• 完整boot引导代码详解（完整无注释代码boot.asm+简单loader.asm）

     代码块一：

    1. org	0x7c00	
    2.  
    3. BaseOfStack	equ	0x7c00
    4. BaseOfLoader	equ	0x1000
    5. OffsetOfLoader	equ	0x00
    6. RootDirSectors	equ	14
    7. SectorNumOfRootDirStart	equ	19
    8. SectorNumOfFAT1Start	equ	1
    9. SectorBalance	equ	17	
    10.  
    11. 	jmp	short Label_Start
    12. 	nop
    13. 	BS_OEMName	db	'MINEboot'
    14. 	BPB_BytesPerSec	dw	512
    15. 	BPB_SecPerClus	db	1
    16. 	BPB_RsvdSecCnt	dw	1
    17. 	BPB_NumFATs	db	2
    18. 	BPB_RootEntCnt	dw	224
    19. 	BPB_TotSec16	dw	2880
    20. 	BPB_Media	db	0xf0
    21. 	BPB_FATSz16	dw	9
    22. 	BPB_SecPerTrk	dw	18
    23. 	BPB_NumHeads	dw	2
    24. 	BPB_HiddSec	dd	0
    25. 	BPB_TotSec32	dd	0
    26. 	BS_DrvNum	db	0
    27. 	BS_Reserved1	db	0
    28. 	BS_BootSig	db	0x29
    29. 	BS_VolID	dd	0
    30. 	BS_VolLab	db	'boot loader'
    31. 	BS_FileSysType	db	'FAT12   '

            这段程序中的代码BaseOfLoader equ 0x1000和offsetofLoader equ 0x00组合成了Loader程序的起始物理地址,这个组合必须经过实模式的地址变换公式才能生成物理地址，即BaseofLoader<<4 +offsetofLoader = 0x10000。
            代码RootDirSectors equ 14定义了根目录占用的扇区数，这个数值是根据FAT12文件系统提供的信息经过计算而得，即(BPB_RootEntCnt * 32 ＋ BPB_BytesPerSec - 1)/BPB_BytesPersec = ( 224×32 + 512 - 1)/ 512 = 14。
            等价语句sectorNumofRootDirstart equ 19定义了根目录的起始扇区号，这个数值也是通过计算而得，即保留扇区数＋FAT表扇区数*FAT表份数=1 + 9 * 2= 19，因为扇区编号的计数值从O开始，故根目录的起始扇区号为19。
            程序SectorNumOfFAT1Start equ 1代表了FAT1表的起始扇区号，在FAT1表前面只有一个保留扇区（引导扇区)，而且它的扇区编号是0，那么FAT1表的起始扇区号理应为1。
            汇编代码sectorBalance equ 17用于平衡文件(或者目录)的起始簇号与数据区起始簇号的差值。更通俗点说，因为数据区对应的有效簇号是2(FAT[2])，为了正确计算出FAT表项对应的数据区起始扇区号，则必须将FAT表项值减2，或者将数据区的起始簇号/扇区号减2(仅在每簇由一个扇区组成时可用)。本程序暂时采用一种更取巧的方法是，将根目录起始扇区号减2(19-2=17)，进而间接把数据区的起始扇区号（数据区起始扇区号=根目录起始扇区号+根目录所占扇区数）减2。

     代码块二：

    1. ;=======	read one sector from floppy
    2.  
    3. Func_ReadOneSector:
    4. 	
    5. 	push	bp
    6. 	mov	bp,	sp
    7. 	sub	esp,	2
    8. 	mov	byte	[bp - 2],	cl
    9. 	push	bx
    10. 	mov	bl,	[BPB_SecPerTrk]
    11. 	div	bl
    12. 	inc	ah
    13. 	mov	cl,	ah
    14. 	mov	dh,	al
    15. 	shr	al,	1
    16. 	mov	ch,	al
    17. 	and	dh,	1
    18. 	pop	bx
    19. 	mov	dl,	[BS_DrvNum]
    20. Label_Go_On_Reading:
    21. 	mov	ah,	2
    22. 	mov	al,	byte	[bp - 2]
    23. 	int	13h
    24. 	jc	Label_Go_On_Reading
    25. 	add	esp,	2
    26. 	pop	bp
    27. 	ret

            代码中的Func_ReadOnesector模块负责实现软盘读取功能，它借助BIOS中断服务程序INT 13h的主功能号AH=02h实现软盘扇区的读取操作，该中断服务程序的各寄存器参数说明如下。
            INT 13h，AH=02h 功能:读取磁盘扇区。

    • AL=读入的扇区数（必须非0);
    • CH=磁道号（柱面号）的低8位;
    • CL=扇区号1~63 ( bit 0~5 )，磁道号（柱面号)的高2位( bit 6~7,只对硬盘有效);
    • DH=磁头号;
    • DL=驱动器号（如果操作的是硬盘驱动器，bit 7必须被置位);
    • ES:BX-一>数据缓冲区。

            模块Func_ReadOnesector仅仅是对BIOS中断服务程序的再次封装，以简化读取磁盘扇区的操作过程，进而在调用Func_ReadOnesector模块时，只需传递下列参数到对应的寄存器中，即可实现磁盘扇区的读取操作。模块Func_ReadOnesector详细参数说明如下。
            模块Func_Readonesector功能:读取磁盘扇区。

    • AX=待读取的磁盘起始扇区号;
    • CL=读入的扇区数量;
    • ES:BX=>目标缓冲区起始地址。

            因为Func_ReadOnesector模块传入的磁盘扇区号是LBA (Logical Block Address，逻辑块寻址)格式的，而INT 13h，AH=O2h中断服务程序只能受理CHS ( Cylinder /Head/Sector，柱面/磁头/扇区)格式的磁盘扇区号，那么必须将LBA格式转换为CHS格式，通过下列公式可将LBA格式转换为CHS格式。

             模块Func_ReadOnesector在读取软盘之前，会先保存栈帧寄存器和栈寄存器的数值，从栈中开辟两个字节的存储空间（将栈指针向下移动两个字节)，由于此时代码bp - 2与ESP寄存器均指向同一内存地址，所以CL寄存器的值就保存在刚开辟的栈空间里。而后，使用AX寄存器（待读取的磁盘起始扇区号)除以BL寄存器（每磁道扇区数)，计算出目标磁道号(商:AL寄存器）和目标磁道内的起始扇区号(余数:AH寄存器)，考虑到磁道内的起始扇区号从1开始计数，故此将余数值加1，即inc ah。紧接着，再按照上公式计算出磁道号（也叫柱面号）与磁头号，将计算结果保存在对应寄存器内。最后，执行INT 13h中断服务程序从软盘扇区读取数据到内存中，当数据读取成功(CF标志位被复位）后恢复调用现场。

    代码块三：

    1. ;=======	search loader.bin
    2. 	mov	word	[SectorNo],	SectorNumOfRootDirStart
    3.  
    4. Lable_Search_In_Root_Dir_Begin:
    5.  
    6. 	cmp	word	[RootDirSizeForLoop],	0
    7. 	jz	Label_No_LoaderBin
    8. 	dec	word	[RootDirSizeForLoop]	
    9. 	mov	ax,	00h
    10. 	mov	es,	ax
    11. 	mov	bx,	8000h
    12. 	mov	ax,	[SectorNo]
    13. 	mov	cl,	1
    14. 	call	Func_ReadOneSector
    15. 	mov	si,	LoaderFileName
    16. 	mov	di,	8000h
    17. 	cld
    18. 	mov	dx,	10h
    19. 	
    20. Label_Search_For_LoaderBin:
    21.  
    22. 	cmp	dx,	0
    23. 	jz	Label_Goto_Next_Sector_In_Root_Dir
    24. 	dec	dx
    25. 	mov	cx,	11
    26.  
    27. Label_Cmp_FileName:
    28.  
    29. 	cmp	cx,	0
    30. 	jz	Label_FileName_Found
    31. 	dec	cx
    32. 	lodsb	
    33. 	cmp	al,	byte	[es:di]
    34. 	jz	Label_Go_On
    35. 	jmp	Label_Different
    36.  
    37. Label_Go_On:
    38. 	
    39. 	inc	di
    40. 	jmp	Label_Cmp_FileName
    41.  
    42. Label_Different:
    43.  
    44. 	and	di,	0ffe0h
    45. 	add	di,	20h
    46. 	mov	si,	LoaderFileName
    47. 	jmp	Label_Search_For_LoaderBin
    48.  
    49. Label_Goto_Next_Sector_In_Root_Dir:
    50. 	
    51. 	add	word	[SectorNo],	1
    52. 	jmp	Lable_Search_In_Root_Dir_Begin

            通过这段代码能够从根目录中搜索出引导加载程序（文件名为loader.bin )。在程序执行初期,程序会先保存根目录的起始扇区号，并依据根目录占用磁盘扇区数来确定需要搜索的扇区数，并从根目录中读入一个扇区的数据到缓冲区;接下来，遍历读入缓冲区中的每个目录项，寻找与目标文件名字符串( “LOADER BIN" , 0 )相匹配的目录项,其中DX寄存器记录着每个扇区可容纳的目录项个数(512/32= 16=0x10 )，CX寄存器记录着目录项的文件名长度（文件名长度为11B，包括文件名和扩展名，但不包含分隔符“.”)。在比对每个目录项文件名的过程中，使用了汇编指令LODSB，该命令的加载方向与DF标志位有关，因此在使用此命令时需用CLD指令清DF标志位。
            以下是Intel官方白皮书对LODSB/LODSW/LODSD/LODSQ指令的概括描述。
            1.该命令可从DS:(R|E)SI寄存器指定的内存地址中读取数据到AL/AX/EAX/RAX寄存器。
            2.当数据载入到AL/AX/EAX/RAX寄存器后，(RE)SI寄存器将会依据R|EFLAGs标志寄存器的DF标志位自动增加或减少载人的数据长度(1/2/4/8字节)。当DF=0时，(RE)SI寄存器将会自动增加;反之，(R|E)SI寄存器将会自动减少。
            一旦发现完全匹配的字符串，则跳转到Label_FileName_Found处执行;如果没有找到，那么就执行其后的Label_No_LoaderBin模块,进而在屏幕上显示提示信息，通知用户引导加载程序不存在。

            特别注意，因为FAT12文件系统的文件名是不区分大小写字母的，即使将小写字母命名的文件复制到FAT12文件系统内，文件系统也会为其创建大写字母的文件名和目录项。而小写字母文件名只作为其显示名，真正的数据内容皆保存在大写字母对应的目录项。所以这里应该搜索大写字母的文件名字符串。


      代码块四：

    1. ;=======	display on screen : ERROR:No LOADER Found
    2.  
    3. Label_No_LoaderBin:
    4.  
    5. 	mov	ax,	1301h
    6. 	mov	bx,	008ch
    7. 	mov	dx,	0100h
    8. 	mov	cx,	21
    9. 	push	ax
    10. 	mov	ax,	ds
    11. 	mov	es,	ax
    12. 	pop	ax
    13. 	mov	bp,	NoLoaderMessage
    14. 	int	10h
    15. 	jmp	$

            这段代码借助BIOS中断处理程序INT 10h ,将字符串ERROR :No LOADER Found显示到屏幕的第1行第0列上。

    代码块五：

    1. ;=======	get FAT Entry
    2.  
    3. Func_GetFATEntry:
    4.  
    5. 	push	es
    6. 	push	bx
    7. 	push	ax
    8. 	mov	ax,	00
    9. 	mov	es,	ax
    10. 	pop	ax
    11. 	mov	byte	[Odd],	0
    12. 	mov	bx,	3
    13. 	mul	bx
    14. 	mov	bx,	2
    15. 	div	bx
    16. 	cmp	dx,	0
    17. 	jz	Label_Even
    18. 	mov	byte	[Odd],	1
    19.  
    20. Label_Even:
    21.  
    22. 	xor	dx,	dx
    23. 	mov	bx,	[BPB_BytesPerSec]
    24. 	div	bx
    25. 	push	dx
    26. 	mov	bx,	8000h
    27. 	add	ax,	SectorNumOfFAT1Start
    28. 	mov	cl,	2
    29. 	call	Func_ReadOneSector
    30. 	
    31. 	pop	dx
    32. 	add	bx,	dx
    33. 	mov	ax,	[es:bx]
    34. 	cmp	byte	[Odd],	1
    35. 	jnz	Label_Even_2
    36. 	shr	ax,	4
    37.  
    38. Label_Even_2:
    39. 	and	ax,	0fffh
    40. 	pop	bx
    41. 	pop	es
    42. 	ret

            此前已经提及FAT12文件系统的每个FAT表项占用12 bit，即每三个字节存储两个FAT表项，由此看来，FAT表项的存储位置是具有奇偶性的。使用Func_GetFATEntry模块可根据当前FAT表项索引出下一个FAT表项,该模块的寄存器参数说明如下。
            模块Func_GetFATEntry 功能:根据当前FAT表项索引出下一个FAT表项。

    •         AH=FAT表项号(输入参数/输出参数)。

            这段程序首先会保存FAT表项号，并将奇偶标志变量(变量[odd])置0。因为每个FAT表项占1.5 B,所以将FAT表项乘以3除以2(扩大1.5倍）来判读余数的奇偶性并保存在[odd]中(奇数为1，偶数为0 )，再将计算结果除以每扇区字节数，商值为FAT表项的偏移扇区号，余数值为FAT表项在扇区中的偏移位置。接着，通过Func_Readonesector模块连续读入两个扇区的数据，此举的目的是为了解决FAT表项横跨两个扇区的问题。最后，根据奇偶标志变量进一步处理奇偶项错位问题，即奇数项向右移动4位。有能力的读者可自行将FAT12文件系统替换为FAT16文件系统，这样可以简化FAT表项的索引过程。
            在完成Func_ReadOnesector和Func_GetFATEntry模块后，就可借助这两个模块把loader.bin文件内的数据从软盘扇区读取到指定地址中。代码清单3-10实现了从FAT12文件系统中加载loader.bin文件到内存的过程。

    代码块六： 

    1. ;=======	found loader.bin name in root director struct
    2.  
    3. Label_FileName_Found:
    4.  
    5. 	mov	ax,	RootDirSectors
    6. 	and	di,	0ffe0h
    7. 	add	di,	01ah
    8. 	mov	cx,	word	[es:di]
    9. 	push	cx
    10. 	add	cx,	ax
    11. 	add	cx,	SectorBalance
    12. 	mov	ax,	BaseOfLoader
    13. 	mov	es,	ax
    14. 	mov	bx,	OffsetOfLoader
    15. 	mov	ax,	cx
    16.  
    17. Label_Go_On_Loading_File:
    18. 	push	ax
    19. 	push	bx
    20. 	mov	ah,	0eh
    21. 	mov	al,	'.'
    22. 	mov	bl,	0fh
    23. 	int	10h
    24. 	pop	bx
    25. 	pop	ax
    26.  
    27. 	mov	cl,	1
    28. 	call	Func_ReadOneSector
    29. 	pop	ax
    30. 	call	Func_GetFATEntry
    31. 	cmp	ax,	0fffh
    32. 	jz	Label_File_Loaded
    33. 	push	ax
    34. 	mov	dx,	RootDirSectors
    35. 	add	ax,	dx
    36. 	add	ax,	SectorBalance
    37. 	add	bx,	[BPB_BytesPerSec]
    38. 	jmp	Label_Go_On_Loading_File
    39.  
    40. Label_File_Loaded:
    41. 	
    42. 	jmp	$

            在Label_FileName_Found模块中，程序会先取得目录项DIR_FstClus字段的数值，并通过配置ES寄存器和BX寄存器来指定loader.bin程序在内存中的起始地址，再根据loader.bin程序的起始簇号计算出其对应的扇区号。为了增强人机交互效果，此处还使用BIOS中断服务程序INT 10h在屏幕上显示一个字符' .'。接着，每读入一个扇区的数据就通过Func_GetFATEntry模块取得下一个FAT表项，并跳转至Label_Go_on_Loading_File处继续读入下一个簇的数据，如此往复，直至Func_GetFATEntry模块返回的FAT表项值是offfh为止。当loader.bin文件的数据全部读取到内存后，跳转至Label_File_Loaded处准备执行loader.bin程序。
            这段代码使用了BIOS中断服务程序INT10h的主功能号AH=0Eh在屏幕上显示一个字符。详细寄存器参数说明如下。
    INT 10h，AH=OEh 功能:在屏幕上显示一个字符。

    • AL=待显示字符;
    • BL=前景色。

    代码块七：

    1. ;=======	tmp variable
    2.  
    3. RootDirSizeForLoop	dw	RootDirSectors
    4. SectorNo		dw	0
    5. Odd			db	0
    6.  
    7. ;=======	display messages
    8.  
    9. StartBootMessage:	db	"Start Boot"
    10. NoLoaderMessage:	db	"ERROR:No LOADER Found"
    11. LoaderFileName:		db	"LOADER  BIN",0

            这三个变量用于保存程序运行时的临时数据，上文已经讲解了它们的使用过程，此处不再过多讲述。

            上述字符串均是屏幕上显示的日志信息。值得说明的是，NASM编译器中的单引号与双引号作用相同，并非如标准C语言中规定的:双引号会在字符串结尾处自动添加字符· \0'，而在NASM编译器中必须自行添加。不过，本程序使用的BIOS中断服务程序必须明确提供显示的字符串的长度，不需要判读字符串结尾处的字符'\0 '。
            目前，我们还未进入Loader引导加载程序的开发环节，所以在Label_File_Loaded处使用代码jmp s，让程序死循环在此处。

    完整无注释代码

    boot.am

    1. org	0x7c00	
    2.  
    3. BaseOfStack	equ	0x7c00
    4. BaseOfLoader	equ	0x1000
    5. OffsetOfLoader	equ	0x00
    6. RootDirSectors	equ	14
    7. SectorNumOfRootDirStart	equ	19
    8. SectorNumOfFAT1Start	equ	1
    9. SectorBalance	equ	17	
    10.  
    11. 	jmp	short Label_Start
    12. 	nop
    13. 	BS_OEMName	db	'MINEboot'
    14. 	BPB_BytesPerSec	dw	512
    15. 	BPB_SecPerClus	db	1
    16. 	BPB_RsvdSecCnt	dw	1
    17. 	BPB_NumFATs	db	2
    18. 	BPB_RootEntCnt	dw	224
    19. 	BPB_TotSec16	dw	2880
    20. 	BPB_Media	db	0xf0
    21. 	BPB_FATSz16	dw	9
    22. 	BPB_SecPerTrk	dw	18
    23. 	BPB_NumHeads	dw	2
    24. 	BPB_HiddSec	dd	0
    25. 	BPB_TotSec32	dd	0
    26. 	BS_DrvNum	db	0
    27. 	BS_Reserved1	db	0
    28. 	BS_BootSig	db	0x29
    29. 	BS_VolID	dd	0
    30. 	BS_VolLab	db	'boot loader'
    31. 	BS_FileSysType	db	'FAT12   '
    32.  
    33. Label_Start:
    34.  
    35. 	mov	ax,	cs
    36. 	mov	ds,	ax
    37. 	mov	es,	ax
    38. 	mov	ss,	ax
    39. 	mov	sp,	BaseOfStack
    40.  
    41. ;=======	clear screen
    42.  
    43. 	mov	ax,	0600h
    44. 	mov	bx,	0700h
    45. 	mov	cx,	0
    46. 	mov	dx,	0184fh
    47. 	int	10h
    48.  
    49. ;=======	set focus
    50.  
    51. 	mov	ax,	0200h
    52. 	mov	bx,	0000h
    53. 	mov	dx,	0000h
    54. 	int	10h
    55.  
    56. ;=======	display on screen : Start Booting......
    57.  
    58. 	mov	ax,	1301h
    59. 	mov	bx,	000fh
    60. 	mov	dx,	0000h
    61. 	mov	cx,	10
    62. 	push	ax
    63. 	mov	ax,	ds
    64. 	mov	es,	ax
    65. 	pop	ax
    66. 	mov	bp,	StartBootMessage
    67. 	int	10h
    68.  
    69. ;=======	reset floppy
    70.  
    71. 	xor	ah,	ah
    72. 	xor	dl,	dl
    73. 	int	13h
    74.  
    75. ;=======	search loader.bin
    76. 	mov	word	[SectorNo],	SectorNumOfRootDirStart
    77.  
    78. Lable_Search_In_Root_Dir_Begin:
    79.  
    80. 	cmp	word	[RootDirSizeForLoop],	0
    81. 	jz	Label_No_LoaderBin
    82. 	dec	word	[RootDirSizeForLoop]	
    83. 	mov	ax,	00h
    84. 	mov	es,	ax
    85. 	mov	bx,	8000h
    86. 	mov	ax,	[SectorNo]
    87. 	mov	cl,	1
    88. 	call	Func_ReadOneSector
    89. 	mov	si,	LoaderFileName
    90. 	mov	di,	8000h
    91. 	cld
    92. 	mov	dx,	10h
    93. 	
    94. Label_Search_For_LoaderBin:
    95.  
    96. 	cmp	dx,	0
    97. 	jz	Label_Goto_Next_Sector_In_Root_Dir
    98. 	dec	dx
    99. 	mov	cx,	11
    100.  
    101. Label_Cmp_FileName:
    102.  
    103. 	cmp	cx,	0
    104. 	jz	Label_FileName_Found
    105. 	dec	cx
    106. 	lodsb	
    107. 	cmp	al,	byte	[es:di]
    108. 	jz	Label_Go_On
    109. 	jmp	Label_Different
    110.  
    111. Label_Go_On:
    112. 	
    113. 	inc	di
    114. 	jmp	Label_Cmp_FileName
    115.  
    116. Label_Different:
    117.  
    118. 	and	di,	0ffe0h
    119. 	add	di,	20h
    120. 	mov	si,	LoaderFileName
    121. 	jmp	Label_Search_For_LoaderBin
    122.  
    123. Label_Goto_Next_Sector_In_Root_Dir:
    124. 	
    125. 	add	word	[SectorNo],	1
    126. 	jmp	Lable_Search_In_Root_Dir_Begin
    127. 	
    128. ;=======	display on screen : ERROR:No LOADER Found
    129.  
    130. Label_No_LoaderBin:
    131.  
    132. 	mov	ax,	1301h
    133. 	mov	bx,	008ch
    134. 	mov	dx,	0100h
    135. 	mov	cx,	21
    136. 	push	ax
    137. 	mov	ax,	ds
    138. 	mov	es,	ax
    139. 	pop	ax
    140. 	mov	bp,	NoLoaderMessage
    141. 	int	10h
    142. 	jmp	$
    143.  
    144. ;=======	found loader.bin name in root director struct
    145.  
    146. Label_FileName_Found:
    147.  
    148. 	mov	ax,	RootDirSectors
    149. 	and	di,	0ffe0h
    150. 	add	di,	01ah
    151. 	mov	cx,	word	[es:di]
    152. 	push	cx
    153. 	add	cx,	ax
    154. 	add	cx,	SectorBalance
    155. 	mov	ax,	BaseOfLoader
    156. 	mov	es,	ax
    157. 	mov	bx,	OffsetOfLoader
    158. 	mov	ax,	cx
    159.  
    160. Label_Go_On_Loading_File:
    161. 	push	ax
    162. 	push	bx
    163. 	mov	ah,	0eh
    164. 	mov	al,	'.'
    165. 	mov	bl,	0fh
    166. 	int	10h
    167. 	pop	bx
    168. 	pop	ax
    169.  
    170. 	mov	cl,	1
    171. 	call	Func_ReadOneSector
    172. 	pop	ax
    173. 	call	Func_GetFATEntry
    174. 	cmp	ax,	0fffh
    175. 	jz	Label_File_Loaded
    176. 	push	ax
    177. 	mov	dx,	RootDirSectors
    178. 	add	ax,	dx
    179. 	add	ax,	SectorBalance
    180. 	add	bx,	[BPB_BytesPerSec]
    181. 	jmp	Label_Go_On_Loading_File
    182.  
    183. ; Label_File_Loaded:
    184. 	
    185. ; 	jmp	$
    186.  
    187. ;=======	read one sector from floppy
    188.  
    189. Func_ReadOneSector:
    190. 	
    191. 	push	bp
    192. 	mov	bp,	sp
    193. 	sub	esp,	2
    194. 	mov	byte	[bp - 2],	cl
    195. 	push	bx
    196. 	mov	bl,	[BPB_SecPerTrk]
    197. 	div	bl
    198. 	inc	ah
    199. 	mov	cl,	ah
    200. 	mov	dh,	al
    201. 	shr	al,	1
    202. 	mov	ch,	al
    203. 	and	dh,	1
    204. 	pop	bx
    205. 	mov	dl,	[BS_DrvNum]
    206. Label_Go_On_Reading:
    207. 	mov	ah,	2
    208. 	mov	al,	byte	[bp - 2]
    209. 	int	13h
    210. 	jc	Label_Go_On_Reading
    211. 	add	esp,	2
    212. 	pop	bp
    213. 	ret
    214.  
    215. ;=======	get FAT Entry
    216.  
    217. Func_GetFATEntry:
    218.  
    219. 	push	es
    220. 	push	bx
    221. 	push	ax
    222. 	mov	ax,	00
    223. 	mov	es,	ax
    224. 	pop	ax
    225. 	mov	byte	[Odd],	0
    226. 	mov	bx,	3
    227. 	mul	bx
    228. 	mov	bx,	2
    229. 	div	bx
    230. 	cmp	dx,	0
    231. 	jz	Label_Even
    232. 	mov	byte	[Odd],	1
    233.  
    234. Label_Even:
    235.  
    236. 	xor	dx,	dx
    237. 	mov	bx,	[BPB_BytesPerSec]
    238. 	div	bx
    239. 	push	dx
    240. 	mov	bx,	8000h
    241. 	add	ax,	SectorNumOfFAT1Start
    242. 	mov	cl,	2
    243. 	call	Func_ReadOneSector
    244. 	
    245. 	pop	dx
    246. 	add	bx,	dx
    247. 	mov	ax,	[es:bx]
    248. 	cmp	byte	[Odd],	1
    249. 	jnz	Label_Even_2
    250. 	shr	ax,	4
    251.  
    252. Label_Even_2:
    253. 	and	ax,	0fffh
    254. 	pop	bx
    255. 	pop	es
    256. 	ret
    257.  
    258. ;=======	tmp variable
    259.  
    260. RootDirSizeForLoop	dw	RootDirSectors
    261. SectorNo		dw	0
    262. Odd			db	0
    263.  
    264. ;=======	display messages
    265.  
    266. StartBootMessage:	db	"Start Boot"
    267. NoLoaderMessage:	db	"ERROR:No LOADER Found"
    268. LoaderFileName:		db	"LOADER  BIN",0
    269.  
    270. ;=========================
    271.  
    272. Label_File_Loaded:
    273. 	jmp BaseOfLoader:OffsetOfLoader
    274.  
    275. ;=======	fill zero until whole sector
    276.  
    277. 	times	510 - ($ - $$)	db	0
    278. 	dw	0xaa55
    279.  
    280.

    简单的loader.asm代码

    1. org 10000h
    2. 	mov ax,cs
    3. 	mov ds,ax
    4. 	mov es,ax
    5. 	mov ax,0x00
    6. 	mov ss,ax
    7. 	mov sp,0x7c00
    8. ;========== 显示 Start Loader....
    9. 	mov ax,1301h
    10. 	mov bx,000fh
    11. 	mov dx,0200h
    12. 	mov cx,12
    13. 	push ax
    14. 	mov ax,ds
    15. 	mov es,ax
    16. 	pop ax
    17. 	mov bp,StartLoaderMessage
    18. 	int 10h
    19. 	jmp $
    20. ;=============
    21. StartLoaderMessage : db "Start Loader"

     摘自：《一个64位操作系统的设计与实现》

  • 相关阅读:
    构造方法与方法调用指令分析 || JVM类加载与字节码技术
    如何使用 React 和 Docusaurus 编写的一些自定义钩子（Hook）
    分库分表实战：竿头日上—千万级数据优化之读写分离
    电巢科技出席第26届西北地区电子技术与线路课程教学改革研讨会，聚焦一流课程建设！
    基于webpack5从0搭建Vue脚手架
    Google Earth Engine ——neighborhoodToBands函数的使用
    Python每日一练（牛客数据分析篇新题库）——第37天：合并
    JVM 的可达性分析法和四种引用
    nodejs配置
    使用策略模式重构审批
  • 原文地址：https://blog.csdn.net/weixin_42492218/article/details/127752246