int g_xchg_dx_ax(void)
{
if (!lbl)
{
m--;
if (*m == 146) { DID(-1); }
m++;
}
GEN(146);
DID(1);
}
bool lookahead(FastVolume * in, std::vector<int> &res, int start, int dir, int amount, int cur_gen){
int cur = start;
for(int i = 0; i <= amount; i++){
cur += dir;
if(in->mask[cur] & TRU)return false;
if(in->mask[cur] & (ZRO | MASK)){//we are out; mark everything in between
for(int j = i; j > 0; j--){
cur -= dir;
if(!(BDR & in->mask[cur])){
if(GEN((in->mask[cur])) != 0) //check if the cell already had a generation
in->record_operation(cur, BDR | (GEN(in->mask[cur])));
else
in->record_operation(cur, BDR | cur_gen);
res.push_back(cur);
};
};
return true; // was able to jump
};
};
return false; //no luck; just propagate one step.
};
int g_pop_dx(void)
{
if (!lbl)
{
m--;
if (*m == 82) { DID(-1); }
if (*m == 80)
{
return g_mov_dx_ax() - 1;
}
if (*m == 83)
{
return g_mov_dx_bx() - 1;
}
if (*m == 81)
{
return g_mov_dx_cx() - 1;
}
m++;
}
GEN(90);
DID(1);
}
void primitive(void)
{
int ptr = 0;
if(tokeq("call"))
{
byte * b = m; int l; int c; int v; int a = 0; int i;
scan();
boolexpr();
if(tokeq("("))
{
scan();
a++;
boolexpr();
g_pop_ax();
g_pop_bx();
g_push_ax();
g_push_bx();
while (tokeq(","))
{
scan();
a++;
boolexpr();
g_pop_ax();
g_pop_bx();
g_push_ax();
g_push_bx();
}
if(tokeq(")"))
{
scan();
} else
{
error("Missing )");
}
}
g_pop_bx();
g_push_bp();
g_mov_ax_sp();
g_add_ax(a << 1);
g_mov_bp_ax();
g_call_bx();
g_pop_dx();
g_pop_bp();
for(i=0;i<a;i++)
{
g_pop_ax();
}
g_push_dx();
return;
}
if(tokeq("poll"))
{
scan();
if(tokeq("tty"))
{
scan();
g_mov_ah(11);
g_int(0x21);
g_xor_ah_ah();
g_push_ax();
return;
}
error("You can only poll the tty");
return;
}
if(tokeq("Ypush"))
{
scan();
if(tokeq("("))
{
scan();
boolexpr();
if(tokeq(")"))
{
g_xor_ax_ax();
g_push_ax();
scan();
return;
}
if(tokeq(","))
{
scan();
boolexpr();
if(tokeq(")"))
{
scan();
return;
}
}
}
error("Usage is Ypush(boolexpr[,boolexpr]) in function");
return;
}
if(tokeq("Ypop"))
{
scan();
if(tokeq("("))
{
scan();
if(tokeq(")"))
{
scan();
return;
}
}
error("Usage would be Ypop() in function");
return;
}
if(tokeq("eof"))
{
scan();
g_mov_bx(caddr(eofflag));
g_push_BX();
g_xor_ax_ax();
g_mov_BX_ax();
return;
}
if(tokeq("gpos"))
{
scan();
if(tokeq("("))
{
scan();
boolexpr();
if (tokeq(","))
{
scan();
boolexpr();
g_xor_cx_cx();
g_pop_dx();
g_mov_ax(0x4201);
g_pop_bx();
g_int(0x21);
g_push_ax();
if (tokeq(")"))
{
scan();
return;
}
}
}
error("Malformed way to use 'gpos'");
}
if(tokeq("sin"))
{
runtime_trig();
scan();
boolexpr();
g_pop_ax();
g_mov_bx(caddr(sin_routine));
g_call_bx();
g_push_cx();
return;
}
if(tokeq("cos"))
{
runtime_trig();
scan();
boolexpr();
g_pop_ax();
g_mov_bx(caddr(cos_routine));
g_call_bx();
g_push_cx();
return;
}
if(tokeq("abs"))
{
scan();
boolexpr();
g_pop_ax();
g_and_ax(0x7fff);
g_push_ax();
return;
}
if(tokeq("asc"))
{
scan();
boolexpr();
g_pop_ax();
g_and_ax(0x007f);
g_push_ax();
return;
}
if(tokeq("low"))
{
scan();
boolexpr();
g_pop_ax();
g_and_ax(0x00ff);
g_push_ax();
return;
}
if(tokeq("med"))
{
scan();
boolexpr();
g_pop_ax();
g_mov_cl(4);
g_shr_ax_cl();
g_and_ax(0x00ff);
g_push_ax();
return;
}
if(tokeq("fix"))
{
scan();
boolexpr();
g_pop_ax();
g_mov_ah_al();
g_xor_al_al();
g_push_ax();
return;
}
if(tokeq("int") || tokeq("hig"))
{
scan();
boolexpr();
g_pop_ax();
g_mov_al_ah();
g_xor_ah_ah();
g_push_ax();
return;
}
if(tokeq("fre"))
{
scan();
boolexpr();
g_pop_ax();
g_mov_ax_I(caddr(d)-2);
g_neg_ax();
g_push_ax();
return;
}
if(tokeq("rnd"))
{
symbol * q = NULL;
scan();
if(tokeq("("))
{
scan();
q = name(0);
if(tokeq(")"))
{
scan();
} else error("Missing )");
} else
{
error("Need identifier in rnd()");
}
g_pop_bx();
g_mov_ax_BX();
g_mov_dx(58653U);
g_imul_dx();
g_mov_dx(13849U);
g_add_ax_dx();
g_mov_BX_ax();
g_push_ax();
if (q != NULL && q->hook_addr != NULL)
{
g_mov_ax(caddr(q->hook_addr));
g_call_ax();
}
return;
}
if(tokeq("stu"))
{
scan();
boolexpr();
g_pop_ax();
g_mov_bx(caddr(sbuffer + 14));
g_label(); g_xor_dx_dx();
g_mov_cx(10);
g_idiv_cx();
g_add_dx('0');
g_mov_BX_dl();
g_dec_bx();
g_or_ax_ax();
g_jnz(-18);
g_inc_bx();
g_push_bx();
return;
}
if(tokeq("str"))
{
scan();
boolexpr();
g_pop_ax();
g_push_ax();
g_cmp_ax(0);
g_jg(+2);
g_neg_ax();
g_label(); g_mov_bx(caddr(sbuffer + 14));
g_label(); g_xor_dx_dx();
g_mov_cx(10);
g_idiv_cx();
g_add_dx('0');
g_mov_BX_dl();
g_dec_bx();
g_or_ax_ax();
g_jnz(-18);
g_pop_ax();
g_cmp_ax(0);
g_jge(+5);
g_mov_al('-');
g_mov_BX_al();
g_dec_bx();
g_label(); g_inc_bx();
g_push_bx();
return;
}
if(tokeq("sif"))
{
scan();
boolexpr();
g_pop_ax();
g_push_ax();
g_xor_ah_ah();
g_mov_dx(39);
g_imul_dx();
/* g_mov_al_ah();
g_mov_ah_dl(); */
g_mov_bx(caddr(sbuffer + 14));
g_mov_cx(10);
g_label(); g_xor_dx_dx();
g_idiv_cx();
g_add_dx('0');
g_mov_BX_dl();
g_dec_bx();
g_cmp_bx(caddr(sbuffer + 10));
g_jnz(-17);
g_mov_dx('.');
g_mov_BX_dl();
g_dec_bx();
g_pop_ax();
g_mov_al_ah();
g_xor_ah_ah();
g_label(); g_xor_dx_dx();
g_idiv_cx();
g_add_dx('0');
g_mov_BX_dl();
g_dec_bx();
g_or_ax_ax();
g_jnz(-15);
g_inc_bx();
g_push_bx();
return;
}
if(tokeq("nameof"))
{
char * q;
byte * b;
scan();
if(tokeq("("))
{
scan();
q = (token+1);
b = stalloc(strlen(q)+1);
name(0);
if(tokeq(")"))
{
scan();
strcpy((char *)b, q);
g_mov_ax(caddr(b));
g_push_ax();
} else error("Missing (");
} else error("Missing )");
return;
}
if(tokeq("^"))
{
scan(); ptr = 1;
}
if(tokeq("#"))
{
scan();
if (tokeq("("))
{
scan();
boolexpr();
if (tokeq(")"))
{
scan();
g_pop_ax();
g_shl_ax_1();
g_neg_ax();
g_xchg_si_ax();
g_mov_ax_BP_SI();
g_push_ax();
return;
}
error("Missing )");
return;
}
g_mov_ax_BP(-2 * member());
g_push_ax();
return;
}
if(sym_exists(token))
{
symbol * q = NULL;
q = name(0);
if (!ptr)
{
g_pop_bx();
g_push_BX();
if (tokeq("++"))
{
scan();
g_mov_ax_BX();
g_inc_ax();
g_mov_BX_ax();
if (q != NULL && q->hook_addr != NULL)
{
g_mov_ax(caddr(q->hook_addr));
g_call_ax();
}
}
if (tokeq("--"))
{
scan();
g_mov_ax_BX();
g_dec_ax();
g_mov_BX_ax();
if (q != NULL && q->hook_addr != NULL)
{
g_mov_ax(caddr(q->hook_addr));
g_call_ax();
}
}
}
return;
}
if (ptr)
{
error("Identifier should follow ^");
}
if(token[0] >= '0' && token[0] <= '9')
{
int v = atoi(token);
g_mov_ax(v);
g_push_ax();
scan();
if (tokeq("."))
{
scan();
while(strlen(token) < 4)
{
strcat(token, "0");
}
v = atoi(token) / 39;
scan();
if (v > 255) v = 255;
g_pop_ax();
g_mov_ah_al();
g_mov_al(v & 0xff);
g_push_ax();
}
return;
}
if(token[0] == '"')
{
char * q = (token+1);
byte * b = stalloc(strlen(q)+1);
strcpy((char *)b, q);
g_mov_ax(caddr(b));
g_push_ax();
scan();
while(token[0] == '"')
{
char * q = (token+1);
byte * b;
stretract();
b = stalloc(strlen(q)+1);
strcpy((char *)b, q);
scan();
}
return;
}
if(tokeq("{"))
{
byte * l; byte * q; int c=0; int v=0; int lc;
scan();
l = m;
g_label();
g_nop();
assignments();
if (tokeq("}"))
{
scan();
g_ret();
q = stalloc(m - l);
memcpy(q, l, m - l);
m = l;
g_mov_ax(caddr(q));
g_push_ax();
return;
}
error("Missing }");
return;
}
if(tokeq("INLINE"))
{
byte * l; byte * q; int c=0; int v=0; int lc;
scan();
if(tokeq("{")) scan();
l = m;
g_label();
g_nop();
while(tokne("}"))
{
GEN(atoi(token));
scan();
}
scan();
g_ret();
q = stalloc(m - l);
memcpy(q, l, m - l);
m = l;
g_mov_ax(caddr(q));
g_push_ax();
return;
}
if(tokeq("("))
{
scan();
boolexpr();
if (tokeq(")"))
{
scan();
return;
}
error("Missing )");
return;
}
if(tokeq("*"))
{
scan();
boolexpr();
g_mov_bx(260);
g_mov_ax_BX();
g_pop_dx();
g_push_ax();
g_add_ax_dx();
g_mov_BX_ax();
return;
}
error("Unrecognized primitive");
}
int g_mov_ah_al(void) { GEN(0x88); GEN(0xC4); DID(2); }
int g_mov_al_ah(void) { GEN(0x88); GEN(0xE0); DID(2); }
int g_add_al(sbyte s) { GEN(4); GEN(s); DID(2); }
int g_jg(sbyte d) { GEN(0x7F); GEN(d); DID(2); }
int g_shl_ax_1(void) { GEN(209); GEN(224); DID(2); }
int g_sub_BX_al(void) { GEN(0x28); GEN(7); DID(2); }
int g_add_BX_al(void) { GEN(0); GEN(7); DID(2); }
int g_sub_BX_ax(void) { GEN(0x29); GEN(7); DID(2); }
int g_add_BX_ax(void) { GEN(1); GEN(7); DID(2); }
int g_cmp_al_dl(void) { GEN(0x38); GEN(0xD0); DID(2); }
int g_cmp_dl(byte q) { GEN(0x80); GEN(0xFA); GEN(q); DID(3); }
int g_jge(sbyte d) { GEN(0x7D); GEN(d); DID(2); }
int g_jl(sbyte d) { GEN(0x7C); GEN(d); DID(2); }
int g_shr_ax_1(void) { GEN(209); GEN(232); DID(2); }
int g_add_bx_ax(void) { GEN(1); GEN(0xC3); DID(2); }
int g_shl_ax_cl(void) { GEN(211); GEN(224); DID(2); }
int g_jmp_bx(void) { GEN(0xff); GEN(0xe3); DID(2); }
int g_shr_ax_cl(void) { GEN(211); GEN(232); DID(2); }
int g_mov_ah_dl(void) { GEN(0x88); GEN(0xD4); DID(2); }
int g_cmp_ax(word i) { GEN(0x3D); GENW(i); g_label(); DID(3); }
int g_mov_dl_ah(void) { GEN(0x88); GEN(0xE2); DID(2); }
int g_cmp_bx(word i) { GEN(0x81); GEN(0xFB); GENW(i); g_label(); DID(4); }
/*
* Process a single instruction.
*
* Returns "false" if something goes fatally wrong.
*/
static bool processInstruction(VerifierData* vdata, u4 insnIdx,
BitVector* workBits)
{
const Method* meth = vdata->method;
const u2* insns = meth->insns + insnIdx;
DecodedInstruction decInsn;
dexDecodeInstruction(insns, &decInsn);
/*
* Add registers to the "GEN" or "KILL" sets. We want to do KILL
* before GEN to handle cases where the source and destination
* register is the same.
*/
switch (decInsn.opcode) {
case OP_NOP:
case OP_RETURN_VOID:
case OP_GOTO:
case OP_GOTO_16:
case OP_GOTO_32:
/* no registers are used */
break;
case OP_RETURN:
case OP_RETURN_OBJECT:
case OP_MONITOR_ENTER:
case OP_MONITOR_EXIT:
case OP_CHECK_CAST:
case OP_THROW:
case OP_PACKED_SWITCH:
case OP_SPARSE_SWITCH:
case OP_FILL_ARRAY_DATA:
case OP_IF_EQZ:
case OP_IF_NEZ:
case OP_IF_LTZ:
case OP_IF_GEZ:
case OP_IF_GTZ:
case OP_IF_LEZ:
case OP_SPUT:
case OP_SPUT_BOOLEAN:
case OP_SPUT_BYTE:
case OP_SPUT_CHAR:
case OP_SPUT_SHORT:
case OP_SPUT_OBJECT:
/* action <- vA */
GEN(workBits, decInsn.vA);
break;
case OP_RETURN_WIDE:
case OP_SPUT_WIDE:
/* action <- vA(wide) */
GENW(workBits, decInsn.vA);
break;
case OP_IF_EQ:
case OP_IF_NE:
case OP_IF_LT:
case OP_IF_GE:
case OP_IF_GT:
case OP_IF_LE:
case OP_IPUT:
case OP_IPUT_BOOLEAN:
case OP_IPUT_BYTE:
case OP_IPUT_CHAR:
case OP_IPUT_SHORT:
case OP_IPUT_OBJECT:
/* action <- vA, vB */
GEN(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
break;
case OP_IPUT_WIDE:
/* action <- vA(wide), vB */
GENW(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
break;
case OP_APUT:
case OP_APUT_BOOLEAN:
case OP_APUT_BYTE:
case OP_APUT_CHAR:
case OP_APUT_SHORT:
case OP_APUT_OBJECT:
/* action <- vA, vB, vC */
GEN(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
GEN(workBits, decInsn.vC);
break;
case OP_APUT_WIDE:
/* action <- vA(wide), vB, vC */
GENW(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
GEN(workBits, decInsn.vC);
break;
case OP_FILLED_NEW_ARRAY:
case OP_INVOKE_VIRTUAL:
case OP_INVOKE_SUPER:
case OP_INVOKE_DIRECT:
case OP_INVOKE_STATIC:
case OP_INVOKE_INTERFACE:
/* action <- vararg */
{
unsigned int idx;
for (idx = 0; idx < decInsn.vA; idx++) {
GEN(workBits, decInsn.arg[idx]);
}
}
break;
case OP_FILLED_NEW_ARRAY_RANGE:
case OP_INVOKE_VIRTUAL_RANGE:
case OP_INVOKE_SUPER_RANGE:
case OP_INVOKE_DIRECT_RANGE:
case OP_INVOKE_STATIC_RANGE:
case OP_INVOKE_INTERFACE_RANGE:
/* action <- vararg/range */
{
unsigned int idx;
for (idx = 0; idx < decInsn.vA; idx++) {
GEN(workBits, decInsn.vC + idx);
}
}
break;
case OP_MOVE_RESULT:
case OP_MOVE_RESULT_WIDE:
case OP_MOVE_RESULT_OBJECT:
case OP_MOVE_EXCEPTION:
case OP_CONST_4:
case OP_CONST_16:
case OP_CONST:
case OP_CONST_HIGH16:
case OP_CONST_STRING:
case OP_CONST_STRING_JUMBO:
case OP_CONST_CLASS:
case OP_NEW_INSTANCE:
case OP_SGET:
case OP_SGET_BOOLEAN:
case OP_SGET_BYTE:
case OP_SGET_CHAR:
case OP_SGET_SHORT:
case OP_SGET_OBJECT:
/* vA <- value */
KILL(workBits, decInsn.vA);
break;
case OP_CONST_WIDE_16:
case OP_CONST_WIDE_32:
case OP_CONST_WIDE:
case OP_CONST_WIDE_HIGH16:
case OP_SGET_WIDE:
/* vA(wide) <- value */
KILLW(workBits, decInsn.vA);
break;
case OP_MOVE:
case OP_MOVE_FROM16:
case OP_MOVE_16:
case OP_MOVE_OBJECT:
case OP_MOVE_OBJECT_FROM16:
case OP_MOVE_OBJECT_16:
case OP_INSTANCE_OF:
case OP_ARRAY_LENGTH:
case OP_NEW_ARRAY:
case OP_IGET:
case OP_IGET_BOOLEAN:
case OP_IGET_BYTE:
case OP_IGET_CHAR:
case OP_IGET_SHORT:
case OP_IGET_OBJECT:
case OP_NEG_INT:
case OP_NOT_INT:
case OP_NEG_FLOAT:
case OP_INT_TO_FLOAT:
case OP_FLOAT_TO_INT:
case OP_INT_TO_BYTE:
case OP_INT_TO_CHAR:
case OP_INT_TO_SHORT:
case OP_ADD_INT_LIT16:
case OP_RSUB_INT:
case OP_MUL_INT_LIT16:
case OP_DIV_INT_LIT16:
case OP_REM_INT_LIT16:
case OP_AND_INT_LIT16:
case OP_OR_INT_LIT16:
case OP_XOR_INT_LIT16:
case OP_ADD_INT_LIT8:
case OP_RSUB_INT_LIT8:
case OP_MUL_INT_LIT8:
case OP_DIV_INT_LIT8:
case OP_REM_INT_LIT8:
case OP_SHL_INT_LIT8:
case OP_SHR_INT_LIT8:
case OP_USHR_INT_LIT8:
case OP_AND_INT_LIT8:
case OP_OR_INT_LIT8:
case OP_XOR_INT_LIT8:
/* vA <- vB */
KILL(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
break;
case OP_IGET_WIDE:
case OP_INT_TO_LONG:
case OP_INT_TO_DOUBLE:
case OP_FLOAT_TO_LONG:
case OP_FLOAT_TO_DOUBLE:
/* vA(wide) <- vB */
KILLW(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
break;
case OP_LONG_TO_INT:
case OP_LONG_TO_FLOAT:
case OP_DOUBLE_TO_INT:
case OP_DOUBLE_TO_FLOAT:
/* vA <- vB(wide) */
KILL(workBits, decInsn.vA);
GENW(workBits, decInsn.vB);
break;
case OP_MOVE_WIDE:
case OP_MOVE_WIDE_FROM16:
case OP_MOVE_WIDE_16:
case OP_NEG_LONG:
case OP_NOT_LONG:
case OP_NEG_DOUBLE:
case OP_LONG_TO_DOUBLE:
case OP_DOUBLE_TO_LONG:
/* vA(wide) <- vB(wide) */
KILLW(workBits, decInsn.vA);
GENW(workBits, decInsn.vB);
break;
case OP_CMPL_FLOAT:
case OP_CMPG_FLOAT:
case OP_AGET:
case OP_AGET_BOOLEAN:
case OP_AGET_BYTE:
case OP_AGET_CHAR:
case OP_AGET_SHORT:
case OP_AGET_OBJECT:
case OP_ADD_INT:
case OP_SUB_INT:
case OP_MUL_INT:
case OP_REM_INT:
case OP_DIV_INT:
case OP_AND_INT:
case OP_OR_INT:
case OP_XOR_INT:
case OP_SHL_INT:
case OP_SHR_INT:
case OP_USHR_INT:
case OP_ADD_FLOAT:
case OP_SUB_FLOAT:
case OP_MUL_FLOAT:
case OP_DIV_FLOAT:
case OP_REM_FLOAT:
/* vA <- vB, vC */
KILL(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
GEN(workBits, decInsn.vC);
break;
case OP_AGET_WIDE:
/* vA(wide) <- vB, vC */
KILLW(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
GEN(workBits, decInsn.vC);
break;
case OP_CMPL_DOUBLE:
case OP_CMPG_DOUBLE:
case OP_CMP_LONG:
/* vA <- vB(wide), vC(wide) */
KILL(workBits, decInsn.vA);
GENW(workBits, decInsn.vB);
GENW(workBits, decInsn.vC);
break;
case OP_SHL_LONG:
case OP_SHR_LONG:
case OP_USHR_LONG:
/* vA(wide) <- vB(wide), vC */
KILLW(workBits, decInsn.vA);
GENW(workBits, decInsn.vB);
GEN(workBits, decInsn.vC);
break;
case OP_ADD_LONG:
case OP_SUB_LONG:
case OP_MUL_LONG:
case OP_DIV_LONG:
case OP_REM_LONG:
case OP_AND_LONG:
case OP_OR_LONG:
case OP_XOR_LONG:
case OP_ADD_DOUBLE:
case OP_SUB_DOUBLE:
case OP_MUL_DOUBLE:
case OP_DIV_DOUBLE:
case OP_REM_DOUBLE:
/* vA(wide) <- vB(wide), vC(wide) */
KILLW(workBits, decInsn.vA);
GENW(workBits, decInsn.vB);
GENW(workBits, decInsn.vC);
break;
case OP_ADD_INT_2ADDR:
case OP_SUB_INT_2ADDR:
case OP_MUL_INT_2ADDR:
case OP_REM_INT_2ADDR:
case OP_SHL_INT_2ADDR:
case OP_SHR_INT_2ADDR:
case OP_USHR_INT_2ADDR:
case OP_AND_INT_2ADDR:
case OP_OR_INT_2ADDR:
case OP_XOR_INT_2ADDR:
case OP_DIV_INT_2ADDR:
/* vA <- vA, vB */
/* KILL(workBits, decInsn.vA); */
GEN(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
break;
case OP_SHL_LONG_2ADDR:
case OP_SHR_LONG_2ADDR:
case OP_USHR_LONG_2ADDR:
/* vA(wide) <- vA(wide), vB */
/* KILLW(workBits, decInsn.vA); */
GENW(workBits, decInsn.vA);
GEN(workBits, decInsn.vB);
break;
case OP_ADD_LONG_2ADDR:
case OP_SUB_LONG_2ADDR:
case OP_MUL_LONG_2ADDR:
case OP_DIV_LONG_2ADDR:
case OP_REM_LONG_2ADDR:
case OP_AND_LONG_2ADDR:
case OP_OR_LONG_2ADDR:
case OP_XOR_LONG_2ADDR:
case OP_ADD_FLOAT_2ADDR:
case OP_SUB_FLOAT_2ADDR:
case OP_MUL_FLOAT_2ADDR:
case OP_DIV_FLOAT_2ADDR:
case OP_REM_FLOAT_2ADDR:
case OP_ADD_DOUBLE_2ADDR:
case OP_SUB_DOUBLE_2ADDR:
case OP_MUL_DOUBLE_2ADDR:
case OP_DIV_DOUBLE_2ADDR:
case OP_REM_DOUBLE_2ADDR:
/* vA(wide) <- vA(wide), vB(wide) */
/* KILLW(workBits, decInsn.vA); */
GENW(workBits, decInsn.vA);
GENW(workBits, decInsn.vB);
break;
/* we will only see this if liveness analysis is done after general vfy */
case OP_THROW_VERIFICATION_ERROR:
/* no registers used */
break;
/* quickened instructions, not expected to appear */
case OP_EXECUTE_INLINE:
case OP_EXECUTE_INLINE_RANGE:
case OP_IGET_QUICK:
case OP_IGET_WIDE_QUICK:
case OP_IGET_OBJECT_QUICK:
case OP_IPUT_QUICK:
case OP_IPUT_WIDE_QUICK:
case OP_IPUT_OBJECT_QUICK:
case OP_INVOKE_VIRTUAL_QUICK:
case OP_INVOKE_VIRTUAL_QUICK_RANGE:
case OP_INVOKE_SUPER_QUICK:
case OP_INVOKE_SUPER_QUICK_RANGE:
/* fall through to failure */
/* correctness fixes, not expected to appear */
case OP_INVOKE_OBJECT_INIT_RANGE:
case OP_RETURN_VOID_BARRIER:
case OP_SPUT_VOLATILE:
case OP_SPUT_OBJECT_VOLATILE:
case OP_SPUT_WIDE_VOLATILE:
case OP_IPUT_VOLATILE:
case OP_IPUT_OBJECT_VOLATILE:
case OP_IPUT_WIDE_VOLATILE:
case OP_SGET_VOLATILE:
case OP_SGET_OBJECT_VOLATILE:
case OP_SGET_WIDE_VOLATILE:
case OP_IGET_VOLATILE:
case OP_IGET_OBJECT_VOLATILE:
case OP_IGET_WIDE_VOLATILE:
/* fall through to failure */
/* these should never appear during verification */
case OP_UNUSED_3E:
case OP_UNUSED_3F:
case OP_UNUSED_40:
case OP_UNUSED_41:
case OP_UNUSED_42:
case OP_UNUSED_43:
case OP_UNUSED_73:
case OP_UNUSED_79:
case OP_UNUSED_7A:
case OP_BREAKPOINT:
case OP_UNUSED_FF:
return false;
}
return true;
}
int g_cmp_ax_dx(void) { GEN(0x39); GEN(0xD0); DID(2); }
/*
* Read power system data from a file and load it into a PS struct.
*/
PS GetPS(const char* file_name){
//numbers of various items in the ps file.
int i, num_buses, num_branches, num_gens, num_shunts, *ids, pv=0, sh=0, src=0;
double base_mva;
PS ps;
//check input
if(file_name == NULL) return NULL;
FILE *ps_file = fopen(file_name, "r");
if(ps_file == NULL) return NULL;
//read off ps data sizes
if(fscanf(ps_file, "BASE_MVA %lg\n", &base_mva) != 1) return NULL;
if(fscanf(ps_file, "BUS %d\n", &num_buses) != 1) return NULL;
if(fscanf(ps_file, "BRANCH %d\n", &num_branches) != 1) return NULL;
if(fscanf(ps_file, "GEN %d\n", &num_gens) != 1) return NULL;
if(fscanf(ps_file, "SHUNT %d\n", &num_shunts) != 1) return NULL;
ps = malloc(sizeof(_PS));
if(!ps) return NULL;
ps->base_mva = base_mva;
ps->num_buses = num_buses;
ps->num_branches = num_branches;
ps->num_gens = num_gens;
ps->num_shunts = num_shunts;
ps->num_macs = num_gens;
//allocate memory for buses, branches, etc.
ps->buses = malloc(num_buses*sizeof(Bus));
ps->branches = malloc(num_branches*sizeof(Branch));
ps->gens = malloc(num_gens*sizeof(Gen));
ps->shunts = malloc(num_shunts*sizeof(Shunt));
ids = malloc(num_buses*sizeof(int));
ps->src_buses = malloc((num_shunts+num_gens)*sizeof(int));
//check out memory allocations
if(!ps->buses || !ps->branches || !ps->gens || !ps->shunts || !ids || !ps->src_buses){
FreePS(&ps);
if(ids) free(ids);
return NULL;
}
//read data from file and populate ps
fscanf(ps_file, "\n");
for(i = 0; i < num_buses; i++){
fscanf(ps_file, "%d %d %lg %lg %lg %lg %d %lg %lg %lg %d %lg %lg\n", BUS(id), BUS(type), BUS(pd), BUS(qd), BUS(gs), BUS(bs), BUS(area), BUS(vmag), BUS(vang), BUS(base_kv), BUS(zone), BUS(vmax), BUS(vmin));
ids[i] = ps->buses[i].id;
}
//sort the bus array, get local indices, and locate the swing bus index
qsort(ps->buses, num_buses, sizeof(Bus), CompareBuses);
for(i = 0; i < num_buses; i++){
ps->buses[i].index = i;
ids[i] = ps->buses[i].id;
if(ps->buses[i].type == 3) ps->swing_bus = i;
}
//branches
int swap_temp;
fscanf(ps_file, "\n");
for(i = 0; i < num_branches; i++){
fscanf(ps_file, "%d %d %lg %lg %lg %lg %lg %lg\n", BR(from), BR(to), BR(r), BR(x), BR(b), BR(rate_a), BR(rate_b), BR(rate_c));
//check whether from is greater than to, and if so, swap. this
//helps identify parallel branches.
if(ps->branches[i].from > ps->branches[i].to){
swap_temp = ps->branches[i].from;
ps->branches[i].from = ps->branches[i].to;
ps->branches[i].to = swap_temp;
}
ps->branches[i].from_index = (int*)bsearch(&(ps->branches[i].from), ids, num_buses, sizeof(int), CompareBuses) - ids;
ps->branches[i].to_index = (int*)bsearch(&(ps->branches[i].to), ids, num_buses, sizeof(int), CompareBuses) - ids;
}
//generators
fscanf(ps_file, "\n");
for(i = 0; i < num_gens; i++){
fscanf(ps_file, "%d %lg %lg %lg %lg %lg %lg %d %lg %lg\n", GEN(bus), GEN(pg), GEN(qg), GEN(qmax), GEN(qmin), GEN(vsp), GEN(m_base), GEN(status), GEN(pmax), GEN(pmin));
ps->gens[i].index = (int*)bsearch(&(ps->gens[i].bus), ids, num_buses, sizeof(int), CompareBuses) - ids;
ps->gens[i].pg/=base_mva;
ps->gens[i].qg/=base_mva;
}
qsort(ps->gens, ps->num_gens, sizeof(Gen), CompareGen);
//shunts
fscanf(ps_file, "\n");
for(i = 0; i < num_shunts; i++){
fscanf(ps_file, "%d %lg %lg\n", SH(bus), SH(p), SH(q));
ps->shunts[i].index = (int*)bsearch(&(ps->shunts[i].bus), ids, num_buses, sizeof(int), CompareBuses) - ids;
ps->shunts[i].p/=base_mva;
ps->shunts[i].q/=base_mva;
}
qsort(ps->shunts, ps->num_shunts, sizeof(Shunt), CompareShunt);
//find the set union of load and generator buses
while(sh < num_shunts || pv < num_gens){
if(pv==num_gens){ps->src_buses[src++] = ps->shunts[sh++].index; continue;}
if(sh==num_shunts){ps->src_buses[src++] = ps->gens[pv++].index; continue;}
if(ps->shunts[sh].index==ps->gens[pv].index){
ps->src_buses[src++] = ps->shunts[sh++].index;
pv++;
continue;
}
ps->src_buses[src++] = (ps->shunts[sh].index < ps->gens[pv].index ? ps->shunts[sh++].index : ps->gens[pv++].index);
}
//free up any extra memory in the source bus array
realloc(ps->src_buses, src*sizeof(int));
ps->num_src = src;
//create ybus. if there are any errors, free allocated memory and
//return NULL
if(CreateYBus(ps, ids)){
FreePS(&ps);
free(ids);
return NULL;
}
//release the bus map
free(ids);
//return success
return ps;
};
int g_jle(sbyte d) { GEN(0x7E); GEN(d); DID(2); }
