导图社区汇编

汇编

汇编基础，包括进制，基础指令、标志寄存器、堆栈、逻辑运算等，需要的可以共享！

编辑于2023-12-25 10:04:44

语言
汇编基础

乐善好施📶iPhone

他的近期作品查看更多>>

CMakeList.txt简单介绍
这是一篇关于CMakeList.txt的思维导图，梳理了 CMake 构建脚本的核心配置步骤，覆盖从基础语法、项目设置到 Qt 模块集成、跨平台适配的全流程配置要点，帮助开发者快速掌握 CMakeList.txt 的编写规范，高效搭建 Qt 项目构建体系，解决 CMake 配置报错、语法不熟悉、跨平台适配难等痛点。基础语法部分讲解注释、最低版本号设置规则；项目配置模块包含项目名称、版本号、编程语言指定方法；路径配置部分介绍如何将当前目录和构建目录添加到包含路径；Qt 相关配置模块详细说明自动处理 UI、MOC、RCC 文件的启用方式；C++ 标准设置部分讲解如何启用 C++17 标准及强制标准生效配置；Qt 模块查找部分梳理 find_package 命令的使用方法，支持不同 Qt 版本（Qt5/Qt6）的 Widgets 模块集成；文件管理部分介绍如何添加项目源文件、头文件和资源文件；跨平台适配部分包含 Qt 版本判断、平台专属配置（Android、Windows、macOS）及链接 QtWidgets 模块的完整示例，覆盖 Qt 项目 CMake 配置的高频场景与易错点。本模板适配 Qt 开发工程师、C++ 后端开发者、嵌入式系统开发者、计算机专业学生、开源项目维护者等多类使用人群，既适合零基础学习者快速入门 CMake 配置，也可作为资深开发者编写跨平台 Qt 项目构建脚本的参考手册，大幅减少配置调试时间。
cpp智能指针
这是一篇关于c智能指针的思维导图，内容详细介绍了C++中智能指针的相关知识，主要内容包括：vs中内存泄漏的检测，智能指针，适合C++开发者学习和查阅，帮助其更好地理解和使用智能指针进行内存管理。
Cpp容器
这是一篇关于C容器的思维导图，主要内容包括：序列式容器，容器适配器(都不支持迭代器)，关联式容器，容器使用注意事项。总结了C++中各类容器的使用方法和注意事项，适合作为学习和复习C++容器知识的参考资料。

汇编

社区模板帮助中心，点此进入>>

乐善好施📶iPhone

他的近期作品查看更多>>

相似推荐
大纲

互联网9大思维
- 40.1k
- 977
- 2.5k
- 401
- 0
MindMaster
组织架构-单商户商城webAPP 思维导图。
- 18.8k
- 3
- 186
- 9
- 1
Kacyun
域控上线
- 4.6k
- 171
- 11
- 4
- 0
jackrao
python思维导图
- 9.9k
- 558
- 242
- 7
- 0
(*^▽^*)
css
- 4.1k
- 1
- 43
- 3
- 0
A张舫
CSS
- 6.6k
- 272
- 189
- 33
- 0
journey
计算机操作系统思维导图
- 8.4k
- 355
- 209
- 16
- 0
journey
计算机组成原理
- 4.2k
- 98
- 71
- 8
- 0
journey
IMX6UL(A7)
- 2.8k
- 41
- 5
- 0
- 0
Handler XU
考试学情分析系统
- 3.8k
- 51
- 10
- 1
- 0
蒋龙

汇编

一、进制

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] 这三个表达式可以单独存在也可以组合型

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 目标操作数,源操作数

目标操作数:r/m

源操作数:r/m/i

al=0x8

cl=0x9

or al,cl

1000--->加法

1001

位与位之间相互没有联系,各做各的运算

第3位1+1=10 不进位第3位直接为1 加满了，又不能进位，就只能取最大数

24 36

0010 0100-->>加法

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 目标操作数,源操作数

目标操作数: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 目标操作数

目标操作数: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 目标

目标：偏移

功能：条件成立，跳转

编译器永远是对的

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：目标，源

目标：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：目标，源

目标：r/m

源： r/imm

功能：目标和源进行与（and）运算，根据结果设置标志位，结果丢弃。

设置（sf、zf、pf） cf和of标志清0.

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 目标操作数