ASM

// 下面的mov 指令可以将内存单元中的内容送入一个寄存器中
// mov 寄存器,[offset]  // ds寄存器内容为段地址，offset为偏移地址，两者合起来标识出内存单元地址

mov bx,1000H   // 将1000放入bx寄存器
mov ds,bx      // 将bx寄存器内容放入ds寄存器
mov al,[0]     // 将内存单元数据送入寄存器al

mov bx,1000H
mov ds,bx
mov ax,[0]  // 将1000:0处的字送入ax
mov [0],cx  // 将cx中16位数据送到1000:0

push ax // 表示将寄存器ax中的数据送入栈中
pop  ax // 表示从栈顶取出数据送入ax

// 利用push pop 可以在内存单元之间传送数据
push 内存单元   // 将一个内存字单元处的字入栈
pop  内存单元   // 用一个内存字单元接收出栈数据

mov ax,[bx]  // 将内存单元的内容送入ax，内存单元的长度为2，内存单元的段地址在ds中，偏移地址在bx中
mov [bx],ax  // 将寄存器ax内容送入内存单元，内存单元的段地址在ds中，偏移地址在bx中
inc bx       // 将bx中内容加1

assume cs:code
code segment
  mov ax,2
  mov cx,11
  s: add ax,ax
  loop s
  mov ax,4c00h
  int 21h
code ends
end

// 方法1: 
(dx) = (dx)+内存中8位数据  // 两个运算对象的类型不匹配

// 方法2: 
(dl) = (dl)+内存中8位数据  // 结果可能越界

// 正确的方法：
(ax) = 内存中8位数据 
(dx)=(dx)+(ax)

assume cs:code
code segment
    mov ax,0ffffH
    mov ds,ax
    mov bx,0                  ;; 初始化ds:bx指向ffff:0
    mov dx,0                  ;; 初始化累加寄存器dx (dx)=0
    mov cx,12                 ;; 初始化循环计数寄存器 cx (cx)=12
s:  mov al,[bx]               ;; 将ds:bx内存中数据送入al
    mov ah,0                  ;; 将ax高位置0
    add dx,ax                 ;; (dx)=(dx)+(ax)
    inc bx                    ;; 将内存偏移地址加1
    loop s                    ;; 循环s
    mov ax,4c00h
    int 21h
code ends
end

// 将内存单元送入ax寄存器
mov ax,ds:[bx]
mov ax,cs:[bx]
mov ax,ss:[bx]
mov ax,es:[bx]
mov ax,ss:[0]
mov ax,cs:[0]

// 将内存ffff:0~ffff:b单元中的数据复制到0:200~0:20b单元
// Tips: 0:200~0:20b 单元等同于 0020:0~0020:b单元（前面表示地址的数都是16进制数）
// 0:200  --> (0*16 + 2*16*16 + 0 + 0) = 512
//   20b  --> (0*16 + 2*16*16 + 0 + b) = 512+11 = 523
// 0020:0 --> (2*16*16 + 0) = 512
// 0020:b --> (2*16*16 + b) = 512+11 = 523

assume cs:code
code segment
    mov ax,0ffffH
    mov ds,ax

    mov ax,0020H
    mov es,ax

    mov bx,0
    mov cx,12            // 循环12次
s:  mov dl,[bx]          // 将ffff:bx中数据送入dl
    mov es:[bx],dl       // 将dl中的数据送入 0020:bx
    inc bx
    loop s

    mov ax,4c00h
    int 21h
code ends
end

assume cs:code, ds:data
data segment
    db 'unIX'
    db 'foRK'
data ends
code segment
start:
    mov al,'a'
    mov bl,'b'
    mov ax,4c00H
    int 21H
code ends
end start

// 下面指令等价，都是将ds:bx+200 的内容送入 ax寄存器
mov ax,[200+bx]   
mov ax,200[bx]
mov ax,[bx].200  

assume cs:codesg,ds:datasg
datasg segment
    db 'BaSiC'
    db 'MinIX'
datasg ends
codesg segment
start:
    mov ax,datasg
    mov ds,ax
    mov bx,0
    mov cx,5
s:
    mov al,[bx]        // 定位第一个字符串中的字符
    and al,11011111b   // 
    mov [bx],al
    mov al,[5+bx]      // 定位第二个字符串中的字符
    or  al,00100000b   //
    mov [5+bx],al
    inc bx
    loop s
codesg ends
end start

// 将'welcom to masm!'复制到其后的数据区中

assume cs:codesg, ds:datasg
datasg segment
    db 'welcome to masm!'
    db '................'
datasg ends
codesg segment
    mov ax,datasg
    mov ds,ax
    mov si,0
    mov cx,8
s:
    mov ax,0[si]    // 将第一行字符串中两个字符放入ax
    mov 16[si],ax   // 将ax内容放入第二行字符串中
    add si,2
    loop s
    mov ax,4c00H
    int 21H
codesg ends
end start

mov ax,[bx]
mov ax,[bx+si]
mov ax,[bp]
mov ax,[bp+si]

// 下面的指令是错误的
mov ax,[cx]
mov ax,[ax]
mov ax,[dx]
mov ax,[ds]

// 下面的指令也是错误的
mov ax,[bx+bp]
mov ax,[si+di]

div reg
div 内存单元

// (al)=(ax)/((ds)*16+0)的商
// (ah)=(ax)/((ds)*16+0)的余数
div byte ptr ds:[0]

// (ax)=[(dx)*10000H+(ax)]/((es)*16+0)的商
// (dx)=[(dx)*10000H+(ax)]/((es)*16+0)的余数
div word ptr es:[0]

// 计算100001/100   
// 100001大于65535=2^16 - 1 因此，需要进行16位除法
mov dx,1
mov ax,86A1H       // (dx)*10000H+(ax) = 100001
mov bx,100
div bx

assume cs:code

stack segment
    db 8 dup (0)
    db 8 dup (0)
stack ends

code segment
start:
    mov ax,stack
    mov ss,ax
    mov sp,16
    mov ax,1000
    call s
    mov ax,4c00h
    int 21H
s:
    add ax,ax
    ret
code ends
end start

// 计算100*10000  10000大于255，所以必须做16位乘法
mov ax,100
mov bx,10000
mul bx

assume cs:code
data segment
    dw 1,2,3,4,5,6,7,8
    dd 0,0,0,0,0,0,0,0
data ends
code segment
start:
    mov ax,data
    mov ds,ax
    mov si,0       // ds:si指向第一组word单元
    mov di,16      // ds:di 指向第二组 dword单元

    mov cx,8
s:
    mov bx,[si]    // cube 子程序只有一个参数，将其存在bx中
    call cube
    mov [di],ax    // cube 子程序只有一个返回值，低位存储在ax中
    mov [di].2,dx  // 高位存储在dx 中，
    add si,2
    add di,4
    loop s
    
    mov ax,4c00H
    int 21H

cube:
    mov ax,bx
    mul bx
    mul bx
    ret
code ends
end start

// 将一个全是字母的字符串转化为大写
assume cs:code
data segment
    db 'conversation'
data ends
code segment
start:
    mov ax,data
    mov ds,ax    
    mov si,0     ;// ds:si指向字符串（批量数据）所在空间的首地址

    mov cx,12    ;// cx存放字符串长度
    call capital
    mov ax,4c00H
    int 21H
capital:
    add byte ptr [si],11011111B
    inc si
    loop capital
    ret
code ends
end start

mov al,98H
add al,al    ;// 执行后(al)=30H, CF=1 CF记录了从最高有效位向更高位的进位值
add al,al    ;// 执行后(al)=60H, CF=0 CF记录了从最高有效位向更高位的进位值

mov al,97H
sub al,98H   ;// 执行后(al)=ffH, CF=1 CF记录了向更高位的借位值
sub al,al    ;// 执行后(al)=0, CF=0 CF记录了向更高位的借位值

// 计算 1ef000H + 201000H，结果放在ax（存放高16位）和bx（存放低16位）
mov ax, 001eH
mov bx, f000H
add bx, 1000H
adc ax, 0020H

// 计算 1ef0001000H + 2010001ef0H，结果放在ax（最高16位），bx（次高16位），cx(低16位)
mov ax,001eH
mov bx,f000H
mov cx,1000H
add cx,1ef0H
adc bx,1000H
adc ax,0020H

// 计算003e1000H - 00202000H，结果放在ax，bx中
mov bx,1000H
mov ax,003eH
sub bx,2000H
sbb ax,0020H

// rep movsb 相当于如下代码
s:
    movsb
    loop s

// iret相当于下面代码
pop ip
pop cs
pop f

mov ax,1000H
mov bh,1
div bh

// 上面代码执行后，CPU会执行0号中断处理程序，默认的0号中断处理程序会显示提示信息 "Divide overflow"，然后返回到操作系统

// 下面实现我们自定义的0号中断处理程序，内存0000:0000~0000:03FF大小为1KB的空间用于系统存放中断处理程序入口地址的中断向量表。8086支持256个中断，但是，需要处理的中断远没有达到256个。所以中断向量表中，有许多单元式空的。
// 一般情况下，0000:0200~0000:02FF的256字节的空间对于的中断向量表项都是空的，我们将我们的0号中断程序放在此处
assume cs:code
code segment
start:
    ; do0安装程序，将do0的代码送入0:200处
    mov ax,cs
    mov ds,ax
    mov si,offset do0   ;; 设置ds:si指向源地址
    mov ax,0
    mov es,ax
    mov di,200h                           ;; 设置 es:di指向目的地址
    mov cx,offset do0end-offset do0       ;; 设置cx为传输长度
    cld                                   ;; 设置传输方向为正
    rep movsb

    ; 设置中断向量表
    mov ax,0
    mov es,ax
    mov word ptr es:[0*4],200H
    mov word ptr es:[0*4+2],0

    mov ax,4c00h
    int 21h
do0:
    jmp short do0start
    db "overflow!"
do0start:
    mov ax,cs
    mov ds,ax
    mov si,202H                        ;; 设置 ds:si 指向字符串 0:200处的指令为jmp short do0start (这条指令长度为2字节)，因此“overflow!”的偏移地址为202H
    mov ax,0b800H                      
    mov es,ax
    mov di,12*160+36*2                 ;; 设置es:di指向显存空间的中间位置

    mov cx,9                           ;; 设置 cx 为字符串长度
s:  mov al,[si]
    mov es:[di],al
    inc si
    add di,2
    loop s

    mov ax,4c00h
    int 21h
do0end: nop

code ends
end start

// 正确设置栈顶的方法
mov ax,1000h
mov ss,ax
mov sp,0

// 错误的方法
mov ax,1000h
mov ss,ax
mov ax,0   // 此处可能响应中断
mov sp,0

;; 调用10H号中断例程的2号子程序，其功能为设置光标所在的行号、列号、页号
mov ah,2             ;; 子程序号
mov bh,0             ;; 设置页号
mov dh,5             ;; 设置行号
mov dl,12            ;; 设置列好
int 10H              ;; 调用

mov ah,4cH    ;; 程序返回
mov al,0      ;; 返回值
int 21H       ;; 调用

in al, 60H             ;; 从60H号端口读入一个字节

;; 1. CPU 通过地址线将60H发出
;; 2. CPU通过控制线发出端口读命令，选中端口所在的芯片，并通知它，将要从中读取数据
;; 3. 端口所在芯片将60H端口中的数据通过数据线送入CPU

mov al,01001000B
shl al,1                 ;; 移位后(al)=10010000B  CF=0

mov al,01001000B
mov cl,3
shl al,cl                ;; 移位后(al)=01000000B  CF=0

;; 在屏幕中间显示当前的月份
assume cs:code
code segment
start: 
    mov al,8      ;; CMOS RAM 第8号内存单元存储当前月份
    out 70H,al    ;; 将要读取的CMOS RAM内存单元送入70H端口
    in al,71H     ;; 从71H端口，取得要读取的数据

    mov ah,al               ;;
    mov cl,4
    shr ah,cl               ;; ah中为月份的十位数码值
    and al,00001111B        ;; al中位月份的个位数码值

    add ah,30H              ;; 二进制值+30H=ASCII码
    add al,30H

    mov bx,0b800H
    mov es,bx
    mov byte ptr es:[160*12+40*2],ah          ;; 显示月份的十位数码
    mov byte ptr es:[160*12+40*2+2],al        ;; 显示月份的个位数码
    
    mov ax,4c00H
    int 21H
code ends
start end

;; 把a中数据累加到b中
assume cs:code
code segment
    a: db 1,2,3,4,5,6,7,8
    b: dw 0

start:
    mov si, offset a
    mov bx, offset b
    mov cx, 8            ;; 循环次数
s:
    mov al,cs:[si]
    mov ah,0
    add cs:[si],ax
    inc si
    loop s
    mov ax,4c00H
    int 21H
code ends

;; 把冒号去掉后，标号a和b不但表示内存单元地址，还表示了内存单元的长度
assume cs:code
code segment
    a db 1,2,3,4,5,6,7,8
    b dw 0
start:
    mov si,0
    mov cx,8
s:
    mov al,a[si]        ;; 相当于 mov al,cs:[si]
    mov ah,0
    add b,ax            ;; 相当于 add add cs:[si],ax
    inc si
    loop s
    mov ax,4c00H
    int 21H

assume cs:code, ds:data   ;; 在代码段中直接用数据标号访问数据，需要使用伪指令assume将标号所在的段和寄存器联系起来
data segment
    a db 1,2,3,4,5,6,7,8
    b dw 0
data ends
code segment
start:
    mov ax,data         ;;
    mov ds,ax           ;; ds中存放data段的段地址
    mov si,0
    mov cx,8
s:
    mov al,a[si]        ;; 编译器会将其翻译为 mov al,[si+0]
    mov ah,0
    add b,ax            ;; 编译器会将其翻译为 add add [8],ax
    inc si
    loop s
    mov ax,4c00H
    int 21H

;; 以16进制在屏幕中间显示二进制数据
showbyte:
    jmp short show
    table db '0123456789ABCDEF'

show:
    push bx
    push es
    mov ah,al
    shr ah,1
    shr ah,1
    shr ah,1
    shr ah,1
    and al,00001111B
    mov bl,ah
    mov bh,0
    mov ah,table[bx]                      ;; 用高4位的值作为相对于table的偏移，取得对应的字符

    mov bx,0b800H
    mov es,bx
    mov es:[160*12+40*2],ah

    mov bl,al
    mov bh,0
    mov al,table[bx]                      ;; 用低4位的值作为相对于table的偏移，取得对应的字符
    mov es:[160*12+40*2+2],al

    pop es
    pop bx

    ret