/*
* Compares two sequence objects
* Assumes both objects are of same type (guaranteed by obj_compare)
*/
int8_t
seq_compare(pPmObj_t pobj1, pPmObj_t pobj2)
{
int16_t l1;
int16_t l2;
pPmObj_t pa;
pPmObj_t pb;
PmReturn_t retval;
int8_t retcompare;
/* Get the lengths of supported types or return differ */
if (OBJ_GET_TYPE(pobj1) == OBJ_TYPE_TUP)
{
l1 = ((pPmTuple_t)pobj1)->length;
l2 = ((pPmTuple_t)pobj2)->length;
}
else if (OBJ_GET_TYPE(pobj1) == OBJ_TYPE_LST)
{
l1 = ((pPmList_t)pobj2)->length;
l2 = ((pPmList_t)pobj2)->length;
}
else
{
return C_DIFFER;
}
/* Return if the lengths differ */
if (l1 != l2)
{
return C_DIFFER;
}
/* Compare all items in the sequences */
while (--l1 >= 0)
{
retval = seq_getSubscript(pobj1, l1, &pa);
if (retval != PM_RET_OK)
{
return C_DIFFER;
}
retval = seq_getSubscript(pobj2, l1, &pb);
if (retval != PM_RET_OK)
{
return C_DIFFER;
}
retcompare = obj_compare(pa, pb);
if (retcompare != C_SAME)
{
return retcompare;
}
}
return C_SAME;
}
/**
* Unit Test ported from SNARF
* This tests if it correctly creates the dictionary object
* This also tests if dict_setItem correctly replaces the existing value
* if the new val has the same key as the exisiting one.
*/
void
ut_dict_getItem_001(CuTest *tc)
{
uint8_t heap[HEAP_SIZE];
p_test_str1 = test_str1;
p_test_str2 = test_str2;
p_test_str3 = test_str3;
p_test_strnew = test_strnew;
PmReturn_t retval;
retval = pm_init(heap, HEAP_SIZE, MEMSPACE_RAM, C_NULL);
retval = string_new((uint8_t const **)&test_str1, &p_firstval);
retval = string_new((uint8_t const **)&test_str2, &p_secondval);
retval = string_new((uint8_t const **)&test_str3, &p_thirdval);
retval = string_new((uint8_t const **)&test_strnew, &p_newval);
retval = int_new(1, (pPmObj_t *)&p_firstkey);
retval = int_new(2, (pPmObj_t *)&p_secondkey);
retval = int_new(3, (pPmObj_t *)&p_thirdkey);
retval = int_new(2, (pPmObj_t *)&p_newkey);
dict_new(&p_dict);
dict_setItem(p_dict, (pPmObj_t)p_firstkey, p_firstval);
dict_setItem(p_dict, (pPmObj_t)p_secondkey, p_secondval);
dict_setItem(p_dict, (pPmObj_t)p_thirdkey, p_thirdval);
dict_setItem(p_dict, (pPmObj_t)p_newkey, p_newval);
dict_setItem(p_dict, (pPmObj_t)p_secondkey, p_secondval);
dict_getItem(p_dict, (pPmObj_t)p_firstkey, &p_tempobj);
CuAssertTrue(tc, obj_compare(p_tempobj, p_firstval) == C_SAME);
dict_getItem(p_dict, (pPmObj_t)p_secondkey, &p_tempobj);
CuAssertTrue(tc, obj_compare(p_tempobj, p_secondval) == C_SAME);
dict_getItem(p_dict, (pPmObj_t)p_thirdkey, &p_tempobj);
CuAssertTrue(tc, obj_compare(p_tempobj, p_thirdval) == C_SAME);
}
static obj_ptr _e(obj_ptr args, obj_ptr env)
{
obj_ptr last = 0, arg;
for (; CONSP(args); args = CDR(args))
{
arg = CAR(args);
if (last && obj_compare(last, arg) != 0)
return MKBOOL(0);
last = arg;
}
return MKBOOL(1);
}
int8_t
dict_compare(pPmObj_t d1, pPmObj_t d2)
{
pPmDict_t pd1 = (pPmDict_t)d1;
pPmDict_t pd2 = (pPmDict_t)d2;
pPmObj_t pkey1;
pPmObj_t pval1;
pPmObj_t pval2;
uint16_t i;
PmReturn_t retval;
/* Return if lengths are not equal */
if (pd1->length != pd2->length)
{
return C_DIFFER;
}
for (i = 0; i < pd1->length; i++)
{
/* Get the key,val from one dict */
retval = seglist_getItem(pd1->d_keys, i, &pkey1);
PM_RETURN_IF_ERROR(retval);
retval = seglist_getItem(pd1->d_vals, i, &pval1);
PM_RETURN_IF_ERROR(retval);
/* Return if the key,val pair is not in the other dict */
retval = dict_getItem(d2, pkey1, &pval2);
if (retval != PM_RET_OK)
{
return C_DIFFER;
}
if (obj_compare(pval1, pval2) != C_SAME)
{
return C_DIFFER;
}
}
/* All key,values match */
return C_SAME;
}
Da_emulate_result Da_emulate(Da* d, CONTEXT * ctx, MemoryCache *mem, bool emulate_FS_accesses, address FS)
{
#ifdef _WIN64
return DA_NOT_EMULATED;
#endif
//bool SF=IS_SET(ctx->EFlags, FLAG_SF);
//bool OF=IS_SET(ctx->EFlags, FLAG_OF);
//bool ZF=IS_SET(ctx->EFlags, FLAG_ZF);
bool CF=IS_SET(ctx->EFlags, FLAG_CF);
bool b;
if (x86_emu_debug)
{
// FIXME: write to log also?
L ("%s() begin: [", __func__);
Da_DumpString(&cur_fds, d);
L ("]\n");
};
if ((emulate_FS_accesses==false && IS_SET(d->prefix_codes, PREFIX_FS)) ||
(IS_SET(d->prefix_codes, PREFIX_SS) || IS_SET(d->prefix_codes, PREFIX_GS)))
{
if (x86_emu_debug)
L ("%s() skipping (data selector prefix present) at 0x" PRI_ADR_HEX "\n", __func__, CONTEXT_get_PC(ctx));
return DA_EMULATED_CANNOT_READ_MEMORY;
};
switch (d->ins_code)
{
case I_CDQ:
{
uint32_t a=CONTEXT_get_Accum (ctx)&0xFFFFFFFF;
CONTEXT_set_xDX (ctx, (a&0x80000000) ? 0xFFFFFFFF : 0);
goto add_to_PC_and_return_OK;
};
break;
case I_PUSH:
{
address rt_adr;
obj v;
b=Da_op_get_value_of_op (&d->op[0], &rt_adr, ctx, mem, __FILE__, __LINE__, &v, d->prefix_codes, FS);
if (b==false)
{
if (x86_emu_debug)
L ("%s() I_PUSH: can't read memory\n", __func__);
return DA_EMULATED_CANNOT_READ_MEMORY;
};
b=DO_PUSH (ctx, mem, obj_get_as_REG(&v));
if (b==false)
{
if (x86_emu_debug)
L ("%s() I_PUSH: can't write memory\n", __func__);
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
goto add_to_PC_and_return_OK;
};
break;
case I_PUSHFD:
if (DO_PUSH (ctx, mem, ctx->EFlags | FLAG_TF)==false)
{
if (x86_emu_debug)
L ("%s() I_PUSHFD: can't write memory\n", __func__);
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
goto add_to_PC_and_return_OK;
break;
case I_POP:
{
REG val;
if (DO_POP(ctx, mem, &val)==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
obj v;
obj_tetrabyte2 (val, &v);
Da_op_set_value_of_op (&d->op[0], &v, ctx, mem, d->prefix_codes, FS);
goto add_to_PC_and_return_OK;
};
break;
case I_POPFD:
{
REG val;
if (DO_POP(ctx, mem, &val)==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
ctx->EFlags=val;
goto add_to_PC_and_return_OK;
};
break;
case I_LEAVE:
{
//ESP <- EBP
//POP EBP
REG val;
CONTEXT_set_SP(ctx, CONTEXT_get_BP(ctx));
if (DO_POP(ctx, mem, &val)==false)
return DA_EMULATED_CANNOT_READ_MEMORY; // FIXME: а надо еще SP назад возвращать!
CONTEXT_set_BP(ctx, val);
goto add_to_PC_and_return_OK;
};
break;
case I_REP_STOSB:
case I_REP_STOSW:
case I_REP_STOSD:
{
BYTE *buf;
bool DF=IS_SET(ctx->EFlags, FLAG_DF);
if (DF)
return DA_NOT_EMULATED; // not supported... bug here
SIZE_T BUF_SIZE;
if (d->ins_code==I_REP_STOSB)
BUF_SIZE=CONTEXT_get_xCX (ctx);
else if (d->ins_code==I_REP_STOSW)
BUF_SIZE=CONTEXT_get_xCX (ctx)*2;
else if (d->ins_code==I_REP_STOSD)
BUF_SIZE=CONTEXT_get_xCX (ctx)*4;
buf=DMALLOC(BYTE, BUF_SIZE, "buf");
if (d->ins_code==I_REP_STOSB)
{
for (REG i=0; i<CONTEXT_get_xCX(ctx); i++) // FIXME: rewrite to my own bzero()!
buf[i]=CONTEXT_get_Accum(ctx)&0xFF;
}
else if (d->ins_code==I_REP_STOSW)
{
for (REG i=0; i<CONTEXT_get_xCX(ctx); i++) // FIXME: rewrite to my own bzero()!
((WORD*)buf)[i]=CONTEXT_get_Accum(ctx)&0xFFFF;
}
else if (d->ins_code==I_REP_STOSD)
{
for (REG i=0; i<CONTEXT_get_xCX(ctx); i++) // FIXME: rewrite to my own bzero()!
((DWORD*)buf)[i]=(DWORD)(CONTEXT_get_Accum(ctx)&0xFFFFFFFF);
}
else
{
oassert(0);
};
if (MC_WriteBuffer (mem, CONTEXT_get_xDI (ctx), BUF_SIZE, buf)==false)
return DA_EMULATED_CANNOT_WRITE_MEMORY;
DFREE(buf);
CONTEXT_set_xDI (ctx, CONTEXT_get_xDI (ctx) + BUF_SIZE);
CONTEXT_set_xCX (ctx, 0);
goto add_to_PC_and_return_OK;
};
break;
case I_REP_MOVSB:
case I_REP_MOVSW:
case I_REP_MOVSD:
{
BYTE *buf;
bool DF=IS_SET(ctx->EFlags, FLAG_DF);
if (DF)
return DA_NOT_EMULATED; // not supported... bug here
SIZE_T BUF_SIZE;
SIZE_T sizeof_element;
if (d->ins_code==I_REP_MOVSB)
sizeof_element=1;
else if (d->ins_code==I_REP_MOVSW)
sizeof_element=2;
else if (d->ins_code==I_REP_MOVSD)
sizeof_element=4;
else
{
oassert(0);
};
BUF_SIZE=CONTEXT_get_xCX(ctx)*sizeof_element;
//printf ("%s() BUF_SIZE=0x%x\n", __func__, BUF_SIZE);
//printf ("%s() (before) SI=0x" PRI_REG_HEX "\n", __func__, CONTEXT_get_xSI(ctx));
//printf ("%s() (before) DI=0x" PRI_REG_HEX "\n", __func__, CONTEXT_get_xDI(ctx));
buf=DMALLOC(BYTE, BUF_SIZE, "buf");
address blk_src=CONTEXT_get_xSI(ctx);
address blk_dst=CONTEXT_get_xDI(ctx);
if (DF)
{
blk_src-=BUF_SIZE; // +sizeof_element;
blk_dst-=BUF_SIZE; // +sizeof_element;
};
if (MC_ReadBuffer (mem, blk_src, BUF_SIZE, buf)==false)
{
DFREE(buf);
return DA_EMULATED_CANNOT_READ_MEMORY;
};
if (MC_WriteBuffer (mem, blk_dst, BUF_SIZE, buf)==false)
{
DFREE(buf);
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
DFREE(buf);
if (DF==false)
{
CONTEXT_set_xSI (ctx, CONTEXT_get_xSI (ctx) + BUF_SIZE);
CONTEXT_set_xDI (ctx, CONTEXT_get_xDI (ctx) + BUF_SIZE);
}
else
{
CONTEXT_set_xSI (ctx, CONTEXT_get_xSI (ctx) - BUF_SIZE);
CONTEXT_set_xDI (ctx, CONTEXT_get_xDI (ctx) - BUF_SIZE);
};
CONTEXT_set_xCX (ctx, 0);
//printf ("%s() (after) SI=0x" PRI_REG_HEX "\n", __func__, CONTEXT_get_xSI(ctx));
//printf ("%s() (after) DI=0x" PRI_REG_HEX "\n", __func__, CONTEXT_get_xDI(ctx));
goto add_to_PC_and_return_OK;
};
case I_STD:
SET_BIT (ctx->EFlags, FLAG_DF);
goto add_to_PC_and_return_OK;
case I_CLD:
REMOVE_BIT (ctx->EFlags, FLAG_DF);
goto add_to_PC_and_return_OK;
case I_RETN:
{
WORD ret_arg=0;
if (d->ops_total==1)
{
oassert (d->op[0].type==DA_OP_TYPE_VALUE);
ret_arg=obj_get_as_wyde(&d->op[0].val._v); // RETN arg is 16-bit
};
address newPC;
if (DO_POP(ctx, mem, &newPC)==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
CONTEXT_set_SP(ctx, CONTEXT_get_SP(ctx)+ret_arg);
CONTEXT_set_PC(ctx, newPC);
return DA_EMULATED_OK;
};
break;
case I_ADD:
case I_ADC:
case I_INC:
{
//L (__FUNCTION__ "() I_ADD/I_INC begin: [%s]\n", ToString().c_str());
obj rt1, rt2;
REG rt1_adr, rt2_adr;
b=Da_op_get_value_of_op (&d->op[0], &rt1_adr, ctx, mem, __FILE__, __LINE__, &rt1, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
if (d->ins_code==I_ADD || d->ins_code==I_ADC)
{
oassert (d->op[0].value_width_in_bits==d->op[1].value_width_in_bits);
b=Da_op_get_value_of_op (&d->op[1], &rt2_adr, ctx, mem, __FILE__, __LINE__, &rt2, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
}
else
{ // INC case
// make second op 1
obj_REG2_and_set_type (rt1.t, 1, 0, &rt2);
};
obj res_sum;
obj_add (&rt1, &rt2, &res_sum);
if (d->ins_code==I_ADC && CF)
obj_increment(&res_sum);
set_PF (ctx, &res_sum);
set_SF (ctx, &res_sum);
set_ZF (ctx, &res_sum);
set_AF (ctx, &rt1, &rt2, &res_sum);
if (d->ins_code==I_ADD || d->ins_code==I_ADC)
set_or_clear_flag (ctx, FLAG_CF, obj_compare (&res_sum, &rt1)==-1); // res_sum < rt1
octabyte tmp=((zero_extend_to_REG(&rt1) ^ zero_extend_to_REG(&rt2) ^
get_sign_bit (d->op[0].value_width_in_bits)) &
(zero_extend_to_REG(&res_sum) ^ zero_extend_to_REG(&rt1)))
&
get_sign_bit (d->op[0].value_width_in_bits);
set_or_clear_flag (ctx, FLAG_OF, tmp);
b=Da_op_set_value_of_op (&d->op[0], &res_sum, ctx, mem, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_WRITE_MEMORY;
goto add_to_PC_and_return_OK;
};
break;
case I_NOT:
{
obj rt1, res;
REG rt1_adr;
if (Da_op_get_value_of_op (&d->op[0], &rt1_adr, ctx, mem, __FILE__, __LINE__, &rt1, d->prefix_codes, FS)==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
obj_NOT(&rt1, &res);
if (Da_op_set_value_of_op (&d->op[0], &res, ctx, mem, d->prefix_codes, FS))
goto add_to_PC_and_return_OK;
};
break;
case I_NEG:
{
obj rt1, res;
REG rt1_adr;
if (Da_op_get_value_of_op (&d->op[0], &rt1_adr, ctx, mem, __FILE__, __LINE__, &rt1, d->prefix_codes, FS)==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
obj_NEG(&rt1, &res);
set_or_clear_flag (ctx, FLAG_CF, obj_is_zero(&rt1)==false);
set_PF (ctx, &res);
set_SF (ctx, &res);
set_ZF (ctx, &res);
set_or_clear_flag (ctx, FLAG_AF, (0 ^ obj_get_4th_bit(&rt1)) ^ obj_get_4th_bit(&res));
REMOVE_BIT (ctx->EFlags, FLAG_OF);
//SET_BIT (ctx->EFlags, FLAG_AF);
if (Da_op_set_value_of_op (&d->op[0], &res, ctx, mem, d->prefix_codes, FS))
goto add_to_PC_and_return_OK;
};
break;
case I_OR:
case I_XOR:
case I_AND:
case I_TEST:
{
oassert (d->op[0].value_width_in_bits==d->op[1].value_width_in_bits);
obj rt1, rt2, res;
REG rt1_adr, rt2_adr;
b=Da_op_get_value_of_op (&d->op[0], &rt1_adr, ctx, mem, __FILE__, __LINE__, &rt1, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
b=Da_op_get_value_of_op (&d->op[1], &rt2_adr, ctx, mem, __FILE__, __LINE__, &rt2, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
switch (d->ins_code)
{
case I_OR:
obj_OR(&rt1, &rt2, &res);
break;
case I_XOR:
obj_XOR(&rt1, &rt2, &res);
break;
case I_TEST:
case I_AND:
obj_AND(&rt1, &rt2, &res);
break;
default:
oassert(0);
break;
};
set_PF (ctx, &res);
set_SF (ctx, &res);
set_ZF (ctx, &res);
REMOVE_BIT (ctx->EFlags, FLAG_AF);
REMOVE_BIT (ctx->EFlags, FLAG_CF);
REMOVE_BIT (ctx->EFlags, FLAG_OF);
if (d->ins_code==I_TEST)
b=true;
else
b=Da_op_set_value_of_op (&d->op[0], &res, ctx, mem, d->prefix_codes, FS);
if (b)
goto add_to_PC_and_return_OK;
else
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
break;
case I_DEC:
case I_SUB:
case I_SBB:
case I_CMP:
{
if (d->ins_code==I_SUB || d->ins_code==I_SBB || d->ins_code==I_CMP)
{
oassert (d->op[0].value_width_in_bits==d->op[1].value_width_in_bits);
};
obj rt1, rt2;
REG rt1_adr, rt2_adr;
b=Da_op_get_value_of_op (&d->op[0], &rt1_adr, ctx, mem, __FILE__, __LINE__, &rt1, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
if (d->ins_code==I_DEC)
{
// make second op 1
obj_REG2_and_set_type (rt1.t, 1, 0, &rt2);
}
else
{
b=Da_op_get_value_of_op (&d->op[1], &rt2_adr, ctx, mem, __FILE__, __LINE__, &rt2, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
};
obj res;
obj_subtract (&rt1, &rt2, &res);
if (d->ins_code==I_SBB && CF)
obj_decrement (&res);
set_PF (ctx, &res);
set_SF (ctx, &res);
set_ZF (ctx, &res);
set_AF (ctx, &rt1, &rt2, &res);
if (d->ins_code==I_SBB)
{
int tmp=(obj_compare (&rt1, &res)==-1 /* rt1<res */) || (CF && obj_get_as_tetrabyte(&rt2)==0xffffffff);
set_or_clear_flag (ctx, FLAG_CF, tmp);
}
else
{
if (d->ins_code!=I_DEC) // DEC leave CF flag unaffected
set_or_clear_flag (ctx, FLAG_CF, obj_compare (&rt1, &rt2)==-1); /* rt1<rt2 */
};
octabyte tmp=((zero_extend_to_octabyte(&rt1) ^ zero_extend_to_octabyte(&rt2)) &
(zero_extend_to_octabyte(&res) ^ zero_extend_to_octabyte(&rt1))) &
get_sign_bit (d->op[0].value_width_in_bits);
set_or_clear_flag (ctx, FLAG_OF, tmp);
if (d->ins_code==I_CMP)
b=true;
else
b=Da_op_set_value_of_op (&d->op[0], &res, ctx, mem, d->prefix_codes, FS);
if (b)
goto add_to_PC_and_return_OK;
else
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
break;
case I_XCHG:
{
REG op1_adr, op2_adr;
obj op1;
b=Da_op_get_value_of_op(&d->op[0], &op1_adr, ctx, mem, __FILE__, __LINE__, &op1, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
obj op2;
b=Da_op_get_value_of_op(&d->op[1], &op2_adr, ctx, mem, __FILE__, __LINE__, &op2, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
if (Da_op_set_value_of_op (&d->op[0], &op2, ctx, mem, d->prefix_codes, FS)==false)
return DA_EMULATED_CANNOT_WRITE_MEMORY;
if (Da_op_set_value_of_op (&d->op[1], &op1, ctx, mem, d->prefix_codes, FS)==false)
return DA_EMULATED_CANNOT_WRITE_MEMORY;
goto add_to_PC_and_return_OK;
};
break;
case I_MOV:
case I_MOVDQA:
case I_MOVDQU:
return Da_emulate_MOV_op1_op2(d, ctx, mem, d->prefix_codes, FS);
case I_MOVZX:
case I_MOVSX:
{
address rt_adr;
obj op2;
bool b=Da_op_get_value_of_op(&d->op[1], &rt_adr, ctx, mem, __FILE__, __LINE__, &op2, d->prefix_codes, FS);
if (b==false)
{
/*
if (L_verbose_level>=2)
{
printf (__FUNCTION__ "(): [");
Da_DumpString(d);
printf ("]: can't read src (2nd) operand\n");
};
*/
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
obj to_be_stored_v;
if (d->ins_code==I_MOVZX)
{
enum obj_type op1_type_will_be=bit_width_to_obj_type (d->op[0].value_width_in_bits);
obj_zero_extend (&op2, op1_type_will_be, &to_be_stored_v);
}
else if (d->ins_code==I_MOVSX)
{
enum obj_type op1_type_will_be=bit_width_to_obj_type (d->op[0].value_width_in_bits);
obj_sign_extend (&op2, op1_type_will_be, &to_be_stored_v);
}
else
{
oassert (0);
};
b=Da_op_set_value_of_op (&d->op[0], &to_be_stored_v, ctx, mem, d->prefix_codes, FS);
if (b==false)
{
/*
if (L_verbose_level>=2)
{
printf(__FUNCTION__ "(): [");
Da_DumpString(d);
printf ("]: can't write dst (1st) operand\n");
};
*/
return DA_EMULATED_CANNOT_WRITE_MEMORY;
};
goto add_to_PC_and_return_OK;
};
case I_NOP:
goto add_to_PC_and_return_OK;
case I_LEA:
{
address a=(address)Da_op_calc_adr_of_op(&d->op[1], ctx, mem, d->prefix_codes, FS);
obj val;
obj_tetrabyte2(a, &val);
b=Da_op_set_value_of_op (&d->op[0], &val, ctx, mem, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_WRITE_MEMORY;
goto add_to_PC_and_return_OK;
};
case I_SAR:
case I_SHR:
case I_SHL:
{
// http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH06/CH06-3.html
REG op1_adr, op2_adr;
obj op1;
bool b=Da_op_get_value_of_op(&d->op[0], &op1_adr, ctx, mem, __FILE__, __LINE__, &op1, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
// should be read anyway!
obj op2;
b=Da_op_get_value_of_op(&d->op[1], &op2_adr, ctx, mem, __FILE__, __LINE__, &op2, d->prefix_codes, FS);
if (b==false)
return DA_EMULATED_CANNOT_READ_MEMORY;
#ifdef _WIN64
obj_AND_with (&op2, 0x3F);
#else
obj_AND_with (&op2, 0x1F);
#endif
if (obj_is_zero(&op2)==false)
{
unsigned new_CF;
if (d->ins_code==I_SHR || d->ins_code==I_SAR)
new_CF=(zero_extend_to_octabyte(&op1) >> (obj_get_as_byte (&op2) - 1)) & 1;
else // SHL
new_CF=(zero_extend_to_octabyte(&op1) >> (obj_width_in_bits(&op1) - obj_get_as_byte (&op2))) & 1;
obj new_op1;
if (d->ins_code==I_SHR)
{
REG new_v=zero_extend_to_REG(&op1) >> obj_get_as_byte (&op2);
obj_REG2_and_set_type(op1.t, new_v, 0, &new_op1);
}
else if (d->ins_code==I_SAR)
int obj_compare(obj_ptr left, obj_ptr right)
{
/* TODO
if (NUMP(left) && NUMP(right))
...
*/
if (TYPE(left) < TYPE(right))
return -1;
if (TYPE(left) > TYPE(right))
return 1;
switch (TYPE(left))
{
case TYPE_INT:
case TYPE_BOOL:
return _int_compare(INT(left), INT(right));
case TYPE_FLOAT:
return _float_compare(FLOAT(left), FLOAT(right), 0.00000001); /* TODO: Better epsilon? */
case TYPE_SYMBOL:
return strcmp(SYMBOL(left), SYMBOL(right));
case TYPE_STRING:
return string_compare(&STRING(left), &STRING(right));
case TYPE_CONS:
{
int res = 0;
for (;;)
{
if (NTYPEP(left, TYPE(right)))
return obj_compare(left, right);
if (NTYPEP(left, TYPE_CONS))
return obj_compare(left, right);
res = obj_compare(CAR(left), CAR(right));
if (res != 0)
return res;
left = CDR(left);
right = CDR(right);
}
assert(0); /* unreachable */
break;
}
case TYPE_VEC:
return vec_compare(&left->data.as_vec, &right->data.as_vec);
/* TODO */
case TYPE_MAP:
assert(TYPE(left) != TYPE_MAP);
break;
case TYPE_CLOSURE:
assert(TYPE(left) != TYPE_CLOSURE);
break;
case TYPE_PRIMITIVE:
assert(TYPE(left) != TYPE_PRIMITIVE);
break;
case TYPE_ERROR:
assert(TYPE(left) != TYPE_ERROR);
break;
case TYPE_PORT:
assert(TYPE(left) != TYPE_PORT);
break;
}
return 0;
}
/* Returns true if the item is in the container object */
PmReturn_t
obj_isIn(pPmObj_t pobj, pPmObj_t pitem)
{
PmReturn_t retval = PM_RET_NO;
pPmObj_t ptestItem;
int16_t i;
uint8_t c;
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_TUP:
/* Iterate over tuple to find item */
for (i = 0; i < ((pPmTuple_t)pobj)->length; i++)
{
PM_RETURN_IF_ERROR(tuple_getItem(pobj, i, &ptestItem));
if (obj_compare(pitem, ptestItem) == C_SAME)
{
retval = PM_RET_OK;
break;
}
}
break;
case OBJ_TYPE_STR:
/* Raise a TypeError if item is not a string */
if ((OBJ_GET_TYPE(pitem) != OBJ_TYPE_STR))
{
retval = PM_RET_EX_TYPE;
break;
}
/* Empty string is alway present */
if (((pPmString_t)pitem)->length == 0)
{
retval = PM_RET_OK;
break;
}
/* Raise a ValueError if the string is more than 1 char */
else if (((pPmString_t)pitem)->length != 1)
{
retval = PM_RET_EX_VAL;
break;
}
/* Iterate over string to find char */
c = ((pPmString_t)pitem)->val[0];
for (i = 0; i < ((pPmString_t)pobj)->length; i++)
{
if (c == ((pPmString_t)pobj)->val[i])
{
retval = PM_RET_OK;
break;
}
}
break;
case OBJ_TYPE_LST:
/* Iterate over list to find item */
for (i = 0; i < ((pPmList_t)pobj)->length; i++)
{
PM_RETURN_IF_ERROR(list_getItem(pobj, i, &ptestItem));
if (obj_compare(pitem, ptestItem) == C_SAME)
{
retval = PM_RET_OK;
break;
}
}
break;
case OBJ_TYPE_DIC:
/* Check if the item is one of the keys of the dict */
retval = dict_getItem(pobj, pitem, &ptestItem);
if (retval == PM_RET_EX_KEY)
{
retval = PM_RET_NO;
}
break;
default:
retval = PM_RET_EX_TYPE;
break;
}
return retval;
}
