go.c

mips架构的bootloader,99左右的版本 但源代码现在没人更新了

	}
return(n);
}

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

if (!atob(&siz,getMonEnv("moresz"),10)) {
	printf("%s: bad moresz value\n",getMonEnv("moresz"));
	return(1);
	}

ioctl_cbreak(0L);
ln = siz;
for (i=0;i<MAX_BPT;i++) {
	if(!Bpt[i].cond) continue;
	sprintf(prnbuf,"Bpt %2d: when (%s) ",i,Bpt[i].cstr);
	if (Bpt[i].cmdstr) {
		sprintf(tmp," \"%s\"",Bpt[i].cmdstr);
		strcat(prnbuf,tmp);
		}
	if (more(prnbuf,&ln,siz)) break;
	}
}

/*************************************************************
*  clrbp(ac,av)
*	The 'db' command. Clear one or more selected breakpoint(s).
*	When invoked without args, this command displays a list
*	of all breakpoints currently set.
*/
clrbp(ac,av)
int ac;
char *av[];
{
Ulong adr;
int i,j,k;

if (!regChain) {
	printf("Target Description Driver not loaded\n");
	return(1);
	}

if(ac > 1){
	for(i = j = 0; j < ac - 1; j++){
		if (strequ(av[1+j],"*")) {
			clrbpt(-1);
			continue;
			}
		if (!atob(&i,av[1+j],10)) {
			printf("%s: decimal number expected\n",av[1+j]);
			continue;
			}
		clrbpt(i);
		}
	}
else dspbpts();
return(0);
}

/*************************************************************
*  void clrbpt(i)
*	Clear specified breakpoint. If i==-1 clear all bpts.
*/
void clrbpt(i)
int i;
{

if (i == -1) {
	for (i=0;i<MAX_BPT;i++) {
		if (Bpt[i].cond) {
			clrbp_target(i);
			free(Bpt[i].cond);
			Bpt[i].cond = 0;
			if (Bpt[i].cmdstr) free(Bpt[i].cmdstr);
			if (Bpt[i].cstr) free(Bpt[i].cstr);
			}
		}
	bptCount = 0;
	return;
	}

if (i < MAX_BPT) {
	if (Bpt[i].cond == 0) printf("Bpt %2d not set\n",i);
	else {
		clrbp_target(i);
		free(Bpt[i].cond);
		Bpt[i].cond = 0;
		if (Bpt[i].cmdstr) free(Bpt[i].cmdstr);
		if (Bpt[i].cstr) free(Bpt[i].cstr);
		}
	bptCount--;
	}
else printf("%d: breakpoint number too large\n",i);
}

/*************************************************************
*  is_validpc(adr)
*/
is_validpc(adr)
unsigned long adr;
{
int i,ac;
char *av[10],tmp[80];
unsigned long a1,a2;

strcpy(tmp,getMonEnv("validpc"));
ac = argvize(av,tmp);
if (ac%2 != 0) {
	printf("validpc variable must have even number of values\n");
	return(0);
	}
for (i=0;i<ac;i++) {
	if (!get_rsa(&a1,av[i])) return(0);
	i++;
	if (!get_rsa(&a2,av[i])) return(0);
	if (adr >= a1 && adr <= a2) return(1);
	}
return(0);
}

/*************************************************************
*  addpchist(adr)
*/
addpchist(adr)
unsigned long adr;
{
pchist_d[pchist_ip] = adr;
pchist_ip = incmod(pchist_ip,PCHISTSZ);
if (pchist_ip == pchist_op) pchist_op = incmod(pchist_op,PCHISTSZ);
}

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

/*************************************************************
*  unsigned long getpchist(n)
*/
unsigned long 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]);
}

char *strrpstr();

/*************************************************************
*  constReduc()
*	optimize by performing constant reduction. 
*	eg. change 80023450 00000018 + to 80023468
*	It would be better to integrate this with parseCond().
*/
constReduc()
{
WhenRec *p,*q;
int count;
Ulong v1,v2;

count = 0;
for (p=when_list;p<when_ptr;p++) {
	switch (p->tag) {
		case WHEN_CONST : count++; break;
		case WHEN_OPR : 
		if (count < 2) {
			count = 0; /* 980802 */
			break;
			}
		v1 = (p-2)->val;
		v2 = (p-1)->val;
		/* printf("opt: %08x %08x %s\n",v1,v2,oprs[p->val]); */
		switch (p->val) {
			case WHEN_OPR_LAND : /* logical AND */
				if (v1 && v2) (p-2)->val = ~0;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_LOR :
				if (v1 || v2) (p-2)->val = ~0;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_EQ :
				if (v1 == v2) (p-2)->val = ~0; 
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_NE :
				if (v1 != v2)  (p-2)->val = ~0;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_GE :
				if (v1 >= v2)  (p-2)->val = ~0;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_LE :
				if (v1 <= v2)  (p-2)->val = ~0;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_GT :
				if (v1 > v2)  (p-2)->val = ~0;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_LT :
				if (v1 < v2) (p-2)->val = 1;
				else (p-2)->val = 0;
				break;
			case WHEN_OPR_ADD :
				(p-2)->val = v1 + v2;
				break;
			case WHEN_OPR_SUB :
				(p-2)->val = v1 - v2;
				break;
			case WHEN_OPR_MUL :
				(p-2)->val = v1 * v2;
				break;
			case WHEN_OPR_DIV :
				(p-2)->val = v1 / v2;
				break;
			case WHEN_OPR_BAND :  /* Bitwise AND */
				(p-2)->val = (v1 & v2);
				break;
			case WHEN_OPR_BOR : 
				(p-2)->val = (v1 | v2);
				break;
			default : count = 0;
			}
			if (count==2) {
				for (q=p+1;q<when_ptr;q++) *(q-2) = *q;
				when_ptr -= 2;
				count = 1;
				p = p-3;
				}
		default : count = 0;
		}
	}
}

/*************************************************************
*  parseCond(p)
*	Parse condition. 
*	This function evaluates expressions on the command line
*	using recursive decent. It places the result in an RPN
*	stack for faster run-time evaluation. It understands expressions
*	containing any combination of register names, symbols,
*	constants, perens, the operators ~!|&+/-* && ||, and the relational
*	operators > >= < <= == !=. In addition	it also permits 
*	the '^' operator to dereference any address. 
*/
parseCond(p)
char *p;
{
int r,inbase,inalpha,i;
char *q,subexpr[LINESZ];
extern char *badhexsym;
Ulong val;

/* strip enclosing parens */
while (*p == '(' && strbalp(p) == p+strlen(p)-1) {
	strdchr(p);
	p[strlen(p)-1] = 0;
	}

for (i=0;oprs[i];i++) {
	if (q=strrpstr(p,oprs[i])) {
		strNcpy(subexpr,p,q-p);
		r = parseCond(subexpr);
		if (r == 0) return(r);
		r = parseCond(q+strlen(oprs[i]));
		if (r == 0) return(r);
		if (when_list) {
			when_ptr->tag = WHEN_OPR;
			when_ptr->val = i;
			}
		when_ptr++;
		return(1);
		}
	}

/* 
 * having taken care of all the usual stuff, we handle the unary
 * operators and special cases.
 */
if (*p == '^') {
	r = parseCond(p+1);
	if (r == 0) return(r);
	if (when_list) {
		when_ptr->tag = WHEN_MEM;
		when_ptr->val = 0;
		}
	when_ptr++;
	return(1);
	}

if (*p == '!') {
	r = parseCond(p+1);
	if (r == 0) return(r);
	if (when_list) {
		when_ptr->tag = WHEN_NOT;
		when_ptr->val = 0;
		}
	when_ptr++;
	return(1);
	}

if (*p == '~') {
	r = parseCond(p+1);
	if (r == 0) return(r);
	if (when_list) {
		when_ptr->tag = WHEN_INV;
		when_ptr->val = 0;
		}
	when_ptr++;
	return(1);
	}

if (*p == '@') {
#ifdef PREGS
	if (ispreg(&p[1])) {
		val = (Ulong)(p[1]-'a');
		if (when_list) {
			when_ptr->tag = WHEN_PREG;
			when_ptr->val = val;
			}
		when_ptr++;
		r = 1;
		}
	else {
		val = (Ulong)findRegRec(&p[1],0);
		if (val) {
			if (when_list) {
				when_ptr->tag = WHEN_REG;
				when_ptr->val = val;
				}
			when_ptr++;
			r = 1;
			}
		else printf("%s: reg not found\n",&p[1]);
		}
#else
	val = (Ulong)findRegRec(&p[1],0);
	if (val) {
		if (when_list) {
			when_ptr->tag = WHEN_REG;
			when_ptr->val = val;
			}
		when_ptr++;
		r = 1;
		}
	else printf("%s: reg not found\n",&p[1]);
#endif
	}
else if (strequ(p,".")) {
	if (when_list) {
		when_ptr->tag = WHEN_REG;
		when_ptr->val = (Ulong)findRegRec("pc",0);
		}
	when_ptr++;
	r = 1;
	}
else if (isdigit(*p)) {
	inbase = matchenv("inbase");
	if (inbase == IB_TEN) r = atob(&val,p,10);
	else if (inbase == IB_SIXTEEN) r = atob(&val,p,16);
	else if (inbase == IB_EIGHT) r = atob(&val,p,8);
	else if (inbase == IB_AUTO) r = atob(&val,p,0);
	else {
		printf("%s: bad inbase value\n",getMonEnv("inbase"));
		return(0);
		}
	if (r == 0) {
		r = atob(&val,p,0);
		if (r == 0) printf("%s: bad base %s value\n",
						p,getMonEnv("inbase"));
		}
	if (r) {
		if (when_list) {
			when_ptr->tag = WHEN_CONST;
			when_ptr->val = val;
			}
		when_ptr++;
		}
	}
else if (isxdigit(*p)) {
	r = sym2adr(&val,p);
	if (r == 0) {
		r = atob(&val,p,16);
		if (r == 0) printf(badhexsym,p);
		}
	if (r) {
		if (when_list) {
			when_ptr->tag = WHEN_CONST;
			when_ptr->val = val;
			}
		when_ptr++;
		}
	}
else {
	r = sym2adr(&val,p);
	if (r == 0) {
		if (*p == '(') printf("unbalanced parens\n");
		else printf("%s: bad symbol name\n",p);
		}
	if (r) {
		if (when_list) {
			when_ptr->tag = WHEN_CONST;
			when_ptr->val = val;
			}
		when_ptr++;
		}
	}
return(r);
}

Ulong when_evalstk[8];
Ulong *when_evalptr;

/*************************************************************
*  evalBpt(p,e)
*/
evalBpt(s,e)
WhenRec *s,*e;
{
WhenRec *p;
Ulong *t,v;

when_evalptr = when_evalstk;
for (p=s;p<e;p++) evalOp(p);
#if 0
for (t=when_evalstk;t<when_evalptr;t++) printf("%08x\n",*t);
#endif
v = *--when_evalptr;
if (when_evalptr != when_evalstk) printf("stack corruption\n");
return(v);
}

/*************************************************************
*  evalOp(p)
*/
evalOp(p)
WhenRec *p;
{
Ulong v1,v2;

switch (p->tag) {
	case WHEN_CONST : *when_evalptr++ = p->val; break;
	case WHEN_MEM : 
		v1 = *--when_evalptr;
		*when_evalptr++ = read_target32(v1); 
		break;
	case WHEN_REG : *when_evalptr++ = getRegVal32(p->val); break;
#ifdef PREGS
	case WHEN_PREG : *when_evalptr++ = getPreg(p->val); break;
#endif
	case WHEN_NOT : 
		v1 = *--when_evalptr; 
		if (v1) *when_evalptr++ = 0;
		else *when_evalptr = 1;
		break;
	case WHEN_INV : v1 = *--when_evalptr; *when_evalptr++ = ~v1; break;
	case WHEN_OPR :
		switch (p->val) {
			case WHEN_OPR_LAND :
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				if (v1 && v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_LOR :
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				if (v1 || v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_EQ :
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				if (v1 == v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_NE :
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				if (v1 != v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_GE :
				v2 = *--when_evalptr;
				v1 = *--when_evalptr;
				if (v1 >= v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_LE :
				v2 = *--when_evalptr;
				v1 = *--when_evalptr;
				if (v1 <= v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_GT :
				v2 = *--when_evalptr;
				v1 = *--when_evalptr;
				if (v1 > v2) *when_evalptr++ = ~0;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_LT :
				v2 = *--when_evalptr;
				v1 = *--when_evalptr;
				if (v1 < v2) *when_evalptr++ = 1;
				else *when_evalptr++ = 0;
				break;
			case WHEN_OPR_ADD :
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				*when_evalptr++ = v1 + v2;
				break;
			case WHEN_OPR_SUB :
				v2 = *--when_evalptr;
				v1 = *--when_evalptr;
				*when_evalptr++ = v1 - v2;
				break;
			case WHEN_OPR_MUL :
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				*when_evalptr++ = v1 * v2;
				break;
			case WHEN_OPR_DIV :
				v2 = *--when_evalptr;
				v1 = *--when_evalptr;
				*when_evalptr++ = v1 / v2;
				break;
			case WHEN_OPR_BAND : 
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				*when_evalptr++ = (v1 & v2);
				break;
			case WHEN_OPR_BOR : 
				v1 = *--when_evalptr;
				v2 = *--when_evalptr;
				*when_evalptr++ = (v1 | v2);
				break;
			default : printf("%d: bad opr\n",p->val);
		}
		break;
	default : printf("%d: bad tag\n",p->tag);
	}
}

/*************************************************************
*  printOps(cond,csz)
*/
printOps(cond,csz)
WhenRec *cond,*csz;
{
WhenRec *p;
for (p=cond;p<csz;p++) {
	switch (p->tag) {
		case WHEN_OPR : 
			printf("opr %s\n",oprs[p->val]); 
			break;
		case WHEN_CONST : 
			printf("const %08x\n",p->val);
			break;
		case WHEN_MEM :
			printf("memref\n");
			break;
#ifdef PREGS
		case WHEN_PREG :
			printf("preg %c\n",p->val+'a');
			break;
#endif
		case WHEN_REG :
			printf("reg %s\n",((RegRec *)p->val)->name);
			break;
		case WHEN_NOT :
			printf("NOT\n");
			break;
		case WHEN_INV :
			printf("INV\n");
			break;
		default : printf("bad tag: %08x %s\n",p->val,p->tag);
		}
	}
}