一直对函数调用的具体汇编指令和各种变量在内存的具体分配，一知半解。各种资料都很详细，但是不实践，不亲自查看下内存总不能笃定。那就自己做下。
两个目的：
一，函数和函数调用编译后的汇编指令基本样貌
二，各种变量类型的内存状况。
二，各种变量类型的内存状况。
1)常见变量在内存的位置
2)自定义结构体
1)，常见变量在内存的位置。
结论：全局变量：程序一加载，和代码一样，已经在内存，放入静态区。
未初始化，内存数据用00或默认直代替。
地址变量（指针类型）放入地址直。
未初始化放入0x00000000.
局部变量： int 和char 等基本类型，程序加载时，不放入任何地方。
只有通过代码才能知道定义了一个变量。
运行代码时 push 1，放入栈中，通过 ebp+x等方式获取。
而int[5] 和char[5] 类拭固定大小数据，一般是放入静态区，编译器在编译阶段已经把使用变量的地方用 变量的偏移地址代替了。如果函数没使用，直接作为其他函数的参数，那也会直接push。不放入静态区，如下例的 p_char2[5]。
不是固定大小的变量放入，如指针，放入静态区。。等等，如果中途改变大小呢，怎么办？等下测试。测试发现会有2个临时变量名。
char * p_char3="hi.";
int p_int2[5]={1,2,3,4,5};
p_char3="hihi.";
LC2:
DB "hihi.",0x00
LC0:
DB "hi.",0x00
代码
int g_int1=3;//静态区.装载程序时已经放入内存
int g_int2;//静态区.装载程序时已经放入内存(放在 char * p_char3="hi."的后面).用4个字节的0来占位。
int HariMain(void)
{
int p_int=1;//代码没有执行，不存在任何地方，执行后，push 1,放入栈中。
char p_char=‘a‘;// 代码没有执行，不存在任何地方，执行后，push 1,放入栈中。
char p_char2[5]={‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};//
//代码没有执行，不存在任何地方，执行后，用mov指令放入栈.
//mov BYTE [-56+EBP],97
char
* p_char3="hi.";//静态区. 装载程序时已经放入内存
int p_int2[5]={1,2,3,4,5};//静态区. 装载程序时已经放入内存
unsigned int sum;
sum=count(p_int,p_char,p_char2,p_char3,p_int2);
sum+=g_int1;
sum+=g_int2;
}
unsigned int count(int a,char c1,char c2[5],char * c3,int i2[5])
{
unsigned int c;
c=0;
c+=a;
c=c+c1;
c+=c2[0];
c+=c2[3];
c+=i2[0];
c+=i2[4];
c+=c3[0];
c+=c3[1];
return c;
}
数据 在内存的位置
程序装载时,
//代码区 0x0028001b
//
//^
//栈顶(空栈) 0x00310000
//静态区 0x00310000
程序运行时
//代码区 0x0028001b
/
//(栈顶)被调者的临时变量
//被调者的局部变量
//调用前的ebp寄存器直(而当前的ebp寄存器存放的这个位置的地址)
//返回地址
//参数
//栈底(空栈) 0x00310000
//静态区 0x00310000
二，自定义结构体
结论：自定义结构，可以看作数组。
自定义结构，作为参数的话，会把所有成员变量，一个一个入栈
如果 传递自定义结构指针，那么只传地址。
//全局自定义结构体变量, 和全局定长数组类拭。
程序一加载，和代码一样，已经在内存，放入静态区。
未初始化放入00数据,
代码中出现变量名，用地址代替。[_struce_a]
赋直：
MOV BYTE [_myStruck_a+4],97
直接 地址+数字定位成员
全局自定义结构体地址变量(指针),
程序一加载，和代码一样，已经在内存，放入静态区。
但是大小不是struck的大小，而是4B，也就是一个地址变量的大小。
未初始化放入0x00000000.
赋直：
MOV EDX,DWORD [_myStruck_c]
MOV DWORD [8+EDX],3
必须取地址的直得到真正的地址再加数字定位成员
//局部变量,
程序一加载，不存在任何地方。
只有运行时，放入栈中。如：
struct myStruck myStruck_d;
编译为SUB ESP,60
myStruck_d.char_b=‘e‘
编译为
MOV BYTE [-36+EBP],101
call 之后的栈数据.
struct myStruck{
int int_a;
char char_b;
int int_array[2];
char * char_array;
};
int HariMain(void)
{
char c1[2]={‘b‘,‘c‘};
//myStruck_a.int_a=1;
myStruck_a.char_b=‘a‘;//MOV BYTE [_myStruck_a+4],97
myStruck_a.int_array[0]=1;//MOV DWORD [_myStruck_a+8],1
myStruck_a.int_array[1]=2;//MOV DWORD [_myStruck_a+12],2
//myStruck_a.char_array=c1;
//MOV EAX,DWORD [_myStruck_c]
myStruck_c->int_a=2;//MOV DWORD [EAX],2
myStruck_c->char_b=‘c‘;//MOV BYTE [4+EAX],99
//MOV EDX,DWORD [_myStruck_c]
myStruck_c->int_array[0]=3;//MOV DWORD [8+EDX],3
myStruck_c->int_array[1]=4;//MOV DWORD [12+EDX],4
myStruck_c->char_array=c1;//LEA EAX,DWORD [-42+EBP] MOV DWORD [16+EDX],EAX
//MOV EBP,ESP
//SUB ESP,60
struct myStruck myStruck_d;
myStruck_d.char_b=‘e‘;//MOV BYTE [-36+EBP],101
myStruck_d.int_array[0]=5;//MOV DWORD [-32+EBP],5
myStruck_d.int_array[1]=6;//MOV DWORD [-28+EBP],6
unsigned int c=counta(myStruck_a,myStruck_c,myStruck_d);
io_hlt();
return 0;
}
unsigned int counta(struct myStruck mys,struct myStruck * mysc,struct myStruck mys2)
{
unsigned int c;
c=0;
c=mys.int_a;
c=c+mysc->int_a;//ADD EAX,DWORD [8+EBP]
c=c+mysc->char_array[0];//MOV EDX,DWORD [28+EBP] MOV EDX,DWORD [16+EDX] ADD EAX,EDX //char_array[0]
c=c+mys.char_array[0];//
c=c+mys2.int_a;
return c;
}