Assembly: x86实模式

nasm exam.asm -f bin -o exam.bin

sudo apt install bochs

#启动bochs
bochs #选择3来编辑硬件

mov ax, 0x30      ;将立即数传送到AX寄存器
mov dx, 0xC0
add ax, dx  ;将寄存器ax和dx的值相加，结果在ax

D:\project\assemblyprojs>nasm  exam.asm -f bin -o exam.bin  #得到8个字节的数据。
$ hexdump -C exam.bin
00000000  b8 30 00 ba c0 00 01 d0                           |.0......|
00000008

#8086是低端字节序的。
b8 30 00 就是 b8 0030
ba 00c0
0d0a

mov ax, 0x30      ;将立即数传送到AX寄存器
mov dx, 0xC0
add ax, dx  ;将寄存器ax和dx的值相加，结果在ax

times 502 db 0 ;重复执行502次后面的指令，db 0 向程序添加1字节数据

db 0x55
db 0xAA ;主引导扇区有效标识55AA

db #伪指令，来向程序中添加1个字节的数据。数据可以是0，55等一个字节的数据。伪指令不是真正处理器指令而是只对编译器有效的指令。
times n #伪指令，重复后指令次数，n为次数

D:\project\assemblyprojs>nasm  exam.asm -f bin -o exam.bin
jasper@jasper MINGW64 /d/project/assemblyprojs
$ hexdump -C exam.bin
00000000  b8 30 00 ba c0 00 01 d0  00 00 00 00 00 00 00 00  |.0..............|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
00000200

10001011 #1为亮，0暗

11111111 #第1个字节对应红像素，每个字节的大小就他们各自原色的饱和度
11111111 #第2个字节对应蓝像素
11111111 #第3个字节对应绿像素

BFFFF   #逻辑地址 B800:7FFF
.....
B8000 #逻辑地址 B800:0000

; 为访问文本模式下的显存做准备工作
mov ax, 0xb800  ; 把段地址0xb800传送给寄存器AX
mov ds, ax   ;将寄存器AX中的内容传送给数据段寄存器DS

# mov ds, 0xb800 #intel处理器，不存在这样的指令
#只允许如下指令

#mov 段寄存器, 通用寄存器
mov ds, ax
mov ds, bx
mov ds, cx

#mov 段寄存器, [内存地址]
mov es, [0x6C]

0x07 0000 0111  #高4位0000是背景色不闪烁黑色，低4位0111是前景色白色

黑底白字不闪烁

mov ax, 0xb800
mov ds, ax

mov byte [0x00], 0x41  ;字符A的ASCII编码。指令的意思是把A的编码传送到B8000处
mov byte [0x01], 0x04  ;黑底红字，无闪烁

mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73  , 汇编语言编译器会把 s 转换成字符的编码
mov byte [0x03], 0x04

mov byte [0x04], 's'
mov byte [0x05], 0x04

mov byte [0x06], 'e'
mov byte [0x07], 0x04

mov byte [0x08], 'm'
mov byte [0x09], 0x04

mov byte [0x0a], 'b'
mov byte [0x0b], 0x04

mov byte [0x0c], 'l'
mov byte [0x0d], 0x04

mov byte [0x0e], 'y'
mov byte [0x0f], 0x04

mov byte [0x10], '.'
mov byte [0x11], 0x04

mov byte [0x00], 0x41 #偏移地址0x00是一个字节单元的偏移地址，本次传送是以字节方式进行
#一但目的操作数0x00被指定是byte，那么0x41也是一个字节长

mov ax, 0xb800 #目的操作数ax是16位长度，因此源操数0xb800是必须是16位的长度，并不需要指明宽度

#下面2条指令同样不用指明宽度
mov [0x00], al    ;按字节操作
mov ax, [0x02]   ;按字操作

MOV  目的操作数,  源操作数

目的操作数相当于容器，可以是：寄存器、内存地址
源操作数可以是：寄存器、内存地址、立即数

传送指令只会改变目的操作数的内容，不会改变源操作数内容

mov ah, bh
mov ax, dx

mov ax, bl ;报错，寄存器的宽度必须相同

mov al, [0xf000] ;把内存里偏移地址为f000的数据传送到寄存器al中，在传送时段地址在段寄存器DS中。
        ;目的操作数是8位的寄存器al，所以传送是以字节为单位进行的，是从偏移地址f000处取一个字节传送
mov bx, [0x08]

mov al, 0x07  ;将立即数0x07传送到寄存器al。因为al是8位寄存器，因此0x07的长度被视为一个字节
mov bx, 0x08

mov [0x0c], dx  ;将寄存器dx中的内容传送到内存中，偏移地址为0x0c处。因为dx是16位的，
        ;因此传送的数据长度也是16位的，将占用偏移地址0x0c处2个连续的最小的单元。
mov [0x2000], ah

mov byte [0x02], 0xe9 ;将字节长度的立即数0xe9传送到起始地址为0x02字节单元
mov byte [0x06], 0x3c ;将一个字长度的立即数0x3c传送到内存中偏移地址为0x06处连续的2个最小单元

; mov 0x07, al  ; 目的操作数不允许是立即数
; mov [0x01], [0x02] ;目的操作数和源操作数不能同时为内存单元

可以用2个指令分阶段实现
mov ax, [0x02]
mov [0x01], ax

;mov ip, 0xf000 ; 非法的，指令指针寄存器IP不能在指令中直接访问

;如果目的操作是段寄存器，源操作数必须是通用寄存器或者内存地址
mov ds, ax
mov es, [0x3002]

#编译，机器码看来不够直观
D:\project\assemblyprojs\assembly>nasm  exam.asm -f bin -o exam.bin

#-l 选项生成列表文件，包含了汇编指令和机器码

D:\project\assemblyprojs>nasm exam.asm -l exam.lst

D:\project\assemblyprojs>type exam.lst
   第1列为行号； 第2列为每条指令相对文件起始处的偏移量(汇编地址，程序汇编阶段所确认的地址)；
   第3列为每条指令的机器码；第4列为每条指令的汇编语言格式；第5列为注释
     1 00000000 B800B8                  mov ax, 0xb800
     2 00000003 8ED8                    mov ds, ax
     3                                  
     4 00000005 C606000041              mov byte [0x00], 0x41  ;字符A的ASCII编码. 指令的意思是把A的编码传送到B8000处
     5 0000000A C606010004              mov byte [0x01], 0x04  ;黑底红字，无闪烁
     6                                  
     7 0000000F C606020073              mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
     8 00000014 C606030004              mov byte [0x03], 0x04
     9                                  
    10 00000019 C606040073              mov byte [0x04], 's'
    11 0000001E C606050004              mov byte [0x05], 0x04
    12                                  
    13 00000023 C606060065              mov byte [0x06], 'e'
    14 00000028 C606070004              mov byte [0x07], 0x04
    15                                  
    16 0000002D C60608006D              mov byte [0x08], 'm'
    17 00000032 C606090004              mov byte [0x09], 0x04
    18                                  
    19 00000037 C6060A0062              mov byte [0x0a], 'b'
    20 0000003C C6060B0004              mov byte [0x0b], 0x04
    21                                  
    22 00000041 C6060C006C              mov byte [0x0c], 'l'
    23 00000046 C6060D0004              mov byte [0x0d], 0x04
    24                                  
    25 0000004B C6060E0079              mov byte [0x0e], 'y'
    26 00000050 C6060F0004              mov byte [0x0f], 0x04
    27                                  
    28 00000055 C60610002E              mov byte [0x10], '.'
    29 0000005A C606110004              mov byte [0x11], 0x04

nasm exam.asm -f bin -o exam.bin -l exam.lst

cat exam.lst
     1 00000000 B800B8                  mov ax, 0xb800
     2 00000003 8ED8                    mov ds, ax
     3                                  
     4 00000005 C606000041              mov byte [0x00], 0x41  ;字符A的ASCII编码. 指令的意思是把A的编码传送到B8000处
     5 0000000A C606010004              mov byte [0x01], 0x04  ;黑底红字，无闪烁
     6                                  
     7 0000000F C606020073              mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
     8 00000014 C606030004              mov byte [0x03], 0x04
     9                                  
    10 00000019 C606040073              mov byte [0x04], 's'
    11 0000001E C606050004              mov byte [0x05], 0x04
    12                                  
    13 00000023 C606060065              mov byte [0x06], 'e'
    14 00000028 C606070004              mov byte [0x07], 0x04
    15                                  
    16 0000002D C60608006D              mov byte [0x08], 'm'
    17 00000032 C606090004              mov byte [0x09], 0x04
    18                                  
    19 00000037 C6060A0062              mov byte [0x0a], 'b'
    20 0000003C C6060B0004              mov byte [0x0b], 0x04
    21                                  
    22 00000041 C6060C006C              mov byte [0x0c], 'l'
    23 00000046 C6060D0004              mov byte [0x0d], 0x04
    24                                  
    25 0000004B C6060E0079              mov byte [0x0e], 'y'
    26 00000050 C6060F0004              mov byte [0x0f], 0x04
    27                                  
    28 00000055 C60610002E              mov byte [0x10], '.'
    29 0000005A C606110004              mov byte [0x11], 0x04
    30                                  
    31                                  ;times 510-? db 0   ; 要填充的字节数为512字节减去55AA的2个字节， 再减程序的长度。 
    32 0000005F 00<rep 1FEh>            times 510 db 0
    33                                  
    34                                  
    35 0000025D 55AA                    db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

mov ax, 0xb800
mov ds, ax

mov byte [0x00], 0x41  ;字符A的ASCII编码. 指令的意思是把A的编码传送到B8000处
mov byte [0x01], 0x04  ;黑底红字，无闪烁

mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
mov byte [0x03], 0x04

mov byte [0x04], 's'
mov byte [0x05], 0x04

mov byte [0x06], 'e'
mov byte [0x07], 0x04

mov byte [0x08], 'm'
mov byte [0x09], 0x04

mov byte [0x0a], 'b'
mov byte [0x0b], 0x04

mov byte [0x0c], 'l'
mov byte [0x0d], 0x04

mov byte [0x0e], 'y'
mov byte [0x0f], 0x04

mov byte [0x10], '.'
mov byte [0x11], 0x04

times 510-0x5f db 0   ; 要填充的字节数为512字节减去55AA的2个字节, 再减程序的长度。 

db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

jasper@jasper MINGW64 /d/project/assemblyprojs
$ hexdump.exe  -C exam.bin
00000000  b8 00 b8 8e d8 c6 06 00  00 41 c6 06 01 00 04 c6  |.........A......|
00000010  06 02 00 73 c6 06 03 00  04 c6 06 04 00 73 c6 06  |...s.........s..|
00000020  05 00 04 c6 06 06 00 65  c6 06 07 00 04 c6 06 08  |.......e........|
00000030  00 6d c6 06 09 00 04 c6  06 0a 00 62 c6 06 0b 00  |.m.........b....|
00000040  04 c6 06 0c 00 6c c6 06  0d 00 04 c6 06 0e 00 79  |.....l.........y|
00000050  c6 06 0f 00 04 c6 06 10  00 2e c6 06 11 00 04 00  |................|
00000060  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
00000200
# 可以看到程序大小正好是512个字节

start:
        mov ax, 0xb800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.指令的意思是把A的编码传送到B8000处
        mov byte [0x01], 0x04  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04
current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

cat exam.lst

     1                                  start:
     2 00000000 B800B8                          mov ax, 0xb800
     3 00000003 8ED8                            mov ds, ax
     4                                  
     5 00000005 C606000041                      mov byte [0x00], 0x41  ;字符A的ASCII编码.指令的意思是把A的编码传送到B8000处
     6 0000000A C606010004                      mov byte [0x01], 0x04  ;黑底红字，无闪烁
     7                                          
     8 0000000F C606020073                      mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
     9 00000014 C606030004                      mov byte [0x03], 0x04
    10                                          
    11 00000019 C606040073                      mov byte [0x04], 's'
    12 0000001E C606050004                      mov byte [0x05], 0x04
    13                                          
    14 00000023 C606060065                      mov byte [0x06], 'e'
    15 00000028 C606070004                      mov byte [0x07], 0x04
    16                                          
    17 0000002D C60608006D                      mov byte [0x08], 'm'
    18 00000032 C606090004                      mov byte [0x09], 0x04
    19                                          
    20 00000037 C6060A0062                      mov byte [0x0a], 'b'
    21 0000003C C6060B0004                      mov byte [0x0b], 0x04
    22                                          
    23 00000041 C6060C006C                      mov byte [0x0c], 'l'
    24 00000046 C6060D0004                      mov byte [0x0d], 0x04
    25                                          
    26 0000004B C6060E0079                      mov byte [0x0e], 'y'
    27 00000050 C6060F0004                      mov byte [0x0f], 0x04
    28                                          
    29 00000055 C60610002E                      mov byte [0x10], '.'
    30 0000005A C606110004                      mov byte [0x11], 0x04
    31                                  current: 
    32 0000005F 00<rep 19Fh>                    times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 
    33                                          
    34 000001FE 55AA                            db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

jasper@jasper MINGW64 /d/project/assemblyprojs
$ hexdump.exe  -C exam.bin
00000000  b8 00 b8 8e d8 c6 06 00  00 41 c6 06 01 00 04 c6  |.........A......|
00000010  06 02 00 73 c6 06 03 00  04 c6 06 04 00 73 c6 06  |...s.........s..|
00000020  05 00 04 c6 06 06 00 65  c6 06 07 00 04 c6 06 08  |.......e........|
00000030  00 6d c6 06 09 00 04 c6  06 0a 00 62 c6 06 0b 00  |.m.........b....|
00000040  04 c6 06 0c 00 6c c6 06  0d 00 04 c6 06 0e 00 79  |.....l.........y|
00000050  c6 06 0f 00 04 c6 06 10  00 2e c6 06 11 00 04 00  |................|
00000060  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
00000200

start:
        mov ax, 0xb800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.指令的意思是把A的编码传送到B8000处
        mov byte [0x01], 0x04  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04

        jmp 0x0000:0x7c00 ;循环从主引导扇区起始处读取指令。段间直接绝对跳转指令

current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

jasper@jasper MINGW64 /d/project/assemblyprojs
$ hexdump.exe -C exam.bin
00000000  b8 00 b8 8e d8 c6 06 00  00 41 c6 06 01 00 04 c6  |.........A......|
00000010  06 02 00 73 c6 06 03 00  04 c6 06 04 00 73 c6 06  |...s.........s..|
00000020  05 00 04 c6 06 06 00 65  c6 06 07 00 04 c6 06 08  |.......e........|
00000030  00 6d c6 06 09 00 04 c6  06 0a 00 62 c6 06 0b 00  |.m.........b....|
00000040  04 c6 06 0c 00 6c c6 06  0d 00 04 c6 06 0e 00 79  |.....l.........y|
00000050  c6 06 0f 00 04 c6 06 10  00 2e c6 06 11 00 04 ea  |................|   #跳转指令，EA是操作码
00000060  00 7c 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |.|..............| #00 7c是偏移地址， 00 00 是段地址。因为是
#intel处理器是低端字节序的，处理器的低字节在内存的低地址处，处理器的高字节在内存的高地址处。
#所以 00 7c 00 00 ， 读的时候是从后往前读，读成 0000  7c00
00000070  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
00000200

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

     1                                  start:
     2 00000000 B800B8                          mov ax, 0xb800 ;段地址B800
     3 00000003 8ED8                            mov ds, ax
     4                                  
     5 00000005 C606000041                      mov byte [0x00], 0x41  ;字符A的ASCII编码.意思是把A的编码传送到内存物理地址B8000处
     6 0000000A C606010004                      mov byte [0x01], 0x04  ;黑底红字，无闪烁
     7                                          
     8 0000000F C606020073                      mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
     9 00000014 C606030004                      mov byte [0x03], 0x04
     ......
    32 0000005F EA007C0000                      jmp 0x0000:0x7c00 ;循环从主引导扇区起始处读取指令。段间直接绝对跳转指令
    33                                  
    34                                  current: 
    35 00000064 00<rep 19Ah>                    times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 
    36                                          
    37 000001FE 55AA                            db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

start:
        mov ax, 0xb800 ;段地址B800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.意思是把A的编码传送到内存物理地址B8000处
        mov byte [0x01], 0x0c  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04

        jmp 0x0000:0x7c5f ;跳转到自己。段间直接绝对跳转指令

current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0xb800            ; b800b8

#反汇编32条指令
<bochs:3> u /32
0000000000007c00: (                    ): mov ax, 0xb800            ; b800b8
0000000000007c03: (                    ): mov ds, ax                ; 8ed8
0000000000007c05: (                    ): mov byte ptr ds:0x0000, 0x41 ; c606000041
0000000000007c0a: (                    ): mov byte ptr ds:0x0001, 0x0c; c60601000c
0000000000007c0f: (                    ): mov byte ptr ds:0x0002, 0x73 ; c606020073
0000000000007c14: (                    ): mov byte ptr ds:0x0003, 0x04 ; c606030004
0000000000007c19: (                    ): mov byte ptr ds:0x0004, 0x73 ; c606040073
0000000000007c1e: (                    ): mov byte ptr ds:0x0005, 0x04 ; c606050004
0000000000007c23: (                    ): mov byte ptr ds:0x0006, 0x65 ; c606060065
0000000000007c28: (                    ): mov byte ptr ds:0x0007, 0x04 ; c606070004
0000000000007c2d: (                    ): mov byte ptr ds:0x0008, 0x6d ; c60608006d
0000000000007c32: (                    ): mov byte ptr ds:0x0009, 0x04 ; c606090004
0000000000007c37: (                    ): mov byte ptr ds:0x000a, 0x62 ; c6060a0062
0000000000007c3c: (                    ): mov byte ptr ds:0x000b, 0x04 ; c6060b0004
0000000000007c41: (                    ): mov byte ptr ds:0x000c, 0x6c ; c6060c006c
0000000000007c46: (                    ): mov byte ptr ds:0x000d, 0x04 ; c6060d0004
0000000000007c4b: (                    ): mov byte ptr ds:0x000e, 0x79 ; c6060e0079
0000000000007c50: (                    ): mov byte ptr ds:0x000f, 0x04 ; c6060f0004
0000000000007c55: (                    ): mov byte ptr ds:0x0010, 0x2e ; c60610002e
0000000000007c5a: (                    ): mov byte ptr ds:0x0011, 0x04 ; c606110004
0000000000007c5f: (                    ): jmpf 0x0000:7c5f          ; ea5f7c0000
......

#设置断点7c5f, 再执行到断点处
<bochs:4> b 0x7c5f
<bochs:5> c
(0) Breakpoint 2, 0x0000000000007c5f in ?? ()
Next at t=17175583
(0) [0x000000007c5f] 0000:7c5f (unk. ctxt): jmpf 0x0000:7c5f          ; ea5f7c0000

#可以看到屏幕上已经显示自定义文本信息

#下一条将执行的指令一直是跳到物理地址7c5f
<bochs:6> s
(0) Breakpoint 2, 0x0000000000007c5f in ?? ()
Next at t=17175584
(0) [0x000000007c5f] 0000:7c5f (unk. ctxt): jmpf 0x0000:7c5f          ; ea5f7c0000
<bochs:7> s
(0) Breakpoint 2, 0x0000000000007c5f in ?? ()
Next at t=17175585
(0) [0x000000007c5f] 0000:7c5f (unk. ctxt): jmpf 0x0000:7c5f          ; ea5f7c0000
<bochs:8> s
(0) Breakpoint 2, 0x0000000000007c5f in ?? ()
Next at t=17175586
(0) [0x000000007c5f] 0000:7c5f (unk. ctxt): jmpf 0x0000:7c5f          ; ea5f7c0000

#退出
<bochs:9> q

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
#设置断点7c00 再执行到断点处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0xb800            ; b800b8

# mov ax, 0xb800~ 这是主引导扇区的第1条指令，它的逻辑地址是 ~0000:7c00~ , 换句话
#说段寄存器CS的内容是0，指令指针寄存器IP的内容是7c00

#查看段寄存器, CS的内容是0000
<bochs:3> sreg
es:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
cs:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
ss:0x0000, dh=0x00009300, dl=0x0000ffff, valid=7
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
ds:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
fs:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
gs:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
ldtr:0x0000, dh=0x00008200, dl=0x0000ffff, valid=1
tr:0x0000, dh=0x00008b00, dl=0x0000ffff, valid=1
gdtr:base=0x00000000000f9e67, limit=0x30
idtr:base=0x0000000000000000, limit=0x3ff

#查看通用寄存器，rip的低16位对应着8086的IP的内容为7c00
<bochs:4> r
rax: 00000000_0000aa55
rbx: 00000000_00000000
rcx: 00000000_00090000
rdx: 00000000_00000080
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000e0000
rdi: 00000000_0000ffac
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c00
eflags: 0x00000082: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf
#退出
<bochs:5> q

start:
        mov ax, 0xb800 ;段地址B800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.意思是把A的编码传送到内存物理地址B8000处
        mov byte [0x01], 0x0c  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04

again:
        jmp 0x0000:0x7c00+again ;跳转到自己。段间直接绝对跳转指令

current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

jmp 0x0000:0x7c00+again ;跳转到自己。段间直接绝对跳转指令

start:
        mov ax, 0xb800 ;段地址B800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.意思是把A的编码传送到内存物理地址B8000处
        mov byte [0x01], 0x0c  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04

        mov bx, 0x7c00+again

again:
        jmp bx ;跳转到自己。绝对间接近跳转指令

current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点7c00 再执行到断点处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0xb800            ; b800b8

#反汇编32条指令，观察指令和对应的物理地址，jmp指令的物理地址是7c62，跳转自己
<bochs:3> u /32
0000000000007c00: (                    ): mov ax, 0xb800            ; b800b8
0000000000007c03: (                    ): mov ds, ax                ; 8ed8
0000000000007c05: (                    ): mov byte ptr ds:0x0000, 0x41 ; c606000041
0000000000007c0a: (                    ): mov byte ptr ds:0x0001, 0x0c ; c60601000c
0000000000007c0f: (                    ): mov byte ptr ds:0x0002, 0x73 ; c606020073
0000000000007c14: (                    ): mov byte ptr ds:0x0003, 0x04 ; c606030004
0000000000007c19: (                    ): mov byte ptr ds:0x0004, 0x73 ; c606040073
0000000000007c1e: (                    ): mov byte ptr ds:0x0005, 0x04 ; c606050004
0000000000007c23: (                    ): mov byte ptr ds:0x0006, 0x65 ; c606060065
0000000000007c28: (                    ): mov byte ptr ds:0x0007, 0x04 ; c606070004
0000000000007c2d: (                    ): mov byte ptr ds:0x0008, 0x6d ; c60608006d
0000000000007c32: (                    ): mov byte ptr ds:0x0009, 0x04 ; c606090004
0000000000007c37: (                    ): mov byte ptr ds:0x000a, 0x62 ; c6060a0062
0000000000007c3c: (                    ): mov byte ptr ds:0x000b, 0x04 ; c6060b0004
0000000000007c41: (                    ): mov byte ptr ds:0x000c, 0x6c ; c6060c006c
0000000000007c46: (                    ): mov byte ptr ds:0x000d, 0x04 ; c6060d0004
0000000000007c4b: (                    ): mov byte ptr ds:0x000e, 0x79 ; c6060e0079
0000000000007c50: (                    ): mov byte ptr ds:0x000f, 0x04 ; c6060f0004
0000000000007c55: (                    ): mov byte ptr ds:0x0010, 0x2e ; c60610002e
0000000000007c5a: (                    ): mov byte ptr ds:0x0011, 0x04 ; c606110004
0000000000007c5f: (                    ): mov bx, 0x7c62            ; bb627c
0000000000007c62: (                    ): jmp bx                    ; ffe3
0000000000007c64: (                    ): add byte ptr ds:[bx+si], al ; 0000


#设置断点，执行到mov bx, 0x7c62停下来
<bochs:4> b 0x7c5f
<bochs:5> c
(0) Breakpoint 2, 0x0000000000007c5f in ?? ()
Next at t=17175583
(0) [0x000000007c5f] 0000:7c5f (unk. ctxt): mov bx, 0x7c62            ; bb627c

#不同的跳转指令，他们的操作码是不一样的。跳转到bx的操作码是ffe3
<bochs:6> s
Next at t=17175584
(0) [0x000000007c62] 0000:7c62 (unk. ctxt): jmp bx                    ; ffe3
<bochs:7> s
Next at t=17175585
(0) [0x000000007c62] 0000:7c62 (unk. ctxt): jmp bx                    ; ffe3
<bochs:8> s
Next at t=17175586
(0) [0x000000007c62] 0000:7c62 (unk. ctxt): jmp bx                    ; ffe3
<bochs:9> s
Next at t=17175587
(0) [0x000000007c62] 0000:7c62 (unk. ctxt): jmp bx                    ; ffe3
#同时要说明的是，这条指令执行时不改变段寄存器CS的内容，只是改变
#指令指针寄存器IP的内容，所以它是段内绝对间接近跳转指令

#只要虚拟机不关机就会永远执行这条指令

#退出
<bochs:11> q

jmp 标号

jmp short 标号 ;短跳转。机器指令2个字节，EB 和 8位的相对偏移量
jmp near 标号  ;近跳转。操作码E9，和16位的相对偏移量

start:
        mov ax, 0xb800 ;段地址B800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.意思是把A的编码传送到内存物理地址B8000处
        mov byte [0x01], 0x0c  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04

again:
        jmp near start ;跳转到自己。相对偏移量跳转。E9 16位的相对偏移量

current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点7c00 再执行到断点处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0xb800            ; b800b8

#反汇编32条指令，观察指令和对应的物理地址
<bochs:3> u /32
0000000000007c00: (                    ): mov ax, 0xb800            ; b800b8
0000000000007c03: (                    ): mov ds, ax                ; 8ed8
0000000000007c05: (                    ): mov byte ptr ds:0x0000, 0x41 ; c606000041
0000000000007c0a: (                    ): mov byte ptr ds:0x0001, 0x0c ; c60601000c
0000000000007c0f: (                    ): mov byte ptr ds:0x0002, 0x73 ; c606020073
0000000000007c14: (                    ): mov byte ptr ds:0x0003, 0x04 ; c606030004
0000000000007c19: (                    ): mov byte ptr ds:0x0004, 0x73 ; c606040073
0000000000007c1e: (                    ): mov byte ptr ds:0x0005, 0x04 ; c606050004
0000000000007c23: (                    ): mov byte ptr ds:0x0006, 0x65 ; c606060065
0000000000007c28: (                    ): mov byte ptr ds:0x0007, 0x04 ; c606070004
0000000000007c2d: (                    ): mov byte ptr ds:0x0008, 0x6d ; c60608006d
0000000000007c32: (                    ): mov byte ptr ds:0x0009, 0x04 ; c606090004
0000000000007c37: (                    ): mov byte ptr ds:0x000a, 0x62 ; c6060a0062
0000000000007c3c: (                    ): mov byte ptr ds:0x000b, 0x04 ; c6060b0004
0000000000007c41: (                    ): mov byte ptr ds:0x000c, 0x6c ; c6060c006c
0000000000007c46: (                    ): mov byte ptr ds:0x000d, 0x04 ; c6060d0004
0000000000007c4b: (                    ): mov byte ptr ds:0x000e, 0x79 ; c6060e0079
0000000000007c50: (                    ): mov byte ptr ds:0x000f, 0x04 ; c6060f0004
0000000000007c55: (                    ): mov byte ptr ds:0x0010, 0x2e ; c60610002e
0000000000007c5a: (                    ): mov byte ptr ds:0x0011, 0x04 ; c606110004
0000000000007c5f: (                    ): jmp .-98  (0x00007c00)    ; e99eff
0000000000007c62: (                    ): add byte ptr ds:[bx+si], al ; 0000
#e99eff一共3个字节。其中e9是操作码，9eff是相对偏移量。

 1                                  start:
 2 00000000 B800B8                          mov ax, 0xb800 ;段地址B800
 ......
32                                  again:
33 0000005F E99EFF                          jmp near start ;跳转到自己。相对偏移量跳转。E9 16位的相对偏移量
36 00000062 00<rep 19Ch>                    times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

<bochs:4> b 0x7c5f
<bochs:5> c
(0) Breakpoint 2, 0x0000000000007c5f in ?? ()
Next at t=17175583
(0) [0x000000007c5f] 0000:7c5f (unk. ctxt): jmp .-98  (0x00007c00)    ; e99eff

#当前 jmp -98执行时，是用指令指针寄存器IP的内容+指令中指令的偏移量得到目标位置处的内存偏移地址。
#指令指针寄存器IP的内容不是7c5f，而是IP的内容等于IP的内容+当前指令的长度，即IP内容自动变为7c5f+16=7c62
#所以目标位置内存偏移地址为=7c62+ff9e=17c00，指令指针的内容只有16位，取7c00
<bochs:6> s
(0) Breakpoint 1, 0x0000000000007c00 in ?? ()
Next at t=17175584
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0xb800            ; b800b8
<bochs:7> s
Next at t=17175585
(0) [0x000000007c03] 0000:7c03 (unk. ctxt): mov ds, ax                ; 8ed8
<bochs:8> s
Next at t=17175586
(0) [0x000000007c05] 0000:7c05 (unk. ctxt): mov byte ptr ds:0x0000, 0x41 ; c606000041

start:
        mov ax, 0xb800 ;段地址B800
        mov ds, ax

        mov byte [0x00], 0x41  ;字符A的ASCII编码.意思是把A的编码传送到内存物理地址B8000处
        mov byte [0x01], 0x0c  ;黑底红字，无闪烁

        mov byte [0x02], 's'   ;等同于 mov [0x02], 0x73
        mov byte [0x03], 0x04

        mov byte [0x04], 's'
        mov byte [0x05], 0x04

        mov byte [0x06], 'e'
        mov byte [0x07], 0x04

        mov byte [0x08], 'm'
        mov byte [0x09], 0x04

        mov byte [0x0a], 'b'
        mov byte [0x0b], 0x04

        mov byte [0x0c], 'l'
        mov byte [0x0d], 0x04

        mov byte [0x0e], 'y'
        mov byte [0x0f], 0x04

        mov byte [0x10], '.'
        mov byte [0x11], 0x04

again:
        jmp near again ;跳转到自己。相对偏移量跳转。E9 16位的相对偏移量

current: 
        times 510-(current-start) db 0   ;要填充的字节数为512字节减去55AA的2个字节, 再减程序长度。 

        db 0x55, 0xaa ;用一个db可以定义多个字节，用逗号分隔

数字1 -> 0000 0001 (0x01)
字符1 -> 0011 0001 (0x31)

div bh
#bh是8位的寄存器，存放的是除数，那么被除数存放在AX里
#AX中内容除以BH中内容，相除后，商在AL中，余数在AH中

div byte [0x2002]
#除数在内存中，从内存地址0x2002处取1个字节
#AX中内容除以0x2002地址的8位除数，相除后，商在AL中，余数在AH中

div bx
#bx是16位的寄存器，存放的是除数，那么被除数是32位的，低16位在寄存器AX里；高16位在寄存器DX里
#用DX和AX组合成32位的被除数除以BX中内容，相除后，商在AX中，余数在DX中

div word [0x2002]
#除数在内存中，从内存地址0x2002处取1个字
#用DX和AX组合成32位的被除数除以0x2002地址的16位除数，相除后，商在AX中，余数在DX中

div ebx
#ebx是32位的寄存器，存放的是除数，那么被除数是64位的，低32位在寄存器EAX里；高32位在寄存器EDX里
#用EDX和EAX组合成64位的被除数除以有EBX中内容，相除后，商在EAX中，余数在EDX中

div dword [0x2002]
#除数在内存中，从内存地址0x2002处取4个字节组合出32位操作数
#用EDX和EAX组合成64位的被除数除以0x2002地址的32位除数，相除后，商在EAX中，余数在EDX中

div rbx
#rbx是64位的寄存器，存放的是除数，那么被除数是128位的，低64位在寄存器RAX里；高64位在寄存器RDX里
#用RDX和RAX组合成128位的被除数除以有RBX中内容，相除后，商在RAX中，余数在RDX中

div qword [0x2002]
#除数在内存中，从内存地址0x2002处取8个字节组合出64位操作数
#用RDX和RAX组合成128位的被除数除以0x2002地址的64位除数，相除后，商在RAX中，余数在RDX中

;计算378除以37的结果
mov ax, 378  ;378传送到ax，被除数
mov bl, 37  ;37传送到bl，除数
div bl     ;AL=商(10), AH=余数(8)

start:
        ;计算378除以37的结果
        mov ax, 378
        mov bl, 37
        div bl     ;AL=商(10), AH=余数(8)

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563  #16进制的17a等于10进制的378
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0x017a            ; b87a01

#单步执行
<bochs:3> s
Next at t=17175564
(0) [0x000000007c03] 0000:7c03 (unk. ctxt): mov bl, 0x25              ; b325
#查看mov ax, 0x017a执行后，寄存器内容
<bochs:4> r
rax: 00000000_0000017a #rax的低16位ax内容为017a，10进制的378
rbx: 00000000_00000000
.....
rip: 00000000_00007c03

#查看mov bl, 0x25执行后，寄存器内容
<bochs:5> s
Next at t=17175565
(0) [0x000000007c05] 0000:7c05 (unk. ctxt): div al, bl                ; f6f3
<bochs:6> r
rax: 00000000_0000017a
rbx: 00000000_00000025 ;rbx的低8位bl内容为25，即10进制37
......
rip: 00000000_00007c05

#查看div al, bl执行后，寄存器内容。这是bochs虚拟机自己定义的格式，实际上是div bl
<bochs:7> s
Next at t=17175566
(0) [0x000000007c07] 0000:7c07 (unk. ctxt): add byte ptr ds:[bx+si], al ; 0000
<bochs:8> r
rax: 00000000_0000080a  #378除以37，商在al中，rax的低8位0a，10进制的10; 余数在ah中，rax的高8位08，10进制的8
rbx: 00000000_00000025
......
rip: 00000000_00007c07

;计算65535除以10的结果
mov ax, 65535
mov bl, 10
div bl     ;AL=商(6553), AH=余数(5)

start:
        ;计算65535除以10的结果
        mov ax, 65535
        mov dx, 0
        mov bx, 10
        div bx     ;AX=商(6553), DX=余数(5)

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

异或电路有2个输入1个输出。当输入相同时，输出为0；当输入不同时，输出为1

0 ^ 0 = 0
1 ^ 1 = 0
0 ^ 1 = 1
1 ^ 0 = 1

#异或操作可在2个数之间进行
129 ^ 127 = ?
1000 0001 
0111 1111 ^
---------
1111 1110  254

xor r/m, r/m/imm

#说明
r 寄存器
m 内存地址
imm 立即数

异或的结果保存在左操作数中。

注意：2个操作数所指定的数据长度必须相同

xor bh, al  #bh的值和al的值做异或操作，结果在bh中

xor cx, dx #cx的值和dx的值做异或操作，结果在cx中

xor ax, 3 #ax的值和立即数3做异或操作，结果在ax中. 因为ax是16位寄存器，
#所以为了保持一致，立即数3被当成16位的数字参与运算

xor word [0x2002], 67 #把从内存地址2002开始的一个字和立即数67做异或操作，结果返回到原来的内存地址保存。
#因为内存操作数是用word来修饰的，因此操作数的长度是16位的字，为了保持一致，立即数
#被当成16位的数字参与运算

xor si, [0x2002] #把si和内存里的数字做异或运算，结果在si中。
#因为si的长度是16位的，所以必须从内存地址2002处读取一个16位的字参与运算。 

start:
        ;计算65535除以10的结果
        mov ax, 65535
        xor dx, dx   ;等价于mov dx, 0, 执行速度更快
        mov bx, 10
        div bx     ;AX=商(6553), DX=余数(5)

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

start:
        ;在屏幕上显示数字65535
        mov ax, 65535
        xor dx, dx          ;等价于mov dx, 0
        mov bx, 10
        div bx              ;AX=商(6553), DX=余数(5)

        add dl, 0x30        ;将数字转换为对应的数字字符

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

add r/m, r/m/imm

#说明
r 寄存器
m 内存地址
imm 立即数

结果保存在左操作数中

说明：2个操作数所指的数据长度必须相同，操作数不能同时为内存地址

add bh, al  #bh的值和al的值相加，结果在bh中

add cx, dx #cx的值和dx的值相加，结果在cx中

add ax, 3 #ax的值和立即数3相加，结果在ax中. 因为ax是16位寄存器，
#所以为了保持一致，立即数3被当成16位的数字参与运算

add word [0x2002], 67 #把从内存地址2002开始的一个字和立即数67相加，结果返回到原来的内存地址保存。
#因为内存操作数是用word来修饰的，因此操作数的长度是16位的字，为了保持一致，立即数
#被当成16位的数字参与运算

add si, [0x2002] #把si和内存里的数字相加，结果在si中。
#因为si的长度是16位的，所以必须从内存地址2002处读取一个16位的字参与运算。 

start:
        ;在屏幕上显示数字65535
        mov ax, 65535
        xor dx, dx          ;等价于mov dx, 0
        mov bx, 10
        div bx              ;AX=商(6553), DX=余数(5)

        add dl, 0x30        ;将数字转换为对应的数字字符

        ;指定数据段寄存ds内容， 0
        mov cx, 0
        mov ds, cx

        mov [0x7c00+buffer], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第1个0处

        ;分解第2个数位，将数位对应字符存放在 db 0,0,0,0,0 的第2个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+1], dl ;将dl中的字符编码0x33传送到段内这个偏移地址处。即第2个0处

        ;分解第3个数位，将数位对应字符存放在 db 0,0,0,0,0 的第3个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+2], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第3个0处

        ;分解第4个数位，将数位对应字符存放在 db 0,0,0,0,0 的第4个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+3], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第4个0处

        ;分解最后一个数位，将数位对应字符存放在 db 0,0,0,0,0 的第5个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+4], dl ;将dl中的字符编码0x36传送到段内这个偏移地址处。即第5个0处

buffer  db 0, 0, 0, 0,0     ;开辟5个字节空间

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

start:
        ;在屏幕上显示数字65535
        mov ax, 65535
        xor dx, dx          ;等价于mov dx, 0
        mov bx, 10
        div bx              ;AX=商(6553), DX=余数(5)

        add dl, 0x30        ;将数字转换为对应的数字字符

        ;指定数据段寄存ds内容， 0
        mov cx, 0
        mov ds, cx

        mov [0x7c00+buffer], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第1个0处

        ;分解第2个数位，将数位对应字符存放在 db 0,0,0,0,0 的第2个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+1], dl ;将dl中的字符编码0x33传送到段内这个偏移地址处。即第2个0处

        ;分解第3个数位，将数位对应字符存放在 db 0,0,0,0,0 的第3个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+2], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第3个0处

        ;分解第4个数位，将数位对应字符存放在 db 0,0,0,0,0 的第4个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+3], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第4个0处

        ;分解最后一个数位，将数位对应字符存放在 db 0,0,0,0,0 的第5个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+4], dl ;将dl中的字符编码0x36传送到段内这个偏移地址处。即第5个0处

        ;分别将字符传送到显存中
        ;第1个字符
        mov al, [0x7c00+buffer+4]

        mov cx, 0xb800
        mov ds, cx

        mov [0x00], al
        mov byte [0x01], 0x2f

        ;第2个字符
        mov cx, 0
        mov ds, cx

        mov al, [0x7c00+buffer+3]

        mov cx, 0xb800
        mov ds, cx

        mov [0x02], al
        mov byte [0x03], 0x2f

        ; 一直到第5个字符....

buffer  db 0, 0, 0, 0,0     ;开辟5个字节空间

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

start:
        ;在屏幕上显示数字65535
        mov ax, 65535
        xor dx, dx          ;等价于mov dx, 0
        mov bx, 10
        div bx              ;AX=商(6553), DX=余数(5)

        add dl, 0x30        ;将数字转换为对应的数字字符

        ;指定数据段寄存ds内容， 0
        mov cx, 0
        mov ds, cx

        mov [0x7c00+buffer], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第1个0处

        ;分解第2个数位，将数位对应字符存放在 db 0,0,0,0,0 的第2个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+1], dl ;将dl中的字符编码0x33传送到段内这个偏移地址处。即第2个0处

        ;分解第3个数位，将数位对应字符存放在 db 0,0,0,0,0 的第3个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+2], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第3个0处

        ;分解第4个数位，将数位对应字符存放在 db 0,0,0,0,0 的第4个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+3], dl ;将dl中的字符编码0x35传送到段内这个偏移地址处。即第4个0处

        ;分解最后一个数位，将数位对应字符存放在 db 0,0,0,0,0 的第5个字节里
        xor dx, dx          ;dx清零，因为它是被除数的高16位
        div bx
        add dl, 0x30        ;将数字转换为对应的数字字符
        mov [0x7c00+buffer+4], dl ;将dl中的字符编码0x36传送到段内这个偏移地址处。即第5个0处


        ;分别将字符传送到显存中
        mov cx, 0xb800
        mov es, cx ;将显存段地址b800传送到附加段寄存器ES中

        ;第1个字符
        mov al, [0x7c00+buffer+4]   ;如果没有特别指名，默认使用段寄存器DS
        mov [es:0x00], al           ;使用段寄存器es来填充显存
        mov byte [es:0x01], 0x2f    ;写入颜色属性

        ;第2~5个字符
        mov al, [0x7c00+buffer+3]
        mov [es:0x02], al
        mov byte [es:0x03], 0x2f

        mov al, [0x7c00+buffer+2]
        mov [es:0x04], al
        mov byte [es:0x05], 0x2f

        mov al, [0x7c00+buffer+1]
        mov [es:0x06], al
        mov byte [es:0x07], 0x2f

        mov al, [0x7c00+buffer]
        mov [es:0x08], al
        mov byte [es:0x09], 0x2f

again:
        jmp again

buffer  db 0, 0, 0, 0,0     ;开辟5个字节空间

current: 
        times 510-(current-start) db 0

        db 0x55, 0xaa

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563  #16进制的17a等于10进制的378
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0xffff            ; b8ffff

#反汇编查看一下
<bochs:3> u /32
0000000000007c00: (                    ): mov ax, 0xffff            ; b8ffff
0000000000007c03: (                    ): xor dx, dx                ; 31d2
0000000000007c05: (                    ): mov bx, 0x000a            ; bb0a00
0000000000007c08: (                    ): div ax, bx                ; f7f3
......

#
<bochs:4> s
Next at t=17175564
(0) [0x000000007c03] 0000:7c03 (unk. ctxt): xor dx, dx                ; 31d2
<bochs:5> s
Next at t=17175565
(0) [0x000000007c05] 0000:7c05 (unk. ctxt): mov bx, 0x000a            ; bb0a00
<bochs:6> s
Next at t=17175566
(0) [0x000000007c08] 0000:7c08 (unk. ctxt): div ax, bx                ; f7f3
<bochs:6> c

       ;代码清单5-1 
       ;文件名：c05_mbr.asm
       ;文件说明：硬盘主引导扇区代码

       mov ax,0xb800                 ;指向文本模式的显示缓冲区
       mov es,ax

       ;以下显示字符串"Label offset:"
       mov byte [es:0x00],'L'
       mov byte [es:0x01],0x07
       mov byte [es:0x02],'a'
       mov byte [es:0x03],0x07
       mov byte [es:0x04],'b'
       mov byte [es:0x05],0x07
       mov byte [es:0x06],'e'
       mov byte [es:0x07],0x07
       mov byte [es:0x08],'l'
       mov byte [es:0x09],0x07
       mov byte [es:0x0a],' '
       mov byte [es:0x0b],0x07
       mov byte [es:0x0c],"o"
       mov byte [es:0x0d],0x07
       mov byte [es:0x0e],'f'
       mov byte [es:0x0f],0x07
       mov byte [es:0x10],'f'
       mov byte [es:0x11],0x07
       mov byte [es:0x12],'s'
       mov byte [es:0x13],0x07
       mov byte [es:0x14],'e'
       mov byte [es:0x15],0x07
       mov byte [es:0x16],'t'
       mov byte [es:0x17],0x07
       mov byte [es:0x18],':'
       mov byte [es:0x19],0x07

       mov ax,number                 ;取得标号number的汇编地址
       mov bx,10

       ;设置数据段的基地址
       mov cx,cs
       mov ds,cx

       ;求个位上的数字
       mov dx,0
       div bx
       mov [0x7c00+number+0x00],dl   ;保存个位上的数字

       ;求十位上的数字
       xor dx,dx
       div bx
       mov [0x7c00+number+0x01],dl   ;保存十位上的数字

       ;求百位上的数字
       xor dx,dx
       div bx
       mov [0x7c00+number+0x02],dl   ;保存百位上的数字

       ;求千位上的数字
       xor dx,dx
       div bx
       mov [0x7c00+number+0x03],dl   ;保存千位上的数字

       ;求万位上的数字 
       xor dx,dx
       div bx
       mov [0x7c00+number+0x04],dl   ;保存万位上的数字

       ;以下用十进制显示标号的偏移地址
       mov al,[0x7c00+number+0x04]
       add al,0x30
       mov [es:0x1a],al
       mov byte [es:0x1b],0x04

       mov al,[0x7c00+number+0x03]
       add al,0x30
       mov [es:0x1c],al
       mov byte [es:0x1d],0x04

       mov al,[0x7c00+number+0x02]
       add al,0x30
       mov [es:0x1e],al
       mov byte [es:0x1f],0x04

       mov al,[0x7c00+number+0x01]
       add al,0x30
       mov [es:0x20],al
       mov byte [es:0x21],0x04

       mov al,[0x7c00+number+0x00]
       add al,0x30
       mov [es:0x22],al
       mov byte [es:0x23],0x04

       mov byte [es:0x24],'D'
       mov byte [es:0x25],0x07

 infi: jmp near infi                 ;无限循环

number db 0,0,0,0,0

times 203 db 0
          db 0x55,0xaa

mov byte [0x00], 'L'
mov byte [0x01], 0x2f

mytext db 'L',0x07,'a',0x07,'b',0x07,'l',0x07,'e',0x07,' ',0x07,'o',0x07,\
          'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

      jmp start
mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
      xx指令 

        jmp start

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
        mov ax, 0x7c0    ;设置数据段基地址
        mov ds, ax

        mov ax, 0xb800   ;设置附加段基地址
        mov es, ax

        jmp start

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
        mov ax, 0x7c0               ;设置数据段基地址
        mov ds, ax

        mov ax, 0xb800              ;设置附加段基地址
        mov es, ax

        cld
        mov si,mytext
        mov di,0
        mov cx,(start-mytext)/2     ;实际上等于 13
        rep movsw

mov si,mytext       ;将文本的起始偏移地址放到SI
mov di,0               ;将0传送给DI. 这意味着文本的传送是从显存的起始位置开始的
mov cx,(start-mytext)/2     ;实际上等于 13
rep movsw

cld  ;方向标志清零指令，将FLAGE寄存器的DF标志清零，0为正方向。与其相反的是STD置方向指令，将FLAGE寄存器DF标志置为1，反方向

mov cx,(start-mytext)/2     ;实际上等于 13
rep movsw

        jmp start

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
        mov ax, 0x7c0               ;设置数据段基地址
        mov ds, ax

        mov ax, 0xb800              ;设置附加段基地址
        mov es, ax

        cld
        mov si,mytext               ;将文本的起始偏移地址放到SI
        mov di,0                    ;将0传送给DI. 这意味着文本的传送是从显存的起始位置开始的
        mov cx,(start-mytext)/2     ;实际上等于 13
        rep movsw                   ;重新执行movsw, 寄存器cx为执行次数

        jmp $

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

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): jmp .+29  (0x00007c1f)    ; eb1d

<bochs:3> s
Next at t=17175564
(0) [0x000000007c1f] 0000:7c1f (unk. ctxt): mov ax, 0x07c0            ; b8c007
<bochs:4> s
Next at t=17175565
(0) [0x000000007c22] 0000:7c22 (unk. ctxt): mov ds, ax                ; 8ed8
<bochs:5> s
Next at t=17175566
(0) [0x000000007c24] 0000:7c24 (unk. ctxt): mov ax, 0xb800            ; b800b8
<bochs:6> s
Next at t=17175567
(0) [0x000000007c27] 0000:7c27 (unk. ctxt): mov es, ax                ; 8ec0
<bochs:7>
Next at t=17175568
(0) [0x000000007c29] 0000:7c29 (unk. ctxt): cld                       ; fc

#查看cld执行前标志寄存器的状态
<bochs:8> info eflags
id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf
#各个标志用名字做显示的，小写的说明该标志是0，大写是1

#查看cld执行后标志寄存器的状态，zf是0没错
<bochs:9> s
Next at t=17175569
(0) [0x000000007c2a] 0000:7c2a (unk. ctxt): mov si, 0x0002            ; be0200
<bochs:10> info eflags
id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf


<bochs:11> r
rax: 00000000_0000b800
rbx: 00000000_00000000
rcx: 00000000_00090000
rdx: 00000000_00000080
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000e0000
rdi: 00000000_0000ffac
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c2a
eflags: 0x00000082: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf
<bochs:12> s
Next at t=17175570
(0) [0x000000007c2d] 0000:7c2d (unk. ctxt): mov di, 0x0000            ; bf0000
<bochs:13> r
rax: 00000000_0000b800
rbx: 00000000_00000000
rcx: 00000000_00090000
rdx: 00000000_00000080
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000e0002
rdi: 00000000_0000ffac
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c2d
eflags: 0x00000082: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf

#观察si di内容
<bochs:14> s
Next at t=17175571
(0) [0x000000007c30] 0000:7c30 (unk. ctxt): mov cx, 0x000e            ; b90e00
<bochs:15> s
Next at t=17175572
(0) [0x000000007c33] 0000:7c33 (unk. ctxt): rep movsw word ptr es:[di], word ptr ds:[si] ; f3a5
<bochs:16> s
Next at t=17175573
(0) [0x000000007c33] 0000:7c33 (unk. ctxt): rep movsw word ptr es:[di], word ptr ds:[si] ; f3a5
<bochs:17> r
rax: 00000000_0000b800
rbx: 00000000_00000000
rcx: 00000000_0009000c #cx内容在变
rdx: 00000000_00000080
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000e0004  #自动变为0004
rdi: 00000000_00000002  #自动变为0002
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c33
eflags: 0x00010082: id vip vif ac vm RF nt IOPL=0 of df if tf SF zf af pf cf

        jmp start

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
        mov ax, 0x7c0               ;设置数据段基地址
        mov ds, ax

        mov ax, 0xb800              ;设置附加段基地址
        mov es, ax

        cld
        mov si,mytext               ;将文本的起始偏移地址放到SI
        mov di,0                    ;将0传送给DI. 这意味着文本的传送是从显存的起始位置开始的
        mov cx,(start-mytext)/2     ;实际上等于 13
        rep movsw                   ;重新执行movsw, 寄存器cx为执行次数

        ;得到标号所代表的汇编地址
        mov ax, number              ;标号和数字是等效的，程序编译后标号会转换为数字。

        ;分解各个数位
        mov bx,ax
        mov cx,5                    ;循环次数
        mov si,10                   ;除数
digit:
        xor dx,dx                   ;此时dx和ax一起形成32位被除数
        div si                      ;商在ax，余数在dx
        mov [bx],dl                 ;保存数位
        inc bx
        loop digit

        jmp $

number  db 0, 0, 0, 0, 0

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

        mov [bx],dl                 ;保存数位
; 将bx内容取出，当作偏移地址。 这个偏移地址是number标号的汇编地址

                jmp start

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
        mov ax, 0x7c0               ;设置数据段基地址
        mov ds, ax

        mov ax, 0xb800              ;设置附加段基地址
        mov es, ax

        cld
        mov si,mytext               ;将文本的起始偏移地址放到SI
        mov di,0                    ;将0传送给DI. 这意味着文本的传送是从显存的起始位置开始的
        mov cx,(start-mytext)/2     ;实际上等于 13
        rep movsw                   ;重新执行movsw, 寄存器cx为执行次数

        ;得到标号所代表的汇编地址
        mov ax, number              ;标号和数字是等效的，程序编译后标号会转换为数字。

        ;分解各个数位
        mov bx,ax
        mov cx,5                    ;循环次数
        mov si,10                   ;除数
digit:
        xor dx,dx                   ;此时dx和ax一起形成32位被除数
        div si                      ;商在ax，余数在dx
        mov [bx],dl                 ;保存数位
        inc bx
        loop digit

        ;开始显示各个数位
        mov cx,5
show:
        dec bx                      ;bx内容减1，bx保存了指向number标号的位置，上次数位分解结束后指向number最后一个位置
        mov al,[bx]
        add al,0x30
        mov ah,04
        mov [es:di],ax
        add di,2                    ;指向显存下一个位置
        loop show

        jmp $

number  db 0, 0, 0, 0, 0

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

        jmp start

mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07
       db 'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07

start:
        mov ax, 0x7c0               ;设置数据段基地址
        mov ds, ax

        mov ax, 0xb800              ;设置附加段基地址
        mov es, ax

        cld
        mov si,mytext               ;将文本的起始偏移地址放到SI
        mov di,0                    ;将0传送给DI. 这意味着文本的传送是从显存的起始位置开始的
        mov cx,(start-mytext)/2     ;实际上等于 13
        rep movsw                   ;重新执行movsw, 寄存器cx为执行次数

        ;得到标号所代表的汇编地址
        mov ax, number              ;标号和数字是等效的，程序编译后标号会转换为数字。

        ;分解各个数位
        mov bx,ax
        mov cx,5                    ;循环次数
        mov si,10                   ;除数
digit:
        xor dx,dx                   ;此时dx和ax一起形成32位被除数
        div si                      ;商在ax，余数在dx
        mov [bx],dl                 ;保存数位
        inc bx
        loop digit

        ;开始显示各个数位
        mov bx,number
        mov si,4
show:
        mov al,[bx+si]              ;si的值相当于索引
        add al,0x30
        mov ah,04
        mov [es:di],ax              ;ax内容为字符编码和颜色属性
        add di,2                    ;指向显存下一个位置
        dec si
        jns show                    ;跳转指令，如果标志寄存器的位7的SF不为1就一直跳转。si显示完最后一个数位后，最高位为1

        jmp $

number  db 0, 0, 0, 0, 0

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

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): jmp .+26  (0x00007c1c)    ; eb1a

#观察，跳转在持续进行
<bochs:4> u /52
0000000000007c00: (                    ): jmp .+26  (0x00007c1c)    ; eb1a
......
0000000000007c58: (                    ): dec si                    ; 4e
0000000000007c59: (                    ): jns .-15  (0x00007c4c)    ; 79f1
0000000000007c5b: (                    ): jmp .-2  (0x00007c5b)     ; ebfe
0000000000007c5d: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c5f: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c61: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c63: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c65: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c67: (                    ): add byte ptr ds:[bx+si], al ; 0000
<bochs:5> b 0x7c58

<bochs:6> c
(0) Breakpoint 2, 0x0000000000007c58 in ?? ()
Next at t=17175621
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): dec si                    ; 4e
<bochs:7> c
(0) Breakpoint 2, 0x0000000000007c58 in ?? ()
Next at t=17175628
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): dec si                    ; 4e
<bochs:8> c
(0) Breakpoint 2, 0x0000000000007c58 in ?? ()
Next at t=17175635
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): dec si                    ; 4e
<bochs:9> c
(0) Breakpoint 2, 0x0000000000007c58 in ?? ()
Next at t=17175642
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): dec si                    ; 4e
<bochs:10> c
(0) Breakpoint 2, 0x0000000000007c58 in ?? ()
Next at t=17175649
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): dec si                    ; 4e

#观察符号标志SF
<bochs:11> info eflags
id vip vif ac vm rf nt IOPL=0 of df if tf sf zf af PF cf
<bochs:12> s
Next at t=17175650
(0) [0x000000007c59] 0000:7c59 (unk. ctxt): jns .-15  (0x00007c4c)    ; 79f1
<bochs:13> info eflags
id vip vif ac vm rf nt IOPL=0 of df if tf SF zf AF PF cf

<bochs:14> r
rax: 00000000_00000433
rbx: 00000000_0000005d
rcx: 00000000_00090000
rdx: 00000000_00000000
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000effff  #si 最高位是1
rdi: 00000000_00000024
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c59
eflags: 0x00000096: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf AF PF cf

<bochs:15> s
Next at t=17175651
(0) [0x000000007c5b] 0000:7c5b (unk. ctxt): jmp .-2  (0x00007c5b)     ; ebfe
<bochs:16> s
Next at t=17175652
(0) [0x000000007c5b] 0000:7c5b (unk. ctxt): jmp .-2  (0x00007c5b)     ; ebfe
<bochs:17> s
Next at t=17175653
(0) [0x000000007c5b] 0000:7c5b (unk. ctxt): jmp .-2  (0x00007c5b)     ; ebfe
<bochs:18>

        jmp start
data1   db -1
data2   dw -25 ;用伪指令dw在程序中开辟一个字的空间，并保存-25
start:
        mov ax,-78 ;将-78传送到寄存器ax

mov ax, 0
sub ax,dx

mov ax, 0
sub ax,dx
mov dx,ax  ;相减的结果再返回到dx中

neg dx ;求负数指令或对面的补码指令

mov ah,0xf0  ;1111 0000 可以解释成-16 或240
inc ah ; ah加1到内容为 1111 0001 可认为是-15或241

mov ah,0xf0 ; 1111 0000
add ah,0x03 ; 1111 0011 可认为是-13或243

mov ax,0x0400
mov bl,0xf0
div bl

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

idiv  r/m

idiv bh
#bh是8位的寄存器，存放的是除数，那么被除数存放在AX里
#AX中内容除以BH中内容，相除后，商在AL中，余数在AH中

idiv byte [0x2002]
#除数在内存中，从内存地址0x2002处取1个字节
#AX中内容除以0x2002地址的8位除数，相除后，商在AL中，余数在AH中

div bx
#bx是16位的寄存器，存放的是除数，那么被除数是32位的，低16位在寄存器AX里；高16位在寄存器DX里
#用DX和AX组合成32位的被除数除以BX中内容，相除后，商在AX中，余数在DX中

div word [0x2002]
#除数在内存中，从内存地址0x2002处取1个字
#用DX和AX组合成32位的被除数除以0x2002地址的16位除数，相除后，商在AX中，余数在DX中

div ebx
#ebx是32位的寄存器，存放的是除数，那么被除数是64位的，低32位在寄存器EAX里；高32位在寄存器EDX里
#用EDX和EAX组合成64位的被除数除以有EBX中内容，相除后，商在EAX中，余数在EDX中

div dword [0x2002]
#除数在内存中，从内存地址0x2002处取4个字节组合出32位操作数
#用EDX和EAX组合成64位的被除数除以0x2002地址的32位除数，相除后，商在EAX中，余数在EDX中

div rbx
#rbx是64位的寄存器，存放的是除数，那么被除数是128位的，低64位在寄存器RAX里；高64位在寄存器RDX里
#用RDX和RAX组合成128位的被除数除以有RBX中内容，相除后，商在RAX中，余数在RDX中

div qword [0x2002]
#除数在内存中，从内存地址0x2002处取8个字节组合出64位操作数
#用RDX和RAX组合成128位的被除数除以0x2002地址的64位除数，相除后，商在RAX中，余数在RDX中

;以下为有符号除法
mov ax,0x0400       ;AX内容为有符号数1024
mov bl,0xf0         ;BL内容为有符号-16
idiv bl             ;1024/-16 AL = 0xC0

;也可以写为下面3行
mov ax,1024
mov bl,-16
idiv bl

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

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov ax, 0x0400            ; b80004
<bochs:3> s
Next at t=17175564
(0) [0x000000007c03] 0000:7c03 (unk. ctxt): mov bl, 0xf0              ; b3f0
<bochs:4> s
Next at t=17175565
(0) [0x000000007c05] 0000:7c05 (unk. ctxt): idiv al, bl               ; f6fb

#在相除之前查看通用寄存器中的内容
<bochs:5> r
rax: 00000000_00000400 #被除数在AX中0400
rbx: 00000000_000000f0 #除数在BL寄存串f0
rcx: 00000000_00090000
rdx: 00000000_00000080
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000e0000
rdi: 00000000_0000ffac
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c05
eflags: 0x00000082: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf

#执行指令 idiv al,bl后，查看通用寄存器中的内容
<bochs:6> s
Next at t=17175566
(0) [0x000000007c07] 0000:7c07 (unk. ctxt): mov ax, 0x0400            ; b80004
<bochs:7> r
rax: 00000000_000000c0  #商在AL中c0，余数在AH中0
rbx: 00000000_000000f0
rcx: 00000000_00090000
rdx: 00000000_00000080
rsp: 00000000_0000ffd6
rbp: 00000000_00000000
rsi: 00000000_000e0000
rdi: 00000000_0000ffac
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c07
eflags: 0x00000082: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf
<bochs:8> q

;以下为有符号数除法
mov ax,-6002
cwd
mov bx,-10
idiv bx

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

mov al,11111000b
add al,00001000b

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

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
Next at t=17175563
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): mov al, 0xf8              ; b0f8

#反汇编3条指令
<bochs:3> u /3
0000000000007c00: (                    ): mov al, 0xf8              ; b0f8
0000000000007c02: (                    ): add al, 0x08              ; 0408
0000000000007c04: (                    ): add byte ptr ds:[bx+si], al ; 0000

#观察标志寄存里标志位变化
<bochs:4> s
Next at t=17175564
(0) [0x000000007c02] 0000:7c02 (unk. ctxt): add al, 0x08              ; 0408
<bochs:5> info eflags
id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af pf cf
<bochs:6> s
Next at t=17175565
(0) [0x000000007c04] 0000:7c04 (unk. ctxt): add byte ptr ds:[bx+si], al ; 0000
<bochs:7> info eflags
id vip vif ac vm rf nt IOPL=0 of df if tf sf ZF AF PF CF

        ;从1加到100并显示累加结果
        jmp start

message db '1+2+3+...+100='         ;等同于 db '1','+','2','+','3','+','.','.','.','+','1','0','0','='

start:  
        mov ax,0x7c0        ;设置数据段的段基地址
        mov ds,ax

        mov ax,0xb800       ;设置附加段基址到显示缓冲区
        mov es,ax

        ;以下显示字符串
        mov si,message
        mov di,0
        mov cx,start-message
showmsg:
        mov al,[si]
        mov [es:di],al
        inc di
        mov byte [es:di],0x07
        inc si
        inc di
        loop showmsg

        ;以下计算1到100的和
        xor ax,ax           ;AX用于存放累加结果
        mov cx,1
summate:
        add ax,cx
        inc cx
        cmp cx,100
        jle  summate

        jmp $

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

        ;从1加到100并显示累加结果
        jmp start

message db '1+2+3+...+100='         ;等同于 db '1','+','2','+','3','+','.','.','.','+','1','0','0','='

start:  
        mov ax,0x7c0        ;设置数据段的段基地址
        mov ds,ax

        mov ax,0xb800       ;设置附加段基址到显示缓冲区
        mov es,ax

        ;以下显示字符串
        mov si,message
        mov di,0
        mov cx,start-message
showmsg:
        mov al,[si]
        mov [es:di],al
        inc di
        mov byte [es:di],0x07
        inc si
        inc di
        loop showmsg

        ;以下计算1到100的和
        xor ax,ax           ;AX用于存放累加结果
        mov cx,1
summate:
        add ax,cx
        inc cx
        cmp cx,100
        jle  summate

        ;以下分解累加和的每个数位
        xor cx,cx           ;设置栈段的段基地址
        mov ss,cx
        mov sp,cx

        mov bx,10
        xor cx,cx
decompo:
        inc cx
        xor dx,dx
        div bx
        add dl,0x30
        push dx
        cmp ax,0
        jne decompo

        ;以下显示各个数位
shownum:
        pop dx
        mov [es:di],dl
        inc di
        mov byte [es:di], 0x07
        inc di
        loop shownum

        jmp $

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

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): jmp .+14  (0x00007c10)    ; eb0e

<bochs:3> u /50
0000000000007c00: (                    ): jmp .+14  (0x00007c10)    ; eb0e
0000000000007c02: (                    ): xor word ptr ss:[bp+di], bp ; 312b
0000000000007c04: (                    ): xor ch, byte ptr ss:[bp+di] ; 322b
0000000000007c06: (                    ): xor bp, word ptr ss:[bp+di] ; 332b
0000000000007c08: (                    ): sub si, word ptr cs:[bx+di] ; 2e2e2e2b31
0000000000007c0d: (                    ): xor byte ptr ds:[bx+si], dh ; 3030
0000000000007c0f: (                    ): cmp ax, 0xc0b8            ; 3db8c0
0000000000007c12: (                    ): pop es                    ; 07
0000000000007c13: (                    ): mov ds, ax                ; 8ed8
0000000000007c15: (                    ): mov ax, 0xb800            ; b800b8
0000000000007c18: (                    ): mov es, ax                ; 8ec0
0000000000007c1a: (                    ): mov si, 0x0002            ; be0200
0000000000007c1d: (                    ): mov di, 0x0000            ; bf0000
0000000000007c20: (                    ): mov cx, 0x000e            ; b90e00
0000000000007c23: (                    ): mov al, byte ptr ds:[si]  ; 8a04
0000000000007c25: (                    ): mov byte ptr es:[di], al  ; 268805
0000000000007c28: (                    ): inc di                    ; 47
0000000000007c29: (                    ): mov byte ptr es:[di], 0x07 ; 26c60507
0000000000007c2d: (                    ): inc si                    ; 46
0000000000007c2e: (                    ): inc di                    ; 47
0000000000007c2f: (                    ): loop .-14  (0x00007c23)   ; e2f2
0000000000007c31: (                    ): xor ax, ax                ; 31c0
0000000000007c33: (                    ): mov cx, 0x0001            ; b90100
0000000000007c36: (                    ): add ax, cx                ; 01c8
0000000000007c38: (                    ): inc cx                    ; 41
0000000000007c39: (                    ): cmp cx, 0x0064            ; 83f964
0000000000007c3c: (                    ): jle .-8  (0x00007c36)     ; 7ef8
0000000000007c3e: (                    ): xor cx, cx                ; 31c9
0000000000007c40: (                    ): mov ss, cx                ; 8ed1
0000000000007c42: (                    ): mov sp, cx                ; 89cc
0000000000007c44: (                    ): mov bx, 0x000a            ; bb0a00
0000000000007c47: (                    ): xor cx, cx                ; 31c9
0000000000007c49: (                    ): inc cx                    ; 41
0000000000007c4a: (                    ): xor dx, dx                ; 31d2
0000000000007c4c: (                    ): div ax, bx                ; f7f3
0000000000007c4e: (                    ): add dl, 0x30              ; 80c230
0000000000007c51: (                    ): push dx                   ; 52
0000000000007c52: (                    ): cmp ax, 0x0000            ; 83f800
0000000000007c55: (                    ): jnz .-14  (0x00007c49)    ; 75f2
0000000000007c57: (                    ): pop dx                    ; 5a
0000000000007c58: (                    ): mov byte ptr es:[di], dl  ; 268815
0000000000007c5b: (                    ): inc di                    ; 47
0000000000007c5c: (                    ): mov byte ptr es:[di], 0x07 ; 26c60507
0000000000007c60: (                    ): inc di                    ; 47
0000000000007c61: (                    ): loop .-12  (0x00007c57)   ; e2f4
0000000000007c63: (                    ): jmp .-2  (0x00007c63)     ; ebfe
0000000000007c65: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c67: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c69: (                    ): add byte ptr ds:[bx+si], al ; 0000
0000000000007c6b: (                    ): add byte ptr ds:[bx+si], al ; 0000

#设置分解数位处为断点 xor cx,cx
<bochs:4> b 0x7c47
<bochs:5> c
(0) Breakpoint 2, 0x0000000000007c47 in ?? ()
Next at t=17176075
(0) [0x000000007c47] 0000:7c47 (unk. ctxt): xor cx, cx                ; 31c9
<bochs:6> n
Next at t=17176076
(0) [0x000000007c49] 0000:7c49 (unk. ctxt): inc cx                    ; 41
<bochs:7> n
Next at t=17176077
(0) [0x000000007c4a] 0000:7c4a (unk. ctxt): xor dx, dx                ; 31d2
<bochs:8> n
Next at t=17176078
(0) [0x000000007c4c] 0000:7c4c (unk. ctxt): div ax, bx                ; f7f3
<bochs:9> n
Next at t=17176079
(0) [0x000000007c4e] 0000:7c4e (unk. ctxt): add dl, 0x30              ; 80c230
<bochs:10> n
Next at t=17176080
(0) [0x000000007c51] 0000:7c51 (unk. ctxt): push dx                   ; 52

#观察压栈前，栈段寄存器SS和栈指针寄存器SP的值
<bochs:11> sreg
es:0xb800, dh=0x0000930b, dl=0x8000ffff, valid=7
        Data segment, base=0x000b8000, limit=0x0000ffff, Read/Write, Accessed
cs:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
ss:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1  #SS值为0000
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
ds:0x07c0, dh=0x00009300, dl=0x7c00ffff, valid=3
        Data segment, base=0x00007c00, limit=0x0000ffff, Read/Write, Accessed
fs:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
gs:0x0000, dh=0x00009300, dl=0x0000ffff, valid=1
        Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
ldtr:0x0000, dh=0x00008200, dl=0x0000ffff, valid=1
tr:0x0000, dh=0x00008b00, dl=0x0000ffff, valid=1
gdtr:base=0x00000000000f9e67, limit=0x30
idtr:base=0x0000000000000000, limit=0x3ff
<bochs:12> r
rax: 00000000_000001f9
rbx: 00000000_0000000a
rcx: 00000000_00090001
rdx: 00000000_00000030
rsp: 00000000_00000000 #栈指针寄存器SP为0000
rbp: 00000000_00000000
rsi: 00000000_000e0010
rdi: 00000000_0000001c
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c51
eflags: 0x00000006: id vip vif ac vm rf nt IOPL=0 of df if tf sf zf af PF cf

#观察压栈后，栈段寄存器SS和栈指针寄存器SP的值
<bochs:13> n
Next at t=17176081
(0) [0x000000007c52] 0000:7c52 (unk. ctxt): cmp ax, 0x0000            ; 83f800
<bochs:14> r
rax: 00000000_000001f9
rbx: 00000000_0000000a
rcx: 00000000_00090001
rdx: 00000000_00000030
rsp: 00000000_0000fffe  #SP = SP-2
rbp: 00000000_00000000
rsi: 00000000_000e0010
rdi: 00000000_0000001c
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c52
eflags: 0x00000006: id vip vif ac vm rf nt IOPL=0 of df if tf sf zf af PF cf
<bochs:15> print-stack  #观察栈内容, print-stack每次显示栈顶10个数据
Stack address size 2
 | STACK 0xfffe [0x0030] (<unknown>)  #栈顶。fffe处压入了一个字，0x0030
 | STACK 0x10000 [0x0000] (<unknown>)
 | STACK 0x10002 [0x0000] (<unknown>)
 | STACK 0x10004 [0x0000] (<unknown>)
 | STACK 0x10006 [0x0000] (<unknown>)
 | STACK 0x10008 [0x0000] (<unknown>)
 | STACK 0x1000a [0x0000] (<unknown>)
 | STACK 0x1000c [0x0000] (<unknown>)
 | STACK 0x1000e [0x0000] (<unknown>)
 | STACK 0x10010 [0x0000] (<unknown>)
 | STACK 0x10012 [0x0000] (<unknown>)
 | STACK 0x10014 [0x0000] (<unknown>)
 | STACK 0x10016 [0x0000] (<unknown>)
 | STACK 0x10018 [0x0000] (<unknown>)
 | STACK 0x1001a [0x0000] (<unknown>)
 | STACK 0x1001c [0x0000] (<unknown>)


 <bochs:16> n
Next at t=17176082
(0) [0x000000007c55] 0000:7c55 (unk. ctxt): jnz .-14  (0x00007c49)    ; 75f2
<bochs:17> n
Next at t=17176083
(0) [0x000000007c49] 0000:7c49 (unk. ctxt): inc cx                    ; 41
<bochs:18> n
Next at t=17176084
(0) [0x000000007c4a] 0000:7c4a (unk. ctxt): xor dx, dx                ; 31d2
<bochs:19> n
Next at t=17176085
(0) [0x000000007c4c] 0000:7c4c (unk. ctxt): div ax, bx                ; f7f3
<bochs:20> n
Next at t=17176086
(0) [0x000000007c4e] 0000:7c4e (unk. ctxt): add dl, 0x30              ; 80c230
<bochs:21> n
Next at t=17176087
(0) [0x000000007c51] 0000:7c51 (unk. ctxt): push dx                   ; 52
<bochs:22> n
Next at t=17176088
(0) [0x000000007c52] 0000:7c52 (unk. ctxt): cmp ax, 0x0000            ; 83f800
<bochs:23> r
rax: 00000000_00000032
rbx: 00000000_0000000a
rcx: 00000000_00090002
rdx: 00000000_00000035
rsp: 00000000_0000fffc
rbp: 00000000_00000000
rsi: 00000000_000e0010
rdi: 00000000_0000001c
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c52
eflags: 0x00000006: id vip vif ac vm rf nt IOPL=0 of df if tf sf zf af PF cf
<bochs:24> print-stack
Stack address size 2
 | STACK 0xfffc [0x0035] (<unknown>)
 | STACK 0xfffe [0x0030] (<unknown>)
 | STACK 0x10000 [0x0000] (<unknown>)
 | STACK 0x10002 [0x0000] (<unknown>)
 | STACK 0x10004 [0x0000] (<unknown>)
 | STACK 0x10006 [0x0000] (<unknown>)
 | STACK 0x10008 [0x0000] (<unknown>)
 | STACK 0x1000a [0x0000] (<unknown>)
 | STACK 0x1000c [0x0000] (<unknown>)
 | STACK 0x1000e [0x0000] (<unknown>)
 | STACK 0x10010 [0x0000] (<unknown>)
 | STACK 0x10012 [0x0000] (<unknown>)
 | STACK 0x10014 [0x0000] (<unknown>)
 | STACK 0x10016 [0x0000] (<unknown>)
 | STACK 0x10018 [0x0000] (<unknown>)
 | STACK 0x1001a [0x0000] (<unknown>)


 #观察POP出栈
 <bochs:25> u/10
0000000000007c52: (                    ): cmp ax, 0x0000            ; 83f800
0000000000007c55: (                    ): jnz .-14  (0x00007c49)    ; 75f2
0000000000007c57: (                    ): pop dx                    ; 5a
0000000000007c58: (                    ): mov byte ptr es:[di], dl  ; 268815
0000000000007c5b: (                    ): inc di                    ; 47
0000000000007c5c: (                    ): mov byte ptr es:[di], 0x07 ; 26c60507
0000000000007c60: (                    ): inc di                    ; 47
0000000000007c61: (                    ): loop .-12  (0x00007c57)   ; e2f4
0000000000007c63: (                    ): jmp .-2  (0x00007c63)     ; ebfe
0000000000007c65: (                    ): add byte ptr ds:[bx+si], al ; 0000
<bochs:26> b 0x7c57
<bochs:27> c
(0) Breakpoint 3, 0x0000000000007c57 in ?? ()
Next at t=17176104
(0) [0x000000007c57] 0000:7c57 (unk. ctxt): pop dx                    ; 5a
<bochs:28> r
rax: 00000000_00000000
rbx: 00000000_0000000a
rcx: 00000000_00090004
rdx: 00000000_00000035
rsp: 00000000_0000fff8  #栈顶fff8
rbp: 00000000_00000000
rsi: 00000000_000e0010
rdi: 00000000_0000001c
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c57
eflags: 0x00000046: id vip vif ac vm rf nt IOPL=0 of df if tf sf ZF af PF cf
<bochs:29> print-stack
Stack address size 2
 | STACK 0xfff8 [0x0035] (<unknown>)
 | STACK 0xfffa [0x0030] (<unknown>)
 | STACK 0xfffc [0x0035] (<unknown>)
 | STACK 0xfffe [0x0030] (<unknown>)
 | STACK 0x10000 [0x0000] (<unknown>)
 | STACK 0x10002 [0x0000] (<unknown>)
 | STACK 0x10004 [0x0000] (<unknown>)
 | STACK 0x10006 [0x0000] (<unknown>)
 | STACK 0x10008 [0x0000] (<unknown>)
 | STACK 0x1000a [0x0000] (<unknown>)
 | STACK 0x1000c [0x0000] (<unknown>)
 | STACK 0x1000e [0x0000] (<unknown>)
 | STACK 0x10010 [0x0000] (<unknown>)
 | STACK 0x10012 [0x0000] (<unknown>)
 | STACK 0x10014 [0x0000] (<unknown>)
 | STACK 0x10016 [0x0000] (<unknown>)

 #出栈后，观察
 <bochs:30> n
Next at t=17176105
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): mov byte ptr es:[di], dl  ; 268815
<bochs:31> r
rax: 00000000_00000000
rbx: 00000000_0000000a
rcx: 00000000_00090004
rdx: 00000000_00000035
rsp: 00000000_0000fffa  #栈顶fffa
rbp: 00000000_00000000
rsi: 00000000_000e0010
rdi: 00000000_0000001c
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c58
eflags: 0x00000046: id vip vif ac vm rf nt IOPL=0 of df if tf sf ZF af PF cf
<bochs:32> print-stack
Stack address size 2
 | STACK 0xfffa [0x0030] (<unknown>)
 | STACK 0xfffc [0x0035] (<unknown>)
 | STACK 0xfffe [0x0030] (<unknown>)
 | STACK 0x10000 [0x0000] (<unknown>)
 | STACK 0x10002 [0x0000] (<unknown>)
 | STACK 0x10004 [0x0000] (<unknown>)
 | STACK 0x10006 [0x0000] (<unknown>)
 | STACK 0x10008 [0x0000] (<unknown>)
 | STACK 0x1000a [0x0000] (<unknown>)
 | STACK 0x1000c [0x0000] (<unknown>)
 | STACK 0x1000e [0x0000] (<unknown>)
 | STACK 0x10010 [0x0000] (<unknown>)
 | STACK 0x10012 [0x0000] (<unknown>)
 | STACK 0x10014 [0x0000] (<unknown>)
 | STACK 0x10016 [0x0000] (<unknown>)
 | STACK 0x10018 [0x0000] (<unknown>)


<bochs:33> n
Next at t=17176106
(0) [0x000000007c5b] 0000:7c5b (unk. ctxt): inc di                    ; 47
<bochs:34> n
Next at t=17176107
(0) [0x000000007c5c] 0000:7c5c (unk. ctxt): mov byte ptr es:[di], 0x07 ; 26c60507
<bochs:35> n
Next at t=17176108
(0) [0x000000007c60] 0000:7c60 (unk. ctxt): inc di                    ; 47
<bochs:36> n
Next at t=17176109
(0) [0x000000007c61] 0000:7c61 (unk. ctxt): loop .-12  (0x00007c57)   ; e2f4
<bochs:37> n
(0) Breakpoint 3, 0x0000000000007c57 in ?? ()
Next at t=17176110
(0) [0x000000007c57] 0000:7c57 (unk. ctxt): pop dx                    ; 5a
<bochs:38> n
Next at t=17176111
(0) [0x000000007c58] 0000:7c58 (unk. ctxt): mov byte ptr es:[di], dl  ; 268815
<bochs:39> r
rax: 00000000_00000000
rbx: 00000000_0000000a
rcx: 00000000_00090003
rdx: 00000000_00000030
rsp: 00000000_0000fffc
rbp: 00000000_00000000
rsi: 00000000_000e0010
rdi: 00000000_0000001e
r8 : 00000000_00000000
r9 : 00000000_00000000
r10: 00000000_00000000
r11: 00000000_00000000
r12: 00000000_00000000
r13: 00000000_00000000
r14: 00000000_00000000
r15: 00000000_00000000
rip: 00000000_00007c58
eflags: 0x00000006: id vip vif ac vm rf nt IOPL=0 of df if tf sf zf af PF cf
<bochs:40> print-stack
Stack address size 2
 | STACK 0xfffc [0x0035] (<unknown>)
 | STACK 0xfffe [0x0030] (<unknown>)
 | STACK 0x10000 [0x0000] (<unknown>)
 | STACK 0x10002 [0x0000] (<unknown>)
 | STACK 0x10004 [0x0000] (<unknown>)
 | STACK 0x10006 [0x0000] (<unknown>)
 | STACK 0x10008 [0x0000] (<unknown>)
 | STACK 0x1000a [0x0000] (<unknown>)
 | STACK 0x1000c [0x0000] (<unknown>)
 | STACK 0x1000e [0x0000] (<unknown>)
 | STACK 0x10010 [0x0000] (<unknown>)
 | STACK 0x10012 [0x0000] (<unknown>)
 | STACK 0x10014 [0x0000] (<unknown>)
 | STACK 0x10016 [0x0000] (<unknown>)
 | STACK 0x10018 [0x0000] (<unknown>)
 | STACK 0x1001a [0x0000] (<unknown>)

 #结束调试
 <bochs:41> c
(0) Breakpoint 3, 0x0000000000007c57 in ?? ()
Next at t=17176116
(0) [0x000000007c57] 0000:7c57 (unk. ctxt): pop dx                    ; 5a
<bochs:42> c
(0) Breakpoint 3, 0x0000000000007c57 in ?? ()
Next at t=17176122
(0) [0x000000007c57] 0000:7c57 (unk. ctxt): pop dx                    ; 5a
<bochs:43> c

push ax

;等价
sub sp,2
mov bx,sp
mov [ss:bx],ax

pop ax

;等价
mov bx,sp
mov ax,[ss:bx]
add sp,2

;使用变址寻址
mov [si],dx ;目的操作数是一个地址，来自于索引寄存器SI
add ax,[di] ;源操作数来自于寻址寄存器DI，
xor word [si],0x8000 ;目的操作数是一个地址，来自于索引寄存器SI

;如果在指令中使用了SI和DI来提供偏移地址，而且没有使用段超越前缀，则默认使用段寄存器DS来提供段地址。

;使用变址寻址
mov [si+0x100],al ;目的操作数是一个内存地址，偏移地址是由变址寄存器SI加上偏移量0x100的结果。
and byte [di+mydata],0x80 ;标号代表汇编地址，本质上是一个数字。

        ;就地反转字符串的内容
        jmp start

string  db 'abcdefghijklmnopqrstuvwxyz'

start:
        mov ax,0x7c0        ;设置数据段的段基地址
        mov ds,ax

        mov ax,cs           ;设置栈段的段基地址
        mov ss,ax           ;这样，栈段SS的内容就和代码段CS内容一致了
        mov sp,0            ;初始化栈顶指针

        mov cx,start-string  ;循环次数，从26到1，共26次
        mov bx,string       ;数据区首地址(基地址)
lppush:
        mov al,[bx]
        push ax
        inc bx
        loop lppush         ;循环压栈

        mov cx,start-string
        mov bx,string
lppop:
        pop ax
        mov [bx],al
        inc bx
        loop lppop          ;循环出栈

        jmp $

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

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

#设置断点到物理地址7c00，因为ROM BIOS执行后最后的工作是把主引导扇区数据读入到内存的物理地址7c00处
Next at t=0
(0) [0x0000fffffff0] f000:fff0 (unk. ctxt): jmpf 0xf000:e05b          ; ea5be000f0
<bochs:1> b 0x7c00
<bochs:2> c #处理器连续地执行，遇到断点停下
......
(0) [0x000000007c00] 0000:7c00 (unk. ctxt): jmp .+26  (0x00007c1c)    ; eb1a
...

        ;就地反转字符串的内容--采用基址变址寻址方式
        jmp start

string  db 'abcdefghijklmnopqrstuvwxyz'

start:
        mov ax,0x7c0        ;设置数据段的段基地址
        mov ds,ax

        mov bx,string       ;数据区首地址
        mov si,0            ;正向索引
        mov di,start-string ;反向索引

rever:
        mov ah,[bx+si]
        mov al,[bx+di]
        mov [bx+si],al
        mov [bx+di],ah
        inc si              ;以上4行用于交换首尾数据
        dec di
        cmp si,di
        jl rever            ;首尾没有相遇，或者没有超越，继续交换

        jmp $

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

SECTION data1
mydata  dw 0xFACE

SECTION data2
string  db 'hello'

section code
        mov bx,string
        mov si,string

D:\project\assemblyprojs>nasm  exam.asm -f bin -o exam.bin -l exam.lst

$ hexdump.exe -C exam.bin
00000000  ce fa 00 00 68 65 6c 6c  6f 00 00 00 bb 04 00 be  |....hello.......|
00000010  04 00                                             |..|
00000012

#在我的机器上，段的长度必须是4的倍数
#ce fa 00 00 #data1段内容
#68 65 6c 6c  6f 00 00 00#data2段内容, hello是5字节不能被4整除，需要被3个字节用0填充
#bb 04 00 be 04 00 #bb 04 00 是mov bx,string 指令；be 04 00 是mov si,string指令

SECTION data1    ALIGN=16
mydata  dw 0xFACE

SECTION data2    ALIGN=16
string  db 'hello'

section code     ALIGN=16
        mov bx,string
        mov si,string

D:\project\assemblyprojs>nasm  exam.asm -f bin -o exam.bin -l exam.lst

$ hexdump.exe -C exam.bin
00000000  ce fa 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  68 65 6c 6c 6f 00 00 00  00 00 00 00 00 00 00 00  |hello...........|
00000020  bb 10 00 be 10 00                                 |......|
00000026

#为了16字节对齐，中间必须用0来填充

SECTION data1    ALIGN=16   VSTART=0
mydata  dw 0xFACE

SECTION data2    ALIGN=16   VSTART=0
string  db 'hello'

section code     ALIGN=16   VSTART=0
        mov bx,string
        mov si,string

D:\project\assemblyprojs>nasm exam.asm -f bin -o exam.bin -l exam.lst

$ hexdump.exe -C exam.bin
00000000  ce fa 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  68 65 6c 6c 6f 00 00 00  00 00 00 00 00 00 00 00  |hello...........|
00000020  bb 00 00 be 00 00                                 |......|

section s1
offset  dw str1,str2,num

section s2    align=16   vstart=0x100
str1    db 'hello'
str2    db 'world'

section s3    align=16
num     dw  0xbad

            ;包含代码段、数据段和栈段的用户程序
;===============================================================================
SECTION header vstart=0                                         ;用户程序头部段
    program_length  dd  program_end                             ;程序总长度[0x00]

    ;用户程序入口点
    code_entry      dw  start                                   ;偏移地址[0x04]
                    dd  section.code.start                      ;段地址[0x06] 

    realloc_tbl_len dw  (segtbl_end-segtbl_begin)/4             ;段重定位表项个数[0x0A]

    ;段重定位表
    segtbl_begin:
    code_segment    dd  section.code.start                      ;[0x0C]
    data_segment    dd  section.data.start                      ;[0x10]
    stack_segment   dd  section.stack.start                     ;[0x14]
    segtbl_end:

;===============================================================================
SECTION code align=16 vstart=0                                  ;代码段 
    start:
        ;初始执行时，DS和ES指向用户程序头部段
        mov ax,[stack_segment]                                  ;设置到用户程序自己的堆栈 
        mov ss,ax
        mov sp,stack_pointer                                    ;设置初始的栈顶指针

        mov ax,[data_segment]                                   ;设置到用户程序自己的数据段
        mov ds,ax

        mov ax,0xb800
        mov es,ax

        mov si,message
        mov di,0

    next:
        mov al,[si]
        cmp al,0
        je exit
        mov byte [es:di],al
        mov byte [es:di+1],0x07
        inc si
        add di,2
        jmp next

    exit:
        jmp $ 

;===============================================================================
SECTION data align=16 vstart=0                                  ;数据段
    message         db  'hello world.',0

;===============================================================================
SECTION stack align=16 vstart=0                                 ;栈段
                    resb 256
    stack_pointer:

;===============================================================================
SECTION trail align=16                                          ;尾部
program_end:

D:\project\assemblyprojs>nasm userapp.asm -f bin -o userapp.bin -l userapp.lst
userapp.asm:55: warning: uninitialized space declared in stack section: zeroing [-w+zeroing]

忽略警告

         ;代码清单8-1
         ;文件名：c08_mbr.asm
         ;文件说明：硬盘主引导扇区代码（加载程序） 

         app_lba_start equ 100           ;声明常数（用户程序起始逻辑扇区号）
                                         ;常数的声明不会占用汇编地址

SECTION mbr align=16 vstart=0x7c00                                     

         ;设置堆栈段和栈指针 
         mov ax,0      
         mov ss,ax
         mov sp,ax

         mov ax,[cs:phy_base]            ;计算用于加载用户程序的逻辑段地址 
         mov dx,[cs:phy_base+0x02]
         mov bx,16        
         div bx            
         mov ds,ax                       ;令DS和ES指向该段以进行操作
         mov es,ax                        

         ;以下读取程序的起始部分 
         xor di,di
         mov si,app_lba_start            ;程序在硬盘上的起始逻辑扇区号 
         xor bx,bx                       ;加载到DS:0x0000处 
         call read_hard_disk_0

         ;以下判断整个程序有多大
         mov dx,[2]                      ;曾经把dx写成了ds，花了二十分钟排错 
         mov ax,[0]
         mov bx,512                      ;512字节每扇区
         div bx
         cmp dx,0
         jnz @1                          ;未除尽，因此结果比实际扇区数少1 
         dec ax                          ;已经读了一个扇区，扇区总数减1 
   @1:
         cmp ax,0                        ;考虑实际长度小于等于512个字节的情况 
         jz direct

         ;读取剩余的扇区
         push ds                         ;以下要用到并改变DS寄存器 

         mov cx,ax                       ;循环次数（剩余扇区数）
   @2:
         mov ax,ds
         add ax,0x20                     ;得到下一个以512字节为边界的段地址
         mov ds,ax  

         xor bx,bx                       ;每次读时，偏移地址始终为0x0000 
         inc si                          ;下一个逻辑扇区 
         call read_hard_disk_0
         loop @2                         ;循环读，直到读完整个功能程序 

         pop ds                          ;恢复数据段基址到用户程序头部段 

         ;计算入口点代码段基址 
   direct:
         mov dx,[0x08]
         mov ax,[0x06]
         call calc_segment_base
         mov [0x06],ax                   ;回填修正后的入口点代码段基址 

         ;开始处理段重定位表
         mov cx,[0x0a]                   ;需要重定位的项目数量
         mov bx,0x0c                     ;重定位表首地址

 realloc:
         mov dx,[bx+0x02]                ;32位地址的高16位 
         mov ax,[bx]
         call calc_segment_base
         mov [bx],ax                     ;回填段的基址
         add bx,4                        ;下一个重定位项（每项占4个字节） 
         loop realloc 

         jmp far [0x04]                  ;转移到用户程序  

;-------------------------------------------------------------------------------
read_hard_disk_0:                        ;从硬盘读取一个逻辑扇区
                                         ;输入：DI:SI=起始逻辑扇区号
                                         ;      DS:BX=目标缓冲区地址
         push ax
         push bx
         push cx
         push dx

         mov dx,0x1f2
         mov al,1
         out dx,al                       ;读取的扇区数

         inc dx                          ;0x1f3
         mov ax,si
         out dx,al                       ;LBA地址7~0

         inc dx                          ;0x1f4
         mov al,ah
         out dx,al                       ;LBA地址15~8

         inc dx                          ;0x1f5
         mov ax,di
         out dx,al                       ;LBA地址23~16

         inc dx                          ;0x1f6
         mov al,0xe0                     ;LBA28模式，主盘
         or al,ah                        ;LBA地址27~24
         out dx,al

         inc dx                          ;0x1f7
         mov al,0x20                     ;读命令
         out dx,al

  .waits:
         in al,dx
         and al,0x88
         cmp al,0x08
         jnz .waits                      ;不忙，且硬盘已准备好数据传输 

         mov cx,256                      ;总共要读取的字数
         mov dx,0x1f0
  .readw:
         in ax,dx
         mov [bx],ax
         add bx,2
         loop .readw

         pop dx
         pop cx
         pop bx
         pop ax

         ret

;-------------------------------------------------------------------------------
calc_segment_base:                       ;计算16位段地址
                                         ;输入：DX:AX=32位物理地址
                                         ;返回：AX=16位段基地址 
         push dx                          

         add ax,[cs:phy_base]
         adc dx,[cs:phy_base+0x02]
         shr ax,4
         ror dx,4
         and dx,0xf000
         or ax,dx

         pop dx

         ret

;-------------------------------------------------------------------------------
         phy_base dd 0x10000             ;用户程序被加载的物理起始地址

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