Experiment 3 transfer instruction jump principle and its simple application programming

------------Restore content start------------

1. Experimental task 1
  • The source code of the program task1.asm and the screenshot of its operation are given:
assume cs:code, ds:data

data segment
    x db 1, 9, 3
    len1 equ $ - x

    y dw 1, 9, 3
    len2 equ $ - y
data ends

code segment
start:
    mov ax, data
    mov ds, ax

    mov si, offset x
    mov cx, len1
    mov ah, 2
 s1:mov dl, [si]
    or dl, 30h
    int 21h

    mov dl, ' '
    int 21h

    inc si
    loop s1

    mov ah, 2
    mov dl, 0ah
    int 21h

    mov si, offset y
    mov cx, len2/2
    mov ah, 2
 s2:mov dx, [si]
    or dl, 30h
    int 21h

    mov dl, ' '
    int 21h

    add si, 2
    loop s2

    mov ah, 4ch
    int 21h
code ends
end start

 

  • 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

 

  According to the machine code, the complement of the offset displacement is F2H, which is expressed as - 14 in decimal number, so the offset is 14; According to the space occupied by the opcode, the machine code occupies a total of 14 bytes from the last instruction after loop s1 to label s1.

  • line44. When the assembly instruction loop s2 jumps, it jumps according to the displacement. Check the machine through debug disassembly
    What is the jump displacement of the code? (the displacement value is answered in decimal) from the perspective of CPU, it is explained
    How to calculate the offset address of the instruction after the jump label s2.

 

  According to the results, the complement of the displacement is F0, which is converted to hexadecimal to - 16, so the offset is 16. Between the next instruction after loop s2 and label s2, the machine code occupies a total of 16 bytes.

2. Experimental task 2  
  • The program task2.asm source code is given
assume cs:code, ds:data

data segment
    dw 200h, 0h, 230h, 0h
data ends

stack segment
    db 16 dup(0)
stack ends

code segment
start:  
    mov ax, data
    mov ds, ax

    mov word ptr ds:[0], offset s1
    mov word ptr ds:[2], offset s2
    mov ds:[4], cs

    mov ax, stack
    mov ss, ax
    mov sp, 16

    call word ptr ds:[0]
s1: pop ax

    call dword ptr ds:[2]
s2: pop bx
    pop cx

    mov ah, 4ch
    int 21h
code ends
end start
  • After analysis, debugging and verification, register (ax) = 0021 (bx) = 0026 (cx) = 076C, attach the screenshot of the debugging result interface.

  • ① According to the jump principle of call instruction, it is analyzed theoretically that the register (ax) before the program execution to exit (line31)=
    ? register (bx) =? Register (cx) =?

A: theoretically, when using the call word instruction, the offset address (current ip) of his next instruction will be pushed into the stack. Therefore, when using the call word instruction for the first time, 0021 will enter the stack. The second call instruction is call dword. It is convenient to enter the cs: ip address into the stack. The first segment address in it will be saved with the offset address. Therefore, ax=0021, bx=0026, cx=076c

  • ② Assemble and link the source program to get the executable program task2.exe. Use debug to debug, observe and verify debugging
    Are the results consistent with the theoretical analysis

Answer: consistent

3. Experimental task 3
The program source code task3.asm is given:
 
assume cs:code, ds:data

data segment
    x db 99, 72, 85, 63, 89, 97, 55 
    len equ $- x
data ends

code segment
start:
    mov ax, data
   mov ds, ax
   
    mov si, offset x
    mov cx, len
    mov bl,0ah
 s1:
     mov al, [si]
     mov ah,0;A 0 must be filled,The divisor must be 16 bits
    call printNumber

    inc si
    call printSpace
    
    loop s1

     mov ah, 4ch
    int 21h
    printSpace proc
    mov ah, 2
         mov dl, ' '
         int 21h
      ret

    printSpace endp
    printNumber proc
 
      div bl;Divisor 8 bits
      mov dl,al;al Storage provider
      or dl,30h;
      mov dh,ah
      or dh,30h
      mov ah, 2
      mov dl,dl
      int 21h
      mov dl,dh
      int 21h
      ret
    printNumber endp

code ends
end start

Screenshot of running test:

4. Experimental task 4
  • The program source code task4.asm is given
assume cs:code, ds:data

data segment
        str db 'try'
        len equ $ - str
data ends

code segment
start:
        mov ax, data
        mov ds, ax
        mov ax, 0b800h ;B8000H~BFFFFH Space 32 in total KB The space is 80*25 Display buffer in color character mode
        mov es, ax

        mov si, offset str;Offset address - si
        mov cx, len;
        mov bl, 2h ;The color is green,
        mov bh, 0 ;The number of rows is row 0
        call printStr

        mov si, offset str
        mov cx, len
        mov bl, 4h ;The color is red
        mov bh, 24 ;The number of lines is line 24
        call printStr

        mov ax, 4c00h
        int 21h

printStr:
        mov al, 160 ;Space occupied by each line of characters: Where characters are stored in high places ascll Code, with attributes stored in the low order
        mul bh ;8 Bit operands and AL Multiplication of registers;
        mov di, ax ;ax For the first bh Offset of row
s:      mov ah, ds:[si];character
        mov es:[di], ah 
        mov es:[di+1], bl ;colour

        add di, 2
        inc si
        loop s
        ret

code ends
end start
  • Screenshot of running test

 

5. Experimental task 5
  • The program source code task5.asm is given
assume ds:data, cs:code

data segment
    str db '201983290280'
    len equ $ - str
data ends

code segment
start:
        mov ax, data
        mov ds, ax
        mov ax, 0b800h
        mov es, ax
        mov cx, 4000 ;The number of bytes occupied by the content of each screen in the display buffer:80×25×2 = 4000Bytes
        mov di, 0
        mov ah,17h ;White characters on blue background     00010111
 s1:    mov al, 0
        mov es:[di], al
        mov es:[di+1], ah
        add di, 2
        loop s1
        ;At the beginning of the last line-
        mov di, 3840 ;Start on line 24
        call printSign;
        ;Print student number
        mov di, 3908 ;3840+68
        mov si, offset str
        mov cx, len
        mov ah, 17h
s2:    call printstr
        inc si
        add di, 2
        loop s2

        ;At the end of the last line-
        mov di, 3932 ;=3840-68
        call printSign
        mov ax, 4c00h
        int 21h

printstr:
        mov al, [si]
        mov es:[di], al
        mov es:[di+1], ah
        ret
printSign:
        mov cx, 34
        mov ah, 17h
      s :mov al, 2Dh ;-
        mov es:[di], al
        mov es:[di + 1], ah
        add di,2
        loop s
        ret

code ends
end start
  • Screenshot of running test

 

 

 

Posted on Sun, 28 Nov 2021 20:06:43 -0500 by jd57