go.c

MIPS处理器的bootloader,龙芯就是用的修改过的PMON2

			else if (i == MAX_BPT) {
				if (WatchLo & (WATCH_R | WATCH_W)) {
					WatchLo = 0;
				}
				else {
					printf ("Bpt %2d not set\n", i);
				}

			}
#endif
			else {
				printf ("%d: breakpoint number too large\n", i);
			}
		}
	}
	else {
		dspbpts ();
	}
	return (0);
}

/*************************************************************
 *  rm_bpts()
 */
void
rm_bpts ()
{
	int	i;

	if (BptTmp.addr != NO_BPT && load_word (BptTmp.addr) == BPT_CODE) {
		store_word ((void *)BptTmp.addr, BptTmp.value);
	}

	for(i = 0; i < MAX_BPT; i++) {
		if(Bpt[i].addr != NO_BPT && load_word(Bpt[i].addr) == BPT_CODE) {
			store_word((void *)Bpt[i].addr, Bpt[i].value);
		}
	}
	remove_trace_breakpoint();
}

/*************************************************************
 *  clrbpts()
 */
void
clrbpts ()
{
	int	i;

	for (i = 0; i < MAX_BPT; i++) {
		Bpt[i].addr = NO_BPT;
		if (Bpt[i].cmdstr)
		free (Bpt[i].cmdstr);
	}
#if defined(R4000)
	WatchLo = 0;
#endif
}

/*************************************************************
 *  goclient()
 */
int
goclient ()
{
	if (is_break_point (md_getpc())) {
		if (setTrcbp (md_getpc(), 0)) {
			return (1);
		}
		trace_mode = TRACE_TG;
		store_trace_breakpoint ();
	}
	else {
		trace_mode = TRACE_GB;
		store_breakpoint ();
	}
	_go ();
	return(0); /* Never really gets here if _go gets called */
}

/*************************************************************
 * sstep()
 */
void
sstep ()
{

    if (setTrcbp (md_getpc(), 0))
	return;
    trace_mode = TRACE_DS;
    store_trace_breakpoint ();
    _go ();
}

/*************************************************************
 *  pmexception(cpc,cause)
 *      An (fatal) exception has been generated within PMON
 */

#if 0 /*XXX*/
pmexception (cpc, cause, ra, badva)
    unsigned int cpc, cause, ra, badva;
{
    extern char    *sbdexception();
    char 	   *exc;
    extern int     *curlst;
    int 	   i;

#ifdef INET
    /* lock out all "interrupts" */
    (void) splhigh();
#endif

    /* display exception on alpha-display before attempting to print */
    exc = 0;
    for (i = (curlst ? 1 : 5); i != 0; i--)
      exc = sbdexception (cpc, cause, ra, badva, exc);

    if (!curlst)
	tgt_reboot ();

    if (exc)
      printf ("\r\n%s\r\n", exc);
    else 
      printf ("\r\nPMON %s exception\r\n", md_getexcname (frame));

#ifdef R4000
    if (cause == EXC_CP2) {
	printf ("ErrPC:    %08x\r\n", cpc);
	printf ("CacheErr: %08x\r\n", badva);
	printf ("ECC:      %08x\r\n", get_ecc());
	tgt_reboot ();
    }
#endif

    printf ("CPC:      %08x\r\n", cpc);
    printf ("RA:       %08x\r\n", ra);
    printf ("Cause:    %08x\r\n", cause);
    switch (cause & CAUSE_EXCMASK) {
    case EXC_MOD:
    case EXC_TLBL:
    case EXC_TLBS:
    case EXC_ADEL:
    case EXC_ADES:
	printf ("BadVaddr: %08x\r\n", badva);
    }

#ifdef INET
    /* XXX something is going wrong when we try to reset the sonic interface */
    /* XXX for now we'll just completely reinitialise from scratch */
    /*reset_net ();*/
    tgt_reboot ();
#endif
    closelst (0);
    curlst = 0;
    main ();
printf("PMON EXCEPTION\n");
}
#endif


/*************************************************************
 *  exception()
 *      An exception has been generated within the client
 */
void
exception(frame)
	struct trapframe *frame;
{
	int exc_type;
	int i, flag;
	char tmp[80], *p = 0;
extern char    *sbddbgintr(unsigned int);

	TRPREG = *frame;	/* Copy and give up frame on stack */
	DBGREG = *frame;
	frame = &TRPREG;

	exc_type = md_exc_type(frame);

#if 0
    if (exc_type == EXC_INT && (p = sbddbgintr (Cause & Status)))
      printf ("\r\n%s Interrupt\r\n", p);

    if (trace_mode == TRACE_DC || trace_mode == TRACE_DS) {
	/* pass all exceptions to remote debugger */
	remove_trace_breakpoint ();
	dbgmode ();
    }
#endif

	if(exc_type != EXC_BPT && exc_type != EXC_TRC && exc_type != EXC_WTCH) {
		if (!p) {
			printf ("\r\nException Cause=%s, SR=0x%08x\r\n",
				md_getexcname(frame)), md_getsr();
		}
		stop (0);
	}
	else if (trace_mode == TRACE_NO) {	/* no bpts set */
		printf ("\r\nBreakpoint reached while not in trace mode!\r\n");
		stop (0);
	}
	else if (trace_mode == TRACE_GB) {	/* go & break */
		if (BptTmp.addr != NO_BPT) {
			store_word ((void *)BptTmp.addr, BptTmp.value);
			BptTmp.addr = NO_BPT;
		}
		for (i = 0; i < MAX_BPT; i++) {
			if (Bpt[i].addr != NO_BPT) {
				store_word ((void *)Bpt[i].addr, Bpt[i].value);
			}
		}
		if (exc_type == EXC_WTCH) {
			printf ("\r\nStopped at HW Bpt %d\r\n", MAX_BPT);
		}
		else {
			for (i = 0; i < MAX_BPT; i++) {
				if (Bpt[i].addr == md_get_excpc(frame)) {
					printf ("\r\nStopped at Bpt %d\n", i);
					stop (Bpt[i].cmdstr);
				}
			}
		}
		stop (0);
	}
    
	remove_trace_breakpoint ();
	if (trace_mode == TRACE_TB) {
		stop (0);		/* trace & break */
	}
	else if (trace_mode == TRACE_TN) {
		for (i = 0; i < MAX_BPT; i++) {
			if (Bpt[i].addr == md_get_excpc(frame)) {
				printf ("\r\nStopped at Bpt %d\r\n", i);
				stop (Bpt[i].cmdstr);
			}
		}
		if (trace_invalid && !is_validpc (md_get_excpc(frame))) {
			printf ("\r\nStopped: Invalid PC value\r\n");
			stop (0);
		}
		for (i = 0; i < STOPMAX; i++) {
			if (stopval[i].addr == 0) {
				continue;
			}
			if ((stopval[i].sense == 0 &&
				load_word (stopval[i].addr) == stopval[i].value)
				|| (stopval[i].sense == 1 &&
				load_word (stopval[i].addr) != stopval[i].value)) {
				if (stopval[i].sense == 0) {
					p = " == ";
				}
				else {
					p = " != ";
				}
				if (strequ (stopval[i].name, "MEMORY")) {
					printf ("\r\nStopped: 0x%08x%s0x%08x\r\n",
						stopval[i].addr, p, stopval[i].value);
				}
				else {
					printf ("\r\nStopped: %s%s0x%08x\r\n", stopval[i].name,
						p, stopval[i].value);
				}
				stop (0);
			}
		}
		flag = 1;
		if (trace_bflag || trace_cflag) {
			if (trace_bflag && md_is_branch ((int *)md_get_excpc(frame))) {
				flag = 1;
			}
			else if (trace_cflag && md_is_call ((int *)md_get_excpc(frame))) {
				flag = 1;
			}
			else {
				flag = 0;
			}
		}
		if (flag) {
			addpchist (md_get_excpc(frame));
			if (trace_verbose) {
				md_disasm (tmp, (void *)md_get_excpc(frame));
				printf ("%s\r\n", tmp);
#ifdef HAVE_DLYSLOT
				if (md_is_branch((void *)md_get_excpc(frame))) {
				/* print the branch delay slot too */
					md_disasm(tmp, (void *)md_get_excpc(frame) + 4);
					printf ("%s\r\n", tmp);
				}
#endif
			}
			else {
				dotik (256, 1);
			}
		}
		else {
			dotik (256, 1);
		}
		if (trace_count) {
			trace_count--;
		}
		if (trace_count == 1) {
			trace_mode = TRACE_TB;
		}
		if (setTrcbp (md_get_excpc(frame), trace_over)) {
			stop (0);
		}
		store_trace_breakpoint ();
		_go ();
	}
/* else TRACE_TG  trace & go, set on g or c if starting at bpt */

	trace_mode = TRACE_GB;	/* go & break */
	store_breakpoint ();
	_go ();
}

/*************************************************************
 *  stop(cmdstr)
 */
void
stop (cmdstr)
	char *cmdstr;
{
	char cmd[LINESZ];

	swlst (1);
	trace_mode = TRACE_NO;
	if (cmdstr) {
		strcpy (cmd, cmdstr);
	}
	else {
		strcpy (cmd, getenv ("brkcmd"));
	}
	do_cmd (cmd);
	main ();
}

/*************************************************************
 *  store_breakpoint()
 */
static void
store_breakpoint ()
{
    int             i;

	/*
	 *  Verify that a trace breakpoint won't
	 *  clash with a 'real' breakpoint. If
	 *  that is the case simply remove trace.
	 */
	for (i = 0; i < MAX_BPT; i++) {
		if (BptTmp.addr == Bpt[i].addr) {
			BptTmp.addr = NO_BPT;
		}
		if (BptTrc.addr == Bpt[i].addr) {
			BptTrc.addr = NO_BPT;
		}
		if (BptTrcb.addr == Bpt[i].addr) {
			BptTrcb.addr = NO_BPT;
		}
	}

	/*
	 *  Now do the same check with the trace breaks.
	 */
	if (BptTrc.addr == BptTmp.addr) {
		BptTrc.addr = NO_BPT;
	}
	if (BptTrcb.addr == BptTmp.addr || BptTrcb.addr == BptTrc.addr) {
		BptTrcb.addr = NO_BPT;
	}

	/*
	 *  Activate the 'real' breakpoints.
	 */
	for (i = 0; i < MAX_BPT; i++) {
		if (Bpt[i].addr != NO_BPT) {
			Bpt[i].value = load_word (Bpt[i].addr);
			store_word ((void *)Bpt[i].addr, BPT_CODE);
		}
	}
	if (BptTmp.addr != NO_BPT) {
		BptTmp.value = load_word (BptTmp.addr);
		store_word ((void *)BptTmp.addr, BPT_CODE);
	}
	store_trace_breakpoint ();
}

/*
 *  When doing single step tracing we need to deal with different
 *  aproaches. Some arches have a trace function while others don't
 *  have HW support for it. The following two functions either embed
 *  the traced instruction with a breakpoint or uses the HW trace.
 *  
 *  store_trace_breakpoint()
 *  remove_trace_breakpoint()
 */
static void
store_trace_breakpoint ()
{
#ifdef HAVE_TRACE
	if (BptTrc.addr != NO_BPT) {
		md_settrace();
	}
#else
	if (BptTrc.addr != NO_BPT) {
		BptTrc.value = load_word (BptTrc.addr);
		store_word ((void *)BptTrc.addr, BPT_CODE);
	}
	if (BptTrcb.addr != NO_BPT) {
		BptTrcb.value = load_word (BptTrcb.addr);
		store_word ((void *)BptTrcb.addr, BPT_CODE);
	}
#endif
}

static void
remove_trace_breakpoint ()
{
#ifndef HAVE_TRACE
	if (BptTrc.addr != NO_BPT && load_word (BptTrc.addr) == BPT_CODE) {
		store_word ((void *)BptTrc.addr, BptTrc.value);
	}
	if (BptTrcb.addr != NO_BPT && load_word (BptTrcb.addr) == BPT_CODE) {
		store_word ((void *)BptTrcb.addr, BptTrcb.value);
	}

	BptTrc.addr = NO_BPT;
	BptTrcb.addr = NO_BPT;
#endif
}

/*************************************************************
 *  int is_break_point(adr)
 */
static int 
is_break_point (adr)
     int32_t            adr;
{
    int             i;

    for (i = 0; i < MAX_BPT; i++)
	if (Bpt[i].addr == adr)
	    return (1);
    if (BptTmp.addr == adr)
	return (1);
    return (0);
}

#define NVALIDPC	10
static unsigned long	validpc[NVALIDPC];
static int		nvalidpc = -1;


void
flush_validpc ()
{
    nvalidpc = -1;
}


/* chg_validpc: called if variable is changed */
int
chg_validpc (name, value)
    char *name, *value;
{
    char           *av[NVALIDPC], tmp[80];

    strcpy (tmp, value);
    if (argvize (av, tmp) % 2 != 0) {
	printf ("validpc variable must have even number of values\n");
	return (0);
    }
    /* don't check the values here, symbols may not be loaded */
    flush_validpc ();
    return (1);
}


static void
compute_validpc ()
{
    char           *av[NVALIDPC], tmp[80];
    int		    ac, i;

    strcpy (tmp, getenv ("validpc"));
    ac = argvize (av, tmp);
    nvalidpc = 0;
    
    for (i = 0; i < ac; i += 2) {
	if (!get_rsa ((u_int32_t *)&validpc[nvalidpc], av[i]))
	  continue;
	if (!get_rsa ((u_int32_t *)&validpc[nvalidpc+1], av[i+1]))
	  continue;
	nvalidpc += 2;
    }
}


/*************************************************************
 *  is_validpc(adr)
 */
static int
is_validpc (adr)
    int32_t adr;
{
    int         i;

    if (nvalidpc < 0)
      compute_validpc ();

    for (i = 0; i < nvalidpc; i += 2)
      if ((u_int32_t)adr >= validpc[i] && (u_int32_t)adr < validpc[i+1])
	return (1);

    return (0);
}


/*************************************************************
 *  addpchist(adr)
 */
static void
addpchist (adr)
    int   adr;
{
    pchist_d[pchist_ip] = adr;
    pchist_ip = incmod (pchist_ip, PCHISTSZ);
    if (pchist_ip == pchist_op)
	pchist_op = incmod (pchist_op, PCHISTSZ);
}

/*************************************************************
 *  clrpchist()
 */
static void
clrpchist ()
{
    pchist_ip = pchist_op = 0;
}

/*************************************************************
 *  unsigned long getpchist(n)
 */
u_int32_t 
getpchist (n)
     int             n;
{
    int             i;

    i = pchist_ip - n - 1;
    if (i < 0)
	i += PCHISTSZ + 1;
    if (incmod (i, PCHISTSZ) == pchist_op)
	return (0);
    return (pchist_d[i]);
}

/*************************************************************
 *  setTrcbp(adr,stepover)
 */
static int
setTrcbp (adr, stepover)
     int32_t	     adr;
     int             stepover;
{

	BptTrc.addr = NO_BPT;
	BptTrcb.addr = NO_BPT;
#ifdef HAVE_TRACE
	BptTrc.addr = adr + 4;
#else
	if (md_is_branch((void *)adr)) {
		unsigned long   target;
#if 0
		if (md_is_branch ((void *)adr + 4)) {
			printf ("branch in delay slot\n");
			return (1);
		}
#endif
		target = md_branch_target((void *)adr);
		if (target == adr)
			target = adr + 8;	/* skip self branches */
		if(md_is_cond_branch((void *)adr) && target != adr + 8)
			BptTrc.addr = adr + 8;
		if(md_is_call((void *)adr) && stepover)
			BptTrc.addr = adr + 8;
		else if(md_is_jr((void *)adr) && !md_is_writeable((void *)target))
			BptTrc.addr = md_getlink();
		else
			BptTrcb.addr = target;
	}
	else {
		BptTrc.addr = adr + 4;
	}
#endif /* HAVE_TRACE */
    return (0);
}