Experiment 3 transfer instruction jump principle and its simple application programming

1, Experimental purpose

1. Understand and master the jump principle of transfer instruction
2. Master the method of using call and ret instructions to realize subroutines, and understand and master the parameter transfer mode
3. Understand and master 80 × 25 color character mode display principle
4. Integrate addressing mode and assembly instructions to complete simple application programming

2, Experimental conclusion

1. Experimental task 1

Contents of this part:
  • Give the program task1.asm source code, and run screenshots
    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
  • Answer question ①
    ① 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.
    The displacement is 001B-000D and 14, which is obtained by subtracting s1 from 001B at the end of loop command
  • Answer question ②
    ② line44. When the assembly instruction loop s2 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 s2.
    The displacement is 0039-0029 and 16, which is obtained by subtracting s2 from 0039 at the end of loop command
  • Question ③
    ③ Attach the disassembly screenshot of debugging observation in debug during the above analysis

2. Experimental task 2

Contents of this part:
  • 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) =? (bx) = (cx) =? Attach the screenshot of the debugging result interface.

        

        ① 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) =?
      The last assignment of ax is at pop ax in line 25. At this time, the value at the top of the stack is the address of s1, and the ax value is the address of line 25
      The last assignment of bx is at pop ax in line 28. At this time, the value at the top of the stack is the address of s2, so the bx value is the address of line 28
      The last assignment of cx is at pop cx in line 29. At this time, the stack is empty. If you continue pop, you will put forward the last value in the data section, which is the value of cs, that is, the short address of the code section

      ② 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.
      As a result, register (ax) =0021 register (bx) = 0026 register (cx) = 076C
      It is consistent with s1 position, s2 position and cs value

3. Experimental task 3

Contents of this part:
  • 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
    
      s:mov al, [si]
        mov ah, 0
        mov bl, 10
        div bl
        or ah, 30h
        or al, 30h
        mov bh, ah
        mov bl, al
        call s1
        call s2
        inc si
        loop s
    
        mov ah, 4ch
        int 21h
    
    s1:
        mov ah, 2
        mov dl, bl
        int 21h
        mov dl, bh
        int 21h
        ret
    
    s2:
        mov ah, 2
        mov dl, ' '
        int 21h
        ret
    
    code ends
    end start
  • Screenshot of running test

4. Experimental task 4

Contents of this part:
  • 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
    mov es, ax
    mov si, offset str

    mov bh, 0
    mov bl, 160
    mov al, bh
    mul bl
    mov di, ax

    mov bl, 2
    mov cx, len

    s:call s1
    inc si
    loop s

    mov si, offset str
    mov bh, 24
    mov bl, 160
    mov al, bh
    mul bl
    mov di, ax

    mov bl, 4
    mov cx, len

    s2:call s1
    inc si
    loop s2

    mov ah, 4ch
    int 21h

    s1:mov al, [si]
    mov es:[di], al
    inc di
    mov es:[di], bl
    inc di
    ret

    code ends
    end start

  • Screenshot of running test

5. Experimental task 5

Contents of this part:
  • The program source code task5.asm is given
    assume cs:code, ds:data
    data segment
        stu_no db '----------------------------------201983290423----------------------------------'
        len = $ - stu_no
    data ends
    
    code segment
    start:
        mov ax, data
        mov ds, ax
        mov ax, 0b800h
        mov es, ax
        mov si, offset stu_no
    
        mov ah, 00010111B
    
    
        mov cx, 0f00h
        mov al, ' '
        mov di, 0
       
    s2:call s1
        loop s2
    
        mov di, 0f00h
        mov cx, len
    
      s:mov al, [si]
        call s1
        inc si
        loop s
    
        mov ah, 4ch
        int 21h
    
    s1:mov es:[di], al
        inc di
        mov es:[di], ah
        inc di
        ret
    
    code ends
    end start
  • Screenshot of running test

Posted on Wed, 01 Dec 2021 14:09:56 -0500 by sheckel