Experiment 2 compilation and debugging of assembly source program of multiple logic segments

experimental result

Experimental task 1

• Task 1-1

  • task1_1.asm source code

    assume ds:data, cs:code, ss:stack
    
    data segment
    	db 16 dup(0) ; 16 byte units are reserved, and the initial values are 0
    data ends
    
    stack segment
    	db 16 dup(0) ;16 byte units are reserved, and the initial values are 0
    stack ends
    
    code segment
    start:
        mov ax, data
        mov ds, ax
        mov ax, stack
        mov ss, ax
        mov sp, 16 ; Set stack top
        mov ah, 4ch
        int 21h
    code ends
    end start
    

  • task1_1 screenshot 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) =076AH, register (SS)=076BH, register (CS) =076CH
    ② 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.

• Task 1-2

  • Task task1_2.asm source code

    assume ds:data, cs:code, ss:stack
    
    data segment
    	db 4 dup(0) ; Four byte units are reserved, and the initial value is 0
    data ends
    
    stack segment
    	db 8 dup(0) ; 8 byte units are reserved, and the initial values are 0
    stack ends
    
    code segment
    start:
        mov ax, data
        mov ds, ax
        mov ax, stack
        mov ss, ax
        mov sp, 8 ; Set stack top
        mov ah, 4ch
        int 21h
    code ends
    end start
    

  • task1_2. After debugging to the end of line17 and before line19, observe the screenshot of register DS, CS and SS values

    

  • Question answer
    ① In debug, execute until the end of line17 and before line19. Record this time: register (DS) =076AH, register (SS)=076BH, register (CS) = 076ch
    ② 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.

• Task 1-3

  • Task task1_3.asm source code

    assume ds:data, cs:code, ss:stack
    
    data segment
    	db 20 dup(0) ; 20 byte units are reserved, and the initial values are 0
    data ends
    
    stack segment
    	db 20 dup(0) ; 20 byte units are reserved, and the initial values are 0
    stack ends
    
    code segment
    start:
    	mov ax, data
    	mov ds, ax
    	mov ax, stack
    	mov ss, ax
    	mov sp, 20 ; Set initial stack top
    	mov ah, 4ch
    	int 21h
    code ends
    end start
    

  • task1_3. Screenshot of the values of registers DS, CS and SS before the end of debugging to line17 and line19

    

  • Question answer
    ① In debug, execute until the end of line17 and before line19. Record this time: register (DS) =076AH, register (SS)= 076CH, register (CS) =076EH
    ② 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.

• Tasks 1-4

  • Task task1_4.asm source code

    assume ds:data, cs:code, ss:stack
    code segment
    start:
    	mov ax, data
    	mov ds, ax
    	mov ax, stack
    	mov ss, ax
    	mov sp, 20
    	mov ah, 4ch
    	int 21h
    code ends
    
    data segment
    	db 20 dup(0)
    data ends
    
    stack segment
    	db 20 dup(0)
    stack ends
    end start
    

  • task1_4. After debugging to the end of line17 and before line19, observe the screenshot of register DS, CS and SS values

    

  • Question answer
    ① In debug, execute until the end of line9 and before line11. Record this time: register (DS) =076CH, register (SS) =076EH, register (CS) = 076AH
    ② 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.

• 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 ceil(N/16)*16.

  xxx segment
  	db N dup(0)
  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.

  Task1_4.asm can be executed normally because it starts with a program.

Experiment task 2

• Assembly source code

  assume ds:data, cs:code
  
  data segment
          db 80 dup(03,04)
  data ends
  
  code segment
  start:
         mov ax, data
         mov ds, ax
  
         mov ax,0b8f0h
         mov es,ax
  
         mov bx,0
         mov cx,80
  s:     mov ax,[bx]
         mov  es:[bx],ax
         add  bx,2
         loop s
         
         mov ah,4ch
         int 21h
  code ends
  end start
  

• Screenshot of operation results

  

Test task 3

• Complete assembly source code

  assume cs:code
  data1 segment
      db 50, 48, 50, 50, 0, 48, 49, 0, 48, 49 ; ten numbers
  data1 ends
  
  data2 segment
      db 0, 0, 0, 0, 47, 0, 0, 47, 0, 0       ; ten numbers
  data2 ends
  
  data3 segment
      db 16 dup(0)
  data3 ends
  
  code segment
  start:
      mov ax, data1
      mov ds, ax
  
      mov bx, 0
      mov si, 16
      mov di, 32
      mov cx, 10
  s:  mov ax, [bx]
      add ax, [si]
      mov [di], ax
      inc bx
      inc si
      inc di
      loop s
  
      mov ax, 4C00H
      int 21H
  code ends
  end start
  

• Load, disassemble and debug screenshots in debug
  It is required to give the debug command and screenshot to view the original value of memory space data corresponding to logical segments data1, data2 and data3 before adding data items in turn
  And, after adding in turn, view the debug command and screenshot of the original value of memory space data corresponding to logical segments data1, data2 and data3

  

Experimental task 4

• Complete assembly source code

  assume cs:code
  data1 segment
  	dw 2, 0, 4, 9, 2, 0, 1, 9
  	data1 ends
  	data2 segment
  	dw 8 dup(?)
  data2 ends
  
  code segment
  start:
      mov ax, data1
      mov ds, ax
  
      mov si, 0
      mov di, 1eh
      mov cx, 8
  
  s:  mov ax, [si]
      mov [di], ax
      add si, 2
      sub di, 2
      loop s
  
      mov ah, 4ch
      int 21h
  	code ends
  end start
  

• Load, disassemble and debug screenshots in debug
  It is required to give a screenshot of the memory space corresponding to data segment data2 by using the d command before the program exits.

  

Experiment task 5

• task5.asm source code

  assume cs:code, ds:data
  data segment
  	db 'Nuist'
  	db 2, 3, 4, 5, 6
  data ends
  
  code segment
  start:
  	mov ax, data
  	mov ds, ax
  	mov ax, 0b800H
  	mov es, ax
  	mov cx, 5
  	mov si, 0
  	mov di, 0f00h
  s: 	mov al, [si]
  	and al, 0dfh
  	mov es:[di], al
  	mov al, [5+si]
  	mov es:[di+1], al
  	inc si
  	add di, 2
  	loop s
  	mov ah, 4ch
  	int 21h
  code ends
  end start
  

• Screenshot of operation results

  

• Use the debug tool to debug the program, and use the g command to execute the screenshot before the program returns (i.e. after ine25 and before line27)

  

• What is the function of line19 in the source code?

  Change lowercase letters to uppercase letters

• What is the purpose of the byte data in the data segment line4 in the source code?

  Change font color

Experimental task 6

• task6.asm source code

  assume cs:code, ds:data
  
  data segment
      db 'Pink Floyd      '
      db 'JOAN Baez       '
      db 'NEIL Young      '
      db 'Joan Lennon     '
  data ends
  
  stack segment
      db 16 dup(?)
  stack ends
  
  code segment
  start:
      mov ax, data
      mov ds, ax
      mov ax, stack
      mov ss, ax
  
      mov cx, 4
      mov bx, [0]
  s1: 
      push cx
          mov cx, 4
      s2: mov al, [bx]
          or al, 20h
          mov [bx], al
          inc bx
          loop s2
      add bx, 12
      pop cx
      loop s1
  
      mov ah, 4ch
      int 21h
  code ends
  end start
  

• Load, disassemble and debug screenshots in debug
  It is required to give a screenshot of the memory space corresponding to the data segment data by using the d command before the program exits.

  

Experimental task 7

• task7.asm source code

  assume cs:code, ds:data, es:table
  
  data segment
      db '1975', '1976', '1977', '1978', '1979'
      dw  16, 22, 382, 1356, 2390
      dw  3, 7, 9, 13, 28
  data ends
  
  table segment
      db 5 dup( 16 dup(' ') )
  table ends
  
  code segment
  start:
  
       mov ax, data
      mov ds, ax
      mov ax, table
      mov es, ax
  
      mov bx, 0
      mov si, 0
      mov cx, 5
  s0:mov ax, [si]
      mov es:[bx], ax
      mov ax, [si+2]
      mov es:[bx+2], ax
      add si, 4
      add bx, 10h
      loop s0
  
      mov bx, 0
      mov si, 14h
      mov cx, 5
  s1:mov ax, [si]
      mov es:[bx+5], ax
      mov ax, 0
      mov es:[bx+5+2], ax
      add si, 2
      add bx, 10h
      loop s1
  
      mov bx, 0
      mov si, 1eh
      mov cx, 5
  s2:mov ax,[si]
      mov es:[bx+0ah], ax
      add si, 2
      add bx, 10h
      loop s2
  
      mov bx, 0
      mov cx, 5
  s3:mov ax, es:[bx+5]
      mov dx, es:[bx+5+2]
      div word ptr es:[bx+0ah]
      mov es:[bx+0dh], ax
      add bx, 10h
      loop s3
  
      mov ah, 4ch
      int 21h
  code ends
  end start
  

• Debug screenshot

  • View screenshot of original data information of 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