程序

源程序

☀️ 由计算机执行、处理的指令和数据称为程序

  1. assume cs:codesg
  3. codesg segment
  5.        ;以下是程序
  6.        mov ax,0123H
  7.        mov bx,0456H
  8.        add ax,bx
  9.        add ax,ax
  11.        mov ax,4c00H
  12.        int 21H
  14. codesg ends
  16. end

数据的后面写 H 表示十六进制数据，写 B 表示二进制，写 D 表示十进制，写 O 表示八进制，不写默认十进制 而debug方式写的时候不能写后面的代号，只能写十六进制

伪指令

定义一个段

  1. 段名 segment
  3. 段名 ends

程序结束

  1. ends

📢 ends 与 assume 不是配套的，assume 只是声明段

关联段寄存器

  1. assume cs:codesg  ; codesg 最终会被编译成“段地址”

伪指令是由编译器执行的，不是由计算机执行的，也就是说计算机不会把 cs 指向 codesg 的段地址

程序返回

单任务操作系统上，正在运行的 汇编程序 - 图1 程序将 汇编程序 - 图2 载入内存，汇编程序 - 图3 将控制权交给 汇编程序 - 图4，汇编程序 - 图5 才能运行，运行结束后，汇编程序 - 图6 又将控制权交给 汇编程序 - 图7，称为程序返回

  1. mov ax,4c00H
  2. int 21H

在程序的末尾写上上面的两条指令，即可实现程序返回
在 DOS 中，汇编程序 - 图8 可以是 command.com即命令解释器
image.png
如果不写程序返回，则会变成
image.png

语法错误

  1. sume cs:codesg  ; 编译器不知道 sume 是什么
  3. codesg segment
  5.     mov ax,1000  ; 代码段没有 ends
  7. end

逻辑错误

  1. assume cs:codesg
  3. codesg segment
  5.        mov ax,1000
  7.        ; 不存在程序返回, 但能通过编译
  9. codesg ends
  11. end

编译

image.png
如果文件名不是.asm结尾的需要输入全名，如 1.txt，如果文件和 masm.exe不在同一个目录，还要输入路径
如果默认忽略各种中间文件，且目标文件名不变，可以直接编译输入下面的代码进行编译，;不能省略

  1. masm 1;

image.png

连接

image.png

  1. link 1;

跟踪

  1. debug 1.exe

注意exe不能省略

程序载入过程

会自动寻找足够大的空闲空间

image.png
image.png
可以输入t进行程序运行过程的监控
image.png

[BX] 与 loop

描述符 ()

  • (寄存器)表示寄存器里的内容，如(ax)=1000H
  • (物理地址)表示物理地址里的内容，如(2000H)=0010H

  • (段寄存器)表示段寄存器的内容，如((ds)×16+(ax))=1000H

    约定符 idata

    idata 表示常量

  • mov ax,[idata]表示 mov ax,[1]``mov ax,[2]等

  • mov ax,idata表示 mov ax,1``mov ax,2等

    [bx]

    mov ax,[bx]表示将偏移地址为(bx)的字型数据送入 ax，即 (ax)=((ds)×16+(bx))
    如果是 mov al,[bx]则 [bx]代表字节型数据(即 1 个字节)

    注意，[...]只能放入bx``si``di``bp寄存器，[ax]``[cx]``[dx]``[ds]是非法的

  1. mov ax,0ffffh  ; 汇编不允许字母开头的数据
  2. mov ds,ax
  3. mov bx,6
  5. ;将字节型(8位)数据 ffff:0 送入 16 位的 ax 中
  6. ;如果直接 mov ax,[bx] 则会送入字型数据(16位), ah 不一定是 0 了
  7. mov al,[bx]
  8. mov ah,0

自增 inc

  1. inc bx  ; 表示 bx=bx+1

不能操作段寄存器 image.png

loop

  1. assume cs:code
  2. code segment
  3.     mov ax,2
  4.     mov cx,11
  5.  s: add ax,ax
  6.     loop s
  8.     mov ax,4c00h
  9.     int 21h
  10. code ends
  11. end

执行到 汇编程序 - 图18 会先让 汇编程序 - 图19 然后再判断是否 汇编程序 - 图20，若成立则退出(汇编程序 - 图21 是通用寄存器)
image.png

指定跟踪位置

  1. assume cs:code
  3. code segment
  5.        mov ax,0ffffh
  6.        mov ds,ax
  7.        mov bx,6
  9.        mov al,[bx]
  10.        mov ah,0
  12.        mov cx,123
  14.     s: add dx,ax  ;这里需要循环
  15.        loop s
  17.        mov ax,4c00H  ; 这里循环结束
  18.        int 21H
  20. code ends
  22. end
  1. g IP

汇编程序 - 图23 指需要循环的指令的 汇编程序 - 图24，即指令 add dx,ax
image.png

跳过循环

  1. p

image.png

  1. g IP

汇编程序 - 图27 指循环结束后指令的 汇编程序 - 图28，即 mov ax,4c00H

循环嵌套

有问题的程序

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'ibm             '
  5.   db 'dec             '
  6.   db 'dos             '
  7.   db 'vax             '
  8. data ends
  10. code segment
  11. start: mov ax,data
  12.        mov ds,ax
  13.        mov bx,0
  14.        mov cx,4  ; 四个单词, 外循环需要循环 4 次
  16.   s0:  mov si,0
  17.        mov cx,3  ; 三个字母, 内循环需要循环 3 次
  19.   s1:  mov al,[bx+si]
  20.        and al,11011111B
  21.        mov [bx+si],al
  22.        inc al
  24.        loop s1
  26.        add bx,16
  28.        loop s0
  29. code ends
  31. end start

当一次内循环结束后遇到loop s0循环次数cx就会变成FFFF这样外循环的循环次数不断被覆盖，无法结束循环
image.png

解决方案一

使用寄存器dx临时保存外循环的cx

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'ibm             '
  5.   db 'dec             '
  6.   db 'dos             '
  7.   db 'vax             '
  8. data ends
  10. code segment
  11. start: mov ax,data
  12.        mov ds,ax
  13.        mov bx,0
  14.        mov cx,4
  16.   s0:  mov dx,cx  ; 保存外循环的 cx
  17.        mov si,0
  18.        mov cx,3
  20.   s1:  mov al,[bx+si]
  21.        and al,11011111B
  22.        mov [bx+si],al
  23.        inc si
  25.        loop s1
  27.        add bx,16
  28.        mov cx,dx  ; 这里恢复外循环的 cx
  30.        loop s0
  32.        mov ax,4c00H
  33.        int 21H
  34. code ends
  36. end start

解决方法二

使用栈来保存多个循环的cx

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'ibm             '
  5.   db 'dec             '
  6.   db 'dos             '
  7.   db 'vax             '
  8. data ends
  10. stack segment
  11.   dw 0  ; 这里写一个 0 就可以创建 16 个字节的栈
  12. stack ends
  14. code segment
  15. start: mov ax, stack
  16.        mov ss,ax
  17.        mov sp,16
  19.        mov ax,data
  20.        mov ds,ax
  21.        mov bx,0
  22.        mov cx,4
  24.   s0:  push cx  ; cx 入栈
  25.        mov si,0
  26.        mov cx,3
  28.   s1:  mov al,[bx+si]
  29.        and al,11011111B
  30.        mov [bx+si],al
  31.        inc si
  33.        loop s1
  35.        add bx,16
  36.        pop cx  ; cx 出栈
  38.        loop s0
  40.        mov ax,4c00H
  41.        int 21H
  42. code ends
  44. end start

汇编代码的不同处理

debug 里[0]就代表ds:0里的数据，而源程序中代表 0
image.png

解决方法

  1. 使用 bx 中转

    1. mov bx,0
    2. mov ax[bx]

  2. 显示声明内存单位，又称为段前缀

    1. mov ax,ds:[0]

    8 位二进制数累加

  3. 8 位二进制范围 0~255，累加可能会导致进位丢失

  4. 不能直接把 8 位二进制放到 ax 中，因为位数不匹配

    解决方法

    1. s:mov al,[bx]
    2. mov ah,0
    3. add dx,ax ; 利用 dx 进行“中转”, dx 是 16 位的, 累加用 dx, ax 通过 al,ah 拼成 16 位
    4. inc bx
    5. loop s

    多段程序

    代码段中使用数据 dw

    使用 dw让系统自动帮我们分配数据的内存 image.png 不够 16 个字节的会占满 16 个字节，超了会到下一行，即 汇编程序 - 图32 个字节数据，实际占用 汇编程序 - 图33 字节 这里要用cs:[bx]不能直接写[bx]，因为数据是存在指令地址空间上的，而[bx]代表 ds:[bx]是数据地址空间

  1. assume cs:code
  3. code segment
  5.        dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h
  7.        mov bx,0
  8.        mov ax,0
  10.        mov cx,8  ;循环 8 次
  12.     s: add ax,cs:[bx]  ; cs[0]指向 dw 所指代的数据
  13.        add bx,2
  14.        loop s
  16.        mov ax,4c00H
  17.        int 21H
  19. code ends
  21. end

直接使用 u查看是一堆看不懂的指令，即由 dw定义的数据被编译器看成了指令
image.png
需要跳过前面的dw才能看到正确的指令
image.png
为了不让编译器误执行前面不对的代码，需要指定代码执行的入口，编译器会根据end start自动设置程序的 汇编程序 - 图36

start只是个单词，写什么都可以，只要end xxx和xxx:对应即可

  1. assume cs:code
  3. code segment
  5.        dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h
  7. start: mov bx,0
  8.        mov ax,0
  10.        mov cx,8  ;循环 8 次
  12.     s: add ax,cs:[bx]  ; cs[0]指向 dw 所指代的数据
  13.        add bx,2
  14.        loop s
  16.        mov ax,4c00H
  17.        int 21H
  19. code ends
  21. end start

代码段中使用栈

使用 dw开辟栈空间

  1. assume cs:code
  3. code segment
  5.        dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h
  6.        dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  ; 申请 16 个字空间
  8. start: mov ax,cs
  9.        mov ss,ax
  10.        mov sp,30h  ; 栈顶从 8×2 + 16×2 = 48 = 30h 开始
  12.        mov bx,0
  13.        mov cx,8
  15.     s: push cs:[bx]
  16.        add bx,2
  17.        loop s
  19.        mov bx,0
  20.        mov cx,8
  22.    s0: pop cs:[bx]
  23.        add bx,2
  24.        loop s0
  26.        mov ax,4c00H
  27.        int 21H
  29. code ends
  31. end start

入栈本来只需要 8 个字即可，但是由于不明确的原因，必须申请 16 个
image.png

数据、代码放在不同段

  1. assume cs:code,ds:data,ss:stack
  3. data segment
  5.        dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h
  7. data ends
  9. stack segment
  11.        dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  13. stack ends
  15. code segment
  17. start: mov ax,stack
  18.        mov ss,ax  ; 栈段地址指向 stack 的段地址
  19.        mov sp,20h
  21.        mov ax,data  ; 数据指向 data 段地址
  22.        mov ds,ax  ; data 会被解析成一个数值, 因此 mov ds,data 不合法
  24.        mov bx,0
  25.        mov cx,8
  27.     s: push [bx]  ; 由于数据不在指令地址空间了, 因此不需要写 cs:[bx]
  28.        add bx,2
  29.        loop s
  31.        mov bx,0
  32.        mov cx,8
  34.    s0: pop [bx]
  35.        add bx,2
  36.        loop s0
  38.        mov ax,4c00H
  39.        int 21H
  41. code ends
  43. end start

如果不指定end start，则会从第一个段开始执行，即 data 段
image.png
image.png
因此如果不想写end start则把 code 段写在第一个即可

更灵活寻址方法

and 按位与

  1. mov al,01100011B
  2. and al,00111011B
  3. ; 结果 al=00100011B

or 按位或

  1. mov al,01100011B
  2. or al,00111011B
  3. ; 结果 al=01111011B

ASCII码

伪指令 db

db不会像dw一样默认占 16 个字节，db定义字节型数据

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'ubIX'
  5.   db 'foRK'
  6. data ends
  8. code segment
  9. start: mov al,'a'
  10.        mov bl,'b'
  11.        mov ax,4c00h
  12.        int 21h
  13. code ends
  15. end start

image.png

转成大写

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'ubIX'
  5. data ends
  7. code segment
  8. start: mov ax,data
  9.        mov ds,ax
  10.        mov bx,0
  11.        mov cx,4  ; 单词数 4 就循环 4 次
  13.      s:mov al,[bx]
  14.        and al,11011111B  ; 小写字母的 ASCII 第 5 个数变成 0, 则变成大写
  15.        mov [bx],al
  16.        inc bx
  17.        loop s
  19.        mov ax,4c00h
  20.        int 21h
  21. code ends
  23. end start

image.png

转成小写

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'ubIX'
  5. data ends
  7. code segment
  8. start: mov ax,data
  9.        mov ds,ax
  10.        mov bx,0
  11.        mov cx,4  ; 单词数 4 就循环 4 次
  13.      s:mov al,[bx]
  14.        or al,00100000B  ; 大写字母的 ASCII 第 5 个数变成 1, 则变成小写
  15.        mov [bx],al
  16.        inc bx
  17.        loop s
  19.        mov ax,4c00h
  20.        int 21h
  21. code ends
  23. end start

[bx+idata]

偏移地址可以使用加法

  1. mov ax,[200+bx]
  1. mov ax,[bx+200]
  1. mov ax,200[bx]
  1. mov ax,[bx].200

以上代码都表示(ax)=((ds)×16+(bx)+200)

C语言对比版

  1. ; 汇编语言
  2. assume cs:code,ds:data
  4. data segment
  5.   db 'BaSic'
  6.   db 'MinIX'
  7. data ends
  9. code segment
  10. start: mov ax,data
  11.        mov ds,ax
  12.        mov bx,0
  13.        mov cx,5
  15.      s:mov al,0[bx]
  16.        and al,11011111B  ; 转大写
  17.        mov 0[bx],al
  19.        mov al,5[bx]
  20.        or al,00100000B  ; 转小写
  21.        mov 5[bx],al
  22.        inc bx
  23.        loop s
  25.        mov ax,4c00h
  26.        int 21h
  27. code ends
  29. end start
  1. // c 语言
  2. char a[5]="BaSic";
  3. char b[5]="MinIx";
  5. int main(){
  6.   int i=0;
  7.   do{
  8.        a[i]=a[i]&0xDF;
  9.     b[i]=b[i]|0x20;
  10.     i++;
  11.   } while(i<5);
  12. }

[SI] 和 [DI]

与 汇编程序 - 图42 寄存器功能类似，不过不能分成两个 8 位寄存器来使用 [si+di]是非法的

复制字符串

  1. assume cs:code,ds:data
  3. data segment
  4.   db 'welcome to masm!'
  5.   db '..........'
  6. data ends
  8. code segment
  9. start: mov ax,data
  10.        mov ds,ax
  11.        mov si,0
  12.        mov di,16
  14.        mov cx,8
  16.      s:mov ax,[si]
  17.        mov [di],ax
  18.        add si,2
  19.        add di,2
  20.        loop s
  22.        mov ax,4c00h
  23.        int 21h
  24. code ends
  26. end start

[bx+si] 和 [bx+di]

与 [bx+idata]功能类似，不过是将idata换成寄存器

  1. mov ax,[bx+si]
  1. mov ax,[bx][si]

以上代码都表示(ax)=((ds)×16+(bx)+(si))

[bx+si/di+idata]

  1. mov ax,[bx+si+200]
  1. mov ax,[bx][si].200
  1. mov ax,200[bx][si]
  1. mov ax,[bx].200[si]

[BP]

[bp]的默认段地址是ss，即 ss:[bp]

[bx]的默认段地址是ds，即ds:[bx] [bx+bp]是非法的，但是bp可以和si``di合用 mov [bp],bx可行，但mov [sp],bx不可行，因此要修改栈元素需要使用bp中转

数据处理

除法 div

用法 div 除数

  • 如果除数是 8 位的，则被除数在ax里，为 16 位，商保存在al里，余数保存在ah里

  • 如果除数是 16 位的，则被除数高位在dx里，低位在ax里，为 32 位，商保存在ax里，余数保存在dx里

    1. div byte ptr [bx+si+8]

    上面的代码表示 (al)=(ax)/((ds)×16+(bx)+(si)+8))的商``(ah)=(ax)/((ds)×16+(bx)+(si)+8))的余数

    计算 100001/100

  • 被除数 100001 不能放到 16 位里，因此只能放在 32 位里

  • 除数 100 可以是 8 位的，但是由于被除数只能是 32 位，因此除数也只能是 16 位的
  • 100001 的 16 进制为 186A1 ``` assume cs:code

code segment mov dx,1 mov ax,86A1H mov bx,100 div bx

  1.   mov ax,4c00H
  2.   int 21H

code ends

end

  1. <a name="ukRIg"></a>
  2. ## 乘法 mul
  3. 用法`mul 内存单元``mul 寄存器`
  4. > 两个乘数位数必须相同
  6. - 都是 8 位，一个数放在`al`中，另一个放在内存单元或寄存器中，结果保存在`ax`中
  7. - 都是 16 位，一个数放在`ax`中，另一个放在内存单元或寄存器中，结果高位放在`dx`中，低位放在`ax`中

mul byte ptr ds:[0] ; 8 位

  1. ```
  2. mul word ptr ds:[0]  ; 16 位

image.png

计算 100×10

100 和 10 都小于 8 位

  1. mov al,10
  2. mov bl,100
  3. mul bl

注意如果写成mul bx则会被当作 16 位，进而计算ax·bx所以不会报错

伪指令 dd

与dw和db类似，dd定义双字型数据，也默认占满 16 个字节

  1. dd 1

上面代码的结果为01 00 00 00

数据重复 dup

dup重复数不能为 0

  1. dw 3 dup (1,2,3) ; 重复 3 次

上面的代码等价于 dw 1,2,3,1,2,3,1,2,3