go.c

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

/* $Id: go.c,v 1.1.1.3 2003/03/18 22:31:48 anoncvs Exp $ */

#include <stdio.h>
#include <termio.h>
#include <string.h>
#include <setjmp.h>
#include <stdlib.h>

#include <signal.h>
#include <machine/cpu.h>
#include <machine/frame.h>
#ifdef _KERNEL
#undef _KERNEL
#include <sys/ioctl.h>
#define _KERNEL
#else
#include <sys/ioctl.h>
#endif

#include <pmon.h>

extern struct trapframe DBGREG;
extern struct trapframe TRPREG;

extern void _go __P((void));

int             trace_mode;
unsigned long   trace_count;
int             trace_verbose;
int             trace_invalid;
int             trace_over;
int             trace_bflag;
int             trace_cflag;

char            clientcmd[LINESZ];
char           *clientav[MAX_AC];
int		clientac;

extern int      clkdat;
#if defined(SCSI) || defined(IDE)
extern void    *callvec;
#else
#define callvec NULL
#endif

#define STOPMAX 10
Stopentry       stopval[STOPMAX];

#define PCHISTSZ  200
unsigned long   pchist_d[PCHISTSZ + 1];
int             pchist_ip, pchist_op;

jmp_buf	gobuf;

void exception __P((struct trapframe *));

static int	setTrcbp __P((int32_t, int));
static int	is_break_point __P((int32_t));
static int	is_validpc __P((int32_t));
static void	addpchist __P((int));
static void	clrpchist __P((void));
static void store_trace_breakpoint __P((void));
static void remove_trace_breakpoint __P((void));
static void store_breakpoint __P((void));
void sstep __P((void));
static void compute_validpc __P((void));
void stop __P((char *));
void rm_bpts __P((void));
void dspbpts __P((void));
int addstop __P((u_int32_t, u_int32_t, char *, char));
void initstack __P((int, char **, int));

/*
 *  Build argument area on 'clientstack' and set up clients
 *  argument registers in preparation for 'launch'.
 *  arg1 = argc, arg2 = argv, arg3 = envp, arg4 = callvector
 */

void
initstack (ac, av, addenv)
    int ac;
    char **av;
    int addenv;
{
	char	**vsp, *ssp;
	int	ec, stringlen, vectorlen, stacklen, i;
	register_t nsp;

	/*
	 *  Calculate the ammount of stack space needed to build args.
	 */
	stringlen = 0;
	for (i = 0; i < ac; i++) {
		stringlen += strlen(av[i]) + 1;
	}
	if (addenv) {
		envsize (&ec, &stringlen);
	}
	else {
		ec = 0;
	}
	stringlen = (stringlen + 3) & ~3;	/* Round to words */
	vectorlen = (ac + ec + 2) * sizeof (char *);
	stacklen = ((vectorlen + stringlen) + 7) & ~7;

	/*
	 *  Allocate stack and us md code to set args.
	 */
	nsp = md_adjstack(0) - stacklen;
	md_setargs(ac, nsp, nsp + (ac + 1) * sizeof(char *), (int)callvec);

	/* put $sp below vectors, leaving 32 byte argsave */
	md_adjstack(nsp - 32);
	memset((void *)(nsp - 32), 0, 32);

	/*
	 * Build argument vector and strings on stack.
	 * Vectors start at nsp; strings after vectors.
	 */
	vsp = (char **) nsp;
	ssp = (char *) (nsp + vectorlen);

	for (i = 0; i < ac; i++) {
		*vsp++ = ssp;
		strcpy (ssp, av[i]);
		ssp += strlen(av[i]) + 1;
	}
	*vsp++ = (char *)0;

	/* build environment vector on stack */
	if (ec) {
		envbuild (vsp, ssp);
	}
	else {
		*vsp++ = (char *)0;
	}
}


const Optdesc         g_opts[] = {
	{"-s", "don't set client sp"},
	{"-t", "time execution"},
	{"-e <adr>", "start address"},
	{"-b <bptadr>", "temporary breakpoint"},
	{"-- <args>", "args to be passed to client"},
	{0}
};

/*************************************************************
 *  go(ac,av), the 'g' command
 */
int
go (ac, av)
	int	ac;
	char	*av[];
{
	int32_t	adr;
	int	sflag;
	int	c;
extern int	optind;
extern char	*optarg;

	sflag = 0;
	BptTmp.addr = NO_BPT;
	BptTrc.addr = NO_BPT;
	BptTrcb.addr = NO_BPT;

	strcpy (clientcmd, av[0]);
	strcat (clientcmd, " ");

	optind = 0;
	while ((c = getopt (ac, av, "b:e:st")) != EOF) {
		switch (c) {
		case 's':
			sflag = 1; 
			break;
		case 't':
			strcpy (clientcmd, "time ");
			break;
		case 'b':
			if (!get_rsa (&adr, optarg)) {
				return (-1);
			}
			BptTmp.addr = adr;
			break;
		case 'e':
			if (!get_rsa (&adr, optarg)) {
				return (-1);
			}
			md_setentry(adr);
			break;
		default:
			return (-1);
		}
	}

	while (optind < ac) {
		strcat (clientcmd, av[optind++]);
		strcat (clientcmd, " ");
	}

	if (!sflag) {
		md_adjstack(tgt_clienttos ());
	}

	clientac = argvize (clientav, clientcmd);
	initstack (clientac, clientav, 1);

	clrhndlrs ();
	closelst (2);
	md_setsr(initial_sr);
	tgt_enable (tgt_getmachtype ()); /* set up i/u hardware */
#ifdef FLOATINGPT
	Fcr = 0;		/* clear any outstanding exceptions / enables */
#endif

#ifdef __powerpc__
	strcpy ((void *)0x4200, getenv ("vxWorks"));
#endif

	if (setjmp (gobuf) == 0) {
		goclient ();
	}
	swlst(1);
	return 0;
}

/*************************************************************
 *  cont(ac,av) the continue command
 */
int
cont (ac, av)
	int	ac;
	char	*av[];
{
	int32_t	adr;

	BptTmp.addr = NO_BPT;
	BptTrc.addr = NO_BPT;
	BptTrcb.addr = NO_BPT;
	if (ac > 1) {
		if (!get_rsa (&adr, av[1])) {
			return (-1);
		}
		BptTmp.addr = adr;
	}
	goclient ();
	return(0); /* Shut up gcc */
}

/*************************************************************
 *  trace(ac,av) the 't' (single-step) command
 */
const Optdesc         t_opts[] = {
	{"-v", "verbose, list each step"},
	{"-b", "capture only branches"},
	{"-c", "capture only calls"},
	{"-i", "stop on pc invalid"},
	{"-m adr val", "stop on mem equal"},
	{"-M adr val", "stop on mem not equal"},
	{"-r reg val", "stop on reg equal"},
	{"-R reg val", "stop on reg not equal"},
	{0}
};

int
trace (ac, av)
	int ac;
	char *av[];
{
	int multi, i, j, n;
	register_t *reg;
	register_t adr, val;
	struct trapframe *frame = &DBGREG;

	trace_over = 0;
	if (strequ (av[0], "to")) {
		trace_over = 1;
	}

	n = 0;
	multi = 0;
	trace_verbose = 0;
	trace_invalid = 0;
	trace_bflag = 0;
	trace_cflag = 0;

	for (i = 0; i < STOPMAX; i++) {
		stopval[i].addr = 0;
	}
	for (i = 1; i < ac; i++) {
		if (av[i][0] == '-') {
			for (j = 1; av[i][j] != 0; j++) {
				if (av[i][j] == 'v') {
					trace_verbose = 1;
					trace_count = 0;
					multi = 1;
				}
				else if (av[i][j] == 'm' || av[i][j] == 'M') {
					if (i + 2 >= ac) {
						printf ("bad arg count\n");
						return (-1);
					}
					if (!get_rsa (&adr, av[i + 1])) {
						return (-1);
					}
					if (!get_rsa (&val, av[i + 2])) {
						return (-1);
					}
					if (!addstop (adr, val, "MEMORY", av[i][j])) {
						return (1);
					}
					trace_count = 0;
					multi = 1;
					i += 2;
					break;
				}
				else if (av[i][j] == 'r' || av[i][j] == 'R') {
					if (i + 2 >= ac) {
						printf ("bad arg count\n");
						return (-1);
					}
					if (!md_getregaddr (&reg, av[i + 1])) {
						printf ("%s: bad reg name\n", av[i + 1]);
						return (-1);
					}
					if (!get_rsa (&val, av[i + 2])) {
						return (-1);
					}
					if (!addstop (*reg, val, av[i + 1], av[i][j])) {
						return (1);
					}
					trace_count = 0;
					multi = 1;
					i += 2;
					break;
				}
				else if (av[i][j] == 'b') {
					trace_bflag = 1;
				}
				else if (av[i][j] == 'c') {
					trace_cflag = 1;
				}
				else if (av[i][j] == 'i') {
					trace_invalid = 1;
					trace_count = 0;
					multi = 1;
				}
				else {
					printf ("%c: unrecognized option\n", av[i][j]);
					return (-1);
				}
			}
		}
		else {
			if (n == 0) {
				if (!get_rsa ((u_int32_t *)&trace_count, av[i])) {
					return (-1);
				}
				multi = 1;
			}
			else {
				printf ("%s: unrecognized argument\n", av[i]);
				return (-1);
			}
			n++;
		}
	}

	if (setTrcbp (md_get_excpc(frame), trace_over))
		return (1);
	clrpchist ();
	if (multi)
		trace_mode = TRACE_TN;
	else
		trace_mode = TRACE_TB;
	store_trace_breakpoint ();
	_go ();
	return(0); /* Shut up gcc */
}

/*************************************************************
 *  addstop(adr,val,name,sense)
 */
int
addstop (adr, val, name, sense)
	u_int32_t adr, val;
	char *name, sense;
{
	int i;

	for (i = 0; i < STOPMAX; i++) {
		if (stopval[i].addr == 0) {
			break;
		}
	}
	if (i >= STOPMAX) {
		printf ("stopval table full\n");
		return (0);
	}
	stopval[i].addr = adr;
	stopval[i].value = val;
	strcpy (stopval[i].name, name);
	if (sense == 'M' || sense == 'R') {
		stopval[i].sense = 1;
	}
	else {
		stopval[i].sense = 0;
	}
	return (1);
}

/*************************************************************
 *  setbp(ac,av) the 'b' (set breakpoint) command
 */
const Optdesc         b_opts[] = {
#ifdef R4000
	{"-d", "hw bpt for data access"},
	{"-r", "hw bpt for data read only"},
	{"-w", "hw bpt for data write only"},
#endif
	{"-s", "command string"},
	{0}
};

int
setbp (ac, av)
	int	ac;
	char	*av[];
{
	int32_t	adr, i, j, w, x;
	char	*str;
	int	flag = 0;

	if (ac == 1) {
		dspbpts ();
		return (0);
	}
	w = 0;
	str = 0;
	for (i = 1; i < ac; i++) {
		if (av[i][0] == '-') {
			x = 0;
			for (j = 1; av[i][j] != 0; j++) {
				if (av[i][j] == 's') {
					i++;
					if (i >= ac) {
						printf ("bad arg count\n");
						return (-1);
					}
					str = av[i];
					break;
				}
#ifdef R4000
		else if (av[i][j] == 'd')
		    w |= WATCH_R | WATCH_W;
		else if (av[i][j] == 'r')
		    w |= WATCH_R;
		else if (av[i][j] == 'w')
		    w |= WATCH_W;
#endif
				else {
					printf ("%c: unrecognized option\n", av[i][j]);
					return (-1);
				}
			}
		}
		else {
			flag = 1;
			if (!get_rsa (&adr, av[i])) {
				return (-1);
			}
		}
	}


	/*
	 *  Find a free breakpoint but reuse the same slot
	 *  if a break gets parameters changed.
	 */
	for (j = 0, i = MAX_BPT; j < MAX_BPT; j++) {
		if (Bpt[j].addr == adr) {
			Bpt[j].addr = NO_BPT;
			if (Bpt[j].cmdstr) {
				free (Bpt[j].cmdstr);
			}
			i = j;
		}
		if(i == MAX_BPT && Bpt[j].addr == NO_BPT) {
			i = j;
		}
	}
	if (MAX_BPT <= i) {
		printf ("too many breakpoints\n");
		return (1);
	}

	Bpt[i].addr = adr;
	printf ("Bpt %2d = %08x", i, adr);
	if (adr & 3L) {
		printf (" -> ??");
	}
	if (str != 0) {
		Bpt[i].cmdstr = malloc (strlen (str) + 1);
		strcpy (Bpt[i].cmdstr, str);
		str = 0;
		printf (" \"%s\"", Bpt[i].cmdstr);
	}
	else {
		Bpt[i].cmdstr = 0;
	}

	putchar ('\n');

	if (!flag) {
		printf ("break address not specified\n");
	}
	return (0);
}

/*************************************************************
 *  dspbpts() display all breakpoints
 */
void
dspbpts ()
{
	int	i, ln, siz;
	char	tmp[64], buf[100];

	siz = moresz;
	ioctl (STDIN, CBREAK, NULL);
	ln = siz;
	for (i = 0; i < MAX_BPT; i++)
		if (Bpt[i].addr != NO_BPT) {
			sprintf (buf, "Bpt %2d = %08x ", i, Bpt[i].addr);
			if (adr2symoff (tmp, Bpt[i].addr, 0)) {
				strcat (buf, tmp);
			}
			if (Bpt[i].addr & 3L) {
				strcat (buf, " -> ??");
			}
			if (Bpt[i].cmdstr) {
				sprintf (tmp, " \"%s\"", Bpt[i].cmdstr);
				strcat (buf, tmp);
			}
			if (more (buf, &ln, siz)) {
				break;
			}
		}
#ifdef R4000
	if (WatchLo & (WATCH_R | WATCH_W)) {
		register_t pa = WatchLo & WATCH_PA;
		printf ("Bpt %2d = %08x", MAX_BPT, pa);
		if (adr2symoff (tmp, pa, 0)) {
			printf (" %s", tmp);
		}
		printf (" [");
		if (WatchLo & WATCH_R) {
			printf (" read");
		}
		if (WatchLo & WATCH_W) {
			printf (" write");
		}
		printf (" ]\n");
	}
#endif
}

/*************************************************************
 *  clrbp(ac,av)
 *      The 'db' command
 */
int
clrbp (ac, av)
	int	ac;
	char	*av[];
{
	int32_t	i, j;

	if (ac > 1) {
		for (i = j = 0; j < ac - 1; j++) {
			if (strequ (av[1 + j], "*")) {
				clrbpts ();
				continue;
			}
			if (!atob (&i, av[1 + j], 10)) {
				printf ("%s: decimal number expected\n", av[1 + j]);
				return (-1);
			}
			if (i < MAX_BPT) {
				if (Bpt[i].addr == NO_BPT) {
					printf ("Bpt %2d not set\n", i);
				}
				else {
					Bpt[i].addr = NO_BPT;
					if (Bpt[i].cmdstr) {
						free (Bpt[i].cmdstr);
					}
				}
			}
#ifdef R4000