The third experiment of assembly language

1. Experimental task 1

  • task1 source code
 1 assume cs:code, ds:data 
 2 
 3 data segment 
 4     x db 1, 9, 3 
 5     len1 equ $ - x ; symbolic constants , $Refers to the offset address of the next data item. In this example, it is 3 
 6 
 7     y dw 1, 9, 3 
 8     len2 equ $ - y ; symbolic constants , $Refers to the offset address of the next data item. In this example, it is 9 
 9 data ends 
10 
11 code segment 
12 start:
13     mov ax, data 
14     mov ds, ax 
15 
16     mov si, offset x ; Take symbol x Corresponding offset address 0 -> si 
17     mov cx, len1 ; From symbol x Number of consecutive byte data items at the beginning -> cx 
18     mov ah, 2 
19 s1:mov dl, [si] 
20     or dl, 30h 
21     int 21h 
22 
23     mov dl, ' ' 
24     int 21h ; Output space 
25 
26     inc si 
27     loop s1 
28 
29     mov ah, 2 
30     mov dl, 0ah 
31     int 21h ; Line feed 
32 
33     mov si, offset y ; Take symbol y Corresponding offset address 3 -> si 
34     mov cx, len2/2 ; From symbol y Number of consecutive word data items started -> cx 
35     mov ah, 2 
36 s2:mov dx, [si] 
37     or dl, 30h 
38     int 21h
39  
40     mov dl, ' ' 
41     int 21h ; Output space 
42 
43     add si, 2 
44     loop s2 
45 
46     mov ah, 4ch 
47     int 21h 
48 code ends 
49 end start
  • Running screenshot

  • Question 1

The jump displacement is - 14. The compiler calculates the jump 8-bit displacement through the address at the label - the address of the first byte after the loop instruction. In this example, the offset address of s1 is 000D, and the offset address of the first byte after the loop instruction is 001B. The subtraction result is - 14.

  • Question 2

The jump displacement is - 10, the offset address of label s2 is 0029, and the offset address of the first byte after the loop instruction is 0039. The subtraction result is - 10. All loop instructions, including loop instructions, are short transfers, and the transfer displacement is included in the corresponding machine code instead of the address.

  •   Disassembly screenshot

 

  2. Experimental task 2

  • task2 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
26 
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
  • Analysis results

The source program line24 stacks the offset address (IP) of the next line instruction in memory, and modifies the content of the IP to the content of the word at ds:[0] in memory. Previously, the offset address (offset s1) of label s1 has been saved to ds:[0], so after the call instruction is executed, it jumps to label s1 for execution. The instruction at s1 takes the stack top data, that is, the offset address (IP) of the line25 pop instruction in memory, out of the stack and stores it in the register ax.

The line27 call instruction successively stacks the segment address (CS) and offset address (IP) of the next line instruction in memory, and modifies the contents of CS and IP to the contents of double words at memory ds:[2]. Previously, the offset address (offset s2) of label s2 was stored at ds:[2], and the segment address (CS) was stored at ds:[4]. Therefore, after the call instruction is executed, it jumps to label s2 for execution. The instruction after label s1 takes the stack top data (IP) out of the stack and stores it in register bx, and takes the stack top data (CS) out of the stack and stores it in register cx.

Conclusion: ax stores the offset address of the instruction at label s1 in memory, bx stores the offset address of the instruction at label s2 in memory, and cx stores the segment address of the instruction at label s2 in memory.

  • Debugging verification

  After reverse compilation, observe the address of the instruction at labels s1 and s2

The debugging results are the same as the analysis.

 

3. Experimental task 3

  • task3 source code
 1 assume cs:code, ds:data
 2 data segment
 3     x db 99, 72, 85, 63, 89, 97, 55
 4     len equ $- x
 5 data ends
 6 
 7 code segment
 8 start:
 9     mov ax, data
10     mov ds, ax
11     mov si, offset x
12     mov cx, len
13   s:mov ah, 0
14     mov al, [si]
15     mov dl, 10
16     div dl
17     mov bx, ax
18     mov ah, 2
19     call printNumber
20     call printSpace
21     inc si
22     loop s
23     mov ah, 4ch
24     int 21h
25     
26 printNumber:
27     mov dl, bl
28     or dl, 30h
29     int 21h
30     mov dl, bh
31     or dl, 30h
32     int 21h
33     ret
34 printSpace:
35     mov dl, ' '
36     int 21h
37     ret
38 code ends
39 end start
  • Run test

 

  4. Experimental task 4

  • task4 source code
 1 assume cs:code, ds:data
 2 data segment
 3     str db 'try'
 4     len equ $ - str
 5 data ends
 6 
 7 code segment
 8 start:
 9     mov ax, data
10     mov ds, ax
11 
12     mov si, offset str
13     mov bh, 0
14     mov bl, 2
15     call printStr
16 
17     mov si, offset str
18     mov bh, 24
19     mov bl, 4
20     call printStr
21 
22     mov ah, 4ch
23     int 21h
24 
25 printStr:mov cx, len
26   s:mov ax, 0b800h
27     mov dx, cx
28     mov ch, 0
29     mov cl, bh
30   t:add ax, 10
31     loop t
32     mov cx, dx
33     mov es, ax
34     mov di, si
35     add di, si
36     mov al, [si]
37     mov es:[di], al
38     mov es:[di].1, bl
39     inc si
40     loop s
41     ret
42 code ends
43 end start
  • Run test

 

  5. Experimental task 5

  • task5 source code
 1 assume cs:code, ds:data
 2 data segment
 3     stu_no db '201983300512'
 4     len = $ - stu_no
 5 data ends
 6 
 7 code segment
 8 start:
 9     mov ax, data
10     mov ds, ax
11     call blueCurtain
12     call printStu_no
13 
14     mov ah, 4ch
15     int 21h
16 printStu_no:mov ax, 0b800h
17     mov cx, 24
18   s:add ax, 10
19     loop s
20     mov es, ax
21     mov di, 0
22     mov cx, 34
23   l:mov byte ptr es:[di], '-'
24     add di, 2
25     loop l
26     mov cx, len
27     mov si, offset stu_no
28   t:mov dl, [si]
29     mov es:[di], dl
30     inc si
31     add di, 2
32     loop t
33     mov cx, 34
34   r:mov byte ptr es:[di], '-'
35     add di, 2
36     loop r
37     ret
38 
39 blueCurtain:mov ax, 0b800h
40     mov es, ax
41     mov cx, 2000
42     mov si, 0
43   b:mov byte ptr es:[si].1, 23
44     add si, 2
45     loop b
46     ret
47 
48 code ends
49 end start
  • Run test

 

Posted on Fri, 26 Nov 2021 21:32:14 -0500 by tolli