导图社区 汇编
- 31
- 1
- 1
- 举报
汇编
汇编基础，包括进制，基础指令、标志寄存器、堆栈、逻辑运算等，需要的可以共享！
编辑于2023-12-25 10:04:44- 语言
- 汇编基础
- cpp智能指针
这是一篇关于c智能指针的思维导图，内容详细介绍了C++中智能指针的相关知识，主要内容包括：vs中内存泄漏的检测，智能指针，适合C++开发者学习和查阅，帮助其更好地理解和使用智能指针进行内存管理。
- Cpp容器
这是一篇关于C容器的思维导图，主要内容包括：序列式容器，容器适配器(都不支持迭代器)，关联式容器，容器使用注意事项。总结了C++中各类容器的使用方法和注意事项，适合作为学习和复习C++容器知识的参考资料。
- Qt 是什么
这是一篇关于Qt是什么的思维导图，主要内容包括：1.Qt介绍，2.Qt 下载与安装，3.Qt Creator，4.Visual Studio，5. Qt 模块解析，6.需要的C 知识。
汇编
社区模板帮助中心，点此进入>>
- cpp智能指针
这是一篇关于c智能指针的思维导图，内容详细介绍了C++中智能指针的相关知识，主要内容包括：vs中内存泄漏的检测，智能指针，适合C++开发者学习和查阅，帮助其更好地理解和使用智能指针进行内存管理。
- Cpp容器
这是一篇关于C容器的思维导图，主要内容包括：序列式容器，容器适配器(都不支持迭代器)，关联式容器，容器使用注意事项。总结了C++中各类容器的使用方法和注意事项，适合作为学习和复习C++容器知识的参考资料。
- Qt 是什么
这是一篇关于Qt是什么的思维导图，主要内容包括：1.Qt介绍，2.Qt 下载与安装，3.Qt Creator，4.Visual Studio，5. Qt 模块解析，6.需要的C 知识。
- 相似推荐
- 大纲
汇编
一、 进制
A. 十进制101个数: 十进制:由0123456789十个符号组成,逢十进一的一种计数法则,最小是0,最大是9
a. 0 1 2 3 4 5 6 7 8 9
b. 10 11 12 13 14 15 16 17 18 19
c. 20 21 22 23 24 25 26 27 28 29
d. 30 31 32 33 34 35 36 37 38 39
e. 40 41 42 43 44 45 46 47 48 49
f. 50 51 52 53 54 55 56 57 58 59
g. 60 61 62 63 64 65 66 67 68 69
h. 70 71 72 73 74 75 76 77 78 79
i. 80 81 82 83 84 85 86 87 88 89
j. 90 91 92 93 94 95 96 97 98 99
k. 100
B. 七进制101个数 七进制:由0123456七个符号组成,逢七进一的一种计数法则,最小是0,最大是6
a. 0 1 2 3 4 5 6
b. 10 11 12 13 14 15 16
c. 20 21 22 23 24 25 26
d. 30 31 32 33 34 35 36
e. 40 41 42 43 44 45 46
f. 50 51 52 53 54 55 56
g. 60 61 62 63 64 65 66
h. 100 101 102 103 104 105 106
i. 110 111 112 113 114 115 116
j. 120 121 122 123 124 125 126
k. 130 131 132 133 134 135 136
l. 140 141 142 143 144 145 146
m. 150 151 152 153 154 155 156
n. 160 161 162 163 164 165 166
o. 200 201 202
C. 九进制101个数: 九进制: 由012345678九个符号组成,逢九进一的一种计数法则,最小是0,最大是8
a. 0 1 2 3 4 5 6 7 8
b. 10 11 12 13 14 15 16 17 18
c. 20 21 22 23 24 25 26 27 28
d. 30 31 32 33 34 35 36 37 38
e. 40 41 42 43 44 45 46 47 48
f. 50 51 52 53 54 55 56 57 58
g. 60 61 62 63 64 65 66 67 68
h. 70 71 72 73 74 75 76 77 78
i. 80 81 82 83 84 85 86 87 88
j. 100 101 102 103 104 105 106 107 108
k. 110 111 112 113 114 115 116 117 118
l. 120 121
D. 五进制101个数: 五进制:由01234五个符号组成,逢五进一的一种计数法则,最小是0,最大是4
a. 0 1 2 3 4
b. 10 11 12 13 14
c. 20 21 22 23 24
d. 30 31 32 33 34
e. 40 41 42 43 44
f. 100 101 102 103 104
g. 110 111 112 113 114
h. 120 121 122 123 124
i. 130 131 132 133 134
j. 140 141 142 143 144
k. 200 201 202 203 204
l. 210 211 212 213 214
m. 220 221 222 223 224
n. 230 231 232 233 234
o. 240 241 242 243 244
p. 300 301 302 303 304
q. 310 311 312 313 314
r. 320 321 322 323 324
s. 330 331 332 333 334
t. 340 341 342 343 344
u. 400
E. 十一进制101个数: 十一进制:由0123456789a十一个符号组成,逢十一进一的一种计数法则,最小是0,最大是A
a. 0 1 2 3 4 5 6 7 8 9 a
b. 10 11 12 13 14 15 16 17 18 19 1a
c. 20 21 22 23 24 25 26 27 28 29 2a
d. 30 31 32 33 34 35 36 37 38 39 3a
e. 40 41 42 43 44 45 46 47 48 49 4a
f. 50 51 52 53 54 55 56 57 58 59 5a
g. 60 61 62 63 64 65 66 67 68 69 6a
h. 70 71 72 73 74 75 76 77 78 79 7a
i. 80 81 82 83 84 85 86 87 88 89 8a
j. 90 91
F. 十四进制101个数 十四进制:由0123456789ABCD十四个符号组成,逢十四进一的一种计数法则,最小是0,最大是D
G. 十六进制101个数: 十六进制:由0123456789ABCDEF十六个符号组成,逢十六进一的一种计数法则,最小是0,最大是F
a. 0 1 2 3 4 5 6 7 8 9 A B C D E F
b. 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
c. 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F
d. 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
e. 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
f. 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F
g. 60 61 62 63 64
H. 二十进制101个数: 二十进制:由0123456789ABCDEFGHIJ二十个符号组成,逢二十进一的一种计数法则,最小是0,最大是J
a. 0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J
b. 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 1G 1H 1I 1J
c. 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 2G 2H 2I 2J
d. 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 3G 3H 3I 3J
e. 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 4G 4H 4I 4J
f. 50
I. 一进制20个数 一进制:由0一个符号组成,逢一进一的一种计数法则,最小是0,最大是0
a. 0
b. 00
c. 000
d. 0000
e. 00000
f. 000000
g. 0000000
h. 00000000
i. 000000000
j. 0000000000
k. 00000000000
l. 000000000000
m. 0000000000000
n. 00000000000000
o. 000000000000000
p. 0000000000000000
q. 00000000000000000
r. 000000000000000000
s. 0000000000000000000
t. 00000000000000000000
J. 二进制30个数: 二进制:由01两个符号组成,逢二进一的一种计数法则,最小时0,最大是1
a. 0 1
b. 10 11
c. 100 101
d. 110 111
e. 1000 1001
f. 1010 1011
g. 1100 1101
h. 1110 1111
i. 10000 10001
j. 10010 10011
k. 10100 10101
l. 10110 10111
m. 11000 11001
n. 11010 11011
o. 11100 11101
K. N进制:是由N个符号组成,逢N进1的一种计数法则,最小是0,最大是N-1
L. 进制转化
a. 十进制100转为5进制:5的平方=25*4=100 所以结果为400
b. 十进制100转为2进制:2的6次方=64.100-64=36.2的5次方=32还剩4是2的平方 所以结果为1100100
c. 十进制100转换为3进制:3的4次方是81.100-81=19 2乘以3的平方=18 还剩一个1，所以结果为10201
d. 其实计算方式也就是10201=1*3^4+2*3^2+1*3^0=100这种算法倒推
二、 进制之间的运算
N进制:是由N个符号组成,逢N进1的一种计数法则,最小是0,最大是N-1
八进制:是由01234567八个符号组成,逢8进1的一种计数法则,最小是0,最大是7
0 1 2 3 4 5 6 7
10 11 12 13 14 15 16 17
20 21 22 23 24 25 26 27
30 31 32 33 34 35 36 37
40 41 42 43 44 45 46 47
50 51 52 53 54 55 56 57
60 61 62 63 64 65 66 67
70 71 72 73 74 75 76 77
100 101 102 103 104 105 106 107
110 111 112 113 114 115 116 117
120 121 122 123 124 125 126 127
130 131 132 133 134 135 136 137
140 141 142 143 144
4+7=13
十进制的九九乘法表 第一列结果递增1 第二列结果递增2 第二列结果递增3 依次类推 横着看 譬如第9行后面一个比前面一个多9 第6行后面结果是前一个结果加6
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
八进制七七乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=11
1*4=4 2*4=10 3*4=14 4*4=20
1*5=5 2*5=12 3*5=17 4*5=24 5*5=31
1*6=6 2*6=14 3*6=22 4*6=30 5*6=36 6*6=44
1*7=7 2*7=16 3*7=25 4*7=34 5*7=43 6*7=52 7*7=61
九进制八八乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=10
1*4=4 2*4=8 3*4=13 4*4=17
1*5=5 2*5=11 3*5=16 4*5=22 5*5=27
1*6=6 2*6=13 3*6=20 4*6=26 5*6=33 6*6=40
1*7=7 2*7=15 3*7=23 4*7=31 5*7=38 6*7=46 7*7=54
1*8=8 2*8=17 3*8=26 4*8=35 5*8=44 6*8=53 7*8=62 8*8=71
十二进制11x11(bxb)乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=10 4*4=14
1*5=5 2*5=a 3*5=13 4*5=18 5*5=21
1*6=6 2*6=10 3*6=16 4*6=20 5*6=26 6*6=30
1*7=7 2*7=12 3*7=19 4*7=24 5*7=2b 6*7=36 7*7=41
1*8=8 2*8=14 3*8=20 4*8=28 5*8=34 6*8=40 7*8=48 8*8=54
1*9=9 2*9=16 3*9=23 4*9=30 5*9=39 6*9=46 7*9=53 8*9=60 9*9=69
1*a=a 2*a=18 3*a=26 4*a=34 5*a=42 6*a=50 7*a=5a 8*a=68 9*a=76 a*a=84
1*b=b 2*b=1a 3*b=29 4*b=38 5*b=47 6*b=56 7*b=65 8*b=74 9*b=83 a*b=92 b*b=a1
三、 进制转换
进制
二进制: 0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111
八进制: 0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17
十进制: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
十六进制: 0 1 2 3 4 5 6 7 8 9 A B C D E F
计算
16-->16+6=22
个位数 6与16的0次方相乘
任何数的0次方都为1.
个位数 6与16的0次方
十位数 1乘以16的1次方
123-->1*16^2+2*16^1+3*16^0=256+32+3=291
十六进制转十进制的算法
110-->1*2^2+1*2^1+0*2^0=4+2=6
13-->>1*8^1+3*8^0=8+3=11
任何进制转换为十进制,用任何进制的数依次乘以任何进制的次方,次方是从0开始,再把结果相加
18-->>转为16进制12
十进制转换成任何进制,用十进制数去除以任何进制,求出商和余数,商在高位,余数依次排列
因为16是2的4次方,所以16进制的一个位对应二进制的四个位
二进制与十六进制对应表
二进制: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 十六进制: 0 1 2 3 4 5 6 7 8 9 A B C D E F
快速记忆法:
2 4 8 -->10 100 1000
3 7 F-->11 111 1111
6-->4+2-->100+10=110
A-->8+2-->1010
C-->8+4-->1100
2 5 A B 8 9 4 5 7 C F 0010 0101 1010 1011 1000 1001 0100 0101 0111 1100 1111
原理上是从右往左转 右边代表低位
01 1101 0101 1101 0101 1101
1D5D5D
二进制转换为十六进制转换过程中要从右边到左边, 四位四位划分依次转成,左边是高位,右边是低位, 如果位数不够,高位补0.
bdcb8a
1011 1101 1100 1011 1000 1010
四、 位宽和寄存器
宽度、位
计算机是有宽度的 8 16 32 64
位代表二进制的位,二进制每个位代表2
字节
4bit-->半个字节
一个字节是8个位BIT,4个BIT半个字节
8bit-->一个字节
16bit-->2个字节-->字
32bit--->4个字节-->2个字
64bit--->8个字节
字
一个字代表两个字节
一个字节8个位 两个字节16位 32位4个字节
有、无符号
4个bit,同一个方向出发,最小是0,最大是F,代表正数(无符号数)
4个bit,从0和F两个方向同时出发,在中间相遇,代表(有符号数),最小是-8,最大是7
8位代表二进制的8个位,无符号 最小为0， 最大为 FF。有符号 最小为-80 最大为7F
1111 1111 ff除以2就成 111 1111 7f
8个bit
内存就是一个循环一个圆
16位代表二进制的16个位,无符号 最小为0， 最大为 FFFF。有符号 最小为-8000 最大为7FFF
32位代表二进制的32个位,无符号,最小为0,最大FFFF FFFF(8个F),有符号 最小为-80000000,最大为7FFFFFFF.
64位代表二进制的64个位,无符号,最小为0,最大为FFFF FFFF FFFF FFFF,
有符号,最小为-8000 0000 0000 0000,最大为7FFF FFFF FFFF FFFF.
寄存器（28个）
所有的指令都是操作寄存器跟内存
32bit 16BIT 8BIT
0 EAX 0 AX 0 AL
1 ECX 1 CX 1 CL
2 EDX 2 DX 2 DL
3 EBX 3 BX 3 BL
4 ESP 4 SP 4 AH
5 EBP 5 BP 5 CH
6 ESI 6 SI 6 DH
7 EDI 7 DI 7 BH
EFLAGS FLAGS
EIP IP
EAX-->累加寄存器
ECX-->计数寄存器
EDX-->数据寄存器
EBX-->基址寄存器
ESP和EBP 对堆栈操作的寄存器
ESI和EDI 对字符串操作的寄存器
EFLAGS-->标志寄存器
EIP-->指令指针
其中EAX ECX EDX 是通用寄存器
EAX 包括两个AX ,AX包含AH AL
汇编:寄存器跟寄存器,寄存器跟内存,内存跟寄存器之间来回移动数据
五、 mov inc dec指令
编译器操作
F7 编译
F9 下断点
F5 调试
shift+F5 停止调试
F10 单步-->步过
F11 单步-->步入
红色感叹号:直接执行
alt+8 反汇编
内存、寄存器、立即数简称
r-->register 寄存器
m-->memory 内存
r8-->8bit寄存器
r16-->16bit 寄存器
r32-->32bit 寄存器
m8-->8bit 内存
m16-->16bit内存
m32-->32bit内存
imm-->立即数(0x12345678)
0X、字、字节
0x-->代表16进制
一个字节8个位 32位4个字节
一个字节8位 一个字16位 一个双字32位
格式
汇编格式:
_asm
{
XXX汇编指令XXXX
}
汇编指令不分大小写
MOV
mov 移动指令
mov 目标操作数,源操作数
功能:把源操作数复制(移动)到目标操作数里面
源操作数:r/m/imm
目标操作数:r/m
两个操作数的大小必须一样,位宽要一样
INC
INC 目标操作数
功能:将目标操作数加1
目标操作数:r/m
DEC
DEC 目标操作数
功能:将目标操作数减1
目标操作数:r/m
六、 用mov指令读写内存
ADD
ADD 目标操作数,源操作数
功能:目标操作数+源操作数-->>目标操作数
目标操作室:r/m
源操作数:r/m/imm
目标操作室和源操作数不能同时为内存
SUB
SUB 目标操作数,源操作数
功能,目标操作数-源操作数-->>目标操作数
目标操作数:r/m
源操作数:r/m/imm
ESP(堆栈)
ESP是栈顶 ebp是栈底
每一个函数都有一个堆栈
4开头的地址是全局变量
[ebx+ecx*1+0x12345678 ] -->[r/imm] 这三个表达式可以单独存在也可以组合型
2
4
8
BYTE -->一个字节--->无符号类型
WORD-->两个字节
DWORD-->四个字节
mov eax,dword ptr ds:[ecx]
ptr-->指向
ds:段前缀,段寄存器
0 es--->96bit
1 cs
2 ss
3 ds
4 fs
5 gs
6 ldtr
7 tr
struct segment
{
word selector;
word attributes;
dword limit;
dword base;
};
读写内存
读
读内存数据
mov ecx,dword ptr ds:[eax+0x2]
内存编号为12ff34的数据复制(取)4个字节给ecx
内存数据是反着存储的,右高左低
内存里面的寄存器都是32位的, 因为内存数据是四个字节四个字节对齐的
写
写内存数据
mov word ptr ds:[0x0012ff30],0x12345678 写5678 从低位开始写
mov ah,0x12345678
mov byte ptr ds:[0x0012ff30],ah -->78
立即数编译器不报错它会自动处理
七、 逻辑运算
内存最好不给ccc
逻辑指令
位与位之间的运算--> 1.位与位之间没有任何联系,
2.不进位,取最大值
or
or 或 (|) 并联
or 目标操作数,源操作数
目标操作数:r/m
源操作数:r/m/i
al=0x8
cl=0x9
or al,cl
1000--->加法
1001
1001
位与位之间相互没有联系,各做各的运算
第3位1+1=10 不进位第3位直接为1 加满了，又不能进位，就只能取最大数
24 36
0010 0100-->>加法
0011 0110
0011 0110
功能:算加法,两个操作数有一个1,就为1,否则为0
0x4589 0100 0101 1000 1001
0x3624 0011 0110 0010 0100
0111 0111 1010 1101 77ad
(两个操作数,有一个操作数为0就为0,否则为1)
and
and 逻辑与运算(&) 串联
and 目标操作数,源操作数
目标操作数:r/m
源操作数:r/m/i
mov al,0x5
mov cl,0x6
and al,cl
0101---->乘法
0110
0100
功能:算乘法,两个操作数对应的位都为1,就为1,否则为0.
0x1594 0001 0101 1001 0100
0x76ad 0111 0110 1010 1101
0001 0100 1000 0100 1484
xor 异或 (^)
xor 异或 (^)
xor 目标操作数,源操作数
目标操作数:r/m
源操作数:r/m/i
功能:两个操作数对应的位,相同为0,不同为1
0x5abc 0101 1010 1011 1100
0x6978 0110 1001 0111 1000
0011 0011 1100 0100 33c4
0xab48 1010 1011 0100 1000
0x26e9 0010 0110 1110 1001
1000 1101 1010 0001 8da1
not取反(! ~)
not取反(! ~)
not 目标操作数
目标操作数:r/m
功能:操作数对应的位,是1就为0,是0就是1(用F去减,看位宽)
0000 0010
1111 1101
0011 0010
1100 1101
0x1598ad26
0001 0101 1001 1000 1010 1101 0010 0110
1110 1010 0110 0111 0101 0010 1101 1001
ea6752d9
1598ad26
是32位用ffff ffff去减 16位用ffff去减 8位用ff去减
0xffff
0x9543
6abc
not((0x1234 or 0xa675) and 0x5894)
0001 0010 0011 0100
1010 0110 0111 0101
1011 0110 0111 0101
0101 1000 1001 0100
0001 0000 0001 0100
1110 1111 1110 1011
efeb
八、 堆栈 push pop jmp
自己了解乘、除
cdq eax-->edx:eax
cwd ax-->dx:ax
压入堆栈
push
push 目标
目标：r(寄存器)/m（内存）/imm(立即数)/seg
功能：递减堆栈指针（32位减去4）， 然后将操作数存储到栈顶-->[esp] （先减4，后给值）
sub esp , 0x4---->
lea esp,dword prt ds:[esp-0x4]--> mov是获取内存的值 ，lea是获取内存编号？
mou duord ptr ds:[esp],eax
push esp(特殊，先给值再减去4）
mov dword ptr ds:[esp-Ox4],esp
lea esp,dword ptr ds:[esp-0x4]
pop esp
lea esp dword ptr ds:[esp+0x4]
mov esp,dword ptr ds:[esp-0x4]
将弹出堆钱
pop
pop目标
目标：r/m/seg
功能：将栈顶的值加现到目标操作数指定的位置， 然后递增堆栈指针
pop eax(先弹出值，再加4）
mov eax,dword ptr ds:[esp]
lea esp,dword ptr ds:[esp+0x4]
无条件跳转
jmp、lab
jmp 目标 -->改变EIP的指令
目标：r/m/imm （立即数实际上偏移量，要给一个寄存器）
功能：跳转目标所指定的位置
jmp和lab标签，配套使用，想跳到什么位置，就在哪个位置，下个标签即可。
九、 标志寄存器
CF 进位标志 运算结果的最高们产生进位或借位，cf=1 否则 CF=0
PF 奇偶标志 运算结果中1的个数为偶数 pf=1 否则 PF=0
AF 辅助进位标志 低半字节向高半字节产生进位或者借位 AF=1 否则 AF=0
ZF 零标志 如果运算结果为0，zf=1 否则 ZF=0
SF 符号标志 运算结果的最高位是多少，sf 就是多少
OF 溢出标志 在有符号数加减运算过程中，是否产生溢出，如果溢出 OF=1 否则OF=0
十、 jcc指令
jcc指令
CF PF AF ZF SF OF
jcc 目标
目标：偏移
功能：条件成立，跳转
jc
jp
ja
jz
js
jo
编译器永远是对的
cmp--->
setcc
根据EFLAGS 寄存器中状态标志（CF、SF、OF、ZF及PF）的设置，将目标操作数设置为0或1
jc cf = 1 跳转
jnc cf = 0 跳转
jp pf = 1 跳转
jnp pf = 0 跳转
ja 无符号的 大于
jz pf = 1 跳转
jnz pf = 0 跳转
je 等于 跳转
jne 不等于 跳转
js pf = 1 跳转
jns pf = 0 跳转
jo of = 1 跳转
jno of = 0 跳转
ja ---->无符号的 大于 跳
jb ---->无符号的 小于 跳
je ---->无符号的 等于 跳
jae ---->无符号的 大于等于 跳
jane---->无符号的 小于 跳
jbe---->无符号的 大于等于 跳
jbe---->无符号的 大于 跳
jna---->无符号的 小于等于 跳
jnb---->无符号的 大于等于 跳
看两个操作数做比较
jg---->有符号的 大于
jl---->有符号的 小于
je---->有符号的 等于
jge---->有符号的 大于等于
jnge---->有符号的 小于
jle---->有符号的 大于等于
jnle---->有符号的 大于
jng---->有符号的 小于等于
jnl---->有符号的 大于等于
十一、 逻辑比较text 条件移动cmovcc 调用函数call
cmp
cmp 目标，源
目标：r/m
源： r/m/imm
功能：比较两个操作数 （用目标操作数-源操作数，根据结果设置标志位，结果丢弃）
test 逻辑比较
test 逻辑比较
test：目标，源
目标：r/m
源： r/imm
功能：目标和源 进行与（and）运算，根据结果设置标志位，结果丢弃。
设置（sf、zf、pf） cf和of标志清0.
cmov(cc)条件移动
cmovcc 条件移动
cmovcc 目标，源 （不支持8位寄存器）
目标： r
源： r/m
功能：根据标志寄存器的状态，是否移动数据
call调用
call 调用过程 --->调用函数
call 目标
目标：r/m/imm
功能：调用函数
十二、 11 逻辑比较text 条件移动cmovcc，调用函数call
cmp
cmp 目标，源
目标：r/m
源： r/m/imm
功能：比较两个操作数 （用目标操作数-源操作数，根据结果设置标志位，结果丢弃）
test 逻辑比较
test 逻辑比较
test：目标，源
目标：r/m
源： r/imm
功能：目标和源 进行与（and）运算，根据结果设置标志位，结果丢弃。
设置（sf、zf、pf） cf和of标志清0.
cmovcc 条件移动
cmovcc 条件移动
cmovcc 目标，源 （不支持8位寄存器）
目标： r
源： r/m
功能：根据标志寄存器的状态，是否移动数据
call 函数调用
call 调用过程 --->调用函数
call 目标
目标：r/m/imm
功能：调用函数
// int 是函数的类型（也称返回类型）
// fun 是函数的名字
// ()里面是参数
int fun()
{
return 0; // 返回 0
}
调用函数，在main函数里面调用
F10 步过，不进call，不进函数，执行
F11 步入，进call，进函数，一步一步执行
一个程序一般分两个部分
一个部分是堆栈的数据 针对VC6编译器，一般是12FF开头的
一部分是全局数据 针对VC6编译器，一般是401000开始的（4打头的）
局部变量一般是放在堆栈里的，特殊情况下（比如说指针，就不一定放在堆栈里）
数据既代码，代码既数据
CALL指数的分解
call的目标操作数 改变的是eip
mov dword ptr ds:[esp], call的下一条指令的地址
call 目标操作数
push call的下一条指令地址 --> （本条指令的地址（EIP）+本条指令的长度）
jmp 目标操作数