《x86汇编语言从实模式到保护模式》学习实验笔记【08】代码重定位

太过爱你忘了你带给我的痛 2023-02-08 15:49 2阅读 0赞

### 目录 ###

*  过程调用和无条件跳转
 *   *  过程调用
     *   *  16位相对近调用
         *  16位间接绝对近调用
         *  16位直接绝对远调用
         *  16位间接绝对远调用
         *  过程返回ret和retf
     *  无条件跳转
     *   *  相对短转移
         *  16位相对近转移
         *  16位间接绝对近转移
         *  16位直接绝对远转移
         *  16位间接绝对远转移
 *  加载协议
 *  段重定位表
 *  根据加载协议改造应用程序
 *  加载器
 *  对段重定位表进行修正
 *  整个加载器的源代码
 *  工程Makefile文件
 *  运行效果

# 过程调用和无条件跳转 #

## 过程调用 ##

在nasm里面，过程调用的指令是call。8086支持四种调用方式：

*  16位相对近调用
 *  16位间接绝对近调用
 *  16位直接绝对远调用
 *  16位间接绝对远调用

### 16位相对近调用 ###

call near procName 或者 call procName  
也就是说，关键字near可以省略。该机器指令的跳转位置是相对于当前ip指令寄存器的，其偏移量offset是一个16位的有符号数，取值范围是-32768~32767。即procName的地址必须位于距离当前指令-32768~32767字节的地方。

### 16位间接绝对近调用 ###

call cx  
call \[bx\]  
call \[bx+si+0x2\]  
即从cx寄存器取值，或者到bx指向的地址中取值，将该值直接赋给ip寄存器，即在当前的代码段内任意跳转。

### 16位直接绝对远调用 ###

call 0x2000:0x0030  
这种调用属于段间调用，故称为远调用，这里的地址以段地址:偏移地址的形式直接给出。

### 16位间接绝对远调用 ###

call far \[bx\]  
call far \[0x2000\]  
call far \[labelName\]  
call far \[bx+si\]  
这些地址处都依次存放着目标的偏移地址和段地址。偏移地址在前，段地址在后。其中far关键字不能省略。

### 过程返回ret和retf ###

对于近调用call，使用ret与其配对。对于远调用call far，则使用retf与其配对。  
ret是近返回指令，当执行它时，处理器只做一件事，就是从栈中弹出一个字到指令寄存器ip中；  
retf时远返回指令，当执行它时，处理器分别从栈中弹出两个字，依次弹到ip寄存器和cs段寄存器中。

最后需要强调一点，call、call far、ret和retf指令都不会影响标志寄存器的值。

## 无条件跳转 ##

无条件跳转共分为5种情况：

*  相对短转移
 *  16位相对近转移
 *  16位间接绝对近转移
 *  16位直接绝对远转移
 *  16位间接绝对远转移

### 相对短转移 ###

jmp short labelName  
只允许在当前指令前后-128~127字节内跳转，必须使用关键字short。

### 16位相对近转移 ###

jmp near labelName  
jmp near 0x3000

### 16位间接绝对近转移 ###

jmp near bx  
jmp near \[memAddress\]  
jmp near \[bx\]  
jmp near \[bx+si\]  
直接使用bx寄存器的值，或者内存中的值替换ip寄存器的值，可实现在当前代码段内任意跳转。

### 16位直接绝对远转移 ###

jmp 0x0000:0x7c00  
以段地址:偏移地址的形式给出，实现任意跳转。

### 16位间接绝对远转移 ###

jmp far \[memAddress\]  
jmp far \[bx\]  
jmp far \[bx+si\]

这些地址处都依次存放着目标的偏移地址和段地址。偏移地址在前，段地址在后。其中far关键字不能省略。

# 加载协议 #

8086处理器的工作模式是将内存分成逻辑上的段。指令的获取和数据的访问一律按照“段地址：偏移地址”的形式进行。  
nasm对段的数量没有任何限制，但8086处理器要求段在内存中的起始物理地址必须是16字节对齐的。nasm提供了对齐的语法支持，align=16即表明使用16字节对齐。

下面我们要做的工作就是将主引导扇区改造成一个程序加载器，用它来加载硬盘指定位置上的应用程序，之后将控制权转交给该应用程序。应用程序由上一篇博客中的字符打印程序修改而来。

一般而言，加载器和应用程序之间彼此不需要了解对方的具体结构和功能实现。但是，加载器必须了解一些必要的信息，如应用程序的总大小，程序入口点，段重定位表的信息。有了这些信息，加载器就可以非常方便地完成加载和重定位工作。

而这些必要的信息，就是我们所说的加载协议。这个信息一般都是放在应用程序的头部。为此，我们在应用程序的头部专门使用一个段来构造加载协议信息。

<table> 
 <thead> 
  <tr> 
   <th>条目名称</th> 
   <th>占用字节数</th> 
   <th>偏移量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>应用程序大小</td> 
   <td>4</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>入口点</td> 
   <td>6</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>段重定位表项数</td> 
   <td>2</td> 
   <td>10 (0xA)</td> 
  </tr> 
  <tr> 
   <td>段重定位表</td> 
   <td>不定，每一项4个字节</td> 
   <td>12 (0xC)</td> 
  </tr> 
 </tbody> 
</table>

需要说明的是，应用程序的入口点包括偏移地址和段地址。段地址使用表达式section.段名称.start来得到。偏移地址在前，占2个字节。段地址在后，由于它有20位，所以我们使用4个字节来存储。所以入口点一共占据6个字节。

由于段重定位表的项数不会太多，所以我们使用两个字节来存储项数即可，最多可存储65535项。

段重定位表中存储的是应用程序中所有段各自的起始地址，应用程序中有多少个段，段表中就有多少项。由于16位实模式环境下段的物理地址都是20位，所以段表中每项我们使用4个字节来存储。

# 段重定位表 #

由于段重定位表每一项占用4个字节，所以表的项数我们使用如下代码进行计算：

;segment relocator item count
    dw	(header_end - code_1_segment)/4		;0xA

其中header\_end 是段重定位表结束的地方，code\_1\_segment是其开始处，二者相减后再除以4，即可得出总项数。

当加载程序加载应用之后，会根据实际的加载物理地址，对段重定位表进行修正，修正后，段重定位表的每一项只使用低2个字节，用于存放应用程序中各个段的实际段地址。

因此，在应用程序的代码中，当需要访问数据段或者别的代码段中的指令时，要通过段重定位表来进行间接访问。了解到这一点是十分重要的。

在下面的应用程序中，我们使用了两个代码段，在段间跳转时我们借助了栈和retf指令。

代码段2中实现了打印功能，打印完毕后，我们仍然跳回到代码段1中，并在屏幕的第二行输出一个单词final来表明我们已经正常回到了代码段1中，此后程序一直死循环。

# 根据加载协议改造应用程序 #

VideoIndexPort equ 0x3D4
    VideoDataPort equ 0x3D5
    
    CursorPosHigh8Index equ 0xE
    CursorPosLow8Index equ 0xF
    
    section header align=16 vstart=0
    ;app length
    app_header dd (app_end - app_header)
    
    ;app entry point
    dw start	;0x4
    dd section.code_1.start	;0x6
    
    ;segment relocator item count
    dw	(header_end - code_1_segment)/4		;0xA
    
    ;segment relocator
    code_1_segment dd section.code_1.start		;0xC
    code_2_segment dd section.code_2.start
    mydata_1_segment dd section.mydata_1.start
    mydata_2_segment dd section.mydata_2.start
    mystack_segment dd section.mystack.start
    
    header_end:
    
    SECTION code_1 align=16 vstart=0x0
    start:
    	;now es ds point to app_header
    	mov ax, [mystack_segment]
    	mov ss, ax
    	mov sp, ax
    
    	;jump to main
    	mov ax, [code_2_segment]
    	push ax
    	mov ax, main
    	push ax
    	retf
    	
    final:	
    	mov ax, 0xb800
    	mov ds, ax
    	mov ah, 0x07
    	mov al, 'f'
    	mov si, 160
    	mov word [ds:si], ax
    	
    	mov al, 'i'
    	add si, 2
    	mov word [ds:si], ax
    	
    	mov al, 'n'
    	add si, 2
    	mov word [ds:si], ax
    	
    	mov al, 'a'
    	add si, 2
    	mov word [ds:si], ax
    	
    	mov al, 'l'
    	add si, 2
    	mov word [ds:si], ax
    	
    	jmp $
    
    
    section code_2 align=16 vstart=0
    main:
    
    	mov ax, [es:mydata_1_segment]
    	mov ds, ax
    	
    	mov ax, cursorMsg
    	call printString
    	
    	mov ax, cursorMsg2
    	call printString
    	
    	mov ax, cursorMsg3
    	call printString
    
    	mov ax, [es:mydata_2_segment]
    	mov ds, ax
    	mov ax, cursorMsg4
    	call printString
    	
    	mov ax, cursorMsg5
    	call printString
    	
    	;go back to code_1 final
    	mov ax, [es:code_1_segment]
    	push ax
    	mov ax, final
    	push ax
    	retf
    
    getCursorPosition:
    	push dx
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	mov ah, al
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	
    	pop dx
    	ret
    
    setCursorPosition:
    	push ax
    	push bx
    	push dx
    	
    	mov bx, ax
    	
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bh
    	out dx, al 
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bl
    	out dx, al
    	
    	pop dx
    	pop bx
    	pop ax	
    	ret
    	
    printString:
    	push ax
    	push si
    	
    	;save string start address to si
    	mov si, ax
    	
    @1: mov al, [si]
    	cmp al, 0
    	je @2
    	
    	call printCharacter
    	
    	inc si
    	jmp @1
    	
    @2:
    	pop si
    	pop ax
    	
    	ret	
    
    printCharacter:
    	push es
    	push ds
    	push ax
    	push di
    	push bx
    	push cx
    	
    	mov bx, ax
    	
    	;set video buffer addr
    	mov ax,0xb800
       	mov es, ax
       	   		
    	;get cursor pos to ax
    	call getCursorPosition
    	;move current cursor pos to di
    	mov di, ax
    	;1 character consumes 2 bytes
    	shl di, 1
    
    	cmp di, 4000
    	;test if the screen is full, if screen is full, just return
    	je .doneWithPrintCharacter
    	
    	;before output, test if it is carriage return
    	cmp bl, 0xD
    	je .handleCarriageReturn
    	
    	cmp bl, 0xA
    	je .handleNewLine
    	
    	
    	mov byte [es:di], bl	
    	inc di
    	mov byte [es:di], 0x0f
    	inc di
    	jmp .doneWithPrintCharacter
    	
    .handleCarriageReturn:
    	;move cursor to the front of current line
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	mul bh
    	shl ax, 1
    	mov di, ax
    	jmp .doneWithPrintCharacter
    	
    .handleNewLine:
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	cmp al, 24
    	jl .addAnotherNewLine
    	
    	;roll the Screen
    	push di
    	mov ax,0xb800
    	mov ds,ax
    	mov es,ax
    	cld
    	mov cx, 1920
    	mov di, 0
    	mov si, 160
    	rep movsw
    	;clear screen last line
    	mov bx, 3840                     
    	mov cx, 80
     .cls:
    	mov word [es:bx], 0x0720
    	add bx, 2
    	loop .cls
    	; keep the cursor in the same place of the last line
    	pop di
    	jmp .doneWithPrintCharacter
    	
    .addAnotherNewLine:
    	;just add another new line if it is not the last line
    	add di, 160
    .doneWithPrintCharacter:	
    	;write new cursor pos to video card
    	mov ax, di
    	shr ax, 1
    	call setCursorPosition
    	
    	pop cx
    	pop bx
    	pop di
    	pop ax
    	pop ds
    	pop es
    	ret
    
    section mydata_1 align=16 vstart=0
    
    cursorMsg: db 'Cursor is Here!', 0
    cursorMsg2: db 'Still the same line goes here.', 0
    cursorMsg3: db 0xd, 'Start from Head.', 0
    
    section mydata_2 align=16 vstart=0
    
    cursorMsg4: db 0xd, 0xa,0xa,0xa,0xa,0xa,'After change line.', 0xa, 'Another line.', 0
    cursorMsg5: db 0xa, 'the 8th line.', 0xa, '9th', 0xa, '10th', 0xa, 0xa, 0xa, 0xa,0xa,0xa
    db 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 'This is the last line.', 0
    
    section mystack align=16 vstart=0
    resb 256
    stack_end:
    
    section tail align=16
    app_end:

如上述代码所示，我们分出来一个协议头段、两个代码段、两个数据段和一个堆栈段。段重定位表中不包含协议头段。

# 加载器 #

需要说明的是，对于要烧入主引导扇区的加载器程序来说，因为结尾处的代码的限制，我们只能使用一个段来进行书写。

times 510-($-$$) db 0
    db 0x55,0xaa

为简化起见，我们在加载器中写死，指定应用程序存放在硬盘的逻辑扇区第512号扇区中。

app_start_lba equ 512
    ......
    loading_sector_lba28 dd app_start_lba

同时，我们在加载器中写死要将应用程序加载到的目的物理地址为0x12340处。

physical_address equ 0x12340
    ......
    loading_physical_address dd physical_address

注意，该地址必须要16字节对齐。  
之后我们通过如下代码来提取该物理地址、

mov ax, [loading_physical_address]
    	mov dx, [loading_physical_address+2]
    	mov bx, 16
    	div bx
    	
    	mov es, ax
    	mov di, dx

之后加载器通过读取硬盘上指定扇区处的512字节，来获取协议头数据。并首先解析出应用程序的总大小，根据总大小除以512，来得到还要读取的扇区数。

# 对段重定位表进行修正 #

我们对于表中的每一项4字节数据，将其先放入bx:ax中，然后对其进行加上实际加载物理地址，之后除以16，以得到各个段对应的实际2字节段地址。代码如下所示：

mov cx, [loading_physical_address]
    	mov dx, [loading_physical_address+2]
    	add ax, cx
    	adc dx, bx
    	mov bx, 16
    	div bx

# 整个加载器的源代码 #

app_start_lba equ 512
    physical_address equ 0x12340
    
    segment loader align=16 vstart=0x7c00
    	xor ax, ax
    	mov ss, ax
    	mov sp, ax
    
    	
    	mov ax, [loading_physical_address]
    	mov dx, [loading_physical_address+2]
    	mov bx, 16
    	div bx
    	
    	mov es, ax
    	mov di, dx
    
    	mov si, [loading_sector_lba28]
    	mov bx, [loading_sector_lba28+2]
    	
    	call readSectorFromDisk
    	
    	;get app total size
    	mov ax, [es:0]
    	mov dx, [es:2]
    	mov bx, 512
    	div bx
    	
    	cmp dx, 0
    	jne @1
    	dec ax
    @1:
    	;set loop count
    	mov cx, ax
    	mov si, [loading_sector_lba28]
    	mov bx, [loading_sector_lba28+2]
    	
    	;before read remain sectors, save es
    	push es
    	;read next sector
    .readRemainSectors:
    	mov ax, es
    	add ax, 512/16
    	mov es, ax
    	xor di, di
    	
    	add si, 1
    	adc bx, 0
    	
    	call readSectorFromDisk
    	loop .readRemainSectors
    	
    	;restore es
    	pop es
    ;relocate entry point
    	mov ax, [es:6]
    	mov bx, [es:8]
    	call calRelocateSegmentAddr
    	mov [es:6], ax
    	
    ;relocate segment table
    	mov cx, [es:0xA]
    	mov si, 0xC
    .relocateSegments:
    	mov ax, [es:si]
    	mov bx, [es:si + 2]
    	call calRelocateSegmentAddr
    	mov [es:si], ax
    	add si, 4
    	loop .relocateSegments
    
    	
    	mov ax, [es:6]
    	push ax
    	mov ax, [es:4]
    	push ax
    	
    	;before execute the app, set es and ds to app header
    	mov ax, es
    	mov ds, ax
    	retf
    
    calRelocateSegmentAddr:
    	;ax low word of segment address
    	;bx high word of segment address
    	push bx
    	push cx
    	push dx
    	
    	mov cx, [loading_physical_address]
    	mov dx, [loading_physical_address+2]
    	add ax, cx
    	adc dx, bx
    	mov bx, 16
    	div bx
    	
    	
    	pop dx
    	pop cx
    	pop bx
    	ret
    	
    
    
    
    loading_sector_lba28 dd app_start_lba
    loading_physical_address dd physical_address
    
    readSectorFromDisk:
    	;从硬盘读取一个逻辑扇区
    	;BX:SI=起始逻辑扇区号
    	;ES:DI=目标缓冲区地址
    	;LBA28(BX:SI)
    DataRegister equ 0x1f0
    FeatureRegister equ 0x1f1
    SectorRegister equ 0x1f2
    LBAlowRegister equ 0x1f3
    LBAmidRegister equ 0x1f4
    LBAhighRegister equ 0x1f5
    DeviceRegister equ 0x1f6
    CommandRegister equ 0x1f7
    
    ReadCMD	 	equ 0x20
    WriteCMD	equ 0x30
    IDCMD		equ 0xEC
    
    	push ax
    	push bx
    	push cx
    	push dx
    	push di
    
    	mov ax, si
    	
    	mov dx, LBAlowRegister
    	out dx, al
    
    	mov dx, LBAmidRegister
    	shr ax, 8
    	out dx, al
    
    	mov dx, LBAhighRegister
    	mov ax, bx
    	out dx, al
    	
    	mov dx, DeviceRegister
    	;LBA28 mode, master disk
    	and ah, 0x0F
    	mov al, 0xe0
    	or al, ah
    	out dx, al
    	
    	mov dx, SectorRegister
    	mov al, 0x1
    	out dx, al
    	
    	mov dx, CommandRegister 
    	mov al, ReadCMD
    	out dx, al
    	
    .wait4Ready:
    	in al, dx
    	and al, 0x88
    	cmp al, 0x08
    	jnz .wait4Ready
    	
    	mov cx, 256
    	mov dx, DataRegister
    .readSectorData:
    	in ax, dx
    	mov word [es:di], ax
    	add di, 2
    	loop .readSectorData
    
    	pop di
    	pop dx
    	pop cx
    	pop bx
    	pop ax
    
    	ret
    	
    
    times 510-($-$$) db 0
    db 0x55,0xaa

# 工程Makefile文件 #

为方便编译和烧写bin文件到.vhd硬盘虚拟文件中，我使用makefile文件来对实验进行管理，loader.mk文件内容如下所示：

appLBAOffset=512
    
    all: appJob loaderJob
    	echo "Job all done."
    
    appJob : app.bin
    	FixVhdWr -r $< -w ~/VirtualBoxVMs/x86AsmLab/x86AsmLab.vhd -a $(appLBAOffset)
    
    loaderJob : loader.bin
    	FixVhdWr -r $< -w ~/VirtualBoxVMs/x86AsmLab/x86AsmLab.vhd -a 0
    
    %.bin : %.s
    	nasm -f bin $< -o $@
    
    
    clean:
    	rm -f app.bin loader.bin

之后在终端中输入make -f loader.mk即可，如下动态图所示：  
![在这里插入图片描述][20200725172854845.gif]

# 运行效果 #

可以看到，加载器正确加载并重定位了应用程序，一切工作正常。  
![在这里插入图片描述][20200725173330382.gif]

[20200725172854845.gif]: /images/20230208/ea336822c42b4bfca3d562d19bbe4bbd.png
[20200725173330382.gif]: /images/20230208/d9d3e4b229584424898426164a0eeea4.png