1. 堆栈框架
1). 栈参数
之前使用寄存器传递参数，现在我们将使用运行栈在子程序中传递参数。堆栈框架（或激活记录）是为传递的参数，子程序返回地址，局部变量和已保存的寄存器预留的堆栈区域。栈框架的创建步骤：
I. 如果有要传递的参数，则压入栈中。
II. 调用子程序，使子程序返回地址被压入堆栈。
III. 子程序开始执行时，EBP被压入栈中。
IV. EBP等于ESP。 从这一点开始，EBP充当所有子例程参数的基础参考。
V. 如果存在局部变量，则ESP递减以为堆栈上的变量保留空间。
VI. 如果需要保存任何寄存器，则将它们压入堆栈。
2). 寄存器参数的缺点
缺点：相同的寄存器用于保存数据值，例如计算中的循环计数器和操作数。 因此，在程序之前必须首先将用作参数的任何寄存器压入堆栈
调用，分配过程参数的值，然后在过程返回后恢复为原始值。例如：
push ebx ; save register values
push ecx
push esi
mov esi,OFFSET array ; starting OFFSET
mov ecx,LENGTHOF array ; size, in units
mov ebx,TYPE array ; doubleword format
call DumpMem ; display memory
pop esi ; restore register values
pop ecx
pop ebx
不仅所有额外的推送和弹出都会造成代码混乱，它们往往会通过避免寄存器参数来消除我们希望获得的性能优势！ 此外，程序员必须非常小心每个寄存器的PUSH与其适当的POP匹配，即使代码中存在多个执行路径。
两种参数类型被压入栈中产生的子程序调用方式有：值传递、引用传递。
- 值传递
向栈中存入变量的值
.data
val1 DWORD 5
val2 DWORD 6
.code
push val2
push val1
call AddTwo
值传递.png
- 引用传递
向栈中压入变量的地址
push OFFSET val2
push OFFSET val1
call Swap
引用传递.png
- 传递数组
高级语言通过引用传递向子程序传递数组。
.data
array DWORD 50 DUP(?)
.code
push OFFSET array
call ArrayFill
3). 接收栈参数
- 基址偏移寻址
我们使用基址偏移地址接收栈参数，EBP是一个基础的寄存器并且偏移量是一个常量。
AddTwo PROC
push ebp
mov ebp,esp ; base of stack frame
mov eax,[ebp + 12] ; second parameter
add eax,[ebp + 8] ; first parameter
pop ebp
ret
AddTwo ENDP
Accessing Stack Parameters.png
- 显示堆栈参数
显示堆栈参数：栈参数使用表达式引用。
y_param EQU [ebp + 12]
x_param EQU [ebp + 8]
AddTwo PROC
push ebp
mov ebp,esp
mov eax,y_param
add eax,x_param
pop ebp
ret
AddTwo ENDP
- 清理堆栈
当子程序返回后，我们必须从堆栈中移除参数。否则，会早晨内存泄漏和栈损坏。
4). 32位调用约定
- C调用约定
C调用约定通常在C和C++程序中使用，子程序参数以相反的顺序被压入堆栈，因此进行函数调用的C程序将首先将B推入堆栈，然后按A。C调用约定解决清理堆栈的方法是：当程序调用子程序时，它在CALL指令后面跟一个语句，该语句向堆栈指针（ESP）添加一个等于子程序参数组合大小的值。
Example1 PROC
push 6
push 5
call AddTwo
add esp,8 ; remove arguments from the stack
ret
Example1 ENDP
- STDCALL调用约定
当程序使用RET时，在RET后跟一个整型参数，整型参数的值为该子程序参数的大小。
AddTwo PROC
push ebp
mov ebp,esp ; base of stack frame
mov eax,[ebp + 12] ; second parameter
add eax,[ebp + 8] ; first parameter
pop ebp
ret 8 ; clean up the stack
AddTwo ENDP
- 保存和恢复寄存器
子程序经常在修改寄存器前保存他们当前的内容。这是一个好方法，因为原数据在子程序返回之后可以被恢复。
MySub PROC
push ebp ; save base pointer
mov ebp,esp ; base of stack frame
push ecx
push edx ; save EDX
mov eax,[ebp+8] ; get the stack parameter
.
.
pop edx ; restore saved registers
pop ecx
pop ebp ; restore base pointer
ret ; clean up the stack
MySub ENDP
Stack frame for the MySub procedure.png
5). 局部变量
局部变量在运行栈上创建，通常在基址（EBP）之下。
Local Variables.png
MySub PROC
push ebp
mov ebp,esp
sub esp,8 ; create locals
mov DWORD PTR [ebp�4],10 ; X
mov DWORD PTR [ebp�8],20 ; Y
mov esp,ebp ; remove locals from stack
pop ebp
ret
MySub ENDP
Stack frame after creating local variables.png
- 局部变量符号
为了阅读更简便，可以定义符号为每个局部变量偏移地址。
X_local EQU DWORD PTR [ebp�4]
Y_local EQU DWORD PTR [ebp�8]
MySub PROC
push ebp
mov ebp,esp
sub esp,8 ; reserve space for locals
mov X_local,10 ; X
mov Y_local,20 ; Y
mov esp,ebp ; remove locals from stack
pop ebp
ret
MySub ENDP
6). 引用参数
引用参数通常使用基址偏移地址（EBP）被程序所访问。因为每个引用参数是一个指针，它通常被加载到寄存器中以用作间接操作数。
- 数组填充实例
; 数组填充
INCLUDE Irvine32.inc
.data
count = 100
array WORD count DUP(?)
.code
main PROC
push OFFSET array
push count
call ArrayFill
call Crlf
call WaitMsg
exit
main ENDP
ArrayFill PROC
push ebp
mov ebp, esp
pushad ; 保存寄存器
mov esi, [ebp + 12] ; 数组地址
mov ecx, [ebp + 8] ; 数组长度
cmp ecx, 0 ; ECX == 0?
je L2 ; 如果是，则结束循环
L1:
mov eax, 10000 ; 从0——10000获取随机数
call RandomRange ; 从Irvine32库中
mov [esi], ax ; 插入数组
add esi, TYPE WORD ; 移动到下一个结点
LOOP L1
L2:
popad
pop ebp
RET 8 ; 清除堆栈
ArrayFill ENDP
END
7). LEA 指令
LEA指令返回间接操作数的地址。因为间接操作数包含一个或多个寄存器，它们的偏移量在运行时计算。
makeArray PROC
push ebp
mov ebp,esp
sub esp,32 ; myString is at EBP�30
lea esi,[ebp–30] ; load address of myString
mov ecx,30 ; loop counter
L1: mov BYTE PTR [esi],'*' ; fill one position
inc esi ; move to next
loop L1 ; continue until ECX = 0
add esp,32 ; remove the array (restore ESP)
pop ebp
ret
makeArray ENDP
8). ENTER 和 LEAVE 指令
- ENTER 指令
ENTER 指令调用程序时自动创建一个堆栈框架。它为局部变量保留堆栈空间并将EBP保存在堆栈中。具体来说它执行三个操作：
I. 将EBP压入栈中（push ebp）
II. 设置EBP为堆栈框架的基地址（mov ebp, esp）
III. 为局部变量预留空间（sub esp, numbytes）
格式
ENTER numbytes, nestinglevel
第一个参数是一个长廊，为局部变量预留的字节空间。第二个参数指定过程的词法嵌套级别。这两个操作数都是立即数。numbytes是4的倍数。在我们的程序中，nestinglevel总是0.
示例：
MySub PROC
enter 8,0
; 类似于
MySub PROC
push ebp
mov ebp,esp
sub esp,8
Stack frame before and after ENTER has executed.png
- LEAVE 指令
LEAVE指令终止进程的堆栈帧。 它通过将ESP和EBP恢复为调用过程时分配的值来反转前一个ENTER指令的操作。
格式
MySub PROC
enter 8,0
.
.
leave
ret
MySub ENDP
9). LOCAL 指令
LOCAL 定义一个或多个局部变量名并分配它们的类型。
格式
LOCAL varlist
; 其中每个变量类似于label:type
示例：
MySub PROC
LOCAL TempArray[10]:DWORD
BubbleSort PROC
LOCAL temp:DWORD, SwapFlag:BYTE
2. 递归
递归子程序是指直接或间接的调用它自身。在处理具有重复模式的数据结构时，递归（调用递归子例程的实践）可以是一个强大的工具。
- 无穷的递归
; 无穷的递归
INCLUDE Irvine32.inc
.data
endlessStr BYTE "This recursion never stops",0
.code
main PROC
call Endless
call Crlf
call WaitMsg
exit
main ENDP
Endless PROC
mov edx,OFFSET endlessStr
call WriteString
call Crlf
call Endless
ret ; never executes
Endless ENDP
END
1). 递归计算和
有用的递归子例程始终包含终止条件。 当终止条件变为真时，当程序执行所有挂起的RET指令时，堆栈将展开。
; 递归计算和
INCLUDE Irvine32.inc
.code
main PROC
mov ecx, 5 ; 设置count = 5
mov eax, 0 ; 设置sum = 0
call CalcSum ; 计算和
L1:
call WriteDec ; 显示EAX
call Crlf
call WaitMsg
exit
main ENDP
;----------------------------------------------
; 计算一串数字之和
; Receives: ECX = count
; Returns: EAX = sum
;----------------------------------------------
CalcSum PROC
cmp ecx, 0 ; 检查counter
jz L2 ; 如果为0， 则退出程序
add eax, ecx ; 否则求和
dec ecx ; counter递减
call CalcSum ; 递归
L2:
ret
CalcSum ENDP
END
Stack Frame and Registers (CalcSum).png
2). 计算因子
; 递归相乘
INCLUDE Irvine32.inc
.code
main PROC
push 5 ; 计算5!
call Factorial ; 计算因子
call WriteDec ; 显示EAX
call Crlf
call WaitMsg
exit
main ENDP
;----------------------------------------------
; 计算因子乘积
; Receives: [ebp + 8] = n, 计算
; Returns: EAX = 乘积
;----------------------------------------------
Factorial PROC
push ebp
mov ebp, esp
mov eax, [ebp + 8] ; 获取n
cmp eax, 0 ; 判断 n > 0?
ja L1 ; 继续L1
mov eax, 1 ; 如果不是，则返回1
jmp L2 ; 返回结果
L1:
dec eax
push eax
call Factorial
ReturnFact:
mov ebx, [ebp + 8] ; 获取n
mul ebx ; EDX:EAX = EAX * EBX
L2:
pop ebp
ret 4
Factorial ENDP
END
Recursive calls to the factorial function.png
3. INVOKE, ADDR, PROC, and PROTO
在32位模式下，INVOKE，PROC和PROTO指令为定义和调用过程提供了强大的工具。除了这些指令外，ADDR运算符也是必不可少的工具
定义程序参数。
1). INVOKE 指令
INVOKE指令，仅在32位模式下可用，将参数压入栈中和调用程序。INVOKE是CALL指令的一个方便替代品，因为它允许您使用一行代码传递多个参数。
- 格式
INVOKE procedureName [, argumentList]
Argument types used with INVOKE.png
EAX,EDX重写： 如果将小于32位的参数传递给程序，INVOKE会经常重写EAX和EDX，因此在使用INVOKE调用程序时，最好使用保存和恢复EAX、DEX的方式。
- 替换代码
push TYPE array
push LENGTHOF array
push OFFSET array
call DumpArray
; call 四行代码等价于 INVOKE 一行代码
INVOKE DumpArray, OFFSET array, LENGTHOF array, TYPE array
2). ADDR 操作
ADDR 操作，32位模式下可用，使用INVOKE指令时可以传递指针参数。
- 格式
INVOKE FillArray, ADDR myArray
3). PROC 指令
- PROC 指令语法
label PROC [attributes] [USES reglist], parameter_list
其中label是用户自定义标签，attributes可选值为[distance] [langtype] [visibility] [prologuearg]
Attributes field in the PROC directive.png
- 参数列表
label PROC [attributes] [USES reglist],
parameter_1,
parameter_2,
.
.
parameter_n
; 其中每个parameter_n的格式为paramName:type
- 由PROC修改的RET指令
push ebp
mov ebp,esp
.
.
leave
ret (n*4)
- 指定参数传递协议
Example1 PROC C,
parm1:DWORD, parm2:DWORD
Example1 PROC STDCALL,
parm1:DWORD, parm2:DWORD
4). PROTO 指令
在64位中，我们可以使用PROTO指令标识外部的程序。
ExitProcess PROTO
.code
mov ecx,0
call ExitProcess
在32位中，PROTO是一个更强大的功能，因为它可以包含一个列表
程序参数。
; 类型于C语言中的函数声明
MySub PROTO ; procedure prototype
.
INVOKE MySub ; procedure call
.
MySub PROC ; procedure implementation
.
.
MySub ENDP
- 程序声明的方法
I> 将PROC改为PROTO
II> 移除USES操作和寄存器列表
; 程序 PROTO 声明:
ArraySum PROTO,
ptrArray:PTR DWORD, ; points to the array
szArray:DWORD ; array size
; 程序实现
ArraySum PROC USES esi ecx,
ptrArray:PTR DWORD, ; points to the array
szArray:DWORD ; array size
; (remaining lines omitted...)
ArraySum ENDP
编译时参数检查
PROTO 指令编译时比较程序声明和程序实现的参数。MASM 检测错误
如果参数超出声明参数的大小，MASM将生成一个错误。MASM 不检测的错误
如果参数小于声明参数的大小，MASM将不生成错误。数组求和示例
; 数组求和
INCLUDE Irvine32.inc
.data
array DWORD 10000h, 20000h, 30000h, 40000h, 50000h
theSum DWORD ?
.code
ArraySum PROTO,
ptrArray: PTR DWORD, ; points to the array
szArray:DWORD ; array size
main PROC
INVOKE ArraySum,
ADDR array, ; 数组首地址
LENGTHOF array ; 数组元素个数
call WriteHex
call Crlf
call WaitMsg
exit
main ENDP
ArraySum PROC USES esi ecx,
ptrArray: PTR DWORD, ; points to the array
szArray:DWORD ; array size
mov esi, ptrArray ; 数组地址
mov ecx, szArray ; 数组长度
mov eax, 0 ; 设置和为0
cmp ecx, 0 ; 数组长度是否为0
je L2 ; 如果等于则quit
L1:
add eax, [esi] ; 求和
add esi, 4 ; 移动到下一个数组元素
LOOP L1 ; 循环
L2:
ret ; sum 在EAX寄存器中
ArraySum ENDP
END
ArraySum.png
5). 参数分类
过程参数通常根据调用程序和被调用过程之间的数据传输方向进行分类:
Input -> 输入参数是由调用程序传递给过程的数据.
Output -> 当调用程序将变量的地址传递给过程时，将创建输出参数.
Input-Output -> 输入输出参数与输出参数相同，但有一个例外：被调用过程期望参数引用的变量包含一些数据。
6). 示例：交换两个整数
; 交换两个数
INCLUDE Irvine32.inc
Swap PROTO, pValX: PTR DWORD, pValY: PTR DWORD
.data
Array DWORD 10000h, 20000h
.code
main PROC
; 交换之前显示数组
mov esi, OFFSET Array
mov ecx, 2 ; 数组长度
mov ebx, TYPE Array
call DumpMem ; 显示数组数据
INVOKE Swap, ADDR Array, ADDR[Array + 4]
; 显示交换后的数据
call DumpMem
call Crlf
call WaitMsg
exit
main ENDP
;--------------------------------------------
; 交换两个32位整型
; Return: 无
;--------------------------------------------
Swap PROC USES eax esi edi,
pValX: PTR DWORD,
pValY: PTR DWORD
mov esi, pValX ; 获取指针
mov edi, pValY
mov eax, [esi] ; 获取第一个整数
xchg eax, [edi] ; 交换两个数
mov [esi], eax ; 替换第一个整数
RET
Swap ENDP
END
效果.png
7). 调试提醒
常见错误：
- 参数大小不匹配
- 传递指针类型错误
- 传递即时值
8). WriteStackFrame 程序
; 交换两个数
INCLUDE Irvine32.inc
WriteStackFrame PROTO,
numParam:DWORD, ; 传递参数个数
numLocalVal: DWORD, ; 本地变量
numSavedReg: DWORD ; 保存寄存器的个数
.code
myProc PROC USES eax ebx,
x: DWORD, y: DWORD
LOCAL a: DWORD, b: DWORD
PARAMS = 2
LOCALS = 2
SAVED_REGS = 2
mov a, 0AAAAh
mov b, 0BBBBh
INVOKE WriteStackFrame, PARAMS, LOCALS, SAVED_REGS
RET
myProc ENDP
main PROC
mov eax, 0EAEAEAEAh
mov ebx, 0EBEBEBEBh
INVOKE myProc, 1111h, 2222h;
call Crlf
call WaitMsg
exit
main ENDP
END
效果.png
4. 创建多模块程序
一个很大的源文件管理起来困难并且编译起来比较慢，可以将单个文件拆分成多个文件，但是对任何源文件的修改仍然需要完整组装所有文件。更好的方法是将程序划分为模块（组合单元）。每个模块都是独立组装的，因此更改一个模块的源代码只需要重新组装单个模块。 链接器将所有已组装的模块（OBJ文件）组合成一个可执行文件很快。 链接大量对象模块所需的时间远远少于组装相同数量的源代码文件所需的时间.
有两种方法去创建多模块程序：第一个是传统的，使用EXTERN指令，这或多或少可以在不同的x86汇编程序中移植。第二种是使用微软的高级指令INVOKE和PROTO，隐藏更多的低级细节。
1). 隐藏和导出程序名称
默认情况下，MASM让所有的程序时public，它们可以被任意模块被调用。我们可以覆盖这个行为，使用PRIVATE修饰符，mySub PROC PRIVATE。
-
OPTION PROC:PRIVATE指令：源程序模块之外的程序总是隐藏。所有的程序默认的访问修饰符变为私有的。然后我们必须使用PUBLIC指令标识它们。
OPTION PROC:PRIVATE
PUBLIC mySub
2). 调用外部程序
EXTERN 指令，在调用当前模块外部的过程时使用，标识过程的名称和堆栈帧大小。
INCLUDE Irvine32.inc
EXTERN sub1@0:PROC
.code
main PROC
call sub1@0
exit
main ENDP
END main
3). 跨模块边界使用变量和符号
- 导出变量和符号
在一个闭合的模块中，变量和符号默认是私有的。我们可以使用PUBLIC指令导出特殊的名字。
PUBLIC count, SYM1
SYM1 = 10
.data
count DWORD 0
- 接收外部变量 和符号
我们可以使用EXTERN指令接收定义在其他模块的变量和符号
EXTERN name : type
- 使用
INCLUDE和EXTERNDEF
vars.inc
; vars.inc
EXTERNDEF count:DWORD, SYM1:ABS
sub1.asm
; sub1.asm
.386
.model flat,STDCALL
INCLUDE vars.inc
SYM1 = 10
.data
count DWORD 0
END
main.asm
.386
.model flat,stdcall
.stack 4096
ExitProcess proto, dwExitCode:dword
INCLUDE vars.inc
.code
main PROC
mov count,2000h
mov eax,SYM1
INVOKE ExitProcess,0
main ENDP
END main
4). 示例：数组求和
模块图结构：
Structure chart, ArraySum program.png
5). 使用EXTERN创建模块
_prompt.asm
; 提示用户输入整数
INCLUDE Irvine32.inc
.code
;------------------------------------------
PromptForIntegers PROC
; 提示用户输入整数数组
; Receives:
; ptrPrompt: PTR BYTE ; 提示信息
; ptrArray: PTR DWORD ; 数组首地址
; arraySize: DWORD ; 数组大小
; Returns: 无
;------------------------------------------
arraySize EQU [ebp + 16]
ptrArray EQU [ebp + 12]
ptrPrompt EQU [ebp + 8]
enter 0,0
pushad ; 保存所有寄存器
mov ecx, arraySize
cmp ecx, 0 ; 判断数组长度是否小于等于0
jle L2 ; 如果是则退出
mov edx, ptrPrompt ; 提示信息的地址
mov esi, ptrArray
L1:
call WriteString ; 显示字符串
call ReadInt ; 从EAX读取一个整数
call Crlf ; 换行
mov [esi], eax ; 存储到数组
add esi, 4 ; 下一个整数
LOOP L1
L2:
popad ; 恢复所有寄存器
leave ; 恢复栈
ret 12
PromptForIntegers ENDP
END
_arraysum.asm
; 数组求和
INCLUDE Irvine32.inc
.code
;------------------------------------------
ArraySum PROC
; 计算数组元素之和
; Receives:
; ptrArray ; 数组首地址
; arraySize ; 数组大小
; Returns: EAX = sum
;------------------------------------------
ptrArray EQU [ebp + 8]
arraySize EQU [ebp + 12]
enter 0,0
push ecx ; 不要push EAX
push esi
mov eax, 0 ; 设置和为0
mov esi, ptrArray
mov ecx, arraySize
cmp ecx, 0 ; 数组大小是否小于0
jle L2 ; 如果是则退出
L1:
add eax, [esi] ; 添加一个整数到sum
add esi, 4 ; 指向数组下一个元素
LOOP L1 ; 循环
L2:
pop esi
pop ecx ; 返回sum到EAX中
leave
ret 8 ; 恢复栈
ArraySum ENDP
END
_display.asm
; 显示程序
INCLUDE Irvine32.inc
.code
;------------------------------------------
DisplaySum PROC
; 在控制台显示数组和
; Receives:
; ptrPrompt ; 提示信息首地址
; theSum ; 数组和
; Returns: 无
;------------------------------------------
theSum EQU [ebp + 12]
ptrPrompt EQU [ebp + 8]
enter 0, 0
push eax
push edx
mov edx, ptrPrompt ; 指向提示信息
call WriteString
mov eax, theSum
call WriteInt ; 显示EAX
call Crlf
pop edx
pop eax
leave
ret 8
DisplaySum ENDP
END
Sum_main.asm
; 数组求和 总模块
; 使用到的模块：_arraysum.asm, _display.asm, _prompt.asm
INCLUDE Irvine32.inc
EXTERN PromptForIntegers@0:PROC
EXTERN ArraySum@0:PROC, DisplaySum@0:PROC
; 重定义方法名，为了使用方便
ArraySum EQU ArraySum@0
PromptForIntegers EQU PromptForIntegers@0
DisplaySum EQU DisplaySum@0
; 数组长度
Count = 3
.data
prompt1 BYTE "Enter a signed integer: ",0
prompt2 BYTE "The sum of the integers is: ",0
array DWORD Count DUP(?)
sum DWORD ?
.code
main PROC
call Clrscr
; 提示用户输入数据
push Count
push OFFSET array
push OFFSET prompt1
call PromptForIntegers
; 计算数组之和
push Count
push OFFSET array
call ArraySum
mov sum, eax
; 显示和
push sum
push OFFSET prompt2
call DisplaySum
call Crlf
call WaitMsg
exit
main ENDP
END
运行效果：
效果.png
6). 使用INVOKE and PROTO 创建模块
sum.inc
; (sum.inc)
INCLUDE Irvine32.inc
PromptForIntegers PROTO,
ptrPrompt:PTR BYTE, ; prompt string
ptrArray:PTR DWORD, ; points to the array
arraySize:DWORD ; size of the array
ArraySum PROTO,
ptrArray:PTR DWORD, ; points to the array
arraySize:DWORD ; size of the array
DisplaySum PROTO,
ptrPrompt:PTR BYTE, ; prompt string
theSum:DWORD ; sum of the array
__prompt.asm
; 提示用户输入整数
INCLUDE sum.inc ; 获取方法原型
.code
;------------------------------------------
PromptForIntegers PROC,
ptrPrompt: PTR BYTE, ; 提示信息
ptrArray: PTR DWORD, ; 数组首地址
arraySize: DWORD ; 数组大小
; 提示用户输入整数数组
; Returns: 无
;------------------------------------------
pushad ; 保存所有寄存器
mov ecx, arraySize
cmp ecx, 0 ; 判断数组长度是否小于等于0
jle L2 ; 如果是则退出
mov edx, ptrPrompt ; 提示信息的地址
mov esi, ptrArray
L1:
call WriteString ; 显示字符串
call ReadInt ; 从EAX读取一个整数
call Crlf ; 换行
mov [esi], eax ; 存储到数组
add esi, 4 ; 下一个整数
LOOP L1
L2:
popad ; 恢复所有寄存器
ret
PromptForIntegers ENDP
END
__arraysum.asm
; 数组求和
INCLUDE sum.inc
.code
;------------------------------------------
ArraySum PROC,
ptrArray:PTR DWORD, ; 数组首地址
arraySize:DWORD ; 数组大小
; 计算数组元素之和
; Returns: EAX = sum
;------------------------------------------
push ecx ; 不要push EAX
push esi
mov eax, 0 ; 设置和为0
mov esi, ptrArray
mov ecx, arraySize
cmp ecx, 0 ; 数组大小是否小于0
jle L2 ; 如果是则退出
L1:
add eax, [esi] ; 添加一个整数到sum
add esi, 4 ; 指向数组下一个元素
LOOP L1 ; 循环
L2:
pop esi
pop ecx ; 返回sum到EAX中
ret ; 恢复栈
ArraySum ENDP
END
__display.asm
; 显示程序
INCLUDE Irvine32.inc
.code
;------------------------------------------
DisplaySum PROC,
ptrPrompt: PTR BYTE, ; 提示信息首地址
theSum:DWORD ; 数组和
; 在控制台显示数组和
; Returns: 无
;------------------------------------------
push eax
push edx
mov edx, ptrPrompt ; 指向提示信息
call WriteString
mov eax, theSum
call WriteInt ; 显示EAX
call Crlf
pop edx
pop eax
ret
DisplaySum ENDP
END
Sum__main.asm
; 数组求和 总模块
; 使用到的模块：_arraysum.asm, _display.asm, _prompt.asm
INCLUDE sum.inc
; 数组长度
Count = 3
.data
prompt1 BYTE "Enter a signed integer: ",0
prompt2 BYTE "The sum of the integers is: ",0
array DWORD Count DUP(?)
sum DWORD ?
.code
main PROC
call Clrscr
INVOKE PromptForIntegers, ADDR prompt1, ADDR array, Count
INVOKE ArraySum, ADDR array, Count
mov sum, eax
INVOKE DisplaySum, ADDR prompt2, sum
call Crlf
call WaitMsg
exit
main ENDP
END
注：这两种方式，使用较多的为EXTERN创建多模块方式，第二种在32位中使用较多。
3749
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
