实验2 多个逻辑段的汇编源程序编写与调试

1. 实验任务1

此实验任务中，包含4个子任务。逐一实践，结合实践观察、验证，回答问题。

任务1-1 对程序task1_1.asm进行汇编、连接，用debug加载、跟踪调试，基于结果，回答问题。

task1_1.asm

 1 assume ds:data, cs:code, ss:stack
 2 
 3 data segment
 4     db 16 dup(0)
 5 data ends
 6 
 7 stack segment
 8     db 16 dup(0)
 9 stack ends
10 code segment
11 start:
12     mov ax, data
13     mov ds, ax
14 
15     mov ax, stack
16     mov ss, ax
17     mov sp, 16
18 
19     mov ah, 4ch
20     int 21h
21 code ends
22 end start

① 在debug中将执行到line17结束、line19之前，记录此时：寄存器(DS) = 076A____，寄存器(SS) = _076B___，寄存器(CS) = _076C___

② 假设程序加载后，code段的段地址是X，则，data段的段地址是_x-2___， stack的段地址是_x-1__。

任务1-2 对程序task1_2.asm进行汇编、连接，用debug加载、跟踪调试，基于结果，回答问题。

task1_2.asm

 1 assume ds:data, cs:code, ss:stack
 2 
 3 data segment
 4     db 4 dup(0)
 5 data ends
 6 
 7 stack segment
 8     db 8 dup(0)
 9 stack ends
10 code segment
11 start:
12     mov ax, data
13     mov ds, ax
14 
15     mov ax, stack
16     mov ss, ax
17     mov sp, 8
18 
19     mov ah, 4ch
20     int 21h
21 code ends
22 end start

① 在debug中将执行到line17结束、line19之前，记录此时：寄存器(DS) = 076A____，寄存器(SS) = _076B___，寄存器(CS) = _076C___

② 假设程序加载后，code段的段地址是X，则，data段的段地址是_x-2___， stack的段地址是__x-1__。

任务1-3 对程序task1_3.asm进行汇编、连接，用debug加载、跟踪调试，基于结果，回答问题。

task1_3.asm

 1 assume ds:data, cs:code, ss:stack
 2 
 3 data segment
 4     db 20 dup(0)
 5 data ends
 6 
 7 stack segment
 8     db 20 dup(0)
 9 stack ends
10 code segment
11 start:
12     mov ax, data
13     mov ds, ax
14 
15     mov ax, stack
16     mov ss, ax
17     mov sp, 20
18 
19     mov ah, 4ch
20     int 21h
21 code ends
22 end start

① 在debug中将执行到line17结束、line19之前，记录此时：寄存器(DS) = 076A____，寄存器(SS) = _076C__，寄存器(CS) = _076E___

② 假设程序加载后，code段的段地址是X，则，data段的段地址是_x-4___， stack的段地址是_x-2___。

任务1-4 对程序task1_4.asm进行汇编、连接，用debug加载、跟踪调试，基于结果，回答问题。

task1_4.asm

 1 assume ds:data, cs:code, ss:stack
 2 code segment
 3 start:
 4     mov ax, data
 5     mov ds, ax
 6 
 7     mov ax, stack
 8     mov ss, ax
 9     mov sp, 20
10 
11     mov ah, 4ch
12     int 21h
13 code ends
14 
15 data segment
16     db 20 dup(0)
17 data ends
18 
19 stack segment
20     db 20 dup(0)
21 stack ends
22 end start

① 在debug中将执行到line9结束、line11之前，记录此时：寄存器(DS) = _076C___，寄存器(SS) = __076E__，寄存器(CS) = _076A___

② 假设程序加载后，code段的段地址是X，则，data段的段地址是_x+2___， stack的段地址是 x+4___。

任务1-5 基于上述四个实验任务的实践、观察，总结并回答： ① 对于如下定义的段，程序加载后，实际分配给该段的内存空间大小是 16 × [数据长度 / 16] Byte____。

1 xxx segment
2 db N dup(0)
3 xxx ends

② 如果将程序task1_1.asm, task1_2.asm, task1_3.asm, task1_4.asm中，伪指令 end start 改成 end , 哪一个程序仍然可以正确执行？结合实践观察得到的结论，分析、说明原因。

task1_1.asm, task1_2.asm, task1_3.asm无法正常执行，

task1_4.asm可以正常执行

原因：end start改成end之后，前三个代码段开头是数据段，无法找到程序的入口，而cs:ip指向了数据段，把数据当作指令来执行，所以会发生错误；

task1_4的程序开头为code段，所以可以找到程序的入口，程序正常执行。

2. 实验任务2

编写一个汇编源程序，实现向内存单元b800:0f00 ~ b800:0f9f连续160字节，依次重复填充十六进制数据03 04。

 1 assume cs:code
 2 code segment
 3 start:
 4     mov ax, 0b800h
 5     mov ds, ax
 6 
 7     mov bx, 0f00h
 8     mov cx, 50h                
 9     mov ax, 0403h            
10 s:  mov ds:[bx], ax
11     add bx, 2                    
12     loop s
13 
14     mov ah, 4ch
15     int 21h
16 code ends
17 end start

3. 实验任务3 已知8086汇编源程序task3.asm代码片段如下。

task3.asm

 1 assume ds:data1, cs:code 
 2 data1 segment
 3     db 50, 48, 50, 50, 0, 48, 49, 0, 48, 49 ; ten numbers
 4 data1 ends
 5 
 6 data2 segment
 7     db 0, 0, 0, 0, 47, 0, 0, 47, 0, 0       ; ten numbers
 8 data2 ends
 9 
10 data3 segment
11     db 16 dup(0)
12 data3 ends
13 
14 code segment
15 start:
16     mov ax, data1                    
17     mov ds, ax
18 
19     mov bx, 0
20     mov cx, 0ah                        
21 s:  mov ax, ds:[bx]                
22     add ax, ds:[bx+10h]        
23     mov ds:[bx+20h], ax        
24     inc bx
25     loop s
26 
27    mov ah, 4ch
28    int 21h
29 code ends
30 end start

要求： ① 编程实现把逻辑段data1和逻辑段data2的数据依次相加，结果保存到逻辑段data3中。

② 在debug中加载、反汇编、调试。在数据项依次相加前，和相加后，分别查看三个逻辑段data1, data2, data3对应的内存空间，确认逐一相加后，结果的确保存在了逻辑段data3中。

反汇编

运行相加后结果图

相加前

4. 实验任务4 已知8086汇编源程序task4.asm代码片段如下。

task4.asm

 1 assume cs:code, ss:stack
 2 
 3 data1 segment
 4     dw 2, 0, 4, 9, 2, 0, 1, 9
 5 data1 ends 
 6 
 7 data2 segment
 8     dw 8 dup(0)
 9 data2 ends
10 
11 stack segment
12     dw 8 dup(0)
13 stack ends
14 
15 code segment
16 start:
17     mov ax, data1
18     mov ds, ax            
19     mov sp, 9                
20     mov bx, 0
21     mov cx, 8                
22 s1: push ds:[bx]
23     add bx, 2        
24     loop s1
25     
26     mov ax, data2        
27     mov ds, ax
28     mov bx, 0
29     mov cx, 8                
30 s2: pop ds:[bx]
31     add bx, 2
32     loop s2
33 
34     mov ah, 4ch
35     int 21h
36 code ends
37 end start

要求： ① 补全程序，实现把逻辑段data1中的8个字数据逆序存储到逻辑段b中。

② 汇编、连接后，在debug中加载程序，运行到line15程序退出前，使用d命令查看数据段data2对应的内存空间，确认是否实现题目要求。

执行前

执行后

数据被逆序存放在了Data处，完成题目要求。

5. 实验任务5

使用任意文本编辑器，录入汇编源程序task5.asm。

task5.asm

 1 assume cs:code, ds:data
 2 data segment
 3         db 'Nuist'
 4         db 2, 3, 4, 5, 6
 5 data ends
 6 
 7 code segment
 8 start:
 9         mov ax, data
10         mov ds, ax            ：ds存放数据段地址
11 
12         mov ax, 0b800H
13         mov es, ax             ；eS存放数据段地址
14 
15         mov cx, 5              ；循环5次
16         mov si, 0
17         mov di, 0f00h
18 s:      mov al, [si]            ; 把ds段的一个字母放进al
19         and al, 0dfh
20         mov es:[di], al        ; 把相与的结果放进es[di]
21         mov al, [5+si]           ; 把data段的一个数字移入al
22         mov es:[di+1], al           ; 把数字移到es[di+1]位置
23         inc si
24         add di, 2
25         loop s
26 
27         mov ah, 4ch
28         int 21h
29 code ends
30 end start

阅读源程序，从理论上分析源代码的功能，尤其是line15-25，循环实现的功能是什么，逐行理解每条指令的功能。

对程序进行汇编、链接，得到可执行文件，运行并观察结果。

使用debug工具对程序进行调试，执行到程序返回前，即line25执行之后、line27执行之前，观察结果。

源代码中line19的作用是？

修改line4里5个字节单元的值，重新汇编、链接、运行，观察结果

1 db 2,3,4,5,6
2 --> 改成:
3 db 5 dup(2) 或 db 5 dup(5)

基于观察，分析、猜测这里的数值作用是什么。

这五个数与颜色有关

运行结果截图

使用g命令一次性执行到程序返回前

源代码中line19的作用是？

执行Line 19的相与操作，使小写字母变成大写字母。

源代码中data段line4的字节数据的用途是？

由于这边定义的是字节，1个字节为8位，所以这里的5个数是8位色彩代码，不同的数字对应了不同的颜色。

6. 实验任务6

 1 assume cs:code, ds:data
 2 
 3 data segment
 4     db 'Pink Floyd      '
 5     db 'JOAN Baez       '
 6     db 'NEIL Young      '
 7     db 'Joan Lennon     '
 8 data ends
 9 
10 code segment
11 start:
12     mov ax, data
13     mov ds, ax
14 
15     mov ax, data    
16     mov es, ax      
17 
18     mov bx, 0       
19     mov cx, 4       
20 s1: 
21     mov si, cx      
22     mov cx, 4       
23     
24 s2: 
25     mov al, es:[bx]  
26     or al, 20h         
27     mov es:[bx], al     
28     inc bx             
29     loop s2             
30    
31     mov cx, si      
32     mov bx, 0      
33 
34     mov ax, es     
35     inc ax          
36     mov es, ax    
37 
38     loop s1        
39 
40     mov ah, 4ch
41     int 21h
42 code ends
43 end start

1 ① 补全程序，将data段中的每行第一个单词从大写->小写。

② 在debug中加载程序，反汇编，执行到line13退出前，用d命令查看data段对应的内存空间，确认每行第一个单词已经由大写->小写。

第一个单词全部变成了小写，实现预定目标。

7. 实验任务7 问题场景描述： Power idea公司1975年-1979年的基本情况如下：

程序task7.asm的逻辑段data中(line4-6)，已经定义好了这些数据。

task7.asm

  1 assume cs:code, ds:data, es:table
  2 
  3 data segment
  4     db '1975', '1976', '1977', '1978', '1979'   
  5     dd  16, 22, 382, 1356, 2390                
  6     dw  3, 7, 9, 13, 28                      
  7 data ends
  8 
  9 table segment
 10     db 5 dup( 16 dup(' ') )     
 11 table ends
 12 
 13 code segment
 14 start:
 15     mov ax, data
 16     mov ds, ax
 17     mov ax, table
 18     mov es, ax
 19 
 20 ; 1.把年份放入每行开头
 21     mov bx, 0   
 22     mov si, 0   
 23     mov di, 0   
 24     mov cx, 5  
 25 year:  
 26    
 27     mov dx, cx  
 28     mov cx, 4   
 29 yearnum:  
 30     
 31     mov al, byte ptr ds:[di]    
 32     mov byte ptr es:[bx][si], al
 33     inc si         
 34     inc di        
 35     loop yearnum 
 36     
 37 
 38     mov cx, dx      
 39     add bx, 10h    
 40     mov si, 0       
 41     loop year
 42  
 43     mov bx, 0      
 44     mov si, 5      
 45     mov cx, 5      
 46 income:
 47   
 48     mov ax, word ptr ds:[di]
 49     mov word ptr es:[bx][si], ax
 50     add si, 2
 51     add di, 2
 52     mov ax, word ptr ds:[di]
 53     mov word ptr es:[bx][si], ax
 54     add si, 2
 55     add di, 2               
 56 
 57     add bx, 10h     
 58     mov si, 5       
 59     
 60     loop income
 61 
 62 
 63     mov bx, 0       
 64     mov si, 0Ah     
 65     mov cx, 5      
 66 employee: 
 67     
 68     mov ax, word ptr ds:[di]
 69     mov word ptr es:[bx][si], ax
 70     add si, 2
 71     add di, 2
 72     
 73     add bx, 10h    
 74     mov si, 0Ah   
 75 
 76     loop employee
 77 
 78 
 79     mov bx, 0       
 80     mov si, 5      
 81     mov cx, 5      
 82 average:
 83     
 84     mov ax, word ptr es:[bx][si]
 85     add si, 2
 86     
 87     mov dx, word ptr es:[bx][si]
 88     add si, 3       
 89     div word ptr es:[bx][si]
 90     add si, 3       ;
 91     
 92     mov word ptr es:[bx][si], ax
 93     
 94     add bx, 10h    
 95     mov si, 5      
 96     loop average
 97 
 98 
 99     mov ah, 4ch
100     int 21h
101 code ends
102 end start