arm平台的调用栈回溯(backtrace)

最新推荐文章于 2024-09-21 16:20:04 发布
最新推荐文章于 2024-09-21 16:20:04 发布
阅读量3.7k 收藏 11
点赞数
分类专栏： c++ arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llljjlj/article/details/116145617
版权
c++ 同时被 2 个专栏收录
4 篇文章 0 订阅
订阅专栏
arm
1 篇文章 0 订阅
订阅专栏

title: arm平台的调用栈回溯(backtrace)
date: 2018-09-19 16:07:47
tags:
---

介绍

arm平台的调用栈与x86平台的调用栈大致相同，稍微有些区别，主要在于栈帧的压栈内容和传参方式不同。在arm平台的不同程序，采用的编译选项不同，程序运行期间的栈帧也会不同。有些工具在对arm的调用栈回溯时，可能会遇到无法回溯的情况。例如gdb在使用bt查看core dump文件调用栈时，有时会出现Backtrace stoped的情况,有可能就是栈空间的压栈顺序导致的。当工具无法回溯时，就需要人工结合汇编代码对栈进行回溯，或者使用unwind进行回溯。

arm栈帧结构

 

通常情况下，arm的调用栈大致结构与x86相同，都是从高地址向低地址扩张。上图是其中一种内存分布。

pc, lr, sp, fp是处理器的寄存器，其含义如下：

  • pc, program counter，程序计数器。程序当前运行的指令会放入到pc寄存器中
  • fp, 即frame pointer,帧指针。通常指向一个函数的栈帧底部，表示一个函数栈的开始位置。
  • sp, stack pointer，栈顶指针。指向当前栈空间的顶部位置，当进行push和pop时会一起移动。
  • lr, link register。在进行函数调用时，会将函数返回后要执行的下一条指令放入lr中，对应x86架构下的返回地址。

调用栈从高地址向低地址增长，当函数调用时，分别将分别将pc, lr, ip和 fp寄存器压入栈中，然后移动sp指针，为当前程序开辟栈空间。

arm官方手册描述如下：

一个arm程序，在任一时刻都存在十五个通用寄存器，这取决于当前的处理器模式。 它们分别是 r0-r12、sp、lr。
sp（或 r13）是堆栈指针。 C 和 C++ 编译器始终将 sp 用作堆栈指针。 在 Thumb-2 中，sp 被严格定义为堆栈指针，因此许多对堆栈操作无用而又使用了 sp 的指令会产生不可预测的结果。 建议您不要将 sp 用作通用寄存器。
在用户模式下，lr（或 r14）用作链接寄存器 (lr)，用于存储调用子例程时的返回地址。 如果返回地址存储在堆栈上，则也可将 r14 用作通用寄存器。
在异常处理模式下，lr 存放异常的返回地址；如果在一个异常内执行了子例程调用，则 lr 存放子例程的返回地址。如果返回地址存储在堆栈上，则可将 lr 用作通用寄存器。

除了官方手册中描述的sp,lr寄存器，通常r12还会作为fp寄存器。fp寄存器对于程序的运行没有帮助，主要用于对栈帧的回溯。因为sp时刻指向的栈顶，通过fp得知上一个栈帧的起始位置。

上图的调用栈对应的汇编代码如下。

  1. 8514行将当前的sp保存在ip中(ip只是个通用寄存器，用来在函数间分析和调用时暂存数据,通常为r12);
  2. 8518行将4个寄存器从右向左依次压栈。
  3. 851c行将保存的ip减4，得到当前被调用函数的fp地址，即指向栈里的pc位置。
  4. 8520行将sp减8，为栈空间开辟出8个字节的大小，用于存放局部便令。
 

  1. 00008514 <func1>:

  2. 8514: e1a0c00d mov ip, sp

  3. 8518: e92dd800 push {fp, ip, lr, pc}

  4. 851c: e24cb004 sub fp, ip, #4

  5. 8520: e24dd008 sub sp, sp, #8

  6. 8524: e3a03000 mov r3, #0

  7. 8528: e50b3010 str r3, [fp, #-16]

  8. 852c: e30805dc movw r0, #34268 ; 0x85dc

  9. 8530: e3400000 movt r0, #0

  10. 8534: ebffff9d bl 83b0 <puts@plt>

  11. 8538: e51b3010 ldr r3, [fp, #-16]

  12. 853c: e12fff33 blx r3

  13. 8540: e3a03000 mov r3, #0

  14. 8544: e1a00003 mov r0, r3

  15. 8548: e24bd00c sub sp, fp, #12

  16. 854c: e89da800 ldm sp, {fp, sp, pc}

-mapcs-frame编译选项

在第一节中，程序压栈的寄存器有{fp, ip, lr, pc} 4个，这是在gcc带有-mapcs-frame的编译选项下编译出来的。而gcc默认情况下的参数为mno-apcs-frame。关于该选项，gcc的手册描述为，

Generate a stack frame that is compliant with the ARM Procedure Call Standard for all functions, even if this is not strictly necessary for correct execution of the code. Specifying -fomit-frame-pointer with this option causes the stack frames not to be generated for leaf functions. The default is -mno-apcs-frame. This option is deprecated.

也就是说，该编译选项会产生(push {fp, ip, lr, pc})，保证栈帧的格式。如果没有-mapcs-frame，则不保证帧格式和当前帧格式，GCC生成的指令可能会发生各种变化。在AAPCS发布之后[附录1]，1993年的APCS就已经太旧了，所以
在gcc5.0之后，该选项已经被废弃。gcc5.0的更新记录写到：

The options -mapcs, -mapcs-frame, -mtpcs-frame and -mtpcs-leaf-frame which are only applicable to the old ABI have been deprecated.
至于该参数在将来是否会被gcc移除，那就不知道了。

将第一节中的程序重新使用默认编译选项，用4.7版本的gcc编译，结果如下。这时，fp还在，调用栈push了fp和lr到栈空间，新的fp指向了lr在栈中的位置。

 

  1. 00008514 <func1>:

  2. 8514: e92d4800 push {fp, lr}

  3. 8518: e28db004 add fp, sp, #4

  4. 851c: e24dd008 sub sp, sp, #8

  5. 8520: e3a03000 mov r3, #0

  6. 8524: e50b3008 str r3, [fp, #-8]

  7. 8528: e30805d4 movw r0, #34260 ; 0x85d4

  8. 852c: e3400000 movt r0, #0

  9. 8530: ebffff9e bl 83b0 <puts@plt>

  10. 8534: e51b3008 ldr r3, [fp, #-8]

  11. 8538: e12fff33 blx r3

  12. 853c: e3a03000 mov r3, #0

  13. 8540: e1a00003 mov r0, r3

  14. 8544: e24bd004 sub sp, fp, #4

  15. 8548: e8bd8800 pop {fp, pc}

  16.  

  17. 0000854c <main>:

  18. 854c: e92d4800 push {fp, lr}

  19. 8550: e28db004 add fp, sp, #4

  20. 8554: ebffffee bl 8514 <func1>

  21. 8558: e1a00003 mov r0, r3

  22. 855c: e8bd8800 pop {fp, pc}

使用gcc-7.3默认选项编译结果如下，fp已经不在了，虽然这里仍然可能通过r7得知上个栈帧的位置，但是已经没法使用fp获取栈帧了。此时是不保证栈帧保存在栈中的。所以依赖栈帧内容进行恢复已经非常不可靠。那么既然无法依赖fp，那该怎么进行栈帧回溯呢，gnu说使用unwind方法回溯，这节暂时不会介绍unwind方法。

 

  1. 000103c8 <func1>:

  2. 103c8: b580 push {r7, lr}

  3. 103ca: b082 sub sp, #8

  4. 103cc: af00 add r7, sp, #0

  5. 103ce: 2300 movs r3, #0

  6. 103d0: 607b str r3, [r7, #4]

  7. 103d2: f240 4048 movw r0, #1096 ; 0x448

  8. 103d6: f2c0 0001 movt r0, #1

  9. 103da: f7ff ef7e blx 102d8 <puts@plt>

  10. 103de: 687b ldr r3, [r7, #4]

  11. 103e0: 4798 blx r3

  12. 103e2: 2300 movs r3, #0

  13. 103e4: 4618 mov r0, r3

  14. 103e6: 3708 adds r7, #8

  15. 103e8: 46bd mov sp, r7

  16. 103ea: bd80 pop {r7, pc}

  17.  

  18. 000103ec <main>:

  19. 103ec: b580 push {r7, lr}

  20. 103ee: af00 add r7, sp, #0

  21. 103f0: f7ff ffea bl 103c8 <func1>

  22. 103f4: 2300 movs r3, #0

  23. 103f6: 4618 mov r0, r3

  24. 103f8: bd80 pop {r7, pc}

使用栈帧进行回溯

这一节使用gcc4.7版本，默认编译选项编译出来的程序，演示调用栈回溯。该编译选项下，压栈的寄存器为{fp, lr}。

下边的内容是一段core dump中的寄存器和调用栈，本节将对这段内容进行回溯。

 

  1. Reg: r9, Val = 0xf7578000; Reg: r10, Val = 0x00000001;

  2. Reg: fp, Val = 0x827d3104; Reg: ip, Val = 0xf7578ae0;

  3. Reg: sp, Val = 0x827d30e0; Reg: lr, Val = 0xf7549990;

  4. Reg: pc, Val = 0xf7548c20; Reg: cpsr, Val = 0x60000210;

  5.  

  6. 0x827d30e0: 0x00000031 0x827d31a0 0x00000001 0xd5dff060

  7. 0x827d30f0: 0xd5e0e6b1 0xd5dec134 0xf7578000 0xf7577c40

  8. 0x827d3100: 0x827d313c 0xf7549990

  9. 0x827d3140: 0x00000000 0xd5dec104 0xf7568514 0x00000002

  10. 0x827d3150: 0xd5dec104 0xf7577c40 0xf7577c38 0xd5de9224

  11. 0x827d3160: 0x827d31a0 0xf757a084 0xf7577c40 0xd5df6dd4

  12. 0x827d3170: 0x827d3194 0x00000001 0xd5e0e678 0xd5dec104

  13. 0x827d3180: 0xd5de9224 0xf7568548 0x00000000 0xf7568550

  1. 当前sp地址为0x827d30e0，fp地址为0x827d3104，从而得知当前函数frame0的栈帧。fp指向的地址0x827d3104为frame1的lr,0x827d3100为上一个栈帧的fp。
 

  1. 0x827d30e0: 0x00000031 0x827d31a0 0x00000001 0xd5dff060

  2. 0x827d30f0: 0xd5e0e6b1 0xd5dec134 0xf7578000 0xf7577c40

  3. 0x827d3100: 0x827d313c(fp) 0xf7549990(lr)

  1. 从frame0的fp地址0x827d313c可知，frame1的调用栈起始地址，去掉frame0的内容，得到frame1的栈帧。
 

  1. 0x827d312c 0xf7530c14

  2. 0x827d3110: 0xd5dff060 0x0000002c 0xd5e0e6b1 0xd5e0e6b1

  3. 0x827d3120: 0x00000001 0xd5e0e6b1 0xd5dff060 0xd5dec134

  4. 0x827d3130: 0xf7578000 0xf7577c40 0x827d3194(fp) 0xf754ad0c(lr)

  1. 依次类推，依次得到frame2、frame3...的栈帧。

当汇编代码的函数调用使用push {fp, ip, lr, pc}时，则上一个栈帧的fp2在当前栈帧的(fp - #4)位置。栈帧的回溯要结合程序的汇编代码具体分析，有可能程序并不使用fp指针，也有可能栈中根本没有保存fp。

unwind方法回溯

TODO

附录1-函数调用标准缩略语

  • PCS Procedure Call Standard.
  • AAPCS Procedure Call Standard for the ARM Architecture (this standard).
  • APCS ARM Procedure Call Standard (obsolete).
  • TPCS Thumb Procedure Call Standard (obsolete).
  • ATPCS ARM-Thumb Procedure Call Standard (precursor to this standar

参考资料

  1. ARM 体系结构概述
  2. Procedure Call Standard for the ARM® Architecture
  3. GCC 5 Release Series

转载于:https://www.cnblogs.com/your2b/p/9698216.html

llljjlj
关注
专栏目录
嵌入式arm开发C语言调用栈回溯实战
暧暧远人村，依依墟里烟 ...
05-12 978
嵌入式arm开发C语言调用栈回溯实战 参考: https://stackoverflow.com/questions/77005/how-to-automatically-generate-a-stacktrace-when-my-program-crashes 代码 #define _GNU_SOURCE #endif #ifndef __USE_GNU #define __USE_GNU #endif #include <execinfo.h> #include <signa
arm 函数栈回溯
qq_42693685的博客
07-26 2245
栈回溯
自己动手实现arm函数栈帧回溯
龙图腾的博客
01-22 3130
内核版本：2.6.14 glibc版本：2.3.6 CPU平台：arm glic中其实有这些函数,当时用的uclib版本较低,没有这些函数,但又需要,只能自己实现了(较高的版本应该有这些函数,换版本很麻烦),而且可以加深自己对这方面的理解.原理性的东西就不深入讲解了,直接上例子! [plain] view plaincopyprint? #in
ARM 栈和函数调用
最新发布
凉、介熙
09-21 1023
ARM 栈和函数调用
ARM backtrace 实战分析
热门推荐
墨染锦年的博客
10-24 1万+
ARM backtrace指的是在ARM架构下的程序调试过程中，获取当前函数调用栈帧的信息，以便定位问题所在。调用栈（Call Stack）是一种数据结构，用于记录函数调用的顺序和嵌套关系，每次函数调用都会在栈上分配一个栈帧（Stack Frame），保存了函数的局部变量、参数和返回地址等信息。backtrace是指获取调用栈的逆序列表，即从当前函数回溯到最开始的函数调用。ARM backtrace通常用于调试应用程序中的错误，如崩溃、段错误等。
arm栈帧回溯
02-13
arm栈帧回溯，自己实现arm-linux下的栈帧回溯，没有使用glibc的backstrace()和backtrace_symbols()，可以很好的调试segment fault问题。
ARM64架构栈帧回溯
小立仔
04-12 1783
ARM64架构栈帧回溯简介以及demo演示
arm下的栈回溯经验总结
jmdvirus
10-12 1266
摘要 arm下出现段错误，却没有回溯到具体的函数，一直在寻找这个问题的原因，在x86 之类的模式下同样的代码是有回溯的。 arm 32 位设备下测试 分析 尝试了很多方法，最终找到一些线索 基础知识 这里就是栈布局的基本原因，网上有很多说这个的，这个可以去尝试搜索一下，这边暂时不讲这方面的知识，网上太多了 主要说一下区别，x86模式下能回溯，arm下不能回溯，主要原因就是在于对栈布局的格式不同，x86模式下会有全面的入栈顺序，寄存器中的值是可能详细追踪具体位置的。 但是在arm下，可能因为速度等方面的追求，
ARM汇编学习笔记（栈回溯-1）
whatnamecaniuse的专栏
09-03 833
https://www.leadroyal.cn/p/1125/ 本系列文章共三篇。本文是第一篇，讲一些栈回溯的背景，不涉及技术细节。关键词：arm unwind，ehabi，arm stacktrace。 起因 故事要从几个月前的一个 arm crash 说起，把 crash 交给新来的小朋友看，他说 IDA 里显示的栈回溯和logcat里显示的栈回溯是不一致的，问我为什么。 我说一直是logcat里看的，是正确的；那么 ida 里只有一层栈回溯肯定是错的，但我却解释不来原因，于是有了.
arm平台根据栈进行backtrace的方法.docx
10-27
arm异常定位方法 包括 1.arm 中断、异常处理流程 2.arm异常时保存的寄存器 3.aapcs 用来分析如何进行backtrace 4.常见工具推荐
arm与arm64调用栈
09-15
ARM Procedure Call Standard定义了各寄存器在函数调用过程中的作用、基础类型的长度、以及函数调用基本准则，包括栈处理、参数传递等。 本文通过实例描述arm与arm64在函数调用过程中栈帧的处理方法，理解栈帧的特点对于理解反汇编代码和定位bug有重要意义。
巧用栈回溯，帮你快速定位问题
qq_42260970的博客
07-21 3302
在系统运行或调试过程中，程序总是出现一些出乎意料的现象（例如程序异常或者某个任务运行不是预料的）。为了帮助用户快速定位问题，减少出现问题难以定位的情况，操作系统中的栈回溯功能就显得十分重要。栈回溯到底是什么？又该如何使用呢？下面让我们一起来详细了解一下吧！（学会了这一招，以后遇到难以定位的问题还怕啥？）...
(重磅原创)冬之焱: 谈谈Linux内核的栈回溯与妙用
sunshineywz的博客
04-20 648
1 前言 如下演示的是linux内核崩溃的一个栈回溯打印，有了这个崩溃打印我们能很快定位到在内核哪个函数崩溃，大概在函数什么位置，大大简化了问题排查过程。 网上或多或少都能找到栈回溯的一些文章，但是讲的都并不完整，没有将内核栈回溯的功能用于实际的内核、应用程序调试，这是本篇文章的核心：尽可能引导读者将栈回溯的功能用于实际项目调试，栈回溯的功能很强大。 本文详细讲解了基于mips、arm架构lin...
函数调用栈帧回溯
sunshineywz的博客
05-15 1537
本文以Linux + arm64平台上的测试程序为例，讲解函数调用的栈帧回溯基本原理。 1. Overview 2. Demo 2.1 堆栈 Thread 9 (LWP 1386): #0 0x0000007faec8fd28 in ?? () #1 0x0000007faf208190 in osal_memcpy (dst=0x7f0e6cc727, src=0x7f08024180, count=32477) at vdi/linux/vdi_osal.c:335 #2 0x0000007fa
ELF文件——栈回溯
qq_35018427的博客
09-26 2811
前言 本文以libunwind库对栈回溯流程进行描述。 libunwind栈回溯流程 libunwind包含两套使用接口，分别以前缀unw_和_Unwind标识，其中_Unwind前缀的接口是供C++异常处理的高级函数接口，unw前缀的则是更为底层通用的接口。根据libunwind代码中的configure.ac文件，在arm架构下是不使能C++的异常处理的，所以栈回溯使用的接口均为前缀位unw的函数接口。 AC_MSG_CHECKING([whether to enable C++ exception s
ARM Linux 手写实现栈回溯
Chasing_Chasing的博客
02-13 2350
        在开发中遇到这样一个问题，程序要跑很久才会出现一次崩溃，由于系统有硬件看门狗，因此程序在崩溃时coredump文件都没生成就已经重启了，这对定位程序bug代价严重。gdb可以对程序错误有很好的定位，因此为了模仿gdb这种从出错函数回溯的功能，于是想实现能否程序中也能实现这个。        一开始，想看gdb源码，但是真的太多太复杂了（不是一般人看的，神人看的）。后来就探究Lin...
ARMv7-A 那些事 - 7.栈回溯浅析
Ailson Jack的专栏
10-14 442
在嵌入式开发过程中，经常需要对代码进行调试来解决各种各样的问题，常用的调试手段有：(1)、开发环境搭配硬件仿真器进行在线调试。优点：调试过程中能够清楚的知道各个寄存器的值以及各个变量的值，程序的执行流程也能够一目了然。缺点：板卡需要引出硬件仿真器的连接口，并且需要购买硬件仿真器。(2)、通过调试串口打印信息梳理程序的执行流程，结合代码分析问题产生的原因。
vxworks栈回溯源码
09-23
### 回答1： 以下是 VxWorks 中获取栈回溯信息的源码示例： ```c void stackTraceTaskPrint (int tid) { REG_SET regSet; WIND_TCB *pTcb = taskIdVerify (tid); if (pTcb == NULL) return; if (taskRegsGet (tid, &regSet) != OK) return; printf ("Stack trace for task %#x (%s):\n", (int) pTcb, pTcb->name); stackTracePrint ((char *) pTcb->name, tid, (char *) regSet.spReg, (char *) regSet.pc); } ``` 此函数获取给定任务 ID 的任务控制块，并通过 taskRegsGet 函数获取该任务的寄存器值，然后调用 stackTracePrint 函数打印该任务的栈回溯信息。 ```c void stackTracePrint (char *name, int tid, char *sp, char *pc) { int count; char **list; list = (char **) malloc (MAX_TRACE_DEPTH * sizeof (char *)); if (list == NULL) return; count = stackTrace (tid, sp, pc, list, MAX_TRACE_DEPTH); printf ("Stack trace for task %#x (%s):\n", tid, name); stackTraceDepthPrint (list, count); free (list); } ``` 此函数分配堆内存以存储栈回溯信息，并调用 stackTrace 函数获取栈回溯信息。然后它将回溯信息作为参数传递给 stackTraceDepthPrint 函数，以打印栈回溯信息。 ```c int stackTrace (int tid, char *sp, char *pc, char **pList, int maxDepth) { int i = 0; int depth = 0; FUNCPTR funcPtr; char *nextPc; char **list = pList; while (i < maxDepth) { if (taskIdVerify (tid) == NULL) break; if (i == 0) { if (pc == 0) break; funcPtr = (FUNCPTR) pc; } else { if (nextPc == 0) break; funcPtr = (FUNCPTR) (nextPc - CALL_INSTR_SIZE); } if (funcPtr == NULL) break; *list++ = (char *) funcPtr; depth++; i++; if (taskRegsStackProbe (tid, (char *) funcPtr, &nextPc) != OK) break; } return (depth); } ``` 此函数根据给定的任务 ID、堆栈指针和程序计数器获取栈回溯信息。它使用 taskRegsStackProbe 函数来确定每个函数调用的下一个程序计数器值，并将每个函数的地址存储在列表中。如果达到最大深度或无法确定下一个程序计数器，则停止回溯。 ```c void stackTraceDepthPrint (char **list, int depth) { int i; for (i = 0; i < depth; i++) printf ("%s\n", symFindByValue ((int) list[i], N_TEXT, (char **) NULL, (char **) NULL)); } ``` 此函数用于打印回溯列表中的每个函数地址对应的符号名称。它使用 symFindByValue 函数查找每个地址对应的符号名称，并将其打印到控制台上。 ### 回答2： vxWorks是一款实时操作系统，它的栈回溯功能可以帮助开发人员定位程序的异常或错误。栈回溯是指在程序发生异常或错误时，通过分析程序运行时的调用栈来定位出错的源码位置。 在vxWorks中，栈回溯功能是通过函数backtrace()实现的。backtrace()函数会返回当前函数调用栈的信息，包括每个函数的返回地址和参数值。使用该函数可以获取当前栈的信息，然后通过解析栈信息，可以找到调用栈中每个函数的源码位置。 具体的栈回溯源码如下： 1. 定义一个结构体存储函数调用栈信息： ```c #define MAX_STACK_FRAMES 50 typedef struct { void *returnAddr; void *args[MAX_ARGS]; } StackFrame; ``` 2. 定义栈回溯函数backtrace()，该函数会获取当前函数调用栈信息： ```c void backtrace(StackFrame *frames, int maxFrames) { int frameCount = 0; // 使用汇编指令获取栈帧信息 // 将返回地址和参数值存储到StackFrame结构体中 while (frameCount < maxFrames && frameCount < MAX_STACK_FRAMES) { frames[frameCount].returnAddr = __builtin_return_address(frameCount); frameCount++; } } ``` 3. 在需要进行栈回溯的地方，调用backtrace()函数，并解析栈信息： ```c StackFrame frames[MAX_STACK_FRAMES]; backtrace(frames, MAX_STACK_FRAMES); for (int i = 0; i < MAX_STACK_FRAMES; i++) { void *returnAddr = frames[i].returnAddr; // 解析返回地址和参数值，找到对应的源码位置 // 打印出错函数、源码文件名和行号等信息 } ``` 通过以上的源码实现，我们可以获取程序运行时的调用栈信息，从而快速定位程序的异常或错误源码位置。这对于调试程序非常有帮助，可以提高开发效率。 ### 回答3： vxWorks是一个实时操作系统，它提供了栈回溯功能，可以帮助开发人员快速定位程序中的问题。 在vxWorks中，栈回溯源码的实现是基于任务控制块（Task Control Block, TCB）和堆栈溢出检测技术。 首先，每个任务在TCB中都有一个指向堆栈顶部的指针，通过这个指针可以访问任务的堆栈。当任务运行时，它的函数调用和局部变量会存储在堆栈中。当任务出现问题时，可以通过访问任务的堆栈来获取栈回溯信息。 在vxWorks中，堆栈溢出检测技术可以帮助检测任务是否发生了栈溢出。当任务的堆栈溢出时，会触发一个硬件中断。当这个中断发生时，系统会保存当前的寄存器状态，并调用栈回溯函数。 栈回溯函数是vxWorks中栈回溯功能的核心。它会逐级遍历任务的调用栈，获取每一级函数的返回地址和参数，并将这些信息打印输出。这样，开发人员就可以根据栈回溯信息来定位程序中的问题。 栈回溯函数的源码在vxWorks的源代码中可以找到，一般位于目录"vxworks\kernel\lib"中。栈回溯函数会使用汇编语言和C语言混合编程实现，通过访问任务的堆栈来获取栈回溯信息，然后将这些信息格式化输出。 总之，vxWorks提供了栈回溯源码，开发人员可以通过它来定位程序中的问题。栈回溯的实现依赖于任务的堆栈和堆栈溢出检测技术，通过遍历任务的调用栈获取栈回溯信息，并将其打印输出。这样，开发人员就可以根据栈回溯信息来进行程序调试和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值