你的变量究竟存储在什么地方 && 全局内存

我相信大家都有过这样的经历，在面试过程中，考官通常会给你一道题目，然后问你某个变量存储在什么地方，在内存中是如何存储的等等一系列问题。不仅仅是在面试中，学校里面的考试也会碰到同样的问题。

 如果你还不知道答案，请接着往下看。接下来，我们将在Linux操作系统上，以GCC编译器为例来讲解变量的存储。

 在计算机系统中，目标文件通常有三种形式：

1. 可重定位的目标文件：包含二进制代码和数据，与其他可重定位目标文件合并起来，创建一个可执行目标文件。

2. 可执行的目标文件：包含二进制代码和数据，其形式可以被直接拷贝到存储器中并执行

3. 共享目标文件：一种特殊的可重定位目标文件，即我们通常所说的动（静）态链接库

一个典型的可重定位目标文件如下图所示：

 高地址

节头部表

.strtab

.line

.debug

.rel.data

.rel.text

.symtab

.bss

>        .dataa （3）

.rodata

>        .textt （1）

ELF头

>                                                                        0

图 1典型的ELF可重定位目标文件（数字代表索引）

 夹在ELF头和节头部表之间的都是节（section），各个节的意思如下：

节	含义
.text	已编译程序的机器代码
.rodata	只读数据，如pintf和switch语句中的字符串和常量值
.data	已初始化的全局变量
.bss	未初始化的全局变量
.symtab	符号表，存放在程序中被定义和引用的函数和全局变量的信息
.rel.text	当链接器吧这个目标文件和其他文件结合时，.text节中的信息需修改
.rel.data	被模块定义和引用的任何全局变量的信息
.debug	一个调试符号表。
.line	原始C程序的行号和.text节中机器指令之间的映射
.strtab	一个字符串表，其内容包含.systab和.debug节中的符号表

 对于static类型的变量，gcc编译器在.data和.bss中为每个定义分配空间，并在.symtab节中创建一个有唯一名字的本地链接器符号。对于malloc而来的变量存储在堆（heap）中，局部变量都存储在栈（stack）中。

 下面我们以实际的例子来分析变量的存储：

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

 

int z = 9;

int a;

static int b =10;

static int c;

void swap(int* x,int* y)

{

int temp;

temp=*x;

*x=*y;

*y=temp;

} 

 

int main()

{

int x=4,y=5;

swap(&x,&y);

printf(“x=%d,y=%d,z=%d,w=%dn”,x,y,z,b);

return 0;

} 

 根据以上题目和理论知识，我们可以推断出：

变量	存储区域
a	.bss
b	.data
c	.bss
x	stack
y	stack
temp	stack
z	.data
swap	.text
main	.text
x=……	.rodata

 我们将从汇编代码和符号表中来分析以上答案是否正确。我们首先来看该程序的汇编代码：

>   >    .filee "var.c"

.globl z

>       .dataa     #数据段

>       .align 4

>       .typee       z, @object

>       .size z, 4

z:

>       .longg       9

>       .align 4

>       .typee       b, @object

>       .size b, 4

b:

>       .longg       10

>       .textt     #代码段

.globl
swap

>       .typee       swap, @function

swap:

>       pushll       %ebp

>       movll       %esp, %ebp

>       subl $4, %esp

>       movll       8(%ebp), %eax

>       movll       (%eax), %eax

>       movll       %eax, -4(%ebp)

>       movll       8(%ebp), %edx

>       movll       12(%ebp), %eax

>       movll       (%eax), %eax

>       movll       %eax, (%edx)

>       movll       12(%ebp), %edx

>       movll       -4(%ebp), %eax

>       movll       %eax, (%edx)

>       leave

>       ret

>       .size swap, .-swap

>       .sectionn   .rodataa     #只读段

.LC0:

>       .stringg     "x=%d,y=%d,z=%d,w=%dn"

>      
.textt           #代码段

.globl
main

>       .typee       main, @function

main:

>       pushll       %ebp

>       movll       %esp, %ebp

>       subl $40, %esp

>       andl $-16, %esp

>       movll       $0, %eax

>       subl %eax, %esp

>       movll       $4, -4(%ebp)

>       movll       $5, -8(%ebp)

>       leall   -8(%ebp), %eax

>       movll       %eax, 4(%esp)

>       leall   -4(%ebp), %eax

>       movll       %eax, (%esp)

>       calll swap

>       movll       b, %eax

>       movll       %eax, 16(%esp)

>       movll       z, %eax

>       movll       %eax, 12(%esp)

>       movll       -8(%ebp), %eax

>       movll       %eax, 8(%esp)

>       movll       -4(%ebp), %eax

>       movll       %eax, 4(%esp)

>       movll       $.LC0, (%esp)

>       calll printf

>       movll       $0, %eax

>       leave

>       ret

>       .size main, .-main

>      
.commm    a,4,4

>       .locall       c

>       .commm    c,4,4

>       .sectionn   .note.GNU-stack,"",@progbits

>       .identt      "GCC: (GNU) 3.3.5 (Debian 1:3.3.5-13)"

 通过以上汇编代码可以发现，z和b在.data段，main和swap在.text段，a和c在.bss段，x,y,temp在stack中，printf函数所打印的字符串在.rodata中。

 下面我们在通过符号表来解释变量的存储。

 每个可重定位目标文件都有一个符号表，它包含该文件所定义和引用的符号的信息。在链接器的上下文中，有三种不同的符号：

1. 由该文件定义并能被其他模块引用的全局符号。即非静态的C函数和非静态的全局变量，如程序中的a,z,swap。

2. 由其他模块定义并被该文件引用的全局符号。用extern关键字所定义的变量和函数。

3. 只被该文件定义和引用的本地符号。用static关键字定义的函数和变量。如程序中的b和c。

该程序所对应的符号表如图所示：

图 2符号表

首先，我们解释上图中各字段的含义：

字段名	含义
Num	序号
Value	符号地址。 可重定位目标文件：距定义目标文件的节的起始位置的偏移 可执行目标文件：一个绝对运行的地址
Size	目标的大小
Type	要么是数据，要么是函数，或各个节的表目
Bind	符号是全局的还是本地的
Vis	目前还没有查到资料，待以后改正
Ndx	通过索引来表示每个节 ABS：不该被重定位的符号 UND：代表未定义的符号（在其他地方定义） COM：未初始化的数据目标
Name	指向符号的名字

 对 于变量b和z，Ndx索引为3，我们观察图1，不难发现索引3对应的是.data段。变量c对应的索引为4（.bss段），变量a对应的索引是COM，最 终当该程序被链接时，它将做为一个.bss目标分配。我们从反汇编代码中，对于变量a和c都是.comm（反汇编代码中以“.”开头的行，是指导汇编器和 链接器运行的命令）：

>        ……

 .commm    a,4,4

>       .locall       c

>       .commm    c,4,4

>       ……

注 意：a所对应的Bind为GLOBAL，即为全局变量，虽然变量c也在.bss段中，但Bind却是LOCAL，则为本地变量。.data段中的变量b和 c也是类似的情况。swap和main都在索引1所对应的.text段中。由于printf是在库中所定义的，所以索引为UND。

 符号表中不包含对应于本地非静态程序变量中的任何符号。这些符号是在栈中被管理的，所以符号表中没有出现x,y,temp符号。

 相信大家读完这篇文章以后，再也用不着对类似的题目胆战心惊了。



------------------------------------------------------------------------------------------------------------------

大内高手—全局内存

转载时请注明出处和作者联系方式：http://blog.csdn.net/absurd

作者联系方式：李先静 <xianjimli at hotmail dot com>

更新时间：2007-7-9

有 人可能会说，全局内存就是全局变量嘛，有必要专门一章来介绍吗？这么简单的东西，还能玩出花来？我从来没有深究它，不一样写程序吗？关于全局内存这个主题 虽然玩不出花来，但确实有些重要，了解这些知识，对于优化程序的时间和空间很有帮助。因为有好几次这样经历，我才决定花一章篇幅来介绍它。

正如大家所知道的，全局变量是放在全局内存中的，但反过来却未必成立。用static修饰的局部变量就是放在放全局内存的，它的作用域是局部的，但生命期是全局的。在有的嵌入式平台中，堆实际上就是一个全局变量，它占用相当大的一块内存，在运行时，把这块内存进行二次分配。

这里我们并不强调全局变量和全局内存的差别。在本文中，全局强调的是它的生命期，而不是它的作用域，所以有时可能把两者的概念互换。

一般来说，在一起定义的两个全局变量，在内存的中位置是相邻的。这是一个简单的常识，但有时挺有用，如果一个全局变量被破坏了，不防先查查其前后相关变量的访问代码，看看是否存在越界访问的可能。

在ELF格式的可执行文件中，全局内存包括三种：bss、data和rodata。其它可执行文件格式与之类似。了解了这三种数据的特点，我们才能充分发挥它们的长处，达到速度与空间的最优化。

1.        
bss

已经记不清bss代表Block
Storage Start还是Block Started by Symbol。像这我这种没有用过那些史前计算机的人，终究无法明白这样怪异的名字，也就记不住了。不过没有关系，重要的是，我们要清楚bss全局变量有什么样特点，以及如何利用它。

通俗的说，bss是指那些没有初始化的和初始化为0的全局变量。它有什么特点呢，让我们来看看一个小程序的表现。

int
bss_array[1024 * 1024] = {0};

int
main(int
argc,
char*
argv[])

{

return 0;

}

[root@localhost
bss]# gcc -g
bss.c -o bss.exe

[root@localhost
bss]# ll

total 12

-rw-r--r-- 1
root
root  
84 Jun 22 14:32 bss.c

-rwxr-xr-x
1 root
root
5683
Jun 22 14:32 bss.exe

变量bss_array的大小为4M，而可执行文件的大小只有5K。
由此可见，bss类型的全局变量只占运行时的内存空间，而不占文件空间。

另外，大多数操作系统，在加载程序时，会把所有的bss全局变量全部清零，无需要你手工去清零。但为保证程序的可移植性，手工把这些变量初始化为0也是一个好习惯。

2.        
data

与bss相比，data就容易明白多了，它的名字就暗示着里面存放着数据。当然，如果数据全是零，为了优化考虑，编译器把它当作bss处理。通俗的说，data指那些初始化过（非零）的非const的全局变量。它有什么特点呢，我们还是来看看一个小程序的表现。

int
data_array[1024 * 1024] = {1};

int
main(int
argc,
char*
argv[])

{

return 0;

}

[root@localhost
data]# gcc
-g
data.c -o
data.exe

[root@localhost
data]# ll

total 4112

-rw-r--r-- 1
root
root     
85 Jun 22 14:35
data.c

-rwxr-xr-x
1 root
root
4200025
Jun 22 14:35
data.exe

仅仅是把初始化的值改为非零了，文件就变为4M多。由此可见，data类型的全局变量是即占文件空间，又占用运行时内存空间的。

3.        
rodata

rodata的意义同样明显，ro代表read
only，即只读数据(const)。关于rodata类型的数据，要注意以下几点：

l        
常量不一定就放在rodata里，有的立即数直接编码在指令里，存放在代码段(.text)中。

l        
对于字符串常量，编译器会自动去掉重复的字符串，保证一个字符串在一个可执行文件(EXE/SO)中只存在一份拷贝。

l        
rodata是在多个进程间是共享的，这可以提高空间利用率。

l        
在有的嵌入式系统中，rodata放在ROM(如norflash)里，运行时直接读取ROM内存，无需要加载到RAM内存中。

l        
在嵌入式linux系统中，通过一种叫作XIP（就地执行）的技术，也可以直接读取，而无需要加载到RAM内存中。

由此可见，把在运行过程中不会改变的数据设为rodata类型的，是有很多好处的：在多个进程间共享，可以大大提高空间利用率，甚至不占用RAM空间。同时由于rodata在只读的内存页面(page)中，是受保护的，任何试图对它的修改都会被及时发现，这可以帮助提高程序的稳定性。

4.        
变量与关键字

static关键字用途太多，以致于让新手模糊。不过，总结起来就有两种作用，改变生命期和限制作用域。如：

l        
修饰inline函数：限制作用域

l        
修饰普通函数：限制作用域

l        
修饰局部变量：改变生命期

l        
修饰全局变量：限制作用域

const
关键字倒是比较明了，用const修饰的变量放在rodata里，字符串默认就是常量。对const，注意以下几点就行了。

l        
指针常量：指向的数据是常量。如 const char* p = “abc”; p指向的内容是常量
，但p本身不是常量，你可以让p再指向”123”。

l        
常量指针：指针本身是常量。如：char* const p = “abc”; p本身就是常量，你不能让p再指向”123”。

l        
指针常量 +
常量指针：指针和指针指向的数据都是常量。const char* const p =”abc”;
两者都是常量，不能再修改。

violatile关键字通常用来修饰多线程共享的全局变量和IO内存。告诉编译器，不要把此类变量优化到寄存器中，每次都要老老实实的从内存中读取，因为它们随时都可能变化。这个关键字可能比较生僻，但千万不要忘了它，否则一个错误让你调试好几天也得不到一点线索。