[add] #define PRINT_COREDUMP_INFO_STRING 1 // 打印字符串格式的coredump信息

Middlewares/MCoreDump/arch/armv7m/armv7m.c

@@ -386,5 +386,5 @@ int armv7m_hard_fault_exception_hook(void *context)
     /* Generate coredump using memory mode */
     mcd_faultdump(MCD_OUTPUT_FAULT_SERIAL);
 
-    return 0;
+    return (int)stack_ptr;
 }

Middlewares/MCoreDump/arch/armv7m/registers.h

@@ -62,6 +62,39 @@ struct arm_vfpv2_regset
 typedef struct armv7m_core_regset    core_regset_type;
 typedef struct arm_vfpv2_regset      fp_regset_type;
 
+struct exception_stack_frame
+{
+    rt_uint32_t r0;
+    rt_uint32_t r1;
+    rt_uint32_t r2;
+    rt_uint32_t r3;
+    rt_uint32_t r12;
+    rt_uint32_t lr;
+    rt_uint32_t pc;
+    rt_uint32_t psr;
+};
+
+struct stack_frame
+{
+    /* r4 ~ r11 register */
+    rt_uint32_t r4;
+    rt_uint32_t r5;
+    rt_uint32_t r6;
+    rt_uint32_t r7;
+    rt_uint32_t r8;
+    rt_uint32_t r9;
+    rt_uint32_t r10;
+    rt_uint32_t r11;
+
+    struct exception_stack_frame exception_stack_frame;
+};
+
+struct exception_info
+{
+    rt_uint32_t exc_return;
+    struct stack_frame stack_frame;
+};
+
 #ifdef __cplusplus
 }
 #endif

Middlewares/MCoreDump/osal/rtthread.c

@@ -12,6 +12,8 @@
 #include "coredump.h"
 #include "mcd_arch_interface.h"
 
+#define PRINT_COREDUMP_INFO_STRING 1 // 打印字符串格式的coredump信息
+
 /*
  * RT-Thread OS abstraction layer implementation for MCoreDump
  */
@@ -127,8 +129,10 @@ static void rtthread_thread_register(struct thread_info_ops *ops, int32_t idx,
                     /* Debug: Dynamic thread for comparison */
                     collect_registers((uint32_t *)thread->sp, core_regset, fp_regset);
                 }
+
                 return;
             }
+
             idx_l++;
         }
     }
@@ -179,6 +183,7 @@ static int32_t rtthread_get_memarea(struct thread_info_ops *ops, int32_t idx,
                 }
                 return 0;
             }
+
             idx_l++;
         }
     }
@@ -198,9 +203,143 @@ void mcd_rtos_thread_ops(struct thread_info_ops *ops)
     priv.thr_cnts = -1;
 }
 
+#if PRINT_COREDUMP_INFO_STRING
+static void DumpRegisters(struct stack_frame *sp, char *thread)
+{
+#if USE_FPU
+    if (sp->flag) /* 使用FPU */
+    {
+        struct stack_frame_fpu *sp_fpu = (struct stack_frame_fpu *)sp;
+        mcd_print("Registers@%s\n", thread);
+        mcd_print("R0: 0x%08x\n", sp_fpu->exception_stack_frame.r0);
+        mcd_print("R1: 0x%08x\n", sp_fpu->exception_stack_frame.r1);
+        mcd_print("R2: 0x%08x\n", sp_fpu->exception_stack_frame.r2);
+        mcd_print("R3: 0x%08x\n", sp_fpu->exception_stack_frame.r3);
+        mcd_print("R4: 0x%08x\n", sp_fpu->r4);
+        mcd_print("R5: 0x%08x\n", sp_fpu->r5);
+        mcd_print("R6: 0x%08x\n", sp_fpu->r6);
+        mcd_print("R7: 0x%08x\n", sp_fpu->r7);
+        mcd_print("R8: 0x%08x\n", sp_fpu->r8);
+        mcd_print("R9: 0x%08x\n", sp_fpu->r9);
+        mcd_print("R10: 0x%08x\n", sp_fpu->r10);
+        mcd_print("R11: 0x%08x\n", sp_fpu->r11);
+        mcd_print("R12: 0x%08x\n", sp_fpu->exception_stack_frame.r12);
+        mcd_print("R13(sp_fpu): 0x%08x\n", (uint32_t)sp_fpu + sizeof(*sp_fpu));
+        mcd_print("R14(LR): 0x%08x\n", sp_fpu->exception_stack_frame.lr);
+        mcd_print("R15(PC): 0x%08x\n", sp_fpu->exception_stack_frame.pc);
+        mcd_print("xPSR: 0x%08x\n", sp_fpu->exception_stack_frame.psr);
+    }
+    else
+#endif
+    {
+        mcd_print("Registers@%s\n", thread);
+        mcd_print("R0: 0x%08x\n", sp->exception_stack_frame.r0);
+        mcd_print("R1: 0x%08x\n", sp->exception_stack_frame.r1);
+        mcd_print("R2: 0x%08x\n", sp->exception_stack_frame.r2);
+        mcd_print("R3: 0x%08x\n", sp->exception_stack_frame.r3);
+        mcd_print("R4: 0x%08x\n", sp->r4);
+        mcd_print("R5: 0x%08x\n", sp->r5);
+        mcd_print("R6: 0x%08x\n", sp->r6);
+        mcd_print("R7: 0x%08x\n", sp->r7);
+        mcd_print("R8: 0x%08x\n", sp->r8);
+        mcd_print("R9: 0x%08x\n", sp->r9);
+        mcd_print("R10: 0x%08x\n", sp->r10);
+        mcd_print("R11: 0x%08x\n", sp->r11);
+        mcd_print("R12: 0x%08x\n", sp->exception_stack_frame.r12);
+        mcd_print("R13(SP): 0x%08x\n", (uint32_t)sp + sizeof(*sp));
+        mcd_print("R14(LR): 0x%08x\n", sp->exception_stack_frame.lr);
+        mcd_print("R15(PC): 0x%08x\n", sp->exception_stack_frame.pc);
+        mcd_print("xPSR: 0x%08x\n", sp->exception_stack_frame.psr);
+    }
+}
+
+static void DumpMem(uint32_t addr, uint32_t len)
+{
+    uint32_t *paddr;
+    uint32_t i;
+
+    if (len == 0)
+        return;
+
+    paddr = (uint32_t *)addr;
+    mcd_print("mem@0x%08x,0x%08x\n", addr, len);
+
+    for (i = 0; i < len;)
+    {
+        mcd_print("0x%08x", *paddr);
+        paddr++;
+
+        i += 4;
+        if (i % 16 == 0)
+            mcd_print("\n");
+        else
+            mcd_print(" ");
+    }
+
+    mcd_print("\n");
+
+    if (len % 16 != 0)
+        mcd_print("\n");
+}
+
+static int _print_coredump_info_string(uint32_t cur_thread_regsiter)
+{
+    struct thread_info_ops ops;
+    mcd_rtos_thread_ops(&ops);
+    rt_int32_t current_idx = rtthread_cur_index(&ops);
+    rt_int32_t idx_l = 0;
+    struct rt_object_information *information;
+    struct rt_object *object;
+    struct rt_list_node *node;
+    uint32_t addr;
+    uint32_t memlen;
+
+    information = rt_object_get_information(RT_Object_Class_Thread);
+    mcd_assert(information != RT_NULL);
+
+    for (node = information->object_list.next; node != &(information->object_list); node = node->next)
+    {
+        object = rt_list_entry(node, struct rt_object, list);
+        rt_thread_t thread = (rt_thread_t)object;
+
+        if (is_thread_object(thread))
+        {
+            /* If this is the current thread, use current stack pointer */
+            if (idx_l == current_idx)
+            {
+                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;
+
+                if (memlen > thread->stack_size)
+                {
+                    mcd_println("The stack may overflow!!!");
+                    memlen = thread->stack_size;
+                }
+
+                DumpRegisters((void *)cur_thread_regsiter, thread->name);
+            }
+            else
+            {
+                addr = (rt_uint32_t)thread->sp;
+                memlen = (rt_uint32_t)thread->stack_addr + thread->stack_size - (rt_uint32_t)thread->sp;
+                DumpRegisters(thread->sp, thread->name);
+            }
+
+            DumpMem(addr, memlen);
+            idx_l++;
+        }
+    }
+
+    return 0;
+}
+#endif
+
 MCD_WEAK rt_err_t rtt_hard_fault_exception_hook(void *context)
 {
-    arch_hard_fault_exception_hook(context);
+    uint32_t cur_thread_regsiter = arch_hard_fault_exception_hook(context);
+#if PRINT_COREDUMP_INFO_STRING
+    _print_coredump_info_string(cur_thread_regsiter);
+#endif
     return -RT_ERROR;
 }