王爽汇编语言第三版第9章转移指令的原理

Dear 丶 2024-04-18 12:31 62阅读 0赞

# 第九章  转移指令的原理 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 1][]

汇编代码：

assume cs:codesg
    
    codesg segment
        s:  
            mov ax,bx  ; mov ax,bx 的机器码占两个字节
            mov si, offset s
            mov di, offset s0
            mov ax, cs:[si]
            mov cs:[di], ax
        s0:
            nop  ; nop 机器码占一个字节
            nop
            mov ax, 4c00h
            int 21h
    codesg ends
    end s

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 2][]

# 9.3 依据 位移 进行 转移的 jmp 指令 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 3][]

# 9.5 转移地址 在 寄存器 中的 jmp 指令 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 4][]

# 9.6 转移地址在内存中的 jmp 指令 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 5][]

## 检测点 9.1  ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 6][]

**分析：jmp word ptr \[bx+1\] 为段内转移，要CS:IP指向程序的第一条指令，应设置ds:\[bx+1\]的字单元(2个字节)存放数据应为0，则(ip)=ds:\[bx+1\]=0**。简单来说就是，**只要 ds:\[bx+1\] 起始地址的两个字节为 0 就可以了。**

答案 1：**db 3 dup (0)**。 答案 2：**dw 2 dup (0)**。 答案 3：**dd 0**。 答案 4：**dd 16 dup (0)**

验证代码：

assume cs:codesg, ds:datasg
    
    datasg segment
    	db 16 dup (0)
    datasg ends
    
    codesg segment
    start:	
    	mov ax, datasg
    	mov ds, ax
    	mov bx,0
    	jmp WORD ptr ds:[0]
    	mov ax,4c00h
    	int 21h
    codesg ends
    end start

验证结果截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 7][]

程序 2：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 8][]

第一空参考答案：

mov [bx], bx            ; 因为 bx 为 0，所以可以把 寄存器 bx 值赋值给 内存[bx]
    mov [bx], word ptr 0    ; 指定 0 是一个 字类型 0000h,  
    mov [bx], offset start  ; 取得 标号 start 相对 cs 段的偏移地址，即 0

第二空参考答案：

mov [bx+2], cs
    mov [bx+2], codesg

验证代码：

; jmp 段 间 转移。转移到 cs:ip 的第一条指令
    ; 高地址 : 转移的目的段地址
    ; 低地址 : 转移的目的偏移地址
    
    assume cs:codesg, ds:datasg
    
    datasg segment
    	dd 12345678H
    datasg ends
    
    codesg segment
    	start:
    		mov ax, datasg
    		mov ds, ax
    		mov bx, 0
    		mov [bx], WORD ptr 0
    		mov [bx+2], cs
    		jmp DWORD ptr ds:[0]
    		
    		mov ax, 4c00h
    		int 21h
    codesg ends
    end start

运行结果截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 14][]

## 实验 8 分析一个奇怪的程序： ##

[https://www.jianshu.com/p/7e5dfea72b65][https_www.jianshu.com_p_7e5dfea72b65]

assume cs:code
    code segment
        mov ax, 4C00H
        int 21H
    
    start:
        mov ax, 0000H
    s:
        nop
        nop
        mov di, offset s
        mov si, offset s2
        mov ax, cs:[si]
        mov cs:[di], ax
    s0: jmp short s
    s1: mov ax, 0000H
        int 21H
        mov ax, 0000H
    s2: jmp short s1
        nop
    code ends
    end start

## 分析 : ##

程序的执行流程是这样的 :

; 从 start 标号开始
    1. mov ax, 0000H
    2. nop
    3. nop
    4. mov di, offset s
    5. mov si, offset s2
    6. mov ax, cs:[si]
    7. mov cs:[di], ax
    8. jmp short s
    9. jmp short si ; 这句 jmp short s1 , 根据我们之前的分析 , 指令是用相对偏移来表示的
    ; 因此执行的操作并不是真的跳转到 s1 这个标号 , 而是跳转编译时确定的 该指令到 s1 标号的偏移
    ; 所以我们要分析接下来程序的流程的话 , 就必须先编译程序 , 然后要知道到底偏移是多少
    ; 然后再根据这个偏移确定程序下一步应该执行哪里的指令
    ; 根据下图的编译结果 , 可以发现 , jmp short s1 在编译后得到的指令是 : 
    ; 偏移是 : EB F6
    ; 这个数据是使用 补码 来表示的 , 也就是说 , 是一个负数 , 然后符号位不变 , 其他位取反 , 然后加 1
    ; 然后 , 我们现在就知道了 , 这条指令是将 ip 的值加上 -10
    ; 我们再看看 ip - 10 指向的地址是哪里 ? 
    ; 对 , 刚好就是 code segment 开始的位置
    10. mov ax, 4C00H
    11. int 21H
    ; 这样程序就实现了正常的返回

反编译结果 :

注意这里使用 debug 的 u 命令进行反汇编的时候要指定代码段的偏移地址为 0
    否则 debug 会自动从 start 标号的地方开始反汇编

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 15][]

可以看到 : 
    jmp short s1 ; 这句汇编指令被翻译成了 : EB F6 , 其中 EB 表示的是跳转 , F6 表示偏移
    F6 怎么理解呢 ? 
    1111 0110 (使用补码来表示)
    补码转换成原码 , 符号位不变 , 其他位取反 , 然后加 1
    1000 1001
    1000 1010 ; 也就是 -10
    也就是上面我们分析的让 (ip) = (ip) - 0x0A
    然后 , 这句指令被复制到 s 标号的开头处
    由于 nop 只占一个字节 , 因此两个 nop 被完全替代
    然后程序执行到 s0 , 又跳转到 s 开始的地方
    这个时候就要执行 : (这个时候 ip = 8)
    EB F6
    首先读取这条指令到指令缓存器里
    接下来 , (ip) = (ip) + len(EB F6) = (ip) + 8 = 10
    然后执行这条指令 , 即为 (ip) = (ip) - 10 = 0
    这样 ip 就回到了 code segment 的起始处
    这样继续执行 
    mov ax, 4C00H
    int 21H
    就实现了程序的正常返回

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 16][]

说明：这题要是把 s 当成 jmp short s1 那就错了，如果是那样的话 ，你就会想当然的跳到 s1，但其实不是的，前边复制的 是**内存里的内容** ，也就是说复制的是 jmp short s1 的机器码 假如机器码是这样的： EB -10（十进制负数先理解嘛~） 也就是向上走10字节， 那么 现在复制到 s 那 也是向上走10 个字节，所以是跳转到 mov ax, 4c00h。

这道题主要理解：**程序 只是 复制 内存里面的数据。**

# **汇编语言是按行一条一条指令进行执行的，****可以按高级语言进行缩进来写汇编程序 ( ****例如可以按照 Pyhton 的空格缩进**** )****，****最后再把缩进给去掉****，****这样可以更好的理解汇编的逻辑和层级关系****。** #

# 实验 9  #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 17][]

**每一个字符占用两个字节 ,** **低地址为 ASCII 码 ，****高地址为属性**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 18][]

示例代码 1：

assume cs:code,ds:data
    
    ; 显存地址 : B8000H - BFFFFH
    ; 显示尺寸 : 80 x 25 个字符
    ;   其中每一个字符占用两个字节 , 低地址为 ASCII 码 , 高地址为属性
    ;   也就是说 每一个字符 可以设置的属性有 256 种
    ;   属性 : 
    ;       是否闪烁 背景色R 背景色G 背景色B 是否高亮 前景色R 前景色G 前景色B
    ; 因此一个屏幕总共有 80 x 25 = 2000 个字符 , 需要 4000 个字节来存储 (约为4K)
    ; 然后系统的显存总共是 32K , 也就是说可以储存 8 个页面 , 默认显示第一个页面
    
    data segment
        db 'Hello world', 33 ; 33 是感叹号的 ASCII 码 
    data ends
    
    code segment
    
        start:
            mov ax, data
            mov ds, ax
            mov ax, 0B800H
            mov es, ax    ; 保存显存的段地址
            mov si, 0000H ; 数据段偏移地址
            mov di, 10*160+80 ; 显存偏移地址
            mov cx, 000CH     ; 设置循环次数 , "Hello world!" 长度为 12
        print_green:
            mov al, ds:[si]   ; 读取数据段中的数据
            mov ah, 00100000B ; 设置字体的属性 (黑底绿字)
            mov es:[di], ax   ; 写入显存
            inc si        ; 数据段偏移地址自增 1 
            add di, 0002H ; 显存偏移地址自增 2
            loop print_green
    
        finish:
            mov ax,4c00H
            int 21H
    
    code ends
    
    end start

运行截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 19][]

示例代码 2：

assume cs:codesg, ds:datasg
    
    datasg segment
        db 'welcome to masm!' ; 显示的字符
        db 2,24h,71h  ; 字符属性
    datasg ends
    
    codesg segment
    start:
        ; 设置 ds 段
        mov ax, datasg
        mov ds, ax
        
        ; 设置 es 段 为 显存地址段
        mov ax, 0b800h
        mov es, ax
     
        ; 设置循环次数 
        mov cx, 16
           
        mov si, 0         ; 字符的偏移量
        mov di, 10*160+80 ; 显存的偏移量
        s:
            mov al, ds:[si]
            mov ah, 2        ; 设置字符的属性 为 2
            mov es:[di], ax  ; 往显存里面写数据
            inc si     ; 字符向后偏移 1 位
            add di, 2  ; 显存向后偏移 2 位
            loop s
        
        mov ax, 4c00h
        int 21h
    codesg ends
    end start

运行截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 20][]

实验 9 代码 1：

[http://blog.sina.com.cn/s/blog\_171daf8e00102xcbv.html][http_blog.sina.com.cn_s_blog_171daf8e00102xcbv.html]

assume cs:codesg
     
    data segment
        db 'welcome to masm!'
        db 02H,24H,71H        ;字符显示的属性值
    data ends
     
    stack segment
        db 16 dup(0)
        ; 也可以是下面的定义法：
        ; dw 8 dup(0)
    stack ends
     
    codesg segment
    start:  
            ;初始化data数据段，es:di指向data
            mov ax, data
            mov es, ax
            mov di, 0
            
            ;初始化显示缓冲区，ds:bx指向显示缓冲区。
            mov ax, 0b800H
            mov ds, ax
            
            ;25行取中是12、13、14行,80列取中开始是61列
            ;12行的偏移量是12*160=1920  (1行总共80个带属性的字符，即 160个字节)
            ;总偏移量为（偏移地址）1920+60=1980?
            mov bx, 1980      
                    
            mov si, 16    ;字符的属性在数据段中的偏移量                
            mov ax, stack ;建栈，并初始化栈顶，熟悉栈结构。其实这里都不用人工建栈，有系统自动的。
            mov ss, ax
            mov sp, 16    ;指向栈顶         
            mov cx, 3     ;计数器初始化为3（循环显示3次）
            
            s:  
                push cx      ;入栈保护 CX，在stack中       
                mov cx, 16   ;内循环为16次，16个字符
                output:      ;将字符写入显存中
                    mov al, es:[di]
                    mov [bx], al
                    
                    ;将字符属性写入显存中
                    mov ah, es:[si]
                    mov [bx+1], ah      
                    
                    inc di
                    add bx, 2
                    loop output
     
                add bx, 128  ;每行输出的偏移量为128字节 
                mov di, 0
                inc si
                pop cx       ;出栈恢复cx计数器值
                loop s           
            mov ax,4c00H
            int 21H
    codesg ends
    end start

运行截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 21][]

总结：

*  1. 合理利用栈结构保存寄存器变量的值。
 *  2. 熟练掌握\[bx+idata\]这种CPU寻址的方式。
 *  3. 在显存中，甚至是内存中，它们都是线性存储的，以列的形式存储的。不存在行的概念的，只不过在计算机屏幕上，还有debug中有行的概念，为了显示方便。

示例代码：

[https://www.cnblogs.com/nojacky/p/9497704.html][https_www.cnblogs.com_nojacky_p_9497704.html]

assume cs:code
    data segment
        db 'welcome to masm!'
        db 02h,24h,71h  ; 要求的三个颜色对应的16进制代码
    data ends
     
    stack segment
        db 16 dup(0)
        ; 也可以是下面的定义法：
        ; dw 8 dup(0)
    stack ends
     
    code segment
     
    start:  
            ; 设置data段，以及ds:bx指向data段的第一个单元，
            ; 即ds:[bx]的内容就是data段第一个单元的内容  
            mov ax,data
            mov ds,ax
            
            ;设置显示缓存区段
            mov ax,0b800h ;设置起始缓存
            mov es,ax       
            
            ;设置栈段
            mov ax,stack
            mov ss,ax
            mov sp,10h  ;指向栈顶
            
            ;初始化三个寄存器
            mov bx,780h ; 行 从12-14行（注意：从第1行开始计数）
            mov si,10h ; 颜色的偏移量，三次循环每次
                        ; 增加 1h 指向下一个颜色
            
            mov cx,3    ; 三次循环改变行
     
            s:  
                mov ah, ds:[si] ;颜色事先存放在ah中
                push cx     
                push si
                    
                mov cx, 16  ; 16次循环改变列        
                mov si, 64  ; 这里的si的意义是多少列,
                ; 为什么从64列开始呢？
                ; (1)字符串为32字节，16字节ASCLL码，16字节属性
                ; (2)每一行有160列，那么余下有 160-32=128列为空白
                ;    要使得字符串居中显示，那么字符串的左边和右边
                ;   都应该是64字节(128/2)，而列数是从0开始计数，
                ; 所以左边的64字节为0-63，所以这里偏移量为64
                mov di,0  
                        
                s0: 
                    mov al,ds:[di] ;将date段中的字符一个一个传入es中
                    mov es:[bx+si],al ; 低位存放字符
                    mov es:[bx+si+1],ah ; 高位存放颜色        
                    add si,2  ;显示缓存区字符ASCII码偏移量为2
                    add di,1  ;data段字符的偏移量，每次加 1         
                    loop s0
            
                pop si  
                pop cx  ;后进先出，先出栈si,再出栈cx
            
                add si,1h  ;指向下一个颜色
                add bx,0a0h ;指向下一行 160=0a0h
                loop s
            
            mov ax,4c00h
            int 21h
    code ends
     
    end start

示例代码：

[https://www.cnblogs.com/zhenzhenhuang/p/6898813.html][https_www.cnblogs.com_zhenzhenhuang_p_6898813.html]

assume cs:code
    
    data segment
        db 'welcome to masm!'
        db 2,24h,71h
    data ends
    
    stack segment
        db 16 dup(0)
    stack ends
    
    code segment
    start:
        mov ax,stack
        mov ss, ax
        mov sp, 16
    
        mov ax,data
        mov ds,ax
    
        mov cx,3
        mov ax,0B800H
        mov es,ax
        mov si,10h
        mov ax,0
        s:
            mov ah,ds:[si]
            push cx
            push si
            mov cx,16
            mov si,0
            add si,160*10+80
            mov bx,0
            mov di,1
            add di,160*10+80
            s1:
                mov al,[bx]
                mov es:[bx+si],al
                mov es:[bx+di],ah
                inc bx
                inc si
                inc di
                loop s1
     
            pop si
            inc si
            pop cx
            mov dx,es
            add dx,0ah
            mov es,dx
            loop s
     
    finish:
        mov ax,4c00h
        int 21h
    code ends
    end start

实验9 代码 2：

[http://www.cppblog.com/Tim/archive/2012/06/04/177420.html][http_www.cppblog.com_Tim_archive_2012_06_04_177420.html]

datasg segment 
        ;对80*25的屏幕，每行的字节数为80*2=160.
        ;要求显示在屏幕中间，先计算行和列的偏移
        ;行偏移：(25-3)/2=11.所以显示在第11,12,13行。偏移值分别为1760,1920,2080。计算方法为 行数*160(每行的字节数) 。
        ;列偏移：由于要显示的字符数为16个，所以开始显示的列偏移为(80-16)/2*2=64。
        dw 1760,1920,2080,64
        ;要显示的字符 16个
        db 'welcome to masm!'
        ;字符属性：第11行显示绿色字，第12行显示绿底红色，第13行显示白底蓝色
        ;在全屏模式下能看到字符的闪烁效果
        db 82h,0ach,0f9h
    datasg ends
     
     
    codesg segment 
        assume cs:codesg, ds:datasg
    start:
        mov ax, datasg ; 设置ds段为datasg数据段
        mov ds, ax
        
        mov ax,0b800h ; 设置es段为显存段
        mov es,ax   
        
        mov cx,3 ; 设置外循环3次
        mov di,0
        
        s1: ; 外循环开始, 循环 行  
            mov ax, di
            mov bl, 2
            div bl  ; 16被除数，ax 的高位是余数，低位是商。
    
            mov si, ax
            mov ah, [24+si] ;取颜色属性
        
            mov si, ds:[6] ;列 ，对应 64
            mov bp, [di]   ;行 ，分别 对应 1760,1920,2080
        
            mov dx, cx
            mov bx, 0  ; 遍历每一行的字符
            mov cx, 16   
     
            s2:
                mov al, [bx+8]       ;取字符
                mov es:[bp+si], al   ;写字符
                mov es:[bp+si].1, ah ;设置颜色属性
                inc bx
                add si, 2
                loop s2
        
            mov cx,dx
            add di,2
            loop s1
        
        mov ax, 4c00H
        int 21H
    codesg ends
        end start

运行结果截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 22][]

示例代码：

[https://www.lscx.org/2718.html][https_www.lscx.org_2718.html]

assume cs:codesg,ds:datasg,ss:stacksg
    
    datasg segment
    	db 'welcome to masm!'
    	db 82h,0a4h,0f1h
    datasg ends
    
    stacksg segment
    	db 8 dup (0)
    stacksg ends
    
    codesg segment
    start:
        mov ax,datasg
        mov ds,ax
         
        mov ax,0B86Eh
        mov es,ax
         
        mov cx,3
        mov si,0
         
    s1: push cx
        mov bx,0
        mov bp,0
        mov cx,16
     
    s:  mov al,ds:[bp]
        mov es:[bx].40h,al
        mov al,ds:16[si]
        mov es:[bx].40h[1],al
        inc bp
        add bx,2
        loop s
         
        pop cx
        mov ax,es
        add ax,10
        mov es,ax
        inc si
        loop s1
         
        mov ax,4c00h
        int 21h     
    codesg ends 
    end start

实验9 代码 3：

assume cs:codesg, ds:datasg, ss:stacksg
    
    datasg segment
        db "welcome to masm!"
        db 2,24h,71h
    datasg ends
     
    stacksg segment
        db 16 dup(0)
    stacksg ends
    
    codesg segment
    start:
        mov ax,datasg
        mov ds,ax
        mov si,10h
        mov di,1824
        mov ax,0b800h
        mov es,ax    
        mov cx,3
    s1:
        mov bx,0
        push cx
        mov cx,16
    s:
        mov al,[bx]
        mov ah,[si]
        mov WORD ptr es:[di],ax
        add bx,1
        add di,2    
        loop s
        
        inc si
        add di,128
        pop cx
        loop s1    
        
    all:
        jmp short all
        mov ax,4c00h
        int 21h
    codesg ends
    end start

实验9 代码4：

[https://blog.csdn.net/Ryannn\_/article/details/84190330][https_blog.csdn.net_Ryannn_article_details_84190330]

assume cs:code,ds:data
    
    data segment ;在数据段定义字符串
    	db 'Welcome to masm!'
    data ends
    
    code segment
    start:  
    	mov ax,data
    	mov ds,ax
    	mov ax,0b800h
    	mov es,ax    ; 使用ds和es寄存器作为段寄存器
    	   
    	mov si,0
    	mov bx,0
    	mov bp,07b0h ; 由计算出的字符串所在位置给bp赋值
    	mov cx,16    ; 16个字符数据故loop16次
    	   
    s:  mov al, [bx]                  ; 以下采用相对基址变址寻址方式
    	mov es:[bp+si], al            ; 经计算得第1行偏移地址应为b87b0h至b87cfh
    	mov es:[bp+si+0a0h], al       ; 第2行偏移地址应为b8850h至b886fh
    	mov es:[bp+si+140h], al       ; 第3行偏移地址应为b88f0h至b890fh
    		
    	mov al, 00000010b             ; 分别给三行设置属性字节
    	mov es:[bp+si+1], al
    	mov al, 00100100b
    	mov es:[bp+si+0a0h+1], al
    	mov al, 01110001b
    	mov es:[bp+si+140h+1], al
    		   
    	inc bx
    	add si,2      ; 每个字符占2个字节
        loop s     	   
    	mov ah,4ch
    	int 21h
    code ends
    end start

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/01dc88ecdc7049bbbf361fd35b4b98aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a84270a10b164a169767907bc5183ef8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/26f0e726cc874ac5aa8f0214eedf4e4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e0ec10be7dea490c928d61aa318f8037.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/83218304421b4b728b7eb473d9d13ce4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4ff99d8e09c5457eb6336e19fffe9798.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b7e0ee4228c5418e9bd19a39b7944f09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ebc1a01765b84feab5c93f1f669b259c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/69c5d5827b974e2aa337353c84e6632e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/17b5b251aa1a4178a81a49271ce4d5bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5f752c2e65a54e6fa77a73c4f044ebb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9ce7f3ad97524c0cac0d140cabf85b08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/47b5b83d993b47af8e7f4c2a9d8e4393.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d6dea24d3a1849749db6d96e69efda36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/cb7a5fe32d3f4d0ea6175243869c94ec.png
[https_www.jianshu.com_p_7e5dfea72b65]: https://www.jianshu.com/p/7e5dfea72b65
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20190907164342959.JPG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2f2ea5c46a3a4939aeb05199c274b1b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5445986b4dbc43b88ba71480404f8ebd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/1ccf3dee0e89402386cd7766ff3a00d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8723f1140ce04fd58055c6c9ad5df3ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f7aa41d0c7f54f8c9fdb42bab315ec64.png
[http_blog.sina.com.cn_s_blog_171daf8e00102xcbv.html]: http://blog.sina.com.cn/s/blog_171daf8e00102xcbv.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/87314959bbdf4a39b9a8f3ad67279d2f.png
[https_www.cnblogs.com_nojacky_p_9497704.html]: https://www.cnblogs.com/nojacky/p/9497704.html
[https_www.cnblogs.com_zhenzhenhuang_p_6898813.html]: https://www.cnblogs.com/zhenzhenhuang/p/6898813.html
[http_www.cppblog.com_Tim_archive_2012_06_04_177420.html]: http://www.cppblog.com/Tim/archive/2012/06/04/177420.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/bc8f94b98b94410ba22530821ffbaf9b.png
[https_www.lscx.org_2718.html]: https://www.lscx.org/2718.html
[https_blog.csdn.net_Ryannn_article_details_84190330]: https://blog.csdn.net/Ryannn_/article/details/84190330