regs.c

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

	col = lmargin+2;
	for (i=posn;p[i].size != 0;i++) {
		if (p[i].name == 0) continue;
		width = fieldsz(&p[i]);
		if (col+width+1 > 76) break;
		sprintf(buf,"%~*s ",width,p[i].name);
		strcat(pb,buf);
		col += width+1;
		}
	}
else { /* print field values */
	for (n=lmargin+2;n>0;n--) strcat(pb," "); /* +2 for ": " */
	col = lmargin+2;
	for (i=posn;p[i].size != 0;i++) {
		if (p[i].name) len = strlen(p[i].name);
		else len = 0;
		width = fieldsz(&p[i]);
		if (col+width+1 > 76) break;
		val = getfield(value,p[i].size,p[i].lsb);
		if (p[i].base == 0) strcpy(buf,p[i].values[val]);
		else {
			btoa(buf,val,p[i].base);
			if (p[i].base != 10) str_fmt(buf,p[i].size,FMT_RJUST0);
			}
		sprintf(tmp,"%~*s ",width,buf);
		strcat(pb,tmp);
		col += width+1;
		}
	posn = i;
	}
return(1);
}

/*************************************************************
*  fieldsz(p)
*/
fieldsz(p)
RegSpec *p;
{
int width,nmsz,valsz,len;
char **q;

nmsz = strlen(p->name);
switch (p->base) {
	case 0 :
		valsz = 0;
		for (q=p->values;*q;q++) {
			len = strlen(*q);
			if (len > valsz) valsz = len;
			}
		break;
	case 2 :
		valsz = p->size;
		break;
	case 10 :
		if (p->size > 3) valsz = 2;
		else valsz = 1;
		break;
	case 16 :
		valsz = 1;
		break;
	}
if (nmsz > valsz) width = nmsz;
else width = valsz;
return(width);
}

/*************************************************************
*  setfield(dstp,size,lsb,value)
*/
setfield(dstp,size,lsb,value)
unsigned int *dstp;
int size,lsb,value;
{
unsigned int msk,v;

msk = ((1<<size)-1)<<lsb;
v = *dstp;
v &= ~msk;
v |= value<<lsb;
*dstp =v;
}

/*************************************************************
*  disp_Fprs(ac,av)
*/
disp_Fprs(ac,av)
int ac;
char *av[];
{
int i,v,temp[2];
#ifdef FLOATINGPT
double *dp;
float *sp;

#if 0
sp = (float *)&v;
dp = (double *)temp;
if (ac == 2) {
	if (av[1][1] == '*') {
		for (i=0;i<32;i+=2) {
			temp[MSHALF] = Fpr[i+1];
			temp[LSHALF] = Fpr[i];
			v = Fpr[i];
			printf("$f%-2d = %08x %08x sp=%e dp=%e\n",
				i,v,Fpr[i+1],*sp,*dp);
			}
		}
	else {
		if (atob(&i,&av[1][1],10)) {
			i &= ~1; /* clear LSB */
			temp[MSHALF] = Fpr[i+1];
			temp[LSHALF] = Fpr[i];
			v = Fpr[i];
			printf("$f%-2d = %08x %08x sp=%e dp=%e\n",
				i,v,Fpr[i+1],*sp,*dp);
			}
		else printf("bad register number\n");
		}
	}
else if (ac == 3) {
	get_rsa(&v,av[2]);
	if (atob(&i,&av[1][1],10)) Fpr[i] = v;
	else printf("bad register number\n");
	}
else printf("Bad arg count\n");
#endif
#endif
}

/*************************************************************
*  disp_as_reg(Ulong value, char *name)
* 	display "value" as reg "name"
*/
disp_as_reg(value,name)
Ulong value;
char *name;
{
int j,state;
RegRec *p;


prnbuf[0] = 0;
for (p=0;p=findRegRec("*",p);) {
	if (striequ(p->name,name) || striequ(p->aname,name)) {
		if (p->spec) {
			state = 0;
			while (disp_reg(prnbuf,p,0,value,state++)) 
				printf("%s\n",prnbuf);
			}
		else {
			if (p->flags&F_ANAME) 
				printf("$%s-%s-%08x\n",p->aname,
						p->name,value);
			else printf("%s: %08x\n",p->name,value);
			}
		return(1);
		}
	}
return(0);
}

/*************************************************************
*  getreg(vp,name)
*	get value from named register
*	return 0 if register not found.
*/
getreg(vp,name)
RegVal *vp;
char *name;
{
RegRec *p;

p = findRegRec(name,0);
if (!p) return(0);
*vp =  getRegVal(p);
return(1);
}


/*************************************************************
*  getRegVal(p)
*	get register value using a RegRec ptr
*/
RegVal getRegVal(p)
RegRec *p;
{
return (* p->func)(0,p->regnum,p->size);
}

/*************************************************************
*  putRegVal(p,v)
*	put register value using a RegRec ptr
*/
putRegVal(RegRec *p,RegVal v)
{
(* p->func)(1,p->regnum,p->size,v);
}

/*************************************************************
*  char *getexcname(n)
*/
char *getexcname(n)
int n;
{
return(excodes[n>>2]);
}

/*************************************************************
*  Ulong getPreg(int reg)
*	return the contents of a specified pseudo register
*/
getPreg(reg)
int reg;
{

if (!preg_valid[reg]) {
	preg_valid[reg] = 1;
	pregs[reg] = 0;
	}
return(pregs[reg]);
}

/*************************************************************
*  putPreg(int reg,Ulong v)
*	write to a specified pseudo register
*/
putPreg(reg,v)
int reg;
Ulong v;
{

preg_valid[reg] = 1;
pregs[reg] = v;
}


/*************************************************************
*  int nxtPreg(int reg)
*	get the number of the next valid pseudo register
*/
nxtPreg(reg)
int reg;
{

for (;reg < 26;reg++) {
	if (preg_valid[reg]) return(reg);
	}
return(-1);
}

/*************************************************************
*  int ispreg(char *name)
*	return 1 if name is a pseudo register
*/
ispreg(name)
char *name;
{

if (strlen(name) != 1) return(0);
if (name[0] >= 'a' && name[0] <= 'z') return(1);
return(0);
}

/*************************************************************
*  addRegRec(p)
*	add a RegRec to the regChain
*/
addRegRec(p)
RegRec *p;
{
RegRec *q;

p->next = 0;
if (!regChain) { /* empty */
	regChain = p;
	}
else {
	for (q=regChain;q->next;q=q->next) ; /* find end of chain */
	q->next = p;
	}
}

/*************************************************************
*  addFpRegs()
*/
addFpRegs()
{
int i;

for (i=0;fpreglist[i].func;i++) addRegRec(&fpreglist[i]);
}

/*************************************************************
*  addGpRegs()
*/
addGpRegs()
{
int i;

for (i=0;gpreglist[i].func;i++) addRegRec(&gpreglist[i]);
}

/*************************************************************
*  RegRec *findRegRec(char *name,RegRec *rec)
*	Searches the regChain and returns the address of the 
*	struct that describes the first register whose name matches.
*
*	name = ptr to the register name (may contain wildcards)
*	rec = ptr to last record matched. Or zero.
*	returns: ptr to RegRec matching, or zero if not found.
*
*	usage:
*	   p = findRegRec(name,0);
*	or:
*	   for (p=0;p=findRegRec(name,p);) {
*		printf("match %s\n",p->name);
*		}
*/
RegRec *findRegRec(name,rec)
char *name;
RegRec *rec;
{
int wild;
RegRec *p;
char tmp[40];

if (strchr(name,'*') || strchr(name,'?')) wild = 1;
else wild = 0;
strtoupper(name);

for (p=(rec)?rec->next:regChain;p;p=p->next) {
#if 0 /* I was having probs w 'p' getting trashed (it seems) */
	if (!p || ((Ulong)p) < 0x80000000 || ((Ulong)p)&3) {
		printf("findRegRec: p=%08x\n",p);
		break;
		}
#endif
	if (wild) {
		strcpy(tmp,p->name);
		strtoupper(tmp);
		if (strpat(tmp,name)) return(p);
		}
	else {
		if (striequ(name,p->name)) return(p);
		if (striequ(name,p->aname)) return(p);
		}
	}
return(0);
}