Collect

Crazy summer study: Introduction to assembly learning notes (VI) - si, di, double loop

Reference: Assembly Language, Chapter 7 by Wang Shuang

1. and and or instructions, and [bx+idata]

I won’t say much about and and or.

[bx+idata] This is acceptable and in some cases, it is more convenient.

[bx+idata] can also be written as idata[bx]

See the example directly: Change 'ABcde' and 'fGHig' to uppercase (in ASCII, uppercase letters and lowercase letters in binary only differ in the fifth bit, uppercase letters are 0, lowercase letters are 1)

assume cs:code,ds:data
data segment
db 'ABcde'
db 'fGHIg'
data ends
code segment
start: mov ax,data
mov ds,ax
mov bx,0
mov cx,4
mov al,00100000b
s: or [bx],al
or [5+bx],al ;[5+bx] can also be written as 5[bx]
inc bx
loops
mov ax,4c00H
int 21H
code ends
end start

2. si, di, and [bx+si], [bx+di], [bx+si+idata], [bx+di+idata]

si and di are the same as bx, except that they cannot be divided into bh and bl like bx. For example, mov ax, [si], etc.

[bx+si],[bx+di],[bx+si+idata],[bx+idata]

These are all possible and, in some cases, convenient.

Where [bx+si] and [bx+di] can be written as [bx][si], [bx][di]

[bx+si+idata],[bx+di+idata] can be written as idata[bx][si],idata[bx][di]

Example: Copy Welcome!

assume cs:code,ds:data
data segment
db 'Welcome! '
data ends
code segment
start: mov ax,data
mov ds,ax
mov si,0
mov cx,4
s: mov ax,[si]
mov 8[si],ax
add si,2
loops
mov ax,4c00H
int 21H
code ends
end start

Example: Capitalize the first letter of the word in data

assume cs:code,ds:data
data segment
db '1.file '
db '2.edit '
db '3.search'
db '4.view '
data ends
code segment
start: mov ax,data
mov ds,ax
mov bx,0
mov cx,4
mov al,11011111b
s: and [bx+2],al
add bx,8
loops
mov ax,4c00H
int 21H
code ends
end start

3. Double loop

Example: Change the words in data to uppercase

assume cs:code,ds:data
data segment
db 'ibm '
db 'dec '
db 'dos '
db 'vax'
data ends
code segment
start: mov ax,data
mov ds,ax
mov bx,0
mov al,11011111b
mov cx,4
s: mov cx,3
mov si,0
s0: and [bx+si],al
inc si
loop s0
add bx,8
loops
mov ax,4c00H
int 21H
code ends
end start

The above code is wrong and will result in an infinite loop, because cx is constantly assigned 3, causing the outer loop to loop infinitely.

assume cs:code,ds:data
data segment
db 'ibm '
db 'dec '
db 'dos '
db 'vax'
data ends
code segment
start: mov ax,data
mov ds,ax
mov bx,0
mov al,11011111b
mov cx,4
s: mov dx,cx; dx is used to temporarily store the value of cx in the outer layer
mov cx,3
mov si,0
s0: and [bx+si],al
inc si
loop s0
mov cx,dx ; used to restore cx of the outer loop
add bx,8
loops
mov ax,4c00H
int 21H
code ends
end start

The above code can solve the above problem and run normally, but the number of registers is limited, and sometimes there may be no other registers available.

Solution, save in memory. Example:

assume cs:code,ds:data
data segment
db 'ibm '
db 'dec '
db 'dos '
db 'vax'
dw 0 ; define a word to save cx
data ends
code segment
start: mov ax,data
mov ds,ax
mov bx,0
mov al,11011111b
mov cx,4
s: mov ds:[20H],cx
mov cx,3
mov si,0
s0: and [bx+si],al
inc si
loop s0
mov cx,ds:[20H]
add bx,8
loops
mov ax,4c00H
int 21H
code ends
end start

The above code solves the problem of insufficient registers. However, it is still quite complicated and will be difficult to understand if there are many loops.

The solution is to use the stack to save and restore cx. Example 1:

assume cs:code,ds:data,ss:stack
data segment
db 'ibm '
db 'dec '
db 'dos '
db 'vax'
data ends
stack segment
dw 0,0,0,0,0,0,0,0
stack ends
code segment
start: mov ax,data
mov ds,ax
mov ax,stack
mov ss,ax
mov sp,16
mov bx,0
mov al,11011111b
mov cx,4
s: push cx
mov cx,3
mov si,0
s0: and [bx+si],al
inc si
loop s0
pop cx
add bx,8
loops
mov ax,4c00H
int 21H
code ends
end start

Example 2: Capitalize the first three letters of the words in data

assume cs:code,ds:data,ss:stack
data segment
db '1.display.......'
db '2.brows.........'
db '3.replace.......'
db '4.modify........'
data ends
stack segment
dw 0,0,0,0,0,0,0,0
stack ends
code segment
start: mov ax,data
mov ds,ax
mov ax,stack
mov ss,ax
mov sp,16
mov bx,0
mov al,11011111b
mov cx,4
s: push cx
mov si,0
mov cx,3
s0: and [bx+si+2],al
inc si
loop s0
pop cx
add bx,10H
loops
mov ax,4c00H
int 21H
code ends
end start

Reference address：Notes on learning how to assemble an introductory chapter (VI) - si, di, double loop

Previous article：Introduction to assembly learning notes (VII) - dp, div, dup
Next article：Introduction to assembly learning notes (V) - programs containing multiple segments

Popular Resources
Popular amplifiers