sergiotarxz/nuttx
sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

assert: unify stack and register dump across platforms

Browse Source 
Signed-off-by: Petro Karashchenko <petro.karashchenko@gmail.com>
This commit is contained in:
Petro Karashchenko 2021-12-16 03:28:26 +02:00 committed by Gustavo Henrique Nihei
parent 67d8a82393
commit 3e76c3266e
43 changed files with 474 additions and 605 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
arch/arm/src/arm/arm_assert.c
View File

@ -69,11 +69,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: arm_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void arm_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -89,16 +89,14 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: arm_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(void)
static inline void arm_registerdump(void)
{
volatile uint32_t *regs = CURRENT_REGS;
int reg;
@ -125,8 +123,6 @@ static inline void up_registerdump(void)
_alert("CPSR: %08x\n", regs[REG_CPSR]);
}
#else
# define up_registerdump()
#endif
/****************************************************************************
@ -160,7 +156,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -171,7 +167,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
arm_registerdump();
/* Get the limits on the user stack memory */
@ -203,12 +199,12 @@ static void up_dumpstate(void)
/* Yes.. dump the interrupt stack */
_alert("Interrupt Stack\n", sp);
up_stackdump(sp, istackbase + istacksize);
arm_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
arm_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -246,12 +242,12 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
arm_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
arm_stackdump(ustackbase, ustackbase + ustacksize);
}
#ifdef CONFIG_ARCH_USBDUMP

47
arch/arm/src/armv6-m/arm_assert.c
View File

@ -68,11 +68,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: arm_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void arm_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -88,16 +88,14 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: arm_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(FAR volatile uint32_t *regs)
static inline void arm_registerdump(FAR volatile uint32_t *regs)
{
/* Are user registers available from interrupt processing? */
@ -121,14 +119,14 @@ static inline void up_registerdump(FAR volatile uint32_t *regs)
regs[REG_R12], regs[REG_R13], regs[REG_R14], regs[REG_R15]);
#ifdef CONFIG_BUILD_PROTECTED
_alert("xPSR: %08x PRIMASK: %08x EXEC_RETURN: %08x\n",
regs[REG_XPSR], regs[REG_PRIMASK], regs[REG_EXC_RETURN]);
regs[REG_XPSR], regs[REG_PRIMASK], regs[REG_EXC_RETURN]);
#else
_alert("xPSR: %08x PRIMASK: %08x\n",
regs[REG_XPSR], regs[REG_PRIMASK]);
regs[REG_XPSR], regs[REG_PRIMASK]);
#endif
}
#else
# define up_registerdump(regs)
# define arm_registerdump(regs)
#endif
/****************************************************************************
@ -167,7 +165,7 @@ static void up_taskdump(FAR struct tcb_s *tcb, FAR void *arg)
/* Dump the registers */
up_registerdump(tcb->xcp.regs);
arm_registerdump(tcb->xcp.regs);
}
/****************************************************************************
@ -215,7 +213,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -232,7 +230,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump(CURRENT_REGS);
arm_registerdump(CURRENT_REGS);
/* Get the limits on the user stack memory */
@ -263,12 +261,12 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
arm_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
arm_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -288,27 +286,13 @@ static void up_dumpstate(void)
#ifdef CONFIG_STACK_COLORATION
_alert(" used: %08x\n", up_check_tcbstack(rtcb));
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase);
}
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
}
#else
_alert("sp: %08x\n", sp);
_alert("stack base: %08x\n", ustackbase);
_alert("stack size: %08x\n", ustacksize);
#ifdef CONFIG_STACK_COLORATION
_alert("stack used: %08x\n", up_check_tcbstack(rtcb));
#endif
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
@ -317,14 +301,13 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
arm_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
arm_stackdump(ustackbase, ustackbase + ustacksize);
}
#endif
/* Dump the state of all tasks (if available) */

30
arch/arm/src/armv7-a/arm_assert.c
View File

@ -71,11 +71,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: arm_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void arm_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -91,16 +91,14 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: arm_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(FAR volatile uint32_t *regs)
static inline void arm_registerdump(FAR volatile uint32_t *regs)
{
int reg;
@ -127,7 +125,7 @@ static inline void up_registerdump(FAR volatile uint32_t *regs)
_alert("CPSR: %08x\n", regs[REG_CPSR]);
}
#else
# define up_registerdump(regs)
# define arm_registerdump(regs)
#endif
/****************************************************************************
@ -166,7 +164,7 @@ static void up_taskdump(FAR struct tcb_s *tcb, FAR void *arg)
/* Dump the registers */
up_registerdump(tcb->xcp.regs);
arm_registerdump(tcb->xcp.regs);
}
/****************************************************************************
@ -214,7 +212,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -234,7 +232,7 @@ static void up_dumpstate(void)
/* Dump the CPU registers (if available) */
up_registerdump(CURRENT_REGS);
arm_registerdump(CURRENT_REGS);
/* Get the limits on the user stack memory */
@ -293,12 +291,12 @@ static void up_dumpstate(void)
/* Yes.. dump the interrupt stack */
_alert("Interrupt Stack\n", sp);
up_stackdump(sp, istackbase + istacksize);
arm_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
arm_stackdump(istackbase, istackbase + istacksize);
}
#endif
@ -320,7 +318,7 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
_alert("User Stack\n", sp);
up_stackdump(sp, ustackbase + ustacksize);
arm_stackdump(sp, ustackbase + ustacksize);
}
#ifdef CONFIG_ARCH_KERNEL_STACK
@ -332,15 +330,15 @@ static void up_dumpstate(void)
sp < kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE)
{
_alert("Kernel Stack\n", sp);
up_stackdump(sp, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
arm_stackdump(sp, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
}
#endif
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
arm_stackdump(ustackbase, ustackbase + ustacksize);
#ifdef CONFIG_ARCH_KERNEL_STACK
up_stackdump(kstackbase, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
arm_stackdump(kstackbase, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
#endif
}

49
arch/arm/src/armv7-m/arm_assert.c
View File

@ -71,11 +71,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: arm_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void arm_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -91,16 +91,14 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: arm_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(FAR volatile uint32_t *regs)
static inline void arm_registerdump(FAR volatile uint32_t *regs)
{
/* Are user registers available from interrupt processing? */
@ -125,18 +123,16 @@ static inline void up_registerdump(FAR volatile uint32_t *regs)
#ifdef CONFIG_ARMV7M_USEBASEPRI
_alert("xPSR: %08x BASEPRI: %08x CONTROL: %08x\n",
regs[REG_XPSR], regs[REG_BASEPRI], getcontrol());
regs[REG_XPSR], regs[REG_BASEPRI], getcontrol());
#else
_alert("xPSR: %08x PRIMASK: %08x CONTROL: %08x\n",
regs[REG_XPSR], regs[REG_PRIMASK], getcontrol());
regs[REG_XPSR], regs[REG_PRIMASK], getcontrol());
#endif
#ifdef CONFIG_BUILD_PROTECTED
_alert("EXC_RETURN: %08x\n", regs[REG_EXC_RETURN]);
#endif
}
#else
# define up_registerdump(regs)
#endif
/****************************************************************************
@ -331,7 +327,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -348,7 +344,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump(CURRENT_REGS);
arm_registerdump(CURRENT_REGS);
/* Get the limits on the user stack memory */
@ -380,12 +376,12 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
arm_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
arm_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -402,28 +398,11 @@ static void up_dumpstate(void)
_alert("User stack:\n");
_alert(" base: %08x\n", ustackbase);
_alert(" size: %08x\n", ustacksize);
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
}
#else
/* Show user stack info */
_alert("sp: %08x\n", sp);
_alert("stack base: %08x\n", ustackbase);
_alert("stack size: %08x\n", ustacksize);
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
@ -431,16 +410,14 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
arm_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
arm_stackdump(ustackbase, ustackbase + ustacksize);
}
#endif
#ifdef CONFIG_SMP
/* Show the CPU number */

30
arch/arm/src/armv7-r/arm_assert.c
View File

@ -68,11 +68,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: arm_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void arm_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -88,16 +88,14 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: arm_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(FAR volatile uint32_t *regs)
static inline void arm_registerdump(FAR volatile uint32_t *regs)
{
int reg;
@ -124,7 +122,7 @@ static inline void up_registerdump(FAR volatile uint32_t *regs)
_alert("CPSR: %08x\n", regs[REG_CPSR]);
}
#else
# define up_registerdump(regs)
# define arm_registerdump(regs)
#endif
/****************************************************************************
@ -163,7 +161,7 @@ static void up_taskdump(FAR struct tcb_s *tcb, FAR void *arg)
/* Dump the registers */
up_registerdump(tcb->xcp.regs);
arm_registerdump(tcb->xcp.regs);
}
/****************************************************************************
@ -211,7 +209,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -231,7 +229,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump(CURRENT_REGS);
arm_registerdump(CURRENT_REGS);
/* Get the limits on the user stack memory */
@ -286,12 +284,12 @@ static void up_dumpstate(void)
/* Yes.. dump the interrupt stack */
_alert("Interrupt Stack\n", sp);
up_stackdump(sp, istackbase + istacksize);
arm_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
arm_stackdump(istackbase, istackbase + istacksize);
}
#endif
@ -313,7 +311,7 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
_alert("User Stack\n", sp);
up_stackdump(sp, ustackbase + ustacksize);
arm_stackdump(sp, ustackbase + ustacksize);
}
#ifdef CONFIG_ARCH_KERNEL_STACK
@ -325,15 +323,15 @@ static void up_dumpstate(void)
sp < kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE)
{
_alert("Kernel Stack\n", sp);
up_stackdump(sp, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
arm_stackdump(sp, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
}
#endif
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
arm_stackdump(ustackbase, ustackbase + ustacksize);
#ifdef CONFIG_ARCH_KERNEL_STACK
up_stackdump(kstackbase, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
arm_stackdump(kstackbase, kstackbase + CONFIG_ARCH_KERNEL_STACKSIZE);
#endif
}

49
arch/arm/src/armv8-m/arm_assert.c
View File

@ -71,11 +71,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: arm_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void arm_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -91,16 +91,14 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: arm_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(FAR volatile uint32_t *regs)
static inline void arm_registerdump(FAR volatile uint32_t *regs)
{
/* Are user registers available from interrupt processing? */
@ -125,18 +123,16 @@ static inline void up_registerdump(FAR volatile uint32_t *regs)
#ifdef CONFIG_ARMV8M_USEBASEPRI
_alert("xPSR: %08x BASEPRI: %08x CONTROL: %08x\n",
regs[REG_XPSR], regs[REG_BASEPRI], getcontrol());
regs[REG_XPSR], regs[REG_BASEPRI], getcontrol());
#else
_alert("xPSR: %08x PRIMASK: %08x CONTROL: %08x\n",
regs[REG_XPSR], regs[REG_PRIMASK], getcontrol());
regs[REG_XPSR], regs[REG_PRIMASK], getcontrol());
#endif
#ifdef CONFIG_BUILD_PROTECTED
_alert("EXC_RETURN: %08x\n", regs[REG_EXC_RETURN]);
#endif
}
#else
# define up_registerdump(regs)
#endif
/****************************************************************************
@ -331,7 +327,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -348,7 +344,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump(CURRENT_REGS);
arm_registerdump(CURRENT_REGS);
/* Get the limits on the user stack memory */
@ -380,12 +376,12 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
arm_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
arm_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -402,28 +398,11 @@ static void up_dumpstate(void)
_alert("User stack:\n");
_alert(" base: %08x\n", ustackbase);
_alert(" size: %08x\n", ustacksize);
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
}
#else
/* Show user stack info */
_alert("sp: %08x\n", sp);
_alert("stack base: %08x\n", ustackbase);
_alert("stack size: %08x\n", ustacksize);
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
@ -431,16 +410,14 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
arm_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
arm_stackdump(ustackbase, ustackbase + ustacksize);
}
#endif
#ifdef CONFIG_SMP
/* Show the CPU number */

98
arch/avr/src/avr/up_dumpstate.c
View File

@ -45,10 +45,10 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: avr_stackdump
****************************************************************************/
static void up_stackdump(uint16_t sp, uint16_t stack_top)
static void avr_stackdump(uint16_t sp, uint16_t stack_top)
{
uint16_t stack;
@ -56,65 +56,63 @@ static void up_stackdump(uint16_t sp, uint16_t stack_top)
syslog_flush();
for (stack = sp & ~0x3; stack < (stack_top & ~0x3); stack += 12)
for (stack = sp & ~0x7; stack < (stack_top & ~0x7); stack += 8)
{
uint8_t *ptr = (uint8_t *)stack;
_alert("%04x: %02x %02x %02x %02x %02x %02x %02x %02x"
" %02x %02x %02x %02x\n",
stack,
ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7],
ptr[8], ptr[9], ptr[10], ptr[11]);
_alert("%04x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
/****************************************************************************
* Name: up_registerdump
* Name: avr_registerdump
****************************************************************************/
static inline void up_registerdump(void)
static inline void avr_registerdump(void)
{
/* Are user registers available from interrupt processing? */
if (g_current_regs)
{
_alert("R%02d: %02x %02x %02x %02x %02x %02x %02x %02x\n",
0,
g_current_regs[REG_R0], g_current_regs[REG_R1],
g_current_regs[REG_R2], g_current_regs[REG_R3],
g_current_regs[REG_R4], g_current_regs[REG_R5],
g_current_regs[REG_R6], g_current_regs[REG_R7]);
0,
g_current_regs[REG_R0], g_current_regs[REG_R1],
g_current_regs[REG_R2], g_current_regs[REG_R3],
g_current_regs[REG_R4], g_current_regs[REG_R5],
g_current_regs[REG_R6], g_current_regs[REG_R7]);
_alert("R%02d: %02x %02x %02x %02x %02x %02x %02x %02x\n",
8,
g_current_regs[REG_R8], g_current_regs[REG_R9],
g_current_regs[REG_R10], g_current_regs[REG_R11],
g_current_regs[REG_R12], g_current_regs[REG_R13],
g_current_regs[REG_R14], g_current_regs[REG_R15]);
8,
g_current_regs[REG_R8], g_current_regs[REG_R9],
g_current_regs[REG_R10], g_current_regs[REG_R11],
g_current_regs[REG_R12], g_current_regs[REG_R13],
g_current_regs[REG_R14], g_current_regs[REG_R15]);
_alert("R%02d: %02x %02x %02x %02x %02x %02x %02x %02x\n",
16,
g_current_regs[REG_R16], g_current_regs[REG_R17],
g_current_regs[REG_R18], g_current_regs[REG_R19],
g_current_regs[REG_R20], g_current_regs[REG_R21],
g_current_regs[REG_R22], g_current_regs[REG_R23]);
16,
g_current_regs[REG_R16], g_current_regs[REG_R17],
g_current_regs[REG_R18], g_current_regs[REG_R19],
g_current_regs[REG_R20], g_current_regs[REG_R21],
g_current_regs[REG_R22], g_current_regs[REG_R23]);
_alert("R%02d: %02x %02x %02x %02x %02x %02x %02x %02x\n",
24,
g_current_regs[REG_R24], g_current_regs[REG_R25],
g_current_regs[REG_R26], g_current_regs[REG_R27],
g_current_regs[REG_R28], g_current_regs[REG_R29],
g_current_regs[REG_R30], g_current_regs[REG_R31]);
24,
g_current_regs[REG_R24], g_current_regs[REG_R25],
g_current_regs[REG_R26], g_current_regs[REG_R27],
g_current_regs[REG_R28], g_current_regs[REG_R29],
g_current_regs[REG_R30], g_current_regs[REG_R31]);
#if !defined(REG_PC2)
_alert("PC: %02x%02x SP: %02x%02x SREG: %02x\n",
g_current_regs[REG_PC0], g_current_regs[REG_PC1],
g_current_regs[REG_SPH], g_current_regs[REG_SPL],
g_current_regs[REG_SREG]);
g_current_regs[REG_PC0], g_current_regs[REG_PC1],
g_current_regs[REG_SPH], g_current_regs[REG_SPL],
g_current_regs[REG_SREG]);
#else
_alert("PC: %02x%02x%02x SP: %02x%02x SREG: %02x\n",
g_current_regs[REG_PC0], g_current_regs[REG_PC1],
g_current_regs[REG_PC2], g_current_regs[REG_SPH],
g_current_regs[REG_SPL], g_current_regs[REG_SREG]);
g_current_regs[REG_PC0], g_current_regs[REG_PC1],
g_current_regs[REG_PC2], g_current_regs[REG_SPH],
g_current_regs[REG_SPL], g_current_regs[REG_SREG]);
#endif
}
}
@ -129,7 +127,7 @@ static inline void up_registerdump(void)
void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint16_t sp = up_getsp();
uint16_t ustackbase;
uint16_t ustacksize;
@ -140,7 +138,7 @@ void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
avr_registerdump();
/* Get the limits on the user stack memory */
@ -171,12 +169,12 @@ void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
avr_stackdump(sp, istackbase + istacksize);
}
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
avr_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -196,26 +194,13 @@ void up_dumpstate(void)
#ifdef CONFIG_STACK_COLORATION
_alert(" used: %08x\n", up_check_tcbstack(rtcb));
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
}
#else
_alert("sp: %04x\n", sp);
_alert("stack base: %04x\n", ustackbase);
_alert("stack size: %04x\n", ustacksize);
#ifdef CONFIG_STACK_COLORATION
_alert("stack used: %08x\n", up_check_tcbstack(rtcb));
#endif
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
@ -224,14 +209,13 @@ void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
avr_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
avr_stackdump(ustackbase, ustackbase + ustacksize);
}
#endif
}
#endif /* CONFIG_ARCH_STACKDUMP */

56
arch/avr/src/avr32/up_dumpstate.c
View File

@ -45,10 +45,10 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: avr_stackdump
****************************************************************************/
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void avr_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -66,28 +66,28 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
}
/****************************************************************************
* Name: up_registerdump
* Name: avr_registerdump
****************************************************************************/
static inline void up_registerdump(void)
static inline void avr_registerdump(void)
{
/* Are user registers available from interrupt processing? */
if (g_current_regs)
{
_alert("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n",
0,
g_current_regs[REG_R0], g_current_regs[REG_R1],
g_current_regs[REG_R2], g_current_regs[REG_R3],
g_current_regs[REG_R4], g_current_regs[REG_R5],
g_current_regs[REG_R6], g_current_regs[REG_R7]);
0,
g_current_regs[REG_R0], g_current_regs[REG_R1],
g_current_regs[REG_R2], g_current_regs[REG_R3],
g_current_regs[REG_R4], g_current_regs[REG_R5],
g_current_regs[REG_R6], g_current_regs[REG_R7]);
_alert("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n",
8,
g_current_regs[REG_R8], g_current_regs[REG_R9],
g_current_regs[REG_R10], g_current_regs[REG_R11],
g_current_regs[REG_R12], g_current_regs[REG_R13],
g_current_regs[REG_R14], g_current_regs[REG_R15]);
8,
g_current_regs[REG_R8], g_current_regs[REG_R9],
g_current_regs[REG_R10], g_current_regs[REG_R11],
g_current_regs[REG_R12], g_current_regs[REG_R13],
g_current_regs[REG_R14], g_current_regs[REG_R15]);
_alert("SR: %08x\n", g_current_regs[REG_SR]);
}
@ -99,7 +99,7 @@ static inline void up_registerdump(void)
void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -110,7 +110,7 @@ void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
avr_registerdump();
/* Get the limits on the user stack memory */
@ -141,12 +141,12 @@ void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
avr_stackdump(sp, istackbase + istacksize);
}
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
avr_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -166,26 +166,13 @@ void up_dumpstate(void)
#ifdef CONFIG_STACK_COLORATION
_alert(" used: %08x\n", up_check_tcbstack(rtcb));
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
}
#else
_alert("sp: %08x\n", sp);
_alert("stack base: %08x\n", ustackbase);
_alert("stack size: %08x\n", ustacksize);
#ifdef CONFIG_STACK_COLORATION
_alert("stack used: %08x\n", up_check_tcbstack(rtcb));
#endif
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
@ -194,13 +181,12 @@ void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
avr_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
avr_stackdump(ustackbase, ustackbase + ustacksize);
}
#endif
}
#endif

41
arch/hc/src/m9s12/m9s12_assert.c
View File

@ -68,11 +68,11 @@ static uint8_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: hc_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint16_t sp, uint16_t stack_top)
static void hc_stackdump(uint16_t sp, uint16_t stack_top)
{
uint16_t stack;
@ -80,27 +80,22 @@ static void up_stackdump(uint16_t sp, uint16_t stack_top)
syslog_flush();
for (stack = sp & ~0x1f; stack < (stack_top & ~0x1f); stack += 16)
for (stack = sp & ~0x7; stack < (stack_top & ~0x7); stack += 8)
{
uint8_t *ptr = (uint8_t *)stack;
_alert("%04x: %02x %02x %02x %02x %02x %02x %02x %02x"
" %02x %02x %02x %02x %02x %02x %02x %02x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4],
ptr[5], ptr[6], ptr[7], ptr[8], ptr[9], ptr[10],
ptr[11], ptr[12], ptr[13], ptr[14], ptr[15]);
_alert("%04x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump()
#endif
/****************************************************************************
* Name: up_registerdump
* Name: hc_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(void)
static inline void hc_registerdump(void)
{
volatile uint8_t *regs = g_current_regs;
@ -127,19 +122,17 @@ static inline void up_registerdump(void)
# error "Need to save more registers"
#elif CONFIG_HCS12_MSOFTREGS == 2
_alert("SOFTREGS: %02x%02x :%02x%02x\n",
regs[REG_SOFTREG1], regs[REG_SOFTREG1 + 1],
regs[REG_SOFTREG2], regs[REG_SOFTREG2 + 1]);
regs[REG_SOFTREG1], regs[REG_SOFTREG1 + 1],
regs[REG_SOFTREG2], regs[REG_SOFTREG2 + 1]);
#elif CONFIG_HCS12_MSOFTREGS == 1
_alert("SOFTREGS: %02x%02x\n",
regs[REG_SOFTREG1], regs[REG_SOFTREG1 + 1]);
regs[REG_SOFTREG1], regs[REG_SOFTREG1 + 1]);
#endif
#ifndef CONFIG_HCS12_NONBANKED
_alert("PPAGE: %02x\n", regs[REG_PPAGE]);
#endif
}
#else
# define up_registerdump()
#endif
/****************************************************************************
@ -173,7 +166,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint16_t sp = up_getsp();
uint16_t ustackbase;
uint16_t ustacksize;
@ -184,7 +177,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
hc_registerdump();
/* Get the limits on the user stack memory */
@ -212,7 +205,7 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
hc_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
@ -224,7 +217,7 @@ static void up_dumpstate(void)
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
hc_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
@ -244,12 +237,12 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
hc_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
hc_stackdump(ustackbase, ustackbase + ustacksize);
}
#ifdef CONFIG_ARCH_USBDUMP

20
arch/mips/src/mips32/mips_dumpstate.c
View File

@ -46,10 +46,10 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: mips_stackdump
****************************************************************************/
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void mips_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -69,10 +69,10 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
}
/****************************************************************************
* Name: up_registerdump
* Name: mips_registerdump
****************************************************************************/
static inline void up_registerdump(void)
static inline void mips_registerdump(void)
{
/* Are user registers available from interrupt processing? */
@ -129,7 +129,7 @@ static inline void up_registerdump(void)
void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -140,7 +140,7 @@ void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
mips_registerdump();
/* Get the limits on the user stack memory */
@ -168,7 +168,7 @@ void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
mips_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
@ -180,7 +180,7 @@ void up_dumpstate(void)
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
mips_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
@ -200,12 +200,12 @@ void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
mips_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
mips_stackdump(ustackbase, ustackbase + ustacksize);
}
}

10
arch/mips/src/mips32/mips_swint0.c
View File

@ -44,11 +44,11 @@
****************************************************************************/
/****************************************************************************
* Name: up_registerdump
* Name: mips_registerdump
****************************************************************************/
#ifdef CONFIG_DEBUG_SYSCALL_INFO
static void up_registerdump(const uint32_t *regs)
static void mips_registerdump(const uint32_t *regs)
{
svcinfo("MFLO:%08x MFHI:%08x EPC:%08x STATUS:%08x\n",
regs[REG_MFLO], regs[REG_MFHI], regs[REG_EPC], regs[REG_STATUS]);
@ -73,8 +73,6 @@ static void up_registerdump(const uint32_t *regs)
regs[REG_RA]);
#endif
}
#else
# define up_registerdump(regs)
#endif
/****************************************************************************
@ -143,7 +141,7 @@ int up_swint0(int irq, FAR void *context, FAR void *arg)
#ifdef CONFIG_DEBUG_SYSCALL_INFO
svcinfo("Entry: regs: %p cmd: %d\n", regs, regs[REG_R4]);
up_registerdump(regs);
mips_registerdump(regs);
#endif
/* Handle the SWInt according to the command in $4 */
@ -289,7 +287,7 @@ int up_swint0(int irq, FAR void *context, FAR void *arg)
if (regs != CURRENT_REGS)
{
svcinfo("SWInt Return: Context switch!\n");
up_registerdump((const uint32_t *)CURRENT_REGS);
mips_registerdump((const uint32_t *)CURRENT_REGS);
}
else
{

57
arch/misoc/src/lm32/lm32_dumpstate.c
View File

@ -44,10 +44,10 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: lm32_stackdump
****************************************************************************/
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void lm32_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -65,43 +65,42 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
}
/****************************************************************************
* Name: up_registerdump
* Name: lm32_registerdump
****************************************************************************/
static inline void up_registerdump(void)
static inline void lm32_registerdump(void)
{
/* Are user registers available from interrupt processing? */
if (g_current_regs)
{
_alert("EPC:%08x \n",
g_current_regs[REG_EPC]);
g_current_regs[REG_EPC]);
_alert(" X0:%08x A0:%08x A1:%08x A2:%08x "
" A3:%08x A4:%08x A5:%08x A6:%08x\n",
g_current_regs[REG_X0_NDX], g_current_regs[REG_X1_NDX],
g_current_regs[REG_X2_NDX], g_current_regs[REG_X3_NDX],
g_current_regs[REG_X4_NDX], g_current_regs[REG_X5_NDX],
g_current_regs[REG_X6_NDX], g_current_regs[REG_X7_NDX]);
g_current_regs[REG_X0_NDX], g_current_regs[REG_X1_NDX],
g_current_regs[REG_X2_NDX], g_current_regs[REG_X3_NDX],
g_current_regs[REG_X4_NDX], g_current_regs[REG_X5_NDX],
g_current_regs[REG_X6_NDX], g_current_regs[REG_X7_NDX]);
_alert(" A7:%08x X9:%08x X10:%08x X11:%08x "
"X12:%08x X13:%08x X14:%08x X15:%08x\n",
g_current_regs[REG_X8_NDX], g_current_regs[REG_X9_NDX],
g_current_regs[REG_X10_NDX], g_current_regs[REG_X11_NDX],
g_current_regs[REG_X12_NDX], g_current_regs[REG_X13_NDX],
g_current_regs[REG_X14_NDX], g_current_regs[REG_X15_NDX]);
g_current_regs[REG_X8_NDX], g_current_regs[REG_X9_NDX],
g_current_regs[REG_X10_NDX], g_current_regs[REG_X11_NDX],
g_current_regs[REG_X12_NDX], g_current_regs[REG_X13_NDX],
g_current_regs[REG_X14_NDX], g_current_regs[REG_X15_NDX]);
_alert("X16:%08x X17:%08x X18:%08x X19:%08x "
"X20:%08x X21:%08x X22:%08x X23:%08x\n",
g_current_regs[REG_X16_NDX], g_current_regs[REG_X17_NDX],
g_current_regs[REG_X18_NDX], g_current_regs[REG_X19_NDX],
g_current_regs[REG_X20_NDX], g_current_regs[REG_X21_NDX],
g_current_regs[REG_X22_NDX], g_current_regs[REG_X23_NDX]);
g_current_regs[REG_X16_NDX], g_current_regs[REG_X17_NDX],
g_current_regs[REG_X18_NDX], g_current_regs[REG_X19_NDX],
g_current_regs[REG_X20_NDX], g_current_regs[REG_X21_NDX],
g_current_regs[REG_X22_NDX], g_current_regs[REG_X23_NDX]);
_alert("X24:%08x X25:%08x GP:%08x FP:%08x "
" SP:%08x RA:%08x EA:%08x BA:%08x\n",
g_current_regs[REG_X24_NDX], g_current_regs[REG_X25_NDX],
g_current_regs[REG_X26_NDX], g_current_regs[REG_X27_NDX],
g_current_regs[REG_X28_NDX], g_current_regs[REG_X29_NDX],
g_current_regs[REG_X30_NDX], g_current_regs[REG_X31_NDX]);
_alert(" IE:%08x\n",
g_current_regs[REG_X32_NDX]);
g_current_regs[REG_X24_NDX], g_current_regs[REG_X25_NDX],
g_current_regs[REG_X26_NDX], g_current_regs[REG_X27_NDX],
g_current_regs[REG_X28_NDX], g_current_regs[REG_X29_NDX],
g_current_regs[REG_X30_NDX], g_current_regs[REG_X31_NDX]);
_alert(" IE:%08x\n", g_current_regs[REG_X32_NDX]);
}
}
@ -115,7 +114,7 @@ static inline void up_registerdump(void)
void lm32_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -126,7 +125,7 @@ void lm32_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
lm32_registerdump();
/* Get the limits on the user stack memory */
@ -154,7 +153,7 @@ void lm32_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
lm32_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
@ -166,7 +165,7 @@ void lm32_dumpstate(void)
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
lm32_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
@ -186,12 +185,12 @@ void lm32_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
lm32_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
lm32_stackdump(ustackbase, ustackbase + ustacksize);
}
}

10
arch/misoc/src/lm32/lm32_swint.c
View File

@ -41,11 +41,11 @@
****************************************************************************/
/****************************************************************************
* Name: up_registerdump
* Name: lm32_registerdump
****************************************************************************/
#ifdef CONFIG_DEBUG_SYSCALL_INFO
static void up_registerdump(const uint32_t *regs)
static void lm32_registerdump(const uint32_t *regs)
{
#if 0
svcinfo("EPC:%08x\n",
@ -73,8 +73,6 @@ static void up_registerdump(const uint32_t *regs)
#endif
#endif
}
#else
# define up_registerdump(regs)
#endif
/****************************************************************************
@ -143,7 +141,7 @@ int lm32_swint(int irq, FAR void *context, FAR void *arg)
#ifdef CONFIG_DEBUG_SYSCALL_INFO
svcinfo("Entry: regs: %p cmd: %d\n", regs, regs[REG_A0]);
up_registerdump(regs);
lm32_registerdump(regs);
#endif
/* Handle the SWInt according to the command in $a0 */
@ -290,7 +288,7 @@ int lm32_swint(int irq, FAR void *context, FAR void *arg)
if (regs != g_current_regs)
{
svcinfo("SWInt Return: Context switch!\n");
up_registerdump((const uint32_t *)g_current_regs);
lm32_registerdump((const uint32_t *)g_current_regs);
}
else
{

74
arch/misoc/src/minerva/minerva_dumpstate.c
View File

@ -44,10 +44,10 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: mineva_stackdump
****************************************************************************/
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void mineva_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -57,7 +57,7 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
for (stack = sp & ~0x1f; stack < (stack_top & ~0x1f); stack += 32)
{
uint32_t *ptr = (uint32_t *) stack;
uint32_t *ptr = (uint32_t *)stack;
_alert("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
@ -65,44 +65,40 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
}
/****************************************************************************
* Name: up_registerdump
* Name: mineva_registerdump
****************************************************************************/
static inline void up_registerdump(void)
static inline void mineva_registerdump(void)
{
/* Are user registers available from interrupt processing? */
if (g_current_regs)
{
_alert("EPC:%08x \n", g_current_regs[REG_CSR_MEPC]);
_alert
(" X0:%08x A0:%08x A1:%08x A2:%08x "
" A3:%08x A4:%08x A5:%08x A6:%08x\n",
g_current_regs[REG_X0_NDX], g_current_regs[REG_X1_NDX],
g_current_regs[REG_X2_NDX], g_current_regs[REG_X3_NDX],
g_current_regs[REG_X4_NDX], g_current_regs[REG_X5_NDX],
g_current_regs[REG_X6_NDX], g_current_regs[REG_X7_NDX]);
_alert
(" A7:%08x X9:%08x X10:%08x X11:%08x "
"X12:%08x X13:%08x X14:%08x X15:%08x\n",
g_current_regs[REG_X8_NDX], g_current_regs[REG_X9_NDX],
g_current_regs[REG_X10_NDX], g_current_regs[REG_X11_NDX],
g_current_regs[REG_X12_NDX], g_current_regs[REG_X13_NDX],
g_current_regs[REG_X14_NDX], g_current_regs[REG_X15_NDX]);
_alert
("X16:%08x X17:%08x X18:%08x X19:%08x "
"X20:%08x X21:%08x X22:%08x X23:%08x\n",
g_current_regs[REG_X16_NDX], g_current_regs[REG_X17_NDX],
g_current_regs[REG_X18_NDX], g_current_regs[REG_X19_NDX],
g_current_regs[REG_X20_NDX], g_current_regs[REG_X21_NDX],
g_current_regs[REG_X22_NDX], g_current_regs[REG_X23_NDX]);
_alert
("X24:%08x X25:%08x GP:%08x FP:%08x "
" SP:%08x RA:%08x EA:%08x BA:%08x\n",
g_current_regs[REG_X24_NDX], g_current_regs[REG_X25_NDX],
g_current_regs[REG_X26_NDX], g_current_regs[REG_X27_NDX],
g_current_regs[REG_X28_NDX], g_current_regs[REG_X29_NDX],
g_current_regs[REG_X30_NDX], g_current_regs[REG_X31_NDX]);
_alert(" X0:%08x A0:%08x A1:%08x A2:%08x "
" A3:%08x A4:%08x A5:%08x A6:%08x\n",
g_current_regs[REG_X0_NDX], g_current_regs[REG_X1_NDX],
g_current_regs[REG_X2_NDX], g_current_regs[REG_X3_NDX],
g_current_regs[REG_X4_NDX], g_current_regs[REG_X5_NDX],
g_current_regs[REG_X6_NDX], g_current_regs[REG_X7_NDX]);
_alert(" A7:%08x X9:%08x X10:%08x X11:%08x "
"X12:%08x X13:%08x X14:%08x X15:%08x\n",
g_current_regs[REG_X8_NDX], g_current_regs[REG_X9_NDX],
g_current_regs[REG_X10_NDX], g_current_regs[REG_X11_NDX],
g_current_regs[REG_X12_NDX], g_current_regs[REG_X13_NDX],
g_current_regs[REG_X14_NDX], g_current_regs[REG_X15_NDX]);
_alert("X16:%08x X17:%08x X18:%08x X19:%08x"
"X20:%08x X21:%08x X22:%08x X23:%08x\n",
g_current_regs[REG_X16_NDX], g_current_regs[REG_X17_NDX],
g_current_regs[REG_X18_NDX], g_current_regs[REG_X19_NDX],
g_current_regs[REG_X20_NDX], g_current_regs[REG_X21_NDX],
g_current_regs[REG_X22_NDX], g_current_regs[REG_X23_NDX]);
_alert("X24:%08x X25:%08x GP:%08x FP:%08x "
" SP:%08x RA:%08x EA:%08x BA:%08x\n",
g_current_regs[REG_X24_NDX], g_current_regs[REG_X25_NDX],
g_current_regs[REG_X26_NDX], g_current_regs[REG_X27_NDX],
g_current_regs[REG_X28_NDX], g_current_regs[REG_X29_NDX],
g_current_regs[REG_X30_NDX], g_current_regs[REG_X31_NDX]);
_alert(" IE:%08x\n", g_current_regs[REG_CSR_MSTATUS]);
}
}
@ -117,7 +113,7 @@ static inline void up_registerdump(void)
void minerva_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -128,7 +124,7 @@ void minerva_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
mineva_registerdump();
/* Get the limits on the user stack memory NOTE: You cannot use the PID to
* determine if this is an IDLE task. In the SMP case, there may be
@ -159,7 +155,7 @@ void minerva_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
mineva_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer which should lie at the base of the
* interrupt stack.
@ -171,7 +167,7 @@ void minerva_dumpstate(void)
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
mineva_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
@ -191,12 +187,12 @@ void minerva_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
mineva_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
mineva_stackdump(ustackbase, ustackbase + ustacksize);
}
}

10
arch/misoc/src/minerva/minerva_swint.c
View File

@ -41,11 +41,11 @@
****************************************************************************/
/****************************************************************************
* Name: up_registerdump
* Name: minerva_registerdump
****************************************************************************/
#ifdef CONFIG_DEBUG_SYSCALL_INFO
static void up_registerdump(const uint32_t * regs)
static void minerva_registerdump(const uint32_t * regs)
{
#if 0
svcinfo("EPC:%08x\n", regs[REG_CSR_MEPC]);
@ -73,8 +73,6 @@ static void up_registerdump(const uint32_t * regs)
#endif
#endif
}
#else
# define up_registerdump(regs)
#endif
/****************************************************************************
@ -139,7 +137,7 @@ int minerva_swint(int irq, FAR void *context, FAR void *arg)
#ifdef CONFIG_DEBUG_SYSCALL_INFO
svcinfo("Entry: regs: %p cmd: %d\n", regs, regs[REG_A0]);
up_registerdump(regs);
minerva_registerdump(regs);
#endif
/* Handle the SWInt according to the command in $a0 */
@ -267,7 +265,7 @@ int minerva_swint(int irq, FAR void *context, FAR void *arg)
if (regs != g_current_regs)
{
svcinfo("SWInt Return: Context switch!\n");
up_registerdump((const uint32_t *)g_current_regs);
minerva_registerdump((const uint32_t *)g_current_regs);
}
else
{

61
arch/or1k/src/common/up_assert.c
View File

@ -68,11 +68,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: or1k_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void or1k_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -88,8 +88,6 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump(sp,stack_top)
#endif
/****************************************************************************
@ -103,12 +101,12 @@ static void up_taskdump(FAR struct tcb_s *tcb, FAR void *arg)
#if CONFIG_TASK_NAME_SIZE > 0
_alert("%s: PID=%d Stack Used=%lu of %lu\n",
tcb->name, tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
tcb->name, tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
#else
_alert("PID: %d Stack Used=%lu of %lu\n",
tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
#endif
}
#endif
@ -129,11 +127,11 @@ static inline void up_showtasks(void)
#endif
/****************************************************************************
* Name: up_registerdump
* Name: or1k_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(void)
static inline void or1k_registerdump(void)
{
volatile uint32_t *regs = CURRENT_REGS;
@ -150,21 +148,19 @@ static inline void up_registerdump(void)
/* Dump the interrupt registers */
_alert("R0: %08x %08x %08x %08x %08x %08x %08x %08x\n",
regs[REG_R0], regs[REG_R1], regs[REG_R2], regs[REG_R3],
regs[REG_R4], regs[REG_R5], regs[REG_R6], regs[REG_R7]);
regs[REG_R0], regs[REG_R1], regs[REG_R2], regs[REG_R3],
regs[REG_R4], regs[REG_R5], regs[REG_R6], regs[REG_R7]);
_alert("R8: %08x %08x %08x %08x %08x %08x %08x %08x\n",
regs[REG_R8], regs[REG_R9], regs[REG_R10], regs[REG_R11],
regs[REG_R12], regs[REG_R13], regs[REG_R14], regs[REG_R15]);
regs[REG_R8], regs[REG_R9], regs[REG_R10], regs[REG_R11],
regs[REG_R12], regs[REG_R13], regs[REG_R14], regs[REG_R15]);
#ifdef CONFIG_BUILD_PROTECTED
_alert("xPSR: %08x PRIMASK: %08x EXEC_RETURN: %08x\n",
regs[REG_XPSR], regs[REG_PRIMASK], regs[REG_EXC_RETURN]);
regs[REG_XPSR], regs[REG_PRIMASK], regs[REG_EXC_RETURN]);
#else
_alert("xPSR: %08x PRIMASK: %08x\n",
regs[REG_XPSR], regs[REG_PRIMASK]);
regs[REG_XPSR], regs[REG_PRIMASK]);
#endif
}
#else
# define up_registerdump()
#endif
/****************************************************************************
@ -199,7 +195,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -210,7 +206,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump();
or1k_registerdump();
/* Get the limits on the user stack memory */
@ -241,12 +237,12 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
or1k_stackdump(sp, istackbase + istacksize);
}
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
or1k_stackdump(istackbase, istackbase + istacksize);
}
/* Extract the user stack pointer if we are in an interrupt handler.
@ -266,27 +262,13 @@ static void up_dumpstate(void)
#ifdef CONFIG_STACK_COLORATION
_alert(" used: %08x\n", up_check_tcbstack(rtcb));
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within the allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
}
#else
_alert("sp: %08x\n", sp);
_alert("stack base: %08x\n", ustackbase);
_alert("stack size: %08x\n", ustacksize);
#ifdef CONFIG_STACK_COLORATION
_alert("stack used: %08x\n", up_check_tcbstack(rtcb));
#endif
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
@ -295,14 +277,13 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
or1k_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
or1k_stackdump(ustackbase, ustackbase + ustacksize);
}
#endif
/* Dump the state of all tasks (if available) */

28
arch/renesas/src/m16c/m16c_dumpstate.c
View File

@ -72,12 +72,12 @@ static void m16c_stackdump(uint16_t sp, uint16_t stack_top)
syslog_flush();
for (stack = sp & ~7; stack < (stack_top & ~7); stack += 8)
for (stack = sp & ~0x7; stack < (stack_top & ~0x7); stack += 8)
{
uint8_t *ptr = (uint8_t *)stack;
_alert("%04x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4],
ptr[5], ptr[6], ptr[7]);
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
@ -87,7 +87,7 @@ static void m16c_stackdump(uint16_t sp, uint16_t stack_top)
static inline void m16c_registerdump(void)
{
uint8_t *ptr = (uint8_t *) g_current_regs;
volatile uint8_t *ptr = (uint8_t *)g_current_regs;
/* Are user registers available from interrupt processing? */
@ -96,24 +96,24 @@ static inline void m16c_registerdump(void)
/* No.. capture user registers by hand */
up_saveusercontext((uint32_t *)s_last_regs);
regs = s_last_regs;
ptr = s_last_regs;
}
/* Dump the interrupt registers */
_alert("PC: %02x%02x%02x FLG: %02x00%02x FB: %02x%02x SB: %02x%02x "
"SP: %02x%02x\n",
ptr[REG_FLGPCHI] & 0xff, ptr[REG_PC], ptr[REG_PC + 1],
ptr[REG_FLGPCHI] >> 8, ptr[REG_FLG],
ptr[REG_FB], ptr[REG_FB + 1],
ptr[REG_SB], ptr[REG_SB + 1],
ptr[REG_SP], ptr[REG_SP + 1]);
ptr[REG_FLGPCHI] & 0xff, ptr[REG_PC], ptr[REG_PC + 1],
ptr[REG_FLGPCHI] >> 8, ptr[REG_FLG],
ptr[REG_FB], ptr[REG_FB + 1],
ptr[REG_SB], ptr[REG_SB + 1],
ptr[REG_SP], ptr[REG_SP + 1]);
_alert("R0: %02x%02x R1: %02x%02x R2: %02x%02x A0: %02x%02x "
"A1: %02x%02x\n",
ptr[REG_R0], ptr[REG_R0 + 1], ptr[REG_R1], ptr[REG_R1 + 1],
ptr[REG_R2], ptr[REG_R2 + 1], ptr[REG_R3], ptr[REG_R3 + 1],
ptr[REG_A0], ptr[REG_A0 + 1], ptr[REG_A1], ptr[REG_A1 + 1]);
ptr[REG_R0], ptr[REG_R0 + 1], ptr[REG_R1], ptr[REG_R1 + 1],
ptr[REG_R2], ptr[REG_R2 + 1], ptr[REG_R3], ptr[REG_R3 + 1],
ptr[REG_A0], ptr[REG_A0 + 1], ptr[REG_A1], ptr[REG_A1 + 1]);
}
/****************************************************************************
@ -126,7 +126,7 @@ static inline void m16c_registerdump(void)
void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint16_t sp = up_getsp();
uint16_t ustackbase;
uint16_t ustacksize;

65
arch/renesas/src/rx65n/rx65n_dumpstate.c
View File

@ -66,19 +66,20 @@ static inline uint16_t rx65n_getusersp(void)
* Name: rx65n_stackdump
****************************************************************************/
static void rx65n_stackdump(uint16_t sp, uint16_t stack_top)
static void rx65n_stackdump(uint32_t sp, uint32_t stack_top)
{
uint16_t stack;
uint32_t stack;
/* Flush any buffered SYSLOG data to avoid overwrite */
syslog_flush();
for (stack = sp & ~7; stack < (stack_top & ~7); stack += 8) /* check */
for (stack = sp & ~0x1f; stack < (stack_top & ~0x1f); stack += 32)
{
uint8_t *ptr = (uint8_t *)&stack;
_alert("%04x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
uint32_t *ptr = (uint32_t *)stack;
_alert("%08" PRIxPTR ": %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 " %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 "\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
@ -90,8 +91,7 @@ static void rx65n_stackdump(uint16_t sp, uint16_t stack_top)
static inline void rx65n_registerdump(void)
{
uint8_t *ptr = (uint8_t *) g_current_regs;
uint32_t regs[XCPTCONTEXT_SIZE];
volatile uint32_t *ptr = g_current_regs;
/* Are user registers available from interrupt processing? */
@ -99,28 +99,31 @@ static inline void rx65n_registerdump(void)
{
/* No.. capture user registers by hand */
up_saveusercontext((uint32_t *)s_last_regs);
*regs = *s_last_regs;
up_saveusercontext(s_last_regs);
ptr = s_last_regs;
}
/* Dump the interrupt registers */
_alert("PC: %08x PSW=%08x\n",
ptr[REG_PC], ptr[REG_PSW]);
_alert("PC: %08" PRIx32 " PSW=%08" PRIx32 "\n",
ptr[REG_PC], ptr[REG_PSW]);
_alert("FPSW: %08x ACC0LO: %08x ACC0HI: %08x ACC0GU: %08x"
"ACC1LO: %08x ACC1HI: %08x ACC1GU: %08x\n",
_alert("FPSW: %08" PRIx32 " ACC0LO: %08" PRIx32 " ACC0HI: %08" PRIx32
" ACC0GU: %08" PRIx32 "ACC1LO: %08" PRIx32 " ACC1HI: %08" PRIx32
" ACC1GU: %08" PRIx32 "\n",
ptr[REG_FPSW], ptr[REG_ACC0LO], ptr[REG_ACC0HI],
ptr[REG_ACC0GU], ptr[REG_ACC1LO],
ptr[REG_ACC1HI], ptr[REG_ACC1GU]);
_alert("R%d:%08x %08x %08x %08x %08x %08x %08x\n", 0,
ptr[REG_R1], ptr[REG_R2], ptr[REG_R3],
ptr[REG_R4], ptr[REG_R5], ptr[REG_R6], ptr[REG_R7]);
_alert("R%d:%08" PRIx32 " %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 " %08" PRIx32 " %08" PRIx32 "\n", 0,
ptr[REG_R1], ptr[REG_R2], ptr[REG_R3],
ptr[REG_R4], ptr[REG_R5], ptr[REG_R6], ptr[REG_R7]);
_alert("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 8,
ptr[REG_R8], ptr[REG_R9], ptr[REG_R10], ptr[REG_R11],
ptr[REG_R12], ptr[REG_R13], ptr[REG_R14], ptr[REG_R15]);
_alert("R%d: %08" PRIx32 " %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 " %08" PRIx32 " %08" PRIx32 " %08" PRIx32 "\n", 8,
ptr[REG_R8], ptr[REG_R9], ptr[REG_R10], ptr[REG_R11],
ptr[REG_R12], ptr[REG_R13], ptr[REG_R14], ptr[REG_R15]);
}
/****************************************************************************
@ -133,7 +136,7 @@ static inline void rx65n_registerdump(void)
void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -149,7 +152,7 @@ void up_dumpstate(void)
/* Get the limits on the user stack memory */
ustackbase = (uint32_t)rtcb->stack_base_ptr;
ustacksize = (uint16_t)rtcb->adj_stack_size;
ustacksize = (uint32_t)rtcb->adj_stack_size;
#if CONFIG_ARCH_INTERRUPTSTACK > 3
istackbase = ebss; /* check how to declare ebss, as of now declared in chip.h */
@ -158,10 +161,10 @@ void up_dumpstate(void)
/* Show interrupt stack info */
_alert("sp: %04" PRIx32 "\n", sp);
_alert("sp: %08" PRIx32 "\n", sp);
_alert("IRQ stack:\n");
_alert(" base: %04" PRIx32 "\n", istackbase);
_alert(" size: %04" PRIx32 "\n", istacksize);
_alert(" base: %08" PRIx32 "\n", istackbase);
_alert(" size: %08" PRIx32 "\n", istacksize);
/* Does the current stack pointer lie within the interrupt
* stack?
@ -176,7 +179,7 @@ void up_dumpstate(void)
/* Extract the user stack pointer from the register area */
sp = rx65n_getusersp();
_alert("sp: %04" PRIx32 "\n", sp);
_alert("sp: %08" PRIx32 "\n", sp);
}
else if (g_current_regs)
{
@ -187,12 +190,12 @@ void up_dumpstate(void)
/* Show user stack info */
_alert("User stack:\n");
_alert(" base: %04" PRIx32 "\n", ustackbase);
_alert(" size: %04" PRIx32 "\n", ustacksize);
_alert(" base: %08" PRIx32 "\n", ustackbase);
_alert(" size: %08" PRIx32 "\n", ustacksize);
#else
_alert("sp: %04" PRIx32 "\n", sp);
_alert("stack base: %04" PRIx32 "\n", ustackbase);
_alert("stack size: %04" PRIx32 "\n", ustacksize);
_alert("sp: %08" PRIx32 "\n", sp);
_alert("stack base: %08" PRIx32 "\n", ustackbase);
_alert("stack size: %08" PRIx32 "\n", ustacksize);
#endif
/* Dump the user stack if the stack pointer lies within the allocated user

16
arch/renesas/src/sh1/sh1_dumpstate.c
View File

@ -74,7 +74,7 @@ static void sh1_stackdump(uint32_t sp, uint32_t stack_top)
static inline void sh1_registerdump(void)
{
uint32_t *ptr = (uint32_t *)g_current_regs;
volatile uint32_t *ptr = g_current_regs;
/* Are user registers available from interrupt processing? */
@ -89,18 +89,18 @@ static inline void sh1_registerdump(void)
/* Dump the interrupt registers */
_alert("PC: %08x SR=%08x\n",
ptr[REG_PC], ptr[REG_SR]);
ptr[REG_PC], ptr[REG_SR]);
_alert("PR: %08x GBR: %08x MACH: %08x MACL: %08x\n",
ptr[REG_PR], ptr[REG_GBR], ptr[REG_MACH], ptr[REG_MACL]);
ptr[REG_PR], ptr[REG_GBR], ptr[REG_MACH], ptr[REG_MACL]);
_alert("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 0,
ptr[REG_R0], ptr[REG_R1], ptr[REG_R2], ptr[REG_R3],
ptr[REG_R4], ptr[REG_R5], ptr[REG_R6], ptr[REG_R7]);
ptr[REG_R0], ptr[REG_R1], ptr[REG_R2], ptr[REG_R3],
ptr[REG_R4], ptr[REG_R5], ptr[REG_R6], ptr[REG_R7]);
_alert("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 8,
ptr[REG_R8], ptr[REG_R9], ptr[REG_R10], ptr[REG_R11],
ptr[REG_R12], ptr[REG_R13], ptr[REG_R14], ptr[REG_R15]);
ptr[REG_R8], ptr[REG_R9], ptr[REG_R10], ptr[REG_R11],
ptr[REG_R12], ptr[REG_R13], ptr[REG_R14], ptr[REG_R15]);
}
/****************************************************************************
@ -113,7 +113,7 @@ static inline void sh1_registerdump(void)
void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;

4
arch/risc-v/src/common/riscv_tls.c
View File

@ -60,9 +60,9 @@ int up_tls_size(void)
*
****************************************************************************/
void up_tls_initialize(FAR struct tls_info_s *info)
void up_tls_initialize(struct tls_info_s *info)
{
FAR uint8_t *tls_data = (FAR uint8_t *)(info + 1);
uint8_t *tls_data = (uint8_t *)(info + 1);
uint32_t tdata_len = sizeof(uint32_t) * (_END_TDATA - _START_TDATA);
uint32_t tbss_len = sizeof(uint32_t) * (_END_TBSS - _START_TBSS);

2
arch/risc-v/src/esp32c3/esp32c3_ble_adapter.c
View File

@ -612,7 +612,7 @@ static void IRAM_ATTR interrupt_clear_wrapper(int intr_source, int intr_num)
*
****************************************************************************/
static int IRAM_ATTR esp_int_adpt_cb(int irq, void *context, FAR void *arg)
static int IRAM_ATTR esp_int_adpt_cb(int irq, void *context, void *arg)
{
struct irq_adpt_s *adapter = (struct irq_adpt_s *)arg;

2
arch/risc-v/src/esp32c3/esp32c3_wireless.c
View File

@ -230,7 +230,7 @@ static void esp32c3_phy_disable_clock(void)
*
****************************************************************************/
static int esp32c3_wl_swi_irq(int irq, void *context, FAR void *arg)
static int esp32c3_wl_swi_irq(int irq, void *context, void *arg)
{
int i;
int ret;

8
arch/risc-v/src/mpfs/mpfs_spi.c
View File

@ -425,8 +425,8 @@ static void mpfs_spi_select(struct spi_dev_s *dev, uint32_t devid,
****************************************************************************/
#ifdef CONFIG_MPFS_SPI0
void weak_function mpfs_spi0_select(FAR struct spi_dev_s *dev,
uint32_t devid, bool selected)
void weak_function mpfs_spi0_select(struct spi_dev_s *dev,
uint32_t devid, bool selected)
{
#ifdef CONFIG_SPI_CS_CONTROL
mpfs_spi_select(dev, devid, selected);
@ -437,8 +437,8 @@ void weak_function mpfs_spi0_select(FAR struct spi_dev_s *dev,
#endif /* CONFIG_MPFS_SPI0 */
#ifdef CONFIG_MPFS_SPI1
void weak_function mpfs_spi1_select(FAR struct spi_dev_s *dev,
uint32_t devid, bool selected)
void weak_function mpfs_spi1_select(struct spi_dev_s *dev,
uint32_t devid, bool selected)
{
#ifdef CONFIG_SPI_CS_CONTROL
mpfs_spi_select(dev, devid, selected);

8
arch/risc-v/src/mpfs/mpfs_spi.h
View File

@ -92,13 +92,13 @@ int mpfs_spibus_uninitialize(struct spi_dev_s *dev);
****************************************************************************/
#ifdef CONFIG_MPFS_SPI0
void weak_function mpfs_spi0_select(FAR struct spi_dev_s *dev,
uint32_t devid, bool selected);
void weak_function mpfs_spi0_select(struct spi_dev_s *dev,
uint32_t devid, bool selected);
#endif
#ifdef CONFIG_MPFS_SPI1
void weak_function mpfs_spi1_select(FAR struct spi_dev_s *dev,
uint32_t devid, bool selected);
void weak_function mpfs_spi1_select(struct spi_dev_s *dev,
uint32_t devid, bool selected);
#endif
#ifdef __cplusplus

22
arch/risc-v/src/rv32im/riscv_assert.c
View File

@ -84,8 +84,6 @@ static void riscv_stackdump(uint32_t sp, uint32_t stack_top)
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define riscv_stackdump(sp, stack_top)
#endif
/****************************************************************************
@ -100,24 +98,24 @@ static inline void riscv_registerdump(volatile uint32_t *regs)
_alert("EPC:%08x \n", regs[REG_EPC]);
_alert("A0:%08x A1:%08x A2:%08x A3:%08x A4:%08x A5:%08x "
"A6:%08x A7:%08x\n",
regs[REG_A0], regs[REG_A1], regs[REG_A2], regs[REG_A3],
regs[REG_A4], regs[REG_A5], regs[REG_A6], regs[REG_A7]);
regs[REG_A0], regs[REG_A1], regs[REG_A2], regs[REG_A3],
regs[REG_A4], regs[REG_A5], regs[REG_A6], regs[REG_A7]);
_alert("T0:%08x T1:%08x T2:%08x T3:%08x T4:%08x T5:%08x T6:%08x\n",
regs[REG_T0], regs[REG_T1], regs[REG_T2], regs[REG_T3],
regs[REG_T4], regs[REG_T5], regs[REG_T6]);
regs[REG_T0], regs[REG_T1], regs[REG_T2], regs[REG_T3],
regs[REG_T4], regs[REG_T5], regs[REG_T6]);
_alert("S0:%08x S1:%08x S2:%08x S3:%08x S4:%08x S5:%08x "
"S6:%08x S7:%08x\n",
regs[REG_S0], regs[REG_S1], regs[REG_S2], regs[REG_S3],
regs[REG_S4], regs[REG_S5], regs[REG_S6], regs[REG_S7]);
regs[REG_S0], regs[REG_S1], regs[REG_S2], regs[REG_S3],
regs[REG_S4], regs[REG_S5], regs[REG_S6], regs[REG_S7]);
_alert("S8:%08x S9:%08x S10:%08x S11:%08x\n",
regs[REG_S8], regs[REG_S9], regs[REG_S10], regs[REG_S11]);
regs[REG_S8], regs[REG_S9], regs[REG_S10], regs[REG_S11]);
#ifdef RISCV_SAVE_GP
_alert("GP:%08x SP:%08x FP:%08x TP:%08x RA:%08x\n",
regs[REG_GP], regs[REG_SP], regs[REG_FP], regs[REG_TP],
regs[REG_RA]);
regs[REG_GP], regs[REG_SP], regs[REG_FP], regs[REG_TP],
regs[REG_RA]);
#else
_alert("SP:%08x FP:%08x TP:%08x RA:%08x\n",
regs[REG_SP], regs[REG_FP], regs[REG_TP], regs[REG_RA]);
regs[REG_SP], regs[REG_FP], regs[REG_TP], regs[REG_RA]);
#endif
}
#else

2
arch/risc-v/src/rv32im/riscv_swint.c
View File

@ -73,8 +73,6 @@ static void riscv_registerdump(const uint32_t *regs)
regs[REG_SP], regs[REG_FP], regs[REG_TP], regs[REG_RA]);
#endif
}
#else
# define riscv_registerdump(regs)
#endif
/****************************************************************************

24
arch/risc-v/src/rv64gc/riscv_assert.c
View File

@ -68,12 +68,12 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: riscv_stackdump
****************************************************************************/
static void up_stackdump(uint64_t sp, uintptr_t stack_top)
static void riscv_stackdump(uint64_t sp, uintptr_t stack_top)
{
uintptr_t stack;
uint64_t stack;
/* Flush any buffered SYSLOG data to avoid overwrite */
@ -82,7 +82,7 @@ static void up_stackdump(uint64_t sp, uintptr_t stack_top)
for (stack = sp & ~0x1f; stack < (stack_top & ~0x1f); stack += 32)
{
uint32_t *ptr = (uint32_t *)stack;
_alert("%08" PRIxPTR ": %08" PRIx32 " %08" PRIx32 " %08" PRIx32
_alert("%016" PRIx64 ": %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 " %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 "\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
@ -91,10 +91,10 @@ static void up_stackdump(uint64_t sp, uintptr_t stack_top)
}
/****************************************************************************
* Name: up_registerdump
* Name: riscv_registerdump
****************************************************************************/
static inline void up_registerdump(volatile uintptr_t *regs)
static inline void riscv_registerdump(volatile uintptr_t *regs)
{
/* Are user registers available from interrupt processing? */
@ -167,7 +167,7 @@ static void up_taskdump(struct tcb_s *tcb, void *arg)
/* Dump the registers */
up_registerdump(tcb->xcp.regs);
riscv_registerdump(tcb->xcp.regs);
}
/****************************************************************************
@ -207,7 +207,7 @@ static void up_dumpstate(void)
/* Dump the registers (if available) */
up_registerdump(CURRENT_REGS);
riscv_registerdump(CURRENT_REGS);
/* Get the limits on the user stack memory */
@ -235,7 +235,7 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
riscv_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer */
@ -245,7 +245,7 @@ static void up_dumpstate(void)
else if (CURRENT_REGS)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
riscv_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
@ -266,11 +266,11 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
riscv_stackdump(ustackbase, ustackbase + ustacksize);
}
else
{
up_stackdump(sp, ustackbase + ustacksize);
riscv_stackdump(sp, ustackbase + ustacksize);
}
}

2
arch/risc-v/src/rv64gc/riscv_swint.c
View File

@ -77,8 +77,6 @@ static void riscv_registerdump(const uint64_t *regs)
regs[REG_SP], regs[REG_FP], regs[REG_TP], regs[REG_RA]);
#endif
}
#else
# define riscv_registerdump(regs)
#endif
/****************************************************************************

8
arch/x86/include/i486/arch.h
View File

@ -357,7 +357,7 @@ begin_packed_struct struct idt_ptr_s
/* Return stack pointer */
static inline uint32_t up_getsp()
static inline uint32_t up_getsp(void)
{
uint32_t regval;
@ -371,7 +371,7 @@ static inline uint32_t up_getsp()
/* Get segment registers */
static inline uint32_t up_getds()
static inline uint32_t up_getds(void)
{
uint32_t regval;
@ -383,7 +383,7 @@ static inline uint32_t up_getds()
return regval;
}
static inline uint32_t up_getcs()
static inline uint32_t up_getcs(void)
{
uint32_t regval;
@ -395,7 +395,7 @@ static inline uint32_t up_getcs()
return regval;
}
static inline uint32_t up_getss()
static inline uint32_t up_getss(void)
{
uint32_t regval;

20
arch/x86/src/common/up_assert.c
View File

@ -69,11 +69,11 @@ static uint32_t s_last_regs[XCPTCONTEXT_REGS];
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: x86_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_top)
static void x86_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t stack;
@ -85,12 +85,10 @@ static void up_stackdump(uint32_t sp, uint32_t stack_top)
{
uint32_t *ptr = (uint32_t *)stack;
_alert("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump()
#endif
/****************************************************************************
@ -124,7 +122,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = running_task();
FAR struct tcb_s *rtcb = running_task();
uint32_t sp = up_getsp();
uint32_t ustackbase;
uint32_t ustacksize;
@ -173,7 +171,7 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
x86_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
@ -185,7 +183,7 @@ static void up_dumpstate(void)
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
up_stackdump(istackbase, istackbase + istacksize);
x86_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
@ -205,12 +203,12 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
x86_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
x86_stackdump(ustackbase, ustackbase + ustacksize);
}
#ifdef CONFIG_ARCH_USBDUMP

10
arch/x86/src/i486/up_regdump.c
View File

@ -40,12 +40,12 @@
void up_registerdump(uint32_t *regs)
{
_alert(" ds:%08x irq:%08x err:%08x\n",
regs[REG_DS], regs[REG_IRQNO], regs[REG_ERRCODE]);
regs[REG_DS], regs[REG_IRQNO], regs[REG_ERRCODE]);
_alert("edi:%08x esi:%08x ebp:%08x esp:%08x\n",
regs[REG_EDI], regs[REG_ESI], regs[REG_EBP], regs[REG_ESP]);
regs[REG_EDI], regs[REG_ESI], regs[REG_EBP], regs[REG_ESP]);
_alert("ebx:%08x edx:%08x ecx:%08x eax:%08x\n",
regs[REG_EBX], regs[REG_EDX], regs[REG_ECX], regs[REG_EAX]);
regs[REG_EBX], regs[REG_EDX], regs[REG_ECX], regs[REG_EAX]);
_alert("eip:%08x cs:%08x flg:%08x sp:%08x ss:%08x\n",
regs[REG_EIP], regs[REG_CS], regs[REG_EFLAGS], regs[REG_SP],
regs[REG_SS]);
regs[REG_EIP], regs[REG_CS], regs[REG_EFLAGS], regs[REG_SP],
regs[REG_SS]);
}

18
arch/x86_64/include/intel64/arch.h
View File

@ -414,7 +414,7 @@ static inline void write_msr(unsigned int msr, unsigned long val)
: "memory");
}
static inline uint64_t read_fsbase()
static inline uint64_t read_fsbase(void)
{
uint64_t val;
asm volatile("rdfsbase %0"
@ -433,7 +433,7 @@ static inline void write_fsbase(unsigned long val)
: "memory");
}
static inline uint64_t read_gsbase()
static inline uint64_t read_gsbase(void)
{
uint64_t val;
asm volatile("rdgsbase %0"
@ -454,7 +454,7 @@ static inline void write_gsbase(unsigned long val)
/* Return stack pointer */
static inline uint64_t up_getsp()
static inline uint64_t up_getsp(void)
{
uint64_t regval;
@ -468,7 +468,7 @@ static inline uint64_t up_getsp()
/* Get segment registers */
static inline uint32_t up_getds()
static inline uint32_t up_getds(void)
{
uint32_t regval;
@ -480,7 +480,7 @@ static inline uint32_t up_getds()
return regval;
}
static inline uint32_t up_getcs()
static inline uint32_t up_getcs(void)
{
uint32_t regval;
@ -492,7 +492,7 @@ static inline uint32_t up_getcs()
return regval;
}
static inline uint32_t up_getss()
static inline uint32_t up_getss(void)
{
uint32_t regval;
@ -504,7 +504,7 @@ static inline uint32_t up_getss()
return regval;
}
static inline uint32_t up_getes()
static inline uint32_t up_getes(void)
{
uint32_t regval;
@ -516,7 +516,7 @@ static inline uint32_t up_getes()
return regval;
}
static inline uint32_t up_getfs()
static inline uint32_t up_getfs(void)
{
uint32_t regval;
@ -528,7 +528,7 @@ static inline uint32_t up_getfs()
return regval;
}
static inline uint32_t up_getgs()
static inline uint32_t up_getgs(void)
{
uint32_t regval;

45
arch/x86_64/src/common/up_assert.c
View File

@ -61,11 +61,11 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: x86_64_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint64_t sp, uint64_t stack_top)
static void x86_64_stackdump(uint64_t sp, uint64_t stack_top)
{
uint64_t stack;
@ -76,13 +76,13 @@ static void up_stackdump(uint64_t sp, uint64_t stack_top)
for (stack = sp & ~0x1f; stack < (stack_top & ~0x1f); stack += 32)
{
uint32_t *ptr = (uint32_t *)stack;
_alert("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
_alert("%016" PRIx64 ": %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 " %08" PRIx32 " %08" PRIx32 " %08" PRIx32
" %08" PRIx32 "\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump()
#endif
/****************************************************************************
@ -116,7 +116,7 @@ static int assert_tracecallback(FAR struct usbtrace_s *trace, FAR void *arg)
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
struct tcb_s *rtcb = this_task();
FAR struct tcb_s *rtcb = running_task();
uint64_t sp = up_getsp();
uint64_t ustackbase;
uint64_t ustacksize;
@ -138,10 +138,10 @@ static void up_dumpstate(void)
/* Show interrupt stack info */
_alert("sp: %016x\n", sp);
_alert("sp: %016" PRIx64 "\n", sp);
_alert("IRQ stack:\n");
_alert(" base: %016x\n", istackbase);
_alert(" size: %016x\n", istacksize);
_alert(" base: %016" PRIx64 "\n", istackbase);
_alert(" size: %016" PRIx64 "\n", istacksize);
/* Does the current stack pointer lie within the interrupt
* stack?
@ -151,25 +151,30 @@ static void up_dumpstate(void)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase + istacksize);
x86_64_stackdump(sp, istackbase + istacksize);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
*/
sp = g_intstacktop;
_alert("sp: %016x\n", sp);
_alert("sp: %016" PRIx64 "\n", sp);
}
else if (g_current_regs)
{
_alert("ERROR: Stack pointer is not within the interrupt stack\n");
x86_64_stackdump(istackbase, istackbase + istacksize);
}
/* Show user stack info */
_alert("User stack:\n");
_alert(" base: %016x\n", ustackbase);
_alert(" size: %016x\n", ustacksize);
_alert(" base: %016" PRIx64 "\n", ustackbase);
_alert(" size: %016" PRIx64 "\n", ustacksize);
#else
_alert("sp: %016x\n", sp);
_alert("stack base: %016x\n", ustackbase);
_alert("stack size: %016x\n", ustacksize);
_alert("sp: %016" PRIx64 "\n", sp);
_alert("stack base: %016" PRIx64 "\n", ustackbase);
_alert("stack size: %016" PRIx64 "\n", ustacksize);
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
@ -178,12 +183,12 @@ static void up_dumpstate(void)
if (sp >= ustackbase && sp < ustackbase + ustacksize)
{
up_stackdump(sp, ustackbase + ustacksize);
x86_64_stackdump(sp, ustackbase + ustacksize);
}
else
{
_alert("ERROR: Stack pointer is not within allocated stack\n");
up_stackdump(ustackbase, ustackbase + ustacksize);
x86_64_stackdump(ustackbase, ustackbase + ustacksize);
}
/* Then dump the registers (if available) */

8
arch/xtensa/src/common/xtensa_dumpstate.c
View File

@ -63,12 +63,12 @@ static void up_taskdump(struct tcb_s *tcb, void *arg)
#if CONFIG_TASK_NAME_SIZE > 0
_alert("%s: PID=%d Stack Used=%lu of %lu\n",
tcb->name, tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
tcb->name, tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
#else
_alert("PID: %d Stack Used=%lu of %lu\n",
tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
tcb->pid, (unsigned long)up_check_tcbstack(tcb),
(unsigned long)tcb->adj_stack_size);
#endif
/* Dump the backtrace */

20
arch/z16/src/common/z16_registerdump.c
View File

@ -48,27 +48,27 @@ static chipreg_t s_last_regs[XCPTCONTEXT_REGS];
* Name: z16_registerdump
****************************************************************************/
static void z16_registerdump(void)
void z16_registerdump(void)
{
#ifdef CONFIG_DEBUG_INFO
FAR uint32_t *regs32 = (FAR uint32_t *)g_current_regs;
FAR volatile uint32_t *regs32 = (FAR volatile uint32_t *)g_current_regs;
if (regs32 == NULL)
{
z16_saveusercontext(s_last_regs);
regs32 = (FAR uint32_t *)s_last_regs;
regs32 = (FAR volatile uint32_t *)s_last_regs;
}
_alert("R0 :%08x R1 :%08x R2 :%08x R3 :%08x "
"R4 :%08x R5 :%08x R6 :%08x R7 :%08x\n"
regs32[REG_R0 / 2], regs32[REG_R1 / 2], regs32[REG_R2 / 2],
regs32[REG_R3 / 2], regs32[REG_R4 / 2], regs32[REG_R5 / 2],
regs32[REG_R6 / 2], regs32[REG_R7 / 2]);
"R4 :%08x R5 :%08x R6 :%08x R7 :%08x\n"
regs32[REG_R0 / 2], regs32[REG_R1 / 2], regs32[REG_R2 / 2],
regs32[REG_R3 / 2], regs32[REG_R4 / 2], regs32[REG_R5 / 2],
regs32[REG_R6 / 2], regs32[REG_R7 / 2]);
_alert("R8 :%08x R9 :%08x R10:%08x R11:%08x R12:%08x R13:%08x\n"
regs32[REG_R8 / 2], regs32[REG_R9 / 2], regs32[REG_R10 / 2],
regs3[REG_R11 / 2], regs32[REG_R12 / 2], regs32[REG_R13 / 2]);
regs32[REG_R8 / 2], regs32[REG_R9 / 2], regs32[REG_R10 / 2],
regs3[REG_R11 / 2], regs32[REG_R12 / 2], regs32[REG_R13 / 2]);
_alert("FP :%08x SP :%08x FLG:%04x\n"
regs32[REG_R14 / 2], regs32[REG_R15 / 2], regs32[REG_FLAGS]);
regs32[REG_R14 / 2], regs32[REG_R15 / 2], regs32[REG_FLAGS]);
#endif
}

15
arch/z16/src/common/z16_stackdump.c
View File

@ -47,13 +47,14 @@
* Name: z16_stackdump
****************************************************************************/
static void z16_stackdump(void)
void z16_stackdump(void)
{
struct tcb_s *rtcb = this_task();
FAR struct tcb_s *rtcb = running_task();
chipreg_t sp = up_getsp();
chipreg_t stack_base = (chipreg_t)rtcb->stack_base_ptr;
chipreg_t stack_size = (chipreg_t)rtcb->adj_stack_size;
chipreg_t stack;
chipreg_t stack_top;
_alert("stack_base: %08x\n", stack_base);
_alert("stack_size: %08x\n", stack_size);
@ -69,18 +70,20 @@ static void z16_stackdump(void)
stack = stack_base;
}
stack_top = stack_base + stack_size;
/* Flush any buffered SYSLOG data to avoid overwrite */
syslog_flush();
for (stack = stack & ~0x0f;
stack < ((stack_base + stack_size) & ~0x0f);
for (stack = stack & ~(8 * sizeof(chipreg_t) - 1);
stack < (stack_top & ~(8 * sizeof(chipreg_t) - 1));
stack += 8 * sizeof(chipreg_t))
{
chipreg_t *ptr = (chipreg_t *)stack;
_alert("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}

4
arch/z80/src/common/z80_assert.c
View File

@ -142,8 +142,8 @@ void up_assert(const char *filename, int lineno)
filename, lineno);
#endif
REGISTER_DUMP();
up_stackdump();
Z80_REGISTER_DUMP();
z80_stackdump();
#ifdef CONFIG_ARCH_USBDUMP
/* Dump USB trace data */

8
arch/z80/src/common/z80_internal.h
View File

@ -133,11 +133,11 @@ uintptr_t up_getsp(void);
/* Dump stack and registers */
#ifdef CONFIG_ARCH_STACKDUMP
void up_stackdump(void);
# define REGISTER_DUMP() _REGISTER_DUMP()
void z80_stackdump(void);
# define Z80_REGISTER_DUMP() _REGISTER_DUMP()
#else
# define up_stackdump()
# define REGISTER_DUMP()
# define z80_stackdump()
# define Z80_REGISTER_DUMP()
#endif
#ifdef __cplusplus

30
arch/z80/src/common/z80_stackdump.c
View File

@ -38,16 +38,17 @@
****************************************************************************/
/****************************************************************************
* Name: up_stackdump
* Name: z80_stackdump
****************************************************************************/
void up_stackdump(void)
void z80_stackdump(void)
{
FAR struct tcb_s *rtcb = this_task();
FAR struct tcb_s *rtcb = running_task();
uintptr_t sp = up_getsp();
uintptr_t stack_base = (uintptr_t)rtcb->stack_base_ptr;
uintptr_t stack_size = (uintptr_t)rtcb->adj_stack_size;
uintptr_t stack;
uintptr_t stack_top;
_alert("stack_base: %06x\n", stack_base);
_alert("stack_size: %06x\n", stack_size);
@ -63,17 +64,20 @@ void up_stackdump(void)
stack = stack_base;
}
for (stack = stack & ~0x0f; stack < stack_base + stack_size; stack += 16)
{
FAR uint8_t *ptr = (FAR uint8_t *)stack;
stack_top = stack_base + stack_size;
_alert("%06x: %02x %02x %02x %02x %02x %02x %02x %02x ",
"%02x %02x %02x %02x %02x %02x %02x %02x\n",
stack,
ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7],
ptr[8], ptr[9], ptr[10], ptr[11],
ptr[12], ptr[13], ptr[14], ptr[15]);
/* Flush any buffered SYSLOG data to avoid overwrite */
syslog_flush();
for (stack = stack & ~(8 * sizeof(chipreg_t) - 1);
stack < (stack_top & ~(8 * sizeof(chipreg_t) - 1));
stack += 8 * sizeof(chipreg_t))
{
FAR chipreg_t *ptr = (FAR chipreg_t *)stack;
_alert("%06x: %06x %06x %06x %06x %06x %06x %06x %06x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}

16
arch/z80/src/ez80/ez80_registerdump.c
View File

@ -60,22 +60,22 @@ void ez80_registerdump(void)
#ifdef CONFIG_EZ80_Z80MODE
_alert("AF: %04x I: %04x\n",
regs[XCPT_AF], regs[XCPT_I]);
regs[XCPT_AF], regs[XCPT_I]);
_alert("BC: %04x DE: %04x HL: %04x\n",
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
_alert("IX: %04x IY: %04x\n",
regs[XCPT_IX], regs[XCPT_IY]);
regs[XCPT_IX], regs[XCPT_IY]);
_alert("SP: %04x PC: %04x\n"
regs[XCPT_SP], regs[XCPT_PC]);
regs[XCPT_SP], regs[XCPT_PC]);
#else
_alert("AF: %06x I: %06x\n",
regs[XCPT_AF], regs[XCPT_I]);
regs[XCPT_AF], regs[XCPT_I]);
_alert("BC: %06x DE: %06x HL: %06x\n",
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
_alert("IX: %06x IY: %06x\n",
regs[XCPT_IX], regs[XCPT_IY]);
regs[XCPT_IX], regs[XCPT_IY]);
_alert("SP: %06x PC: %06x\n",
regs[XCPT_SP], regs[XCPT_PC]);
regs[XCPT_SP], regs[XCPT_PC]);
#endif
}

12
arch/z80/src/z180/z180_registerdump.c
View File

@ -48,7 +48,7 @@ static chipreg_t s_last_regs[XCPTCONTEXT_REGS];
* Name: z180_registerdump
****************************************************************************/
static void z180_registerdump(void)
void z180_registerdump(void)
{
volatile chipreg_t *regs = g_current_regs;
@ -59,15 +59,15 @@ static void z180_registerdump(void)
}
_alert("AF: %04x I: %04x\n",
regs[XCPT_AF], regs[XCPT_I]);
regs[XCPT_AF], regs[XCPT_I]);
_alert("BC: %04x DE: %04x HL: %04x\n",
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
_alert("IX: %04x IY: %04x\n",
regs[XCPT_IX], regs[XCPT_IY]);
regs[XCPT_IX], regs[XCPT_IY]);
_alert("SP: %04x PC: %04x\n"
regs[XCPT_SP], regs[XCPT_PC]);
regs[XCPT_SP], regs[XCPT_PC]);
_alert("CBAR: %02x BBR: %02x CBR: %02x\n"
inp(Z180_MMU_CBAR), inp(Z180_MMU_BBR), inp(Z180_MMU_CBR));
inp(Z180_MMU_CBAR), inp(Z180_MMU_BBR), inp(Z180_MMU_CBR));
}
#endif /* CONFIG_ARCH_STACKDUMP */

6
arch/z80/src/z8/z8_registerdump.c
View File

@ -48,15 +48,15 @@ static chipreg_t s_last_regs[XCPTCONTEXT_REGS];
static inline void z8_dumpregs(FAR chipret_t *regs)
{
_alert("REGS: %04x %04x %04x %04x %04x %04x %04x %04x\n",
regs[XCPT_RR0], regs[XCPT_RR2], regs[XCPT_RR4], regs[XCPT_RR6],
regs[XCPT_RR8], regs[XCPT_RR10], regs[XCPT_RR12], regs[XCPT_RR14]);
regs[XCPT_RR0], regs[XCPT_RR2], regs[XCPT_RR4], regs[XCPT_RR6],
regs[XCPT_RR8], regs[XCPT_RR10], regs[XCPT_RR12], regs[XCPT_RR14]);
}
static inline void z8_dumpstate(chipreg_t sp, chipreg_t pc, uint8_t irqctl,
chipreg_t rpflags)
{
_alert("SP: %04x PC: %04x IRQCTL: %02x RP: %02x FLAGS: %02x\n",
sp, pc, irqctl & 0xff, rpflags >> 8, rpflags & 0xff);
sp, pc, irqctl & 0xff, rpflags >> 8, rpflags & 0xff);
}
/****************************************************************************

10
arch/z80/src/z80/z80_registerdump.c
View File

@ -48,7 +48,7 @@ static chipreg_t s_last_regs[XCPTCONTEXT_REGS];
* Name: z80_registerdump
****************************************************************************/
static void z80_registerdump(void)
void z80_registerdump(void)
{
volatile chipreg_t *regs = g_current_regs;
@ -59,13 +59,13 @@ static void z80_registerdump(void)
}
_alert("AF: %04x I: %04x\n",
regs[XCPT_AF], regs[XCPT_I]);
regs[XCPT_AF], regs[XCPT_I]);
_alert("BC: %04x DE: %04x HL: %04x\n",
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
regs[XCPT_BC], regs[XCPT_DE], regs[XCPT_HL]);
_alert("IX: %04x IY: %04x\n",
regs[XCPT_IX], regs[XCPT_IY]);
regs[XCPT_IX], regs[XCPT_IY]);
_alert("SP: %04x PC: %04x\n"
regs[XCPT_SP], regs[XCPT_PC]);
regs[XCPT_SP], regs[XCPT_PC]);
}
#endif /* CONFIG_ARCH_STACKDUMP */