dis16.c

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

		mkcomment(prnbuf,"# 0x%08lx",vaddr+im);
		break;
	case RX_PC_I8:
		im = imm(instr,(!extended)?UIMM8:UIMM16,wd,2);
		sprintf(tmp,"%s,pc,%d",RX(instr),im);
		strcat(prnbuf,tmp); *tmp = 0;
		mkcomment(prnbuf,"# 0x%08lx",vaddr+im);
		break;
	/* im,im */
	case OFFSET8_ONLY: /* bteqz btnez */
		sz = instr_size(addr,instr);
		im = vaddr+sz+imm(instr,(!extended)?SIMM8:SIMM16S,wd,1);
		if (!adr2symoff(tmp,im+1,0)) sprintf(tmp,"%x",im);
		strcat(prnbuf,tmp); *tmp = 0;
		mkcomment(prnbuf,"# 0x%08lx",im);
		break;
	case OFFSET11_ONLY: /* b */
		sz = instr_size(addr,instr);
		im = vaddr+sz+imm(instr,(!extended)?SIMM11:SIMM16S,wd,1);
		if (!adr2symoff(tmp,im+1,0)) sprintf(tmp,"%x",im);
		strcat(prnbuf,tmp); *tmp = 0;
		mkcomment(prnbuf,"# 0x%08lx",im);
		break;
	case SP_I8:
		im = imm(instr,(!extended)?SIMM8:UIMM16,wd,3);
		sprintf(tmp,"sp,%d",im);
		strcat(prnbuf,tmp); *tmp = 0;
		mkcomment(prnbuf,"# 0x%08lx",im);
		break;
	case RA_O_SP:
		im = imm(instr,(!extended)?UIMM8:SIMM16,wd,2);
		sprintf(tmp,"ra,%d(sp)",im);
		break;
	/* rx,rx,ry */
	case RZ_RX_RY:
		sprintf(tmp,"%s,%s,%s",RZ(instr),RX(instr),RY(instr));
		break;
	/* r32b,rz */
	case R32B_RZ :
		sprintf(tmp,"%s,%s",R32B(instr),RZ(instr));
		break;
	/* ry,r32a */
	case RY_R32A :
		sprintf(tmp,"%s,%s",RY(instr),R32A(instr));
		break;
	case RY_RX:
		sprintf(tmp,"%s,%s",RY(instr),RX(instr));
		break;

	}

if (*tmp) strcat(prnbuf,tmp);
return(addr+2);
}

/*************************************************************
*/
static Ulong get16Gpr(int n)
{
return getGpr32(gp16regNum[n]);
}

/*************************************************************
*/
static Ulong imm(w,sz,wd,shamt)
Ulong w; /* inst */
int sz; /* size (format) */
Ulong wd; /* entire word, needed for extended */
int shamt; /* shift amount */
{
Ulong im;

switch (sz) {
	case SIMM4 : 
		im = (w&0xf)<<shamt; 
		im = sgnext(im,4+shamt);
		break;
	case SIMM5 : 
		im = (w&0x1f)<<shamt; 
		im = sgnext(im,5+shamt);
		break;
	case UIMM5 : 
		im = (w&0x1f)<<shamt; 
		break;
	case UIMM8 : 
		im = (w&0xff)<<shamt; 
		break;
	case SIMM8 : 
		im = (w&0xff)<<shamt; 
		im = sgnext(im,8+shamt);
		break;
	case SIMM11 : 
		im = (w&0x7ff)<<shamt; 
		im = sgnext(im,11+shamt);
		break;
	case SIMM15 : 
		im = ((wd>>5)&0x7800)|((wd>>16)&0x07f0)|(wd&0x0f); 
		im = sgnext(im,15);
		break;
	case UIMM16 : 
		im = ((wd>>5)&0xf800)|((wd>>16)&0x07e0)|(wd&0x1f); 
		break;
	case SIMM16 : 
		im = ((wd>>5)&0xf800)|((wd>>16)&0x07e0)|(wd&0x1f); 
		im = sgnext(im,16);
		break;
	case SIMM16S : 
		im = (((wd>>5)&0xf800)|((wd>>16)&0x07e0)|(wd&0x1f))<<shamt; 
		im = sgnext(im+(1<<shamt),16);
		break;
	}
return(im);
}

/*************************************************************
*/
static Ulong sgnext(w,n)
Ulong w;
int n;
{
long sw;

sw = w;
sw <<= 32-n;
sw >>= 32-n;
return((Ulong)sw);
}

/*************************************************************
*/
Ulong mips16_branch_target_address(adr,wd)
Ulong adr,wd;
{
Ulong	im,vaddr,inst;
int sz,extended;
Dis16Rec *t;

if (mips16_is_extended(wd)) extended = 1;
else extended = 0;

if ((t=getDis16Rec(wd))==0) return(0);
inst = getInst(wd);
sz = instr_size(adr,inst);
vaddr = adr & ~1;
switch(t->fmt) {
	case OFFSET11_ONLY: /* b */
		return adr+sz+imm(inst,(!extended)?SIMM11:SIMM16S,wd,1);
	case RX_OFFSET:  /* beqz bnez */
		return adr+sz+imm(inst,(!extended)?SIMM8:SIMM16S,wd,1);
	case OFFSET8_ONLY: /* btnez bteqz */
		return adr+sz+imm(inst,(!extended)?SIMM8:SIMM16S,wd,1);

	case JAL_TARG: 
		im = ((hw0(wd)&0x1f)<<21)| ((hw0(wd)&0x3e0)<<(16-5))|hw1(wd);
		return (vaddr&0xf0000000)|(im<<2)|1;
	case JALX_TARG: 
		im = ((hw0(wd)&0x1f)<<21)| ((hw0(wd)&0x3e0)<<(16-5))| hw1(wd);
		return (vaddr&0xf0000000)|(im<<2);
	case RA_RX: 
	case JR_RX:
		return get16Gpr(RXN(inst));
	case RA_ONLY:
		return getGpr32(31);
	default:
		return(0);
	}
}


/*************************************************************
*  Ulong mips16_actual_branch_target_address(adr,wd)
*	Called from machine.c
*	Problems here
*/
Ulong mips16_actual_branch_target_address(adr,wd)
Ulong adr,wd;
{
Ulong target,inst;
int sz;

target = mips16_branch_target_address(adr,wd);
if (!mips16_is_conditional_branch(adr,wd)) return(target);

if (mips16_is_extended(wd)) sz = 4;
else sz = 2;

inst = getInst(wd);
/* beqz bnez bteqz btnez */
if ((inst&0xf800)==0x2000) return (get16Gpr(RXN(inst)))?adr+sz:target;
else if ((inst&0xf800)==0x2800) return (get16Gpr(RXN(inst)))?target:adr+sz;
else if ((inst&0xff00)==0x6000) return (getGpr32(24))?adr+sz:target;
else if ((inst&0xff00)==0x6100) return (getGpr32(24))?target:adr+sz;

return(0);
}

/*************************************************************
*  int mips16_is_extended(wd)
*/
int mips16_is_extended(wd)
Ulong wd;
{
if ((hw0(wd)&0xf800)==0xf000) return(1);
return(0);
}

/*************************************************************
*  int mips16_is_jal(addr,wd)
*	Called from machine.c
*/
int mips16_is_jal(addr,wd)
Ulong addr, wd;
{
Dis16Rec *t;

if ((t=getDis16Rec(wd))==0) return(0);
switch(t->fmt) {
	case JAL_TARG: 
	case JALX_TARG: 
	case RA_RX: 
		return(1);
	default:
		return(0);
	}
}

/*************************************************************
*  int mips16_is_jr(addr,wd)
*	Called by machine.c
*/
int mips16_is_jr(addr,wd)
Ulong addr, wd;
{
Dis16Rec *t;

if ((t=getDis16Rec(wd))==0) return(0);
switch(t->fmt) {
	case RA_RX: 
	case JR_RX:
	case RA_ONLY:
		return(1);
	default:
		return(0);
	}
}

/*************************************************************
*  int mips16_is_branch(addr,wd)
*	Called by machine.c
*/
int mips16_is_branch(addr,wd)
Ulong addr,wd;
{
Dis16Rec *t;

if ((t=getDis16Rec(wd))==0) return(0);
switch(t->fmt) {
	case RX_OFFSET: 
	case OFFSET11_ONLY: 
	case OFFSET8_ONLY:
	case JAL_TARG: 
	case JALX_TARG: 
	case RA_RX: 
	case JR_RX:
	case RA_ONLY:
		return(1);
	default:
		return(0);
	}
}

/*************************************************************
*/
int mips16_is_conditional_branch(addr,wd)
Ulong addr, wd;
{
Dis16Rec *t;

if ((t=getDis16Rec(wd))==0) return(0);
switch(t->fmt) {
	case RX_OFFSET: 
	case OFFSET8_ONLY:
		return(1);
	default:
		return(0);
	}
}

/*************************************************************
*/
static Dis16Rec *getDis16Rec(Ulong wd)
{
int i;
Ulong inst;

inst = getInst(wd);
for (i=0;dis16tbl[i].name;i++) {
	if ((inst&dis16tbl[i].mask) == dis16tbl[i].val) return(&dis16tbl[i]);
	}
return(0);
}

/*************************************************************
*/
static int mips16_32bit_instr(Ulong wd)
{
if ((hw0(wd)&0xf800)==0x1800) return(1); /* jal or jalx */
if (mips16_is_extended(wd)) return(1);
return(0);
}

/*************************************************************
*/
static Ulong getInst(Ulong wd)
{
if (mips16_is_extended(wd)) return(hw1(wd));
else return(hw0(wd));
}