gcc代码反汇编查看内存分布[1]: gcc

# gcc -v
gcc version 4.4.5 (Ubuntu/Linaro 4.4.4-14ubuntu5)

重点:

　　代码中的内存分配, 地址从低到高: 代码段(RO, 保存函数代码) --> 只读数据段(RO, 保存常量) --> 数据段(RW, 已初始化并且初始值不为0的全局变量和静态变量) -->bss段(RW,  未初始化或者初始化为0的全局变量和静态变量).

　　程序运行起来之后, 堆区和栈区的变量地址是动态分配的.

#include<stdio.h>
#include<stdlib.h>

int global_ni;        // .bss
int global_iz =  ; // .bss

int global_inz = ; // .data

const int global_const0 = ;
const int global_const1 = ;

void function(void)
{
    int local_fni;
    int local_finz = ;
    int local_fiz =  ;

    static int static_fni;
    static int static_finz = ;
    static int static_fiz =  ;

    int *p2 = (int*)malloc(sizeof(int));

    printf("子函数 局部变量 : \n");
    printf(" local_fni: %p \n", &local_fni);
    printf(" local_finz: %p \n", &local_finz);
    printf(" local_fiz: %p \n", &local_fiz);

    printf("子函数 静态变量 : \n");
    printf(" static_fni: %p \n", &static_fni);
    printf(" static_finz: %p \n", &static_finz);
    printf(" static_fiz: %p \n", &static_fiz);

    printf("子函数 指针变量 : \n");
    printf(" p2 : %p \n", p2);

    printf("子函数地址 : \n");
    printf(" function : %p \n", function);
}

int main(int argc, char **argv)
{
    int local_mni;
    int local_minz = ;
    int local_miz =  ;

    static int static_mni;
    static int static_minz = ;
    static int static_miz =  ;

    int *p1 = (int*)malloc(sizeof(int));
    const int local_const0 = ;
    const int local_const1 = ;
    char* str_ptr = "char";

    printf("主函数 局部变量 : \n");
    printf(" local_mni : %p \n", &local_mni);
    printf(" local_minz : %p \n", &local_minz);
    printf(" local_miz : %p \n", &local_miz);

    printf("const 变量: \n");
    printf(" local_const0 : %p \n", &local_const0);
    printf(" local_const1 : %p \n", &local_const1);
    printf(" global_const0 : %p \n", &global_const0);
    printf(" global_const1 : %p \n", &global_const1);

    printf("主函数 malloc指针变量 : \n");
    printf(" p1 : %p \n", p1);

    printf("全局变量 : \n");
    printf(" global_ni : %p \n", &global_ni);
    printf(" global_inz : %p \n", &global_inz);
    printf(" global_iz : %p \n", &global_iz);

    printf("主函数 静态变量 : \n");
    printf(" static_mni: %p \n", &static_mni);
    printf(" static_minz: %p \n", &static_minz);
    printf(" static_miz: %p \n", &static_miz);

    printf("字符串常量 : \n");
    printf(" str_ptr : %p \n", str_ptr);

    printf("主函数地址 : \n");
    printf(" main : %p \n", main);

    printf("= = = = = = = = = = = = = = = \n");

    function();

    return ;
}

/*
= = = = = = = = = = = = = = =
测试:
 gcc -o test main.c
 objdump -Dhs test > test.dis
 ./test 

分析:
Disassembly of section .text: 08048370
{
子函数地址 :
 function : 0x8048424
主函数地址 :
 main : 0x804851d 

}

Disassembly of section .rodata: 080487d8
{
const 变量: 全局
 global_const0 : 0x80487e0
 global_const1 : 0x80487e4 

字符串常量 :
 str_ptr : 0x80488d0
}

//.data中是初始化为非0的全局变量和静态变量
Disassembly of section .data: 0804a014
{
子函数 静态变量 :
 static_finz: 0x804a024 

全局变量 :
 global_inz : 0x804a01c 

主函数 静态变量 :
 static_minz: 0x804a020
}    

//.bss中是初始化为0以及没有初始化的全局变量和静态变量
Disassembly of section .bss: 0804a028
{
子函数 静态变量 :
 static_fni: 0x804a03c
 static_fiz: 0x804a040 

全局变量 :
 global_iz : 0x804a030
 global_ni : 0x804a044 

主函数 静态变量 :
 static_mni: 0x804a034
 static_miz: 0x804a038
}

堆空间: //动态的
{
主函数 malloc指针变量 :
 p1 : 0x967c008 

子函数 malloc指针变量 :
 p2 : 0x967c018
}

栈空间:    //动态的
{
子函数 局部变量 :
 local_fiz : 0xbfb79924
 local_finz: 0xbfb79928
 local_fni : 0xbfb7992c 

const 变量: 局部
 local_const1 : 0xbfe3cee8
 local_const0 : 0xbfe3ceec 

主函数 局部变量 :
 local_miz : 0xbfb79964
 local_minz: 0xbfb79968
 local_mni : 0xbfb7996c
}
*/

附反汇编文件test.dis节选

test:     file format elf32-i386

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
   .interp               **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .note.ABI-tag         **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .note.gnu.build-id         **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .gnu.hash       0804818c  0804818c  0000018c  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .dynsym         080481ac  080481ac  000001ac  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .dynstr         0804821c  0804821c  0000021c  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .gnu.version  0000000e        **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .gnu.version_r         **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .rel.dyn        080482a4  080482a4  000002a4  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
   .rel.plt        080482ac  080482ac  000002ac  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  .init           080482d4  080482d4  000002d4  **
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  .plt                  **
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  .text         0000044c        **
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  .fini         0000001c  080487bc  080487bc  000007bc  **
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  .rodata       000002db  080487d8  080487d8  000007d8  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  .eh_frame       08048ab4  08048ab4  00000ab4  **
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  .ctors          08049f14  08049f14  00000f14  **
                  CONTENTS, ALLOC, LOAD, DATA
  .dtors          08049f1c  08049f1c  00000f1c  **
                  CONTENTS, ALLOC, LOAD, DATA
  .jcr            08049f24  08049f24  00000f24  **
                  CONTENTS, ALLOC, LOAD, DATA
  .dynamic      000000c8  08049f28  08049f28  00000f28  **
                  CONTENTS, ALLOC, LOAD, DATA
  .got            08049ff0  08049ff0  00000ff0  **
                  CONTENTS, ALLOC, LOAD, DATA
  .got.plt        08049ff4  08049ff4  00000ff4  **
                  CONTENTS, ALLOC, LOAD, DATA
  .data           0804a014  0804a014    **
                  CONTENTS, ALLOC, LOAD, DATA
  .bss            0804a028  0804a028    **
                  ALLOC
  .comment      0000006c        **
                  CONTENTS, READONLY