Experiment 1 Compilation and debugging of assembly source program for multiple logic segments
Experiment task 1:
(1) Task 1-1:
- task1_1.asm source code:
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
- task1_1. Screenshot from the end of debugging to line17 and before line19:
- Question answer
① In debug, execute until the end of line17 and before line19. Record this time: register (DS) = 076A, register (SS) = 076B, register (CS)= 076C
② Assuming that the segment address of the code segment is X after the program is loaded, the segment address of the data segment is X-2 and the segment address of the stack is X-1
(2) Task 1-2:
- Task task1_2.asm source code:
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
- task1_2 screenshot of register DS, CS and SS values before the end of line17 and line19:
- Question answer
① In debug, execute until the end of line17 and before line19. Record this time: register (DS) = 076A, register (SS) = 076B, register (CS) = 076C
② Assuming that the segment address of the code segment is X after the program is loaded, the segment address of the data segment is X-2 and the segment address of the stack is X-1
(3) Tasks 1-3:
- Task task1_3.asm source code:
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
- task1_3 screenshot of register DS, CS and SS values before the end of line17 and line19:
- Question answer
① In debug, execute until the end of line17 and before line19. Record this time: register (DS) = 076A, register (SS) = 076C, register (CS) = 076E
② Assuming that the segment address of the code segment is X after the program is loaded, the segment address of the data segment is X-4 and the segment address of the stack is X-2
(4) Tasks 1-4:
- Task task1_4.asm source code:
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
- task1_4 screenshot of register DS, CS and SS values before the end of line17 and line19:
- Question answer
① In debug, execute until the end of line9 and before line11. Record this time: register (DS) = 076C, register (SS) = 076E, register (CS) = 076A
② Assuming that the segment address of the code segment is X after the program is loaded, the segment address of the data segment is X+2 and the segment address of the stack is X+4
(5) Tasks 1-5:
Based on the practice and observation of the above four experimental tasks, summarize and answer:
① for the segment defined below, after the program is loaded, the actual memory space allocated to the segment is 16*Math.ceil(N/16).
1 xxx segment 2 db N dup(0) 3 xxx ends
② if the program Task1_ 1.asm, task1_ 2.asm, task1_ 3.asm, task1_ 4. In ASM, if the pseudo instruction end start is changed to end, which program can still be executed correctly. The reasons are analyzed and explained in combination with the conclusions obtained from practical observation.
A: only task1_4.asm can be executed correctly. Observed through practice: Task1_ 1~task1_ cs in 3 has no code that needs to be executed. Without end start, it means that the end position of code execution is not defined in the program. In Task1_ 1~task1_ In 3, the data segment is executed and the code segment execution fails. In task1_4, because the code segment is defined at the beginning, it is called task1_4 can be executed successfully.
Experiment task 2:
- Assembly source code:
1 assume cs:code 2 code segment 3 start: 4 mov ax,0b800h 5 6 mov ds,ax 7 mov bx,0f00h 8 mov ax,0403h 9 10 mov cx,80 11 s: 12 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
- Screenshot of operation results:
Experiment task 3:
- Complete assembly source code:
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,10h 20 s: 21 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
- Screenshot of loading, disassembling and debugging in debug:
- debug command and screenshot of the original value of memory space data corresponding to logical segments data1, data2 and data3 before data items are added in turn:
- After adding in sequence, the debug command and screenshot of the original value of memory space data corresponding to logical segments data1, data2 and data3:
Experiment task 4:
- Complete assembly source code:
1 assume cs:code 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(?) 9 data2 ends 10 11 code segment 12 start: 13 mov ax,data1 14 mov ds,ax 15 mov ax,data2 16 mov ss,ax 17 mov sp,16 18 mov bx,0 19 mov cx,8 20 s :push ds:[bx] 21 add bx,2 22 loop s 23 24 mov ah, 4ch 25 int 21h 26 code ends 27 end start
- Screenshot of loading, disassembling and debugging in debug:
- Before the program exits, use the d command to view a screenshot of the memory space corresponding to data segment data2.
Experiment task 5:
- task5.asm source code:
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 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
- Screenshot of operation results:
- Use the debug tool to debug the program, and use the g command to execute it once before the program returns (i.e. after ine25 and before line27):
- What is the function of line19 in the source code?
A: the code of line19 is: and al, 0dfh, where and means to perform and operate by bit, that is, AL performs and operates on DF(1101 1111), that is, set the third position on the left as 0
- What is the purpose of the byte data in the data segment line4 in the source code?
A: the purpose of db is to allocate a storage unit for the following numbers.
Experiment task 6:
- task6.asm source code:
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 mov bx,0 15 mov cx,4 16 s: or [bx],byte ptr 00100000b 17 add bx,16 18 loop s 19 20 mov ah, 4ch 21 int 21h 22 code ends 23 end start
- Screenshot of loading, disassembling and debugging in debug:
- Before the program exits, use the d command to view a screenshot of the memory space corresponding to the data segment data:
Experiment task 7:
- task7.asm source code:
1 assume cs:code, ds:data, es:table
2
3 data segment
4 db '1975', '1976', '1977', '1978', '1979'
5 dw 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 cx,5
21 mov si,0
22 mov bx,0
23 s: mov ax,[si]
24 mov es:[bx],ax
25 mov ax,[si+2]
26 mov es:[bx+2],ax
27 add bx,10h
28 add si,4
29 loop s ;particular year
30
31 mov cx,5
32 mov si,20
33 mov bx,5
34 s1:mov ax,[si]
35 mov es:[bx],ax
36 mov ax,0
37 mov es:[bx+2],ax
38 add bx,16
39 add si,2
40 loop s1; ;income
41
42 mov cx,5
43 mov si,30
44 mov bx,10
45 s2:mov ax,[si]
46 mov es:[bx],ax
47 add bx,16
48 add si,2
49 loop s2 ;Number of employees
50
51 mov cx,5
52 mov si,5
53 s3:mov ax,es:[si]
54 mov bl,es:[si+5]
55 div bl
56 mov es:[si+8],al
57 add si,16
58 loop s3 ;Per capita income
59
60 mov ah, 4ch
61 int 21h
62 code ends
63 end start- Commissioning screenshot:
- View the screenshot of the original data information of the table segment:
- Run in debug until the program exits, use the d command to view the screenshot of the memory space corresponding to the table segment, and confirm whether the information is structurally written to the specified memory as required
