1. Experimental task 1
1)task1.asm source code:
1 assume cs:code, ds:data 2 3 data segment 4 x db 1, 9, 3 5 len1 equ $ - x 6 7 y dw 1, 9, 3 8 len2 equ $ - y 9 data ends 10 11 code segment 12 start: 13 mov ax, data 14 mov ds, ax 15 16 mov si, offset x 17 mov cx, len1 18 mov ah, 2 19 s1:mov dl, [si] 20 or dl, 30h 21 int 21h 22 23 mov dl, ' ' 24 int 21h 25 26 inc si 27 loop s1 28 29 mov ah, 2 30 mov dl, 0ah 31 int 21h 32 33 mov si, offset y 34 mov cx, len2/2 35 mov ah, 2 36 s2:mov dx, [si] 37 or dl, 30h 38 int 21h 39 40 mov dl, ' ' 41 int 21h 42 43 add si, 2 44 loop s2 45 46 mov ah, 4ch 47 int 21h 48 code ends 49 end start
Screenshot of compilation, connection and operation:
① line27, when the assembly instruction loop s1 jumps, it jumps according to the displacement. Check the machine code through debug disassembly and analyze the jump displacement? (the displacement value is answered in decimal) from the perspective of the CPU, explain how to calculate the offset address of the instruction after the jump label s1.
debug disassembly:
(1) The machine code of the loop instruction is E2F2, and the 8-bit shift of the jump = the address at the label - the address of the first byte after the loop instruction.
Here, the address at the label is s1, and the address of the first byte after the loop instruction is 076B:000D. The address of the next instruction after the loop instruction is 076B:001B.
Therefore, 8-bit displacement = 000D-001B=-0E (hexadecimal) = - 14 (decimal), and the hexadecimal complement is F2.
(2) The CPU calculates the offset address (IP) after the jump through the machine code of the loop instruction and the current IP.
Machine code E2F2, where E2 indicates that this command is a loop instruction, and F2 is the hexadecimal complement form of displacement.
When the CPU reads and executes E2F2, the current IP=001B (0019 + 0003), and after jump, IP = current IP + displacement = 001B-0E=000D.
② line44, when the assembly instruction loop s2 jumps, it jumps according to the displacement. Through debug disassembly, check its machine code and analyze the jump displacement? (the displacement value is answered in decimal) from the perspective of CPU, explain how to calculate the offset address of the instruction after the jump label s2.
debug disassembly:
(1) The machine code of the loop instruction is E2F0, and the 8-bit shift of the jump = the address at the label - the address of the first byte after the loop instruction.
Here, the address at the label is s2, and the address of the first byte after the loop instruction is 076B:0029. The address of the next instruction after the loop instruction is 076B:0039.
Therefore, the 8-bit displacement = 0029-0039 = - 10 (hexadecimal) = - 16 (decimal), and the hexadecimal complement is F0.
(2) The CPU calculates the offset address (IP) after the jump through the machine code of the loop instruction and the current IP.
Machine code E2F0, where E2 indicates that the command is a loop instruction, and F0 is the hexadecimal complement of the displacement.
When the CPU reads and executes E2F0, the current IP=0039 (0037 + 0002), and after jump, IP = current IP + displacement = 0039-10 = 0029.
2. Experimental task 2
1)task2.asm source code:
1 assume cs:code, ds:data 2 3 data segment 4 dw 200h, 0h, 230h, 0h 5 data ends 6 7 stack segment 8 db 16 dup(0) 9 stack ends 10 11 code segment 12 start: 13 mov ax, data 14 mov ds, ax 15 16 mov word ptr ds:[0], offset s1 17 mov word ptr ds:[2], offset s2 18 mov ds:[4], cs 19 20 mov ax, stack 21 mov ss, ax 22 mov sp, 16 23 24 call word ptr ds:[0] 25 s1: pop ax 27 call dword ptr ds:[2] 28 s2: pop bx 29 pop cx 30 31 mov ah, 4ch 32 int 21h 33 code ends 34 end start
① According to the jump principle of call instruction, it is analyzed theoretically that before the program executes to exit (line31), register (ax) =? Register (bx) =? Register (cx) =?
(1) call word ptr memory unit is equivalent to
push IP
jmp word ptr memory unit address
(2) call dword ptr memory unit is equivalent to
push CS
push IP
jmp dword ptr memory unit address
(3) The IP of s1 is stored in ds:[0], and the IP of s2 is stored in ds:[2]. The first call instruction first pushes the IP of s1 into the stack, and then jumps to ds:[0], that is, s1 to execute pop ax, that is, s1's IP=0021 is out of the stack and stored in ax.
(4) The second call instruction first pushes the CS at s2 into the stack, then pushes the IP at s2 into the stack, and then jumps to ds:[2], that is, execute pop bx at s2, that is, get the IP:0026 of s2 out of the stack and store it in bx, and then execute pop cx, that is, get the CS:076C of s2 out of the stack and store it in cx.
To sum up, the program is executed before line31, ax=0021, bx=0026, cx=076C
② Assemble and link the source program to get the executable program task2.exe. Use debug to observe and verify whether the debugging results are consistent with the theoretical analysis results.
Screenshot of compilation and connection:
Use debug to debug, observe and verify the debugging results
Run to line 31 before -g 076C:0028
It can be seen that ax=0021, bx=0026, cx=076C, which is consistent with the theoretical value.
3. Experimental task 3
Write the 8086 assembly source program task3.asm to output this group of continuous data in the data section in decimal form on the screen, and the data is separated by spaces.
1)task3.asm source code:
1 assume cs:code, ds:data 2 3 data segment 4 x db 99, 72, 85, 63, 89, 97, 55 5 len equ $ - x 6 data ends 7 8 code segment 9 start: 10 mov ax, data 11 mov ds, ax 12 mov si, offset x 13 mov cx, len 14 mov byte ptr ds:[8],10 ;Use a memory unit to store divisor 10. Be careful not to use the used memory space 15 16 s: mov ah, 0 17 mov al, [si] 18 div byte ptr ds:[8] ;Divisor x The remainder of division 10 and the existence of commercial insurance ax in 19 call printNumber 20 call printSpace 21 22 inc si 23 loop s 24 25 mov ax, 4c00h 26 int 21h 27 28 printNumber: 29 mov bx, ax ;Used here bx Temporary storage, because the output characters need to be used ax 30 or bh, 30h ;Converted to digital ASCII Code value 31 or bl,30h 32 mov ah,2 ;Ready to output characters 33 mov dl,bl ;First exporter 34 int 21h; 35 mov dl,bh ;Re output remainder 36 int 21h; 37 ret 38 39 printSpace: 40 mov ah, 2 41 mov dl, ' ' 42 int 21h 43 ret 44 45 code ends 46 end start
2) Screenshot of running test
4. Experimental task 4
Output a string on the screen with a specified color and a specified line.
1)task4.asm source code:
1 assume cs:code, ds:data 2 3 data segment 4 str db 'try' 5 len equ $ - str 6 data ends 7 8 code segment 9 start: 10 mov ax, data 11 mov ds, ax 12 mov ax, 0b800h ;Show beginning of buffer 13 mov es, ax 14 15 mov si, offset str 16 mov cx, len 17 mov bl, 2h ;The color is green 18 mov bh, 0 ;The number of rows is row 0 19 call printStr 20 21 mov si, offset str 22 mov cx, len 23 mov bl, 4h ;The color is red 24 mov bh, 24 ;The number of lines is line 24 25 call printStr 26 27 mov ax, 4c00h 28 int 21h 29 30 printStr: 31 mov al, 160 ;Space occupied by each line of characters: 80×2=160Bytes 32 mul bh 33 mov di, ax ;ax For the first bh Offset of row 34 s: mov ah, ds:[si] 35 mov es:[di], ah ;character 36 mov es:[di+1], bl ;colour 37 38 add di, 2 39 inc si 40 loop s 41 ret 42 43 code ends 44 end start
2) Screenshot of running test
5. Experimental task 5
At 80 × In 25 color character mode, the student number is displayed in the middle of the last line of the screen. It is required that the blue background, student number and broken lines on both sides of the output window be displayed in white foreground color.
White characters on blue background: 0001,0111 = 17h
1)task5.asm source code:
1 assume ds:data, cs:code 2 3 data segment 4 stu_no db '201983290278' 5 len = $ - stu_no 6 data ends 7 8 code segment 9 start: 10 mov ax, data 11 mov ds, ax 12 mov ax, 0b800h 13 mov es, ax 14 mov cx, 4000 ;The number of bytes occupied by the content of each screen in the display buffer:80×25×2 = 4000Bytes 15 mov di, 0 16 mov ah,17h ;White characters on blue background 17 18 s1: mov al, 0 19 mov es:[di], al 20 mov es:[di+1], ah 21 add di, 2 22 loop s1 23 24 ;At the beginning of the last line- 25 mov di, 3840 ;Start on line 24 26 mov cx, 34 ;=(160-12*2)/2/2 27 mov ah, 17h 28 s2: call printSign 29 add di, 2 30 loop s2 31 32 ;Print student number 33 mov di, 3908 ;3840+(160-12*2)/2=3840+68 34 mov si, offset stu_no 35 mov cx, len 36 mov ah, 17h 37 s3: call printStu_no 38 inc si 39 add di, 2 40 loop s3 41 42 ;At the end of the last line- 43 mov di, 3932 ;=3840-68 44 mov cx, 34 45 mov ah, 17h 46 s4: call printSign 47 add di, 2 48 loop s4 49 50 mov ax, 4c00h 51 int 21h 52 53 printStu_no: 54 mov al, [si] 55 mov es:[di], al 56 mov es:[di+1], ah 57 ret 58 59 printSign: 60 mov al, 2Dh ;- 61 mov es:[di], al 62 mov es:[di + 1], ah 63 ret 64 65 code ends 66 end start
2) Screenshot of running test
