machine.c

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

if (c3cRegNames==0) c3cRegNames = regs_hw;

if(!adr2symoff(dest,addr,12)) sprintf(dest,"%08lx",addr&~1);

if (addr&3) return dis16(dest,addr,bits);

sprintf(tmp," %08lx ",inst);
strcat(dest,tmp);

sz = 4;
if(inst == 0L){
	strcat(dest,"nop");
	return(addr + 4L);
	}

pt = get_distbl(inst);
i = strlen(pt->str);
strcat(dest,pt->str);
while(i++ < 8) strcat(dest," ");
switch(pt->type) {
	case FT_FS_FD:	fd(), comma(), fs(), comma(), ft();	break;
	case FS_FD:	fd(), comma(), fs();			break;
	case FT_FS:	fs(), comma(), ft();			break;
	case RT_RS_IMM:	rt(), comma(), rs(), comma(),imm(dest);	break;
	case RT_RS_SIMM:rt(), comma(), rs(),comma(),simm(dest);	break;
	case RS_SIMM:	rs(),comma(),simm(dest);		break;
	case RT_IMM:	rt(), comma(),imm(dest);		break;
	case RT_SIMM:	rt(), comma(), simm(dest);		break;
	case RT_RD:	rt(), comma();
	case RDX:	rd();					break;
	case RT_C0:	rt(),comma(),c0();			break;
	case RT_C1:	rt(),comma(),c1();			break;
#ifdef LR33000
	case RT_C2:	rt(),comma(),c2();			break;
	case RT_CC2:	rt(),comma(),cc2();			break;
#endif
	case RT_CN:	rt(),comma(),cn();			break;
	case RT_CC1:	rt(),comma(),cc1();			break;
	case RD_RT_RS:	rd(), comma(), rt(), comma();
	case JR: case RSX:
			rs();					break;
	case RD_RS:	rd(), comma(), rs(); 			break;
	case RS_CN:	rs(), comma(), cn(); 			break;
	case RD_RS_RT:	rd(), comma();
	case RS_RT:	rs(), comma(), rt();			break;
	case RD_RT_SFT:	rd(), comma(), rt(), comma();
			sprintf(tmp,"0x%x",SHAMT_(inst));
			strcat(dest,tmp);
			mkcomment(dest,"# %d",SHAMT_(inst));
			break;
	case RS_RT_OFF:
	case RS_OFF:
			rs(), comma();
			if(pt->type == RS_RT_OFF)
				rt(), comma();
	case OFFSET:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			v1 = addr + 4L + (v << 2);
			if (!adr2symoff(tmp,v1,0)) sprintf(tmp,"%x",v1);
			strcat(dest,tmp);
			mkcomment(dest,"# 0x%08lx",v1);
			break;
	case DBPCODE:	sprintf(tmp,"%d",(inst>>6)&0xfffff);
			strcat(dest,tmp);
			break;
	case BPCODE:	sprintf(tmp,"%d",(inst>>16)&0x3ff);
			strcat(dest,tmp);
			break;
	case COFUN:	sprintf(tmp,"0x%x",inst & 0x01ffffffL);
			strcat(dest,tmp);
			break;
	case NOOPR:						break;
	case JALX_TARG:
			v = (inst & 0x03ffffffL) << 2;
			v |= (addr & 0xf0000000L);
			if (!adr2symoff(tmp,v+1,0)) sprintf(tmp,"%x",v);
			strcat(dest,tmp);
			mkcomment(dest,"# 0x%08lx",v);
			break;
	case JAL_TARG:
	case TARGET:
			v = (inst & 0x03ffffffL) << 2;
			v |= (addr & 0xf0000000L);
			if (!adr2symoff(tmp,v,0)) sprintf(tmp,"%x",v);
			strcat(dest,tmp);
			mkcomment(dest,"# 0x%08lx",v);
			break;
	case JALR:
			if(RD_(inst) != 31L)
				rd(), comma();
			rs();
			break;
	case LDSTC0:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			c0ft(), comma();
			sprintf(tmp,"%d(",v);
			strcat(dest,tmp);
			rs();
			strcat(dest,")");
			mkcomment(dest,"# 0x%x",v);
			break;
	case LDSTC1:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			c1ft(), comma();
			sprintf(tmp,"%d(",v);
			strcat(dest,tmp);
			rs();
			strcat(dest,")");
			mkcomment(dest,"# 0x%x",v);
			break;
	case LDSTCN:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			cnft(), comma();
			sprintf(tmp,"%d(",v);
			strcat(dest,tmp);
			rs();
			strcat(dest,")");
			mkcomment(dest,"# 0x%x",v);
			break;
	case CACHE_OP:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			sprintf(tmp,"%d,%d(",RT_(inst),v);
			strcat(dest,tmp);
			rs();
			strcat(dest,")");
			mkcomment(dest,"# 0x%x",v);
			break;
	case OFF_BASE:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			sprintf(tmp,"%d(",v);
			strcat(dest,tmp);
			rs();
			strcat(dest,")");
			mkcomment(dest,"# 0x%x",v);
			break;
	case LOAD_STORE:
			v = IMM_(inst);
			if(v & (1L << 15)) v |= 0xffff0000L;
			rt(), comma();
			sprintf(tmp,"%d(",v);
			strcat(dest,tmp);
			rs();
			strcat(dest,")");
			mkcomment(dest,"# 0x%x",v);
			break;
	case WRD:
			sprintf(tmp,"%08lx",inst);
			strcat(dest,tmp);
			strcat(dest,"      # ");
			w = addr;
			for(i = 0; i < 4 ; i++){
				v = read_target8(w++);
				if (isprint(v)) strccat(dest,(char)v);
				else strccat(dest,'.');
				}
			break;
	}
return(addr + sz);
}

/*************************************************************
*  DISTBL *get_distbl(bits)
*/
DISTBL *get_distbl(bits)
long bits;
{
DISTBL *pt = distbl;

while((bits & pt->mask) != pt->code) ++pt;
return(pt);
}

/*************************************************************
*  int is_branch(addr,inst)
*/
int is_branch(addr,inst)
Ulong addr,inst;
{
DISTBL	*pt;

if (addr&1) return mips16_is_branch(addr,inst);

pt = get_distbl(inst);
switch(pt->type){
	case OFFSET: 
	case RS_RT_OFF: 
	case RS_OFF:
	case TARGET: 
	case JAL_TARG: 
	case JALX_TARG: 
	case JALR: 
	case JR:
		return(1);
	default:
		return(0);
	}
}

/*************************************************************
*  int is_branch_likely(inst)
*	returns true if instr at adr is a branch likely instr
*/
int is_branch_likely(inst)
Ulong inst;
{
DISTBL	*pt;
int len;

pt = get_distbl(inst);
if (pt->str[0] != 'b') return(0);
len = strlen(pt->str);
if (pt->str[len-1] == 'l' && pt->str[len-2] != 'a') return(1);
return(0);
}

/*************************************************************
*  int is_conditional_branch(addr,inst)
*/
int is_conditional_branch(addr,inst)
Ulong addr,inst;
{
DISTBL	*pt;

if (addr&1) return mips16_is_conditional_branch(addr,inst);

pt = get_distbl(inst);
switch(pt->type) {
	case OFFSET: /* branch on copN */
	case RS_RT_OFF: 
	case RS_OFF:
		return(1);
	default:
		return(0);
	}
}

/*************************************************************
*  is_jr(addr,inst)
*/
is_jr(addr,inst)
Ulong addr,inst;
{
DISTBL	*pt;

if (addr&1) return mips16_is_jr(addr,inst);

pt = get_distbl(inst);
if (pt->type == JR) return(1);
return(0);
}

/*************************************************************
*  is_jal(addr,inst)
*/
is_jal(addr,inst)
Ulong addr,inst;
{
DISTBL	*pt;

if (addr&1) return mips16_is_jal(addr,inst);

#if 0
op = getfield(inst,6,26);
if (op == 3) return(1);
if (op == 0 && getfield(inst,6,0) == 9) return(1);
return(0);
#else
pt = get_distbl(inst);
switch(pt->type) {
	case JALR:
	case JAL_TARG:
	case JALX_TARG:
		return(1);
	default:
		return(0);
	}
#endif
}

/*************************************************************
*  Ulong branch_target_address(adr,inst)
*/
Ulong branch_target_address(adr,inst)
Ulong adr;
Ulong inst;
{
DISTBL	*pt;
Ulong	val;

pt = get_distbl(inst);
switch(pt->type) {
	case OFFSET: 
	case RS_RT_OFF: 
	case RS_OFF:
		val = inst & 0xffff;
		if(val & 0x8000)
			val |= 0xffff0000;
		return(adr + 4 + (val << 2));
	case JAL_TARG:
	case TARGET:
		val = inst & 0x3ffffff;
		return(((adr + 4) & 0xf0000000) | (val << 2));
	case JALR: 
	case JR:
		val = RS_(inst); 
		return(getGpr(val));
	case JALX_TARG:
		val = (inst & 0x03ffffffL) << 2;
		val |= (adr & 0xf0000000L);
		return(val+1);
	default:
		return(0);
	}
}


/*************************************************************
*  static void simm(char *dest)
*	signed immediate value
*/
static void simm(dest)
char *dest;
{
char tmp[20];
long v;

v = IMM_(inst);
sprintf(tmp,"0x%x",v);
strcat(dest,tmp);
if (v >= 0 && v <= 9) return;
if(v & (1L << 15)) v |= 0xffff0000L;
mkcomment(dest,"# %d",v);
}

/*************************************************************
*  static void imm(char *dest)
*	unsigned immediate value
*/
static void imm(dest)
char *dest;
{
char tmp[20];
long v;

v = IMM_(inst);
sprintf(tmp,"0x%x",v);
strcat(dest,tmp);
if (v >= 0 && v <= 9) return;
mkcomment(dest,"# %d",v);
}

/*************************************************************
*  void mkcomment(char *p,char *fmt,Ulong v)
*	generate an appropriate comment
*/
void mkcomment(p,fmt,v)
char *p,*fmt;
Ulong v;
{
char tmp[20];
int n;

if (v >= 0 && v <= 9) return;
for (n=60-strlen(p);n>0;n--) strcat(p," ");
sprintf(tmp,fmt,v);
strcat(p,tmp);
}

static do_bltz(x) {return((x<0)?1:0);}
static do_bgez(x) {return((x>=0)?1:0);}
static do_beq(x,y) {return((x==y)?1:0);}
static do_bne(x,y) {return((x!=y)?1:0);}
static do_blez(x) {return((x<=0)?1:0);}
static do_bgtz(x) {return((x>0)?1:0);}

static Func *bcc_table[] = 
	{0,do_bltz,do_bgez,0,do_beq, do_bne, do_blez,do_bgtz};


/*************************************************************
*  Ulong actual_branch_target_address(adr,inst)
*/
Ulong actual_branch_target_address(adr,inst)
Ulong adr;
Ulong inst;
{
int s,t,v,target;
Func *func;

if (adr&1) return mips16_actual_branch_target_address(adr,inst);

target = branch_target_address(adr,inst);
if (!is_conditional_branch(adr,inst)) return(target);

if (getfield(inst,3,26) == 1 && getfield(inst,1,16) == 1) v = 2;
else v = getfield(inst,3,26);

func = bcc_table[v];
if (!func) return(adr+8); /* error condition - should never happen */

s = getfield(inst,5,21);
t = getfield(inst,5,16);
if ((*func)(read_target(XT_GPR,s,0),read_target(XT_GPR,t,0))) return(target);
else return(adr+8);
}

/*************************************************************
*/
int instr_size(adr,inst)
Ulong adr, inst;
{
if ((adr&1)==0) return(4);
if (mips16_is_extended(inst)) return(4);
return(2);
}