bfin-dis.c

skyeye 仿真软件

		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 0) {
		notethat ("dregs_hi = W [ pregs ++ pregs ]");
		addr = PREG (ptr);
		val = get_word (saved_state.memory, addr);
		STORE (DREG (reg), (DREG (reg) & 0xFFFF) | (val << 16));
		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else if (aop == 3 && W == 0) {
		notethat ("dregs = W [ pregs ++ pregs ] (Z)");
		addr = PREG (ptr);
		val = get_word (saved_state.memory, addr);
		STORE (DREG (reg), val);
		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else if (aop == 3 && W == 1) {
		notethat ("dregs = W [ pregs ++ pregs ] (X)");
		addr = PREG (ptr);
		val = get_word (saved_state.memory, addr);
		STORE (DREG (reg), (bs32) (bs16) val);
		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else if (aop == 0 && W == 1) {
		notethat ("[ pregs ++ pregs ] = dregs");
		addr = PREG (ptr);
		put_long (saved_state.memory, addr, DREG (reg));
		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 1) {
		notethat (" W [ pregs ++ pregs ] = dregs_lo");
		addr = PREG (ptr);
		put_word (saved_state.memory, addr, DREG (reg));
		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 1) {
		notethat (" W[ pregs ++ pregs ] = dregs_hi");
		addr = PREG (ptr);
		put_word (saved_state.memory, addr, DREG (reg) >> 16);
		STORE (PREG (ptr), addr + PREG (idx));
		PCREG += 2;
		return;
	}
	else
		unhandled_instruction ();
}

static void
decode_dagMODim_0 (bu16 iw0)
{
/* dagMODim
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
| 1 | 0 | 0 | 1 | 1 | 1 | 1 | 0 |.br| 1 | 1 |.op|.m.....|.i.....|
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
*/
	int i = ((iw0 >> 0) & 0x3);
	int br = ((iw0 >> 7) & 0x1);
	int m = ((iw0 >> 2) & 0x3);
	int op = ((iw0 >> 4) & 0x1);



	if (op == 0 && br == 1) {
		notethat ("iregs += mregs ( BREV )");
		OUTS (outf, iregs (i));
		OUTS (outf, "+=");
		OUTS (outf, mregs (m));
		OUTS (outf, "(");
		OUTS (outf, "BREV");
		OUTS (outf, ")");
		unhandled_instruction ();
		PCREG += 2;
		return;
	}
	else if (op == 0) {
		notethat ("iregs += mregs");
		OUTS (outf, iregs (i));
		OUTS (outf, "+=");
		OUTS (outf, mregs (m));
		unhandled_instruction ();
		PCREG += 2;
		return;
	}
	else if (op == 1) {
		notethat ("iregs -= mregs");
		OUTS (outf, iregs (i));
		OUTS (outf, "-=");
		OUTS (outf, mregs (m));
		unhandled_instruction ();
		PCREG += 2;
		return;
	}
	else
		unhandled_instruction ();
}

static void
decode_dagMODik_0 (bu16 iw0)
{
/* dagMODik
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
| 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 0 | 1 | 1 | 0 |.op....|.i.....|
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
*/
	int i = ((iw0 >> 0) & 0x3);
	int op = ((iw0 >> 2) & 0x3);



	if (op == 0) {
		notethat ("iregs += 2");
		OUTS (outf, iregs (i));
		OUTS (outf, "+=");
		OUTS (outf, "2");
		unhandled_instruction ();
		PCREG += 2;
		return;
	}
	else if (op == 1) {
		notethat ("iregs -= 2");
		unhandled_instruction ();
		OUTS (outf, iregs (i));
		OUTS (outf, "-=");
		OUTS (outf, "2");
		PCREG += 2;
		return;
	}
	else if (op == 2) {
		notethat ("iregs += 4");
		unhandled_instruction ();
		OUTS (outf, iregs (i));
		OUTS (outf, "+=");
		OUTS (outf, "4");
		PCREG += 2;
		return;
	}
	else if (op == 3) {
		notethat ("iregs -= 4");
		unhandled_instruction ();
		OUTS (outf, iregs (i));
		OUTS (outf, "-=");
		OUTS (outf, "4");
		PCREG += 2;
		return;
	}
	else
		unhandled_instruction ();
}

static void
decode_dspLDST_0 (bu16 iw0)
{
/* dspLDST
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
| 1 | 0 | 0 | 1 | 1 | 1 |.W.|.aop...|.m.....|.i.....|.reg.......|
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
*/
	int aop = ((iw0 >> 7) & 0x3);
	int i = ((iw0 >> 3) & 0x3);
	int m = ((iw0 >> 5) & 0x3);
	int reg = ((iw0 >> 0) & 0x7);
	int W = ((iw0 >> 9) & 0x1);
	bu32 addr;

	if (aop == 0 && W == 0 && m == 0) {
		notethat ("dregs = [ iregs ++ ]");
		addr = IREG (i);
		STORE (IREG (i), addr + 4);
		STORE (DREG (reg), get_long (saved_state.memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 0 && W == 0 && m == 1) {
		notethat ("dregs_lo = W [ iregs ++ ]");
		addr = IREG (i);
		STORE (IREG (i), addr + 2);
		STORE (DREG (reg),
		       (DREG (reg) & 0xFFFF0000) | get_word (saved_state.
							     memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 0 && W == 0 && m == 2) {
		notethat ("dregs_hi = W [ iregs ++ ]");
		addr = IREG (i);
		STORE (IREG (i), addr + 2);
		STORE (DREG (reg),
		       (DREG (reg) & 0xFFFF) |
		       (get_word (saved_state.memory, addr) << 16));
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 0 && m == 0) {
		notethat ("dregs = [ iregs -- ]");
		addr = IREG (i);
		STORE (IREG (i), addr - 4);
		STORE (DREG (reg), get_long (saved_state.memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 0 && m == 1) {
		notethat ("dregs_lo = W [ iregs -- ]");
		addr = IREG (i);
		STORE (IREG (i), addr - 2);
		STORE (DREG (reg),
		       (DREG (reg) & 0xFFFF0000) | get_word (saved_state.
							     memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 0 && m == 2) {
		notethat ("dregs_hi = W [ iregs -- ]");
		addr = IREG (i);
		STORE (IREG (i), addr - 2);
		STORE (DREG (reg),
		       (DREG (reg) & 0xFFFF) |
		       (get_word (saved_state.memory, addr) << 16));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 0 && m == 0) {
		notethat ("dregs = [ iregs ]");
		addr = IREG (i);
		STORE (DREG (reg), get_long (saved_state.memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 0 && m == 1) {
		notethat ("dregs_lo = W [ iregs ]");
		addr = IREG (i);
		STORE (DREG (reg),
		       (DREG (reg) & 0xFFFF0000) | get_word (saved_state.
							     memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 0 && m == 2) {
		notethat ("dregs_hi = W [ iregs ]");
		addr = IREG (i);
		STORE (DREG (reg),
		       (DREG (reg) & 0xFFFF) |
		       (get_word (saved_state.memory, addr) << 16));
		PCREG += 2;
		return;
	}
	else if (aop == 0 && W == 1 && m == 0) {
		notethat ("[ iregs ++ ] = dregs");
		addr = IREG (i);
		STORE (IREG (i), addr + 4);
		put_long (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else if (aop == 0 && W == 1 && m == 1) {
		notethat ("W [ iregs ++ ] = dregs_lo");
		addr = IREG (i);
		STORE (IREG (i), addr + 2);
		put_word (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else if (aop == 0 && W == 1 && m == 2) {
		notethat ("W [ iregs ++ ] = dregs_hi");
		addr = IREG (i);
		STORE (IREG (i), addr + 2);
		put_word (saved_state.memory, addr, DREG (reg) >> 16);
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 1 && m == 0) {
		notethat ("[ iregs -- ] = dregs");
		addr = IREG (i);
		STORE (IREG (i), addr - 4);
		put_long (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 1 && m == 1) {
		notethat ("W [ iregs -- ] = dregs_lo");
		addr = IREG (i);
		STORE (IREG (i), addr - 2);
		put_word (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else if (aop == 1 && W == 1 && m == 2) {
		notethat ("W [ iregs -- ] = dregs_hi");
		addr = IREG (i);
		STORE (IREG (i), addr - 2);
		put_word (saved_state.memory, addr, DREG (reg) >> 16);
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 1 && m == 0) {
		notethat ("[ iregs ] = dregs");
		addr = IREG (i);
		put_long (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 1 && m == 1) {
		notethat (" W [ iregs ] = dregs_lo");
		addr = IREG (i);
		put_word (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else if (aop == 2 && W == 1 && m == 2) {
		notethat (" W [ iregs ] = dregs_hi");
		addr = IREG (i);
		put_word (saved_state.memory, addr, DREG (reg) >> 16);
		PCREG += 2;
		return;
	}
	else if (aop == 3 && W == 0) {
		notethat ("dregs = [ iregs ++ mregs ]");
		addr = IREG (i);
		STORE (IREG (i), addr + MREG (m));
		STORE (DREG (reg), get_long (saved_state.memory, addr));
		PCREG += 2;
		return;
	}
	else if (aop == 3 && W == 1) {
		notethat ("[ iregs ++ mregs ] = dregs");
		addr = IREG (i);
		STORE (IREG (i), addr + MREG (m));
		put_long (saved_state.memory, addr, DREG (reg));
		PCREG += 2;
		return;
	}
	else
		unhandled_instruction ();
}

static void
decode_LDST_0 (bu16 iw0)
{
	/* LDST
	   +---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
	   | 1 | 0 | 0 | 1 |.sz....|.W.|.aop...|.Z.|.ptr.......|.reg.......|
	   +---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
	 */
	int aop = ((iw0 >> 7) & 0x3);
	int Z = ((iw0 >> 6) & 0x1);
	int sz = ((iw0 >> 10) & 0x3);
	int reg = ((iw0 >> 0) & 0x7);
	int ptr = ((iw0 >> 3) & 0x7);
	int W = ((iw0 >> 9) & 0x1);
//      printf("\n\niw0=%x\n\n",iw0);
	if (aop == 3)
		unhandled_instruction ();

	if (W == 0) {
		if (aop != 2 && sz == 0 && Z == 1)
			if (ptr == reg)
				unhandled_instruction ();

		if (sz == 0 && Z == 0) {
			notethat ("dregs = [ pregs ]");
			DREG (reg) =
				get_long (saved_state.memory, PREG (ptr));
		}
		else if (sz == 0 && Z == 1) {
			notethat ("pregs = [ pregs ]");
			PREG (reg) =
				get_long (saved_state.memory, PREG (ptr));
		}
		else if (sz == 1 && Z == 0) {
			notethat ("dregs = W [ pregs ] (z)");
			DREG (reg) =
				get_word (saved_state.memory, PREG (ptr));
		}
		else if (sz == 1 && Z == 1) {
			notethat ("dregs = W [ pregs ] (X)");
			DREG (reg) =
				(bs32) (bs16) get_word (saved_state.memory,
							PREG (ptr));
		}
		else if (sz == 2 && Z == 0) {
			notethat ("dregs = B [ pregs ] (Z)");
			DREG (reg) =
				get_byte (saved_state.memory, PREG (ptr));
			
			//if(aop == 0)
			//	PREG(ptr) = PREG(ptr) + 1;
		}
		else if (sz == 2 && Z == 1) {
			notethat ("dregs = B [ pregs ] (X)");
			DREG (reg) =
				(bs32) (bs8) get_byte (saved_state.memory,
						       PREG (ptr));
			//if(aop == 0)
                          //      PREG(ptr) ++;

		}

		if (aop == 0)
			PREG (ptr) += sz == 0 ? 4 : sz == 1 ? 2 : 1;
		if (aop == 1)
			PREG (ptr) -= sz == 0 ? 4 : sz == 1 ? 2 : 1;
	}
	else {
		if (sz != 0 && Z == 1)
			unhandled_instruction ();

		if (sz == 0 && Z == 0) {
			notethat ("[ pregs ] = dregs");
			put_long (saved_state.memory, PREG (ptr), DREG (reg));
		}
		else if (sz == 0 && Z == 1) {
			notethat ("[ pregs ] = pregs");
			put_long (saved_state.memory, PREG (ptr), PREG (reg));
		}
		else if (sz == 1 && Z == 0) {
			notethat ("W [ pregs ] = dregs");
			put_word (saved_state.memory, PREG (ptr), DREG (reg));
		}
		else if (sz == 2 && Z == 0) {
			notethat ("B [ pregs ] = dregs");
			put_byte (saved_state.memory, PREG (ptr), DREG (reg));
		}

		if (aop == 0)
			PREG (ptr) += sz == 0 ? 4 : sz == 1 ? 2 : 1;
		if (aop == 1)
			PREG (ptr) -= sz == 0 ? 4 : sz == 1 ? 2 : 1;
	}

	PCREG += 2;
	return;
}

static void
decode_LDSTiiFP_0 (bu16 iw0)
{
/* LDSTiiFP
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
| 1 | 0 | 1 | 1 | 1 | 0 |.W.|.offset............|.reg...........|
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
*/
	int reg = ((iw0 >> 0) & 0xf);
	int offset = ((iw0 >> 4) & 0x1f);
	int W = ((iw0 >> 9) & 0x1);
	bu32 ea = PREG (7) + negimm5s4 (offset);

	if (W == 0)
		DPREG (reg) = get_long (saved_state.memory, ea);
	else
		put_long (saved_state.memory, ea, DPREG (reg));
	PCREG += 2;
	return;
}

static void
decode_LDSTii_0 (bu16 iw0)
{
	/* LDSTii
	   +---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
	   | 1 | 0 | 1 |.W.|.op....|.offset........|.ptr.......|.reg.......|
	   +---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
	 */
	int reg = ((iw0 >> 0) & 0x7);
	int ptr = ((iw0 >> 3) & 0x7);
	int offset = ((iw0 >> 6) & 0xf);
	int op = ((iw0 >> 10) & 0x3);
	int W = ((iw0 >> 12) & 0x1);
	bu32 ea = PREG (ptr) + (op == 0 || op == 3 ? uimm4s4 (offset)
				: uimm4s2 (offset));

	if (W == 1 && op == 2)
		unhandled_instruction ();

	if (W == 0) {
		if (op == 0) {
			notethat ("dregs = [ pregs + uimm4s4 ]");
			DREG (reg) = get_long (saved_state.memory, ea);
		}
		else if (op == 1) {
			notethat ("dregs = W [ pregs + uimm4s2 ] (Z)");
			DREG (reg) = get_word (saved_state.memory, ea);
		}
		else if (op == 2) {
			notethat ("dregs = W [ pregs + uimm4s2 ] (X)");
			DREG (reg) =
				(bs32) (bs16) get_word (saved_state.memory,
							ea);
		}
		else if (op == 3) {
			notethat ("pregs = [ pregs + uimm4s4 ]");
			PREG (reg) = get_long (saved_state.memory, ea);
		}
	}
	else {
		if (op == 0) {
			notethat ("[ pregs + uimm4s4 ] = dregs");
			put_long (saved_state.memory, ea, DREG (reg));
		}
		else if (op == 1) {
			notethat ("W [ pregs + uimm4s2 ] = dregs");
			put_word (saved_state.memory, ea, DREG (reg));
		}
		else if (op == 3) {
			notethat ("[ pregs + uimm4s4 ] = pregs");
			put_long (saved_state.memory, ea, PREG (reg));
		}
	}
	PCREG += 2;
}

static void
decode_LoopSetup_0 (bu16 iw0, bu16 iw1, bu32 pc)
{
/* LoopSetup
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
| 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |.rop...|.c.|.soffset.......|
|.reg...........| - | - |.eoffset...............................|
+---+---+---+---|---+---+---+---|---+---+---+---|---+---+---+---+
*/
	int rop = ((iw0 >> 5) & 0x3);
	int soffset = ((iw0 >> 0) & 0xf);
	int c = ((iw0 >> 4) & 0x1);
	int eoffset = ((iw1 >> 0) & 0x3ff);
	int reg = ((iw1 >> 12) & 0xf);

	if (rop == 0) {
		notethat ("LSETUP ( pcrel4 , lppcrel10 ) counters");
		saved_state.lt[c] = PCREG + pcrel4 (soffset);
		saved_state.lb[c] = PCREG + lppcrel10 (eoffset);
		PCREG += 4;
		return;
	}
	else if (rop == 1) {
		notethat ("LSETUP ( pcrel4 , lppcrel10 ) counters = pregs");
		saved_state.lt[c] = PCREG + pcrel4 (soffset);
		saved_s