Java教程

汇编语言(王爽第三版)笔记

本文主要是介绍汇编语言(王爽第三版)笔记,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

基础知识

1.每一种CPU(微处理器)都有自己的汇编指令集

2.汇编指令是机器指令的助记符, 与机器指令一一对应

3.地址总线宽度 => 寻址能力 数据总线宽度 => 数据传送时的数据传输量 控制总线宽度 => 系统中其他器件的控制能力

4.逻辑存储器 => 内存地址空间 => 受CPU寻址能力的限制(地址总线) => 分配
在这里插入图片描述

寄存器

8086CPU所有寄存器都是16位的, 可以放两个字节, 有14个寄存器

1.通用寄存器: AX BX CX DX 为了兼容上一代, 都可以分为两个独立的8位寄存器H(igh) L(ow) AH AL BH BL CH CL DH DL

2.字节 byte, 一个字节由8bit组成 字 word, 一个字由两个字节组成, 分别称为高位字节和低位字节

3.数据传输或运算时, 两个操作对象的位数要一致

4.物理地址 => 8086CPU20位地址总线 => 16位结构 => 内部两个16位地址合成为一个20位的物理地址 => 段地址+偏移地址 => 地址加法器 => 物理地址=段地址*16+偏移地址 => *16即左移4位
在这里插入图片描述
在这里插入图片描述
5.基础地址+偏移地址 = 物理地址

6.段的概念 => 内存并没有分段 => 段的划分来自CPU => 可以分段管理内存

7.段地址*16必然是16的倍数 => 所以一个段的起始地址也一定是16的倍数

8.偏移地址位16位, 寻址能力为64KB => 一个段的长度最大为64KB
9.在这里插入图片描述
10.段寄存器: CS DS SS ES

11.CS:代码段寄存器, IP:指令指针寄存器
12.
在这里插入图片描述
13.
在这里插入图片描述
14,8086CPU的工作过程:
在这里插入图片描述
15.在这里插入图片描述
16.CS,IP的值不能通过mov指令修改 => jmp 段地址:偏移地址

jmp 3:0B16 ;执行后CS=0003H, IP=0B16H, CPU将从0B46H处读取指令 jmp ax ;仅修改IP的内容,
jmp 某一合法寄存器,把寄存器的赋给IP

18.代码段 => 代码存放一组连续, 起始地址为16的倍数的内存单元中 => CS:IP指向代码段第一条指令的首地址

19.DosBox => debug.exe => debug
在这里插入图片描述

寄存器(内存访问)

1.内存中字的存储 => 两个内存单元 => 低地址单元存放低位字节, 高地址单元存放高位字节 => 如0,1两个单元存放4E20H, 0存放20H, 1存放4EH => 这两个单元称为0地址字单元 => 起始地址为N, 称为N地址字单元
2.

mov bx, 1000h
mov ds, bx
mov al, [0] ;将内存单元10000的数据送入al
mov ax,[0] ;起始地址为10000的内存字单元数据送入ax

3.DS寄存器 => 存放要访问的数据的段地址 => mov bx 1000H => mov ds, bx => 需要寄存器中转

8086不支持直接向段寄存器送入数据

4.mov al, [0] => [0]表示一个内存单元 => 0表示偏移地址 => 段地址来自DS寄存器的数据

5.mov ax, [0] => 则送入ax一个字型数据
6.
在这里插入图片描述
7.mov 段寄存器, 寄存器 => mov 寄存器, 段寄存器

8.mov 内存单元, 寄存器 => mov 内存单元, 段寄存器 => mov 段寄存器, 内存单元

9.在这里插入图片描述
10.数据段 => 将一段内存当作数据段 => ds存放数据段的段地址

11.栈 => LIFO => Last In First Out => PUSH 入栈 => POP 出栈 => 都以字为单位进行

12.SS存放栈顶的段地址, SP存放偏移地址 => SS:SP指向栈顶元素 类似 CS:IP指向指令

13.push ax => SP=SP-2 => ax送入SS:SP指向的内存单元处 => 入栈时, 栈顶从高地址向低地址方向增长 => pop ax相反 => SP=SP+2, SS:SP指向当前栈顶下面的字单元, 以此单元为新的栈顶

14.栈空时, 不存在栈顶元素 => SS:SP指向最底部单元下面的单元

15.栈顶超过栈空间 => 8086没有解决方案, 需要自己注意栈空间大小

16.push 寄存器 => 将一个寄存器中的数据入栈 => push 段寄存器 => push 内存字单元

17.pop 寄存器 => 用一个寄存器接收出栈的数据 => pop 段寄存器 => pop 内存字单元

18.push, pop是一种内存传送指令

;将10000H~1000FH当作栈, 将AX,BX,DS中的数据入栈

;初始化栈顶
mov ax, 1000h
mov ss, ax	;8086不支持直接向段寄存器送入数据
mov sp, 0010h

push ax
push bx
push ds

;将ax,bx设值, 清零后恢复
mov ax, 001ah
mov bx, 001bh
push ax
push bx
sub ax, ax	;2bytes
mov bx, 0	;3bytes
pop bx
pop ax

20.栈段 => 10000H1FFFFH当作栈段, 初始状态为空, 则SS=1000H, SP=? => SP= FFFE+2=0000 => SS=1000, SP=0000 => 所以栈最大为0FFFF, 64KB => 当栈满时, 再次压入栈, 将环绕覆盖原来栈中的内容

21.在这里插入图片描述
22.在这里插入图片描述
23.在这里插入图片描述
24.

mov ax, 1000h
mov ds, ax
mov ax, 2000h
mov ss, ax
mov sp, 10h
push [0]
push [2]
push [4]
push [6]
push [8]
push [A]
push [C]
push [E]

第一个程序

1.伪指令由编译器执行, 汇编指令由CPU执行

assume cs:codesg	;将代码段codesg与段寄存器cs联系起来

;伪指令*** segment ~ *** ends 成对使用
codesg segment

	mov ax, 0123h
	mov bx, 0456h
	add ax, bx
	add ax, ax

	mov ax, 4c00h
	int 21h		;程序返回, 程序运行完毕后将CPU的控制权交出
	
codesg ends

end		;伪指令, 汇编程序的结束标记

2.用masm.exe进行编译, 会产生3个输出文件, 目标文件.obj (列表文件.lst, 交叉引用文件.crf)

3.用link.exe进行连接得到可执行文件

4.连接的作用有: 描述信息在这里插入图片描述
5.masm 路径\文件名; link 路径\文件名; 忽略中间文件的生成
6.
在这里插入图片描述
7.debug *.exe
在这里插入图片描述
8.exe文件的加载过程
在这里插入图片描述
9. ds=075A => PSP地址为075A:0 => 程序地址为076A:0 cs:ip=076A:0 => 指向程序的第一条指令 cx => 存放程序的长度

10.要用p命令执行int 21, 程序会返回到debug中, q命令退出debug返回到command中

[BX]和loop指令

1.在这里插入图片描述
2.在这里插入图片描述
3.[0]表示内存单元 => 0是偏移地址 => 段地址在ds中 => 单元的长度由具体指令中的其他对象如寄存器指出

4.[bx]也表示一个内存单元 => 偏移地址在bx中

5.inc bx => (bx)+1

6.loop 标号 => CPU执行时 => (cx)=(cx)-1 => 判断cx中的值,不为0则转到标号处执行程序,为0向下执行(即cx存放循环次数)

mov cx, 循环次数
s: 循环执行的程序段
loop s

8.在汇编源程序中数据不能以字母开头, 要在前面加上0

9.g 代码地址跳过单步执行过程, 在遇到loop指令时, p命令自动重复执行loop

10.在汇编源程序中不可以使用类似mov ax, [0]的指令, masm编译器会当作mov ax, 0来处理 => 可以用bx间接给出内存单元的偏移地址 => mov ax, ds:[0]

;累加ffff:0~ffff:b的数据
assume cs:code

code segment
	     mov  ax, 0ffffh
	     mov  ds, ax
	     mov  bx, 0     	;ds:bx

	     mov  dx, 0     	;初始化累加寄存器

	     mov  cs, 12    	;初始化循环计数寄存器
	s:   mov  al, [bx]
	     mov  ah, 0
	     add  dx, ax
	     inc  bx
	     loop s

	     mov  ax, 4c00h
	     int  21h
code ends

end

12.找到一段空的安全的内存使用 => 一般情况使用0:200~0:2ff这段空间

;0:200~0:23f = 0020:0~0020:3f
;在这个段中分别写入0~63
assume cs: code

code segment
	     mov  ax, 0020h
	     mov  ds, ax
	     mov  bx, 0h

	     mov  cx, 40h	;64
	s:   mov  ds:[bx], bl	;8位对8位
	     inc  bx
	     loop s

	     mov  ax, 4c00h
	     int  21h
code ends

end

包含多个段的程序

1.内存空间的获取 => 加载程序时为程序分配 => 在源程序中定义段
2.

; 将定义的数据逆序排放
assume cs:code

code segment
	;dw => define word 定义了8个字型数据
	;在cs得到段地址, 因为定义在代码段的开始所以偏移地址为0,2,4...
	;代码段前16个字节存储dw定义的数据, 所以cs:ip, ip应该设置为10h, 或者在end后表明程序的入口
	;定义16个字型数据, 在后面的代码中当作栈来使用
	      dw   0123h, 0456h, 0789h, 0abch, 0defh, 0fedh, 0cbah, 0987h
	      dw   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
	
	start:
	;ss:sp => cs:30
	      mov  ax, cs
	      mov  ss, ax
	      mov  sp, 30h
	
	      mov  bx, 0
	      mov  cx, 8
	s:    push cs:[bx]
	      add  bx,2
	      loop s

	      mov  bx, 0
	      mov  cx, 8
	s0:   pop  cs:[bx]
	      add  bx, 2
	      loop s0

	      mov  ax, 4c00h
	      int  21h
code ends

end start	;end 标号表明程序的入口

3.可执行文件=描述信息+程序 => 描述信息是编译, 连接对伪指令进行处理得到的信息
4.

;重构2, 将代码 数据 栈分开
assume cs:code, ds:data, ss:stack

data segment
	     dw 0123h, 0456h, 0789h, 0abch, 0defh, 0fedh, 0cbah, 0987h
data ends

stack segment
	      dw 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
stack ends

code segment
	start:
	      mov  ax, stack
	      mov  ss, ax
	      mov  sp, 20h  ;stack

	      mov  ax, data
	      mov  ds, ax

	      mov  bx, 0
	      mov  cx, 8
	s:    push [bx]
	      add  bx,2
	      loop s

	      mov  bx, 0
	      mov  cx, 8
	s0:   pop  [bx]
	      add  bx, 2
	      loop s0

	      mov  ax, 4c00h
	      int  21h
code ends

end start

更灵活的定位内存的方法

1.and => 逻辑与指令
在这里插入图片描述
2.or => 逻辑或指令
在这里插入图片描述
3.db => define byte 以字符形式给出数据db ‘Unix’ mov al, ‘a’

4.ASCII => A=41h , a= 61h => 65,97 => 相差20h, 就是二进制第六位32 => 二进制倒数第六位是0是大写, 是1是小写

5.[bx+idata] => mov ax, [200+bx] => mov ax, 200[bx] => mov ax, [bx].200 => 都是指偏移地址为(bx)+200

assume cs:code, ds:data

data segment
	     db 'BasiC'
	     db 'MiniX'
data ends

code segment
	start:mov  ax, data
	      mov  ds, ax
	
	;[bx+idata]的写法, 类似数组
	      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
	      
	;原本写法
	; s:      mov al, [bx]
	;         and al, 11011111b   ;将第六位置0,即小写变大写
	;         mov [bx], al
	;         inc bx
	;         loop s

	;         mov bx, 5
	;         mov cx, 5
	; s0:     mov al, [bx]
	;         or al, 00100000b    ;第六位置1,大写变小写
	;         inc bx
	;         loop s0

	      mov  ax, 4c00h
	      int  21h
code ends

7.si, di是8086中和bx功能相近的寄存器 => 不能分成2个8位寄存器来使用

8.[bx+si] [bx+di] => mov ax, [bx+si] => mov ax, [bx] [si]

9.mov ax, [bx+si+200] => mov ax, 200[bx] [si] => mov ax, [bx].200[si] => mov ax, [bx] [si].200

10.嵌套循环时 => 将外层循环的cx值保存起来 => 保存在闲置的寄存器中 => 开辟一段内存空间保存dw 0 => 定义一个栈段来存储

assume cs:code, ss:stack, ds:data

;每个单词的前四个字母改成大写字母
data segment
    db '1. display      '
    db '2. brows        '
    db '3. replace      '
    db '4. modify       '
data ends

stack segment
    dw 0, 0, 0, 0, 0, 0, 0, 0
stack ends

code segment
    start:  mov ax, stack
            mov ss, ax
            mov sp, 16h

            mov ax, data
            mov ds, ax

            mov bx, 0
            mov cx, 4
    s:      push cx
            mov cx, 4
            mov si, 0
    s0:     mov al, [bx+si]
            and al, 11011111b
            mov [bx+si], al
            inc si
            loop s0

            add bx,16
            pop cx
            loop s

            mov ax, 4c00h
            int 21h
code ends

end start

数据处理的两个基本问题

1.寄存器 => reg => ax, bx, cx, dx, ah, al, bh, bl, ch, cl, dh, dl, sp, bp, si, di

2.段寄存器 => sreg => ds, cs, ss, es

3.bx, si, di, bp => 寻址 => 单独出现 => bx, si => bx, di => bp, si => bp, di

4.使用bp时没有显性给出段地址 => 段地址默认在ss中

5.在这里插入图片描述

数据位置的表达

1.立即数, 包含在机器指令中的数据, 执行前在CPU的指令缓冲器中 => 1, 20h, 0011b, ‘a’
2.寄存器
3.段地址SA+偏移地址EA

寻址方式

1.直接寻址 => [idata]
2.寄存器间接寻址 => [bx]
3.寄存器相对寻址 => 结构体 [bx].idata, 二维数组 idata[bx], [bx] [idata]
4.基址变址寻址 => [bx] [si]
5.相对基址变址寻址 => 二维数组 idata[bx] [si], 结构体 [bx].idata[si]

指明要处理的数据的长度

1.寄存器名直接指明 => ax, al
2.X ptr => word ptr, byte ptr => mov word ptr ds:[0], 1
3.其他方法 => 有些指令默认了访问数据的长度 => push, pop只进行字操作

struct company {
    char cn[3];     //名称
    char hn[9];     //总裁姓名
    int pm;         //排名
    int sr;         //收入
    char cp[3];     //产品
};

// 存储在seg:60
struct company dec = {"DEC", "Ken Olsen", 137, 40, "PDP"};

int main(void) {
    /*
        mov ax, seg
        mov ds, ax
        mov bx, 60h     ;首地址
    */
    int i;      
    dec.pm = 38;            // mov word ptr [bx].0ch, 38
    dec.sr = dec.sr+70;     // add word ptr [bx].0eh, 70
    i = 0;                  // mov si, 0
    dec.cp[i] = 'V';        // mov byte ptr [bx].10h[si], 'V'
    i++;                    // inc si
    dec.cp[i] = 'A';        // mov byte ptr [bx].10h[si], 'A'
    i++;                    // inc si
    dec.cp[i] = 'X';        // mov byte ptr [bx].10h[si], 'X'

    return 0;
}

10.div => 除法指令 => div reg => div 内存单元
在这里插入图片描述
11.

; 除法100001/100 
; 100001>65535 dx+ax存放, 186A1h
mov dx, 1
mov ax, 86A1h
mov bx, 100
div bx
; 商(ax)=03E8h
; 余数(dx)=1

; 1001/100
mov ax, 1001
mov bl, 100
div bl
; 商(ah)=0Ah
; 余数(al)=1

12.dd => 定义dword(double word)双字型数据

13.dup => 与db,dw,dd配合使用 => 进行数据的重复 => db 3 dup(0, 1, 2) 定义了9个字节相当于db 0,1,2,0,1,2,0,1,2 => db/dw/dd 重复次数 dup (数据)

assume cs:code, ds:data, es:table

data segment
	;年份21*4 0~83
	     db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
	     db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
	     db '1993','1994','1995'
	;收入21*4 84~167
	     dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
	     dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
	;雇员人数21*2 168~209
	     dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
	     dw 11542,14430,45257,17800
data ends

;将数据放到table里
table segment
	      db 21 dup ('year summ ne ?? ')
table ends

code segment
	start:mov  ax, data
	      mov  ds, ax
	      mov  bx, 0

	      mov  ax, table
	      mov  es, ax
	      mov  si, 0
	      mov  di, 0

	      mov  cx, 21
	s:    mov  ax, [bx]
	      mov  es:[si], ax
	      mov  ax, [bx+2]
	      mov  es:[si+2], ax    	;放入年份

	      mov  ax, [bx+84]      	;低位收入
	      mov  dx, [bx+86]      	;高位收入
	      mov  es:[si+5], ax    	;放入低位收入
	      mov  es:[si+7], dx    	;放入高位收入

	      div  word ptr [di+168]	;计算平均收入
	      mov  es:[si+13], ax   	;放入平均收入

	      mov  ax, [di+168]
	      mov  es:[si+10], ax   	;放入雇员
            
	      add  bx, 4            	;年份
	      add  si, 16           	;table
	      add  di, 2            	;雇员
	      loop s

	      mov  ax,4c00h
	      int  21h
code ends

end start

转移指令的原理

1.可以修改ip或同时修改cs:ip的指令叫做转移指令 => 控制CPU执行内存中某处代码的指令

2.段内转移 => 只修改ip => jmp ax => 短转移ip范围-128127 => 长转移范围-3276832767

3.段间转移 => 修改cs:ip => jmp 1000:0 形如此类指令只能在debug中使用

4.offset => 取得标号的偏移地址 => mov ax, offset start => mov ax, 0

5.jmp short 标号 => 转到标号处执行指令 => 段内短转移修改范围-128~127

6.在一般的汇编指令中的立即数, 无论是数据还是偏移地址都会在机器指令中出现
在这里插入图片描述
7.CPU在执行jmp指令时不需要转移目的地址, 就可以实现对ip的修改 => jmp指令包含到目的地址的位移
在这里插入图片描述
8.jmp下一个指令的地址 - 标号处地址 = 偏移位移地址
在这里插入图片描述
9.在这里插入图片描述
10.jmp far ptr 标号 => 段间转移 => (cs)=标号所在段地址, (ip)标号所在段的偏移地址

11.jmp word ptr 内存单元地址(段内转移) => 内存单元地址存放专一的目的偏移地址 => (ip)=(字单元地址)

12.jmp dword ptr 内存单元地址(段间转移) => (cs)=(内存单元地址+2), (ip)=(内存单元地址)

13.有条件转移指令, 所有有条件转移指令都是短转移=> jcxz 标号 => 如果(cx)=0,转到标号处执行

14.所有循环指令都是短转移 => loop 标号

15.短转移位移超界编译时会报错

16.80*25彩色字符模式缓冲区 B8000H~BFFFFH
每行可以显示80个字符, 1个字符2个字节
低位字节存放ASCII码, 高位字节存放字符属性属性字节格式
在这里插入图片描述
17.

;在屏幕中间分别显示绿色、绿底红色、白底蓝色的字符串 'welcome to masm!'。
;00000010 02h  00100100 24h  01110001 71h

assume cs:code, ds:data, ss:stack

data segment
	     db 'welcome to masm!'	;16 byte
	     db 02h, 24h, 71h
data ends

stack segment
	      dw 8 dup (0)
stack ends

code segment

	start:mov  ax, data
	      mov  ds, ax

	      mov  ax, stack
	      mov  ss, ax
	      mov  sp, 10h

	      mov  ax, 0b800h      	;显示区段
	      mov  es, ax
        
	      mov  bx, 780h        	;屏幕中间第12行
	      mov  si, 10h         	;指向颜色

	      mov  cx, 3
	s:    mov  ah, ds:[si]     	;颜色
	      push cx
	      push si

	      mov  cx, 16
	      mov  si, 64          	;160列中间就是(160-32)/2=64
	      mov  di, 0

	s0:   mov  al, ds:[di]     	;data段的字符
	      mov  es:[bx+si], al  	;低位存放字符
	      mov  es:[bx+si+1], ah	;高位存放属性
          
	      add  si, 2
	      add  di, 1
	      loop s0

	      pop  si
	      pop  cx
	      add  si, 1           	;指向下一个颜色
	      add  bx, 0a0h        	;指向下一行 160=0a0h
	      loop s

	      mov  ax, 4c00h
	      int  21h
code ends

end start

在这里插入图片描述

CALL和RET指令

1.ret => 使用栈中的数据修改ip => 近转移 => 类似于pop ip

2.retf => 使用栈中的数据修改cs:ip => 远转移 => 类似于pop ip, pop cs

3.call 标号 => 将当前ip压栈后, 转到标号处执行命令 => 类似于push ip, jmp near ptr 标号
call指令与jmp类似, 对应的机器指令中没有转移目的地址, 而是相对于当前ip的转移位移

4.call far ptr 标号 => push cs, push ip, jmp far ptr 标号

5.call 16位reg => push ip, jmp reg

6.call word ptr 内存单元地址 => push ip, jmp word ptr 内存单元地址

7.call dword ptr 内存单元地址 => push cs, push ip, jmp dword ptr 内存单元地址

8.mul => 乘法指令 => mul reg => mul 内存单元 => 与除法指令类似
在这里插入图片描述
9.

;计算100 * 10
mov al, 100
mov bl, 10
mul bl
;计算100 * 10000
mov ax, 100
movbx, 10000
mul bx

10.call和ret指令可以实现模块化编程, 比如:
在这里插入图片描述
在这里插入图片描述
为了避免寄存器冲突, 把子程序要用的寄存器全都入栈结束后出栈
在这里插入图片描述

标志寄存器

在这里插入图片描述
1.flag寄存器
在这里插入图片描述
2.ZF标志 => zero => 相关指令执行后结果为0, zf=1

3.PF标志 => 奇偶标志位parity => 结果中所有bit位1的个数为偶数, pf =1

4.SF标志 => 符号标志位signal => 结果为负sf=1 => 对有符号计算结果的记录

5.CF标志 => 进位标志位carry => 进行无符号运算时,记录了最高有效位更高位的进位值或者借位值

6.OF标志 => 移除标志位overflow => 有符号运算超过了机器所能表示的范围

在这里插入图片描述
8.
在这里插入图片描述
9.cmp ax,bx => 做减法运算(ax)-(bx) => 不保存结果,影响标志寄存器
在这里插入图片描述
10.在这里插入图片描述
11.

;一些条件转移指令
;根据无符号数的比较结果进行转移
je 			zf=1		;equal = 
jne 		zf=0		;not equal !=
jb 			cf=1		;below <
jnb 		cf=0		;not below >
ja			cf=0且zf=0	;above	>
jna			cf=1或zf=1	;not above <=

12.DF标志 => 方向标志位direction => 在串处理指令中, df=0, 每次操作后si, di递增 => df=1, 递减 串处理指令 => movsb => 传送一个字节 => 将ds:si指向的内存单元的字节送入es:si中
在这里插入图片描述
movsw => 传送一个字 => 传送完递增或递减2 一般都和rep连在一起使用, 根据cx的值来重复执行传送指令 => rep movsb => rep movsw

cld 将df置0 std 将df置1
13.

;将F000h段中最后16个字节复制到data段中
; ds:si  =>  es:di
data segment
	db 16 dup (0)
data ends

; ds:si => es:si
mov ax, 0f000h
mov ds, ax
mov si, 0ffffh
mov ax, data
mov es, ax

mov di, 15
mov cx, 16
std
rep movsb

14.pushf popf => 将flag标志寄存器的内容压栈, 出栈数据送入

15.debug中的表示在这里插入图片描述

内中断

1.CPU内部中断源及中断类型码
除法错误: 0
单步执行: 1
执行into指令: 4
执行int指令: int n , n为字节型立即数是提供给CPU的中断类型码
2.产生中断 => 中断信息包含表示中断源的类型码 => 查找中断向量表 => 得到中断处理程序的入口地址 => 设置cs:ip

8086中断向量表指定放在内存0000:0000~0000:03FF的1024个单元中, 一个表项占两个字, 高地址字存放段地址,
低地址字存放偏移地址

3.8086收到中断信息后引发的中断过程
得到中断类型码 N
flag寄存器的值入栈 pushf
设置标志寄存器第8位TF和第九位IF的值为0 tf=0, if=0
cs内容入栈, ip内容入栈 push cs, push ip
从内存地址为中断类型码 *4和 中断类型码 *4+2的两个字单元中读取中断处理程序的入口地址设置cs:ip (ip)=(N * 4) (cs) = (N * 4 +2)
硬件自动执行的中断过程, 程序员无法改变这个过程中做的工作

4.中断处理程序的编写方法
在这里插入图片描述
5.iret => pop ip, pop cs, popf

6.中断向量表一般占不满 => 可以使用0000:0200~0000:02FF这段内存

7.单步中断 => 为了单步跟踪程序的执行过程 => debug
在这里插入图片描述
8.ss:sp设置应该连续完成 => 设置ss后即使发生中断CPU也不会响应

;0号中断 除法溢出时屏幕中间显示字符串"divide error!"
assume cs:code

code segment
	start:  mov  ax, cs
	        mov  ds, ax
	        mov  si, offset d0             	;源地址ds:si

	        mov  ax, 0
	        mov  es, ax
	        mov  di, 200h                  	;目的地址es:di 0:200

	        mov  cx, offset d0end-offset d0	;传输长度

	        cld                            	;正向
	        rep  movsb

	        mov  ax, 0
	        mov  es, ax
	        mov  word ptr es:[0*4], 200h
	        mov  word ptr es:[0*4+2], 0    	;设置中断向量表,0中断

	        mov  ax, 4c00h
	        int  21h
	d0:     jmp  short d0start
	        db   'divide error!'

	d0start:mov  ax, cs
	        mov  ds, ax
	        mov  si, 202h                  	;ds:si指向字符串

	        mov  ax, 0b800h
	        mov  es, ax
	        mov  di, 12*160+36*2           	;es:di指向显存, 屏幕中间

	        mov  ah, 24h                   	;颜色属性
	        mov  cx, 13                    	;字符串长度
	s:      mov  al, [si]
	        mov  es:[di], al
	        mov  es:[di+1], ah
	        inc  si
	        add  di, 2
	        loop s

	        mov  ax, 4c00h                 	;返回dos
	        int  21h
	d0end:  nop								;计算程序长度
code ends

end start

int指令

1.在这里插入图片描述
2.在这里插入图片描述
3.和硬件设备相关的dos中断例程中, 一般都掉用了BIOS的中断例程

4.BIOS和DOS提供的中断例程安装到内存中
在这里插入图片描述
5.

;BIOS提供的int 10h中断例程
;在屏幕的5行12列显示3个红底高亮闪烁绿色的'a'
assume cs:code

code segment
    mov ah, 2       ;内部子程序的编号2,置光标
    mov bh, 0       ;第0页
    mov dh, 5       ;行号
    mov dl, 12      ;列号
    int 10h

    mov ah, 9           ;光标处显示字符
    mov al, 'a'         ;字符
    mov bl, 11001010b   ;颜色属性
    mov bh, 0
    mov cx, 3           ;字符重复个数
    int 10h

    mov ax, 4c00h
    int 21h         
code ends

end 
;DOS提供的int 21h中断例程
;子程序4ch 程序返回
;子程序9 光标位置显示字符串
;要显示的字符串以$作为结束符, ds:dx指向字符串
assume cs:code

data segment
	db 'Welcome to masm', '$'
data ends

code segment
	start:	mov ah, 2
			mov bh, 0
			mov dh, 5
			mov dl, 12
			int 10h
			
			mov ax, data
			mov ds, ax
			mov dx, 0
			mov ah, 9
			int 21h
			
			mov ax, 4c00h
			int 21h
code ends

端口

1.各种存储器都和CPU的地址,数据,控制线相连, 在操控这些存储器时当作内存来对待 => 总地看作一个由若干存储单元组成的逻辑存储器 => 将这个逻辑存储器称作内存地址空间
2.在这里插入图片描述
3.这些芯片中都有一组可以由CPU读写的寄存器 => CPU在对他们进行读写的时候都是通过控制线向他们所在的芯片发出端口读写命令 => CPU将这些寄存器当作端口进行统一编址, 建立了一个统一的端口地址空间, 每一个端口在地址空间中都有一个地址

4.在这里插入图片描述
5.端口地址和内存地址一样通过地址总线来传送 => 64KB => 端口号: 0~65535

6.端口读写指令in从端口读入 out向端口写入

7.CPU访问内存 mov ax, ds:[8]

CPU通过地址线将地址信息8发出
CPU通过控制线发出读内存命令, 选中存储器芯片, 通知它要读数据
存储器将8号单元的数据通过数据线送到CPU

8.CPU访问端口 in al, 60h

CPU通过地址线将地址信息60h发出
CPU通过控制线发出端口读命令, 选中端口所在芯片, 通知它要读数据
端口所在的芯片将60h端口的数据通过数据线送到CPU
9.在这里插入图片描述

;CMOS RAM不断电保存时间和系统配置信息
;70h地址端口 71h数据端口读写CMOS RAM
assume cs:code

code segment
    mov al, 2
    out 70h, al
    in al, 71h      ;读取CMOS RAM的2号单元的内容

    mov al, 2
    out 70h, al
    out 71h, 0      ;向CMOS RAM的2号单元写入0
code ends

11.逻辑移位指令 => shl shr
最后移除的1位写入cf中
最低位/最高位用0补充
移动多位时, 移动位数放在cl中

12.CMOS RAM中用BCD码存放当前时间: 年 月 日 时 分 秒 6个信息各1个字节, 高4位BCD码存放十位, 低4位存放个位, 存放单元分别为:
在这里插入图片描述

外中断

1.CPU通过端口和外设进行联系

2.外中断源
(1)可屏蔽中断 => 检测到中断时 => if=1响应中断, if=0不响应可屏蔽中断 => 所以在处理内中断中断过程中将if置0 => sti 置if为1 cli 置if为0

与内中断类似, 只在取中断类型码时有区别, 可屏蔽中断通过地址线送入CPU, 中断类型码是在CPU内部产生的

(2)不可屏蔽中断 => 中断类型码固定为2, 不需要取 =>但几乎所有外设引起的中断都是可屏蔽中断

3.键盘处理
按下一个按键 => 产生扫描码 => 送入相关芯片寄存器端口地址为60h => 通码
松开 => 扫描码 => 60h => 断码
扫描码长度一个字节 => 通码最高位0, 断码最高位1
断码 = 通码+80h => 最高位变为1
键盘的输入到达60h端口时 => 相关芯片向CPU发出中断类型码为9的可屏蔽中断 => CPU执行int 9中断例程处理键盘输入

4.BIOS提供了int 9中断例程
(1)读出60h端口的扫描码
(2)字符区的会将该扫描码和ASCII码送入内存中的BIOS键盘缓冲区
在这里插入图片描述
(3)控制键或切换键会将其转变为状态字节写入内存中存储状态字节的单元
在这里插入图片描述
(4)对键盘系统进行相关的控制
(5)

;安装一个新的int 9中断例程
;功能:在DOS下,按下“A”键后,除非不再松开,如果松开,就显示满屏幕的“A”,其他的键照常处理

assume cs:code

stack segment
	      db 128 dup (0)
stack ends

code segment
	start:  
	        mov   ax, stack
	        mov   ss, ax
	        mov   sp, 128

	;di:si => es:di
	        push  cs
	        pop   ds
	        mov   ax, 0
	        mov   es, ax
	        mov   si, offset int9
	        mov   di, 204h

	        mov   cx, offset int9end-offset int9
	        cld
	        rep   movsb

	;原int 9地址入口放到0:200
	        push  es:[9*4]
	        pop   es:[200h]
	        push  es:[9*4+2]
	        pop   es:[202h]

	;新的int 9放到中断向量表中
	        cli
	        mov   word ptr es:[9*4], 204h
	        mov   word ptr es:[9*4+2], 0
	        sti

	        mov   ax, 4c00h
	        int   21h
	int9:   
	        push  ax
	        push  bx
	        push  cx
	        push  es

	        in    al, 60h
	        pushf
	        call  dword ptr cs:[200h]
        
	        cmp   al, 1eh+80h                   	;a的扫描码
	        jne   int9ret

	        mov   ax, 0b800h
	        mov   es, ax
	        mov   bx, 0
	        mov   al, 'A'
	        mov   cx, 2000
	s:      
	        mov   byte  ptr es:[bx], al
	        add   bx, 2
	        loop  s
	int9ret:
	        pop   es
	        pop   cx
	        pop   bx
	        pop   ax
	        iret
	int9end:nop
code ends

end start

直接定址表

1.地址标号: => 仅标记地址 => 只能在代码段中使用

2.数据标号 => 不加冒号 => 标记了存储单元的地址和长度 => 想在代码段中直接用数据标号访问数据,用assume将标号所在段与一个段寄存器连接起来满足编译器的需要

;累加a里的数据, 结果存到b中
assume cs:code, ds:data

data segment
	a db 1, 2, 3, 4, 5, 6, 7, 8
    b dw 0
data ends

code segment
	start:
		mov ax, data	;指明段ds
		mov ds, ax
		
		mov si, 0
		mov cx, 8
	s:
		mov al, a[si]
		mov ah, 0
		add b, ax
		inc si
		loop s
		
		mov ax, 4c00h
		int 21h
code ends

4.seg 标号 => 取得段地址

5.在这里插入图片描述
相当于c dw offset a, offset b
6.在这里插入图片描述
7.可以通过依据数据, 直接计算出所要找的元素的位置的表 => 称为直接定址表

; 安装一个新的int 7ch中断例程,为显示输出提供如下功能子程序。
; (1)清屏 (2)设置前景色;(3)设置背景色;(4)向上滚动一行。
; 入口参数说明:
; (1)用ah寄存器传递功能号:0表示清屏,1表示设置前景色,2表示设置背景色,3表示向上滚动一行
; (2)对于1、2号功能,用al传送颜色值,(al)∈ {0,1,2,3,4,5,6,7}。
assume cs:code

code segment
	start:     
	;int 7ch安装
	           push cs
	           pop  ds
	           mov  si, offset int7ch                  	;ds:si指向源地址

	           mov  ax, 0
	           mov  es, ax
	           mov  di, 204h

	           mov  cx, offset int7ch_end-offset int7ch
	           cld
	           rep  movsb

	           mov  ax, 0
	           mov  es, ax
	;原int7ch入口地址放到0:200处
	           push es:[7ch*4]
	           pop  es:[200h]
	           push es:[7ch*4+2]
	           pop  es:[202h]
	;设置新的int7ch到中断向量表
	           cli
	           mov  word ptr es:[7ch*4], 204h
	           mov  word ptr es:[7ch*4+2], 0h
	           sti

	           mov  ax, 4c00h
	           int  21h

	;让编译器从204h重新计算标号地址
	           org  204h
	int7ch:    
	           jmp  short set
	table      dw   sub1, sub2, sub3, sub4
	set:       
	           push bx
	           cmp  ah, 3
	           ja   sret
	           mov  bl, ah
	           mov  bh, 0
	           add  bx, bx
	           call word ptr table[bx]
	sret:      
	           pop  bx
	           iret
	sub1:      
	           push bx
	           push cx
	           push es
	           mov  bx, 0b800h
	           mov  es, bx
	           mov  bx, 0
	           mov  cx, 2000
	sub1s:     
	           mov  byte ptr es:[bx], ' '              	;清屏, 每一个字符都用' '替换
	           add  bx, 2
	           loop sub1s
	           pop  es
	           pop  cx
	           pop  bx
	           ret

	sub2:      
	           push bx
	           push cx
	           push es
	           mov  bx, 0b800h
	           mov  es, bx
	           mov  bx, 1                              	;颜色属性在高位
	           mov  cx, 2000
	sub2s:     
	           and  byte ptr es:[bx], 11111000b        	;前景色置0
	           or   es:[bx], al                        	;放入前景色
	           add  bx, 2
	           loop sub2s
	           pop  es
	           pop  cx
	           pop  bx
	           ret
    
	sub3:      
	           push bx
	           push cx
	           push es
	           mov  bx, 0b800h
	           mov  es, bx
	           mov  bx, 1                              	;颜色属性在高位
	           mov  cl, 4
	           shl  al, cl                             	;al左移4位
	           mov  cx, 2000
	sub3s:     
	           and  byte ptr es:[bx], 10001111b
	           or   es:[bx], al
	           add  bx, 2
	           loop sub3s
	           pop  es
	           pop  cx
	           pop  bx
	           ret

	sub4:      
	           push cx
	           push ds
	           push es
	           push si
	           push di
	;ds:si => es:si
	           mov  si, 0b800h
	           mov  es, si
	           mov  ds, si
	           mov  si, 160                            	;第一行后
	           mov  di, 0
	           cld

	           mov  cx, 24                             	;行数
	sub4s:     
	           push cx
	           mov  cx, 160                            	;将第一行后面的数据复制到从第一行开始, 向上滚动一行
	           rep  movsb

	           pop  cx
	           loop sub4s
        
	           mov  cx, 80
	           mov  si, 0
	sub4s1:    
	           mov  byte ptr [160*24+si], ' '          	;最后一行清空
	           add  si, 2
	           loop sub4s1

	           pop  di
	           pop  si
	           pop  es
	           pop  ds
	           pop  cx
	           ret
	int7ch_end:nop
code ends

end start

使用BIOS进行键盘读写和磁盘读写

1.int 9中断例程对键盘输入的处理 => 具体看外中断4

2.int 16h中断例程读取键盘缓冲区 => 从键盘缓冲区读取一个键盘输入, 然后将其从缓冲区删除, 该功能编号为0 mov ah, 0 int 16h => 结果扫描码放到ah中, ASCII码放到al中 => 检测缓冲区为空后, 会循环等待直到缓冲区中有数据

; 子程序:字符栈的入栈、出栈和显示
; 参数说明:(ah)=功能号,0表示入栈,1表示出栈,2表示显示; ds:si 指向字符栈空间
; 对于0号功能:(al)=入栈字符;对于1号功能:(al)=返回的字符
; 对于2号功能:(dh)、(dl)=字符串在屏幕上显示的行、列位置

assume cs:code

code segment
	charstack:
	          jmp  short charstart
	table     dw   charpush, charpop, charshow
	top       dw   0                          	;字符栈 栈顶

	charstart:
	          push bx
	          push dx
	          push di
	          push es
            
	          cmp  ah, 2                      	;0表示入栈,1表示出栈,2表示显示
	          ja   sret                       	;>2
	          mov  bl, ah
	          mov  bh, 0
	          add  bx, bx                     	;找到功能号*2的子程序
	          jmp  word ptr table[bx]

	charpush: 
	          mov  bx, top
	          mov  [si][bx], al               	;将读取的ASCII码放入栈
	          inc  top
	          jmp  sret

	charpop:  
	          cmp  top, 0
	          je   sret
	          dec  top
	          mov  bx, top
	          mov  al, [si][bx]               	;栈顶元素读出
	          jmp  sret

	charshow: 
	          mov  bx, 0b800h
	          mov  es, bx
	          mov  al, 160
	          mov  ah, 0
	          mul  dh                         	;ROW
	          mov  di, ax
	          add  dl, dl                     	;COLUMN
	          mov  dh, 0
	          add  di, dx                     	;偏移值 es:di
            
	          mov  bx, 0
	s:        
	          cmp  bx, top
	          jne  noempty
	          mov  byte ptr es:[di], ' '
	          jmp  sret
	noempty:  
	          mov  al, [si][bx]
	          mov  es:[di], al
	          mov  byte ptr es:[di+2], ' '
	          inc  bx
	          add  di, 2
	          jmp  s
	sret:     
	          pop  es
	          pop  di
	          pop  dx
	          pop  bx
	          ret

	getstr:   
	          push ax
	getstrs:  
	          mov  ah, 0
	          int  16h
	          cmp  al, 20h
	          jb   nochar
	          mov  ah, 0
	          call charstack
	          mov  ah, 2
	          call charstack
	          jmp  getstrs
	nochar:   
	          cmp  ah, 0eh                    	;backspace的扫描码
	          je   backspace
	          cmp  ah, 1ch                    	;enter的扫描码
	          je   enter
	          jmp  getstrs
	backspace:
	          mov  ah, 1
	          call charstack
	          mov  ah, 2
	          call charstack
	          jmp  getstrs
	enter:    
	          mov  ah, 0
	          mov  al, 0
	          call charstack
	          mov  ah, 2
	          call charstack
	          pop  ax
	          ret
code ends

end getstr

4.int 13h对磁盘进行读写 => 通过磁盘控制器进行读写 => 读写时给出面号,磁道号, 扇区号 => 只有扇区号从1开始在这里插入图片描述
在这里插入图片描述
5.功能号3是写扇区

6.在这里插入图片描述

这篇关于汇编语言(王爽第三版)笔记的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!