汇编语言程序设计 实验报告-2

1. 实验目的

  1. 加深对循环结构的理解
  2. 掌握循环程序的设计方法
  3. 学习子程序的定义和调用方法
  4. 掌握子程序、子程序的嵌套、递归子程序的结构
  5. 掌握子程序设计、编制及调试
  6. 熟练掌握 DEBUG 的常用命令，学会用 DEBUG 调试程序

2. 实验内容

2.1 任务一

编制程序计算 S=1+2·3+3·4+4·5+……+N(N+1) 直到 N(N+1) 大于 200 为止，并将结果由屏幕上显示出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
DATA SEGMENT
    BUF DB'S=1+2*3+3*4+4*5+...+N(N+1)+...=','$'
    RES  DW  4 DUP(0),'$'
DATA ENDS
CODE SEGMENT
    ASSUME CS:CODE,DS:DATA
START:
    MOV    AX,DATA
    MOV    DS,  AX
    MOV    DX,  OFFSET   BUF
    MOV    AH,  09H
    INT    21H
    MOV    DX,  1
    MOV    BL,  2
NEXT:
    MOV    AL,  BL
    INC    BL
    MUL    BL
    ADD    DX, AX
    CMP    AX, 200
    JNA    NEXT
    MOV    CX, 0004H
    MOV    DI, OFFSET    RES
    ADD    DI, 03H
NEXT1:
    MOV    AX,  DX
    AND    AX,  000FH
    CMP    AL, 0AH
    JB     NEXT2
    ADD    AL, 07
NEXT2:
    ADD    AL,  30H
    MOV    [DI],AL
    DEC    DI
    PUSH   CX
    MOV    CL,04
    SHR    DX,CL
    POP    CX
    LOOP   NEXT1
    MOV    DX, OFFSET   RES
    MOV    AH, 09H
    INT    21H
    MOV    AH, 4CH
    INT    21H
CODE ENDS
    END   START

2.2 任务二

将从 3000H 内存单元开始的 100 个字节存储单元全部清 0。

1
2
3
4
5
6
7
8
ORG     2000H
2000    BF0030    MOV    DI,   3000
2003    B164      MOV    CL,   64
2005    C60500    MOV    BYTE  PTR[DI],  0
2008    47        INC    DI
2009    FEC9      DEC    CL
200B    75F8      JNZ    2005
200D    F4        HLT

2.3 任务三

编制在屏幕上显示九九乘法表的程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
STACK SEGMENT   STACK
    DB 1024  DUP(0)
STACK ENDS
DATA SEGMENT

    BUF    DW    0F101H,110DH,52H,100H,456H
    COUNT =($-BUF)/2
    RESULT DW    4  DUP(?),'$'
DATA ENDS
CODE SEGMENT
    ASSUME CS:CODE,DS:DATA,SS:STACK
    WDADD PROC
        PUSH   DI
        MOV  AX,  0
        MOV  DX,  0
        MOV  DI,  OFFSET  BUF
NEXT2:
        ADD    AX,  [DI]
        JNC  NEXT1
        INC  DX
NEXT1:
        ADD    DI,    2
        LOOP   NEXT2
        POP  DI
        RET  
    WDADD ENDP
    SHOW PROC
        PUSH   CX
        PUSH   DI
        MOV  CX,    04H
        MOV  DI,    OFFSET  RESULT
        MOV  BX,    AX
        ADD  DI,    07H
BBB:
        MOV    AX,   BX
        AND  AX,   000FH
        CMP  AL,   0AH
        JB   QQQ
        ADD  AL,   07H
QQQ:
        ADD    AL,   30H
        MOV  [DI],  AL
        DEC  DI
        PUSH   CX
        MOV  CL,   04
        SHR  BX,    CL
        POP  CX
        LOOP   BBB
        MOV  CX,    0004H
CCC:
        MOV    AX,    DX
        AND  AX,   000FH
        CMP  AL,   0AH
        JB   DDD
        ADD  AL,   07H
DDD:
        ADD    AL,    30H
        MOV  [DI],   AL
        DEC  DI
        PUSH   CX
        MOV  CL,    04H
        SHR  DX,   CL
        POP  CX
        LOOP   CCC
        POP  DI
        POP  CX
        RET  
    SHOW ENDP
BEGIN:
    MOV    AX,    DATA
    MOV    DS,    AX
    MOV    CX,    COUNT
    CALL   WDADD
    CALL   SHOW
    MOV    DX,   OFFSET  RESULT
    MOV    AH,   09H
    INT    21H
    MOV    AH,   4CH
    INT    21H
CODE ENDS
    END      BEGIN

2.4 任务四

编制在屏幕上显示用 * 组成的三角形的程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
STACK SEGMENT STACK         ;初始化堆栈段
    DB 1024 DUP(0)
STACK ENDS                  ;堆栈段结束

DATA SEGMENT        ;定义数据段
    I    DB 8    ;行数
    J    DB 1    ;首行字符数
DATA ENDS        ;数据段结束

CODE SEGMENT                         ;定义代码段
    ASSUME CS:CODE, DS:DATA    ;指明段寄存器与段的关系
BEGIN:
    MOV    AX, DATA
    MOV    DS, AX              ;装入DS

    MOV    CL,I
    MOV    CH,00H              ;装入CX作为行数的循环

LOPI:
    MOV    BL,00H              ;外层循环，为行数循环，置BL寄存器为0，作为输出*的计数器
LOPJ:
    MOV    DL,'*'              ;输出一个*
    MOV    AH,02H
    INT    21H

    INC    BL                  ;输出一次*，计数器加一
    CMP    BL,J                ;与当前的J（该行*的个数）比较
    JNZ    LOPJ                ;若不等于J则跳回LOPJ继续输出*

    INC    J                   ;跳出LOPJ后J加一，为下一行的*个数

    MOV    DL,0AH              ;输出换行符
    MOV    AH,02H
    INT    21H

    LOOP   LOPI                ;（CX）=（CX）-1，若（CX）不等于0则跳回LOPI

    MOV    AH, 4CH
    INT    21H                 ;程序结束
CODE ENDS
    END   BEGIN

2.5 任务五

设有五个字数据存放在以 BUF 为首地址的内存单元中，要求采用调用多个字数据相加的子程序方法编程。和的低位字放在 RESULT 单元，和的高位字放在 RESULT+2 单元，并将结果显示在屏幕上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
DATA SEGMENT
    BUF    DW 1234H,3456H,2134H,7893H,3456H
    RESULT DW 0,0
DATA ENDS
STACK SEGMENT STACK
    DB 200 DUP(0)
STACK ENDS
CODE SEGMENT
    ASSUME DS:CODE,SS:STACK,CS:CODE
START:
    MOV    AX,DATA
    MOV    DS,AX
    CALL   PLUS_N
    MOV    SI,OFFSET RESULT
    MOV    BX,[SI+2]
    CALL   DISPLAY
    MOV    BX,[SI]
    CALL   DISPLAY
    MOV    AH,4CH
    INT    21H
    ;功能：计算多字节相加
    ;入口参数：BUF
    ;出口参数：RESULT
    PLUS_N PROC
        AND  DX,0
        AND  AX,0
        MOV  CL,5
        MOV  SI,OFFSET BUF
LOP:
        ADD    AX,[SI]
        ADC  DX,0
        INC  SI
        INC  SI
        LOOP   LOP
        MOV  SI,OFFSET RESULT
        MOV  [SI],AX
        MOV  [SI+2],DX
        RET  
    PLUS_N ENDP
    ;功能：显示十六进数
    ;入口参数：BX
    DISPLAY PROC
        MOV    CH,4
LOP1:
        MOV    CL,4
        ROL    BX,CL
        MOV    DL,BL
        AND    DL,0FH
        ADD    DL,30H
        CMP    DL,3AH
        JB  NEXT
        ADD    DL,7
NEXT:
        MOV    AH,2
        INT    21H
        DEC    CH
        CMP    CH,0
        JNZ    LOP1
        RET
    DISPLAY ENDP
CODE ENDS
    END START

2.6 任务六

编写一个递归子程序，计算指数函数 Xn 的值，其中 X、n 从键盘输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
CODE SEGMENT
    ASSUME CS:CODE

START:
    MOV    CX,6
    MOV    BX,5
    CALL   DIGUIMI
    CALL   DIGUIAX
    MOV    AH,4CH
    INT    21H
    ;================================
    DIGUIMI PROC      NEAR
        ; cx为幂次，bx为底
        ; ax 中返回 乘幂
        CMP  CX,0
        JNE  @DIGUIMI
        MOV  AX,1
        RET  
@DIGUIMI:
        DEC  CX
        CALL   DIGUIMI
        MUL  BX
        RET  
    DIGUIMI ENDP
    ;=================================
    DIGUIAX PROC      NEAR
        ; 递归显示 AX 中的无符号数（10进制）
        PUSH   BX
        PUSH   DX
        MOV  DX,0
        MOV  BX,10
        DIV  BX
        CMP  AX,0
        JE   @DIGUIAX1
        CALL   DIGUIAX
@DIGUIAX1:
        OR   DX,30H
        MOV  AH,2
        INT  21H
        POP  DX
        POP  BX
        RET  
    DIGUIAX ENDP
;=================================
CODE ENDS
    END       START

3. 调试步骤

  1. 按程序流程图编制实验程序
  2. 输入源程序
  3. 汇编、连接程序、执行程序、检查结果
  4. 对内存单元 3000H 开始的 100 个存储单元用 E 命令输入任意数
  5. 程序的执行可 DEBUG 的 G 命令，也可用 T 命令单步跟踪执行
  6. 用 D 命令检查执行结果

4. 分析与思考

  1. 常用指令
指令 指令功能
mov reg, data reg = data
add reg, data reg = reg + data
sub reg, data reg = reg - data
mul reg ax = ax * reg
div reg 当 reg 为 8 位, ah = ax / reg, al = ax % reg. 当 reg 为 16 位, ax = ax / reg, dx = ax % reg.
cmp a, b a == b zf = 1
a != b zf = 0
a < b cf = 1
a >= b cf = 0
a > b cf = 0, zf = 0
a <= b cf = 1, zf = 1
jb tag 当 cf = 1, 跳转到 tag
je tag 当 zf = 1, 跳转到 tag
jmp tag 无条件跳转到 tag
  1. 标志位寄存器
寄存器 功能
sf 符号标志位, 运算结果为负时为 1
cf 进位标志位(无符号数)当向最高位进位或借位时为 1
of 溢出标志位(有符号数)当有符号数运算发生溢出时为 1
  1. 汇编循环程序的实现

循环程序由初始化部分、循环部分、调整部分、控制部分组成。有两种方式：一种是先判断在执行，另一种是先执行再判断。两种控制循环的方式：

  • 计数控制循环：一般使用 LOOP 指令，要先将循环的次数放入 CX 中，在多重循环的计数控制中要注保存和复原上一次循环的断点信息，在保留和复原时可以使用堆栈进行处理。自认为可以理解为一根盘绕了确定的圈数的绳子，又进入的头，又出去的尾。

  • 条件控制循环：一般使用 JMP 指令使程序跳到这一段的开头，用 CMP 在循环中进行比较判断，再根据程序要求，选择适当的转移条件，跳出循环。自认为可以理解为一圆形的导轨，并在导轨上设置一个出口，在符合条件时就在导轨上脱离，否则将会在导轨上一直的转下去。

再循环中可以同时使用两者，当即己知循环的次数限制范围，但又要求在符合条件时结束循环时，就要同时使用两者。

附录

  1. 文件列表

    • 8086-8088 汇编语言指令表.pdf

  2. 下载地址

University
#河北工业大学 #汇编语言程序设计
汇编语言程序设计 实验报告-2
https://flowerdown.org/posts/20221219-161614
作者
Unrealfeathers
发布于
2022年12月19日
许可协议