过程的实现离不开堆栈的应用，堆栈是一种后进先出(LIFO)的数据结构，最后压入栈的值总是最先被弹出，而新数值在执行压栈时总是被压入到栈的最顶端，栈主要功能是暂时存放数据和地址，通常用来保护断点和现场。
栈是由CPU管理的线性内存数组,它使用两个寄存器(SS和ESP)来保存栈的状态，SS寄存器存放段选择符，而ESP寄存器的值通常是指向特定位置的一个32位偏移值，我们很少需要直接操作ESP寄存器，相反的ESP寄存器总是由CALL,RET,PUSH,POP等这类指令间接性的修改。
CPU提供了两个特殊的寄存器用于标识位于系统栈顶端的栈帧。
- ESP 栈指针寄存器：栈指针寄存器，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的栈顶。
- EBP 基址指针寄存器：基址指针寄存器，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的底部。
在通常情况下ESP是可变的，随着栈的生成而逐渐变小，而EBP寄存器是固定的，只有当函数的调用后，发生入栈操作而改变。
- 执行PUSH压栈时，堆栈指针自动减4，再将压栈的值复制到堆栈指针所指向的内存地址。
- 执行POP出栈时，从栈顶移走一个值并将其复制给内存或寄存器，然后再将堆栈指针自动加4。
- 执行CALL调用时，CPU会用堆栈保存当前被调用过程的返回地址，直到遇到RET指令再将其弹出。
10.1 PUSH/POP
PUSH和POP是汇编语言中用于堆栈操作的指令，它们通常用于保存和恢复寄存器的值，参数传递和函数调用等。
PUSH指令用于将操作数压入堆栈中，它执行的操作包括将操作数复制到堆栈的栈顶，并将堆栈指针（ESP）减去相应的字节数。指令格式如下：
PUSH operand
其中，operand可以是8位，16位或32位的寄存器，立即数，以及内存中的某个值。例如，要将寄存器EAX的值压入堆栈中，可以使用以下指令：
PUSH EAX
从汇编代码的角度来看，PUSH指令将操作数存储到堆栈中，它实际上是一个入栈操作。
POP指令用于将堆栈中栈顶的值弹出到指定的目的操作数中，它执行的操作包括将堆栈顶部的值移动到指定的操作数，并将堆栈指针增加相应的字节数。指令格式如下：
POP operand
其中，operand可以是8位，16位或32位的寄存器，立即数，以及内存中的某个位置。例如，要将从堆栈中弹出的值存储到BX寄存器中，可以使用以下指令：
POP EBX
从汇编代码的角度来看，POP指令将从堆栈中取出一个值，并将其存储到目的操作数中，它是一个出栈操作。
在函数调用时，PUSH指令被用于向堆栈中推送函数的参数，这些参数可以是寄存器、立即数或者内存中的某个值。在函数返回之前，POP指令被用于将堆栈顶部的值弹出，并将其存储到寄存器或者内存中。
读者需要特别注意，在使用PUSH和POP指令时需要保证堆栈的平衡，也就是说，每个PUSH指令必须有对应的POP指令，否则堆栈会失去平衡，最终导致程序出现错误。
在读者了解了这两条指令时则可以执行一些特殊的操作，如下代码我们以数组入栈与出栈为例，执行PUSH指令时，首先减小ESP的值，然后把源操作数复制到堆栈上，执行POP指令则是先将数据弹出到目的操作数中，然后再执行ESP值增加4，并以此分别将数组中的元素压入栈，最终再通过POP将元素反弹出来。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
Array DWORD 1,2,3,4,5,6,7,8,9,10
szFmt BYTE '%d ',0dh,0ah,0
.code
main PROC
; 使用Push指令将数组正向入栈
mov eax,0
mov ecx,10
S1:
push dword ptr ds:[Array + eax * 4]
inc eax
loop S1
; 使用pop指令将数组反向弹出
mov ecx,10
S2:
push ecx ; 保护ecx
pop ebx ; 将Array数组元素弹出到ebx
invoke crt_printf,addr szFmt,ebx
pop ecx ; 弹出ecx
loop S2
int 3
main ENDP
END main
至此当读者理解了这两个指令之后，那么利用堆栈的先进后出特定，我们就可以实现将特殊的字符串反转后输出的效果，首先我们循环将字符串压入堆栈，然后再从堆栈中反向弹出来，这样就可以实现字符串的反转操作，这段代码的实现也相对较为容易；
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
MyString BYTE "hello lyshark",0
NameSize DWORD ($ - MyString) - 1
szFmt BYTE '%s',0dh,0ah,0
.code
main PROC
; 正向压入字符串
mov ecx,dword ptr ds:[NameSize]
mov esi,0
S1: movzx eax,byte ptr ds:[MyString + esi]
push eax
inc esi
loop S1
; 反向弹出字符串
mov ecx,dword ptr ds:[NameSize]
mov esi,0
S2: pop eax
mov byte ptr ds:[MyString + esi],al
inc esi
loop S2
invoke crt_printf,addr szFmt,addr MyString
int 3
main ENDP
END main
10.2 PROC/ENDP
PROC/ENDP 伪指令是用于定义过程（函数）的伪指令，这两个伪指令可分别定义过程的开始和结束位置。此处读者需要注意，这两条伪指令并非是汇编语言中所兼容的，而是MASM编译器为我们提供的一个宏，是MASM的一部分，它允许程序员使用汇编语言定义过程（函数）可以像标准汇编指令一样使用。
对于不使用宏定义来创建函数时我们通常会自己管理函数栈参数，而有了宏定义这些功能都可交给编译器去管理，下面的一个案例中，我们通过使用过程创建ArraySum函数，实现对整数数组求和操作，函数默认将返回值存储在EAX中，并打印输出求和后的参数。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
MyArray DWORD 1,2,3,4,5,6,7,8,9,10
Sum DWORD ?
szFmt BYTE '%d',0dh,0ah,0
.code
; 数组求和过程
ArraySum PROC
push esi ; 保存ESI,ECX
push ecx
xor eax,eax
S1: add eax,dword ptr ds:[esi] ; 取值并相加
add esi,4 ; 递增数组指针
loop S1
pop ecx ; 恢复ESI,ECX
pop esi
ret
ArraySum endp
main PROC
lea esi,dword ptr ds:[MyArray] ; 取出数组基址
mov ecx,lengthof MyArray ; 取出元素数目
call ArraySum ; 调用方法
mov dword ptr ds:[Sum],eax ; 得到结果
invoke crt_printf,addr szFmt,Sum
int 3
main ENDP
END main
接着我们来实现一个具有获取随机数功能的案例，在C语言中如果需要获得一个随机数一般会调用Seed函数，如果读者逆向分析过这个函数的实现原理，那么读者应该能理解，在调用取随机数之前会生成一个随机数种子，这个随机数种子的生成则依赖于0x343FDh这个特殊的常量地址，当我们每次访问该地址都会产出一个随机的数据，当得到该数据后，我们再通过除法运算取出溢出数据作为随机数使用实现了该功能。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
seed DWORD 1
szFmt BYTE '随机数: %d',0dh,0ah,0
.code
; 生成 0 - FFFFFFFFh 的随机种子
Random32 PROC
push edx
mov eax, 343FDh
imul seed
add eax, 269EC3h
mov seed, eax
ror eax,8
pop edx
ret
Random32 endp
; 生成随机数
RandomRange PROC
push ebx
push edx
mov ebx,eax
call Random32
mov edx,0
div ebx
mov eax,edx
pop edx
pop ebx
ret
RandomRange endp
main PROC
; 调用后取出随机数
call RandomRange
invoke crt_printf,addr szFmt,eax
int 3
main ENDP
END main
10.3 局部参数传递
在汇编语言中，可以使用堆栈来传递函数参数和创建局部变量。当程序执行到函数调用语句时，需要将函数参数传递给被调用函数。为了实现参数传递，程序会将参数压入栈中，然后调用被调用函数。被调用函数从栈中弹出参数并执行，然后将返回值存储在寄存器中，最后通过跳转返回到调用函数。
局部变量也可以通过在栈中分配内存来创建。在函数开始时，可以使用push指令将局部变量压入栈中。在函数结束时，可以使用pop指令将变量从栈中弹出。由于栈是后进先出的数据结构，局部变量的创建可以很方便地通过在栈上压入一些数据来实现。
局部变量是在程序运行时由系统动态的在栈上开辟的，在内存中通常在基址指针(EBP)之下，尽管在汇编时不能给定默认值，但可以在运行时初始化，如下一段C语言伪代码:
void MySub()
{
int var1 = 10;
int var2 = 20;
}
上述的代码经过C编译后，会变成如下汇编指令，其中EBP-4必须是4的倍数，因为默认就是4字节存储，如果去掉了mov esp,ebp，那么当执行pop ebp时将会得到EBP等于10，执行RET指令会导致控制转移到内存地址10处执行，从而程序会崩溃。
MySub PROC
push ebp ; 将EBP存储在栈中
mov ebp,esp ; 堆栈框架的基址
sub esp,8 ; 创建局部变量空间(分配2个局部变量)
mov DWORD PTR [ebp-8],10 ; var1 = 10
mov DWORD PTR [ebp-4],20 ; var2 = 20
mov esp,ebp ; 从堆栈上删除局部变量
pop ebp ; 恢复EBP指针
ret 8 ; 返回,清理堆栈
MySub ENDP
为了使上述代码片段更易于理解，可以在上述的代码的基础上给每个变量的引用地址都定义一个符号，并在代码中使用这些符号，如下代码所示，代码中定义了一个名为MySub的过程，该过程将两个局部变量分别设置为10和20。
在该过程中，首先使用push ebp指令将旧的基址指针压入栈中，并将ESP寄存器的值存储到ebp中。这个旧的基址指针将在函数执行完毕后被恢复。然后，我们使用sub esp,8指令将8字节的空间分配给两个局部变量。在堆栈上分配的空间可以通过var1_local和var2_local符号来访问。在这里，我们定义了两个符号，将它们与ebp寄存器进行偏移以访问这些局部变量。var1_local的地址为[ebp-8]，var2_local的地址为[ebp-4]。然后，我们使用mov指令将10和 20分别存储到这些局部变量中。最后，我们将ESP寄存器的值存储回ebp中，并使用pop ebp指令将旧的基址指针弹出堆栈。现在，栈顶指针(ESP)下移恢复上面分配的8个字节的空间，最后通过ret 8返回到调用函数。
在使用堆栈传参和创建局部变量时，需要谨慎考虑栈指针的位置，并确保遵守调用约定以确保正确地传递参数和返回值。
var1_local EQU DWORD PTR [ebp-8] ; 添加符号1
var2_local EQU DWORD PTR [ebp-4] ; 添加符号2
MySub PROC
push ebp
mov ebp,esp
sub esp,8
mov var1_local,10
mov var2_local,20
mov esp,ebp
pop ebp
ret 8
MySub ENDP
接着我们来实现一个具有功能的案例，首先为了能更好的让读者理解我们先使用C语言方式实现MakeArray()函数，该函数的内部是动态生成的一个MyString数组，并通过循环填充为星号字符串，最后使用POP弹出，并输出结果，观察后尝试用汇编实现。
void makeArray()
{
char MyString[30];
for(int i=0;i<30;i++)
{
myString[i] = "*";
}
}
call makeArray()
上述C语言代码如果翻译为汇编格式则如下所示，代码使用汇编语言实现makeArray的程序，该程序开辟了一个长度为30的数组，将其中的元素填充为*，然后弹出两个元素，并将它们输出到控制台。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
szFmt BYTE '出栈数据: %x ',0dh,0ah,0
.code
makeArray PROC
push ebp
mov ebp,esp
; 开辟局部数组
sub esp,32 ; MyString基地址位于 [ebp - 30]
lea esi,[ebp - 30] ; 加载MyString的地址
; 填充数据
mov ecx,30 ; 循环计数
S1: mov byte ptr ds:[esi],'*' ; 填充为*
inc esi ; 每次递增一个字节
loop S1
; 弹出2个元素并输出,出栈数据
pop eax
invoke crt_printf,addr szFmt,eax
pop eax
invoke crt_printf,addr szFmt,eax
; 以下平栈,由于我们手动弹出了2个数据
; 则平栈 32 - (2 * 4) = 24
add esp,24 ; 平栈
mov esp,ebp
pop ebp ; 恢复EBP
ret
makeArray endp
main PROC
call makeArray
invoke ExitProcess,0
main ENDP
END main
在该程序的开始部分，我们首先通过push ebp和mov ebp,esp指令保存旧的基址指针并将当前栈顶指针(ESP)存储到ebp中。然后，我们使用sub esp, 32指令开辟一个长度为30的数组MyString。我们将MyString数组的基地址存储在[ebp - 30]的位置。使用lea esi, [ebp - 30]指令将MyString的基地址加载到esi寄存器中。该指令偏移ebp-30是因为ebp-4是MakeArray函数的第一个参数的位置，因此需要增加四个字节。我们利用MOV byte ptr ds:[esi],'*'指令将MyString中的所有元素填充为*。
然后，使用pop eax和invoke crt_printf, addr szFmt, eax指令两次弹出两个元素，并使用crt_printf函数输出这些元素。该函数在msvcrt.dll库中实现，用于将格式化的信息输出到控制台。在输出数据之后，我们通过add esp,24和mov esp,ebp指令将堆栈平衡，恢复旧的基址指针ebp，然后从堆栈中弹出ebp，并通过ret指令返回到调用程序。
接着我们继续来对比一下堆栈中参数传递的异同点，平栈的方式一般可分为调用者平栈和被调用者平栈，在使用堆栈传参时，需要平衡栈以恢复之前的堆栈指针位置。
当平栈由被调用者完成时，被调用函数使用
ret指令将控制权返回到调用函数，并从堆栈中弹出返回地址。此时，被调用函数需要将之前分配的局部变量从堆栈中弹出，以便调用函数能够恢复堆栈指针的位置。因此，被调用函数必须知道其在堆栈上分配的内存大小，并将该大小与其ret指令中的参数相匹配，以便调用函数可以正确恢复堆栈指针位置。当平栈由调用者完成时，调用函数需要在调用子函数之前平衡堆栈。因此，调用函数需要知道子函数在堆栈上分配的内存大小，并在调用子函数之前向堆栈提交额外的空间。调用函数可以使用
add esp, N指令来恢复堆栈指针的位置，其中 N 是被调用函数在堆栈上分配的内存大小。然后，调用函数调用被调用函数，该函数将返回并将堆栈指针恢复到调用函数之前的位置。
如下这段汇编代码中笔者分别实现了两种调用方式，其中MyProcA函数是一种被调用者平栈，由于调用者并没有堆栈修正所以需要在函数内部通过使用ret 12的方式平栈，之所以是12是因为我们使用了三个局部变量，而第二个MyProcB函数则是调用者平栈，该方式在函数内部并没有返回任何参数，所以在调用函数结束后需要通过add esp,4的方式对堆栈进行修正。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
szFmt BYTE '数据: %d ',0dh,0ah,0
.code
; 第一种方式：被调用者平栈
MyProcA PROC
push ebp
mov ebp,esp
xor eax,eax
mov eax,dword ptr ss:[ebp + 16] ; 获取第一个参数
mov ebx,dword ptr ss:[ebp + 12] ; 获取第二个参数
mov ecx,dword ptr ss:[ebp + 8] ; 获取第三个参数
add eax,ebx
add eax,ebx
add eax,ecx
mov esp,ebp
pop ebp
ret 12 ; 此处ret12可平栈,也可使用 add ebp,12
MyProcA endp
; 第二种方式：调用者平栈
MyProcB PROC
push ebp
mov ebp,esp
mov eax,dword ptr ss:[ebp + 8]
add eax,10
mov esp,ebp
pop ebp
ret
MyProcB endp
main PROC
; 第一种被调用者MyProcA平栈 3*4 = 12
push 1
push 2
push 3
call MyProcA
invoke crt_printf,addr szFmt,eax
; 第二种方式：调用者平栈
push 10
call MyProcB
add esp,4
invoke crt_printf,addr szFmt,eax
int 3
main ENDP
END main
当然了如果读者认为自己维护堆栈很繁琐，则此时可以直接使用MASM汇编器提供的PROC定义过程，使用该伪指令汇编器会自行计算所需要使用的变量数量并自行在结尾处添加对应的平栈语句，这段代码实现起来将变得非常容易理解。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
.data
szFmt BYTE '计算参数: %d ',0dh,0ah,0
.code
my_proc PROC x:DWORD,y:DWORD,z:DWORD ; 定义过程局部参数
LOCAL @sum:DWORD ; 定义局部变量存放总和
mov eax,dword ptr ds:[x]
mov ebx,dword ptr ds:[y] ; 分别获取到局部参数
mov ecx,dword ptr ds:[z]
add eax,ebx
add eax,ecx ; 相加后放入eax
mov @sum,eax
ret
my_proc endp
main PROC
LOCAL @ret_sum:DWORD
push 10
push 20
push 30 ; 传递参数
call my_proc
mov @ret_sum,eax ; 获取结果并打印
invoke crt_printf,addr szFmt,@ret_sum
int 3
main ENDP
END main
这里笔者还需要扩展一个伪指令LOCAL，LOCAL是一种汇编语言中的伪指令，用于定义存储在堆栈上的局部变量。使用LOCAL指令定义的局部变量只在函数执行时存在，当函数返回后，该变量将被删除。根据使用LOCAL指令时指定的内存空间大小，汇编器将为每个变量保留足够的空间。
例如，下面是一个使用LOCAL定义局部变量的示例：
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
.code
main PROC
; 定义局部变量,自动压栈/平栈
LOCAL var_byte:BYTE,var_word:WORD,var_dword:DWORD
LOCAL var_array[3]:DWORD
; 填充局部变量
mov byte ptr ds:[var_byte],1
mov word ptr ds:[var_word],2
mov dword ptr ds:[var_dword],3
; 填充数组方式1
lea esi,dword ptr ds:[var_array]
mov dword ptr ds:[esi],10
mov dword ptr ds:[esi + 4],20
mov dword ptr ds:[esi + 8],30
; 填充数组方式2
mov var_array[0],100
mov var_array[1],200
mov var_array[2],300
invoke ExitProcess,0
main ENDP
END main
在上述示例代码中，main过程使用LOCAL指令定义了几个局部变量，包括一个字节类型的变量var_byte、一个字类型的变量var_word、一个双字类型的变量var_dword和一个包含三个双字元素的数组var_array。
在代码中，我们使用mov指令填充这些变量的值。对于字节类型、字类型和双字类型的变量，使用mov byte ptr ds:[var_byte], 1、mov word ptr ds:[var_word], 2和mov dword ptr ds:[var_dword], 3指令将相应的常数值存储到变量中。在填充数组时，分别使用了两种不同的方式。一种方式是使用lea指令将数组的地址加载到esi寄存器中，然后使用mov dword ptr ds:[esi],10等指令将相应的常数值存储到数组中。另一种方式是直接访问数组元素，如mov var_array[0], 100等指令。需要注意，由于数组元素在内存中是连续存储的，因此可以使用[]操作符访问数组元素。
在汇编中使用LOCAL伪指令来实现自动计算局部变量空间，以及最后的平栈操作，将会极大的提高开发效率。
10.4 USES/ENTER
USES是汇编语言中的伪指令，用于保存一组寄存器的状态，以便函数调用过程中可以使用这些寄存器。使用USES时，程序可以保存一组需要保护的寄存器，汇编器将在程序入口处自动向堆栈压入这些寄存器的值。读者需注意，我们可以在需要保存寄存器的程序段中使用USES来保护寄存器，但不应在整个程序中重复使用寄存器。
ENTER也是一种伪指令，用于创建函数调用过程中的堆栈帧。使用ENTER时，程序可以定义一个名为ENTER的指定大小的堆栈帧。该指令会将新的基准指针ebp 压入堆栈同时将当前的基准指针ebp存储到另一个寄存器ebx中，然后将堆栈指针esp减去指定大小的值，获取新的基地址，并将新的基地址存储到ebp 中。之后，程序可以在此帧上创建和访问局部变量，并使用LEAVE指令将堆栈帧删除，将ebp恢复为旧的值，同时将堆栈指针平衡。
在使用USES和ENTER指令时，需要了解这些指令在具体的平台上的支持情况，以及它们适用的调用约定。通常情况下，在函数开头，我们将使用ENTER创建堆栈帧，然后使用USES指定需要保护的寄存器。在函数末尾，我们使用LEAVE删除堆栈帧。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
.code
; USES 自动压入 eax,ebx,ecx,edx
my_proc PROC USES eax ebx ecx edx x:DWORD,y:DWORD
enter 8,0 ; 自动保留8字节堆栈空间
add eax,ebx
leave
my_proc endp
main PROC
mov eax,10
mov ebx,20
call my_proc
int 3
main ENDP
END main
10.5 STRUCT/UNION
STRUCT和UNION是汇编语言中的数据类型，STRUCT是一种复合数据类型，它将多个不同类型的变量按顺序放置在一起，并使用单个名称来引用集合。使用STRUCT时，我们可以将不同类型的变量组合成一个结构体并定义其属性，如结构体中包含的成员变量的数据类型、名称和位置。
例如，下面是一个使用STRUCT定义自定义类型的示例：
; 定义一个名为 MyStruct 的结构体，包含两个成员变量。
MyStruct STRUCT
Var1 DWORD ?
Var2 WORD ?
MyStruct ENDS
在上述示例代码中，我们使用STRUCT定义了一个名为MyStruct的结构体，其中包含两个成员变量Var1和Var2。其中，Var1是DWORD类型的数据类型，以问号?形式指定了其默认值，Var2是WORD类型的数据类型。
另一个数据类型是UNION，它也是一种复合数据类型，用于将多个不同类型的变量叠加在同一内存位置上。使用UNION时，程序内存中的数据将只占用所有成员变量中最大的数据类型变量的大小。与结构体不同，联合中的所有成员变量共享相同的内存位置。我们可以使用一种成员变量来引用内存位置，但在任何时候仅能有一种成员变量存储在该内存位置中。
例如，下面是一个使用UNION定义自定义类型的示例：
; 定义一个名为 MyUnion 的联合，包含两个成员变量。
MyUnion UNION
Var1 DWORD ?
Var2 WORD ?
MyUnion ENDS
在上述示例代码中，我们使用UNION定义了一个名为MyUnion的联合，其中包含两个不同类型的成员变量Var1和Var2，将它们相对应地置于联合的同一内存位置上。
读者在使用STRUCT和UNION时，需要根据内存分布和变量类型来正确访问成员变量的值。在汇编语言中，结构体和联合主要用于定义自定义数据类型、通信协议和系统数据结构等，如下一段代码则是汇编语言中实现结构体赋值与取值的总结。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
; 定义坐标结构
MyPoint Struct
pos_x DWORD ?
pos_y DWORD ?
pos_z DWORD ?
MyPoint ends
; 定义人物结构
MyPerson Struct
Fname db 20 dup(0)
fAge db 100
fSex db 20
MyPerson ends
.data
; 声明结构: 使用 <>,{}符号均可
PtrA MyPoint <10,20,30>
PtrB MyPoint {100,200,300}
; 声明结构: 使用MyPerson声明结构
UserA MyPerson <'lyshark',24,1>
.code
main PROC
; 获取结构中的数据
lea esi,dword ptr ds:[PtrA]
mov eax,(MyPoint ptr ds:[esi]).pos_x
mov ebx,(MyPoint ptr ds:[esi]).pos_y
mov ecx,(MyPoint ptr ds:[esi]).pos_z
; 向结构中写入数据
lea esi,dword ptr ds:[PtrB]
mov (MyPoint ptr ds:[esi]).pos_x,10
mov (MyPoint ptr ds:[esi]).pos_y,20
mov (MyPoint ptr ds:[esi]).pos_z,30
; 直接获取结构中的数据
mov eax,dword ptr ds:[UserA.Fname]
mov ebx,dword ptr ds:[UserA.fAge]
int 3
main ENDP
END main
接着我们来实现一个输出结构体数组的功能，结构数组其实就是一维的空间，因此使用两个比例因子即可实现寻址操作，如下代码我们先来实现一个简单的功能，只遍历第一层，结构数组外层的数据。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
; 定义坐标结构
MyPoint Struct
pos_x DWORD ?
pos_y DWORD ?
pos_z DWORD ?
MyPoint ends
; 定义循环结构
MyCount Struct
count_x DWORD ?
count_y DWORD ?
MyCount ends
.data
; 声明结构: 使用 <>,{}符号均可
PtrA MyPoint <10,20,30>,<40,50,60>,<70,80,90>,<100,110,120>
Count MyCount <0,0>
szFmt BYTE '结构数据: %d',0dh,0ah,0
.code
main PROC
; 获取结构中的数据
lea esi,dword ptr ds:[PtrA]
mov eax,(MyPoint ptr ds:[esi]).pos_x ; 获取第一个结构X
mov eax,(MyPoint ptr ds:[esi + 12]).pos_x ; 获取第二个结构X
; while 循环输出结构的每个首元素元素
mov (MyCount ptr ds:[Count]).count_x,0
S1: cmp (MyCount ptr ds:[Count]).count_x,48 ; 12 * 4 = 48
jge lop_end
mov ecx,(MyCount ptr ds:[Count]).count_x
mov eax,dword ptr ds:[PtrA + ecx] ; 寻找首元素
invoke crt_printf,addr szFmt,eax
mov eax,(MyCount ptr ds:[Count]).count_x
add eax,12 ; 每次递增12
mov (MyCount ptr ds:[Count]).count_x,eax
jmp S1
lop_end:
int 3
main ENDP
END main
接着我们递增难度，通过每次递增将两者的偏移相加，获得比例因子，通过因子嵌套双层循环实现寻址打印。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
; 定义坐标结构
MyPoint Struct
pos_x DWORD ?
pos_y DWORD ?
pos_z DWORD ?
MyPoint ends
; 定义循环结构
MyCount Struct
count_x DWORD ?
count_y DWORD ?
MyCount ends
.data
; 声明结构: 使用 <>,{}符号均可
PtrA MyPoint <10,20,30>,<40,50,60>,<70,80,90>,<100,110,120>
Count MyCount <0,0>
szFmt BYTE '结构数据: %d',0dh,0ah,0
.code
main PROC
; 获取结构中的数据
lea esi,dword ptr ds:[PtrA]
mov eax,(MyPoint ptr ds:[esi]).pos_x ; 获取第一个结构X
mov eax,(MyPoint ptr ds:[esi + 12]).pos_x ; 获取第二个结构X
; while 循环输出结构的每个首元素元素
mov (MyCount ptr ds:[Count]).count_x,0
S1: cmp (MyCount ptr ds:[Count]).count_x,48 ; 12 * 4 = 48
jge lop_end
mov (MyCount ptr ds:[Count]).count_y,0
S3: cmp (MyCount ptr ds:[Count]).count_y,12 ; 3 * 4 = 12
jge S2
mov eax,(MyCount ptr ds:[Count]).count_x
add eax,(MyCount ptr ds:[Count]).count_y ; 相加得到比例因子
mov eax,dword ptr ds:[PtrA + eax] ; 使用相对变址寻址
invoke crt_printf,addr szFmt,eax
mov eax,(MyCount ptr ds:[Count]).count_y
add eax,4 ; 每次递增4
mov (MyCount ptr ds:[Count]).count_y,eax
jmp S3
S2: mov eax,(MyCount ptr ds:[Count]).count_x
add eax,12 ; 每次递增12
mov (MyCount ptr ds:[Count]).count_x,eax
jmp S1
lop_end:
int 3
main ENDP
END main
结构体同样支持内嵌的方式,如下Rect指针中内嵌两个MyPoint分别指向左子域和右子域,这里顺便定义一个MyUnion联合体把,其使用规范与结构体完全一致,只不过联合体只能存储一个数据.
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
; 定义坐标结构
MyPoint Struct
pos_x DWORD ?
pos_y DWORD ?
pos_z DWORD ?
MyPoint ends
; 定义左右结构
Rect Struct
Left MyPoint <>
Right MyPoint <>
Rect ends
; 定义联合体
MyUnion Union
my_dword DWORD ?
my_word WORD ?
my_byte BYTE ?
MyUnion ends
.data
PointA Rect <>
PointB Rect {<10,20,30>,<100,200,300>}
test_union MyUnion {1122h}
szFmt BYTE '结构数据: %d',0dh,0ah,0
.code
main PROC
; 嵌套结构的赋值
mov dword ptr ds:[PointA.Left.pos_x],100
mov dword ptr ds:[PointA.Left.pos_y],200
mov dword ptr ds:[PointA.Right.pos_x],100
mov dword ptr ds:[PointA.Right.pos_y],200
; 通过地址定位
lea esi,dword ptr ds:[PointB]
mov eax,dword ptr ds:[PointB] ; 定位第一个MyPoint
mov eax,dword ptr ds:[PointB + 12] ; 定位第二个内嵌MyPoint
; 联合体的使用
mov eax,dword ptr ds:[test_union.my_dword]
mov ax,word ptr ds:[test_union.my_word]
mov al,byte ptr ds:[test_union.my_byte]
main ENDP
END main
当然有了结构体这一成员的加入，我们同样可以在汇编层面实现链表的定义与输出，如下代码所示，首先定义一个ListNode用于存储链表结构的数据域与指针域，接着使用TotalNodeCount定义链表节点数量，最后使用REPEAT伪指令开辟ListNode对象的多个实例，其中的NodeData域包含一个1-15的数据，后面的($ + Counter * sizeof ListNode)则是指向下一个链表的头指针，通过不断遍历则可输出整个链表。
.386p
.model flat,stdcall
option casemap:none
include windows.inc
include kernel32.inc
includelib kernel32.lib
include msvcrt.inc
includelib msvcrt.lib
ListNode Struct
NodeData DWORD ?
NextPtr DWORD ?
ListNode ends
TotalNodeCount = 15
Counter = 0
.data
LinkList LABEL PTR ListNode
REPEAT TotalNodeCount
Counter = Counter + 1
ListNode <Counter,($ + Counter * sizeof ListNode)>
ENDM
ListNode<0,0> ; 标志着结构链表的结束
szFmt BYTE '结构地址: %x 结构数据: %d',0dh,0ah,0
.code
main PROC
mov esi,offset LinkList
; 判断下一个节点是否为<0,0>
L1: mov eax,(ListNode PTR [esi]).NextPtr
cmp eax,0
je lop_end
; 显示节点数据
mov eax,(ListNode PTR [esi]).NodeData
invoke crt_printf,addr szFmt,esi,eax
; 获取到下一个节点的指针
mov esi,(ListNode PTR [esi]).NextPtr
jmp L1
lop_end:
int 3
main ENDP
END main
本文作者： 王瑞
本文链接： https://www.lyshark.com/post/e43f6d19.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
