汇编学习-分支与循环

在高级语言程序设计中，我们不仅要求程序可以顺序运行，还要求其可以运行不同分支，或者反复运行某些操作。在汇编语言中，相同具有相同的能力，可以由对应的指令来控制程序的运行流程。由于毕竟高级语言都是汇编实现的，仅仅是不直观而已。

 

转移

无条件转移为JMP。类似c语言中的 goto。

在c语言中，goto是不推荐使用的，会使程序难以控制和理解，但在汇编中，没有对应的if 和 while语句。仅仅能使用 JMP来完毕逻辑复杂的控制结构。

JMP分为段内转移和段间转移。只是在windows编程上，一个代码段的大小为 4GB。一般不须要段间转移。

 

条件转移是由CPU提供多个标志位，在运行这类指令之前。检查之前已经设置的标志位的状态来决定是否进行转移。能够想象，通过条件转移。能够实现分支和循环。

 

分支

在汇编中，设计一个分支结构的思路基本是这种。由条件转移指令来推断条件是否满足，若满足，则跳过分支程序。否则继续向下运行，最后会合。

求 x的符号

原c 程序

</pre><pre name="code" class="cpp">int x = 10;
int signX;
int main()
{
	if (x > 0)
		signX = 1;
	else if (x == 0)
		signX = 0;
	else
		signX = -1;
}

相应的汇编

x                SDWORD        -45
signX        SDWORD        ?
 
mov signX, 0
cmp        x, 0
jz        a70                                ;为0
jg        a60                                ;大于0
mov signX, -1
jmp        a70
a60:
mov        signX, 1
a70:

 

二分查找

对于一个已排序的数组，最快的查找一个元素的方法不是顺序查找。而是二分查找。这个用c 语言写很方便。首先我们还是画出流程图，这有助于我们用 JMP转换之。

数组为R，元素个数为n。要查找的数为a。

运行过程为：
（1）先设定查找范围为下界 l到上界h

（2）假设下界大于上界，且没查到。则查找失败

（3）取下界和上界的中点m=(l+h)/2，该数为R[m]

（4）若该数为a，则算法结束

（5）若该数小于a。则改动下界l=m+1，并跳转到第二步

（6）若该数大于a，则改动上界 h=m-1，并跳转到第二步

汇编源代码

.386
.model flat,stdcall        
optioncasemap:none
includelib  msvcrt.lib
printf      PROTO C :dword, :vararg
 
.data
dArray      dword 50, 56, 64, 73, 83, 92, 103, 105
ITEMS       equ    $-dArray)/4        ; 数组长度          
Index           dword   ?
Count           dword   ?
szFmt           byte    'Index=%d Count=%d Element=%d', 0;  格式化字符串
szErr           byte    'Not Found'
 
l       sdword ?

h       sdword ?
m       sdword ?
a       sdword 83      ; 所查找的数字
.code
start:
    mov    Index, -1;
    mov    Count,  0
    mov    l, 0
    mov    h, ITEMS-1;
    mov    ecx, l
    mov    edx, h
b10:   
    cmp    ecx, edx    ; 下界和上界比較
    jg     b40         ; 超出。则未找到
    mov    esi, ecx;
    add    esi, edx
    shr    esi, 1      ; m = (l+h)>>1
    inc    Count
    mov    eax, a      ; 取出被比較的数
    cmp    eax, dArray[esi*4] ; 取出该数
    jz     b30         ; 相等
    jg     b20         ; 比 a 小，改动下界
    ; 比 a 大，改动上界
    mov    edx, esi
    dec    edx         ; h = m-1
    jmp    b10
b20:
    mov    ecx, esi
    inc    ecx         ; l = m+1
    jmp    b10
b30:
    mov    Index, esi
    ; 调用 c 库的 printf
    invoke printf, offset szFmt, Index, Count, dArray[esi*4]
    jmp    b50
b40:
    ; 查找失败
    invoke printf, offset szErr
b50:
    ret
end start

 

有序表插入

首先遍历数组。找到m，满足 R[m-1]<a && R[m]>a。

然后将R[m..n-1]每个元素向后移动一个位置，再插入a。

关键部分汇编代码

start:
    mov    eax, Element        ; 将插入的元素
    mov    esi, 0              ; 当前比較元素的下标
c10:
    cmp    dArray[esi*4], eax
    ja     c20
    inc    esi
    cmp    esi, ITEMS          ; 超出数组长度，
    jb     c10                 ; 没有超出
    ;
c20:
    mov    edi, ITEMS-1        ; 从数组尾部開始移动
c30:
    cmp    edi, esi            ; 与插入位置比較
    jl     c40                 ; 移动完毕
    ; 还没完毕，继续移动
    mov    ebx, dArray[edi*4]
    mov    dArray[edi*4+4], ebx ; 向后移动一个元素
    dec    edi
    jmp    c30                 ; 继续推断。决定是否移动
c40:
    mov    dArray[esi*4], eax  ; 移动完毕，插入元素

 

循环

实际编码解决这个问题时，常常遇到大量反复的动作，利用循环结构能够简化程序的编写。

实际在上文中，已经有循环部分出现，但那是不定次数的循环。

一个循环结构分为三部分：循环初始化，循环体，循环结束控制。

一个固定次数的循环，有LOOP命令来实现。循环次数在ECX中。

 

阶乘

这里直接使用ECX 作为乘数。其会随循环递减。正好符合阶乘的定义。

.data
    Fact   dword   ?
    N      EQU     5
.code
start:
    mov    ecx, N      ; 循环初值，同一时候也是乘数初值
    mov    eax, 1      ; fact 初值
e10:
    imul   eax, ecx    ; 相乘
    loop   e10
   
    mov    Fact, eax   ; 阶乘结果

 

冒泡

冒泡算法是一个多重循环。

start:
    mov    ecx, ITEMS-1
i10:
    xor    esi, esi    ; 清零
i20:
    mov    eax, dArray[esi*4]
    mov    ebx, dArray[esi*4+4]
    cmp    eax, ebx    ; 比較相邻的两个数
    jl     i30
    mov    dArray[esi*4], ebx    ;较大的数在左边。须要移动
    mov    dArray[esi*4+4], eax  ; 须要交换两个数
; 比較下一对数
i30:
    inc    esi
    cmp    esi, ecx
    jb     i20     ; 内循环。一遍下来，最大的数，移到了最右边
    loop   i10     ; 外循环

參考文献

[1] 谭毓安, 张雪兰. Windows汇编语言程序设计教程. 北京: 电子工业出版社, 2005.