excarchshow.c

VxWorks BSP框架源代码包含头文件和驱动

    int		vecNum,		/* exception vector number */
    ESFSH *	pEsf,		/* pointer to exception stack frame */
    REG_SET *	pRegs,		/* pointer to register info on stack */
    EXC_INFO *	pExcInfo	/* parsed exception information */
    )
    {
    char *vecName = "";

    if ((vecNum < NELEMENTS (excMsgs)) && (excMsgs [vecNum] != NULL))
	vecName = excMsgs [vecNum];

#if (CPU==SH7750 || CPU==SH7700)
    vecNum = INUM_TO_IEVT(vecNum);
#endif
    if (Q_FIRST (&activeQHead) == NULL)			/* pre kernel */
	{
	printExc (excIntInfoFmt, vecNum, (int)vecName, (int)pEsf->pc, 
		  (int)pEsf->sr, 0);
	excRegsShow (pRegs);
	}
    else
	logMsg (excIntInfoFmt, vecNum, (int)vecName, (int)pEsf->pc,
		(int)pEsf->sr, 0, 0);
    }

/*******************************************************************************
*
* excPanicShow - exception at interrupt level
*
* This routine is called if an exception is caused at interrupt
* level.  We can't handle it in the usual way.  Instead, we save info in
* sysExcMsg and trap to rom monitor.
*/

LOCAL void excPanicShow
    (
    int		vecNum,		/* exception vector number */
    ESFSH *	pEsf,		/* pointer to exception stack frame */
    REG_SET *	pRegs,		/* pointer to register info on stack */
    EXC_INFO *	pExcInfo	/* parsed exception information */
    )
    {
    if (INT_CONTEXT ())
	printExc (" \nException at interrupt level:\n", 0, 0, 0, 0, 0);

    if (Q_FIRST (&activeQHead) == NULL)
	printExc ("Exception before kernel initialized:\n", 0, 0, 0, 0, 0);

    excInfoShow (pExcInfo, FALSE);	/* print the message into sysExcMsg */

    printExc ("Regs at 0x%x\n", (int) pRegs, 0, 0, 0, 0);
    }

/*******************************************************************************
*
* excRegsShow - print REG_SET on stack
*
* NOMANUAL
*/

LOCAL void excRegsShow
    (
    REG_SET *  pRegs		/* pointer to register info on stack */
    )
    {
    REG_SET *  pSave = &excRegsBuf;

    bcopy ((char *)pRegs, (char *)pSave, sizeof (REG_SET));

    printExc ("\nr0  = 0x%08x, r1  = 0x%08x, r2   = 0x%08x, r3     = 0x%08x",
	pSave->voreg[0], pSave->voreg[1], pSave->voreg[2], pSave->voreg[3], 0);
    printExc ("\nr4  = 0x%08x, r5  = 0x%08x, r6   = 0x%08x, r7     = 0x%08x",
	pSave->voreg[4], pSave->voreg[5], pSave->voreg[6], pSave->voreg[7], 0);
    printExc ("\nr8  = 0x%08x, r9  = 0x%08x, r10  = 0x%08x, r11    = 0x%08x",
	pSave->nvreg[0], pSave->nvreg[1], pSave->nvreg[2], pSave->nvreg[3], 0);
    printExc ("\nr12 = 0x%08x, r13 = 0x%08x, r14  = 0x%08x, r15/sp = 0x%08x",
	pSave->nvreg[4], pSave->nvreg[5], pSave->nvreg[6], pSave->nvreg[7], 0);
    printExc ("\ngbr = 0x%08x, vbr = 0x%08x, mach = 0x%08x, macl   = 0x%08x",
	pSave->gbr,      pSave->vbr,      pSave->mac[0],   pSave->mac[1], 0);
    printExc ("\npr  = 0x%08x, sr  = 0x%08x, pc   = 0x%08x (inst   = 0x%04x)\n",
	(int) pSave->pr, pSave->sr, (int) pSave->pc, (int) *pSave->pc, 0);
    }

#if (CPU==SH7750 || CPU==SH7700)

/*******************************************************************************
*
* excFpregsShow - print SH7750/SH7718 FPU registers on TCB
*
* NOMANUAL
*/

LOCAL void excFpregsShow
    (
    FP_CONTEXT * pFp		/* pointer to FPU register info on TCB */
    )
    {
    UINT32 fpscr = pFp->fpscr;
    char s[64];

#if (CPU==SH7750)
    if (fpscr & FPSCR_DOUBLE_PRECISION)
    {
    excFormatDbl (pFp->fpx[0], pFp->fpx[1], s);
    printExc("\ndr0  = 0x%08x%08x (%s)\n",pFp->fpx[0], pFp->fpx[1], (int)s,0,0);
    excFormatDbl (pFp->fpx[2], pFp->fpx[3], s);
    printExc ( "dr2  = 0x%08x%08x (%s)\n",pFp->fpx[2], pFp->fpx[3], (int)s,0,0);
    excFormatDbl (pFp->fpx[4], pFp->fpx[5], s);
    printExc ( "dr4  = 0x%08x%08x (%s)\n",pFp->fpx[4], pFp->fpx[5], (int)s,0,0);
    excFormatDbl (pFp->fpx[6], pFp->fpx[7], s);
    printExc ( "dr6  = 0x%08x%08x (%s)\n",pFp->fpx[6], pFp->fpx[7], (int)s,0,0);
    excFormatDbl (pFp->fpx[8], pFp->fpx[9], s);
    printExc ( "dr8  = 0x%08x%08x (%s)\n",pFp->fpx[8], pFp->fpx[9], (int)s,0,0);
    excFormatDbl (pFp->fpx[10], pFp->fpx[11], s);
    printExc ( "dr10 = 0x%08x%08x (%s)\n",pFp->fpx[10],pFp->fpx[11],(int)s,0,0);
    excFormatDbl (pFp->fpx[12], pFp->fpx[13], s);
    printExc ( "dr12 = 0x%08x%08x (%s)\n",pFp->fpx[12],pFp->fpx[13],(int)s,0,0);
    excFormatDbl (pFp->fpx[14], pFp->fpx[15], s);
    printExc ( "dr14 = 0x%08x%08x (%s)\n",pFp->fpx[14],pFp->fpx[15],(int)s,0,0);
    }
    else
#endif
    {
    excFormatFlt (pFp->fpx[0], s);
    excFormatFlt (pFp->fpx[1], &s[32]);
    printExc ("\nfr0  = 0x%08x (%s)\nfr1  = 0x%08x (%s)\n",
	pFp->fpx[0], (int)s ,pFp->fpx[1], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[2], s);
    excFormatFlt (pFp->fpx[3], &s[32]);
    printExc ("fr2  = 0x%08x (%s)\nfr3  = 0x%08x (%s)\n",
	pFp->fpx[2], (int)s, pFp->fpx[3], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[4], s);
    excFormatFlt (pFp->fpx[5], &s[32]);
    printExc ("fr4  = 0x%08x (%s)\nfr5  = 0x%08x (%s)\n",
	pFp->fpx[4], (int)s, pFp->fpx[5], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[6], s);
    excFormatFlt (pFp->fpx[7], &s[32]);
    printExc ("fr6  = 0x%08x (%s)\nfr7  = 0x%08x (%s)\n",
	pFp->fpx[6], (int)s, pFp->fpx[7], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[8], s);
    excFormatFlt (pFp->fpx[9], &s[32]);
    printExc ("fr8  = 0x%08x (%s)\nfr9  = 0x%08x (%s)\n",
	pFp->fpx[8], (int)s, pFp->fpx[9], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[10], s);
    excFormatFlt (pFp->fpx[11], &s[32]);
    printExc ("fr10 = 0x%08x (%s)\nfr11 = 0x%08x (%s)\n",
	pFp->fpx[10], (int)s, pFp->fpx[11], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[12], s);
    excFormatFlt (pFp->fpx[13], &s[32]);
    printExc ("fr12 = 0x%08x (%s)\nfr13 = 0x%08x (%s)\n",
	pFp->fpx[12], (int)s, pFp->fpx[13], (int)&s[32], 0);

    excFormatFlt (pFp->fpx[14], s);
    excFormatFlt (pFp->fpx[15], &s[32]);
    printExc ("fr14 = 0x%08x (%s)\nfr15 = 0x%08x (%s)\n",
	pFp->fpx[14], (int)s, pFp->fpx[15], (int)&s[32], 0);
    }

    printExc ("fpul = 0x%08x\n", pFp->fpul, 0,0,0,0);

    /* dump FPSCR */
	{
	int i,j;
	UINT32 val = fpscr;
	char buf[32+1+3];

	for (i=0, j=0; i<32; ++i, ++j)
	    {
	    if (i==8 || i==16 || i==24) buf[j++] = ' ';

	    if (val & 0x80000000) buf[j] = '1'; else buf[j] = '0';
	    val <<= 1;
	    }
	buf [35] = '\0';
	printExc ("fpscr=(%s)\n", (int)buf,0,0,0,0);
	}
    printExc ("                  |||||      |     |    |     \n",0,0,0,0,0);

    switch (fpscr & FPSCR_ROUND_MODE_MASK)
	{
	case FPSCR_ROUND_TO_ZERO:	strcpy (s, "round to zero");	break;
	case FPSCR_ROUND_TO_NEAREST:	strcpy (s, "round to nearest");	break;
	default:			strcpy (s, "<reserved>");
	}
    printExc ("                  |||||      |     |    RM: %s\n",
		(int)s,0,0,0,0);

    s[0] = '\0';
    if (fpscr & FPSCR_FLAG_INVALID_OP)	strcat (s, " Invalid");
    if (fpscr & FPSCR_FLAG_ZERO_DIVIDE)	strcat (s, " Zero-Divide");
    if (fpscr & FPSCR_FLAG_OVERFLOW)	strcat (s, " Overflow");
    if (fpscr & FPSCR_FLAG_UNDERFLOW)	strcat (s, " Underflow");
    if (fpscr & FPSCR_FLAG_INEXACT)	strcat (s, " Inexact");
    if (s[0] == '\0') strcpy (s, " <none>");
    printExc ("                  |||||      |     Flag:%s\n",(int)s,0,0,0,0);

    s[0] = '\0';
    if (fpscr & FPSCR_ENABLE_INVALID_OP)strcat (s, " Invalid");
    if (fpscr & FPSCR_ENABLE_ZERO_DIVIDE)strcat (s, " Zero-Divide");
    if (fpscr & FPSCR_ENABLE_OVERFLOW)	strcat (s, " Overflow");
    if (fpscr & FPSCR_ENABLE_UNDERFLOW)	strcat (s, " Underflow");
    if (fpscr & FPSCR_ENABLE_INEXACT)	strcat (s, " Inexact");
    if (s[0] == '\0') strcpy (s, " <none>");
    printExc ("                  |||||      Enable:%s\n",(int)s,0,0,0,0);

    s[0] = '\0';
    if (fpscr & FPSCR_CAUSE_FPU_ERROR)	strcat (s, " FPU-Error");
    if (fpscr & FPSCR_CAUSE_INVALID_OP)	strcat (s, " Invalid");
    if (fpscr & FPSCR_CAUSE_ZERO_DIVIDE)strcat (s, " Zero-Divide");
    if (fpscr & FPSCR_CAUSE_OVERFLOW)	strcat (s, " Overflow");
    if (fpscr & FPSCR_CAUSE_UNDERFLOW)	strcat (s, " Underflow");
    if (fpscr & FPSCR_CAUSE_INEXACT)	strcat (s, " Inexact");
    if (s[0] == '\0') strcpy (s, " <none>");
    printExc ("                  ||||Cause:%s\n",(int)s,0,0,0,0);

    strcpy (s, fpscr & FPSCR_DENORM_TRUNCATE ? "zero" : "it is");
    printExc ("                  |||DN: treat denormalized number as %s\n",
		(int)s,0,0,0,0);

#if (CPU==SH7750)
    strcpy (s, fpscr & FPSCR_DOUBLE_PRECISION ? "double" : "single");
    printExc ("                  ||PR: %s precision\n",(int)s,0,0,0,0);

    strcpy (s, fpscr & FPSCR_FMOV_32BIT_PAIR ? "32bit pair" : "one 32bit");
    printExc ("                  |SZ: fmov transfers %s\n",(int)s,0,0,0,0);

    strcpy (s, fpscr & FPSCR_BANK1_SELECT ? "bank 1" : "bank 0");
    printExc ("                  FR: select FP register %s\n",(int)s,0,0,0,0);
#endif /*CPU==SH7750*/
    }

/******************************************************************************
*
* excFormatDbl - format double precision FP number into ASCII string
*
* RETURNS: OK, or ERROR
*
* NOMANUAL
*/

STATUS excFormatDbl
    (
    UINT32 upper32,
    UINT32 lower32,
    char *s
    )
    {
    UINT64 dval, body;
    BOOL sign;

    dval = upper32;
    dval <<= 32;
    dval += lower32;

    body = dval & 0x7fffffffffffffff;
    sign = dval & 0x8000000000000000 ? TRUE : FALSE;

    if      (body >= 0x7ff8000000000000) strcpy (s, "sNaN");
    else if (body >  0x7ff0000000000000) strcpy (s, "qNaN");
    else if (body == 0x7ff0000000000000) strcpy (s,  sign ? "-Inf" : "+Inf");
    else if (body == 0x0000000000000000) strcpy (s,  sign ? "-0.0" : "+0.0");
    else
	{
	int   exp = ((body & 0x7ff0000000000000) >> 52) - 1023;
	INT64 rem =   body & 0x000fffffffffffff;
	INT64 pow2to52 = 0x0010000000000000;
	int i;
	char buf[32];
	
	for (i=0; i<17; i++)
	    {
	    int quot = (rem * 10) / pow2to52;

	    if (quot > 9 || quot < 0)
		{
		strcpy (s, "error\n");
		return ERROR;
		}

	    buf[i] = (UINT8)quot | 0x30;
	    rem = (rem * 10) - (pow2to52 * quot);
	    }
	buf[i] = '\0';

	if (body >= pow2to52)
	    sprintf (s, "%s%s x 2^%+d", sign ? "-1." : "+1.", buf, exp);
	else
	    sprintf (s, "%s%s x 2^%+d", sign ? "-0." : "+0.", buf, exp + 1);
	}
    return OK;
    }

/******************************************************************************
*
* excFormatFlt - format single precision FP number into ASCII string
*
* RETURNS: OK, or ERROR
*
* NOMANUAL
*/

STATUS excFormatFlt
    (
    UINT32 fval,
    char *s
    )
    {
    UINT32 body = fval & 0x7fffffff;
    BOOL   sign = fval & 0x80000000 ? TRUE : FALSE;

    if      (body >= 0x7fc00000) strcpy (s, "sNaN");
    else if (body >  0x7f800000) strcpy (s, "qNan");
    else if (body == 0x7f800000) strcpy (s,  sign ? "-Inf" : "+Inf");
    else if (body == 0x00000000) strcpy (s,  sign ? "-0.0" : "+0.0");
    else
	{
	int exp = ((body & 0x7f800000) >> 23) - 127;
	int rem =   body & 0x007fffff;
	int pow2to23 = 0x00800000;
	int i;
	char buf[16];

	for (i=0; i<8; i++)
	    {
	    int quot = (rem * 10) / pow2to23;

	    if (quot > 9 || quot < 0)
		{
		strcpy (s, "error\n");
		return ERROR;
		}

	    buf[i] = (UINT8)quot | 0x30;
	    rem = (rem * 10) - (pow2to23 * quot);
	    }
	buf[i] = '\0';

	if (body >= pow2to23)
	    sprintf (s, "%s%s x 2^%+d", sign ? "-1." : "+1.", buf, exp);
	else
	    sprintf (s, "%s%s x 2^%+d", sign ? "-0." : "+0.", buf, exp + 1);
	}
    return OK;
    }

#endif /* CPU==SH7750 || CPU==SH7700 */