arm平台下使用反汇编分析c内存分布:

arm：使用arm-linux-objdump命令将编译完毕之后的elf文件，进行反汇编．
之后重定向到tmp.s文件里．

第一步变量例如以下c文件．
vim tmp.c

  #include<stdio.h>

  #define  VAR 0xFF

  int a = 0; 
  static int  b =  0;

  int c = 10;
  static int  d = 20; 

  const int finalone = 10;
  const int final;

  int main(void)
  {

    char *hell = "hhhhhhh";
    const int finaltwo = 50 ;
    static int f = 0;
    static int k = 10;
    int aa; 
    int bb=10;
    printf("VAR = %d\n, finalone = %d, finaltwo = %d",VAR,finalone,finaltwo);
  }

第二步：编写Makefile文件例如以下
  Makefile文件例如以下:
  vim Makefile
  CC=arm-linux-gcc
  CFLAGS += -march=armv7-a


第三步:编译生成可执行文件.  
  然后使用make命令编译给文件．make tmp 生成tmp elf格式文件.

第四步:
  以下通过使用arm-linux-objdump -D tmp  >  tmp.s

//得到例如以下文件tmp.s文件.

  :     file format elf32-littlearm
  以下是摘出来的相关内如例如以下:

//以下是相应的.data段相关的初始化的变量.
//变量c,d,k都存取再该区域内.结论例如以下:
//须要满足例如以下要求的变量被放在.data段,也就是初始化数据段.
//全部全局||statickeyword修饰)&&初始化不为的变量)

sassembly of section .data: 
  00011020 <__data_start>:
  11020:  00000000  andeq r0, r0, r0

  00011024 <__dso_handle>:
  11024:  00000000  andeq r0, r0, r0

  00011028 <c>:
  11028:  0000000a  andeq r0, r0, sl      

  0001102c <d>:
  1102c:  00000014  andeq r0, r0, r4, lsl r0

  00011030 <k.1728>:
  11030:  0000000a  andeq r0, r0, sl

//以下是相应的.bss段.变量a,b,f都存储再这个区域.
//该区域存储的是没有初始化或者初始化为0的变量.
  这些变量应该满足例如以下,条件才会被放到给区域:
  (全局的|被statickeyword修饰的)&&(为初始化||初始化为0的变量)

  Disassembly of section .bss:
  00011034 <completed.5796>:
  11034:  00000000  andeq r0, r0, r0

  00011038 <a>:
  11038:  00000000  andeq r0, r0, r0

  0001103c <b>:
  1103c:  00000000  andeq r0, r0, r0

  00011040 <f.1727>:
  11040:  00000000  andeq r0, r0, r0

  00011044 <final>:
  11044:  00000000  andeq r0, r0, r0


//这个区域存放了一些字符串常量.如上c程序中的 "hhhhhhh"相应的686868.....
//还有使用const修饰的全局初始化的常量.如上面的const int finalone变量.它的仅仅相应的是848c的00000000a. 
  sassembly of section .rodata:

  00008488 <_IO_stdin_used>:
  8488: 00020001  andeq r0, r2, r1

  0000848c <finalone>:
  848c: 0000000a  andeq r0, r0, sl
  8490: 68686868  stmdavs r8!, {r3, r5, r6, fp, sp, lr}^
  8494: 68686868  stmdavs r8!, {r3, r5, r6, fp, sp, lr}^
  8498: 00000068  andeq r0, r0, r8, rrx
  849c: 20524156  subscs  r4, r2, r6, asr r1
  84a0: 6425203d  strtvs  r2, [r5], #-61  ; 0x3d
  84a4: 66202c0a  strtvs  r2, [r0], -sl, lsl #24
  84a8: 6c616e69  stclvs  14, cr6, [r1], #-420  ; 0xfffffe5c
  84ac: 20656e6f  rsbcs r6, r5, pc, ror #28
  84b0: 6425203d  strtvs  r2, [r5], #-61  ; 0x3d
  84b4: 6966202c  stmdbvs r6!, {r2, r3, r5, sp}^
  84b8: 746c616e  strbtvc r6, [ip], #-366 ; 0x16e
  84bc: 3d206f77  stccc 15, cr6, [r0, #-476]! ; 0xfffffe24
  84c0: 2c642520  cfstr64cs mvdx2, [r4], #-128  ; 0xffffff80
  84c4: 203d2068  eorscs  r2, sp, r8, rrx
  84c8: 00732520  rsbseq  r2, r3, r0, lsr #10}

//上面还使用#define声明一个宏.它存储再哪里呢.我们能够看一下啊main中的汇编例如以下:
//第一步找出.在main中声明的局部变量.
  char *hell = "hhhhhhh"    //这个是hell变量的声明,83c0:  e3083490  movw  r3, #33936  ; 0x8490
  const int finaltwo = 50 ; // 83cc:  e3a03032  mov r3, #50 ; 0x32 //它会被保存的栈中.
  static int f = 0;
  static int k = 10;
  int aa;                   //aa变量被默认优化,不存在了.由于没有被使用,也没有使用volatilekeyword修饰,
                //编译在当前arm平台下默认优化等级是O2,那么将将会再汇编中步存在.
  int bb=10;                //83d4: e3a0300a  mov r3, #10 这个是bb=10


  //这段汇编代码中还包括一个#255,也就是我们使用#define VAR 255 常量, 
  //它是一个马上数.说明它仅仅占用.text文本段,也就是我们常说的代码段.
  //以下由段具体的解释:说明const,和#define常量的不同之处.

  000083b4 <main>:
  83b4: e92d4800  push  {fp, lr}
  83b8: e28db004  add fp, sp, #4
  83bc: e24dd018  sub sp, sp, #24
  83c0: e3083490  movw  r3, #33936  ; 0x8490
  83c4: e3403000  movt  r3, #0
  83c8: e50b3008  str r3, [fp, #-8]
  83cc: e3a03032  mov r3, #50 ; 0x32
  83d0: e50b300c  str r3, [fp, #-12]
  83d4: e3a0300a  mov r3, #10
  83d8: e50b3010  str r3, [fp, #-16]
  83dc: e308349c  movw  r3, #33948  ; 0x849c
  83e0: e3403000  movt  r3, #0
  83e4: e308248c  movw  r2, #33932  ; 0x848c
  83e8: e3402000  movt  r2, #0
  83ec: e5922000  ldr r2, [r2]
  83f0: e51b1008  ldr r1, [fp, #-8]
  83f4: e58d1000  str r1, [sp]
  83f8: e1a00003  mov r0, r3
  83fc: e3a010ff  mov r1, #255  ; 0xff
  8400: e51b300c  ldr r3, [fp, #-12]
  8404: ebffffbc  bl  82fc <_init+0x44>
  8408: e1a00003  mov r0, r3
  840c: e24bd004  sub sp, fp, #4
  8410: e8bd8800  pop {fp, pc}

//解析define和const的不同之处.  
  const 定义的仅仅读变量从汇编角度来看 仅仅是给出了相应的内存地址 
  而不是像define一样给出的是马上数 所以 const定义的仅仅读变量在程序执行过程中仅仅有一份拷贝
  (由于它是全局的仅仅读变量 存放在静态区) 而define定义的宏变量在内存中有若干个拷贝 define宏是在预编译阶段进行替换 
  而const修饰的仅仅读变量是在编译的时候确定其值 define宏没有类型 而const修饰的仅仅读变量具有特定的类型.