笔记

原版全
计算机系统
浅色主题
深色主题

定点数的加减运算

ZF & SF

零标志 ZF = 1 表示结果 F 为 0。不管对于无符号整数还是有符号整数运算，ZF 都有意义
符号标志 SF = 1 表示有符号数运算结果为负；有符号数运算结果为正时 SF = 0。对于无符号数运算，SF 没有意义。

无符号数溢出 & CF

无符号数都为正数

sub=0 $C_{out}=1$ ，此时CF=1表示进位)
sub=1 $C_{out}=0$ ，此时CF=1表示借位)

综合来说

无 符 号 数 溢 出 = CF = \overset{―}{Sub} \cdot C_{out} + Sub \cdot \overset{―}{C_{out}} = Sub ⨁ C_{out}

带符号数溢出 & OF

采用一位符号位

带 符 号 数 溢 出 = OF = C_{n} ⨁ C_{n - 1}

假设机器字长为 4（n = 4），能表示的有符号数范围为 -8 ~ 7，那么就有：
[5]补 = 0101，[4]补 = 0100；
[-5]补 = 1011，[-4]补 = 1100；
[5 + 4]补 = 0101 + 0100 = 1001 = [-7]补；（正溢出）
[5 - 4]补 = [5 + (-4)]补 = 0101 + 1100 = 1 0001 = [1]补；
[4 - 5]补 = [4 + (-5)]补 = 0100 + 1011 = 1111 = [-1]补；
[-5 - 4]补 = [-5 + (-4)]补 = 1011 + 1100 = 1 0111 = [7]补；（负溢出）

采用两位符号位

带 符 号 数 溢 出 = OF = S_{n} ⨁ S_{n - 1}

[5]补 = 00 101，[4]补 = 00 100；
[-5]补 = 11 011，[-4]补 = 11 100；
[5 + 4]补 = 00 101 + 00 100 = 01 001 = [1]补；（正溢出）
[5 - 4]补 = [5 + (-4)]补 = 00 101 + 11 100 = 1 00 001 = [1]补；
[4 - 5]补 = [4 + (-5)]补 = 00 100 + 11 011 = 11 111 = [-1]补；
[-5 - 4]补 = [-5 + (-4)]补 = 11 011 + 11 100 = 1 10 111 = [-1]补；（负溢出）

浮点数的表示

程序的机器级表示

寻址方式

立即寻址
直接寻址
寄存器寻址
寄存器间接寻址
基址寻址
变址寻址
……

`IA32`汇编指令

通用寄存器

前四个：a -> add, b -> base, c -> count, d -> 'data'
si: s -> source -> 源地址, di -> destination -> 目的地址
bp -> base pointer, sp -> stack pointer

`ATT` & `Intel`

寻址方式

常用指令

数据传输指令

mov指令
数据传递方向
ATT ->
Intel <-

lea：load effective address，加载有效地址，将一个内存地址加载到目的寄存器；
push：将数据压入栈，同时 esp 减去数据长度；
pop：将栈顶数据弹出栈，同时 esp 加上数据长度；

算术和逻辑运算指令

除法指令，它们都只有一个操作数，表示除数，被除数则放在 edx : eax 中；得到的结果商放在 eax 中，余数放在 edx 中：
div：无符号除
idiv：有符号除

转移指令

重置条件码

e.g

选择结构机器级表示

C程序


xxxxxxxxxx
10
1
int a = 23;
2
int b = 31;
3
if (a > b)
4
{
5
    a++;
6
}
7
else {
8
    a--;
9
}
10
printf(" a = %d\n", a);

使用goto


xxxxxxxxxx
8
1
    if (a <= b)
2
        goto L1;
3
    a++;
4
    goto L2;
5
L1:
6
    a--;
7
L2:
8
    printf(" a = %d\n", a);

汇编

使用vs2022 x86反汇编


xxxxxxxxxx
21
1
    int a = 23;
2
00151896  mov         dword ptr [ebp-8],17h  
3
    int b = 31;
4
0015189D  mov         dword ptr [ebp-14h],1Fh  
5
    if (a > b)
6
001518A4  mov         eax,dword ptr [ebp-8]  
7
001518A7  cmp         eax,dword ptr [ebp-14h]  
8
001518AA  jle         001518B7  
9
    {
10
        a++;
11
001518AC  mov         eax,dword ptr [ebp-8]  
12
001518AF  add         eax,1  
13
001518B2  mov         dword ptr [ebp-8],eax  
14
    }
15
001518B5  jmp         001518C0  
16
    else {
17
        a--;
18
001518B7  mov         eax,dword ptr [ebp-8]  
19
001518BA  sub         eax,1  
20
001518BD  mov         dword ptr [ebp-8],eax  
21
    }

循环结构机器级表示

`do - while`循环

C程序


xxxxxxxxxx
5
1
int a = 0;
2
do {
3
    a++;
4
} while (a < 5);
5
printf(" a = %d \n ", a);

使用goto


x
1
    int a = 0;
2
L1:
3
    a++;
4

5
    if (a < 5)
6
        goto L1;
7
    printf(" a = %d \n ", a);

汇编


xxxxxxxxxx
10
1
    int a = 0;
2
007A1896  mov         dword ptr [ebp-8],0  
3
    do {
4
        a++;
5
007A189D  mov         eax,dword ptr [ebp-8]  
6
007A18A0  add         eax,1  
7
007A18A3  mov         dword ptr [ebp-8],eax  
8
    } while (a < 5);
9
007A18A6  cmp         dword ptr [ebp-8],5  
10
007A18AA  jl          007A189D

`while`循环


xxxxxxxxxx
5
1
int a = 0;
2
while (a < 5) {
3
    a++;
4
}
5
printf(" a = %d \n ", a);


xxxxxxxxxx
8
1
    int a = 0;
2
L1:
3
    if (a >= 5)
4
        goto L2;
5
    a++;
6
    goto L1;
7
L2:
8
    printf(" a = %d \n ", a);


xxxxxxxxxx
11
1
    int a = 0;
2
007A18BD  mov         dword ptr [ebp-8],0  
3
    while (a < 5) {
4
007A18C4  cmp         dword ptr [ebp-8],5  
5
007A18C8  jge         007A18D5  
6
        a++;
7
007A18CA  mov         eax,dword ptr [ebp-8]  
8
007A18CD  add         eax,1  
9
007A18D0  mov         dword ptr [ebp-8],eax  
10
    }
11
007A18D3  jmp         007A18C4

`for`循环


xxxxxxxxxx
6
1
int a = 10;
2
for (int i = 0; i < 5; i++)
3
{
4
    a--;
5
}
6
printf(" a = %d \n ", a);


xxxxxxxxxx
2
1
for( 初始化循环变量; 判断循环条件; 更新循环变量)
2
    循环体


xxxxxxxxxx
7
1
int a = 10;
2
int i = 0;
3
while (i < 5) {
4
    a--;
5
    i++;
6
}
7
printf(" a = %d \n ", a);


xxxxxxxxxx
10
1
    int a = 10;
2
    int i = 0;
3
L1:
4
    if (i >= 5)
5
        goto L2;
6
    a--;
7
    i++;
8
    goto L1;
9
L2:
10
    printf(" a = %d \n ", a);


xxxxxxxxxx
19
1
    int a = 10;
2
007A18E6  mov         dword ptr [ebp-8],0Ah  
3
    for (int i = 0; i < 5; i++)
4
007A18ED  mov         dword ptr [ebp-14h],0  
5
007A18F4  jmp         007A18FF  
6
007A18F6  mov         eax,dword ptr [ebp-14h]  
7
007A18F9  add         eax,1  
8
007A18FC  mov         dword ptr [ebp-14h],eax  
9
007A18FF  cmp         dword ptr [ebp-14h],5  
10
007A1903  jge         007A1910  
11
    {
12
        a--;
13
007A1905  mov         eax,dword ptr [ebp-8]  
14
007A1908  sub         eax,1  
15
007A190B  mov         dword ptr [ebp-8],eax  
16
    }
17
007A190E  jmp         007A18F6  
18
    printf(" a = %d \n ", a);
19
007A1910 ...

过程调用的机器级表示

使用栈实现

流程

程序代码和数据：主要包括 只读代码段 和 读写段（.data 和 .bss）。对所有进程来说，代码都是从固定地址开始，紧接着就是 C 语言中的全局和静态数据。其中 .data 中是已初始化的全局和静态 C 变量，而 .bss 中是未初始化的全局和静态变量。
堆（Heap）：用于运行时的动态内存分配，向上（高地址）生长。代码和数据区，在进程开始运行时就被指定了大小；而通过调用 malloc 和 free 这样的 C 标准库函数，可以让堆区动态地扩展和收缩。
共享库的内存映射区：用户区的中间部分是一块内存映射区域，用来存放像 C 标准库这样的共享库。(printf)
用户栈（Stack）：位于虚拟地址空间用户区顶部，向下（低地址）生长。一般用来存储局部变量和函数参数，结合堆栈指针可以方便地实现函数的调用和返回。

从可执行文件加载
执行P指令
1. P函数局部变量入栈
2. 调用Q函数
  问题：
  1. 参数能够传递给Q函数
  2. 执行完Q函数能够返回到跳转语句的下一句
  3. P函数中使用的寄存器的值应该被保存
  依次由如下解决方案：
  1. 在P函数的栈帧中压入参数构造区和调用指令的下一条指令
    eip寄存器传入跳转的指令的位置
  2. 在Q函数的栈帧中P寄存器的值入栈


xxxxxxxxxx
15
1
int add(int x, int y);
2

3
int main() {
4
    int a = 23;
5
    int b = 31;
6

7
    int sum = add(a, b);
8

9
    printf(" sum = %d\n", sum);
10
}
11

12
int add(int x, int y) {
13
    int sum = x + y;
14
    return sum;
15
}

main栈帧


xxxxxxxxxx
5
1
# P的局部变量
2
    int a = 23;
3
005018F6  mov         dword ptr [ebp-8],17h  
4
    int b = 31;
5
005018FD  mov         dword ptr [ebp-14h],1Fh

EAX = 0050C008 EBX = 02636000 ECX = 0050C008 EDX = 00000001 ESI = 02636000
EDI = 028FF6BC EIP = 00501904 ESP = 028FF5CC EBP = 028FF6BC EFL = 00000246


xxxxxxxxxx
6
1
# 参数构造区
2
    int sum = add(a, b);
3
00501904  mov         eax,dword ptr [ebp-14h]  # 参数b移到eax寄存器  
4
00501907  push        eax                      # eax压栈
5
00501908  mov         ecx,dword ptr [ebp-8]    # 参数a移到ecx寄存器
6
0050190B  push        ecx                      # ecx压栈

EAX = 0000001F EBX = 02636000 ECX = 00000017 EDX = 00000001 ESI = 02636000
EDI = 028FF6BC EIP = 0050190C ESP = 028FF5C4 EBP = 028FF6BC EFL = 00000246

栈顶指针对应的内存地址


xxxxxxxxxx
7
1
# 调用Q函数(`add`)
2
# 跳转的同时，该地址的下一行地址作为返回地址入栈
3
0050190C  call        00501023
4

5
---
6
0050190C  call        00501023  
7
00501911  add         esp,8

ESP = 028FF5C0

call位置


xxxxxxxxxx
6
1
00501023  jmp         00501870
2

3
---
4
# 跳转到add函数起始位置
5
int add(int x, int y) {
6
00501870  push        ebp


xxxxxxxxxx
2
1
# 将P的ebp栈基指针入栈
2
00501870  push        ebp

ESP = 028FF5BC EBP = 028FF6BC

Q的栈帧开始


xxxxxxxxxx
1
1
00501871  mov         ebp,esp  # P的栈顶作为Q的栈基址

初态： ESP = 028FF5BC EBP = 028FF6BC

末态： ESP = 028FF5BC EBP = 028FF5BC


xxxxxxxxxx
1
1
00501873  sub         esp,0CCh  # 加上一个较大的偏移量开辟栈空间

ESP = 028FF4F0


xxxxxxxxxx
4
1
# 保存P的寄存器的值(ebx, esi, edi)入栈
2
00501879  push        ebx  
3
0050187A  push        esi  
4
0050187B  push        edi

P寄存器值

EBX = 02636000 ESI = 02636000 EDI = 028FF6BC

此时：ESP = 028FF4E4


xxxxxxxxxx
5
1
# Q的局部变量 && Q局部变量执行Q语句
2
    int sum = x + y;
3
00501896  mov         eax,dword ptr [ebp+8]   # Q的栈基址向上寻址，对应参数a放入eax 
4
00501899  add         eax,dword ptr [ebp+0Ch] # 参数a和eax的值作为alu的两个输入
5
0050189C  mov         dword ptr [ebp-8],eax


xxxxxxxxxx
19
1
# 调用Q结果返回
2
    return sum;
3
0050189F  mov         eax,dword ptr [ebp-8] # 将结果移动到eax寄存器 
4
}
5
# 保存的P寄存器出栈
6
005018A2  pop         edi  
7
005018A3  pop         esi  
8
005018A4  pop         ebx 
9
# 回收Q的栈空间地址
10
005018A5  add         esp,0CCh  
11
# 维持P的栈顶esp
12
005018AB  cmp         ebp,esp  
13
005018AD  call        00501253  
14
005018B2  mov         esp,ebp
15
# 保存的P的栈基址出栈
16
005018B4  pop         ebp 
17
# 返回地址出栈
18
005018B5  ret 
19
# 到此P的各寄存器值均恢复


xxxxxxxxxx
4
1
00501911  add         esp,8  
2
00501914  mov         dword ptr [ebp-20h],eax
3
printf(" sum = %d\n", sum);
4
...

实践（归并排序的机器级表示）

`C`


xxxxxxxxxx
78
1
#include <stdio.h>
2
#include <stdlib.h>
3

4
void merge(int arr[], int left, int mid, int right) {
5
    int n1 = mid - left + 1;
6
    int n2 = right - mid;
7

8
    int* leftArray = (int*)malloc(n1 * sizeof(int));
9
    int* rightArray = (int*)malloc(n2 * sizeof(int));
10

11
    for (int i = 0; i < n1; i++) {
12
        leftArray[i] = arr[left + i];
13
    }
14
    for (int j = 0; j < n2; j++) {
15
        rightArray[j] = arr[mid + 1 + j];
16
    }
17

18
    int i = 0, j = 0, k = left;
19
    while (i < n1 && j < n2) {
20
        if (leftArray[i] <= rightArray[j]) {
21
            arr[k] = leftArray[i];
22
            i++;
23
        }
24
        else {
25
            arr[k] = rightArray[j];
26
            j++;
27
        }
28
        k++;
29
    }
30

31
    while (i < n1) {
32
        arr[k] = leftArray[i];
33
        i++;
34
        k++;
35
    }
36
    while (j < n2) {
37
        arr[k] = rightArray[j];
38
        j++;
39
        k++;
40
    }
41

42
    free(leftArray);
43
    free(rightArray);
44
}
45

46
void mergeSort(int arr[], int left, int right) {
47
    if (left < right) {
48
        int mid = left + ((right - left) >> 1);
49

50
        mergeSort(arr, left, mid);
51
        mergeSort(arr, mid + 1, right);
52

53
        merge(arr, left, mid, right);
54
    }
55
}
56

57
void printArray(int arr[], int size) {
58
    for (int i = 0; i < size; i++) {
59
        printf("%d ", arr[i]);
60
    }
61
    printf("\n");
62
}
63

64
int main() {
65
    int arr[] = { 9, 5, 6, 2, 1, 4, 3, 7, 8, 10 };
66
    int arr_size = sizeof(arr) / sizeof(arr[0]);
67

68
    printf("排序前的数组: \n");
69
    printArray(arr, arr_size);
70

71
    mergeSort(arr, 0, arr_size - 1);
72

73
    printf("排序后的数组: \n");
74
    printArray(arr, arr_size);
75

76
    return 0;
77
}
78

`main`


xxxxxxxxxx
43
1
int main() {
2
00D418A0  push        ebp  
3
00D418A1  mov         ebp,esp  
4
00D418A3  sub         esp,100h  
5
00D418A9  push        ebx  
6
00D418AA  push        esi  
7
00D418AB  push        edi  
8
00D418AC  lea         edi,[ebp-40h]  
9
00D418AF  mov         ecx,10h  
10
00D418B4  mov         eax,0CCCCCCCCh  
11
00D418B9  rep stos    dword ptr es:[edi]  
12
00D418BB  mov         eax,dword ptr ds:[00D4A000h]  
13
00D418C0  xor         eax,ebp  
14
00D418C2  mov         dword ptr [ebp-4],eax  
15
00D418C5  mov         ecx,0D4C00Eh  
16
00D418CA  call        00D41343  
17
00D418CF  nop  
18
    int arr[] = { 9, 5, 6, 2, 1, 4, 3, 7, 8, 10 };
19
00D418D0  mov         dword ptr [ebp-30h],9  
20
00D418D7  mov         dword ptr [ebp-2Ch],5  
21
00D418DE  mov         dword ptr [ebp-28h],6  
22
00D418E5  mov         dword ptr [ebp-24h],2  
23
00D418EC  mov         dword ptr [ebp-20h],1  
24
00D418F3  mov         dword ptr [ebp-1Ch],4  
25
00D418FA  mov         dword ptr [ebp-18h],3  
26
00D41901  mov         dword ptr [ebp-14h],7  
27
00D41908  mov         dword ptr [ebp-10h],8  
28
00D4190F  mov         dword ptr [ebp-0Ch],0Ah  
29
    int arr_size = sizeof(arr) / sizeof(arr[0]);
30
00D41916  mov         dword ptr [ebp-3Ch],0Ah  
31

32
    printf("排序前的数组: \n");
33
00D4191D  push        0D47B38h  
34
00D41922  call        00D410D7  
35
00D41927  add         esp,4  
36
    printArray(arr, arr_size);
37
# 参数构造区
38
00D4192A  mov         eax,dword ptr [ebp-3Ch]  
39
00D4192D  push        eax  
40
00D4192E  lea         ecx,[ebp-30h]  # 加载数组的有效地址
41
00D41931  push        ecx
42
# 调用printArray
43
00D41932  call        00D411EF

ECX = 0x00AFF75C

`printArray`


xxxxxxxxxx
33
1
void printArray(int arr[], int size) {
2
# main的栈底入栈
3
00D41D50  push        ebp  
4
# main的栈顶作为printArray的栈底
5
00D41D51  mov         ebp,esp
6
# 开辟保存main寄存器值的空间
7
00D41D53  sub         esp,0CCh
8
# 归档main寄存器
9
00D41D59  push        ebx  
10
00D41D5A  push        esi  
11
00D41D5B  push        edi  
12
...
13
    for (int i = 0; i < size; i++) {
14
00D41D76  mov         dword ptr [ebp-8],0  # i=0
15
00D41D7D  jmp         00D41D88  
16
# L1(i++)
17
00D41D7F  mov         eax,dword ptr [ebp-8]
18
00D41D82  add         eax,1 
19
00D41D85  mov         dword ptr [ebp-8],eax  
20
# L2(终止条件，>=跳转到程序外的地址)
21
00D41D88  mov         eax,dword ptr [ebp-8] 
22
00D41D8B  cmp         eax,dword ptr [ebp+0Ch]  
23
00D41D8E  jge         00D41DA9   
24

25
        printf("%d ", arr[i]);
26
00D41D90  mov         eax,dword ptr [ebp-8]  
27
00D41D93  mov         ecx,dword ptr [ebp+8]  
28
00D41D96  mov         edx,dword ptr [ecx+eax*4]  
29
00D41D99  push        edx  
30
00D41D9A  push        0D47B30h  
31
00D41D9F  call        00D410D7  
32
00D41DA4  add         esp,8  
33
    }

打印第一个数：

i传递给eax
mov eax,dword ptr [ebp-8]

arr的有效地址传递给ecx
mov ecx,dword ptr [ebp+8]

取出数组的第一个数赋给edx寄存器（使用比例变址寻址）
mov edx,dword ptr [ecx+eax*4]


xxxxxxxxxx
1
1
00D41DA7  jmp         00D41D7F  # 跳转到L1

`main`


xxxxxxxxxx
11
1
    mergeSort(arr, 0, arr_size - 1);
2
# arr_size-1
3
00D4193A  mov         eax,dword ptr [ebp-3Ch]  
4
00D4193D  sub         eax,1  
5
00D41940  push        eax  
6
00D41941  push        0
7
# arr有效地址
8
00D41943  lea         ecx,[ebp-30h]  
9
00D41946  push        ecx
10

11
00D41947  call        00D41280

`mergeSort`


xxxxxxxxxx
7
1
void mergeSort(int arr[], int left, int right) {
2
00D41C90  push        ebp  
3
00D41C91  mov         ebp,esp  
4
00D41C93  sub         esp,0CCh  
5
00D41C99  push        ebx  
6
00D41C9A  push        esi  
7
00D41C9B  push        edi


xxxxxxxxxx
5
1
    if (left < right) {
2
# 终止条件
3
00D41CB6  mov         eax,dword ptr [ebp+0Ch]  
4
00D41CB9  cmp         eax,dword ptr [ebp+10h]  
5
00D41CBC  jge         00D41D0F


xxxxxxxxxx
9
1
        int mid = left + ((right - left) >> 1);
2
# (right - left) >> 1
3
00D41CBE  mov         eax,dword ptr [ebp+10h]  
4
00D41CC1  sub         eax,dword ptr [ebp+0Ch]  
5
00D41CC4  sar         eax,1  
6
# left + ()
7
00D41CC6  add         eax,dword ptr [ebp+0Ch]  
8
# 返回值从栈基址开始写入，此处只用了4个字节
9
00D41CC9  mov         dword ptr [ebp-8],eax


xxxxxxxxxx
20
1
# 和main调用mergeSort一样递归调用
2
    mergeSort(arr, left, mid);
3
00D41CCC  mov         eax,dword ptr [ebp-8]  
4
00D41CCF  push        eax  
5
00D41CD0  mov         ecx,dword ptr [ebp+0Ch]  
6
00D41CD3  push        ecx  
7
00D41CD4  mov         edx,dword ptr [ebp+8]  
8
00D41CD7  push        edx  
9
00D41CD8  call        00D41280  
10
00D41CDD  add         esp,0Ch  
11
        mergeSort(arr, mid + 1, right);
12
00D41CE0  mov         eax,dword ptr [ebp+10h]  
13
00D41CE3  push        eax  
14
00D41CE4  mov         ecx,dword ptr [ebp-8]  
15
00D41CE7  add         ecx,1  
16
00D41CEA  push        ecx  
17
00D41CEB  mov         edx,dword ptr [ebp+8]  
18
00D41CEE  push        edx  
19
00D41CEF  call        00D41280  
20
00D41CF4  add         esp,0Ch

`merge`


xxxxxxxxxx
7
1
void merge(int arr[], int left, int mid, int right) {
2
00D41A00  push        ebp  
3
00D41A01  mov         ebp,esp  
4
00D41A03  sub         esp,12Ch  
5
00D41A09  push        ebx  
6
00D41A0A  push        esi  
7
00D41A0B  push        edi


xxxxxxxxxx
11
1
    int n1 = mid - left + 1;
2
# 计算左侧数组的长度放到[ebp-8]的位置
3
00D41A26  mov         eax,dword ptr [ebp+10h]  
4
00D41A29  sub         eax,dword ptr [ebp+0Ch]  
5
00D41A2C  add         eax,1  
6
00D41A2F  mov         dword ptr [ebp-8],eax  
7
    int n2 = right - mid;
8
# 计算右侧数组的长度放到[ebp-20]的位置
9
00D41A32  mov         eax,dword ptr [ebp+14h]  
10
00D41A35  sub         eax,dword ptr [ebp+10h]  
11
00D41A38  mov         dword ptr [ebp-14h],eax


xxxxxxxxxx
77
1
    // 创建临时数组
2
    int* leftArray = (int*)malloc(n1 * sizeof(int));
3
# 数组的字节数 长度*4
4
00D41A3B  mov         eax,dword ptr [ebp-8]  
5
00D41A3E  mov         ecx,4  
6
00D41A43  mul         eax,ecx
7
## 了解：防止乘法溢出
8
00D41A45  mov         edx,0FFFFFFFFh  
9
00D41A4A  cmovb       eax,edx  # 条件传送指令之一，该指令成立条件(~CF)
10
# 保存当前栈顶指针
11
00D41A4D  mov         esi,esp  
12
# 调用malloc
13
00D41A4F  push        eax  
14
00D41A50  call        dword ptr ds:[00D4B170h]  
15
00D41A56  add         esp,4  
16
00D41A59  cmp         esi,esp  
17
00D41A5B  call        00D41262  
18
00D41A60  mov         dword ptr [ebp-20h],eax  
19

20
    int* rightArray = (int*)malloc(n2 * sizeof(int));
21
00D41A63  mov         eax,dword ptr [ebp-14h]  
22
00D41A66  mov         ecx,4  
23
00D41A6B  mul         eax,ecx  
24
00D41A6D  mov         edx,0FFFFFFFFh  
25
00D41A72  cmovb       eax,edx  
26
00D41A75  mov         esi,esp  
27
00D41A77  push        eax  
28
00D41A78  call        dword ptr ds:[00D4B170h]  
29
00D41A7E  add         esp,4  
30
00D41A81  cmp         esi,esp  
31
00D41A83  call        00D41262  
32
00D41A88  mov         dword ptr [ebp-2Ch],eax 
33

34
    for (int i = 0; i < n1; i++) {
35
00D41A8B  mov         dword ptr [ebp-38h],0  
36
00D41A92  jmp         00D41A9D  
37
# L1 (i++)
38
00D41A94  mov         eax,dword ptr [ebp-38h]  
39
00D41A97  add         eax,1  
40
00D41A9A  mov         dword ptr [ebp-38h],eax 
41
# L2 (>=n1跳出)
42
00D41A9D  mov         eax,dword ptr [ebp-38h]  
43
00D41AA0  cmp         eax,dword ptr [ebp-8]  
44
00D41AA3  jge         00D41ABC  
45
        leftArray[i] = arr[left + i];
46
00D41AA5  mov         eax,dword ptr [ebp+0Ch]  # left 
47
00D41AA8  add         eax,dword ptr [ebp-38h]  # left+i
48
00D41AAB  mov         ecx,dword ptr [ebp-38h]  
49
00D41AAE  mov         edx,dword ptr [ebp-20h]  # leftArray有效地址 
50
00D41AB1  mov         esi,dword ptr [ebp+8]    # arr有效地址
51
# 比例变址寻址，比例因子4为字节，eax，ecx寄存器中保存的是对应index
52
00D41AB4  mov         eax,dword ptr [esi+eax*4]  # eax <-arr[left + 1]  
53
00D41AB7  mov         dword ptr [edx+ecx*4],eax  # leftArray[i] <- eax  
54
    }
55
00D41ABA  jmp         00D41A94  # 跳转L1
56

57
# 同上
58
    for (int j = 0; j < n2; j++) {
59
00D41ABC  mov         dword ptr [ebp-44h],0  
60
00D41AC3  jmp         00D41ACE  
61
00D41AC5  mov         eax,dword ptr [ebp-44h]  
62
00D41AC8  add         eax,1  
63
00D41ACB  mov         dword ptr [ebp-44h],eax  
64
00D41ACE  mov         eax,dword ptr [ebp-44h]  
65
00D41AD1  cmp         eax,dword ptr [ebp-14h]  
66
00D41AD4  jge         00D41AF1  
67
        rightArray[j] = arr[mid + 1 + j];
68
00D41AD6  mov         eax,dword ptr [ebp-44h]  
69
00D41AD9  mov         ecx,dword ptr [ebp+10h]  
70
00D41ADC  lea         edx,[ecx+eax+1]  
71
00D41AE0  mov         eax,dword ptr [ebp-44h]  
72
00D41AE3  mov         ecx,dword ptr [ebp-2Ch]  
73
00D41AE6  mov         esi,dword ptr [ebp+8]  
74
00D41AE9  mov         edx,dword ptr [esi+edx*4]  
75
00D41AEC  mov         dword ptr [ecx+eax*4],edx  
76
    }
77
00D41AEF  jmp         00D41AC5


xxxxxxxxxx
107
1
/*合并数组
2
    回忆归并排序：(由于递归调用，所以每次合并左右数组均认为有序)
3
        1. 左右数组均还有元素，一次比较对应指针索引的值，取小填入，填入的数组对应的索引+1
4
        2. 一侧数组无元素，直接在尾部合并  */
5
# 情景一
6
    int i = 0, j = 0, k = left;
7
00D41AF1  mov         dword ptr [ebp-50h],0  
8
00D41AF8  mov         dword ptr [ebp-5Ch],0  
9
00D41AFF  mov         eax,dword ptr [ebp+0Ch]  # left
10
00D41B02  mov         dword ptr [ebp-68h],eax  
11
    while (i < n1 && j < n2) {
12
# i >= n1跳出
13
00D41B05  mov         eax,dword ptr [ebp-50h]
14
00D41B08  cmp         eax,dword ptr [ebp-8]   
15
00D41B0B  jge         00D41B6C
16
# i >= n2跳出
17
00D41B0D  mov         eax,dword ptr [ebp-5Ch]  
18
00D41B10  cmp         eax,dword ptr [ebp-14h]  
19
00D41B13  jge         00D41B6C  
20

21
# branch
22
        if (leftArray[i] <= rightArray[j]) {
23
00D41B15  mov         eax,dword ptr [ebp-50h]  # i  
24
00D41B18  mov         ecx,dword ptr [ebp-20h]  # leftArray的有效地址
25
00D41B1B  mov         edx,dword ptr [ebp-5Ch]  # j
26
00D41B1E  mov         esi,dword ptr [ebp-2Ch]  # rightArray的有效地址
27
00D41B21  mov         eax,dword ptr [ecx+eax*4]  
28
00D41B24  cmp         eax,dword ptr [esi+edx*4]  
29
00D41B27  jg          00D41B46  # >跳出
30
            arr[k] = leftArray[i];
31
00D41B29  mov         eax,dword ptr [ebp-68h]  # left/k  
32
00D41B2C  mov         ecx,dword ptr [ebp+8]    # arr的有效地址
33
00D41B2F  mov         edx,dword ptr [ebp-50h]  # i
34
00D41B32  mov         esi,dword ptr [ebp-20h]  # leftArray的有效地址
35
00D41B35  mov         edx,dword ptr [esi+edx*4]  
36
00D41B38  mov         dword ptr [ecx+eax*4],edx  
37
            i++;
38
00D41B3B  mov         eax,dword ptr [ebp-50h]  
39
00D41B3E  add         eax,1  
40
00D41B41  mov         dword ptr [ebp-50h],eax  
41
        }
42
00D41B44  jmp         00D41B61  # 跳转到k++
43
        else {
44
            arr[k] = rightArray[j];
45
00D41B46  mov         eax,dword ptr [ebp-68h]  
46
00D41B49  mov         ecx,dword ptr [ebp+8]  
47
00D41B4C  mov         edx,dword ptr [ebp-5Ch]  
48
00D41B4F  mov         esi,dword ptr [ebp-2Ch]  
49
00D41B52  mov         edx,dword ptr [esi+edx*4]  
50
00D41B55  mov         dword ptr [ecx+eax*4],edx  
51
            j++;
52
00D41B58  mov         eax,dword ptr [ebp-5Ch]  
53
00D41B5B  add         eax,1  
54
00D41B5E  mov         dword ptr [ebp-5Ch],eax  
55
        }
56
        
57
 # 修改arr的指针右移       
58
        k++;
59
00D41B61  mov         eax,dword ptr [ebp-68h]  
60
00D41B64  add         eax,1  
61
00D41B67  mov         dword ptr [ebp-68h],eax  
62
    }
63
00D41B6A  jmp         00D41B05  # 跳转while循环
64

65
# 情景二：复制剩余元素(基本同上)
66
    while (i < n1) {
67
00D41B6C  mov         eax,dword ptr [ebp-50h]  
68
00D41B6F  cmp         eax,dword ptr [ebp-8]  
69
00D41B72  jge         00D41B9A  
70
        arr[k] = leftArray[i];
71
00D41B74  mov         eax,dword ptr [ebp-68h]  
72
00D41B77  mov         ecx,dword ptr [ebp+8]  
73
00D41B7A  mov         edx,dword ptr [ebp-50h]  
74
00D41B7D  mov         esi,dword ptr [ebp-20h]  
75
00D41B80  mov         edx,dword ptr [esi+edx*4]  
76
00D41B83  mov         dword ptr [ecx+eax*4],edx  
77
        i++;
78
00D41B86  mov         eax,dword ptr [ebp-50h]  
79
00D41B89  add         eax,1  
80
00D41B8C  mov         dword ptr [ebp-50h],eax  
81
        k++;
82
00D41B8F  mov         eax,dword ptr [ebp-68h]  
83
00D41B92  add         eax,1  
84
00D41B95  mov         dword ptr [ebp-68h],eax  
85
    }
86
00D41B98  jmp         00D41B6C  
87
    while (j < n2) {
88
00D41B9A  mov         eax,dword ptr [ebp-5Ch]  
89
00D41B9D  cmp         eax,dword ptr [ebp-14h]  
90
00D41BA0  jge         00D41BC8  
91
        arr[k] = rightArray[j];
92
00D41BA2  mov         eax,dword ptr [ebp-68h]  
93
00D41BA5  mov         ecx,dword ptr [ebp+8]  
94
00D41BA8  mov         edx,dword ptr [ebp-5Ch]  
95
00D41BAB  mov         esi,dword ptr [ebp-2Ch]  
96
00D41BAE  mov         edx,dword ptr [esi+edx*4]  
97
00D41BB1  mov         dword ptr [ecx+eax*4],edx  
98
        j++;
99
00D41BB4  mov         eax,dword ptr [ebp-5Ch]  
100
00D41BB7  add         eax,1  
101
00D41BBA  mov         dword ptr [ebp-5Ch],eax  
102
        k++;
103
00D41BBD  mov         eax,dword ptr [ebp-68h]  
104
00D41BC0  add         eax,1  
105
00D41BC3  mov         dword ptr [ebp-68h],eax  
106
    }
107
00D41BC6  jmp         00D41B9A


xxxxxxxxxx
20
1
# 释放临时数组空间(free函数调用，和其他函数调用的流程一样)
2
    free(leftArray);
3
00D41BC8  mov         esi,esp  
4
00D41BCA  mov         eax,dword ptr [ebp-20h]  
5
00D41BCD  push        eax  
6
00D41BCE  call        dword ptr ds:[00D4B174h]  
7
00D41BD4  add         esp,4  
8
00D41BD7  cmp         esi,esp  
9
00D41BD9  call        00D41262  
10
00D41BDE  nop  
11
    free(rightArray);
12
00D41BDF  mov         esi,esp  
13
00D41BE1  mov         eax,dword ptr [ebp-2Ch]  
14
00D41BE4  push        eax  
15
00D41BE5  call        dword ptr ds:[00D4B174h]  
16
00D41BEB  add         esp,4  
17
00D41BEE  cmp         esi,esp  
18
00D41BF0  call        00D41262  
19
00D41BF5  nop  
20
}


1
# 执行完函数后出栈返回
2
00D41BF6  pop         edi  
3
00D41BF7  pop         esi  
4
00D41BF8  pop         ebx  
5
00D41BF9  add         esp,12Ch  
6
00D41BFF  cmp         ebp,esp  
7
00D41C01  call        00D41262  
8
00D41C06  mov         esp,ebp  
9
00D41C08  pop         ebp  
10
00D41C09  ret

笔记

原版全

计算机系统

定点数的加减运算

ZF & SF

无符号数溢出 & CF

带符号数溢出 & OF

浮点数的表示

程序的机器级表示

寻址方式

IA32汇编指令

通用寄存器

ATT & Intel

寻址方式

常用指令

数据传输指令

算术和逻辑运算指令

转移指令

e.g

选择结构机器级表示

循环结构机器级表示

do - while循环

while循环

for循环

过程调用的机器级表示

使用栈实现

实践（归并排序的机器级表示）

C

main

printArray

main

mergeSort

merge

`IA32`汇编指令

`ATT` & `Intel`

`do - while`循环

`while`循环

`for`循环

`C`

`main`

`printArray`

`main`

`mergeSort`

`merge`