C语言逆向分析语法超详细分析

int tmp = 10；
int* a = &tmp;
(*a)+=1;
对应的汇编简单来写如下：
mov dword ptr [esp],0Ah;           将10存在栈中
lea eax,[esp]						取得tmp所在的地址
mov dword ptr [esp-4],eax					将tmp所在的地址存储到栈中
mov ecx,dword ptr [esp-4]					取出tmp所在的地址
mov ecx,dword ptr [eax]
add dword ptr ecx,1								将tmp所在地址所指向的内容加一
mov dword ptr[eax],ecx

int tmp = 10；
int& a = &tmp;
a+=1;
对应的汇编简单来写如下：
mov dword ptr [esp],0Ah;           将10存在栈中
lea eax,[esp]						取得tmp所在的地址
mov dword ptr [esp-4],eax					将tmp所在的地址存储到栈中
mov ecx,dword ptr [esp-4]					取出tmp所在的地址
mov ecx,dword ptr [eax]
add dword ptr ecx,1								将tmp所在地址所指向的内容加一
mov dword ptr[eax],ecx

int tmp = 10；
int* a = &tmp;
a++；
对应的汇编简单来写如下：
mov dword ptr [esp],0Ah;           将10存在栈中
lea eax,[esp]						取得tmp所在的地址
mov dword ptr [esp-4],eax					将tmp所在的地址存储到栈中
mov eax,dword ptr [esp-4]		
add eax,4												此时加的不在是1而是当前指针所表示类型的大小
mov dowrd ptr [esp-4],eax

int test(int a,int b){
	return a+b;
}
int _tmain(int argc, _TCHAR* argv[])
{
	int a=10,b=1;
	int res = test(a,b);
	printf("%d",res);
	return 0;
}
简单汇编代码：
int test(int a,int b){
009D1A50  push        ebp  								//同样是保存和初始化堆栈
009D1A51  mov         ebp,esp 
009D1A53  sub         esp,0C0h 
009D1A59  push        ebx  
009D1A5A  push        esi  
009D1A5B  push        edi  
009D1A5C  lea         edi,[ebp-0C0h] 			
009D1A62  mov         ecx,30h 
009D1A67  mov         eax,0CCCCCCCCh 
009D1A6C  rep stos    dword ptr es:[edi] 
	return a+b;
009D1A6E  mov         eax,dword ptr [a] 		//取出将a，b做合
009D1A71  add         eax,dword ptr [b] 		//此处的a是ebp+4h，b是ebp+8h
}
009D1A74  pop         edi  
009D1A75  pop         esi  
009D1A76  pop         ebx  
009D1A77  mov         esp,ebp 
009D1A79  pop         ebp  									//回退堆栈
009D1A7A  ret     													//返回
int _tmain(int argc, _TCHAR* argv[])
{
009D1AF0  push        ebp  								//保存ebp
009D1AF1  mov         ebp,esp 						//将栈底指向当前栈顶
009D1AF3  sub         esp,0E4h 						//提升堆栈
009D1AF9  push        ebx  								//保存寄存器
009D1AFA  push        esi  
009D1AFB  push        edi  
009D1AFC  lea         edi,[ebp-0E4h] 			//初始化堆栈内容
009D1B02  mov         ecx,39h 
009D1B07  mov         eax,0CCCCCCCCh 
009D1B0C  rep stos    dword ptr es:[edi] 
	int a=10,b=1;														//这里开始进入我们在main中写的代码
009D1B0E  mov         dword ptr [a],0Ah 	//a其实是ebp-4h，这里将10存入到ebp-4，也就是栈底的第																							一个4字节内存
009D1B15  mov         dword ptr [b],1 		//这里同上b是ebp-8h，将1放入栈底开始的第二个4字节中
	int res = test(a,b);										//下面要注意，下面压栈是从esp开始压栈，前面的通过ebp																					所操作的赋值语句是将内容存放到开始提升堆栈所占有的内存
009D1B1C  mov         eax,dword ptr [b] 	//这里是取出1到eax
009D1B1F  push        eax  								//将eax压栈
009D1B20  mov         ecx,dword ptr [a] 	//取出10到ecx
009D1B23  push        ecx  								//ecx压栈
009D1B24  call        func (9D126Ch) 			//调用我们的test方法此时可以看做一个																														jmp详细的后续再讲
009D1B29  add         esp,8 							//平衡传入参数时提升的堆栈
009D1B2C  mov         dword ptr [res],eax //eax便是返回值
	printf("%d",res);
009D1B2F  mov         esi,esp 
009D1B31  mov         eax,dword ptr [res] 
009D1B34  push        eax  
009D1B35  push        offset string "%d" (9D774Ch) 
009D1B3A  call        dword ptr [__imp__printf (9DA40Ch)] 
009D1B40  add         esp,8 
009D1B43  cmp         esi,esp 
009D1B45  call        @ILT+435(__RTC_CheckEsp) (9D11B8h) 
	return 0;
009D1B4A  xor         eax,eax 
}

struct test_struct{
	int a;
	char b;
	int c;
};
int _tmain(int argc, _TCHAR* argv[])
{
	struct test_struct s;
	s.a = 10;
	s.b = 11;
	s.c = 12;
	test(&s);
	return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
。。。。。。。
	struct test_struct s;
	s.a = 10;
00E524DE  mov         dword ptr [s],0Ah 			//这里的s可以简单看为ebp-4
	s.b = 11;
00E524E5  mov         byte ptr [ebp-0Ch],0Bh 
	s.c = 12;
00E524E9  mov         dword ptr [ebp-8],0Ch 
	test(&s);
00E524F0  lea         eax,[s] 						//lea为取地址的指令，前面我们也遇到过
00E524F3  push        eax  								//将这个地址作为参数传递
00E524F4  call        test (0E511B8h) 
00E524F9  add         esp,4 
	return 0;
00E524FC  xor         eax,eax 
。。。。。
}

class test_struct{
public:
	int a;
	char b;
	int c;
};
void test(test_struct* s){
	printf("%d",s->a);
}
int _tmain(int argc, _TCHAR* argv[])
{
	test_struct s;
	s.a = 10;
	s.b = 11;
	s.c = 12;
	test(&s);
	return 0;
}

class test_struct{
public:
	int a;
	char b;
	int c;
	
	void test(test_struct* s){
	printf("%d",s->a);
}
};
int _tmain(int argc, _TCHAR* argv[])
{
	test_struct s;
	s.a = 10;
	s.b = 11;
	s.c = 12;
	s.test(&s);
	return 0;
}
汇编只看main这部分的代码
  int _tmain(int argc, _TCHAR* argv[])
{
。。。。。
	test_struct s;
	s.a = 10;
00D3339E  mov         dword ptr [s],0Ah 
	s.b = 11;
00D333A5  mov         byte ptr [ebp-0Ch],0Bh 
	s.c = 12;
00D333A9  mov         dword ptr [ebp-8],0Ch 
	s.test(&s);
00D333B0  lea         eax,[s] 
00D333B3  push        eax  
00D333B4  lea         ecx,[s] 
00D333B7  call        test_struct::test (0D311D6h) 
	return 0;
00D333BC  xor         eax,eax 
  。。。。。。。。
}