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

本文主要是介绍实验2 多个逻辑段的汇编源程序编写与调试，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、实验目的

　　1. 理解和掌握8086多个逻辑段的汇编源程序　　2. 理解和熟练应用灵活的寻址方式　　3. 通过汇编指令loop的使用理解编程语言中循环的本质，掌握其在嵌套循环中的正确使用　　4. 掌握使用debug调试8086汇编程序的方法二、实验准备　　复习教材5-8章：　　包含多个逻辑段的汇编源程序结构　　寻址方式　　汇编指令loop, div用法三、实验内容 1.实验任务1 　　任务1-1

寄存器DS=076A；SS=076B；CS=076C；

Code的地址段是X，则Data的地址段是X-32；stack的地址段是X-16

任务1-2

寄存器DS=076A；SS=076B；CS=076C；

Code的地址段是X，则Data的地址段是X-12；stack的地址段是X-8

任务1-3

寄存器DS=076A；SS=076C；CS=076E；

Code的地址段是X，则Data的地址段是X-40；stack的地址段是X-20

任务1-4

寄存器DS=076C；SS=076E；CS=076A；

Code的地址段是X，则Data的地址段是X+20；stack的地址段是X+40

任务1-5

1：16*(N/16向上取整)

2：task1-4可以运行，因为start指明了代码段的起始位置，end后去除start后自动从程序开头执行；而只有1-4中指令从程序开头开始，其他为数据段开始会错误识别成指令，无法执行

任务2

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

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

3.实验任务3

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

 1 assume 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     mov bx, 0
19     mov cx, 0ah
20 s:    mov ax, ds:[bx]
21     add ax, ds:[bx+10h]
22     mov ds:[bx+20h], ax
23     inc bx
24     loop s
25 
26     mov ah, 4ch
27     int 21h
28 code ends
29 end start

4.实验任务4

 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     mov ah, 4ch
34     int 21h
35 code ends
36 end start

实验任务5

 1 assume cs:code, ds:data
 2 data segment
 3         db 'Nuist'
 4         db 5 dup(2)
 5 data ends
 6 
 7 code segment
 8 start:
 9         mov ax, data
10         mov ds, ax
11 
12         mov ax, 0b800H
13         mov es, ax
14 
15         mov cx, 5
16         mov si, 0
17         mov di, 0f00h
18 s:      mov al, [si]
19         and al, 0dfh
20         mov es:[di], al
21         mov al, [5+si]
22         mov es:[di+1], al
23         inc si
24         add di, 2
25         loop s
26 
27         mov ah, 4ch
28         int 21h
29 code ends
30 end start

问题3：line19作用：

0dfh=0000 1101 1111，相与运算将小写字母ASCII值减32变为大写字母

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

　　运行结果：db 5 dup（2）

实验任务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:    mov si, cx
21     mov cx, 4
22 s2:    mov al, es:[bx]
23     or al, 20h
24     mov es:[bx], al
25     inc bx
26     loop s2
27 
28     mov cx, si
29     mov bx, 0
30 
31     mov ax, es
32     inc ax
33     mov es, ax
34 
35     loop s1
36    mov ah, 4ch
37    int 21h
38 code ends
39 end start

 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     mov bx, 0   
21     mov si, 0   
22     mov di, 0  
23     mov cx, 5   
24 year:  
25     mov dx, cx  
26     mov cx, 4   
27 yearnum:  
28     mov al, byte ptr ds:[di]   
29     mov byte ptr es:[bx][si], al
30     inc si     
31     inc di     
32     loop yearnum 
33 
34     mov cx, dx     
35     add bx, 10h   
36     mov si, 0      
37     loop year
38 
39     mov bx, 0      
40     mov si, 5     
41     mov cx, 5      
42 income:
43     mov ax, word ptr ds:[di]
44     mov word ptr es:[bx][si], ax
45     add si, 2
46     add di, 2
47     mov ax, word ptr ds:[di]
48     mov word ptr es:[bx][si], ax
49     add si, 2
50     add di, 2               
51 
52     add bx, 10h    
53     mov si, 5      
54     
55     loop income
56 
57     mov bx, 0   
58     mov si, 0Ah   
59     mov cx, 5       
60 employee: 
61     mov ax, word ptr ds:[di]
62     mov word ptr es:[bx][si], ax
63     add si, 2
64     add di, 2
65     
66     add bx, 10h     
67     mov si, 0Ah    
68 
69     loop employee
70 
71     mov bx, 0       
72     mov si, 5       
73     mov cx, 5       
74 average:
75     mov ax, word ptr es:[bx][si]
76     add si, 2
77     mov dx, word ptr es:[bx][si]
78     add si, 3       
79     div word ptr es:[bx][si]
80     add si, 3     
81     mov word ptr es:[bx][si], ax
82     
83     add bx, 10h     
84     mov si, 5      
85     loop average
86 
87 
88     mov ah, 4ch
89     int 21h
90 code ends
91 end start