常用汇编指令

NOT ;非
AND ;与
OR ;或
;时钟用于将CPU的内部操作和其他系统部件同步
;控制单元(CU)协调执行机器指令时隔各个步骤地次序
;算数逻辑单元(ALU) 执行加减的算数运算以及NOT,OR,AND之类的逻辑运算
;内存储器 用于存储指令和数据，处理完毕后存入存储器
;数据总线　用于CPU和内存之间传送数据
;控制总线 用于控制所有的设备的动作进行同步
;地址总线 用于存放指令和数据的地址
;时钟 涉及CPU和系统总线的每个操作的以各内部时钟同步，用以以固定频率产生脉冲。
;机器指令使用的最基本的时间单位称为机器周期或时钟周期，等价于一个完整的时钟脉冲的时间。0 1 表示一个周期
;1GHz的时钟，其周期的持续时间为1秒的10亿次分之一 周期
;等待状态称为空时钟周期
;保护模式 是处理器的主要状态，所有指令和特性都可以使用，程序被赋予了独立的内存款区域（段）
;虚拟模式 在假死模式即使DOS挂起也不会影响运行
;实地址模式 需要调用硬件设备的时候会用到
;系统管理模式 提供给系统用的实现电源管理和系统安全的机制。提供自定义系统启动过程的设计
;--------------------------------------------
comment !
注释
!

mov ax,[200];将内存地址200的地址的值送到ax
mov ax,myVariable ;将变量 myVariable 变量值送入ax
target:
;...
jmp target; 跳转到target标记

first byte 10; 第一变量

mov ;移动
add ;加法
sub ;减法
mul ;乘法
jmp ;跳转
cal ;条用过程

stc; 设置cf 为1
inc ax ; ax++
;--------------------------------------
title 示例代码
include Irvine32.inc
.code
main proc
mov eax,10000h
add eax,40000h
sub eax,20000h
call dumpRegs
exit
main endp
end main

title ;标题注释
; 注视
include ; 导入文件设置和信息
;-----------------------------------
.code ;代码段
main proc ; 定义定义一个名字叫main的过程
call [procName]; 调用一个过程
exit ;dos结束函数
end main ;结束程序并且执行

.386 ;指定运行的最低cpu
.model flat,stdcall ; 为保护模式 ，stdcall是允许调用mswindows函数
proto ;指定该程序使用的子程序
invoke ;调用函数


;-----------------------------------
title program temp
;
;
;
include Irvine32.inc
.data
;...
.code
main proc
;...
exit
main endp
end main
;------------------------------------
byte ;8为无符号整数
sbyte ; 8位有符号整数
word ;16为无符号整数
sword ;16位有符号整数
dword ; 32位无符号整数（保护模式，可以用作近指针）
sdword;32位有符号整数
fword ;48为整数
qword ;64位整数
tbyte ;80位 （10字节）证书
real4 ;32位4字节短实数
real8 ;64位8字节长实数
real10 ; 80位10扩展精度实数

value1 byte 'a'
value2 byte 0
value3 byte 255
value4 sbyte -128
value5 sbyte +127

;----------------
value6 byte ? ; 不定义初始值 可以动态赋值

value1 db 255
value2 db -128 ;早版本的定义方式

list byte 10,20,30,40
byte 50,60,70,80

list byte 10,32,41h,00100010b
list byte 0ah,20h,'a',22h
;可以使用多种数据类型

greeting1 byte "good afternon",0

dup ;定义初始化和未初始化 BYTE 5 dup(?) 5个空间

/ ;连接两行代码

byte 20 dup(0) ; 20字节 全部为0
byte 20 dup(?) ; 20 未初始化
byte 4 dup("stack");20 "stackstackstack"


word1 word 65535
word2 sowrd -32768
word3 word ?

var1 dw 65535;早期方式
var2 dw -32768


var1 dword 12345678
var2 sword -21474836
var3 dword 20 dup(?)

var1 dd 12345678h
var2 dd -21474736

qword1 qword 123455678888h
quad1 dq 1234567899h


var1 tbyte 10000000001234567h

var1 dt 100000000000123243534h

.data? ;定义未初始化得数据

$;当前地址

list byte 1,0,203,3,
listSize = ($-list)

list word 1,2,3,4,5,6
listSize = ($-list)/2

list dword 1,2,3,4,5,6
listSize = ($-list)/4

equ ;定义表达式
PI equ <3.1415>
.data
var1 byte PI


d equ <10*10>
s equ<"aasdfasdf",0>

d equ 10*10



;--------------------------------------

textequ ;文本宏 表达式

msg textequ <"sdfdsfadsfadsfa">

count textequ %<10*10>
move textequ <mov>

st textequ <mov al,10>
;----------------------------------------

@data ;数据段 起始地址


;8位寄存器 AH,AL,BH,BL,CH,CL,DH,DL
;16位寄存器 AX,BX,CX,DX,SI,DI,SP,BP
;32位寄存器 EAX,EBX,ECX,EDX,ESI,EDI,ESP,EDP
;reg 任意通用寄存器


;sreg 16位寄存器 CS,DS,SS,ES,FS,GS
;imm

mov al,[varl+5] ;直接偏移
;无符号 扩展转换
movzz 32,8
movzx 32,16
movzx 16,8
;有符号扩展 转换
movsx 32,8
movsx 16,8
movsx 32,16

lahf ;将EFLAGS寄存器的低字节拷贝到ah中

lahf
mov saveflags,ah

sahf ;将ah中的数据拷贝到eflags中

xchg ;交换内容
xchg ax,bx
;---------------------------------

arrayB byte 10h,20h,30h,40h,50h

mov al,arrayB ;Al=10h 默认首地址

mov al,[arrayB+1] ; Al=20h;偏移 1个地址
mov al,[arrayB+2] ; Al=30h;偏移2个地址
mov al,arrayB

word ; 16位需要加2
mov al,arrayB+2

inc ax ; ax++
dec ax ; ax--
;--

neg reg ;求相反数 正负交换

Xval SWORD 26
mov eax,Xval
neg eax ; -26

Yval SWORD 30
Zval SWORD 40
mov eax,Yval
sub eax,Zval ; 30-40 = -10

offset ;操作符号返回一个变量相对其所在段的开始的偏移
ptr ;允许重载变量的默认尺寸
type ;返回数组中每个元素的大小
lengthof ;返回数组的数目
sizeof ;返回所占空间

.data
bVal BYTE ? ;00404000
wVal WORD ?
dVal DWORD ?
dVal2 WORD ?

mov esi, offset bVal ;00404000 1
mov esi,offset wVal ;00404001 2
mov esi,offset dVal ;00404003 4k
mov esi,offset dVal2 ;00404007 2

align ;对齐 按位置 字节，字，双字节 边界对齐

bVal BYTE ? ;-------1字节
align 2 ;-------2字节
wVal WORD ?
bVal2 WORD ?
align 4 ;-------4字节
dVal DWORD ?

.data
myDouble DWORD 12345678h
.code
;mov ax,myDouble
mov ax,WORD ptr myDouble ; 以 WORD 传入 ax

;ptr 设置 存取 尺寸

;type 返回类型 byte=1 word=2 DWORD = 4 QWORD = 8

.data
bVal BYTE 10,0,0
dVal DWORD 33 dup(?)
lengthof bVal ; lengthof = 3 针对长度而已
lengthof dVal ; lengthof = 33

dArray WORD 32 dup(?)
sizeof dArray ; sizeof = 32*2 = 64

label [type]; BYTE WORD DWORD QWORD 为下面的类型进行别名的定义
dVal label QWORD
val WORD 1234h; dVal 控制
val2 WORD 5678h; dVal 控制

;dVal = 123456h


;---间接操作数
.data
val1 BYTE 10h
.code
mov esi,offset val1
mov al,[esi] ; al = 10h

mov [esi],bl ;
;116p

typedef ;定义新数据类型
pbyte typedef ptr BYTE
.data
ptr1 pbyte ?

TITLE Pointers
include Irvine32.inc
PBYTE TYPEDEF PTR BYTE
PWORD TYPEDEF PTR WORD
PDWORD TYPEDEF PTR DWORD
.data
arrayB BYTE 10h,20h,30h
arrayW WORD 1,2,3
arrayD DWORD 4,5,6

ptr1 PBYTE arrayB
ptr2 PWORD arrayW
ptr3 PDWORD arrayD

main proc
mov esi,ptr1
mov al,[esi]
mov esi,ptr2
mov ax,[esi]
mov esi,ptr3
mov eax,[esi]
exit
main endp
end main

jmp [target] ; 无条件跳转

teg:
jmp teg

loop [目的地址] ; 重复执行特定次数的方法

mov ax,0 ; ax 计数器
mov ecx,5; 循环5次
L1:
inc ax
loop L1


title sum
.data
intarray WORD 100h,200h,300h
.code
mov edi,offset intarray
mov ecx,lengthof intarray
mov ax,0
L1:
add ax,[edi]
add edi,type intarray
loop L1
exit
main endp
end main

[outApp] proto ;引入过程
call [outApp] ; 调用过程


push [dta] ; 入盏操作
pop ax; 出盏 操作
pushfd ; 压入eflags 的值
popfd ; 弹出 Eflags 的值


pushf ;在堆栈 上压入16位的Flags 的值
popf ; 从堆栈弹出16位的值赋给Flags

pushad ; 从 Eax, ecx,edx,ebx,esp,ebp,esi,edi 压入
pusha ; ax,cx,dx,bx,sp,bp,si,di

popad ;上面相反
popa ;上面相反


proc ;过程指令

sample proc
;...
ret
sample endp

invoke ExitProcess,0



main proc
jmp L2 ;-------->不时全局标示
L1::
main endp
sub2 proc
L2:
jmp L1
ret
sub2 endp

proc USES esi ecx
USES ; 定义过程中可以修改的寄存器,就是在过程开始时保存原寄存器的数据，执行完后恢复数据

AND ;源操作数和目的操作数之间进行布尔与操作
or;
XOR ; 异或操作
not ; 非操作
test; 只设置CPU标示 但不修改操作数
bt,btc,btr,bts;

cmp ;大小比较 cmp ax<bx 1 否则 0

and al,0 ; 设置零标志
or al,1 ; 清楚零标志

or al,80h ;设置符号标志
and al,7fh ;清楚符号标志

stc ;设置进位标志
clc ;清楚进位标志

mov al,7fh
inc al;
or eax,0 ; 清楚益处 标志


jmp ; 无条件跳转

jz ; zf 为0 跳转 cmp 1,0 1>0

jnc ;非进位跳转
jc ; 进位跳转
jnz ; 非零跳转 cmp 0,1 0<1 1 跳转

je ; 判断相等跳转 zf 是否为1
jne; 相同跳转
jl ; 同jz 0<1
jg ; 同jnz 1>0

jo ;益处跳转
jno ;未益处跳转
js ;有标志跳转
jns; 无标志跳转
jp ; 偶数跳转
jnp; 奇数跳转

jcxz ; cx = 0跳转
jecxz ; ECX = 0 跳转
JA ;LEFT>RIGHT
JNBE ; !a>=b
jae ; a>=b
jnb ; !a<=b
jb ; a<b
jnae ;!a>=b
jnb ; a<=b
jna ; !a<b

jg ; a>b
jnle ; !a>=b
jge ; a>=b
jnl ; !a<b
jl ; a<b
jnge ;!a>=b
jle ; a<=b
jng ;!a<b

bt r,r ; 选择第一个操作数的第N位给CF

.data
semaphore WORD 10001000b
.code
bt semaphore,7 1

mov ax,semaphore
shr ax,8


btc r,r ; 选择第一个操作的第N位给CF并将源数据取反

.code
btc semaphore,6; cf=0,sempahore = 11001000b


btr r,r ;选择第一个操作数的第N位给CF,并将源数据清 零
.code
btr semaphore,7; cf = 1,semaphore = 00001000b


bts ; 同bt 功能一致



loopz ; Ecx >0 zf = 1被设置时

loopnz ; ecx>0 zf = 0
loopne ; 同上

; 分支结构

clusterSize = 8192
if(gigabytes<8)
clusterSize = 4096

;---------------------
mov clusterSize,8192
cmp gigabytes,8
jae next
mov clusterSize,4096
next:
;----

if(a1>b1) and (b1>c1){
x=1
}

cmp a1,b1
ja L1
jmp next
L1:
cmp b1,c1
ja L2
jmp next
L2:
mov X,1

next:


.IF eax>val2
mov result,1

.endif

.if (DL<0 ) || (DL >79)


.if

.elseif

.endif

.while eax <10
inc eax
.endw

.repeat ; 好比 do {} while

.repeat
inc eax
.until eax == 10

shl ; 逻辑 左移
shr ; 逻辑 右移
sal ; 算术 左移
sar ; 算术 右移
rol ; 循环 左移
ror ; 循环 右移
rcl ; 带进位的循环左移
rcr ; 带进位的循环右移
shld ; 双精度左移
shrd ; 双精度右移


mov bl,8fh ; bl = 10001111b
shl bl,1 ; bl = 00011110b cf = 1

mov al,0d0h ; al = 11010000b
shr al,1 ; al = 01101000b cf = 0


mov al,0f0h ; al = 11110000b (-16)
sar al,1 ; al = 11111000b (-8) cf = 0

mov dl,-128 ; dl = 10000000b
sar dl,3 ; dl = 11110000b


mov al,40 ; al = 01000000b
rol al,1 ; al = 10000000b cf = 0
rol al,1 ; al = 00000001b cf = 1
rol al,1 ; al = 00000010b cf = 0


stc ;cf =1
mov ah,10h ; cf = 1 ah = 00010000b
rcr ah,1 ; cf =0 ah = 10001000b

mov ax,234bh
mov dx,7654h
shrd ax,dx,4 ; ax = 4234h

mul r;乘法 计算

mov al,5h
mov bl,10h
mul bl ;


.data
var1 WORD 2000h
var2 WORD 0100h
.code
mov ax,var1
mul var2 ; cf = 1


mov eax,12345h
mov ebx,1000h
mul ebx ; cf = 0

imul ; 符号乘法

mov al,48
mov bl,4
imul bl ; ax = 00c0h , of = 1

mov al,-4
mov bl,4
imul bl ; ax = fff0h of = 0

mov ax,48
mov bx,4
imul bx ; dx:ax = 000000c0h of = 0

mov eax , +4823424
mov ebx , -423
imul ebx ; edx:eax = fffffff86635d80h, of = 0



mov ax,0083h
mov bl,2
dir bl ; al = 41h 商 ,ah = 01h 余数

mov dx,0 ; 高 位
mov ax,8003h ;低位
mov cx,100h ; 被除数
div cx ; ax = 0080 商 dx = 0003h 余数

mov edx,DWORD PTR dividend +4 ; high
mov eax,DWORD PTR dividend ;low
div divisor ; EAX = 08003000H 商 edx = 00000020h 余数

cbw ; 将 符号 放入 ah

cwd ; 将符号 放入 DX

cdq ; 将符号 放入 eax


idiv ;

adc ; a+b+cf

mov al,0
mov al,0ffh
add al,0ffh ; al = fe
adc dl,0 ; dl = fe+1 = 01

sbb ; a-b-cf

mov edx,1
mov eax,0
sub eax,1 ; 1
sub edx ;

aaa ; 将 结果ASCII 转换为 值 使用前 必须 将 al 清 0

mov ah,0
mov al,'8' ; ax = 0038h
add al,'2' ; ax = 006ah
aaa
or ax,3030 ; ax =3130h = '10'

aas ; 相减 后 转换为 ASCII
aam ;
add
daa
das



local ;在 过程 中 局部变量 的 定义
MySub proc
local var1:BYTE,temp:DWORD,TempArray[10]:DWORD



invoke [过程名称],参数1,参数2..

.data
var1 DWORD 12345h
var2 DWORD 23456h
.code
invoke AddTwo,var1,var2

;或则 是
push var2
push var1
call AddTwo

addr ; 运算符 可以 在 使用 Invoke传递指针
invoke FillArray,Addr MyArray

procName proc parameter1,parameter2...


FillArray proc,pArray:ptr BYTE,var1:DWORD
local fileHandle:DWORD
;...
FillArray endp

proto ;申明 原型 不然不能调用
MySub proto
Invoke MySub


;值传递
.data
myData WORD 1000h
.code
main proc
invoke sub1,myData
main endp
sub1 proc someData:WORD
mov someData,0
ret
sub1 endp
;不会修改 原数据

;引用传递
.data
myData WORD 1000h
.code
main proc
invoke sub1,addr myData
main endp
sub1 proc someData:ptr WORD
mov someData,0
ret
sub1 endp
;修改 数据



.data
myData WORD 1000h
.code
main proc
invoke sub1,addr myData
main endp
sub1 proc someData:ptr WORD ;也 可以 做 返回 内容
mov someData,0
ret
sub1 endp
;修改 数据


.model ;模式,模式,模式...

tiny ;微型模式 只有 一个 同时 包含代码 和 数据 的 段 由 .COM程序使用
small ;小型 一个 代码段和 一个 数据段,所有代码和数据都是近地址的
medium ;中型 多个 代码段但只有一个数据段
compact ; 紧凑 一个代码段和 多个数据段
large ; 大型 多个代码段和数据段
huge ; 巨型 除了单个数据项大小可以操作一个 数据段 ,其余 与 大型一样
flat ; 保护模式 , 代码 和数据使用 32位 偏移 ,所有 代码和数据都在 一个 32位段中

c,basic,fortran,pascal,syscall,stdcall;语言 兼容汇编

lea ;返回 任意类型的 间接操作数的偏移 ,

;定义 局部 变量

MySub proc
push ebp
mov ebp,esp
sub esp,36
mov BYTE PTR [ebp-4],'X'
mov DWORD ptr [ebp-8],10
mov esp,ebp
pop ebp
ret
endp

enter [保留的空间][过程 嵌套层次];自动调用 过程 创建堆栈框架,它为使用局部

leave ;释放堆栈框架

MySub proc
enter 8,0
;...
leave
ret
mySyb endp

movsb ;拷贝 字节 esi edi
movsw ;拷贝 字
movsd ;拷贝 双字
;移动 字符串数据 将一个数从内存中的一个位置拷贝到另一个位置

cmpsb ;比较字节
cmpsw ;比较字
cmpsd ;比较双字
;比较字符串: 比较两 个内存值

scasb
scasw
scasd
;扫描字符串:将一个整 数与内存值相比较

stosb
stosw
stosd
;存储字符串数据: 将一个整数存储到内存中
lodsb
lodsw
lodsd
;将字符串数据装入累加器: 从内存中取出一个整数送入累加器(al,ax,eax)

mian proc
mov ax,@data;-->将数据段传入 寄存器
mov ds,ax
mov es,ax
main endp

rep ; 当 ECX>0时 重复
repz,repe ; 当zf 被 设置 并且 ECX>0时 重复
repnz,repne; 当zf 并清除 并且 ECX>0 时 重复

cld ;清理方向标志
std ;设置 方向标志


;定义结构
Poin STRUCT
x WORD ?
Y WORD ?
Poin ENDS

point1 Poin <4,5>
point1 Poin {33,5}


unionName union
d DWORD 0
unionName ends


NewLine macro char:REQ ; 参数
call Crlf
endm

.code
NewLine

echo 显示信息


if ; 如果哦表达式 为真 允许汇编 ;相关操作符 : LT,gt,eq,ne,le,ge

ifb <参数> ;如果参数为空允许汇编 参数 必须用 括号 括起
ifidn <参数1,参数2> ;如果两个参数相同 就 汇编 ,大小写敏感
ifidni <参数1,参数2> ;相同 就汇编 ,不区分大小写
ifdif <参数1,参数2> ; 如果参数不相同 就 汇编 敏感
ifdifi <参数1,参数2> ; 如果参数不相同就汇编 ,不敏感
ifdef 名字 ; 如果名字已经定义就汇编
ifndef 名字; 如果名字 没定义 就汇编
endif ;结束
else ;否则做什么
exitm ;立即 退出 宏

lt ;小于
gt ;大于
eq ; 等于
ne ;不等于
le ;小于等于
ge ; 大于等于
& ;替换操作符
<> ;文本操作符
! ; 特殊字符操作
% ;展开操作符


while var3 LT 0f000000h

endm

repeat 100


endm


for 参数,arg1,agr2,arg3

endm

forc 参数,<string>

endm


WriteConsole equ <WriteConsoleA>