void op_enc_sys_input(op_enc_t* enc, s8 v) {
/* print_dbg("\r\n enc sys input, address: 0x"); */
/* print_dbg_hex((u32)enc); */
/* print_dbg(" , input value: 0x"); */
/* print_dbg_hex((u32)v); */
enc->val = op_add(enc->val, op_mul(enc->step, op_from_int(v)));
op_enc_perform(enc);
}
int executeInstruction(struct Instruction *instr, struct FunctionContext *func, struct RuntimeContext *ctx) {
switch (instr->opcode) {
case PUSH:
op_push(instr, func);
break;
case ADD:
op_add(instr, func);
break;
case SUB:
op_sub(instr, func);
break;
case MUL:
op_mul(instr, func);
break;
case DIV:
op_div(instr, func);
break;
case LCALL:
op_lcall(instr, func, ctx);
break;
case IJMP:
op_ijmp(instr, func);
break;
case RARG:
op_rarg(instr, func);
break;
case MKARR:
op_mkarr(instr, func, ctx);
break;
case SETELEM:
op_setelem(instr, func, ctx);
break;
case GETELEM:
op_getelem(instr, func, ctx);
break;
case SETVAR:
op_setvar(instr, func);
break;
case GETVAR:
op_getvar(instr, func);
break;
case JLE:
op_jle(instr, func);
break;
case RET:
op_ret(instr, func);
return 0;
}
if (instr->opcode != IJMP) {
if (func->next +1 <= func->opCount)
func->next++;
}
return 1;
}
void op_enc_sys_input(op_enc_t* enc, s8 v) {
/* print_dbg("\r\n enc sys input, address: 0x"); */
/* print_dbg_hex((u32)enc); */
/* print_dbg(" , input value: 0x"); */
/* print_dbg_hex((u32)v); */
// use saturating add. have to explicitly check for "would-be overflow" in wrap mode with max val.
// enc->val = op_sadd(enc->val, op_mul(enc->step, op_from_int(v)));
/// HACK: assuming the io_t is small enough t
/// that we can void overflow by casting to 4 bytes.
enc->val32 = (s32)(enc->val) + (s32)(op_mul(enc->step, op_from_int(v)));
op_enc_perform(enc);
}
void flt_mod (mval *u, mval *v, mval *q)
{
int exp;
int4 z, x;
mval w; /* temporary mval for division result */
mval y; /* temporary mval for extended precision promotion
to prevent modifying caller's data */
mval *u_orig; /* original (caller's) value of u */
error_def(ERR_DIVZERO);
u_orig = u;
MV_FORCE_NUM(u);
MV_FORCE_NUM(v);
if ((v->mvtype & MV_INT) != 0 && v->m[1] == 0)
rts_error(VARLSTCNT(1) ERR_DIVZERO);
if ((u->mvtype & MV_INT & v->mvtype) != 0)
{
/* Both are INT's; use shortcut. */
q->mvtype = MV_NM | MV_INT;
eb_int_mod(u->m[1], v->m[1], q->m);
return;
}
else if ((u->mvtype & MV_INT) != 0)
{
/* u is INT; promote to extended precision for compatibility with v. */
y = *u;
promote(&y); /* y will be normalized, but not in canonical form */
u = &y; /* this is why we need u_orig */
}
else if ((v->mvtype & MV_INT) != 0)
{
/* v is INT; promote to extended precision for compatibility with u. */
y = *v;
promote(&y);
v = &y;
}
/* At this point, both u and v are in extended precision format. */
/* Set w = floor(u/v). */
op_div (u, v, &w);
if ((w.mvtype & MV_INT) != 0)
promote(&w);
exp = w.e;
if (exp <= MV_XBIAS)
{
/* Magnitude of w, floor(u/v), is < 1. */
if (u->sgn != v->sgn && w.m[1] != 0 && exp >= EXPLO)
{
/* Signs differ (=> floor(u/v) < 0) and (w != 0) and (no underflow) => floor(u/v) == -1 */
w.sgn = 1;
w.e = MV_XBIAS + 1;
w.m[1] = MANT_LO;
w.m[0] = 0;
}
else
{
/* Signs same (=> floor(u/v) >= 0) or (w == 0) or (underflow) => floor(u/v) == 0 */
*q = *u_orig; /* u - floor(u/v)*v == u - 0*v == u */
return;
}
}
else if (exp < EXP_IDX_BIAL)
{
z = ten_pwr[EXP_IDX_BIAL - exp];
x = (w.m[1]/z)*z;
if (u->sgn != v->sgn && (w.m[1] != x || w.m[0] != 0))
{
w.m[0] = 0;
w.m[1] = x + z;
if (w.m[1] >= MANT_HI)
{
w.m[0] = w.m[0]/10 + (w.m[1]%10)*MANT_LO;
w.m[1] /= 10;
w.e++;
}
}
else
{
w.m[0] = 0;
w.m[1] = x;
}
}
else if (exp < EXP_IDX_BIAQ)
{
z = ten_pwr[EXP_IDX_BIAQ - exp];
x = (w.m[0]/z)*z;
if (u->sgn != v->sgn && w.m[0] != x)
{
w.m[0] = x + z;
if (w.m[0] >= MANT_HI)
{
w.m[0] -= MANT_HI;
w.m[1]++;
}
}
else
{
w.m[0] = x;
}
}
op_mul (&w, v, &w); /* w = w*v = floor(u/v)*v */
op_sub (u_orig, &w, q); /* q = u - w = u - floor(u/v)*v */
}
void Step()
{
Opcodes OP = (Opcodes)Fetch8();
//printf("%08X:%08X\n", Registers[sp], Registers[pc]);
switch (OP)
{
case O_NOP:
op_nop();
break;
case O_MOV:
op_mov();
break;
case O_ADD:
op_add();
break;
case O_SUB:
op_sub();
break;
case O_MUL:
op_mul();
break;
case O_DIV:
op_div();
break;
case O_LI:
op_li();
break;
case O_MOVF:
op_movf();
break;
case O_ADDF:
op_addf();
break;
case O_SUBF:
op_subf();
break;
case O_MULF:
op_mulf();
break;
case O_DIVF:
op_divf();
break;
case O_LIF:
op_lif();
break;
case O_XOR:
op_xor();
break;
case O_AND:
op_and();
break;
case O_MOD:
op_mod();
break;
case O_OR:
op_or();
break;
case O_NOT:
op_not();
break;
case O_SHR:
op_shr();
break;
case O_SHL:
op_shl();
break;
case O_PUSH:
op_push();
break;
case O_POP:
op_pop();
break;
case O_STB:
op_stb();
break;
case O_LDB:
op_ldb();
break;
case O_STH:
op_sth();
break;
case O_LDH:
op_ldh();
break;
case O_STW:
op_stw();
break;
case O_LDW:
op_ldw();
break;
case O_LDF:
op_ldf();
break;
case O_STF:
op_stf();
break;
case O_CMP:
op_cmp();
break;
case O_B:
op_b(0);
break;
case O_BC:
op_b(1);
break;
case O_BEQ:
op_bcond(ctr0_eq);
break;
case O_BNE:
op_bcond(ctr0_ne);
break;
case O_BGT:
op_bcond(ctr0_gt);
break;
case O_BLT:
op_bcond(ctr0_lt);
break;
case O_BTC:
op_btc();
break;
case O_INC:
op_inc();
break;
case O_DEC:
op_dec();
break;
default:
Error("Error: Unknown Opcode PC = %d OP = %08X\n", Registers[pc], OP);
}
Ticks++;
}
void doop(Mips * emu, uint32_t op) {
switch(op & 0xfc000000) {
case 0x8000000:
op_j(emu,op);
return;
case 0xc000000:
op_jal(emu,op);
return;
case 0x10000000:
op_beq(emu,op);
return;
case 0x14000000:
op_bne(emu,op);
return;
case 0x18000000:
op_blez(emu,op);
return;
case 0x1c000000:
op_bgtz(emu,op);
return;
case 0x20000000:
op_addi(emu,op);
return;
case 0x24000000:
op_addiu(emu,op);
return;
case 0x28000000:
op_slti(emu,op);
return;
case 0x2c000000:
op_sltiu(emu,op);
return;
case 0x30000000:
op_andi(emu,op);
return;
case 0x34000000:
op_ori(emu,op);
return;
case 0x38000000:
op_xori(emu,op);
return;
case 0x3c000000:
op_lui(emu,op);
return;
case 0x50000000:
op_beql(emu,op);
return;
case 0x54000000:
op_bnel(emu,op);
return;
case 0x58000000:
op_blezl(emu,op);
return;
case 0x80000000:
op_lb(emu,op);
return;
case 0x84000000:
op_lh(emu,op);
return;
case 0x88000000:
op_lwl(emu,op);
return;
case 0x8c000000:
op_lw(emu,op);
return;
case 0x90000000:
op_lbu(emu,op);
return;
case 0x94000000:
op_lhu(emu,op);
return;
case 0x98000000:
op_lwr(emu,op);
return;
case 0xa0000000:
op_sb(emu,op);
return;
case 0xa4000000:
op_sh(emu,op);
return;
case 0xa8000000:
op_swl(emu,op);
return;
case 0xac000000:
op_sw(emu,op);
return;
case 0xb8000000:
op_swr(emu,op);
return;
case 0xbc000000:
op_cache(emu,op);
return;
case 0xc0000000:
op_ll(emu,op);
return;
case 0xcc000000:
op_pref(emu,op);
return;
case 0xe0000000:
op_sc(emu,op);
return;
}
switch(op & 0xfc00003f) {
case 0x0:
op_sll(emu,op);
return;
case 0x2:
op_srl(emu,op);
return;
case 0x3:
op_sra(emu,op);
return;
case 0x4:
op_sllv(emu,op);
return;
case 0x6:
op_srlv(emu,op);
return;
case 0x7:
op_srav(emu,op);
return;
case 0x8:
op_jr(emu,op);
return;
case 0x9:
op_jalr(emu,op);
return;
case 0xc:
op_syscall(emu,op);
return;
case 0xf:
op_sync(emu,op);
return;
case 0x10:
op_mfhi(emu,op);
return;
case 0x11:
op_mthi(emu,op);
return;
case 0x12:
op_mflo(emu,op);
return;
case 0x13:
op_mtlo(emu,op);
return;
case 0x18:
op_mult(emu,op);
return;
case 0x19:
op_multu(emu,op);
return;
case 0x1a:
op_div(emu,op);
return;
case 0x1b:
op_divu(emu,op);
return;
case 0x20:
op_add(emu,op);
return;
case 0x21:
op_addu(emu,op);
return;
case 0x22:
op_sub(emu,op);
return;
case 0x23:
op_subu(emu,op);
return;
case 0x24:
op_and(emu,op);
return;
case 0x25:
op_or(emu,op);
return;
case 0x26:
op_xor(emu,op);
return;
case 0x27:
op_nor(emu,op);
return;
case 0x2a:
op_slt(emu,op);
return;
case 0x2b:
op_sltu(emu,op);
return;
case 0x2d:
op_addu(emu,op); //daddu
return;
case 0x36:
op_tne(emu,op);
return;
}
switch(op & 0xfc1f0000) {
case 0x4000000:
op_bltz(emu,op);
return;
case 0x4010000:
op_bgez(emu,op);
return;
case 0x4020000:
op_bltzl(emu,op);
return;
case 0x4030000:
op_bgezl(emu,op);
return;
case 0x4100000:
op_bltzal(emu,op);
return;
case 0x4110000:
op_bgezal(emu,op);
return;
case 0x5c000000:
op_bgtzl(emu,op);
return;
}
switch(op & 0xffffffff) {
case 0x42000002:
op_tlbwi(emu,op);
return;
case 0x42000006:
op_tlbwr(emu,op);
return;
case 0x42000008:
op_tlbp(emu,op);
return;
case 0x42000018:
op_eret(emu,op);
return;
}
switch(op & 0xfc0007ff) {
case 0xa:
op_movz(emu,op);
return;
case 0xb:
op_movn(emu,op);
return;
case 0x70000002:
op_mul(emu,op);
return;
}
switch(op & 0xffe00000) {
case 0x40000000:
op_mfc0(emu,op);
return;
case 0x40800000:
op_mtc0(emu,op);
return;
}
switch(op & 0xfe00003f) {
case 0x42000020:
op_wait(emu,op);
return;
}
// printf("unhandled opcode at %x -> %x\n",emu->pc,op);
setExceptionCode(emu,EXC_RI);
emu->exceptionOccured = 1;
return;
}
