[关闭]
@iar 2016-08-12T18:15:25.000000Z 字数 3208 阅读 119

庖丁解牛Linux内核笔记: 计算机是如何工作的

Linux Note OS

Heng Zhang + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

计算机是如何工作的

寄存器

EFLAGS

常见的5种内存寻址方式

Stack memory + operations: 4大virtual instruction

  1. pushl %eax \\ 等价如下
  2. subl $4, %esp
  3. movl %eax, (%esp)
  5. popl %eax \\ 等价如下
  6. movl (%esp), %eax
  7. addl $4, %esp
  9. call 0x12345 \\ 等价如下
  10. pushl %eip
  11. movl $0x12345, %eip
  13. ret \\ 等价如下
  14. popl %eip
  1. enter \\ 等价如下
  2. pushl %ebp
  3. movl %esp, %ebp
  5. leave \\ 等价如下
  6. movl %ebp, %esp
  7. popl %ebp

通过反汇编一个简单的C程序，分析汇编代码理解计算机是如何工作的

实验部分:

  1. int g(int x)
  2. {
  3.     return x+42;
  4. }
  6. int f(int x)
  7. {
  8.     return g(x);
  9. }
  11. int main(void)
  12. {
  13.     return f(4)+17;
  14. }
  1. g:
  2.     pushl   %ebp
  3.     movl    %esp, %ebp
  4.     movl    8(%ebp), %eax
  5.     addl    $42, %eax
  6. 	popl	%ebp
  7. 	ret
  8. f:
  9. 	pushl	%ebp
  10. 	movl	%esp, %ebp
  11. 	subl	$4, %esp
  12.     movl    8(%ebp), %eax
  13.     movl    %eax, (%esp)
  14.     call    g
  15.     leave
  16.     ret
  17. main:
  18.     pushl   %ebp
  19.     movl    %esp, %ebp
  20.     subl    $4, %esp
  21. 	movl	$4, (%esp)
  22.     call    f
  23.     addl    $17, %eax
  24.     leave
  25.     ret

剪裁后汇编码

  1. 0x80483e2 <frame_dummy+34>      jmp    0x8048360 <register_tm_clones>    
  2. 0x80483e7 <frame_dummy+39>      nop                                      
  3. 0x80483e8 <frame_dummy+40>      jmp    0x8048360 <register_tm_clones>    
  4. 0x80483ed <g>                   push   %ebp                              
  5. 0x80483ee <g+1>                 mov    %esp,%ebp                         
  6. 0x80483f0 <g+3>                 mov    0x8(%ebp),%eax                    
  7. 0x80483f3 <g+6>                 add    $0x2a,%eax                        
  8. 0x80483f6 <g+9>                 pop    %ebp                              
  9. 0x80483f7 <g+10>                ret                                      
  10. 0x80483f8 <f>                   push   %ebp                              
  11. 0x80483f9 <f+1>                 mov    %esp,%ebp                         
  12. 0x80483fb <f+3>                 sub    $0x4,%esp                         
  13. 0x80483fe <f+6>                 mov    0x8(%ebp),%eax                    
  14. 0x8048401 <f+9>                 mov    %eax,(%esp)                       
  15. 0x8048404 <f+12>                call   0x80483ed <g>                     
  16. 0x8048409 <f+17>                leave                                    
  17. 0x804840a <f+18>                ret                                      
  18. 0x804840b <main>                push   %ebp                              
  19. 0x804840c <main+1>              mov    %esp,%ebp                         
  20. 0x804840e <main+3>              sub    $0x4,%esp                         
  21. 0x8048411 <main+6>              movl   $0x4,(%esp)                       
  22. 0x8048418 <main+13>             call   0x80483f8 <f>                     
  23. 0x804841d <main+18>             add    $0x11,%eax                        
  24. 0x8048420 <main+21>             leave                                    
  25. 0x8048421 <main+22>             ret                                      
  26. 0x8048422                       xchg   %ax,%ax                           
  27. 0x8048424                       xchg   %ax,%ax                           
  28. 0x8048426                       xchg   %ax,%ax

分析如下:

  • 按照老师的Stack的画法: 横线是地址, 横线上的空格表示该地址所存储的值. 空格中, 使用('值').
  • 为了方便, 地址的增加为1, 实际上32位机是增加4 byte, 不过为了方便演示学习. 这里的单位是1byte.
  • C 文件从main函数开始, 此时ebp, esp指向loc: 0. eip永远指向当前命令的下一条指令. 这样CPU才会知道下一步跑什么.
  • main的最后: ret, 执行的main函数之前的eip. 这里由操作系统管理.
  • eax默认作为函数的返回值return给上一级函数.

总结

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注