[add] 文件目录整理

EWARM/stm32_broad_mini.ewp

                     <state>$PROJ_DIR$/../Middlewares/rtthread/include</state>
                     <state>$PROJ_DIR$/../Middlewares/rtthread/include/libc</state>
                     <state>$PROJ_DIR$/../Middlewares/rtthread/finsh</state>
-                    <state>$PROJ_DIR$/../Middlewares/MCoreDump/src/arm</state>
-                    <state>$PROJ_DIR$/../Middlewares/MCoreDump/inc</state>
-                    <state>$PROJ_DIR$/../Middlewares/MCoreDump/arch</state>
-                    <state>$PROJ_DIR$/../Middlewares/MCoreDump/arch/armv7m</state>
+                    <state>$PROJ_DIR$/../Middlewares/MCoreDump</state>
                 </option>
                 <option>
                     <name>CCStdIncCheck</name>
                     <name>$PROJ_DIR$\..\Middlewares\MCoreDump\arch\armv7m\armv7m.c</name>
                 </file>
             </group>
-            <group>
-                <name>osal</name>
-                <file>
-                    <name>$PROJ_DIR$\..\Middlewares\MCoreDump\osal\rtthread.c</name>
-                </file>
-            </group>
-            <group>
-                <name>src</name>
-                <file>
-                    <name>$PROJ_DIR$\..\Middlewares\MCoreDump\src\coredump.c</name>
-                </file>
-                <file>
-                    <name>$PROJ_DIR$\..\Middlewares\MCoreDump\src\faultdump.c</name>
-                </file>
-                <file>
-                    <name>$PROJ_DIR$\..\Middlewares\MCoreDump\src\arm\mcd_arm.c</name>
-                </file>
-            </group>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\MCoreDump\coredump.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\MCoreDump\faultdump.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\MCoreDump\arm\mcd_arm.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\MCoreDump\rtthread_port.c</name>
+            </file>
         </group>
         <group>
             <name>RTT</name>

Middlewares/MCoreDump/arch/armv7m/armv7m.c

     struct thread_info_ops ops;
     mcd_rtos_thread_ops(&ops);
     mcd_gen_coredump(&ops);
+
+    if (ops.print_info_string)
+        ops.print_info_string(&ops);
 }
 
 // 只保存当前线程或非线程（主栈）：更新当前寄存器到全局变量
 
     mcd_mini_dump_ops(&ops);
     mcd_gen_coredump(&ops);
+
+    if (ops.print_info_string)
+        ops.print_info_string(&ops);
 }
 
 // 保存RTOS所有线程：更新当前寄存器到全局变量
 
     mcd_rtos_thread_ops(&ops);
     mcd_gen_coredump(&ops);
+
+    if (ops.print_info_string)
+        ops.print_info_string(&ops);
 }
 
 #endif
 
+void print_registers_armv7m(core_regset_type *reg, fp_regset_type *fp_reg, char *thread)
+{
+    mcd_print("Registers@%s\n", thread);
+    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("R3: 0x%08x\n", reg->r3);
+    mcd_print("R4: 0x%08x\n", reg->r4);
+    mcd_print("R5: 0x%08x\n", reg->r5);
+    mcd_print("R6: 0x%08x\n", reg->r6);
+    mcd_print("R7: 0x%08x\n", reg->r7);
+    mcd_print("R8: 0x%08x\n", reg->r8);
+    mcd_print("R9: 0x%08x\n", reg->r9);
+    mcd_print("R10: 0x%08x\n", reg->r10);
+    mcd_print("R11: 0x%08x\n", reg->r11);
+    mcd_print("R12: 0x%08x\n", reg->r12);
+    mcd_print("R13(SP): 0x%08x\n", reg->sp);
+    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);
+}
+
+void print_mem_armv7m(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");
+}
+
 /**
  * @brief Collect ARM Cortex-M4 registers from RT-Thread stack frame
  *
  * @param core_regset Pointer to structure for storing ARM core registers
  * @param fp_regset Pointer to structure for storing FPU registers
  */
+// 通过sp指针得到寄存器信息
 void collect_registers_armv7m(uint32_t *stack_top, core_regset_type *core_regset, fp_regset_type *fp_regset)
 {
     /*
 //  stack_ptr += 1; // 如开启fpuflag
 #endif
 
-    //extern void DumpCore(void *sp);
-    //DumpCore(stack_ptr);
-
     /*
      * Now stack_ptr points to where collect_registers_armv7m expects:
      * - With FPU: points to FPU flag (first field to be read)
      * - Without FPU: points to r4 (first register to be read)
      */
-    collect_registers_armv7m(stack_ptr,
-                             get_cur_core_regset_address(),
-                             get_cur_fp_regset_address());
-
+    collect_registers_armv7m(stack_ptr, get_cur_core_regset_address(), get_cur_fp_regset_address());
     /* Generate coredump using memory mode */
     mcd_faultdump(MCD_OUTPUT_FAULT_SERIAL);
-
-    return (int)stack_ptr;
+    return 0;
 }

Middlewares/MCoreDump/arch/mcd_arch_interface.h

 
 /**
  * @brief Architecture-specific hard fault exception handler
- * 
+ *
  * This function should be implemented by each supported architecture
  * to handle the architecture-specific stack frame processing.
- * 
+ *
  * @param context Pointer to exception context (architecture-specific format)
  * @return int Always returns -1 to indicate fault condition
  */
 
 /**
  * @brief Architecture-specific register collection function
- * 
+ *
  * This function extracts register values from the architecture-specific
  * stack frame format and stores them in the standard register sets.
- * 
+ *
  * @param stack_top Pointer to the stack frame
- * @param core_regset Pointer to store ARM core registers  
+ * @param core_regset Pointer to store ARM core registers
  * @param fp_regset Pointer to store FPU registers
  */
-void collect_registers_armv7m(uint32_t *stack_top,
-                             core_regset_type *core_regset,
-                             fp_regset_type *fp_regset);
+void collect_registers_armv7m(uint32_t *stack_top, core_regset_type *core_regset, fp_regset_type *fp_regset);
+
+// 打印寄存器
+void print_registers_armv7m(core_regset_type *reg, fp_regset_type *fp_reg, char *thread);
+// 打印一段内存
+void print_mem_armv7m(uint32_t addr, uint32_t len);
 
 /* Generic interface macro for architecture-agnostic code */
-#define collect_registers collect_registers_armv7m
-#endif
+    #define collect_registers collect_registers_armv7m
+    #define print_registers print_registers_armv7m
+    #define print_mem print_mem_armv7m
+    #define arch_hard_fault_exception_hook armv7m_hard_fault_exception_hook
 
-#ifdef PKG_USING_MCOREDUMP_ARCH_ARMV8M
+#elif defined(PKG_USING_MCOREDUMP_ARCH_ARMV8M)
 int armv8m_hard_fault_exception_hook(void *context);
 
 /**
  * @brief Architecture-specific register collection function
- * 
+ *
  * This function extracts register values from the architecture-specific
  * stack frame format and stores them in the standard register sets.
- * 
+ *
  * @param stack_top Pointer to the stack frame
- * @param core_regset Pointer to store ARM core registers  
+ * @param core_regset Pointer to store ARM core registers
  * @param fp_regset Pointer to store FPU registers
  */
-void collect_registers_armv8m(uint32_t *stack_top,
-                             core_regset_type *core_regset,
-                             fp_regset_type *fp_regset);
+void collect_registers_armv8m(uint32_t *stack_top, core_regset_type *core_regset, fp_regset_type *fp_regset);
 
 /* Generic interface macro for architecture-agnostic code */
-#define collect_registers collect_registers_armv8m
+    #define collect_registers collect_registers_armv8m
+    #define print_registers
+    #define print_mem
+    #define arch_hard_fault_exception_hook armv8m_hard_fault_exception_hook
+#else
+    #error "MCoredump does not support this architecture"
 #endif
 
 #endif /* __MCD_ARCH_INTERFACE_H__ */

Middlewares/MCoreDump/src/arm/mcd_arm_define.h → Middlewares/MCoreDump/arm/mcd_arm_define.h

 #ifndef __MCD_ARM_DEFINE_H__
 #define __MCD_ARM_DEFINE_H__
 
-#include "registers.h"
+#include "arch/armv7m/registers.h"
 
 /* ARM Architecture Detection */
 #if defined(__aarch64__) || defined(_M_ARM64)

Middlewares/MCoreDump/src/coredump.c → Middlewares/MCoreDump/coredump.c

 #include <string.h>
 #include "coredump.h"
 #include "mcd_elf_define.h"
-#include "mcd_arm_define.h"
+#include "arm\mcd_arm_define.h"
 
 typedef uint16_t elf_half;
 typedef uint32_t elf_word;
     memset(&m_ctx, 0, sizeof(mcd_instance_t));
     m_ctx.stack_size = 1536;
     m_ctx.writeout_func = func;
-    
+
     /* Automatically detect FPU support based on compiler definitions */
     m_ctx.with_fp = MCD_FPU_SUPPORT;
 }
     *addr &= CORE_MEM_LINE_MASK;
 }
 
-// Éú³É.elfÎļþ
+// 生�.elf格�
 void mcd_gen_coredump(struct thread_info_ops *ops)
 {
     int note_size;

Middlewares/MCoreDump/inc/coredump.h → Middlewares/MCoreDump/coredump.h

 #define __COREDUMP_H__
 
 #include "mcd_cfg.h"
-#include "mcd_arm_define.h"
+#include "arm/mcd_arm_define.h"
 
 /**
  * @brief Function pointer type for coredump data output
     int32_t (*get_memarea)(struct thread_info_ops *, int32_t,
                            uint32_t *, uint32_t *);
 
+    // 打印字符串形式的coredump信息
+    int (*print_info_string)(struct thread_info_ops *);
+
     /** Private data for RTOS-specific implementations */
     void *priv;
 };

Middlewares/MCoreDump/example/mcd_example.c

-/*
- * Copyright (c) 2025, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2025-08-16     Rbb666       first version
- */
-
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include "coredump.h"
-
-typedef void (*fault_func)(float);
-
-static int mcd_test(int argc, char **argv)
-{
-    int x, y;
-    const char * sx = "84597";
-    const char * sy = "35268";
-
-    float a, b, c;
-    const char * fsa = "1.1322";
-    const char * fsb = "45.2547";
-    const char * fsc = "7854.2";
-
-    if (argc < 2)
-    {
-        rt_kprintf("Please input 'mcd_test <COREDUMP|ASSERT|FAULT>' \n");
-        return 0;
-    }
-
-    if (!strcmp(argv[1], "COREDUMP"))
-    {
-        mcd_faultdump(MCD_OUTPUT_SERIAL);
-        return 0;
-    }
-    else if (!strcmp(argv[1], "ASSERT"))
-    {
-        a = atof(&fsa[0]);
-        b = atof(&fsb[0]);
-        c = atof(&fsc[0]);
-
-        x = atoi(&sx[0]);
-        y = atoi(&sy[0]);
-
-        mcd_assert(x * a == y * b * c);
-        return 0;
-    }
-    else if (!strcmp(argv[1], "FAULT"))
-    {
-        fault_func func = (fault_func)0xFFFF0000;
-        
-        a = atof(&fsa[0]);
-        b = atof(&fsb[0]);
-        c = atof(&fsc[0]);
-
-        x = atoi(&sx[0]);
-        y = atoi(&sy[0]);
-
-        func(x * a + y * b * c);
-        return 0;
-    }
-    
-    return 0;
-}
-MCD_CMD_EXPORT(mcd_test, mCoreDump test: mcd_test <COREDUMP|FLOAT|ASSERT|FAULT>);

Middlewares/MCoreDump/osal/rtthread.c → Middlewares/MCoreDump/rtthread_port.c

 
 #include <rtthread.h>
 #include "coredump.h"
-#include "mcd_arch_interface.h"
+#include "arch/mcd_arch_interface.h"
 
 #define PRINT_COREDUMP_INFO_STRING 1 // 打印字符串格式的coredump信息
 
     rt_int32_t cur_idx;
 } rtthread_ti_priv_t;
 
-/* Architecture-specific exception hook function */
-#ifdef PKG_USING_MCOREDUMP_ARCH_ARMV7M
-    #define arch_hard_fault_exception_hook armv7m_hard_fault_exception_hook
-#elif defined(PKG_USING_MCOREDUMP_ARCH_ARMV8M)
-    #define arch_hard_fault_exception_hook armv8m_hard_fault_exception_hook
-#else
-    #error "MCoredump does not support this architecture"
-#endif
-
 static rt_int32_t is_thread_object(rt_thread_t thread)
 {
     /* Check if the object is a thread (both static and dynamic) */
     return 0;
 }
 
-void mcd_rtos_thread_ops(struct thread_info_ops *ops)
-{
-    static rtthread_ti_priv_t priv;
-    ops->get_threads_count = rtthread_thread_cnts;
-    ops->get_current_thread_idx = rtthread_cur_index;
-    ops->get_thread_regset = rtthread_thread_register;
-    ops->get_memarea_count = rtthread_get_mem_cnts;
-    ops->get_memarea = rtthread_get_memarea;
-    ops->priv = &priv;
-    priv.cur_idx = -1;
-    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)
+static int mcd_print_coredump_info_string(struct thread_info_ops *ops)
 {
-    struct thread_info_ops ops;
-    mcd_rtos_thread_ops(&ops);
-    rt_int32_t current_idx = rtthread_cur_index(&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;
 
     information = rt_object_get_information(RT_Object_Class_Thread);
     mcd_assert(information != RT_NULL);
+    mcd_print("\n\n");
 
     for (node = information->object_list.next; node != &(information->object_list); node = node->next)
     {
                     memlen = thread->stack_size;
                 }
 
-                DumpRegisters((void *)cur_thread_regsiter, thread->name);
+                print_registers((void *)get_cur_core_regset_address(), get_cur_fp_regset_address(), 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);
+                core_regset_type core_regset;
+                fp_regset_type fp_regset;
+                collect_registers((uint32_t *)thread->sp, &core_regset, &fp_regset); // rtos栈寄存器格式转换成core_regset类型的
+                print_registers(&core_regset, &fp_regset, thread->name);
             }
 
-            DumpMem(addr, memlen);
+            print_mem(addr, memlen);
             idx_l++;
         }
     }
 }
 #endif
 
-MCD_WEAK rt_err_t rtt_hard_fault_exception_hook(void *context)
+void mcd_rtos_thread_ops(struct thread_info_ops *ops)
 {
-    uint32_t cur_thread_regsiter = arch_hard_fault_exception_hook(context);
+    static rtthread_ti_priv_t priv;
+    ops->get_threads_count = rtthread_thread_cnts;
+    ops->get_current_thread_idx = rtthread_cur_index;
+    ops->get_thread_regset = rtthread_thread_register;
+    ops->get_memarea_count = rtthread_get_mem_cnts;
+    ops->get_memarea = rtthread_get_memarea;
 #if PRINT_COREDUMP_INFO_STRING
-    _print_coredump_info_string(cur_thread_regsiter);
+    ops->print_info_string = mcd_print_coredump_info_string;
 #endif
+    ops->priv = &priv;
+    priv.cur_idx = -1;
+    priv.thr_cnts = -1;
+}
+
+MCD_WEAK rt_err_t rtt_hard_fault_exception_hook(void *context)
+{
+    arch_hard_fault_exception_hook(context);
     return -RT_ERROR;
 }
 
 
 static int mcd_coredump_init(void)
 {
-    static mcd_bool_t is_init = MCD_FALSE;
-
-    if (is_init)
-    {
-        return 0;
-    }
-
     //mcd_print_memoryinfo();
-
     rt_hw_exception_install(rtt_hard_fault_exception_hook);
-
-    //rt_assert_set_hook(rtt_assert_hook);
-
-    is_init = MCD_TRUE;
-    return RT_EOK;
+#ifdef RT_DEBUG
+    rt_assert_set_hook(rtt_assert_hook);
+#endif
+    return 0;
 }
 INIT_DEVICE_EXPORT(mcd_coredump_init);