static PyObject *get_memory_operand_length(instruction_t *self, PyObject *args)
{
unsigned int i, length;
xed_decoded_inst_t *decoded_inst;
PyObject *r = NULL;
if(PyArg_ParseTuple(args, "I", &i) == 0)
goto _err;
decoded_inst = self->decoded_inst;
if(i >= xed_decoded_inst_number_of_memory_operands(decoded_inst))
{
PyErr_SetString(PyExc_IndexError, "Invalid operand index");
goto _err;
}
length = xed_decoded_inst_get_memory_operand_length(decoded_inst, i);
r = PyLong_FromUnsignedLong(length);
_err:
return r;
}
static PyObject *is_mem_written_only(instruction_t *self, PyObject *args)
{
unsigned int i;
xed_decoded_inst_t *decoded_inst;
xed_bool_t flag;
PyObject *r = NULL;
if(PyArg_ParseTuple(args, "I", &i) == 0)
goto _err;
decoded_inst = self->decoded_inst;
if(i >= xed_decoded_inst_number_of_memory_operands(decoded_inst))
{
PyErr_SetString(PyExc_IndexError, "Invalid operand index");
goto _err;
}
flag = xed_decoded_inst_mem_written_only(decoded_inst, i);
r = PyBool_FromLong(flag);
_err:
return r;
}
static PyObject *get_index_reg(instruction_t *self, PyObject *args)
{
unsigned int i;
xed_decoded_inst_t *decoded_inst;
xed_reg_enum_t reg;
PyObject *r = NULL;
if(PyArg_ParseTuple(args, "I", &i) == 0)
goto _err;
decoded_inst = self->decoded_inst;
if(i >= xed_decoded_inst_number_of_memory_operands(decoded_inst))
{
PyErr_SetString(PyExc_IndexError, "Invalid operand index");
goto _err;
}
reg = xed_decoded_inst_get_index_reg(decoded_inst, i);
r = PyInt_FromLong(reg);
_err:
return r;
}
static PyObject *get_memory_displacement(instruction_t *self, PyObject *args)
{
unsigned int i;
xed_decoded_inst_t *decoded_inst;
xed_int64_t disp;
PyObject *r = NULL;
if(PyArg_ParseTuple(args, "I", &i) == 0)
goto _err;
decoded_inst = self->decoded_inst;
if(i >= xed_decoded_inst_number_of_memory_operands(decoded_inst))
{
PyErr_SetString(PyExc_IndexError, "Invalid operand index");
goto _err;
}
disp = xed_decoded_inst_get_memory_displacement(decoded_inst, i);
r = PyLong_FromLongLong(disp);
_err:
return r;
}
int
main(int argc, char** argv)
{
xed_error_enum_t xed_error;
xed_bool_t long_mode = 0;
xed_bool_t real_mode = 0;
xed_bool_t protected_16 = 0;
xed_state_t dstate;
unsigned int first_argv;
unsigned int bytes = 0;
unsigned char itext[XED_MAX_INSTRUCTION_BYTES];
int i;
unsigned int u;
xed_decoded_inst_t xedd;
#define BUFLEN 1000
char buffer[BUFLEN];
xed_bool_t ok;
unsigned int isyntax;
xed_syntax_enum_t syntax;
unsigned int memop_index = 0;
unsigned int memops = 0;
xed_uint64_t out_addr = 0;
xed_tables_init();
xed_agen_register_callback( register_callback, segment_callback);
xed_state_zero(&dstate);
xed_set_verbosity( 99 );
if (argc > 2 && strcmp(argv[1], "-64") == 0)
long_mode = 1;
if (argc > 2 && strcmp(argv[1], "-r") == 0)
real_mode = 1;
if (argc > 2 && strcmp(argv[1], "-16") == 0)
protected_16 = 1;
if (long_mode) {
first_argv = 2;
dstate.mmode=XED_MACHINE_MODE_LONG_64;
}
else if (protected_16) {
first_argv = 2;
xed_state_init(&dstate,
XED_MACHINE_MODE_LEGACY_16,
XED_ADDRESS_WIDTH_16b,
XED_ADDRESS_WIDTH_16b);
}
else if (real_mode) {
first_argv = 2;
/* we say that real mode uses 16b addressing even though the
addresses returned are 20b long. */
xed_state_init(&dstate,
XED_MACHINE_MODE_REAL_16,
XED_ADDRESS_WIDTH_16b,
XED_ADDRESS_WIDTH_16b);
}
else {
first_argv=1;
xed_state_init(&dstate,
XED_MACHINE_MODE_LEGACY_32,
XED_ADDRESS_WIDTH_32b,
XED_ADDRESS_WIDTH_32b);
}
xed_decoded_inst_zero_set_mode(&xedd, &dstate);
for( i=first_argv ; i < argc; i++) {
xed_uint8_t x = (xed_uint8_t)(xed_atoi_hex(argv[i]));
assert(bytes < XED_MAX_INSTRUCTION_BYTES);
itext[bytes++] = x;
}
if (bytes == 0) {
fprintf(stderr, "Must supply some hex bytes\n");
exit(1);
}
printf("PARSING BYTES: ");
for( u=0; u<bytes; u++)
printf("%02x ", STATIC_CAST(unsigned int,itext[u]));
printf("\n");
xed_error = xed_decode(&xedd,
REINTERPRET_CAST(const xed_uint8_t*,itext),
bytes);
switch(xed_error)
{
case XED_ERROR_NONE:
break;
case XED_ERROR_BUFFER_TOO_SHORT:
fprintf(stderr,"Not enough bytes provided\n");
exit(1);
case XED_ERROR_GENERAL_ERROR:
fprintf(stderr,"Could not decode given input.\n");
exit(1);
default:
fprintf(stderr,"Unhandled error code %s\n", xed_error_enum_t2str(xed_error));
exit(1);
}
xed_decoded_inst_dump(&xedd,buffer, BUFLEN);
printf("%s\n",buffer);
for(isyntax= XED_SYNTAX_XED; isyntax < XED_SYNTAX_LAST; isyntax++) {
syntax = STATIC_CAST(xed_syntax_enum_t, isyntax);
ok = xed_format(syntax, &xedd, buffer, BUFLEN, 0);
if (ok)
printf("%s syntax: %s\n", xed_syntax_enum_t2str(syntax), buffer);
else
printf("Error disassembling %s syntax\n", xed_syntax_enum_t2str(syntax));
}
memops = xed_decoded_inst_number_of_memory_operands(&xedd);
printf("\nNumber of memory operands: %d\n", (int)memops);
for(memop_index=0; memop_index<memops; memop_index++) {
xed_error = xed_agen(&xedd, memop_index, 0, &out_addr);
if (xed_error != XED_ERROR_NONE) {
fprintf(stderr,"Agen error code %s\n", xed_error_enum_t2str(xed_error));
exit(1);
}
printf("\tMemory agen%d: " XED_FMT_LX "\n", (int)memop_index, out_addr);
}
return 0;
}
static PyObject *get_number_of_memory_operands(instruction_t *self)
{
xed_uint_t num;
num = xed_decoded_inst_number_of_memory_operands(self->decoded_inst);
return PyLong_FromUnsignedLong(num);
}
