美文网首页Linux内核
【图文】反汇编解析函数调用堆栈

【图文】反汇编解析函数调用堆栈

作者: Minority | 来源:发表于2020-05-09 11:56 被阅读0次

转载请注明出处https://www.jianshu.com/p/07283353d267

一、基本知识

1.1 堆栈的用途:

堆栈是C语言程序运行时必须的一个记录调用路径和参数
的空间,堆栈的用处:

  • 函数调用框架
  • 传递参数(X86-64改为使用寄存器传递参数)
  • 保存返回地址
  • 提供局部变量空间
  • 等等

1.2 堆栈寄存器和堆栈操作:

堆栈相关的寄存器:

  • esp,堆栈指针( stack pointer)
  • ebp,基址指针( base pointer)
  • cs:eip:总是指向下一条的指令地址
    ◆顺序执行:总是指向地址连续的下一条指令
    ◆跳转/分支:执行这样的指令的时候,cs:eip的值会根据
    程序需要被修改
    ◆cal:将当前cs:eijp的值压入栈顶,cs:eip指向被调用函
    数的入口地址
    ◆ret:从栈顶弹出原来保存在这里的cs:eip的值,放入cs
    ◆发生中断时?

堆栈相关的操作:

  • push
    栈顶地址减少4个字节(32位)
  • pop
    栈顶地址增加4个字节

push和pop详解(32位):

  • push example:pushl %eax
    上面的push操作就是把EAX寄存器的值压到堆栈栈顶。它实际上做了这样两个动作:
    subl $4, %esp
    movl %eax, (%esp)
    其中第一个动作就是把堆栈的栈顶ESP寄存器的值减4。因为堆栈是向下增长的,所以用减指令subl,也就是在栈顶预留出一个存储单元;第二个动作把ESP寄存器加一个小括号(间接寻址),就是把EAX寄存器的值放到ESP寄存器所指向的地方,这时ESP寄存器已经指向预留出的存储单元了
  • pop example:popl %eax
    就是从堆栈的栈顶取一个存储单元(32位数值),从堆栈栈顶的位置放到EAX寄存器里,这称为出栈。实际上也做了这样两个动作:
    movl (%esp), %eax
    addl $4, %esp
    第一步是把栈顶的数值放到EAX寄存器里,然后用指令addl把栈顶加4,相当于栈向上回退了一个存储单元的位置,也就是栈在收缩。每次执行指令pushl栈都在增长,执行指令popl栈都在收缩。

二、函数调用堆栈框架

执行过程:

  • call XXX
    执行call时,cs:eip原来的值
    指向ca一条指令,该值被
    保存到栈顶,然后cs:ejp的值
    指向XXX的入口地址
  • 进入XXX
    第一条指令:push%ebp
    第二条指令:movl %esp,%ebp
    函数体中的常规操作,可能会压栈、出栈
  • 退出XXX
    movl %ebp, %esp
    popl %ebp
    ret

注意:enterleave指令经常看到,其都是宏指令,enter相当于push%ebpmovl %esp,%ebpleave相当于movl %ebp, %esppopl %ebp

三、通过实例来查看函数调用堆栈

编写一个简单的三级调用c程序,代码如下:

#include <stdio.h>

void p1(char c){
        printf("%c\n", c);
}

int p2(int x, int y){
        char c;
        c = 'a';
        p1(c);
        return x+y;
}

int main(void){

        int x, y, z;
        x = 1;
        y = 2;
        z = p2(x, y);
        printf("%d = %d + %d\n", x, y, z);
        return 0;
}

使用gcc -g test.c -o test -m32编译生成32位的文件test,然后在使用objdump -S test进行反汇编,得到的部分汇编代码如下:

0804840b <p1>:
#include <stdio.h>

void p1(char c){
 804840b:   55                      push   %ebp
 804840c:   89 e5                   mov    %esp,%ebp
 804840e:   83 ec 18                sub    $0x18,%esp
 8048411:   8b 45 08                mov    0x8(%ebp),%eax
 8048414:   88 45 f4                mov    %al,-0xc(%ebp)
    printf("%c\n", c);
 8048417:   0f be 45 f4             movsbl -0xc(%ebp),%eax
 804841b:   83 ec 08                sub    $0x8,%esp
 804841e:   50                      push   %eax
 804841f:   68 30 85 04 08          push   $0x8048530
 8048424:   e8 b7 fe ff ff          call   80482e0 <printf@plt>
 8048429:   83 c4 10                add    $0x10,%esp
}
 804842c:   90                      nop
 804842d:   c9                      leave  
 804842e:   c3                      ret    

0804842f <p2>:

int p2(int x, int y){
 804842f:   55                      push   %ebp
 8048430:   89 e5                   mov    %esp,%ebp
 8048432:   83 ec 18                sub    $0x18,%esp
    char c;
    c = 'a';
 8048435:   c6 45 f7 61             movb   $0x61,-0x9(%ebp)
    p1(c);
 8048439:   0f be 45 f7             movsbl -0x9(%ebp),%eax
 804843d:   83 ec 0c                sub    $0xc,%esp
 8048440:   50                      push   %eax
 8048441:   e8 c5 ff ff ff          call   804840b <p1>
 8048446:   83 c4 10                add    $0x10,%esp
    return x+y;
 8048449:   8b 55 08                mov    0x8(%ebp),%edx
 804844c:   8b 45 0c                mov    0xc(%ebp),%eax
 804844f:   01 d0                   add    %edx,%eax
}
 8048451:   c9                      leave  
 8048452:   c3                      ret    

08048453 <main>:

int main(void){
 8048453:   8d 4c 24 04             lea    0x4(%esp),%ecx
 8048457:   83 e4 f0                and    $0xfffffff0,%esp
 804845a:   ff 71 fc                pushl  -0x4(%ecx)
 804845d:   55                      push   %ebp
 804845e:   89 e5                   mov    %esp,%ebp
 8048460:   51                      push   %ecx
 8048461:   83 ec 14                sub    $0x14,%esp
    
    int x, y, z;
    x = 1;
 8048464:   c7 45 ec 01 00 00 00    movl   $0x1,-0x14(%ebp)
    y = 2;
 804846b:   c7 45 f0 02 00 00 00    movl   $0x2,-0x10(%ebp)
    z = p2(x, y);
 8048472:   83 ec 08                sub    $0x8,%esp
 8048475:   ff 75 f0                pushl  -0x10(%ebp)
 8048478:   ff 75 ec                pushl  -0x14(%ebp)
 804847b:   e8 af ff ff ff          call   804842f <p2>
 8048480:   83 c4 10                add    $0x10,%esp
 8048483:   89 45 f4                mov    %eax,-0xc(%ebp)
    printf("%d = %d + %d\n", x, y, z);
 8048486:   ff 75 f4                pushl  -0xc(%ebp)
 8048489:   ff 75 f0                pushl  -0x10(%ebp)
 804848c:   ff 75 ec                pushl  -0x14(%ebp)
 804848f:   68 34 85 04 08          push   $0x8048534
 8048494:   e8 47 fe ff ff          call   80482e0 <printf@plt>
 8048499:   83 c4 10                add    $0x10,%esp
    return 0;
 804849c:   b8 00 00 00 00          mov    $0x0,%eax
}

但拿出p2函数的汇编代码,如下:

0804842f <p2>:

int p2(int x, int y){
 804842f:   55                      push   %ebp   // 建立框架
 8048430:   89 e5                   mov    %esp,%ebp  // 建立框架
 8048432:   83 ec 18                sub    $0x18,%esp
    char c;
    c = 'a';
 8048435:   c6 45 f7 61             movb   $0x61,-0x9(%ebp)
    p1(c);
 8048439:   0f be 45 f7             movsbl -0x9(%ebp),%eax
 804843d:   83 ec 0c                sub    $0xc,%esp
 8048440:   50                      push   %eax
 8048441:   e8 c5 ff ff ff          call   804840b <p1>
 8048446:   83 c4 10                add    $0x10,%esp
    return x+y;
 8048449:   8b 55 08                mov    0x8(%ebp),%edx
 804844c:   8b 45 0c                mov    0xc(%ebp),%eax
 804844f:   01 d0                   add    %edx,%eax
}
 8048451:   c9                      leave   // 拆除框架
 8048452:   c3                      ret    
p2堆栈的建立

建立p2的堆栈之前,执行一系列出栈和入栈的操作,p2执行之间还使用call调用了p1,p1堆栈的建立也经过了如上的建立堆栈和拆除堆栈,最后执行完p2函数后进行堆栈的拆除,返回到main,也就是p2的最后两条汇编指令:

8048451:    c9                      leave   // 拆除框架
8048452:    c3                      ret    

其中,leave相当于movl %ebp, %esppopl %ebp,框架拆除如下图所示:

pop是分两步的,movl (%esp), %eaxaddl $4, %esp,上图更清晰的步骤为:

p2拆除框架

其中,movl (%esp), %eax相当于把p2的堆栈清空。

如果再考虑eip的话,整个流程如下图所示:

执行main函数时 执行到p2 建立p2的堆栈 执行到调用p1 建立p1堆栈 p1执行完返回,返回到p2调用处 p2执行结束 p2返回,返回到main调用处

最后,main函数执行完毕,整个程序执行完毕。

相关文章

  • 【图文】反汇编解析函数调用堆栈

    转载请注明出处:https://www.jianshu.com/p/07283353d267 一、基本知识 1.1...

  • C语言2-参数的传递与返回值

    C语言2-参数的传递与返回值 plus函数对应反汇编代码和意义 调用函数调用: 下面是call内部 堆栈没有变化 ...

  • C语言编程: 函数调用中堆栈的个人理解

    接下来将通过下面几个问题解析函数调用中对堆栈理解: (1)函数调用过程中堆栈在内存中存放的结构如何? (2)汇编语...

  • 调用堆栈阅读笔记

    1. 定义 调用堆栈是解析器在脚本调用多个函数时,跟踪当前正在执行的函数及下一个将要被调用及执行的函数的机制。 当...

  • Linux内核分析:操作系统是如何工作的?

    函数调用堆栈 堆栈是C语言程序运行时必须的一个记录调用路径和参数的空间 堆栈的几个重要功能 函数调用框架 传递参数...

  • 多线程 调用堆栈

    什么是调用堆栈?调用堆栈简单的讲就是程序从开始运行到当前函数(方法)之间,所有调用过的函数(方法)的前后顺序. 打...

  • 函数调用堆栈

    函数调用堆栈 函数调用堆栈最常用的是收集crash信息,解决问题用的,这方面网上有很多的资料,也有成熟的第三方,如...

  • 多态--虚函数

    1.通过对象调用成员函数(无虚函数) 源代码 反汇编代码 2. 通过对象调用成员函数(有虚函数) 对比发现通过对象...

  • Javascript事件循环和调用堆栈

    调用堆栈 众所周知JavaScript是单线程编程语言,它只有一个单一的调用堆栈,当调用堆栈由函数在运行,它就不能...

  • 深入理解函数调用堆栈

    堆栈是C语言程序运行时一个必须的记录函数调用路径和参数的空间。堆栈提供函数调用框架,具有传递参数,保存函数返回地址...

网友评论

    本文标题:【图文】反汇编解析函数调用堆栈

    本文链接:https://www.haomeiwen.com/subject/unihnhtx.html