二进制数101101.18 转换为十进制数
101101.1 B = 1 x 2^5 + 0 x 2^4 + 1 x 2^3 + 1 x 2^2 + 0 x 2^1 + 1 x2^0 + 1 x 1^-1 =45.5 D

101101 B = 0010 1101.1000 = 2D.8 H

十六进制数39C H转换为十进制数
按权展开：
39C H= 3 X 16^2 + 9 X 16^1 + 12 X 16^0 = 924 D

[+1]原 = 0000 0001

[-1]原 = 1000 0001

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原 = [11111110]反

[+1] = [00000001]原 = [00000001]反 = [00000001]补

[-1] = [10000001]原 = [11111110]反 = [11111111]补

正数 
00000000 B - 01111111 B
00H - 7FH
0 - 127D

负数
10000000 B - 11111111 B
80H - FFH
-128D - -1D

机器字长为8位，则－50D 的补码为：
   ＋50的补码为   0011 0010B
   按位求反后为： 1100 1101B
   末位加1 ：     1100 1110B
   则[-50]补＝ 1100 1110 B=0CE H

 [A+B]补= [A]补+ [B]补

 [A- B]补= [A]补+ [-B]补

1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2

1 - 1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原= [0000 0001]反 + [1111 1110]反 = [1111 1111]反 = [1000 0000]原 = -0

1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原 = [0000 0001]补 + [1111 1111]补 = [0000 0000]补=[0000 0000]原

(-1) + (-127) = [1000 0001]原 + [1111 1111]原 = [1111 1111]补 + [1000 0001]补 = [1000 0000]补

[1111 1111 ，0111 1111]
即
[-127 ，127]

[0000 0000 , 1111 1111]
即
[0 , 255]

1MB = 1024KB = 1M x 8bit 

1k = 2^10 = 1024
1M = 2^20
1byte = 8bit
1kB = 1024byte

85D = 10000101 = 85H

85D = 000010000 00000101 = 0805H

大写字母A-Z: 41H-5AH 		
小写字母a-z: 61H-7AH 
数字0-9: 30H -39H	

空格： 20H 
回车： ODH 
换行： OAH 
响铃： 07H

例1：3AH + 7CH＝B6H  
即00111010 + 01111100 = 10110110
无符号数运算：	58＋124＝182
	范围内，无进位
有符号数运算： 	58＋124＝182
	范围外，有溢出

若地址位数为 n，则CPU可以直接寻址 2^n个存储单元

MOV BX,1000H
MOV DS,BX

MOV AX,[0]  表示将起始内存为1000:0000的字数据存放到AX中
MOV AL,[0]  表示将起始内存为1000:0000的字节数据存放到AL中

末单元物理地址=首地址+(N-1)*TYPE

N为存储区空间大小，单位是字节，因为地址是从0开始，所以要减一

TYPE 是存储区的数据类型所占存储单元个数，如字节型，值为1，字型为2

(3075A H) = 12 H 代表3075A H单元中的内容是 12H

(37692 H) = 5678 H 代表37692 H单元和 37693 H单元一起存放 5678H，该单元是字单元

MOV AX,DS:[2000H]

MOV AL,[32H]
MOV AX,1234H
MOV BX,16
MOV EAX,56H

MOV AX,BX

MOV AX,DS:[2000H]
操作数的有效地址EA直接写在指令中，用括号里的数值作为操作数的偏移地址(有效地址)，操作数的段地址为数据段，由DS指出
注意：不加DS:前缀，汇编时会认为，[2000H]是立即数而不是偏移地址

x dw 5678H
MOV AX,X
或
MOV AX,[X]

MOV AX,[BX]
MOV AX,SS:[BP]  这里使用了段超越前缀

MOV AX,[BX+1234H]
MOV AX,VALUE[BX] #符号地址

MOV AX,[BX+DI]
MOV AX,[BX][DI]

MOV AX,[MASK+BX+SI]

;以1000CH-1000FH段内存为栈
MOV AX,1000H
MOV SS,AX
MOV SP,0010H

MOV AX,001AH	;以字为单位进行操作
MVO BX,001BH

PUSH AX
PUSH BX

ASSUME CS:CODES
CODES SEGMENT 
START:
    MOV AX,3
    MOV BX,5
    ADD BX,AX
    INT 21H
CODES ENDS
END START

段名 segment
...
...
...
段名 ends

ASSUME CS:CODES
	CODES SEGMENT 
START:
    MOV AX,3
    MOV BX,5
    ADD BX,AX
    INT 21H
CODES ENDS
    END START

将用作代码段的段codesg和寄存器cs关联起来
assume  cs:codesg

codesg segment
codesg最终将被处理为一个段的段地址

MOV AX,4c00H
int 21H
这两段代码的功能就是程序返回

SA x 16 + 0 + 256 = SA x 16 + 16 x 16 
或
SA + 10H : 0

ffff H 需要写为 0ffff H

assume cs:codesg
codesg segment
	MOV AX,2
	MOV CX,3
S:	ADD AX,AX	;标号S标记了一个地址，这个地址有一条指令	ADD AX,AX
	LOOP S	
	
	MOV AX,4c00H
	INT 21H
codesg ends
end

ASSUME CS:CODE
CODE SEGMENT
	DW 0123H,0456H,0789H,0ABCH,0DEFH,0FEDH,0CBAH,0987H
	
	MOV AX,0
	MOV BX,0
	
	MOV CX,8
	
S:	ADD AX,CS:[BX]
	ADD BX,2
	LOOP S
	
	MOV AX,4C00H
	INT 21H
CODE ENDS

END

ASSUME CS:CODES
CODES SEGMENT 
;定义数据
START:
;代码
    ADD BX,AX
    INT 21H
CODES ENDS
END START

ASSUME CS:CODES,DS:DATA,SS:STACK
DATA SEGMENT
	DW 0123H
DATA ENDS

STACK SEGMENT
	DW 0,0,0,0,0
STACK ENDS

CODES SEGMENT 
START:
	MOV AX,STACK
	MOV SS,AX
	
	MOV AX,DATA
	MOV DS,AX
	
    INT 21H
CODES ENDS
END START

OR AL,00100000B

OR AL,00100000B

全部转为小写字母
ASSUME CS:CODES,DS:DATAS
DATAS SEGMENT
	db 'BaSiC'
DATAS ENDS

CODES SEGMENT
    
START:
    MOV AX,DATAS
    MOV DS,AX
    
    MOV BX,0
    MOV CX,5
S:	MOV AL,[BX]
	OR AL,00100000B
	MOV [BX],AL
	INC BX
	LOOP S
	 
    
    MOV AH,4C00H
    INT 21H
CODES ENDS
END START

将数据段中定义的第一个字符串转为大写，第二个字符串转为小写
ASSUME CS:CODES,DS:DATA
DATA SEGMENT
	DB 'BaSiC'
	DB 'MinIX'
DATA ENDS

CODES SEGMENT
START:
	MOV AX,DATA
	MOV DS,AX
	
	MOV BX,0
	MOV CX,5
S:	MOV AL,0[BX]
	AND AL,11011111B
	MOV 0[BX],AL
	
	MOV AL,5[BX]
	OR AL,00100000B
	MOV 5[BX],AL
	INC BX
	LOOP S
	
	MOV AX,4C00H
	INT 21H
CODES ENDS
END START

word ptr指明访问的内存单元是字型
inc word ptr [bx]

byte ptr指明访问的内存单元是字节型
inc byte ptr [bx]

div byte ptr ds:[21]

db 3 dup (0) 相当于 db 0,0,0
db 3 dup (0,1,2) 相当于 db 0,1,2,0,1,2,0,1,2

assume cs:code
code segment
	start:
	mov ax,offset start		;相当于 mov ax,0
	s:
	mov ax,offset s			;相当于 mov ax,3
code ends
end start

mov ax,0123H
mov ds:[0],ax
jmp word ptr ds:[0]		;(IP) = 0123H

mov ax,0123H
mov ds:[0],ax
mov word ptr ds:[2],0
jmp dword ptr ds:[0]

(CS) = 0
(IP) = 0123H

pop IP

pop IP 
pop CS

CALL 标号

相当于
push IP
jmp near ptr 标号

CALL far ptr 标号

相当于
push CS
push IP
jmp far ptr 标号

CALL 16位reg

相当于
push IP
jmp 16位reg

CALL WORD PTR 内存单元地址

相当于
push IP
jmp word ptr 内存单元地址

CALL DWORD PTR 内存单元地址

相当于
push CS
push IP
jmp dword ptr 内存单元地址

         mov al,x
	       CMP	Al，0	  ;与0进行比较
	       JGE	A1	       ;X≥0转A1
	       MOV	Y，-1	  ;X ＜0时，-1→Y
	       JMP	EXIT
A1：     JG	A2 	       	   ;X＞0转
	       MOV	Y，0	       ;X=0时，0→Y
	       JMP	EXIT
A2：     MOV	Y，1	       	  ;X＞0，1→Y 

EXIT：   MOV	AH，4CH
	       INT	21H 

  1．跳转表中存放多分支程序的偏移地址(标号)
  2．跳转表中存放多分支程序的转移指令

DATAS SEGMENT
    BASE   DW SUB1,SUB2,SUB3,SUB4,SUB5,……
    BN     DB 3   
DATAS ENDS

CODES SEGMENT
start:

      MOV AL, BN      
      MOV AH, 0
      DEC AL          ;建索引号
      SHL AL, 1       ; (3-1)*2
      MOV BX, OFFSET  BASE  ;?不用XLAT?
      ADD BX, AX      ;求功能3的有效地址 
      MOV BX, [BX];      jmp near ptr  [bx]
      JMP BX       ;BX中存放具体标号(SUB3)


SUB1: ....
      JMP EXIT
      .....
SUB2: ....
      JMP EXIT
      .....
SUB3: .......
      JMP EXIT
      .....
      .....
SUB8: .....
      JMP EXIT
EXIT:

CODES ENDS

ASSUME CS:CODES,DS:DATAS,SS:STACKS

DATAS SEGMENT
   buf DW 12,32,45,1,33       ;要排序的数
   COUNT DW ?      ;数组元素个数
DATAS ENDS

STACKS SEGMENT
    ;此处输入堆栈段代码
STACKS ENDS

CODES SEGMENT

START:

	MOV AX,DATAS
	MOV DS,AX
    
	;此段代码，按冒泡排序，小到大
	MOV CX,COUNT	#count 记录数组长度
	DEC CX		;记录循环次数
	
lp1:			;外循环
	PUSH CX		;记录外循环次数
	MOV BX,0
					
lp2:    		;内循环
	MOV AX,buf[BX]
	CMP AX,buf[BX+2]	;比较大小
	JLE next
	XCHG AX,buf[BX+2]
	MOV buf[BX],AX
	
next:	
	ADD BX,2
	LOOP lp2
	POP CX		;恢复外循环次数
	LOOP lp1

finish:	
	MOV AH,4CH
	INT 21H

CODES ENDS
END START

子程序名 proc 属性       
...
...
...
子程序名 endp

注：属性为 near或far

属性的确定原则：
1.主程序和子程序在同一个代码段内，用near
2.主程序和子程序不在同一个代码段内，用far
3.主程序是第一个被执行的程序，则主程序应定义为far(相对DOS系统来讲)

宏名字 MACRO 哑元1,哑元2,哑元3...
	语句串
	ENDM
说明：
语句串代表宏定义体，即具体的程序代码
哑元代表形参，用逗号分割，可以没有形参，和哑元对应的是实元，相当于实参(实元和哑元统称为变元)

例
两数相加宏指令
SUMM MACRO x1,x2,x3
	MOV AX,x1
	ADD AX,x2
	MOV X3,AX
	ENDM

例
调用宏SUMM实现(BX) = 34 + 25
SUMM 34,25,BX

TEST MACRO x1,x2
	MOV AX,x1
	ADD AX,x2
ENDM

TEST MACRO x1,x2
	x1 AX,2
	x2 AX,3
ENDM

TEST MACRO x1,x2
	MO&x1 AX,2
	AD&x2 AX,3
ENDM
宏调用
TEST V,D 
等价于
	MOV AX,2
	ADD AX,3

TEST MACRO x1,x2,x3
	x1 DB x2 DUP(x3)
ENDM

宏调用
TEST SS,6,5
等价于
SS DB 6 DUP(5)

TEST MACRO x1
	SS DB 'Number &x1','$'
ENDM

宏调用
TEST abc
等价于
SS DB 'Number abc','$'

段名 segment 
...
...
段名 ends

assume 段寄存器:段名

(变量名)存储单元名 DB 操作数

DB 个数 dup(?)  ;重复定义相同操作数

注意：
一条数据定义指令，可为多个存储单元赋值
操作数默认是10进制的，定义16进制后面加H
数字不能以字母开头，前面要加0
操作数可为 ? 表示为变量预留空间而不赋初值
操作数可为表达式，表达式会先计算，再将结果存到存储单元
操作数若为字符串，要用单引号包围
字符串应使用DB定义，存入的是字符串的ASCII码

变量名 EQU 表达式或数据 

变量名 = 表达书或数据

注意：
EQU不允许重复定义，即一个变量名只能使用一次
= 允许重复定义

如
CR EQU 0DH  
MOV	AL,CR  ;等价于 MOV  AL, 0DH

name 模块名
...
...
end 起始标号

注意：
name伪指令可缺省

$ 表示当前的偏移地址

如：jmp $+5 则跳转到当前指令的偏移地址加5的单元

在数据段中，可以在指定偏移地址的存储单元存放数据
在代码段中，可以从指定单元开始存放并执行指令

如 org 0020H 表示设置当前偏移地址为 0020H

mov bx,offset x	;将x单元的偏移地址送给bx
mov ax,offset start	;将标号start的偏移地址送给 ax

mov bx,seg x	;将x单元的段地址送给bx

mov bx,type x ;

注意：
如果 x 是字节单元，回送值为 1 
如果 x 是字单元，回送值为 2 

mov cx,length y

注意
y如果是dup()定义的，cx = 变量的个数

mov ax,size y

注意：
如果y是用dup()定义的，ax = 所有变量所占的总字节数

mov byte ptr [bx],10	;定义目的操作数为字节单元
mov word ptr [ax],20	;定义目的操作数为字单元

要与EQU配合

x label byte ;将x单元的类型定义为byte字节型

;

注意：
立即数是字节型还是字型
明确指令是字节操作还是字操作
目标寄存器不能是CS
立即数和存储器数不能直接送段寄存器
两个段寄存器间不能直接传送
两个存储单元之间不能直接传送

xchg ax,bx ;交换bx和ax的内容

注意:
必须有一个操作数是寄存器
操作数不能是立即数

注意：
操作单位是 字

注意：
操作单位是 字

PUSH  SP指令入栈的是该指令已修改的SP新值，
PUSH  ESP指令入栈的是执行该指令之前的ESP旧值，
POP ESP使用指令执行后的ESP内容.

通过AL寄存器中的索引值在表中查得表项内容并返回到AL中

使用这条指令之前，数据段中应有一个字节型表，该表起始地址的偏移量应放入BX，表索引值(要查找单元的位移量)放入AL

(AL) = ((BX)+(AL))

lea 寄存器,存储单元
把源操作数的有效地址送给指定的寄存器(除段寄存器)

注意：
源操作数必须是存储单元
等价的OFFSET后面只能跟变量，不能是变址(DI、SI)

lds 寄存器,双字存储单元
将双字存储单元的低字节送入寄存器，高字节送入DS段寄存器

les 寄存器,双字存储单元
将双字存储单元的低字节送入寄存器，高字节送入ES附加段寄存器

将al扩展到ax
逻辑意义就是AL的符号扩展到AH

将ax扩展到dx

目的操作数是一个存储单元中的数据
对操作数的限定同MOV指令

ADC执行加法运算时，会将CF位的值一起加到目标操作数中
如果必须处理非常大的、不能存放到双字数据长度（ADD可以使用的最大长度）中的整数，可以把值分割为多个双字数据元素，并且对每个元素执行独立的加法操作。
为了正确完成这个操作，必须检测每个加法操作的进位标志，如果进位标志被设置为1，就必须进位到下一对相加的数据元素

实现地址指针或循环次数的加1修改

sf = 1 结果为负
zf = 1 结果为 0
cf = 1 和的最高有效位，向前进位
cf = 0 
of = 1 两个操作数符号相同，结果符号与之相反
of = 0 

cf = 1 的最高有效位，向前进位
cf = 0 
of = 1 
of = 0 

字节乘法：被乘数放在al中，结果放在ax中
字乘法：被乘数放在ax中，结果放在dx、ax中
乘数写在指令中
注意：
源操作数只能是寄存器(reg)或存储器操作数(m)，不能是立即数

对CF和OF的影响是:
若乘积的高半部分(例字节型乘法结果的AH)为0则对CF和OF清0，否则置CF和OF为1

规则和mul一样

对CF和OF的影响是:若乘积的高半部分为低半部分的符号扩展，则对CF和OF清0,否则置CF和OF为1

格式：

div registre
div 内存单元


注意：

除数

有8位和16位两种，在一个寄存器中或内存单元中

被除数

默认放在AX或AX和DX中

如果除数为8位，被除数为16位，则默认放在AX中

如果除数为16位，被除数为32位，则放在DX和AX中，DX存放高16位，AX存放低16位

结果

如果除数为8位，则AL存储除法操作的商，AH存储除法操作的余数

如果除数为16位，则AX存储除法操作的商，DX存储除法操作的余数

为了保证被除数位数，需进行位扩展，使用CBW和CWD

跟在二进制加法指令之后,把AL中的结果调整成压缩BCD码并送回AL

标志:
AF、CF按以上情况设置,SF、ZF、PF按结果设置，OF位不确定

若是多字节加法，可以通过ADC指令把CF的进位加到高位中

跟在二进制减法指令之后,把AL中的结果调整成两位压缩BCD码并送回AL

跟在二进制减法指令之后
调整AL中的结果成为非压缩BCD码并送回AL
如果AL的低4位大于9，则AL+6，AH+1，AL的高4位清0，CF=1，AF=1

注意：
参与运算的操作数必须是ASCII码或非压缩BCD码

同加法

跟在乘法指令MUL之后,对AL中的结果进行调整，调整后的非压缩BCD码在AX中。（调整的过程相当于AL除10,商送AH，余数送AL）

除法指令之前，对AX中的非压缩BCD码进行调整,以便执行DIV指令之后，得到非压缩BCD码形式的商在AL中，余数在AH中

功能号送AH寄存器，
调用参数送所要求的位置，
再执行 INT  21H 系统功能调用中断

功能号：1
	返回参数：AL＝输入字符的ASCII值
	说明：等待从标准输入设备(通常为键盘)输入一个字符，把接收到的字符的ASCII值送给AL，并显示到显示器的当前光标位置。

功能号：2
	调用参数：DL＝字符的ASCII值
	说明：该输出功能使光标跟随移动，同时输出字符的ASCII值送给AL
	例：输出一个字符Y。
		MOV    AH , 2
		MOV    DL , "Y"
		INT      21H

显示字符串
	功能号：9
	调用参数：DS:DX指向要输出的以＄结尾的字符串首地址
	功能：输出字符串到标准输出设备
	说明：要输出的字符串必须以＄结束

PRINT	DB 'What is your name$'
MOV	AH,9
MOV DX,OFFSET PRINT
INT	21H

功能号：0AH
	调用参数：DS:DX指向自定义的输入缓冲区首地址
	功能：从标准输入设备(例如键盘)输入一串字符到用户定义的缓冲区，直到按下Enter键为止，回车符0DH占用一个字节单元，在接收的同时显示到屏幕上，如果超过缓冲区的最大容纳量，则忽略此字符并响铃警告
	说明：定义缓冲区的第一个字节单元为允许输入的最大字符数，第二个字节单元为实际键入的字符个数(系统自动填入)，第三个字节单元开始存放键入的字符

BUFFER 	DB 60	;定义缓冲区长度
			DB ?	;存放实际键入的字符数
			DB 61 DUP(?)	;存放实际输入的字符
			;设DS已是BUFFER的段基址
			MOV  AH,0AH	;接收一串字符
			LEA  DX,BUFFER
			INT  21H

	;实现换行
	MOV AH,2	;先输出 回车符
	MOV DL,0DH
	INT 21H
	
	MOV AH,2	;再输出 换行符
	MOV DL,0AH
	INT 21H

ASSUME CS:CODES,DS:DATAS

DATAS SEGMENT
	CRLF DB 0AH,0DH,'$'		;存放换行的存储单元
DATAS ENDS

CODES SEGMENT

start:
    MOV AX,DATAS
    MOV DS,AX
    LEA DX, CRLF     ;换行                   
    MOV AH, 09H							 
    INT 21H		

ASSUME CS:CODES,DS:DATAS

DATAS SEGMENT
	n DB 60,?,61 DUP(?)		;存放输入字符串的缓冲区
	
DATAS ENDS

CODES SEGMENT

START:    
		   	
    MOV DX,OFFSET n ;接收字符串，放入缓冲区
    MOV AH,10
    INT 21H
    	
    				;对输入的字符串进行处理，准备输出
    MOV AL,n+1       ;此时AL中存的是实际输入的字符的个数
    ADD AL, 2		;此时AL存的是整个输入缓存区的使用长度，也是回车符所在存储单元的偏移量
    MOV AH, 0		
    MOV SI, AX		;此时 SI 中存的是回车符所在存储单元的偏移量
    MOV n[SI], '$'	;用 $ 替换回车符
    			 
    
	MOV DX,OFFSET n	;已经在输入字符串后面加了 $ ，所以直接 输出输入的字符
    ADD DX,2		
    MOV AH,9							 
    INT 21H

如：
12除以10，商为1，余数为2，使用 1、2的字符形式组成12的字符形式

;输出数字36

ASSUME CS:CODES,DS:DATAS

DATAS SEGMENT

DATAS ENDS


CODES SEGMENT
   
START:
      MOV AX,DATAS
      MOV DS,AX
      
      MOV AX,36
   	  MOV BL,10
      DIV BL
      
      MOV BL,AH		;BL存放余数
      ADD BL,30H	;余数的ASCII码
	  ADD AL,30H	;商的ASCII码
	  
	  MOV AH,2		;先输出商
	  MOV DL,AL
	  INT 21H
	  
	  MOV AH,2		;再输出余数
	  MOV DL,BL
	  INT 21H


      MOV AX,4C00H
      INT 21H 
  

CODES ENDS
    END START
	

				;输出3位数，每次除10，取余
	MOV AX,res	 ; res中存的是3位数
	MOV Y,10
	
	DIV Y		;共3位数，求个位
	ADD AH,30H
	MOV g,AH	
	
	CBW			;拓展AL		
	DIV Y		;共2位数，求十位
	ADD AH,30H
	MOV shi,AH
	
	CBW
	DIV Y		;共1位数，求百位
	ADD AH,30H
	MOV bai,AH


	MOV AH,2
	MOV DL,bai
	INT 21H
	
	MOV AH,2
	MOV DL,shi
	INT 21H
	
	MOV AH,2
	MOV DL,g
	INT 21H
	 
    MOV AH,4CH
    INT 21H

ASSUME CS:CODES,DS:DATAS

DATAS SEGMENT
   buf DW 100 dup(?)       ;预留100个数组元素
   COUNT DW ?      ;数组元素个数
   error DB 13,10,'input error',13,10,'$'
DATAS ENDS


CODES SEGMENT

START:

	MOV AX,DATAS
	MOV DS,AX
	
	MOV SI,0
	MOV DI,0
	
	MOV BX,0
	
input:	

	MOV AH,1
	INT 21H
	
	.IF AL == 13	;回车退出
		JMP exit1
	.ELSEIF AL== 32	;空格输入下一组数据
		JMP lp1
	.ENDIF
	
	.IF AL < '0'
		JMP e
	.ELSEIF AL > '9'
		JMP e
	.ELSE			; 40 - 49 得到输入的真实数值，并把两位数存入BX中
		SUB AL,30H	;从ASCII码得到真实数字

      	CBW			;将AL拓展为AX
      	XCHG  AX, BX   

     	MOV   CX, 10
      	MUL   CX
      	XCHG  AX, BX
      	ADD   BX, AX
      	JMP input      
		
	.ENDIF
	
lp1:
	;存数据
	MOV buf[SI],BX
	MOV BX,0
	INC SI
	INC SI
	INC DI
	
	MOV COUNT,DI		;记录输入的个数
	
	JMP input
			
		
e:		;错误提示
	MOV AH,9
	LEA DX,error
	INT 21H	
	
	JMP finish
		
exit1:
	MOV buf[SI],BX  ;存入最后一个数
finish:	
	MOV AH,ACH
	INT 21H

格式：
AND mem,imm/reg ;
AND reg,imm/reg/mem ;

注意：
均为1才为1，否则为0
AND 指令可用于屏蔽某些位(用0相与)
AND指令设置CF = OF = 0，根据结果设置SF、ZF和PF状态，而对AF未定义

格式：
同上

注意：
有1为1，否则为0
OR 指令可用于置位某些位(用1相或)
标志的影响同AND指令

格式：
同上

注意：
相同为0，不同为1
XOR 指令可用于求反某些位(用1相异或)
标志的影响同AND指令

格式：
NOT reg/mem

注意：
取反
NOT指令是一个单操作数指令
NOT指令不影响标志位

对两个操作数执行逻辑与运算，结果不回送到目的操作数
标志的影响同 AND 指令

大写字母A-Z: 01000001B - 01011010B		
小写字母a-z: 01100001B - 01111010B
数字0-9:     00110000B - 00111001B

数字和字母的第6位不同，TEST AL，40H，第6位为0是数字，第6位为1是字母

大小写字母的第5位不同，TEST AL,20H，第5位为0是大写字母，第5位为1是小写字母

偶数的特点是换算成二进制的话最后一位必定是0(2的倍数),所以检测最后一位是否是0就能判断出是否是偶

有符号数的第一位用0代表正，1代表负

AND AL,0DFH

算术左移，最高位进入CF，最低位补0

算术右移，最低位进入CF，最高位不变

逻辑左移，最高位进入CF，最低位补0

逻辑右移，最低位进入CF，最高位补0

按照移入的位设置进位标志CF

对AF没有定义

如果移位次数为1，则按照操作数的最高符号位是否改变，相应设置溢出标志OF：如果移位前操作数最高位与移位后不同则OF = 1；否则OF = 0。

当移位次数大于1时，OF不确定

功能：
将操作数从一端移出的位返回到另一端形成循环，分成不带进位和带进位，分别具有左移或右移操作。

格式：
ROL reg/mem,1/CL	不带进位循环左移
ROR reg/mem,1/CL	不带进位循环右移
RCL reg/mem,1/CL	带进位循环左移
RCR reg/mem,1/CL	带进位循环右移

最高位移入CF，同时将操作数从首端移出的位返回到末端形成循环
如：
MOV AL,8AH	;10001010
ROL AL,1	;00010101

最低位移入CF，同时将操作数从末端移出的位返回到首端形成循环
如：
MOV AL,8AH	;10001010
ROR AL,1	;01000101

操作数和进位一起循环左移，CF移入最低位，同时最高位移入CF

操作数和进位一起循环右移，CF移入最高位，同时最低位移入CF

CMP i,j


JE 标号		;i == j 则跳转   检测 zf=1
JNE 标号		;i != j 则转移  检测 zf=0

JB 标号		;i < j 跳转	检测 cf=1
JNB 标号		;i >= j 跳转	检测 cf=0

JA 标号		;i > j 跳转   检测 cf=0且zf=0
JNA 标号		 ;i <=j 跳转	检测 cf=1或zf=1

JZ 标号		; i == j 跳转


注意：
e 表示 equal 等于
b 表示 below 小于
a 表示 above 大于
n 表示 no 否

JL	小于			SF!=OF且ZF=0
JLE 小于等于	   SF!=OF或ZF=1

JG				SF=OF且ZF=0
JGE				SF=OF或ZF=1

G greater 大
L less    小

JZ (JE) 	结果为0或相等   	ZF=1
JNZ (JNE) 	结果不为0或不相等  ZF=0

JC 		    结果有进位		 CF=1
JNC			结果无进位		CF=0

JS			结果为负		 SF=1
JNS			结果为正		 SF=0

JO			结果溢出		 OF=1
JNO			结果无溢出		OF=0

JP			结果为偶数个1	    PF=1
JNP			结果为奇数个1		PF=0

格式：JCXZ OPR
若CX=0则转移

显式：MOVS  DST, SRC	
隐式：MOVSB	  ;字节传送
     MOVSW		;字传送
     MOVSD		;双字传送

串指令可以处理累加寄存器和存储器操作数。对于存储器操作数应先建立地址指针:

	若为源操作数，则必须把DS：源串首地址放入SI寄存器，缺省情况寻址DS段

    若为目标操作数，则必须把ES：目标串首地址放入DI寄存器，不允许使用段超越前缀

串指令执行后自动修改地址指针SI、DI

 
   若DF＝0，则地址指针增量
   若DF＝1，则地址指针减量

串指令前可以加重复前缀REPE／REPZ、 REP或REPNE／REPNZ,使后跟的串指令重复执行

重复次数应事先初始化在计数器CX中

串操作指令的重复前缀和LOOP对应

REP :重复串操作，直到（CX） = 0

REPZ/REPE :结果为0或相等则重复。若CX != 0 且 ZF = 1，则重复，（CX） = （CX） - 1，直到（CX） = 0。如果结果不为0或不相等则提前退出，此时CX还没减为 0，SI和DI已经增量

REPNZ/REPNE :结果不为0或不相等则重复。若CX != 0 且 ZF = 0，则重复，（CX） = （CX） - 1，直到（CX） = 0。如果结果为0或相等则提前退出，此时CX还没减为 0，SI和DI已经增量

不影响标志位
MOVS  DST, SRC
REP MOVSB 以字节形式重复传送

结果不回送，改变标志位
CMPS
REPE CMPSB 以字节形式重复比较

结果不保存，影响标志位
在目的串中查找与AL、AX中相同或不同的字节或字
SCAS DST
SCASB

前面不加重复指令
不影响标志位
从源串中取出字或字节放入AL、AX中
LODS SRC
LODSB

将AL、AX内容存入目的串中
STOS DST

.IF 条件表达式 
               分支体
 [.ELSEIF 条件表达式 
               分支体 ]
 [.ELSE
            分支体 ]
 .ENDIF ;分支结束
 
 
 例
    .IF ax==5
             mov bx, ax
             mov ax, 0
    .ELSE
             dec  ax
    .ENDIF

           .WHILE 条件表达式 
                  循环体
           .ENDW
 UNTIL结构格式为：     >=类是按无符号数
           .REPEAT
                  循环体
           .UNTIL 条件表达式 
 UNTIL结构还有一种格式：
           .REPEAT 
                  循环体
           .UNTILCXZ [条件表达式] 
          ;cx←cx-1，直到cx=0或条件为真

.MODEL must precede this directive                           .MODEL必须在指令之前
[ELSE]IF2/.ERR2 not allowed : single-pass assembler          [ELSE]IF2/.ERR2不允许单独汇编
assembler limit : macro parameter name table full      汇编限制：宏参数名表已满
can ALIGN only to power of 2                    仅能对齐到2的幂
cannot access label through segment registers        在段寄存器中不能存取标记
cannot access symbol in given segment or group        在特定的段或类不能存取符号
cannot add memory expression and code label                  不能增加内存表达式和代码标记
cannot add two relocatable labels                         不能增加双重转移表标记
cannot define as public or external                     不能定义为公有或外部的
cannot find cvpack.exe                          找不到cvpack.exe
cannot find link.exe                              找不到连接程序
cannot have more than one ELSE clause per IF block            IF段只能有一个ELSE从句
cannot mix 16- and 32-bit registers                 不能结合16位和32位寄存器
cannot open file 不能打开文件
COFF error writing file                      COFF错误，正在写文件
constant expected                         连续预期
constant or relocatable label expected                       预期的转移表或连续的
constant value too large             连续标准太多
count must be positive or zero                              计数必须是零或明确的
count value too large                                        计数标准太多
directive must be in control block                指令必须在控制段
distance invalid for word size of current segment           当前区、段的大小命令无效
DUP too complex                          DUP太复杂
empty (null) string                没有字符串
END directive required at end of file                        END指令必须在文件结尾
error count exceeds 100; stopping assembly             错误数超过100，停止汇编
expected               预定义  
expression expected                   预期表达式
expression must be a code address             表达式必须是一个代码地址
expression too complex for .UNTILCXZ             .UNTILCXZ表达式太复杂
extra characters after statement                           附加的字符在声明之后
FATAL   严重错误
forced error                           强制错误
forced error : string blank                   字符串是空的
forced error : string not blank             字符串不是空的
forced error : strings equal              字符串是相同的
forced error : strings not equal              字符串不是相同的
forced error : symbol defined               符号已定义
forced error : symbol not defined            符号没有定义
forced error : value equal to 0                 标准等于零
forced error : value not equal to 0             标准不等于零
I/O error closing file I/O错误 正在关闭文件
I/O error reading file            I/O错误 正在读取文件
I/O error writing file I/O错误 正在写文件
identifier not a record                      没有记录标示符
identifier too long                       标识符太长
immediate operand not allowed                      当前操作数无法载入
incompatible CPU mode and segment size              不匹配的CPU模式和段尺寸
index value past end of string                              索引标准在字符串结尾之后
initializer magnitude too large for specified size        初始指定尺寸太大
instruction does not allow FAR direct addressing       指令不允许远直接寻址
instruction does not allow FAR indirect addressing      指令不允许远间接寻址
instruction does not allow NEAR indirect addressing      指令不允许近间接寻址
instruction form requires 80386/486                 指令需要80386/486指示   
instruction operand must have size             命令操作数必须有长度
instruction operands must be the same size        命令操作数必须是一样的长度
instruction or register not accepted in current CPU mode   当前CPU模式不认可的指令或寄存器
instruction prefix not allowed                    不允许的命令前缀
Internal Assembler Error                         内部汇编错误
invalid character in file                 文件里有无效字符
invalid command-line option           无效命令行参数
invalid debug and browser data; file exceeds line limit        不能排除故障和浏览数据；文件超过行限制
invalid instruction operands                   无效的指令操作数
invalid INVOKE argument                   无效的INVOKE符号
invalid numerical command-line argument                无效命令行参数
invalid operand for OFFSET                                    OFFSET操作数无效
invalid operand size for instruction            操作数长度对于指令无效
invalid scale value                                无效范围标准
invalid type expression                      无效的类型表达式
invalid use of external absolute                             由于完全外部的使用无效
invalid use of external symbol               使用了无效的外部符号
invalid use of register                     使用的寄存器无效
jump destination must specify a label           跳转目标必须指定一个标记
jump destination too far                            跳转目标太远
jump distance not possible in current CPU mode       跳转距离不适合当前CPU模式
line too long
line too long                  行太长
LOCK must be followed by a memory operation          LOCK指令必须跟在内存操作之后
memory operand not allowed in context                  内存操作数无法载入上下文环境
missing angle bracket or brace in literal         语句里找不到同样的括弧或框架
missing operand after unary operator                 一元运算符之后找不到操作数
missing operand for macro operator             找不到宏的操作数
missing single or double quotation mark in string          找不到单引号或双引号
missing source filename                                找不到源文件名
multiple base registers not allowed             不允许多重基础寄存器
multiple index registers not allowed           不允许多重标志寄存器
must be in segment block                  必须在区、段、块中
must be index or base register                  必须是基础或标志寄存器
nesting level too deep             嵌套过深
no operands allowed for this instruction          指令没有操作数
non-benign record redefinition                      没有利于记录的定义
nondigit in number                   没有总数
operand must be a memory expression             操作数必须是一个内存表达式
operand must be RECORD type or field            操作数必须是RECORD类型或域
operand must be relocatable                                  操作数必须是转移表
operands have different frames                  操作数存在不同的结构
operands must be in same segment              操作数必须在相同的段
operator expected                      预期操作数
out of memory              缺少内存
positive value expected                                      预期的明确的标准
PROC, MACRO, or macro repeat directive must precede LOCAL    PROC, MACRO, 或 macro repeat指令必须在LOCAL之前
real or BCD number not allowed                不允许real或BCD编码
record constants may not span line breaks                 连续记录不能超过行间隔
reserved word expected                      预期的保留字
segment attributes cannot change                        区、段属性不能更换
segment expected                                                预期的区段
segment or group not allowed                               区段或类型不允许
segment register not allowed in context            上下文不允许有寄存器
segment, group, or segment register expected                   预期的段，类型或段寄存器
SEVERE                              严重的错误
statement not allowed inside structure definition         声明不允许在结构里面
statement too complex                                   声明太复杂
statement too complex                    声明太复杂
string or text literal too long                 文本或字符串太长
structure alignment must be 1, 2, 4, 8, or 16             结构对齐必须是1，2，4，8或16
symbol redefinition                         符号已经定义
symbol type conflict                             符号类型冲突
syntax error                                语法错误
syntax error in expression                   表达式存在语法错误
syntax error in floating-point constant           不确定的指向中有语法错误
text item required                       必须的文本项
too many arguments                                     太多参数、定义、冲突
too many bits in RECORD                                      太多位在记录里
too many initial values for structure                太多结构的基础资料
undefined symbol                        符号没有定义
unmatched block nesting                   不正确的区、段嵌套
unmatched macro nesting            不正确的宏嵌套