Lea指令计算地址（用于四则混合运算），附上一个函数调用例子及其反汇编代码，很清楚

比如你用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\ChinaZip_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\ChinaZip_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

反汇编知识匮乏，目前只能到这步了，先混个脸熟。。。