trclib.c

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

/* trcLib.c - PowerPC stack trace library */

/* Copyright 1984-1994 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
02b,27feb96,ms   reworked findFuncStart.
02a,01feb96,ms   rewritten.
01c,16jan95,caf  disabled stack trace support for now.
01b,05dec94,caf  added cast to trcStack().
01a,07nov94,yao  written.
*/

/*
This module provides the routine trcStack(), which traces a stack
given the current frame pointer, stack pointer, and program counter.
The resulting stack trace lists the nested routine calls and their arguments.

This module provides the low-level stack trace facility.
A higher-level symbolic stack trace, implemented on top of this facility,
is provided by the routine tt() in dbgLib.

SEE ALSO:
dbgLib, tt(),
.pG "Debugging"
*/

#include "vxWorks.h"
#include "symLib.h"
#include "taskLib.h"
#include "regs.h"
#include "string.h"
#include "private/funcBindP.h"
#include "dbgLib.h"
#include "sysSymTbl.h"
#include "vxLib.h"

/* definitions */

#define MAX_TRACE_DEPTH	80	/* maximum stack frames to trace */
#define MAX_SCAN_DEPTH	250	/* maximum distance to scan text */
#define MAX_PROLOGUE_SIZE 20	/* maximum size of function prologue */
#define FP_FROM_STACK(sp)	 (*(char **)(sp))
#define RETURN_PC_FROM_STACK(sp) (*(INSTR **)((sp) + 4))
#define BOGUS_SP(sp,low,high)	 (((int)(sp) % 8) || ((sp) < (low)) || \
				  ((sp) > (high)) || (sp == 0))
#define BOGUS_PC(pc, junk)	 (vxMemProbe((char *)(pc), VX_READ, 4, \
				  (char *)&(junk)) == ERROR)

/* some dissassembly macros */

#define INST_LWZX_SP		_OP(31, 55) | (1 << 21)
#define INST_LWZUX_SP		_OP(31, 23) | (1 << 21)
#define INST_LWZX_SP_MASK	0xffe007fe
#define INST_LWZ_SP_MASK	0xffe00000
#define STW(reg)	((36 << 26) | ((reg) << 21))
#define STW_REG_MASK	0xffe00000

/* globals */

int trcDefaultArgs = 0;			/* default # of args to print */
int trcScanDepth = MAX_SCAN_DEPTH;

/* forward declarations */

static int	trcGetArgs (INSTR *procAddr, char *sp, int *args);
static INSTR *	trcFindFuncStart (INSTR *pc, INSTR *returnPc);
static void	trcDefaultPrint (INSTR *callAdrs, INSTR *funcAdrs, 
			int nargs, int *args);
static void	trcStackLvl (INSTR *pc, INSTR *returnPc, char *sp, char *fp,
			char *stackBottom, int depth, FUNCPTR printRtn);
static STATUS	trcInfoGet (int tid, REG_SET * pRegs, INSTR ** pPc,
			INSTR ** pReturnPc, char ** pSp, char ** pFp);

/*******************************************************************************
*
* trcStack - print a trace of function calls from the stack
*
* This routine provides the low-level stack trace function.
* A higher-level symbolic stack trace, built on top of this, is provided
* by tt() in dbgLib.
* 
* The routine prints a list of the nested routine calls that are on the stack,
* showing each routine call with its parameters.
*
* The stack being traced should be quiescent.  The caller should avoid tracing
* its own stack.
*
* PRINT ROUTINE
* To allow symbolic or alternative printout formats, the call to this
* routine includes the <printRtn> parameter, which specifies a user-supplied
* routine to be called at each nesting level to print out the routine name
* and its arguments.  This routine should be declared as follows:
* .ne 5
* .CS
*     void printRtn (callAdrs, rtnAdrs, nargs, args)
*         INSTR *callAdrs;  /@ address from which routine was called @/
*         int   rtnAdrs;    /@ address of routine called             @/
*         int   nargs;      /@ number of arguments in call           @/
*         int   *args;      /@ pointer to arguments                  @/
* .CE
*
* If <printRtn> is NULL, a default routine is used that prints out just
* the call address, function address, and arguments as hexadecimal values.
*
* CAVEAT
* There is no way to determine the function arguments unless the
* code is compiled with debugging (e.g., "-gdwarf).
*
* EXAMPLE
* The following sequence can be used
* to trace a VxWorks task given a pointer to the task's TCB:
* .CS
*
*     REG_SET regSet;	/@ task's data registers @/
*
*     taskRegsGet (taskId, &regSet);
*     trcStack (&regSet, (FUNCPTR) NULL, tid);
*
* .CE
*
* RETURNS: N/A
*
* SEE ALSO: tt()
* 
* NOMANUAL
*/

void trcStack
    (
    REG_SET * pRegs,	/* general purpose registers */
    FUNCPTR printRtn,	/* routine to print single function call */
    int     tid         /* task's id */
    )
    {
    char *stackBottom = taskTcb (tid)->pStackBase;
    char *sp;			/* current stack pointer */
    char *fp;			/* frame pointer (previous sp) */
    INSTR *pc;			/* current program counter */
    INSTR *returnPc;		/* return address */

    /* get info on the top level stack frame */

    if (trcInfoGet (tid, pRegs, &pc, &returnPc, &sp, &fp) == ERROR)
	{
	if (_func_printErr != NULL)
	    _func_printErr ("trcStack aborted: error in top frame\n");
	return;
	}

    /* use default print routine if none specified */

    if (printRtn == NULL)
	printRtn = (FUNCPTR) trcDefaultPrint;

    /* do the recursive stack trace. */

    trcStackLvl (pc, returnPc, sp, fp, stackBottom, 0, printRtn);
    }

/************************************************************************
*
* trcStackLvl - recursive stack trace routine
*
* This routine is recursive, being called once for each level of routine
* nesting.  The maximum recursion depth is limited to 40 to prevent
* garbage stacks from causing this routine to continue unbounded.
* The "depth" parameter on the original call should be 0.
*/

static void trcStackLvl
    (
    INSTR *pc,		/* current program counter location */
    INSTR *returnPc,	/* return address */
    char *sp,		/* stack pointer */
    char *fp,		/* frame pointer (previous stack pointer) */
    char *stackBottom,	/* effective base of task's stack */
    int depth,		/* recursion depth */
    FUNCPTR printRtn 	/* routine to print single function call */
    )
    {
    char *	prevFp = NULL;
    INSTR *	prevReturnPc;
    int		args[MAX_TASK_ARGS];
    INSTR *	procAddr;
    int		nArgs;

    /* recursive trace if depth not maxed and framepointer is valid */

    if (depth < MAX_TRACE_DEPTH)
	{
	prevFp = FP_FROM_STACK(fp);
	if (BOGUS_SP (prevFp, fp, stackBottom))
	    return;

	prevReturnPc = RETURN_PC_FROM_STACK(prevFp);
	if (!BOGUS_PC (prevReturnPc, procAddr))
	    trcStackLvl (returnPc, prevReturnPc, fp, prevFp, stackBottom,
			 depth+1, printRtn);
	}

    /* get the current routine's starting address */

    procAddr = trcFindFuncStart (pc, returnPc);

    /* get the function arguments */

    nArgs = trcGetArgs (procAddr, sp, args);

    (* printRtn) (returnPc, procAddr, nArgs, args);
    }

/*******************************************************************************
*
* trcDefaultPrint - print a function call
*
* This routine is called by trcStack to print each level in turn.
*
* If nargs is specified as 0, then a default number of args (trcDefaultArgs)
* is printed in brackets ("[..]"), since this often indicates that the
* number of args is unknown.
*/

static void trcDefaultPrint
    (
    INSTR *callAdrs,		/* address from which function was called */
    INSTR *funcAdrs,		/* address of function called */
    int nargs,			/* number of arguments in function call */
    int *args 			/* pointer to function args */
    )
    {
    int ix;
    BOOL doingDefault = FALSE;

    if (!_func_printErr)
	return;

    /* print call address and function address */

    _func_printErr ("%6x: %x (", callAdrs, funcAdrs);

    /* if no args are specified, print out default number (see doc at top) */

    if ((nargs == 0) && (trcDefaultArgs != 0))
	{
	doingDefault = TRUE;
	nargs = trcDefaultArgs;
	_func_printErr ("[");
	}

    /* print args */

    for (ix = 0; ix < nargs; ++ix)
	{
	if (ix != 0)
	    _func_printErr (", ");
	_func_printErr ("%x", args[ix]);
	}

    if (doingDefault)
	_func_printErr ("]");

    _func_printErr (")\n");
    }

/******************************************************************************
*
* trcFindFuncStart - get starting address of a procedure.
*
* Given a "pc" value, determine the address of the procedure
* containing that pc.
* We try several methods until one succeeds.
* 1) First check the returnPc to see if we got to the current proc
* via a branch instruction. If so we can determine the procedure
* address accuratly.
* 2) If there is no branch instruction found, scan backwards up to
* trcScanDepth bytes looking for a "stwu sp, xxx(sp)" instruction,
* and assume that instruction is the proc entry.
*
* RETURNS: The starting address of the procedure, or NULL if it couldn't
* be found.