转自:http://blog.csdn.net/kevinlynx/article/details/39269507

版权声明:本文为博主原创文章,未经博主允许不得转载。

当我们的程序core掉之后,如果能获取到core时的函数调用堆栈将非常有利于定位问题。在Windows下可以使用SEH机制;在Linux下通过gdb使用coredump文件即可。

但有时候由于某些错误导致堆栈被破坏,发生拿不到调用堆栈的情况。

一些基础预备知识本文不再详述,可以参考以下文章:

需要知道的信息:

  • 函数调用对应的call指令本质上是先压入下一条指令的地址到堆栈,然后跳转到目标函数地址
  • 函数返回指令ret则是从堆栈取出一个地址,然后跳转到该地址
  • EBP寄存器始终指向当前执行函数相关信息(局部变量)所在栈中的位置,ESP则始终指向栈顶
  • 每一个函数入口都会保存调用者的EBP值,在出口处都会重设EBP值,从而实现函数调用的现场保存及现场恢复
  • 64位机器增加了不少寄存器,从而使得函数调用的参数大部分时候可以通过寄存器传递;同时寄存器名字发生改变,例如EBP变为RBP

在函数调用中堆栈的情况可用下图说明:

将代码对应起来:

  1. void g() {
  2. int *p = 0;
  3. long a = 0x1234;
  4. printf("%p %x\n", &a, a);
  5. printf("%p %x\n", &p, p);
  6. f();
  7. *p = 1;
  8. }
  9. void b(int argc, char **argv) {
  10. printf("%p %p\n", &argc, &argv);
  11. g();
  12. }
  13. int main(int argc, char **argv) {
  14. b(argc, argv);
  15. return 0;
  16. }

在函数g()中断点,看看堆栈中的内容(64位机器):

  1. (gdb) p $rbp
  2. $2 = (void *) 0x7fffffffe370
  3. (gdb) p &p
  4. $3 = (int **) 0x7fffffffe368
  5. (gdb) p $rsp
  6. $4 = (void *) 0x7fffffffe360
  7. (gdb) x/8ag $rbp-16
  8. 0x7fffffffe360: 0x1234  0x0
  9. 0x7fffffffe370: 0x7fffffffe390  0x400631 <b(int, char**)+43>
  10. 0x7fffffffe380: 0x7fffffffe498  0x1a561cbc0
  11. 0x7fffffffe390: 0x7fffffffe3b0  0x40064f <main(int, char**)+27>

对应的堆栈图:

可以看看例子中0x400631 <b(int, char**)+43>0x40064f <main(int, char**)+27>中的代码:

  1. (gdb) disassemble 0x400631
  2. ...
  3. 0x0000000000400627 <b(int, char**)+33>: callq  0x400468 <printf@plt>
  4. 0x000000000040062c <b(int, char**)+38>: callq  0x4005ae <g()>
  5. 0x0000000000400631 <b(int, char**)+43>: leaveq                           # call的下一条指令
  6. ...
  7. (gdb) disassemble 0x40064f
  8. ...
  9. 0x000000000040063f <main(int, char**)+11>:      mov    %rsi,-0x10(%rbp)
  10. 0x0000000000400643 <main(int, char**)+15>:      mov    -0x10(%rbp),%rsi
  11. 0x0000000000400647 <main(int, char**)+19>:      mov    -0x4(%rbp),%edi
  12. 0x000000000040064a <main(int, char**)+22>:      callq  0x400606 <b(int, char**)>
  13. 0x000000000040064f <main(int, char**)+27>:      mov    $0x0,%eax         # call的下一条指令
  14. ...

顺带一提,每个函数入口和出口,对应的设置RBP代码为:

  1. (gdb) disassemble g
  2. ...
  3. 0x00000000004005ae <g()+0>:     push   %rbp               # 保存调用者的RBP到堆栈
  4. 0x00000000004005af <g()+1>:     mov    %rsp,%rbp          # 设置自己的RBP
  5. ...
  6. 0x0000000000400603 <g()+85>:    leaveq                    # 等同于:movq %rbp, %rsp
  7. #         popq %rbp
  8. 0x0000000000400604 <g()+86>:    retq

由以上可见,通过当前的RSP或RBP就可以找到调用堆栈中所有函数的RBP;找到了RBP就可以找到函数地址。因为,任何时候的RBP指向的堆栈位置就是上一个函数的RBP;而任何时候RBP所在堆栈中的前一个位置就是函数返回地址。

由此我们可以自己构建一个导致gdb无法取得调用堆栈的例子:

  1. void f() {
  2. long *p = 0;
  3. p = (long*) (&p + 1); // 取得g()的RBP
  4. *p = 0;  // 破坏g()的RBP
  5. }
  6. void g() {
  7. int *p = 0;
  8. long a = 0x1234;
  9. printf("%p %x\n", &a, a);
  10. printf("%p %x\n", &p, p);
  11. f();
  12. *p = 1; // 写0地址导致一次core
  13. }
  14. void b(int argc, char **argv) {
  15. printf("%p %p\n", &argc, &argv);
  16. g();
  17. }
  18. int main(int argc, char **argv) {
  19. b(argc, argv);
  20. return 0;
  21. }

使用gdb运行该程序:

  1. Program received signal SIGSEGV, Segmentation fault.
  2. g () at ebp.c:37
  3. 37          *p = 1;
  4. (gdb) bt
  5. Cannot access memory at address 0x8
  6. (gdb) p $rbp
  7. $1 = (void *) 0x0

bt无法获取堆栈,在函数g()中RBP被改写为0,gdb从0偏移一个地址长度即0x8,尝试从0x8内存位置获取函数地址,然后提示Cannot access memory at address 0x8

RBP出现了问题,我们就可以通过RSP来手动获取调用堆栈。因为RSP是不会被破坏的,要通过RSP获取调用堆栈则需要偏移一些局部变量所占的空间:

  1. (gdb) p $rsp
  2. $2 = (void *) 0x7fffffffe360
  3. (gdb) x/8ag $rsp+16             # g()中局部变量占16字节
  4. 0x7fffffffe370: 0x7fffffffe390  0x400631 <b(int, char**)+43>
  5. 0x7fffffffe380: 0x7fffffffe498  0x1a561cbc0
  6. 0x7fffffffe390: 0x7fffffffe3b0  0x40064f <main(int, char**)+27>
  7. 0x7fffffffe3a0: 0x7fffffffe498  0x100000000

基于以上就可以手工找到调用堆栈:

  1. g()
  2. 0x400631 <b(int, char**)+43>
  3. 0x40064f <main(int, char**)+27>

上面的例子本质上也是破坏堆栈,并且仅仅破坏了保存了的RBP。在实际情况中,堆栈可能会被破坏得更多,则可能导致手动定位也较困难。

堆栈被破坏还可能导致更多的问题,例如覆盖了函数返回地址,则会导致RIP错误;例如堆栈的不平衡。导致堆栈被破坏的原因也有很多,例如局部数组越界;delete/free栈上对象等

omit-frame-pointer

使用RBP获取调用堆栈相对比较容易。但现在编译器都可以设置不使用RBP(gcc使用-fomit-frame-pointer,msvc使用/Oy),对于函数而言不设置其RBP意味着可以节省若干条指令。在函数内部则完全使用RSP的偏移来定位局部变量,包括嵌套作用域里的局部变量,即使程序实际运行时不会进入这个作用域。

例如:

  1. void f2() {
  2. int a = 0x1234;
  3. if (a > 0) {
  4. int b = 0xff;
  5. b = a;
  6. }
  7. }

gcc中使用-fomit-frame-pointer生成的代码为:

  1. (gdb) disassemble f2
  2. Dump of assembler code for function f2:
  3. 0x00000000004004a5 <f2+0>:      movl   $0x1234,-0x8(%rsp)    # int a = 0x1234
  4. 0x00000000004004ad <f2+8>:      cmpl   $0x0,-0x8(%rsp)
  5. 0x00000000004004b2 <f2+13>:     jle    0x4004c4 <f2+31>
  6. 0x00000000004004b4 <f2+15>:     movl   $0xff,-0x4(%rsp)      # int b = 0xff
  7. 0x00000000004004bc <f2+23>:     mov    -0x8(%rsp),%eax
  8. 0x00000000004004c0 <f2+27>:     mov    %eax,-0x4(%rsp)
  9. 0x00000000004004c4 <f2+31>:     retq

可以发现f2()没有操作RBP之类的指令了。

原文地址: http://codemacro.com/2014/09/02/stack-frame/
written by Kevin Lynx  posted at
http://codemacro.com

C/C++中手动获取调用堆栈【转】的更多相关文章

  1. delphi中获取调用堆栈信息

    异常堆栈有利于分析程序的错误,Delphi的Exception有StackTrace属性,但是值为空,因为StackTrace的信息收集Delphi委托给了第三方组件来完成,真是脑子有毛病! 借助于m ...

  2. C++从LPEXCEPTION_POINTERS获取调用堆栈

    #pragma once #include <map> #include <vector> struct FunctionCall { DWORD64 Address; std ...

  3. VC++ 崩溃处理以及打印调用堆栈

    title: VC++ 崩溃处理以及打印调用堆栈 tags: [VC++, 结构化异常处理, 崩溃日志记录] date: 2018-08-28 20:59:54 categories: windows ...

  4. 在 Visual Studio 中调试时映射调用堆栈上的方法

    本文转自:https://msdn.microsoft.com/zh-cn/library/dn194476.aspx 1.创建代码图,以便在调试时对调用堆栈进行可视化跟踪. 你可以在图中进行标注以跟 ...

  5. .NET 中获取调用方法名

    在写记录日志功能时,需要记录日志调用方所在的模块名.命名空间名.类名以及方法名,想到使用的是反射(涉及到反射请注意性能),但具体是哪一块儿还不了解,于是搜索,整理如下: 需要添加相应的命名空间: us ...

  6. Linux下手动获取当前调用栈

    被问到如何手动获取当前的调用栈,之前碰到过一时没记起来,现在回头整理一下. 其原理是:使用backtrace()从栈中获取当前调用各层函数调用的返回地址,backtrace_symbols()将对应地 ...

  7. 如何手动获取Spring容器中的bean(ApplicationContextAware 接口)

    ApplicationContextAware 接口的作用 先来看下Spring API 中对于 ApplicationContextAware 这个接口的描述:   即是说,当一个类实现了这个接口之 ...

  8. 程序中打印当前进程的调用堆栈(backtrace)

    为了方便调式程序,产品中需要在程序崩溃或遇到问题时打印出当前的调用堆栈.由于是基于Linux的ARM嵌入式系统,没有足够的空间来存放coredump文件. 实现方法,首先用__builtin_fram ...

  9. C#获取当前堆栈的各调用方法列表

    在使用.NET编写的代码在debug时很容易进行排查和定位问题,一旦项目上线并出现问题的话那么只能依靠系统日志来进行问题排查和定位,但当项目复杂时,即各种方法间相互调用将导致要获取具体的出错方法或调用 ...

随机推荐

  1. 2018 杭电多校1 - Chiaki Sequence Revisited

    题目链接 Problem Description Chiaki is interested in an infinite sequence $$$a_1,a_2,a_3,...,$$$ which i ...

  2. 【bzoj5110】[CodePlus2017]Yazid 的新生舞会 Treap

    题目描述 求一个序列所有的子区间,满足区间众数的出现次数大于区间长度的一半. 输入 第一行2个用空格隔开的非负整数n,type,表示序列的长度和数据类型.数据类型的作用将在子任务中说明. 第二行n个用 ...

  3. Python 源码剖析(三)【字符串对象】

    三.字符串对象 1.PyStringObject与PyString_Type 2.创建PyStringObject对象 3.Intern 机制 4.字符缓冲池 5.PyStringObject 效率相 ...

  4. Codeforces ZeptoLab Code Rush 2015 D.Om Nom and Necklace(kmp)

    题目描述: 有一天,欧姆诺姆发现了一串长度为n的宝石串,上面有五颜六色的宝石.他决定摘取前面若干个宝石来做成一个漂亮的项链. 他对漂亮的项链是这样定义的,现在有一条项链S,当S=A+B+A+B+A+. ...

  5. URAL1297:Palindrome——题解

    http://acm.timus.ru/problem.aspx?space=1&num=1297 https://vjudge.net/problem/URAL-1297 给定一个字符串,求 ...

  6. 虚拟机网络连接模式中桥接模式和NAT模式的区别

    1.桥接模式:当虚拟机系统的网络连接模式为桥接模式时,相当于在主机系统和虚拟机系统之间连接了一个网桥,而网桥两端的网络都属于同一网络,主机和虚拟机是处于同一网络中的对等主机. 实例,在使用Xshell ...

  7. How far away ? LCA求树上两点距离

    How far away ? Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)To ...

  8. poj 3498 最大流

    March of the Penguins Time Limit: 8000MS   Memory Limit: 65536K Total Submissions: 4809   Accepted:  ...

  9. 手脱ASProtect v1.23 RC1(无Stolen Code)

    1.载入PEID ASProtect v1.23 RC1 2.载入OD,不勾选内存访问异常,其他异常全部勾选 > 01C04200 push 跑跑排行.0042C001 ; //入口处 E8 c ...

  10. Oracle raw类型

    RAW(size):长度为size字节的原始二进制数据,size的最大值为2000字节; RAW类型好处:在网络中的计算机之间传输 RAW 数据时,或者使用 Oracle 实用程序将 RAW 数据从一 ...