比如你用local在栈上定义了一个局部变量LocalVar，你知道实际的指令是什么么？一般都差不多像下面的样子：
push ebp
mov esp, ebp
sub esp, 4
现在栈上就有了4各字节的空间，这就是你的局部变量。
接下来，你执行mov LocalVar, 4，那么实际的指令又是什么？是这样：
mov dword ptr [ebp-4]， 4
于是，这个局部变量的“地址”就是ebp-4——显然，它不是一个固定的地址。现在需要将它的“地址”作为参数传给某个函数，你这样写：
invoke/call SomeFunc, addr LocalVar
实际生成的指令是：
lea eax, [ebp-4]
push eax
call SomeFunc
当然，你也可以写成：
mov eax, ebp
sub eax, 4
push eax
call SomeFunc
看到了，这里多了一条指令。这就是lea的好处。于是，lea又多了一个非常美妙的用途：作简单的算术计算，特别是有了32位指令的增强寻址方式，更是“如虎添翼”：
比如你要算EAX*4+EBX+3，结果放入EDX，怎么办？
mov edx, eax
shl edx, 2
add edx, ebx
add edx, 3
现在用lea一条指令搞定：
lea edx, [ebx+eax*4+3] // 相当于 lea edx, [eax*4+ebx+3]，这里完全与内存地址无关
lea的英文解释是： Load Effective Address.（加入有效地址，开始迷惑效地址是什么？？？既然是有效地址与mov ax , [address] 又有什么不同呢？其实他们都是等效的。 后来知道实际上是一个偏移量可以是立即数，也可以是经过四则运算的结果，更省空间，更有效率）
参考：
http://blog.csdn.net/lostspeed/article/details/8959142
http://www.cnitblog.com/textbox/articles/51912.html
-------------------------------------------------------------------------------
亲自花了两小时研究一个小例子，VC6 Debug版本：
源程序：
#include "stdafx.h" int add(int i)
{
int x = i+;
return x;
} int fun()
{
int i=;
return add(i);
} int main()
{
int y = fun();
return y;
}
汇编程序：
// 知识点：
// ESP：寄存器存放当前线程的栈顶指针（堆栈指针），压入堆栈的数据越多，ESP也就越来越小，用它只可访问栈顶
// EBP：寄存器存放当前线程的栈底指针（基址指针，base pointer），用它可直接存取堆栈中的数据
// __cdecl 所有参数从右到左依次入栈，这些参数由调用者清除，称为手动清栈 // 编译器提前生成的函数跳转代码，一共3个函数，地址准确对应：
@ILT+(?add@@YAHH@Z):
jmp add () // 执行前 ESP = 0012FED0
// 执行后 ESP = 0012FED0 无条件跳转，不需要压栈
@ILT+(?fun@@YAHXZ):
0040100A jmp fun ()
@ILT+(_main):
0040100F jmp main (004010c0) int add(int i)
{
push ebp // 执行前 ESP = 0012FED0 EBP = 0012FF28
// 执行后 ESP = 0012FECC EBP = 0012FF28 （ESP减少4，第二次偏移）
mov ebp,esp // 执行后 ESP = 0012FECC EBP = 0012FECC （保护esp的值，这样esp可随便使用了）
sub esp,44h // 执行后 ESP = 0012FE88 EBP = 0012FECC 给栈增加44h的空间
push ebx // 执行后 ESP = 0012FE84
push esi // 执行后 ESP = 0012FE80
push edi // 执行后 ESP = 0012FE7C
lea edi,[ebp-44h] // 执行后 EDI = 0012FE88
0040103C mov ecx,11h
mov eax,0CCCCCCCCh
rep stos dword ptr [edi] int x = i+;
mov eax,dword ptr [ebp+] // 执行前 EBP = 0012FECC，执行 EBP + = 0012FED4，就取到了fun函数压栈的数据
0040104B add eax, // 前面call的时候导致了两次减4，所以要加8。此时用EBP访问数据。此时eax也是空闲的
0040104E mov dword ptr [ebp-],eax // 把eax的值放到[ebp-]里，相当于为x赋值了
return x;
mov eax,dword ptr [ebp-] // 函数的返回值为eax
}
pop edi
pop esi
pop ebx
mov esp,ebp // 恢复ESP，即退出函数前，栈顶指针不变
pop ebp // 恢复EBP，站底指针
0040105A ret
// 这里不用加44，因为add没有调用其它函数 int fun()
{
push ebp
mov ebp,esp
sub esp,44h
push ebx
push esi
push edi
lea edi,[ebp-44h]
0040107C mov ecx,11h
mov eax,0CCCCCCCCh
rep stos dword ptr [edi] int i=;
mov dword ptr [ebp-],0Ah // i是函数内第一个局部变量，占据了[ebp-]的位置，因此把0Ah这个值放里
: return add(i);
0040108F mov eax,dword ptr [ebp-] // 把这个i局部变量的值，临时放到eax里，目的是为了方便压栈
push eax // 准备调用add函数，要给它准备所有参数，即把i的值压栈(cdeclf方式)。
// 执行前 ESP = 0012FED8 EBP = 0012FF28
// 执行后 ESP = 0012FED4 EBP = 0012FF28 （ESP减少4）
// 注意，ESP的值在整个CPU里是唯一的，各个函数之间会相互影响（特别是cdecl调用方式下），push会导致ESP的值减4（可观察CPU状态）
call @ILT+(add) () // 执行前 ESP = 0012FED4 EBP = 0012FF28
// 执行后 ESP = 0012FED0 EBP = 0012FF28 （ESP减少4，第一次偏移。call语句自动就包括了压栈功能）
// 一共两次减小4
add esp,
}
0040109B pop edi
0040109C pop esi
0040109D pop ebx
0040109E add esp,44h // 调用者清除，对应add函数造成的esp减少了44
004010A1 cmp ebp,esp
004010A3 call __chkesp ()
004010A8 mov esp,ebp
004010AA pop ebp
004010AB ret int main()
{
int y = fun();
004010D8 call @ILT+(fun) (0040100a) // 呼叫语句，执行fun函数。此函数执行完毕后，会把运算结果放在eax里。
004010DD mov dword ptr [ebp-],eax // 本地变量y占据了[ebp-4]的位置，所以需要把前面函数的执行结果eax放到这个位置
return y;
004010E0 mov eax,dword ptr [ebp-] // 把[ebp-]的值放到eax里，相当于main函数的返回值已经在eax里了
}
004010E3 pop edi
004010E4 pop esi
004010E5 pop ebx
004010E6 add esp,44h // 调用者清除，对应fun函数造成的esp减少了44
004010E9 cmp ebp,esp
004010EB call __chkesp ()
004010F0 mov esp,ebp
004010F2 pop ebp
004010F3 ret
不知道release版本有没有这个ESP-44的问题，之所以花了2小时，就是因为这个原因。可是VC++为什么要这样做呢？难道是为了给调用函数的时候，留出足够的栈空间（够放10个参数了，另一个4字节空间是被调用函数自己造成的）？
----------------------------------------------------------------------------------
再接再厉，使用W32Dasm反汇编并精简之后得到的代码（VC自身也可看Release版的汇编源码）：
Disassembly of File: C:\Dev\*p_Crack\Tools\w32dasm\lll_cdcel.exe
Code Offset = , Code Size =
Data Offset = , Data Size = Number of Objects = (dec), Imagebase = 00400000h Object01: .text RVA: Offset: Size: Flags:
Object02: .rdata RVA: Offset: Size: Flags:
Object03: .data RVA: Offset: Size: Flags: C0000040 +++++++++++++++++++ IMPORT MODULE DETAILS +++++++++++++++ Import Module : KERNEL32.dll // 导入系统API地址，地址都很小，低于0x004000000 Addr:000054F8 hint(00CA) Name: GetCommandLineA
Addr:0000550A hint() Name: GetVersion
Addr: hint(007D) Name: ExitProcess
Addr: hint(029E) Name: TerminateProcess
Addr:0000553A hint(00F7) Name: GetCurrentProcess
Addr:000056D6 hint(00BF) Name: GetCPInfo
Addr:000056E2 hint(00B9) Name: GetACP
Addr:000056EC hint() Name: GetOEMCP
Addr:000056F8 hint(02BB) Name: VirtualAlloc
Addr: hint(01A2) Name: HeapReAlloc
Addr: hint(013E) Name: GetProcAddress
Addr: hint(01C2) Name: LoadLibraryA
Addr: hint(01E4) Name: MultiByteToWideChar
Addr:0000574E hint(01BF) Name: LCMapStringA
Addr:0000575E hint(01C0) Name: LCMapStringW
Addr:0000576E hint() Name: GetStringTypeA
Addr: hint() Name: GetStringTypeW +++++++++++++++++++ ASSEMBLY CODE LISTING ++++++++++++++++++
//********************** Start of Code in Object .text **************
Program Entry Point = (C:\Dev\*p_Crack\Tools\w32dasm\lll_cdcel.exe File Offset:) // 估计是 int add(int i) : 8B442404 mov eax, dword ptr [esp+]
: 83C004 add eax,
: C3 ret * Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:(U) // 估计是 int fun() : 6A0A push 0000000A
: E8E9FFFFFF call
: 83C404 add esp,
:0040101A C3 ret * Referenced by a CALL at Address:
|:004010DF : E9EBFFFFFF jmp 00401010 // 一句单独的跳转语句（准备跳转到fun函数），main函数就是靠它调用fun函数 //******************** Program Entry Point ********
// 估计是 int main()，那么多前期准备！！！ : push ebp
: 8BEC mov ebp, esp
: 6AFF push FFFFFFFF
: 68A0504000 push 004050A0
:0040103A 688C1C4000 push 00401C8C
:0040103F 64A100000000 mov eax, dword ptr fs:[]
: push eax
: mov dword ptr fs:[], esp
:0040104D 83EC10 sub esp,
: push ebx
: push esi
: push edi
: 8965E8 mov dword ptr [ebp-], esp * Reference To: KERNEL32.GetVersion, Ord:0174h
|
: FF1504504000 Call dword ptr []
:0040105C 33D2 xor edx, edx
:0040105E 8AD4 mov dl, ah
: 8915E4844000 mov dword ptr [004084E4], edx
: 8BC8 mov ecx, eax
: 81E1FF000000 and ecx, 000000FF
:0040106E 890DE0844000 mov dword ptr [004084E0], ecx
: C1E108 shl ecx,
: 03CA add ecx, edx
: 890DDC844000 mov dword ptr [004084DC], ecx
:0040107F C1E810 shr eax,
: A3D8844000 mov dword ptr [004084D8], eax
: 6A00 push
: E8A80A0000 call 00401B36
:0040108E pop ecx
:0040108F 85C0 test eax, eax
: jne 0040109B
: 6A1C push 0000001C
: E89A000000 call
:0040109A pop ecx * Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:(C)
|
:0040109B 8365FC00 and dword ptr [ebp-],
:0040109F E872070000 call * Reference To: KERNEL32.GetCommandLineA, Ord:00CAh
|
:004010A4 FF1500504000 Call dword ptr []
:004010AA A3D8894000 mov dword ptr [004089D8], eax
:004010AF E830060000 call 004016E4
:004010B4 A3C0844000 mov dword ptr [004084C0], eax
:004010B9 E8D9030000 call
:004010BE E81B030000 call 004013DE
:004010C3 E890000000 call
:004010C8 A1F4844000 mov eax, dword ptr [004084F4]
:004010CD A3F8844000 mov dword ptr [004084F8], eax
:004010D2 push eax
:004010D3 FF35EC844000 push dword ptr [004084EC]
:004010D9 FF35E8844000 push dword ptr [004084E8]
:004010DF E83CFFFFFF call // 估计是调用fun()函数
:004010E4 83C40C add esp, 0000000C
:004010E7 8945E4 mov dword ptr [ebp-1C], eax
:004010EA push eax
:004010EB E895000000 call
:004010F0 8B45EC mov eax, dword ptr [ebp-]
:004010F3 8B08 mov ecx, dword ptr [eax]
:004010F5 8B09 mov ecx, dword ptr [ecx]
:004010F7 894DE0 mov dword ptr [ebp-], ecx
:004010FA push eax
:004010FB push ecx
:004010FC E859010000 call 0040125A
: pop ecx
: pop ecx
: C3 ret
反汇编知识匮乏，目前只能到这步了，先混个脸熟。。。