[update]

Middlewares/MCoreDump/addr2line/addr2line.c

 #include <rtthread.h>
 #include "addr2line.h"
 
-#define PROJECT_NAME "project"
+#define PROJECT_NAME "project.out"
 #define addr2line_print rt_kprintf
 
 // 错误类型打印
     }
 }
 
+// 只会找符合要求的lr，不能找pc值。所以要指定pc
 void addr2line_cmd_with_pc_print(uint32_t *thread_pc, uint32_t *addr, int size)
 {
     addr2line_print("addr2line -e " PROJECT_NAME " -a -f ");
 
         if (pc % 2 == 0) // thumb 指令pc寄存器值一定是偶数
             continue;
-        
 
         pc = lr - 1; // lr寄存器值保存的是pc+1
 
         if ((uint32_t)thread_pc == pc) // 忽略：已经指定打印过了
             continue;
 
-        if (true == disassembly_ins_is_bl_blx(pc - sizeof(size_t))) // pc 的上一条指令是跳转指令
+        if (true == disassembly_ins_is_bl_blx(pc - sizeof(size_t))) // pc 的上一条指令是跳转指
+        {
+//          if (i + 1 < size && pc != addr[i + 1] && true == is_in_text(addr[i + 1])) // 最后一次调用的情况：LR、PC还在CPU寄存器里面挨着的
+//          {
+//              addr2line_print("%08x ", addr[i + 1]);
+//              i++;
+//          }
+
             addr2line_print("%08x ", pc);
+        }
     }
 
-    addr2line_print("\n\n");
+    addr2line_print("\n");
 }
 
 void addr2line_cmd_print(uint32_t *addr, int size)

Middlewares/MCoreDump/arch/armv7m/armv7m.c

 void print_registers_armv7m(core_regset_type *reg, fp_regset_type *fp_reg, char *thread)
 {
     mcd_print("Registers@%s\n", thread);
+    mcd_print("R13(SP): 0x%08x\n", reg->sp);
+#if 0
     mcd_print("R0: 0x%08x\n", reg->r0);
     mcd_print("R1: 0x%08x\n", reg->r1);
     mcd_print("R2: 0x%08x\n", reg->r2);
     mcd_print("R14(LR): 0x%08x\n", reg->lr);
     mcd_print("R15(PC): 0x%08x\n", reg->pc);
     mcd_print("xPSR: 0x%08x\n", reg->xpsr);
+#else // 按压栈顺序打印
+    mcd_print("xPSR: 0x%08x\n", reg->xpsr);
+    mcd_print("R15(PC): 0x%08x\n", reg->pc);
+    mcd_print("R14(LR): 0x%08x\n", reg->lr);
+    mcd_print("R12: 0x%08x\n", reg->r12);
+    mcd_print("R3: 0x%08x\n", reg->r3);
+    mcd_print("R2: 0x%08x\n", reg->r2);
+    mcd_print("R1: 0x%08x\n", reg->r1);
+    mcd_print("R0: 0x%08x\n", reg->r0);
+    mcd_print("R11: 0x%08x\n", reg->r11);
+    mcd_print("R10: 0x%08x\n", reg->r10);
+    mcd_print("R9: 0x%08x\n", reg->r9);
+    mcd_print("R8: 0x%08x\n", reg->r8);
+    mcd_print("R7: 0x%08x\n", reg->r7);
+    mcd_print("R6: 0x%08x\n", reg->r6);
+    mcd_print("R5: 0x%08x\n", reg->r5);
+    mcd_print("R4: 0x%08x\n", reg->r4);
+#endif
 }
 
 /**
 #else
     uint32_t *stack_ptr = context;
     stack_ptr += 1; /* 跳过：exc_return */
-//  stack_ptr += 1; // 如开启fpuflag
+    //  stack_ptr += 1; // 如开启fpuflag
 #endif
 
     /*

Middlewares/MCoreDump/rtthread_port.c

 #include "addr2line/addr2line.h"
 
 #define PRINT_COREDUMP_INFO_STRING 1 // 打印字符串格式的coredump信息
+#define STACK_CORE_REG_SIZE (17 * 4) // 16个自动+手动压栈寄存器 + exe_return
+#define STACK_FPU_REG_SIZE (17 * 4) // 17个自动压栈的浮点寄存器
 
 /*
  * RT-Thread OS abstraction layer implementation for MCoreDump
                 {
                     *addr = get_cur_core_regset_address()->sp;  // 异常中填充
                     *memlen = (rt_uint32_t)thread->stack_addr + thread->stack_size - (rt_uint32_t)thread->sp;
-
+                    *addr -= STACK_CORE_REG_SIZE; // 异常中断里面已经压栈了但还没更新tcb里面的sp指针
+                    *memlen += STACK_CORE_REG_SIZE * 2; // 前后括大两倍：实际可能更多局部变量在死机前还没来得及向下增长sp
+#if MCD_FPU_SUPPORT
+                    /* Read FPU flag first - indicates if FPU context was saved */
+                    uint32_t fpu_flag = *(uint32_t *)thread->sp;
+                    *addr -= 1;
+                    *memlen += 1;
+
+                    if (fpu_flag)
+                    {
+                        *addr -= STACK_FPU_REG_SIZE; // 异常中断里面已经压栈了但还没更新tcb里面的sp指针
+                        *memlen += STACK_FPU_REG_SIZE;
+                    }
+#endif
                     if (*memlen > thread->stack_size)
                     {
                         mcd_println("The stack may overflow!!!");
             {
                 addr = (rt_uint32_t)get_cur_core_regset_address()->sp;      // 异常中填充
                 memlen = (rt_uint32_t)thread->stack_addr + thread->stack_size - (rt_uint32_t)thread->sp;
-
+                addr -= STACK_CORE_REG_SIZE; // 异常中断里面已经压栈了但还没更新tcb里面的sp指针
+                memlen += STACK_CORE_REG_SIZE * 2; // 前后括大两倍：实际可能更多局部变量在死机前还没来得及向下增长sp
+#if MCD_FPU_SUPPORT
+                /* Read FPU flag first - indicates if FPU context was saved */
+                uint32_t fpu_flag = *(uint32_t *)thread->sp;
+                addr -= 1;
+                memlen += 1;
+
+                if (fpu_flag)
+                {
+                    addr -= STACK_FPU_REG_SIZE; // 异常中断里面已经压栈了但还没更新tcb里面的sp指针
+                    memlen += STACK_FPU_REG_SIZE;
+                }
+#endif
                 if (memlen > thread->stack_size)
                 {
                     mcd_println("The stack may overflow!!!");
                 }
 
                 print_registers((void *)get_cur_core_regset_address(), get_cur_fp_regset_address(), thread->name);
-#define STACK_FRAME_SIZE (17 * 4) // 17个寄存器
-                rt_uint32_t addr2 = (rt_uint32_t)thread->sp - STACK_FRAME_SIZE;
-                addr2line_cmd_with_pc_print((rt_uint32_t *)get_cur_core_regset_address()->pc, (uint32_t *)addr2, memlen + STACK_FRAME_SIZE);
+                addr2line_cmd_with_pc_print((rt_uint32_t *)get_cur_core_regset_address()->pc, (uint32_t *)addr, memlen);
             }
             else
             {