8086 汇编（十二）

最新推荐文章于 2024-10-22 16:51:13 发布
原创 最新推荐文章于 2024-10-22 16:51:13 发布 · 767 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文对比分析了C语言实现的Objective-C数组对象（链式存储结构）与顺序存储结构线性表的函数执行效率，探讨了不同存储结构在插入、删除等操作上的性能差异，并介绍了XCode下的汇编语言使用方法。

目录

用 C语言 写一个 Objective-C 的数组对象（链式存储结构）

  • 分析 Objective-C 中 NSMutableArray 的属性与方法，规划线性表对象
    1.属性方面：容量（capacity）、长度（length）、指向存储线性表元素的堆内存的指针（value）
    2.方法方面：创建线性表、销毁线性表、清空线性表、获取线性表的属性（capacity、length）、对线性表的增、删、改、查、删除特定值，打印

    线性表对象内存图如下所示：
    线性表内存结构图

  • 实现线性表对象
    HZPLinearList.h 文件代码如下：

    #ifndef LinearList_h
#define LinearList_h

#include <stdio.h>

#pragma mark -  宏定义（条件编译）
#ifndef LINEARLIST_STRUCT

// 线性表节点数据
typedef void* LinearListNodeValue;
// 线性表
typedef void LinearList;

#endif

#pragma mark - 创建 销毁 清空
// 创建线性表
// return.线性表指针
LinearList* listCreat();

// 销毁线性表
// param0.线性表指针
void listRelease(LinearList* list);

// 清空线性表
// param0.线性表指针
void listClear(LinearList* list);

#pragma mark - 属性获取
// 获取线性表的长度
// param0.线性表指针
// return.线性表长度
int listLength(LinearList* list);

#pragma mark - 增
// 往线性表中插入数据
// param0.线性表指针
// param1.要插入的位置的索引
// param2.要插入的值
void listInsert(LinearList* list, int index, LinearListNodeValue value);

// 往线性表中添加数据（添加在表尾）
void listAdd(LinearList* list, LinearListNodeValue value);

#pragma mark - 删
// 删除线性表中指定索引位置的元素
// param0.线性表指针
// param1.索引
void listRemove(LinearList* list, int index);

#pragma mark - 改
// 修改线性表中指定位置的元素为指定的值
// param0.线性表指针
// param1.索引
// param2.值
void listSet(LinearList* list, int index, LinearListNodeValue value);

#pragma mark - 查
// 获取线性表指定索引处元素的值
// param0.线性表指针
// param1.索引
// return.元素的值
LinearListNodeValue listGet(LinearList* list, int index);

#pragma mark - 特殊功能
// 删除线性表中具有指定值的所有元素
// param0.线性表指针
// param1.要删除的值
void listRemoveValue(LinearList* list, LinearListNodeValue value);

// 打印线性表
// param0.线性表指针
void listPrint(LinearList* list);

#endif /* LinearList_h */

    HZPLinearList.c 代码如下：

    #pragma mark - 定义线性表结构体
// 节点数据指针
typedef void* LinearListNodeValue;

// 节点结构体
typedef struct _LinearListNode LinearListNode;
struct _LinearListNode {
    LinearListNodeValue value;  // 节点数据
    LinearListNode* next;       // 指向下个节点的指针
};

// 线性表结构体
typedef struct {
    int length;                 // 长度
    LinearListNode* header;     // 头节点
} LinearList;

/*
 注意：宏 LINEARLIST_STRUCT 的定义，一定要在导入 HZPLinearList.h 之前
 这是为了防止上面的 LinearListNodeValue 指针和 LinearList 结构体被重复定义
 **/
//
#define LINEARLIST_STRUCT

#pragma mark - 导入头文件
#include "HZPLinearList.h"

// 使用 mallc函数 需要导入
#include <stdlib.h>

#pragma mark - 创建 销毁 清空
// 创建线性表
LinearList* listCreat() {
    // 分配线性表结构体和表头的内存空间（在堆区）
    // malloc函数如果遇到内存资源紧张，给不了这么多字节，可能会返回空
    LinearList* list = malloc(sizeof(LinearList) + sizeof(LinearListNode));
    if (list) {
        list->length = 0;
        list->header = (LinearListNode *)(list + 1);
        list->header->value = NULL;
        list->header->next = NULL;
    }
    return list;
}

// 销毁线性表
void listRelease(LinearList* list) {
    if (NULL == list) {
        return;
    }
    listClear(list);
    free(list);
}

// 清空线性表
void listClear(LinearList* list) {
    if (NULL == list) {
        return;
    }
    // while 循环中，headerNode 会一直有值，while 循环通过 break 跳出
    LinearListNode* headerNode = list->header;
    while (headerNode) {
        LinearListNode* removeNode = headerNode->next;
        if (NULL == removeNode) {
            break;
        }
        headerNode->next = removeNode->next;
        free(removeNode);
    }
    // 将线性表的长度置为 0
    list->length = 0;
}

#pragma mark - 属性获取
// 获取线性表的长度
int listLength(LinearList* list) {
    if (NULL == list) {
        return 0;
    }
    return list->length;
}

#pragma mark - 增
// 往线性表中插入数据
void listInsert(LinearList* list, int index, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 可以在表尾进行插入，因此这里的条件是 index > list->length，而不是 index >= list->length
    if (index < 0 || index > list->length) {
        return;
    }
    // 获取 index - 1 节点
    LinearListNode* currentNode = list->header;
    for (int i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }
    // 创建新增节点
    LinearListNode* tempNode = malloc(sizeof(LinearListNode));
    if (NULL == tempNode) {
        return;
    }
    tempNode->value = value;
    // 交换 新增节点 与 index - 1节点 的 next 指针
    tempNode->next = currentNode->next;
    currentNode->next = tempNode;
    // 线性表的长度 + 1
    list->length++;
}

// 往线性表中添加数据（添加在表尾）
void listAdd(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    listInsert(list, list->length, value);
}

#pragma mark - 删
// 删除线性表中指定索引位置的元素
void listRemove(LinearList* list, int index) {
    if (NULL == list) {
        return;
    }
    if (index < 0 || index > list->length - 1) {
        return;
    }
    // 获取 index - 1 节点
    LinearListNode* currentNode = list->header;
    for (int i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }
    // 获取 index 节点
    LinearListNode* removeNode = currentNode->next;
    // 删除 index 节点
    currentNode->next = removeNode->next;
    free(removeNode);
    // 线性表的长度 - 1
    list->length--;
}

#pragma mark - 改
// 修改线性表中指定位置的元素为指定的值
void listSet(LinearList* list, int index, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    if (index < 0 || index > list->length - 1) {
        return;
    }
    // 获取 index 节点，并修改 index 节点的值
    LinearListNode* currentNode = list->header;
    for (int i = 0; i <= index; i++) {
        currentNode = currentNode->next;
    }
    currentNode->value = value;
}

#pragma mark - 查
// 获取线性表指定索引处元素的值
LinearListNodeValue listGet(LinearList* list, int index) {
    if (NULL == list) {
        return 0;
    }
    if (index < 0 || index > list->length - 1) {
        return 0;
    }
    // 获取 index 节点，并获取 index 节点的值
    LinearListNode* currentNode = list->header;
    for (int i = 0; i <= index; i++) {
        currentNode = currentNode->next;
    }
    return currentNode->value;
}

#pragma mark - 特殊功能
// 删除线性表中具有指定值的所有元素 - 效率较高
void listRemoveValue(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 遍历所有元素
    // 注意：
    // 1.for 循环的循环次数依赖于集合的大小，如果在循环过程中集合的大小发生改变，会变得比较难处理。因此这里用 while 循环
    // 2.这里的 while 循环通过 return 跳出
    LinearListNode* currentNode = list->header;
    while (currentNode) {
        LinearListNode* nextNode = currentNode->next;
        if (NULL == nextNode) {
            return;
        }
        if (nextNode->value == value) {
            currentNode->next = nextNode->next;
            free(nextNode);
            list->length--;
        } else {
            currentNode = nextNode;
        }
    }
}

// 打印线性表
void listPrint(LinearList* list) {
    if (NULL == list) {
        return;
    }
    printf("list{\n");
    printf("\tlength = %d;\n", list->length);
    printf("\tvalue = [");
    LinearListNode* currentNode = list->header;
    for (int i = 0; i <= list->length - 1; i++) {
        currentNode = currentNode->next;
        printf("%p", currentNode->value);
        if (i <= list->length - 2) {
            printf(",");
        }
    }
    printf("];\n\t}\n\n");
}

    main.m 代码如下

    #import <Foundation/Foundation.h>
#import "HZPLinearList.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 创建线性表
        LinearList* list = listCreat();
        
        // 添加数据
        for (int i = 0; i < 5; i++) {
            listAdd(list, (LinearListNodeValue)i);
        }
        listInsert(list, 0, (LinearListNodeValue *)3);
        listInsert(list, 1, (LinearListNodeValue *)4);
        listPrint(list);
        /*
        list{
        length = 7;
        value = [0x3,0x4,0x0,0x1,0x2,0x3,0x4];
        }
         **/
        
        // 删除数据
        listRemove(list, 2);
        listPrint(list);
        /*
        list{
        length = 6;
        value = [0x3,0x4,0x1,0x2,0x3,0x4];
        }
        **/
        
        // 修改数据
        listSet(list, 0, (LinearListNodeValue)4);
        listPrint(list);
        /*
        list{
        length = 6;
        value = [0x4,0x4,0x1,0x2,0x3,0x4];
        }
        **/
        
        // 查询数据
        LinearListNodeValue value = listGet(list, 0);
        NSLog(@"value = %p", value);
        /*
        value = 0x4
        **/
        
        // 删除指定数据
        listRemoveValue(list, (LinearListNodeValue)4);
        listPrint(list);
        /*
        list{
        length = 3;
        value = [0x1,0x2,0x3];
        }
        **/
        
        // 清空线性表
        int length = listLength(list);
        NSLog(@"length = %d", length);
        listClear(list);
        listPrint(list);
        /*
        length = 3
        list{
        length = 0;
        value = [];
        }
        **/
        
        // 销毁线性表
        listRelease(list);
        listPrint(list);
        /*
        list{
        length = 0;
        value = [];
        }
        **/
    }
    return 0;
}

线性表 HCGLinearList && HZPLinearList 函数执行效率分析

  • 线性表 HCGLinearList（顺序存储结构）和 HZPLinearList（链式存储结构）各个函数的时间复杂度如下：

    函数HCGLinearList（顺序存储结构）HZPLinearList（链式存储结构）
    LinearList* listCreat()O(1)O(1)
    void listRelease(LinearList* list)O(1)O(n)
    void listClear(LinearList* list)O(1)O(n)
    int listLength(LinearList* list)O(1)O(1)
    int listCapacity(LinearList* list)O(1)- - - -
    void listInsert(LinearList* list, int index, LinearListNodeValue value)O(n)O(n)
    void listAdd(LinearList* list, LinearListNodeValue value)O(n)O(n)
    void listRemove(LinearList* list, int index)O(n)O(n)
    void listSet(LinearList* list, int index, LinearListNodeValue value)O(1)O(n)
    LinearListNodeValue listGet(LinearList* list, int index)O(1)O(n)
    void listRemoveValue(LinearList* list, LinearListNodeValue value)O(n)O(n)
    void listPrint(LinearList* list)O(n)O(n)

  • 函数执行效率分析
    对比 HCGLinearList（顺序存储结构） 与 HZPLinearList（链式存储结构）各个函数的时间复杂度，我们发现：

    1. HCGLinearList（顺序存储结构）中，除了 listInsert、listAdd、listRemove、listRemoveValue、listPrint 的时间复杂度为 O(n) 外，其余函数的时间复杂度均为 O(1)
    2. HZPLinearList（链式存储结构）中，除了 listCreat、listLength 的时间复杂度为 O(1) 外，其余函数的时间复杂度均为 O(n)

    虽然 HCGLinearList 的总体执行效率明显高于 HZPLinearList，但是这并不能说明 顺序存储结构 优于 链式存储结构。顺序存储结构与链式存储结构，各有优缺点：

    1. 顺序存储结构：存储单元的内存地址是连续的。适用于：对数据遍历和查找频繁 && 对数据插入和删除较少 的场合。
    2. 链式存储结构：存储单元的内存地址可以是连续的也可以是不连续的，它不要求逻辑上相邻的元素在物理地址上也相邻。适用于：对数据遍历和查找较少 && 对数据插入和删除频繁 的场合。

    Question：
    那是什么原因造成 HZPLinearList（链式存储结构）在插入数据和删除数据的性能上没有高于 HCGLinearList（顺序存储结构）呢？
    Answer：
    问题出在函数调用方法的设计上。
    HCGLinearList 为 顺序存储结构，存储单元的内存地址是连续的，操作数据可以通过索引（index）。
    HZPLinearList 为 链式存储结构，存储单元的内存地址是不连续的，如果通过索引操作数据，则必然会进行遍历，这样就体现不出链式存储的优势。因此，链式存储结构 操作数据应该通过节点（LinearListNode），而不是通过索引（index）。

XCode 使用汇编

在 XCode 下使用汇编的方式有两种：

  1. 内联汇编：汇编代码与高级语言代码混合使用
  2. 外联汇编：用专门的文件编写汇编代码，高级语言通过函数调用汇编代码。

  • 内联汇编

    int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int num1 = 10;
        int num2 = 20;
        int result = num1 + num2;
        
        asm
        (
         "pushq %rax\n"
         "pushq %rdi\n"
         "pushq %rsi\n"
         
         "movq $0x1122, %rdi\n"
         "movq $0x3344, %rsi\n"
         "movq %rdi, %rax\n"
         "addq %rsi, %rax\n"
         
         "popq %rsi\n"
         "popq %rdi\n"
         "popq %rax\n"
         );
        
        NSLog(@"result = %d", result);
    }
    return 0;
}

  • 外联汇编

    外联汇编使用步骤：

    1. 新建汇编代码文件，使用汇编代码实现相应的函数功能
    2. 在高级语言中导入相应的函数，然后调用

    HcgFunc.h 文件如下：

    #ifndef Sum_h
#define Sum_h

int sum(int a, int b);

#endif /* Sum_h */

    HcgFunc.s 文件如下：

    /*
 <<新建汇编代码文件>>
 新建汇编代码文件的步骤：
 New File ... - macOS - Assembly File
 汇编代码在 macOS/Unix 下后缀为 .s，在 Windows 下后缀为 .asm
 
 注意：
 汇编代码文件（.s 文件），也是代码文件，并非真正的 以 0 和 1 表示的汇编代码
 .s 文件也需要经过编译器编译才能生成对应的汇编代码
 我们可以在 Build Phases - Compile Sources 下看到，我们新建的汇编文件也会参与编译，
 因为 .s 文件也是源文件，并非目标二进制代码文件
  
 
 <<编写汇编代码>>
 .text : 表示代码段
 .data : 表示数据段
 .global 标号 : 在.s文件里面定义的函数，默认是私有函数，外界调用不到，使用（.global 标号）将函数声明为全局函数
 _sum : 汇编代码里面的标号为 _函数名，高级语言调用汇编代码的功能时，直接使用函数名（ 在汇编代码里面，如果是函数的实现，则需要在函数名前面加一个下划线 _ ）

 通过编译器生成的汇编代码，在调用函数进行传参时，存储参数的寄存器是有顺序的：
 di si dx cx 8d 9d
 MacBook 的 CPU 为 64 位的 CPU，其专门用来存储函数形参的寄存器有6个
 当源函数传递给目标函数的形参超过6个，则会将剩余的形参 push 到源函数的栈空间中

 esi : e 表示 32 位寄存器
 rsi : r 表示 64 位寄存器
 
 movl : l 表示操作 32 位
 movq : q 表示操作 64 位
 
 
 <<导入汇编函数并使用>>
 高级语言中导入汇编函数的方式有两种：
 1.为汇编文件 HcgFunc.s 新建一个相应的头文件 HcgFunc.h，在 HcgFunc.h 中声明 HcgFunc.s 里面实现的函数，然后在高级语言中导入 HcgFunc.h，高级语言通过 HcgFunc.h 声明的函数调用相应的汇编代码。
 2.在高级语言中，通过 extern 导入相应的函数，进行使用
 extern int sum(int a, int b);
 */

.text
.global _sum

_sum:
movq %rdi, %rax
addq %rsi, %rax
retq

    main.m 文件如下：

    #import <Foundation/Foundation.h>
//#import "HcgFunc.h"

extern int sum(int num1, int num2);

int main(int argc, const char * argv[]) {
    @autoreleasepool {	
        /*
        关于如何传参数
        sum(10, 20) 必然生成如下汇编指令
        movq $10, %rdi
        movq $20, %rsi
        call _sum
         */
        int result = sum(10, 20);
        NSLog(@"result = %d", result);
    }
    return 0;
}
汇编语言指令LENGTH
JeredYe的博客
10-16 2352
汇编LENGTH伪指令
汇编语言的LENGTH问题
万无引力的博客
11-11 5776
再看汇编语言程序设计时有个例题是这样的 ARRAY DW 1,2,3 对于指令MOV CX,LENGTH ARRAY 汇编程序将其形成为 MOV CX,1 还有个例题 TABLE DB ’ABCD’ 对于指令MOV CX,LENGTH TABLE 汇编程序使其形成 MOV CX,1 而书上对length的定义却是：数值回送操作符LENGTH返回的是变量的单元数 但是书上的定义有点模糊准确的定义应...
汇编中的length（返回利用dup定义的数组中的元素个数，即重复操作符dup前的count值）
deniece1的博客
12-14 5030
LENGTH是属于析值操作符之一，也称为数值回送操作符，原因是这些操作符把一些特征或存储器地址的一部分作为数据返回。length的用法：length 变量名 。作用是返回利用dup定义的数组中的元素个数，即重复操作符dup前的count值。 例如有 varw db 1234h | buffer db 10 dup (0) length varw ;返回1给cx length bu...
汇编——操作符和常用指令
筱羊冰冰
01-02 5127
操作符 操作符分为四大类，算数操作符、关系操作符、数值回送操作符和属性操作符。 注：这里指的是[sp+8]这样的加法，而不是我们的add指令。 算数操作符 加减乘除和求模，这个就不说了。 关系运算符 EQ 等于 NE 不等于 LT 小于 LE 小于等于 GT 大于 GE 大于等于 注记：有E的就含有等于项。 如果为真，返回0fffh，否则为0000h。 其实这个不太常见，一般比较的时候，我们都是配合跳转指令来的，而跳转指令中直接cmp比较，然后看标志位就行了。（其实标志位都不需要你看，直接使用对应的跳
汇编语言 TYPE ，LENGTHOF,SIZEOF运算符
弹炒饭的博客
12-24 1万+
啊巴阿巴阿巴阿巴阿巴阿巴阿巴阿巴
汇编学习（十二）8086汇编拾遗 (11)
密码小仙女
06-02 396
《汇编语言》最后一章，键盘和磁盘的读取 一个键盘读写程序： assume cs:code code segment charstack: jmp short charstart ;字符串及栈处理 table dw charpush,charpop,charshow top dw 0 charstart: push bx push dx push di push es cmp ah,2 ;...
8086 汇编笔记（十二）：int 指令 & 端口 & 直接定址表
Flag少侠的博客
06-06 9554
int 指令的格式为:int n，n 为中断类型码，它的功能是引发中断过程CPU 执行 intn 指令，相当于引发一个n号中断的中断过程，执行过程如下：(1) 取中断类型码 n;(2) 标志寄存器入栈，IF=0，TF=0;(3) CS、IP 入栈;从此处转去执行n号中断的中断处理程序。
王爽《汇编语言》笔记（详细）
热门推荐
洋葱汪的博客
03-24 16万+
一、基础知识 1、指令 机器指令：CPU能直接识别并执行的二进制编码（指令） 汇编指令：是机器指令便于记忆的书写格式。汇编指令是机器指令的助记符，同机器指令一一对应。 指令：指令通常由操作码和地址码（操作数）两部分组成 指令集：每种CPU都有自己的汇编指令集。 汇编语言发展至今，有以下3类指令组成。 汇编指令：机器码的助记符，有对应的机器码。 伪指令：没有对应的机器码，由编译器执行，计算机并不执...
汇编语言程序设计---期末复习大纲知识点总结（王爽第二版）
要像蜗牛一样一步一步往上爬！
03-12 1万+
文章目录@[toc]第一~三章 概述第四~六章 基本程序结构第七章 更灵活的访存方法第八章 数据处理的两个基本问题第九章 转移指令的原理第十章 call和ret指令第十一章 标志寄存器第十二章 中断第十三章 中断程序设计 + 宏第十四~十六章 端口、外中断、 第一~三章 概述 1.机器语言、汇编语言、高级语言的概念 机器语言：直接用二进制代码的机器指令表示的语言 汇编语言：用指令助记符、符号地址、标号等符 号书写程序的语言 高级语言：一种类似于人类语言的语言 2.汇编语言特点 占用空间少、执行速度
微机原理之汇编 （三） 表达式，部分中断 学习笔记
苹果好吃呀的博客
08-15 2128
文章目录一，表达式1. 算数运算符2. 逻辑运算符3. 关系运算符4. 分析运算符（1） OFFSET（2） SEG（3）TYPE5. 修改属性运算符1. 段操作符2. PTR3. HIGH 和 LOW二，指令语句三，宏指令语句1. 宏定义2. 宏调用3. 宏展开（不用管。。）4. 宏嵌套5. 宏定义中的标号和变量6.其他宏指令语句7.宏定义与子程序的区别三，DOS 系统功能调用1.程序结束软中...
IOS逆向之汇编语言程序入门
细心程度决定你的成败
08-12 3075
原文地址一、寻址方式1、概念：    一条指令由操作码和操作数构成，操作码是系统定义好的符号，执行指定的操作，操作数即是指令的对象，而寻址方式就是操作数的指定方式操作码 目的操作数，源操作数 2、寻址方式的三种情况：（1）CPU中（2）储存器（3）I/O中 3、寻址方式分类（1）隐含寻址：    指令中只有操作码没有指定的操作数，但是根据操作码就可确定相应的操作数MUL BL; DIV B
汇编语言中关于Length操作符的问题
西红柿爱炒番茄
06-28 9388
再看汇编语言程序设计时有个例题是这样的ARRAY DW 1,2,3对于指令MOV CX,LENGTH ARRAY汇编程序将其形成为MOV CX,1还有个例题TABLE DB ’ABCD’对于指令MOV CX,LENGTH TABLE汇编程序使其形成MOV CX,1 而书上对length的定义却是：数值回送操作符LENGTH返回的是变量的单元数但是书上的定义有点模糊准确的定义应该是：LENGTH返回...
常见汇编指令
Wolf__king的博客
11-18 1886
常见汇编指令
汇编语言 数值回送操作符（type,size,length）
untilyouydc
10-07 1万+
1. type    格式为 type  expression     如果该表达式是变量，则返回该变量的以字节数表示的类型，DB为1，DW为2 ，DD为4，DF为8....  如果表达式是标号，则返回代表该标号的数值类型，NEAR是-1，FAR为-2。如果表达式是常数，则应该回送0 。   2 length  对于变量中使用DUP 的情况，返回分配的单元数（例如  3 dup(?)）...
length，length()，size()的区别
Xueyinnnnn的博客
11-07 1012
删除线格式 @TOC 区别如下： length：是针对数组来说的，如果写了一个数组，想要知道数组的长度，则可以使用这个属性； length()：是针对字符串String来说的,如果想看这个字符串的长度则用length()这个方法; size()：是针对泛型集合来说的，如果想要知道这个泛型集合中有多少元素，即可使用size()这个方法。 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 M...
汇编语言期末复习不挂科——知识点总结
静Yu的博客
03-19 1万+
汇编语言期末考试复习详细资料，赶快收藏。
微机原理与接口技术—— 8086 CPU 指令系统总结（3）
最新发布
2302_80919983的博客
10-22 1674
在中断处理程序执行完毕后，使用 IRET 指令可以恢复被中断程序的执行现场，包括恢复标志寄存器、CS 和 IP 寄存器的值，使 CPU 继续从被中断的地方执行程序。例如，在中断处理程序的末尾执行IRET指令，CPU 会将栈中的返回地址弹出到 IP 和 CS 寄存器中，并恢复标志寄存器的状态，然后返回到被中断的程序继续执行。中断是指计算机在执行程序的过程中，当出现某种特殊情况（如外部设备请求、故障、定时器溢出等）时，暂停当前正在执行的程序，转而去执行特定的中断处理程序，处理完后再返回到被中断的程序继续执行。
汇编语言计算数组和字符串长度
Java入门基础教程
06-22 3298
在使用数组时，通常会想要知道它的大小。下例使用常量 ListSize 来声明 list 的大小： list BYTE 10,20,30,40 ListSize = 4 显式声明数组的大小会导致编程错误，尤其是如果后续还会插入或删除数组元素。声明数组大小更好的方法是，让汇编器来计算这个值。 $ 运算符（当前地址计数器）返回当前程序语句的偏移量。在下例中，从当前地址计数器（$）中减去 li...
汇编语言求数组的长度_$的用法
杨雪
03-18 8607
$: 为地址运算符，属伪操作指令。当我们需要汇编编译器自动计算出数组大小的时候，可能就会用到当前地址计数器$运算符了，MASM用$运算符返回当前程序语句的地址偏移值，利用该数值，我们可以计算出数组的长度。 例如： xxx BYTE 10,20,30,40,50 xxxlen = $ - xxx 则常量xxxlen就是数组list
x86汇编_type/lengthof/sizeof运算符_笔记_10
Silent_Hunter的博客
03-18 2135
type：返回变量的每个元素的字节大小，byte返回1，word返回2，dword返回3，qword返回4。 lengthof：返回数组变量中一共有多少个元素。 sizeof：返回数组的总字节数，或者可以理解为type * lengthof。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值