更灵活定位内存地址

更灵活定位内存地址

1.SI和DI

SI和DI是8086CPU中和bx功能相近的寄存器，但是SI和DI不能够分为两个8位寄存器使用。

下面三组指令实现了相同的功能

(1)

1
2
mov bx,0
mov ax,[bx]

(2)

1
2
mov si,0
mov ax,[si]

(3)

1
2
mov di,0
mov ax,[di]

问题：用寄存器SI和DI实现将字符串’welcome to masm!’复制到它后面的数据区中。

分析：我们在处理数据之前首先要搞清楚数据存储在什么地方，也就是说数据的内存地址。

因为’welcome to masm!’从偏移地址0开始存放，长度为16个字节，所以，它后面的数据区的偏移地址为16，就是字符串所要存放的空间。

我们用ds:si指向要复制的源始字符串，用ds:di指向复制的目的空间,然后用一个循环来完成复制。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
assume cs:codesg,ds:datasg

  datasg segment
    db 'welcome to masm!'
  datasg ends

  codesg segment
    start: mov ax,datasg
           mov ds,ax
           mov si,0
           mov di,16
           mov cx,8
        s: mov ax,[si]
           mov [di],ax
           add si,2
           add di,2
           loop s
                                                                           
           mov ax,4c00h
           int 21h
  codesg ends
  
end start

1.1 [bx+si] 和 [bx+di]

[bx+si]和[bx+di]的含义类似，我们以[bx+si]为例。

[bx+si]表示一个内存单元，它的偏移地址为(bx)+(si)，即bx中的数值加上si中的数值

指令mov ax,[bx+si]的数学化的描述为：(ax) = ((ds)*16 + (bx) + (si))

问题：用Debug查看内存，结果如下：

2000:1000 BE 00 06 00 00 00 …

写出下面程序执行后,cx、ax中的内容

1
2
3
4
5
6
7
8
9
10
mov ax,2000h
mov ds,ax
mov bx,1000h
mov si,0
mov ax,[bx+si]	;ax的值为00BE
inc si
mov cx,[bx+si]	;cx的值为0600
inc si
mov di,si	;di的值为3
mov ax,[bx+di]	;ax的值为0006

1.2 [bx+si+idata]和[bx+di+idata]

[bx+si+idata]和[bx+di+idata]的含义相似。我们以[bx+si+idata]为例。

[bx+si+idata]表示一个内存单元，它的偏移地址为(bx)+(si)+idata。

指令mov ax,[bx+si+idata]的数学化描述为(ax) = ((ds)*16 + (bx) +(si) + idata)

该指令可以写成如下格式

1
2
3
4
mov ax,[bx+200+si]
mov ax,200[bx][si]
mov ax,[bx].200[si]
mov ax,[bx][si].200

问题：用Debug查看内存，结果如下

2000:1000 BE 00 06 00 6A 22 …

写出下面的程序执行后,ax、bx、cx中的内容。

1
2
3
4
5
6
7
8
9
10
mov ax,2000h
mob ds,ax
mov bx,1000h
mov si,0
mov ax,[bx+2+si]	;ax=0006H
inc si	
mov cx,[bx+2+si]	;cx=6A00H
inc si
mov di,si	;di=0002H
mov bx,[bx+2+di]	;bx=226A

2.不同寻址方式的灵活应用

将寻址方式总结为以下几种方法:

  1. [idata]用一个常量来表示地址，可用于直接定位一个内存单元（直接寻址）
  2. [bx]用一个变量来表示内存单元，可用于间接定位一个内存单元（间接寻址）
  3. [bx+idata]用一个变量和常量表示地址，可在一个起始地址的基础上用变量间接定位一个内存单元（基址寻址）
  4. [si+idata]（变址寻址）
  5. [bx+si]用两个变量表示地址（基址加变址寻址）
  6. [bx+si+idata]用两个变量和一个常量表示地址

可以看到：

从[idata]一直到[bx+si+idata]，我们可以用更加灵活的方式来定位一个内存单元的地址。这使我们可以从更加结构化的角度来看待所要处理的数据。

2.1 单重循环处理

问题1：编程，将datasg段中每个单词的头一个字母改为大写字母。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
assume cs:codesg,ds:datasg

datasg segment
  db '1. file         '	
  db '2 .edit         '
  db '3 .search       '
  db '4 .view         '
  db '5 .options      '
  db '6 .help         '
datasg ends

codesg segment
  start: ...
codesg ends

分析：datasg中的数据的存储结构，如图：

image-20221018212503530

我们需要进行6次循环，用一个变量R定位行，用常量3定位列。处理过程如下：

bx先存放第一行的地址

mov cx,6 ;因为总共有6行

s: 改变第bx行，第三列的字母为大写。改变bx的值使它指向下一行的地址

loop s

我们用bx作变量，定位每行的起始地址，用3定位要修改的列，用[bx+idata]的方式来对目标单元进行寻址。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
assume cs:codesg,ds:datasg

datasg segment
  db '1 .file         '	
  db '2 .edit         '
  db '3 .search       '
  db '4 .view         '
  db '5 .options      '
  db '6 .help         '
datasg ends

codesg segment
  start: mov ax,datasg
  		 mov ds,ax
  		 mov bx,0
  			 
  		 mov cx,6
   	  s: mov al,[bx+3]	;注意,单位是字节,所以是al
  	     and al,11011111b
 	     mov [bx+3],al
  	     add bx,16
  	     loop s
  		   
  	mov ax,4c00h
  	int 21h
codesg ends
end start

debug效果：

image-20221018215751846

2.2 多重循环处理

问题2：将datasg段中每个单词改为大写字母。

1
2
3
4
5
6
7
8
9
10
11
12
13
assume cs:codesg,ds:datasg

datasg segment
  db 'ibm             '
  db 'dec             '
  db 'dos             '
  db 'vax             '
datasg ends

codesg segment
  start: ...
  codesg ends
end start

分析：因为它们是连续存放的，我们可以将这4个字符串看成一个4行16列的二维数组。按照要求，我们需要修改每一个单词，即二维数组的每一行的前三列。

我们需要进行4*3次的二重循环（循环嵌套），用变量R定位行，变量C定位列

  • 外层循环按行来进行
  • 内层循环按列来进行

我们首先用R定位第一行，然后循环修改R行的前三列；然后再用R定位到下一行，再次循环修改R行的前三列

如此重复直到所有数据修改完毕。

我们用bx来作变量，定位每行的起始地址，用si定位要修改的列，用[bx+si]的方式来对目标单元进行查找

关键问题：我们进行二重循环，但是loop指令默认cx为循环计数器，在内层循环时会覆盖外层循环的循环计数值。

我们应该在每次开始内层循环的时候，将外层循环的cx中的数值保存起来，在执行外层循环的loop指令前，在恢复外层循环的数值。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
assume cs:codesg,ds:datasg

datasg segment
  db 'ibm             '
  db 'dec             '
  db 'dos             '
  db 'vax             '
datasg ends

codesg segment
  start: mov ax,datasg
   		 mov ds,ax
     	 mov bx,0
   		 mov cx,4
   	 s0: mov si,0
   	     mov dx,cx
   	     mov cx,3
   	  s: mov al,[bx+si]
   	     and al,11011111b
   	     mov [bx+si],al
   	     inc si
   	     
   	     loop s
   	     
   	     add bx,16
   	     mov cx,dx
   	     loop s0
   	     
   	     mov ax,4c00h
   	     int 21h
  codesg ends
end start

上面的程序用dx来暂时存放cx中的值；如果在内层循环中，dx寄存器也被使用，该怎么办？

CPU中的寄存器数量毕竟是有限的，如8086CPU只有14个寄存器。

我们希望寻找一个通用的方案，来解决这种在编程中经常会出现的问题。

我们可以考虑将需要暂存的数据放到内存单元中，需要使用的时候，再从内存单元中恢复。这样我们就需要开辟一段内存空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
assume cs:codesg,ds:datasg

datasg segment
  db 'ibm             '
  db 'dec             '
  db 'dos             '
  db 'vax             '
  dw 0	;定义一个字,用来保存cx
datasg ends

codesg segment
  start: mov ax,datasg
   		 mov ds,ax
   		 mov bx,0
   		 mov cx,4
   	 s0: mov si,0
   	     mov ds:[40h],cx	;将外层循环的cx值保存在datasg:40h单元中
   	     mov cx,3
   	  s: mov al,[bx+si]
   	     and al,11011111b
   	     mov [bx+si],al
   	     inc si
   	     
   	     loop s
   	     
   	     add bx,16
   	     mov cx,ds:[40h]	;用datasg:40h单元中的值恢复cx
   	     loop s0
   	     
   	     mov ax,4c00h
   	     int 21h
  codesg ends
end start

但是上面的做法有些麻烦，因为如果需要保存多个数据的时候，必须要记住哪些数据放在了哪个单元中，这样程序容易混乱。

我们使用内存来暂存数据，这一点是确定了的，但是值得推敲的是，我们用怎样的结构来保存这些数据，从而使得程序更加清晰。

一般来说，在需要暂存数据的时候，我们都应该使用栈。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
assume cs:codesg,ds:datasg,ss:stacksg

datasg segment
  db 'ibm             '
  db 'dec             '
  db 'dos             '
  db 'vax             '
datasg ends

stacksg segment	;定义一个段,用来作栈段,容量为16个字节
	dw 0,0,0,0,0,0,0,0
stacksg ends

codesg segment
  start: mov ax,datasg
   	     mov ds,ax
   		 mov bx,0
   		 mov cx,4
   	 s0: mov si,0
   	     push cx	;将外层循环的cx值压栈
   	     mov cx,3
   	  s: mov al,[bx+si]
   	     and al,11011111b
   	     mov [bx+si],al
   	     inc si
   	     
   	     loop s
   	     
   	     add bx,16
   	     pop cx	;从栈顶弹出原cx的值,恢复cx
   	     loop s0
   	     
   	     mov ax,4c00h
   	     int 21h
  codesg ends
end start

3.课后实验

题目：编程，将datasg段中每个单词的前四个字母改为大写字母。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
assume cs:codesg,ds:datasg,ss:stacksg
stacksg segment
  dw 0,0,0,0,0,0,0,0
stacksg ends

datasg segment
  db '1. display......'
  db '2. brows........'
  db '3. replace......'
  db '3. modify.......'
datasg ends

codesg segment
  start: ...
codesg ends
end start

答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
assume cs:codesg,ds:datasg,ss:stacksg
stacksg segment
  dw 0,0,0,0,0,0,0,0
stacksg ends

datasg segment
  db '1. display......'
  db '2. brows........'
  db '3. replace......'
  db '4. modify.......'
datasg ends

codesg segment
  start: mov ax,datasg
         mov ds,ax
         mov bx,0	;bx指向行
         mov cx,4	;外层循环4次
     s1: mov si,0
     	 push cx  ;将cx压栈
     	 mov cx,4 ;内层循环4次   
     s2: mov al,[bx+si+3]
         and al,11011111b
         mov [bx+si+3],al
         inc si
         
         loop s2
         
         add bx,16
         pop cx	;恢复cx
         loop s1		 
         
         mov ax,4c00h
         int 21h
codesg ends
end start

debug结果：

image-20221019210537607

注意and运算时，后面要加上b表明是二进制数据

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

hello<br><br>这里leiteorz<br>一只黑猫