| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "libdis.h" |
| #include <inttypes.h> |
| |
| #ifdef _MSC_VER |
| #define snprintf _snprintf |
| #define inline __inline |
| #endif |
| |
| |
| /* |
| * concatenation macros. STRNCATF concatenates a format string, buf |
| * only with one argument. |
| */ |
| #define STRNCAT( buf, str, len ) do { \ |
| int _i = strlen(str), _blen = strlen(buf), _len = len - 1; \ |
| if ( len ) { \ |
| strncat( buf, str, _len ); \ |
| if ( _len <= _i ) { \ |
| buf[_blen+_len] = '\0'; \ |
| len = 0; \ |
| } else { \ |
| len -= _i; \ |
| } \ |
| } \ |
| } while( 0 ) |
| |
| #define STRNCATF( buf, fmt, data, len ) do { \ |
| char _tmp[MAX_OP_STRING]; \ |
| \ |
| snprintf( _tmp, sizeof _tmp, fmt, data ); \ |
| STRNCAT( buf, _tmp, len ); \ |
| } while( 0 ) |
| |
| |
| #define PRINT_DISPLACEMENT( ea ) do { \ |
| if ( ea->disp_size && ea->disp ) { \ |
| if ( ea->disp_sign ) { \ |
| STRNCATF( buf, "-0x%" PRIX32, -ea->disp, len ); \ |
| } else { \ |
| STRNCATF( buf, "0x%" PRIX32, ea->disp, len ); \ |
| } \ |
| } \ |
| } while( 0 ) |
| |
| static const char *prefix_strings[] = { |
| "", /* no prefix */ |
| "repz ", /* the trailing spaces make it easy to prepend to mnemonic */ |
| "repnz ", |
| "lock ", |
| "branch delay " /* unused in x86 */ |
| }; |
| |
| static int format_insn_prefix_str( enum x86_insn_prefix prefix, char *buf, |
| int len ) { |
| |
| int len_orig = len; |
| |
| /* concat all prefix strings */ |
| if ( prefix & 1 ) { STRNCAT( buf, prefix_strings[1], len ); } |
| if ( prefix & 2 ) { STRNCAT( buf, prefix_strings[2], len ); } |
| if ( prefix & 4 ) { STRNCAT( buf, prefix_strings[3], len ); } |
| if ( prefix & 8 ) { STRNCAT( buf, prefix_strings[4], len ); } |
| |
| /* return the number of characters added */ |
| return (len_orig - len); |
| } |
| |
| /* |
| * sprint's an operand's data to string str. |
| */ |
| static void get_operand_data_str( x86_op_t *op, char *str, int len ){ |
| |
| if ( op->flags & op_signed ) { |
| switch ( op->datatype ) { |
| case op_byte: |
| snprintf( str, len, "%" PRId8, op->data.sbyte ); |
| return; |
| case op_word: |
| snprintf( str, len, "%" PRId16, op->data.sword ); |
| return; |
| case op_qword: |
| snprintf( str, len, "%" PRId64, op->data.sqword ); |
| return; |
| default: |
| snprintf( str, len, "%" PRId32, op->data.sdword ); |
| return; |
| } |
| } |
| |
| //else |
| switch ( op->datatype ) { |
| case op_byte: |
| snprintf( str, len, "0x%02" PRIX8, op->data.byte ); |
| return; |
| case op_word: |
| snprintf( str, len, "0x%04" PRIX16, op->data.word ); |
| return; |
| case op_qword: |
| snprintf( str, len, "0x%08" PRIX64,op->data.sqword ); |
| return; |
| default: |
| snprintf( str, len, "0x%08" PRIX32, op->data.dword ); |
| return; |
| } |
| } |
| |
| /* |
| * sprints register types to a string. the register types can be ORed |
| * together. |
| */ |
| static void get_operand_regtype_str( int regtype, char *str, int len ) |
| { |
| static struct { |
| const char *name; |
| int value; |
| } operand_regtypes[] = { |
| {"reg_gen" , 0x00001}, |
| {"reg_in" , 0x00002}, |
| {"reg_out" , 0x00004}, |
| {"reg_local" , 0x00008}, |
| {"reg_fpu" , 0x00010}, |
| {"reg_seg" , 0x00020}, |
| {"reg_simd" , 0x00040}, |
| {"reg_sys" , 0x00080}, |
| {"reg_sp" , 0x00100}, |
| {"reg_fp" , 0x00200}, |
| {"reg_pc" , 0x00400}, |
| {"reg_retaddr", 0x00800}, |
| {"reg_cond" , 0x01000}, |
| {"reg_zero" , 0x02000}, |
| {"reg_ret" , 0x04000}, |
| {"reg_src" , 0x10000}, |
| {"reg_dest" , 0x20000}, |
| {"reg_count" , 0x40000}, |
| {NULL, 0}, //end |
| }; |
| |
| unsigned int i; |
| |
| memset( str, 0, len ); |
| |
| //go thru every type in the enum |
| for ( i = 0; operand_regtypes[i].name; i++ ) { |
| //skip if type is not set |
| if(! (regtype & operand_regtypes[i].value) ) |
| continue; |
| |
| //not the first time around |
| if( str[0] ) { |
| STRNCAT( str, " ", len ); |
| } |
| |
| STRNCAT(str, operand_regtypes[i].name, len ); |
| } |
| } |
| |
| static int format_expr( x86_ea_t *ea, char *buf, int len, |
| enum x86_asm_format format ) { |
| char str[MAX_OP_STRING]; |
| |
| if ( format == att_syntax ) { |
| if (ea->base.name[0] || ea->index.name[0] || ea->scale) { |
| PRINT_DISPLACEMENT(ea); |
| STRNCAT( buf, "(", len ); |
| |
| if ( ea->base.name[0]) { |
| STRNCATF( buf, "%%%s", ea->base.name, len ); |
| } |
| if ( ea->index.name[0]) { |
| STRNCATF( buf, ",%%%s", ea->index.name, len ); |
| if ( ea->scale > 1 ) { |
| STRNCATF( buf, ",%d", ea->scale, len ); |
| } |
| } |
| /* handle the syntactic exception */ |
| if ( ! ea->base.name[0] && |
| ! ea->index.name[0] ) { |
| STRNCATF( buf, ",%d", ea->scale, len ); |
| } |
| |
| STRNCAT( buf, ")", len ); |
| } else |
| STRNCATF( buf, "0x%" PRIX32, ea->disp, len ); |
| |
| } else if ( format == xml_syntax ){ |
| |
| if ( ea->base.name[0]) { |
| STRNCAT (buf, "\t\t\t<base>\n", len); |
| |
| get_operand_regtype_str (ea->base.type, str, |
| sizeof str); |
| STRNCAT (buf, "\t\t\t\t<register ", len); |
| STRNCATF (buf, "name=\"%s\" ", ea->base.name, len); |
| STRNCATF (buf, "type=\"%s\" ", str, len); |
| STRNCATF (buf, "size=%d/>\n", ea->base.size, len); |
| |
| STRNCAT (buf, "\t\t\t</base>\n", len); |
| } |
| |
| if ( ea->index.name[0]) { |
| STRNCAT (buf, "\t\t\t<index>\n", len); |
| |
| get_operand_regtype_str (ea->index.type, str, |
| sizeof str); |
| |
| STRNCAT (buf, "\t\t\t\t<register ", len); |
| STRNCATF (buf, "name=\"%s\" ", ea->index.name, len); |
| STRNCATF (buf, "type=\"%s\" ", str, len); |
| STRNCATF (buf, "size=%d/>\n", ea->index.size, len); |
| |
| STRNCAT (buf, "\t\t\t</index>\n", len); |
| } |
| |
| //scale |
| STRNCAT (buf, "\t\t\t<scale>\n", len); |
| STRNCAT (buf, "\t\t\t\t<immediate ", len); |
| STRNCATF (buf, "value=\"%d\"/>\n", ea->scale, len); |
| STRNCAT (buf, "\t\t\t</scale>\n", len); |
| |
| if ( ea->disp_size ) { |
| |
| STRNCAT (buf, "\t\t\t<displacement>\n", len); |
| |
| if ( ea->disp_size > 1 && ! ea->disp_sign ) { |
| STRNCAT (buf, "\t\t\t\t<address ", len); |
| STRNCATF (buf, "value=\"0x%" PRIX32 "\"/>\n", ea->disp, |
| len); |
| } else { |
| STRNCAT (buf, "\t\t\t\t<immediate ", len); |
| STRNCATF (buf, "value=%" PRId32 "/>\n", ea->disp, len); |
| } |
| |
| STRNCAT (buf, "\t\t\t</displacement>\n", len); |
| } |
| |
| } else if ( format == raw_syntax ) { |
| |
| PRINT_DISPLACEMENT(ea); |
| STRNCAT( buf, "(", len ); |
| |
| STRNCATF( buf, "%s,", ea->base.name, len ); |
| STRNCATF( buf, "%s,", ea->index.name, len ); |
| STRNCATF( buf, "%d", ea->scale, len ); |
| STRNCAT( buf, ")", len ); |
| |
| } else { |
| |
| STRNCAT( buf, "[", len ); |
| |
| if ( ea->base.name[0] ) { |
| STRNCAT( buf, ea->base.name, len ); |
| if ( ea->index.name[0] || |
| (ea->disp_size && ! ea->disp_sign) ) { |
| STRNCAT( buf, "+", len ); |
| } |
| } |
| if ( ea->index.name[0] ) { |
| STRNCAT( buf, ea->index.name, len ); |
| if ( ea->scale > 1 ) |
| { |
| STRNCATF( buf, "*%" PRId32, ea->scale, len ); |
| } |
| if ( ea->disp_size && ! ea->disp_sign ) |
| { |
| STRNCAT( buf, "+", len ); |
| } |
| } |
| |
| if ( ea->disp_size || (! ea->index.name[0] && |
| ! ea->base.name[0] ) ) |
| { |
| PRINT_DISPLACEMENT(ea); |
| } |
| |
| STRNCAT( buf, "]", len ); |
| } |
| |
| return( strlen(buf) ); |
| } |
| |
| static int format_seg( x86_op_t *op, char *buf, int len, |
| enum x86_asm_format format ) { |
| int len_orig = len; |
| const char *reg = ""; |
| |
| if (! op || ! buf || ! len || ! op->flags) { |
| return(0); |
| } |
| if ( op->type != op_offset && op->type != op_expression ){ |
| return(0); |
| } |
| if (! ((int) op->flags & 0xF00) ) { |
| return(0); |
| } |
| |
| switch (op->flags & 0xF00) { |
| case op_es_seg: reg = "es"; break; |
| case op_cs_seg: reg = "cs"; break; |
| case op_ss_seg: reg = "ss"; break; |
| case op_ds_seg: reg = "ds"; break; |
| case op_fs_seg: reg = "fs"; break; |
| case op_gs_seg: reg = "gs"; break; |
| default: |
| break; |
| } |
| |
| if (! reg[0] ) { |
| return( 0 ); |
| } |
| |
| switch( format ) { |
| case xml_syntax: |
| STRNCAT( buf, "\t\t\t<segment ", len ); |
| STRNCATF( buf, "value=\"%s\"/>\n", reg, len ); |
| break; |
| case att_syntax: |
| STRNCATF( buf, "%%%s:", reg, len ); |
| break; |
| |
| default: |
| STRNCATF( buf, "%s:", reg, len ); |
| break; |
| } |
| |
| return( len_orig - len ); /* return length of appended string */ |
| } |
| |
| static const char *get_operand_datatype_str( x86_op_t *op ){ |
| |
| static const char *types[] = { |
| "sbyte", /* 0 */ |
| "sword", |
| "sqword", |
| "sdword", |
| "sdqword", /* 4 */ |
| "byte", |
| "word", |
| "qword", |
| "dword", /* 8 */ |
| "dqword", |
| "sreal", |
| "dreal", |
| "extreal", /* 12 */ |
| "bcd", |
| "ssimd", |
| "dsimd", |
| "sssimd", /* 16 */ |
| "sdsimd", |
| "descr32", |
| "descr16", |
| "pdescr32", /* 20 */ |
| "pdescr16", |
| "bounds16", |
| "bounds32", |
| "fpu_env16", |
| "fpu_env32", /* 25 */ |
| "fpu_state16", |
| "fpu_state32", |
| "fp_reg_set" |
| }; |
| |
| /* handle signed values first */ |
| if ( op->flags & op_signed ) { |
| switch (op->datatype) { |
| case op_byte: return types[0]; |
| case op_word: return types[1]; |
| case op_qword: return types[2]; |
| case op_dqword: return types[4]; |
| default: return types[3]; |
| } |
| } |
| |
| switch (op->datatype) { |
| case op_byte: return types[5]; |
| case op_word: return types[6]; |
| case op_qword: return types[7]; |
| case op_dqword: return types[9]; |
| case op_sreal: return types[10]; |
| case op_dreal: return types[11]; |
| case op_extreal: return types[12]; |
| case op_bcd: return types[13]; |
| case op_ssimd: return types[14]; |
| case op_dsimd: return types[15]; |
| case op_sssimd: return types[16]; |
| case op_sdsimd: return types[17]; |
| case op_descr32: return types[18]; |
| case op_descr16: return types[19]; |
| case op_pdescr32: return types[20]; |
| case op_pdescr16: return types[21]; |
| case op_bounds16: return types[22]; |
| case op_bounds32: return types[23]; |
| case op_fpustate16: return types[24]; |
| case op_fpustate32: return types[25]; |
| case op_fpuenv16: return types[26]; |
| case op_fpuenv32: return types[27]; |
| case op_fpregset: return types[28]; |
| default: return types[8]; |
| } |
| } |
| |
| static int format_insn_eflags_str( enum x86_flag_status flags, char *buf, |
| int len) { |
| |
| static struct { |
| const char *name; |
| int value; |
| } insn_flags[] = { |
| { "carry_set ", 0x0001 }, |
| { "zero_set ", 0x0002 }, |
| { "oflow_set ", 0x0004 }, |
| { "dir_set ", 0x0008 }, |
| { "sign_set ", 0x0010 }, |
| { "parity_set ", 0x0020 }, |
| { "carry_or_zero_set ", 0x0040 }, |
| { "zero_set_or_sign_ne_oflow ", 0x0080 }, |
| { "carry_clear ", 0x0100 }, |
| { "zero_clear ", 0x0200 }, |
| { "oflow_clear ", 0x0400 }, |
| { "dir_clear ", 0x0800 }, |
| { "sign_clear ", 0x1000 }, |
| { "parity_clear ", 0x2000 }, |
| { "sign_eq_oflow ", 0x4000 }, |
| { "sign_ne_oflow ", 0x8000 }, |
| { NULL, 0x0000 }, //end |
| }; |
| |
| unsigned int i; |
| int len_orig = len; |
| |
| for (i = 0; insn_flags[i].name; i++) { |
| if (! (flags & insn_flags[i].value) ) |
| continue; |
| |
| STRNCAT( buf, insn_flags[i].name, len ); |
| } |
| |
| return( len_orig - len ); |
| } |
| |
| static const char *get_insn_group_str( enum x86_insn_group gp ) { |
| |
| static const char *types[] = { |
| "", // 0 |
| "controlflow",// 1 |
| "arithmetic", // 2 |
| "logic", // 3 |
| "stack", // 4 |
| "comparison", // 5 |
| "move", // 6 |
| "string", // 7 |
| "bit_manip", // 8 |
| "flag_manip", // 9 |
| "fpu", // 10 |
| "", // 11 |
| "", // 12 |
| "interrupt", // 13 |
| "system", // 14 |
| "other", // 15 |
| }; |
| |
| if ( gp > sizeof (types)/sizeof(types[0]) ) |
| return ""; |
| |
| return types[gp]; |
| } |
| |
| static const char *get_insn_type_str( enum x86_insn_type type ) { |
| |
| static struct { |
| const char *name; |
| int value; |
| } types[] = { |
| /* insn_controlflow */ |
| { "jmp", 0x1001 }, |
| { "jcc", 0x1002 }, |
| { "call", 0x1003 }, |
| { "callcc", 0x1004 }, |
| { "return", 0x1005 }, |
| { "loop", 0x1006 }, |
| /* insn_arithmetic */ |
| { "add", 0x2001 }, |
| { "sub", 0x2002 }, |
| { "mul", 0x2003 }, |
| { "div", 0x2004 }, |
| { "inc", 0x2005 }, |
| { "dec", 0x2006 }, |
| { "shl", 0x2007 }, |
| { "shr", 0x2008 }, |
| { "rol", 0x2009 }, |
| { "ror", 0x200A }, |
| /* insn_logic */ |
| { "and", 0x3001 }, |
| { "or", 0x3002 }, |
| { "xor", 0x3003 }, |
| { "not", 0x3004 }, |
| { "neg", 0x3005 }, |
| /* insn_stack */ |
| { "push", 0x4001 }, |
| { "pop", 0x4002 }, |
| { "pushregs", 0x4003 }, |
| { "popregs", 0x4004 }, |
| { "pushflags", 0x4005 }, |
| { "popflags", 0x4006 }, |
| { "enter", 0x4007 }, |
| { "leave", 0x4008 }, |
| /* insn_comparison */ |
| { "test", 0x5001 }, |
| { "cmp", 0x5002 }, |
| /* insn_move */ |
| { "mov", 0x6001 }, /* move */ |
| { "movcc", 0x6002 }, /* conditional move */ |
| { "xchg", 0x6003 }, /* exchange */ |
| { "xchgcc", 0x6004 }, /* conditional exchange */ |
| /* insn_string */ |
| { "strcmp", 0x7001 }, |
| { "strload", 0x7002 }, |
| { "strmov", 0x7003 }, |
| { "strstore", 0x7004 }, |
| { "translate", 0x7005 }, /* xlat */ |
| /* insn_bit_manip */ |
| { "bittest", 0x8001 }, |
| { "bitset", 0x8002 }, |
| { "bitclear", 0x8003 }, |
| /* insn_flag_manip */ |
| { "clear_carry", 0x9001 }, |
| { "clear_zero", 0x9002 }, |
| { "clear_oflow", 0x9003 }, |
| { "clear_dir", 0x9004 }, |
| { "clear_sign", 0x9005 }, |
| { "clear_parity", 0x9006 }, |
| { "set_carry", 0x9007 }, |
| { "set_zero", 0x9008 }, |
| { "set_oflow", 0x9009 }, |
| { "set_dir", 0x900A }, |
| { "set_sign", 0x900B }, |
| { "set_parity", 0x900C }, |
| { "tog_carry", 0x9010 }, |
| { "tog_zero", 0x9020 }, |
| { "tog_oflow", 0x9030 }, |
| { "tog_dir", 0x9040 }, |
| { "tog_sign", 0x9050 }, |
| { "tog_parity", 0x9060 }, |
| /* insn_fpu */ |
| { "fmov", 0xA001 }, |
| { "fmovcc", 0xA002 }, |
| { "fneg", 0xA003 }, |
| { "fabs", 0xA004 }, |
| { "fadd", 0xA005 }, |
| { "fsub", 0xA006 }, |
| { "fmul", 0xA007 }, |
| { "fdiv", 0xA008 }, |
| { "fsqrt", 0xA009 }, |
| { "fcmp", 0xA00A }, |
| { "fcos", 0xA00C }, |
| { "fldpi", 0xA00D }, |
| { "fldz", 0xA00E }, |
| { "ftan", 0xA00F }, |
| { "fsine", 0xA010 }, |
| { "fsys", 0xA020 }, |
| /* insn_interrupt */ |
| { "int", 0xD001 }, |
| { "intcc", 0xD002 }, /* not present in x86 ISA */ |
| { "iret", 0xD003 }, |
| { "bound", 0xD004 }, |
| { "debug", 0xD005 }, |
| { "trace", 0xD006 }, |
| { "invalid_op", 0xD007 }, |
| { "oflow", 0xD008 }, |
| /* insn_system */ |
| { "halt", 0xE001 }, |
| { "in", 0xE002 }, /* input from port/bus */ |
| { "out", 0xE003 }, /* output to port/bus */ |
| { "cpuid", 0xE004 }, |
| /* insn_other */ |
| { "nop", 0xF001 }, |
| { "bcdconv", 0xF002 }, /* convert to or from BCD */ |
| { "szconv", 0xF003 }, /* change size of operand */ |
| { NULL, 0 }, //end |
| }; |
| |
| unsigned int i; |
| |
| //go thru every type in the enum |
| for ( i = 0; types[i].name; i++ ) { |
| if ( types[i].value == type ) |
| return types[i].name; |
| } |
| |
| return ""; |
| } |
| |
| static const char *get_insn_cpu_str( enum x86_insn_cpu cpu ) { |
| static const char *intel[] = { |
| "", // 0 |
| "8086", // 1 |
| "80286", // 2 |
| "80386", // 3 |
| "80387", // 4 |
| "80486", // 5 |
| "Pentium", // 6 |
| "Pentium Pro", // 7 |
| "Pentium 2", // 8 |
| "Pentium 3", // 9 |
| "Pentium 4" // 10 |
| }; |
| |
| if ( cpu < sizeof(intel)/sizeof(intel[0]) ) { |
| return intel[cpu]; |
| } else if ( cpu == 16 ) { |
| return "K6"; |
| } else if ( cpu == 32 ) { |
| return "K7"; |
| } else if ( cpu == 48 ) { |
| return "Athlon"; |
| } |
| |
| return ""; |
| } |
| |
| static const char *get_insn_isa_str( enum x86_insn_isa isa ) { |
| static const char *subset[] = { |
| NULL, // 0 |
| "General Purpose", // 1 |
| "Floating Point", // 2 |
| "FPU Management", // 3 |
| "MMX", // 4 |
| "SSE", // 5 |
| "SSE2", // 6 |
| "SSE3", // 7 |
| "3DNow!", // 8 |
| "System" // 9 |
| }; |
| |
| if ( isa > sizeof (subset)/sizeof(subset[0]) ) { |
| return ""; |
| } |
| |
| return subset[isa]; |
| } |
| |
| static int format_operand_att( x86_op_t *op, x86_insn_t *insn, char *buf, |
| int len){ |
| |
| char str[MAX_OP_STRING]; |
| |
| memset (str, 0, sizeof str); |
| |
| switch ( op->type ) { |
| case op_register: |
| STRNCATF( buf, "%%%s", op->data.reg.name, len ); |
| break; |
| |
| case op_immediate: |
| get_operand_data_str( op, str, sizeof str ); |
| STRNCATF( buf, "$%s", str, len ); |
| break; |
| |
| case op_relative_near: |
| STRNCATF( buf, "0x%08X", |
| (unsigned int)(op->data.sbyte + |
| insn->addr + insn->size), len ); |
| break; |
| |
| case op_relative_far: |
| if (op->datatype == op_word) { |
| STRNCATF( buf, "0x%08X", |
| (unsigned int)(op->data.sword + |
| insn->addr + insn->size), len ); |
| } else { |
| STRNCATF( buf, "0x%08X", |
| (unsigned int)(op->data.sdword + |
| insn->addr + insn->size), len ); |
| } |
| break; |
| |
| case op_absolute: |
| /* ATT uses the syntax $section, $offset */ |
| STRNCATF( buf, "$0x%04" PRIX16 ", ", op->data.absolute.segment, |
| len ); |
| if (op->datatype == op_descr16) { |
| STRNCATF( buf, "$0x%04" PRIX16, |
| op->data.absolute.offset.off16, len ); |
| } else { |
| STRNCATF( buf, "$0x%08" PRIX32, |
| op->data.absolute.offset.off32, len ); |
| } |
| break; |
| case op_offset: |
| /* ATT requires a '*' before JMP/CALL ops */ |
| if (insn->type == insn_jmp || insn->type == insn_call) |
| STRNCAT( buf, "*", len ); |
| |
| len -= format_seg( op, buf, len, att_syntax ); |
| STRNCATF( buf, "0x%08" PRIX32, op->data.sdword, len ); |
| break; |
| |
| case op_expression: |
| /* ATT requires a '*' before JMP/CALL ops */ |
| if (insn->type == insn_jmp || insn->type == insn_call) |
| STRNCAT( buf, "*", len ); |
| |
| len -= format_seg( op, buf, len, att_syntax ); |
| len -= format_expr( &op->data.expression, buf, len, |
| att_syntax ); |
| break; |
| case op_unused: |
| case op_unknown: |
| /* return 0-truncated buffer */ |
| break; |
| } |
| |
| return ( strlen( buf ) ); |
| } |
| |
| static int format_operand_native( x86_op_t *op, x86_insn_t *insn, char *buf, |
| int len){ |
| |
| char str[MAX_OP_STRING]; |
| |
| switch (op->type) { |
| case op_register: |
| STRNCAT( buf, op->data.reg.name, len ); |
| break; |
| |
| case op_immediate: |
| get_operand_data_str( op, str, sizeof str ); |
| STRNCAT( buf, str, len ); |
| break; |
| |
| case op_relative_near: |
| STRNCATF( buf, "0x%08" PRIX32, |
| (unsigned int)(op->data.sbyte + |
| insn->addr + insn->size), len ); |
| break; |
| |
| case op_relative_far: |
| if ( op->datatype == op_word ) { |
| STRNCATF( buf, "0x%08" PRIX32, |
| (unsigned int)(op->data.sword + |
| insn->addr + insn->size), len ); |
| break; |
| } else { |
| STRNCATF( buf, "0x%08" PRIX32, op->data.sdword + |
| insn->addr + insn->size, len ); |
| } |
| break; |
| |
| case op_absolute: |
| STRNCATF( buf, "$0x%04" PRIX16 ":", op->data.absolute.segment, |
| len ); |
| if (op->datatype == op_descr16) { |
| STRNCATF( buf, "0x%04" PRIX16, |
| op->data.absolute.offset.off16, len ); |
| } else { |
| STRNCATF( buf, "0x%08" PRIX32, |
| op->data.absolute.offset.off32, len ); |
| } |
| break; |
| |
| case op_offset: |
| len -= format_seg( op, buf, len, native_syntax ); |
| STRNCATF( buf, "[0x%08" PRIX32 "]", op->data.sdword, len ); |
| break; |
| |
| case op_expression: |
| len -= format_seg( op, buf, len, native_syntax ); |
| len -= format_expr( &op->data.expression, buf, len, |
| native_syntax ); |
| break; |
| case op_unused: |
| case op_unknown: |
| /* return 0-truncated buffer */ |
| break; |
| } |
| |
| return( strlen( buf ) ); |
| } |
| |
| static int format_operand_xml( x86_op_t *op, x86_insn_t *insn, char *buf, |
| int len){ |
| |
| char str[MAX_OP_STRING] = "\0"; |
| |
| switch (op->type) { |
| case op_register: |
| |
| get_operand_regtype_str( op->data.reg.type, str, |
| sizeof str ); |
| |
| STRNCAT( buf, "\t\t<register ", len ); |
| STRNCATF( buf, "name=\"%s\" ", op->data.reg.name, len ); |
| STRNCATF( buf, "type=\"%s\" ", str, len ); |
| STRNCATF( buf, "size=%d/>\n", op->data.reg.size, len ); |
| break; |
| |
| case op_immediate: |
| |
| get_operand_data_str( op, str, sizeof str ); |
| |
| STRNCAT( buf, "\t\t<immediate ", len ); |
| STRNCATF( buf, "type=\"%s\" ", |
| get_operand_datatype_str (op), len ); |
| STRNCATF( buf, "value=\"%s\"/>\n", str, len ); |
| break; |
| |
| case op_relative_near: |
| STRNCAT( buf, "\t\t<relative_offset ", len ); |
| |
| STRNCATF( buf, "value=\"0x%08" PRIX32 "\"/>\n", |
| (unsigned int)(op->data.sbyte + |
| insn->addr + insn->size), len ); |
| break; |
| |
| case op_relative_far: |
| STRNCAT( buf, "\t\t<relative_offset ", len ); |
| |
| if (op->datatype == op_word) { |
| STRNCATF( buf, "value=\"0x%08" PRIX32 "\"/>\n", |
| (unsigned int)(op->data.sword + |
| insn->addr + insn->size), len); |
| break; |
| } else { |
| |
| STRNCATF( buf, "value=\"0x%08" PRIX32 "\"/>\n", |
| op->data.sdword + insn->addr + insn->size, |
| len ); |
| } |
| break; |
| |
| case op_absolute: |
| |
| STRNCATF( buf, |
| "\t\t<absolute_address segment=\"0x%04" PRIX16 "\"", |
| op->data.absolute.segment, len ); |
| |
| if (op->datatype == op_descr16) { |
| STRNCATF( buf, "offset=\"0x%04" PRIX16 "\">", |
| op->data.absolute.offset.off16, len ); |
| } else { |
| STRNCATF( buf, "offset=\"0x%08" PRIX32 "\">", |
| op->data.absolute.offset.off32, len ); |
| } |
| |
| STRNCAT( buf, "\t\t</absolute_address>\n", len ); |
| break; |
| |
| case op_expression: |
| |
| |
| STRNCAT( buf, "\t\t<address_expression>\n", len ); |
| |
| len -= format_seg( op, buf, len, xml_syntax ); |
| len -= format_expr( &op->data.expression, buf, len, |
| xml_syntax ); |
| |
| STRNCAT( buf, "\t\t</address_expression>\n", len ); |
| break; |
| |
| case op_offset: |
| |
| STRNCAT( buf, "\t\t<segment_offset>\n", len ); |
| |
| len -= format_seg( op, buf, len, xml_syntax ); |
| |
| STRNCAT( buf, "\t\t\t<address ", len); |
| STRNCATF( buf, "value=\"0x%08" PRIX32 "\"/>\n", |
| op->data.sdword, len ); |
| STRNCAT( buf, "\t\t</segment_offset>\n", len ); |
| break; |
| |
| case op_unused: |
| case op_unknown: |
| /* return 0-truncated buffer */ |
| break; |
| } |
| |
| return( strlen( buf ) ); |
| } |
| |
| static int format_operand_raw( x86_op_t *op, x86_insn_t *insn, char *buf, |
| int len){ |
| |
| char str[MAX_OP_RAW_STRING]; |
| const char *datatype = get_operand_datatype_str(op); |
| |
| switch (op->type) { |
| case op_register: |
| |
| get_operand_regtype_str( op->data.reg.type, str, |
| sizeof str ); |
| |
| STRNCAT( buf, "reg|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| STRNCATF( buf, "%s:", op->data.reg.name, len ); |
| STRNCATF( buf, "%s:", str, len ); |
| STRNCATF( buf, "%d|", op->data.reg.size, len ); |
| break; |
| |
| case op_immediate: |
| |
| get_operand_data_str( op, str, sizeof str ); |
| |
| STRNCAT( buf, "immediate|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| STRNCATF( buf, "%s|", str, len ); |
| break; |
| |
| case op_relative_near: |
| /* NOTE: in raw format, we print the |
| * relative offset, not the actual |
| * address of the jump target */ |
| |
| STRNCAT( buf, "relative|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| STRNCATF( buf, "%" PRId8 "|", op->data.sbyte, len ); |
| break; |
| |
| case op_relative_far: |
| |
| STRNCAT( buf, "relative|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| |
| if (op->datatype == op_word) { |
| STRNCATF( buf, "%" PRId16 "|", op->data.sword, len); |
| break; |
| } else { |
| STRNCATF( buf, "%" PRId32 "|", op->data.sdword, len ); |
| } |
| break; |
| |
| case op_absolute: |
| |
| STRNCAT( buf, "absolute_address|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| |
| STRNCATF( buf, "$0x%04" PRIX16 ":", op->data.absolute.segment, |
| len ); |
| if (op->datatype == op_descr16) { |
| STRNCATF( buf, "0x%04" PRIX16 "|", |
| op->data.absolute.offset.off16, len ); |
| } else { |
| STRNCATF( buf, "0x%08" PRIX32 "|", |
| op->data.absolute.offset.off32, len ); |
| } |
| |
| break; |
| |
| case op_expression: |
| |
| STRNCAT( buf, "address_expression|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| |
| len -= format_seg( op, buf, len, native_syntax ); |
| len -= format_expr( &op->data.expression, buf, len, |
| raw_syntax ); |
| |
| STRNCAT( buf, "|", len ); |
| break; |
| |
| case op_offset: |
| |
| STRNCAT( buf, "segment_offset|", len ); |
| STRNCATF( buf, "%s|", datatype, len ); |
| |
| len -= format_seg( op, buf, len, xml_syntax ); |
| |
| STRNCATF( buf, "%08" PRIX32 "|", op->data.sdword, len ); |
| break; |
| |
| case op_unused: |
| case op_unknown: |
| /* return 0-truncated buffer */ |
| break; |
| } |
| |
| return( strlen( buf ) ); |
| } |
| |
| int x86_format_operand( x86_op_t *op, char *buf, int len, |
| enum x86_asm_format format ){ |
| x86_insn_t *insn; |
| |
| if ( ! op || ! buf || len < 1 ) { |
| return(0); |
| } |
| |
| /* insn is stored in x86_op_t since .21-pre3 */ |
| insn = (x86_insn_t *) op->insn; |
| |
| memset( buf, 0, len ); |
| |
| switch ( format ) { |
| case att_syntax: |
| return format_operand_att( op, insn, buf, len ); |
| case xml_syntax: |
| return format_operand_xml( op, insn, buf, len ); |
| case raw_syntax: |
| return format_operand_raw( op, insn, buf, len ); |
| case native_syntax: |
| case intel_syntax: |
| default: |
| return format_operand_native( op, insn, buf, len ); |
| } |
| } |
| |
| #define is_imm_jmp(op) (op->type == op_absolute || \ |
| op->type == op_immediate || \ |
| op->type == op_offset) |
| #define is_memory_op(op) (op->type == op_absolute || \ |
| op->type == op_expression || \ |
| op->type == op_offset) |
| |
| static int format_att_mnemonic( x86_insn_t *insn, char *buf, int len) { |
| int size = 0; |
| const char *suffix; |
| |
| if (! insn || ! buf || ! len ) |
| return(0); |
| |
| memset( buf, 0, len ); |
| |
| /* do long jump/call prefix */ |
| if ( insn->type == insn_jmp || insn->type == insn_call ) { |
| if (! is_imm_jmp( x86_operand_1st(insn) ) || |
| (x86_operand_1st(insn))->datatype != op_byte ) { |
| /* far jump/call, use "l" prefix */ |
| STRNCAT( buf, "l", len ); |
| } |
| STRNCAT( buf, insn->mnemonic, len ); |
| |
| return ( strlen( buf ) ); |
| } |
| |
| /* do mnemonic */ |
| STRNCAT( buf, insn->mnemonic, len ); |
| |
| /* do suffixes for memory operands */ |
| if (!(insn->note & insn_note_nosuffix) && |
| (insn->group == insn_arithmetic || |
| insn->group == insn_logic || |
| insn->group == insn_move || |
| insn->group == insn_stack || |
| insn->group == insn_string || |
| insn->group == insn_comparison || |
| insn->type == insn_in || |
| insn->type == insn_out |
| )) { |
| if ( x86_operand_count( insn, op_explicit ) > 0 && |
| is_memory_op( x86_operand_1st(insn) ) ){ |
| size = x86_operand_size( x86_operand_1st( insn ) ); |
| } else if ( x86_operand_count( insn, op_explicit ) > 1 && |
| is_memory_op( x86_operand_2nd(insn) ) ){ |
| size = x86_operand_size( x86_operand_2nd( insn ) ); |
| } |
| } |
| |
| if ( size == 1 ) suffix = "b"; |
| else if ( size == 2 ) suffix = "w"; |
| else if ( size == 4 ) suffix = "l"; |
| else if ( size == 8 ) suffix = "q"; |
| else suffix = ""; |
| |
| STRNCAT( buf, suffix, len ); |
| return ( strlen( buf ) ); |
| } |
| |
| int x86_format_mnemonic(x86_insn_t *insn, char *buf, int len, |
| enum x86_asm_format format){ |
| char str[MAX_OP_STRING]; |
| |
| memset( buf, 0, len ); |
| STRNCAT( buf, insn->prefix_string, len ); |
| if ( format == att_syntax ) { |
| format_att_mnemonic( insn, str, sizeof str ); |
| STRNCAT( buf, str, len ); |
| } else { |
| STRNCAT( buf, insn->mnemonic, len ); |
| } |
| |
| return( strlen( buf ) ); |
| } |
| |
| struct op_string { char *buf; size_t len; }; |
| |
| static void format_op_raw( x86_op_t *op, x86_insn_t *insn, void *arg ) { |
| struct op_string * opstr = (struct op_string *) arg; |
| |
| format_operand_raw(op, insn, opstr->buf, opstr->len); |
| } |
| |
| static int format_insn_note(x86_insn_t *insn, char *buf, int len){ |
| char note[32] = {0}; |
| int len_orig = len, note_len = 32; |
| |
| if ( insn->note & insn_note_ring0 ) { |
| STRNCATF( note, "%s", "Ring0 ", note_len ); |
| } |
| if ( insn->note & insn_note_smm ) { |
| STRNCATF( note, "%s", "SMM ", note_len ); |
| } |
| if ( insn->note & insn_note_serial ) { |
| STRNCATF(note, "%s", "Serialize ", note_len ); |
| } |
| STRNCATF( buf, "%s|", note, len ); |
| |
| return( len_orig - len ); |
| } |
| |
| static int format_raw_insn( x86_insn_t *insn, char *buf, int len ){ |
| struct op_string opstr = { buf, len }; |
| int i; |
| |
| /* RAW style: |
| * ADDRESS|OFFSET|SIZE|BYTES| |
| * PREFIX|PREFIX_STRING|GROUP|TYPE|NOTES| |
| * MNEMONIC|CPU|ISA|FLAGS_SET|FLAGS_TESTED| |
| * STACK_MOD|STACK_MOD_VAL |
| * [|OP_TYPE|OP_DATATYPE|OP_ACCESS|OP_FLAGS|OP]* |
| * |
| * Register values are encoded as: |
| * NAME:TYPE:SIZE |
| * |
| * Effective addresses are encoded as: |
| * disp(base_reg,index_reg,scale) |
| */ |
| STRNCATF( buf, "0x%08" PRIX32 "|", insn->addr , len ); |
| STRNCATF( buf, "0x%08" PRIX32 "|", insn->offset, len ); |
| STRNCATF( buf, "%d|" , insn->size , len ); |
| |
| /* print bytes */ |
| for ( i = 0; i < insn->size; i++ ) { |
| STRNCATF( buf, "%02X ", insn->bytes[i], len ); |
| } |
| STRNCAT( buf, "|", len ); |
| |
| len -= format_insn_prefix_str( insn->prefix, buf, len ); |
| STRNCATF( buf, "|%s|", insn->prefix_string , len ); |
| STRNCATF( buf, "%s|", get_insn_group_str( insn->group ), len ); |
| STRNCATF( buf, "%s|", get_insn_type_str( insn->type ) , len ); |
| STRNCATF( buf, "%s|", insn->mnemonic , len ); |
| STRNCATF( buf, "%s|", get_insn_cpu_str( insn->cpu ) , len ); |
| STRNCATF( buf, "%s|", get_insn_isa_str( insn->isa ) , len ); |
| |
| /* insn note */ |
| len -= format_insn_note( insn, buf, len ); |
| |
| len -= format_insn_eflags_str( insn->flags_set, buf, len ); |
| STRNCAT( buf, "|", len ); |
| len -= format_insn_eflags_str( insn->flags_tested, buf, len ); |
| STRNCAT( buf, "|", len ); |
| STRNCATF( buf, "%d|", insn->stack_mod, len ); |
| STRNCATF( buf, "%" PRId32 "|", insn->stack_mod_val, len ); |
| |
| opstr.len = len; |
| x86_operand_foreach( insn, format_op_raw, &opstr, op_any ); |
| |
| return( strlen (buf) ); |
| } |
| |
| static int format_xml_insn( x86_insn_t *insn, char *buf, int len ) { |
| char str[MAX_OP_XML_STRING]; |
| int i; |
| |
| STRNCAT( buf, "<x86_insn>\n", len ); |
| |
| STRNCATF( buf, "\t<address rva=\"0x%08" PRIX32 "\" ", insn->addr, len ); |
| STRNCATF( buf, "offset=\"0x%08" PRIX32 "\" ", insn->offset, len ); |
| STRNCATF( buf, "size=%d bytes=\"", insn->size, len ); |
| |
| for ( i = 0; i < insn->size; i++ ) { |
| STRNCATF( buf, "%02X ", insn->bytes[i], len ); |
| } |
| STRNCAT( buf, "\"/>\n", len ); |
| |
| STRNCAT( buf, "\t<prefix type=\"", len ); |
| len -= format_insn_prefix_str( insn->prefix, buf, len ); |
| STRNCATF( buf, "\" string=\"%s\"/>\n", insn->prefix_string, len ); |
| |
| STRNCATF( buf, "\t<mnemonic group=\"%s\" ", |
| get_insn_group_str (insn->group), len ); |
| STRNCATF( buf, "type=\"%s\" ", get_insn_type_str (insn->type), len ); |
| STRNCATF( buf, "string=\"%s\"/>\n", insn->mnemonic, len ); |
| |
| STRNCAT( buf, "\t<flags type=set>\n", len ); |
| STRNCAT( buf, "\t\t<flag name=\"", len ); |
| len -= format_insn_eflags_str( insn->flags_set, buf, len ); |
| STRNCAT( buf, "\"/>\n\t</flags>\n", len ); |
| |
| |
| STRNCAT( buf, "\t<flags type=tested>\n", len ); |
| STRNCAT( buf, "\t\t<flag name=\"", len ); |
| len -= format_insn_eflags_str( insn->flags_tested, buf, len ); |
| STRNCAT( buf, "\"/>\n\t</flags>\n", len ); |
| |
| if ( x86_operand_1st( insn ) ) { |
| x86_format_operand( x86_operand_1st(insn), str, |
| sizeof str, xml_syntax); |
| STRNCAT( buf, "\t<operand name=dest>\n", len ); |
| STRNCAT( buf, str, len ); |
| STRNCAT( buf, "\t</operand>\n", len ); |
| } |
| |
| if ( x86_operand_2nd( insn ) ) { |
| x86_format_operand( x86_operand_2nd( insn ), str, |
| sizeof str, xml_syntax); |
| STRNCAT( buf, "\t<operand name=src>\n", len ); |
| STRNCAT( buf, str, len ); |
| STRNCAT( buf, "\t</operand>\n", len ); |
| } |
| |
| if ( x86_operand_3rd( insn ) ) { |
| x86_format_operand( x86_operand_3rd(insn), str, |
| sizeof str, xml_syntax); |
| STRNCAT( buf, "\t<operand name=imm>\n", len ); |
| STRNCAT( buf, str, len ); |
| STRNCAT( buf, "\t</operand>\n", len ); |
| } |
| |
| STRNCAT( buf, "</x86_insn>\n", len ); |
| |
| return strlen (buf); |
| } |
| |
| int x86_format_header( char *buf, int len, enum x86_asm_format format ) { |
| switch (format) { |
| case att_syntax: |
| snprintf( buf, len, "MNEMONIC\tSRC, DEST, IMM" ); |
| break; |
| case intel_syntax: |
| snprintf( buf, len, "MNEMONIC\tDEST, SRC, IMM" ); |
| break; |
| case native_syntax: |
| snprintf( buf, len, "ADDRESS\tBYTES\tMNEMONIC\t" |
| "DEST\tSRC\tIMM" ); |
| break; |
| case raw_syntax: |
| snprintf( buf, len, "ADDRESS|OFFSET|SIZE|BYTES|" |
| "PREFIX|PREFIX_STRING|GROUP|TYPE|NOTES|" |
| "MNEMONIC|CPU|ISA|FLAGS_SET|FLAGS_TESTED|" |
| "STACK_MOD|STACK_MOD_VAL" |
| "[|OP_TYPE|OP_DATATYPE|OP_ACCESS|OP_FLAGS|OP]*" |
| ); |
| break; |
| case xml_syntax: |
| snprintf( buf, len, |
| "<x86_insn>" |
| "<address rva= offset= size= bytes=/>" |
| "<prefix type= string=/>" |
| "<mnemonic group= type= string= " |
| "cpu= isa= note= />" |
| "<flags type=set>" |
| "<flag name=>" |
| "</flags>" |
| "<stack_mod val= >" |
| "<flags type=tested>" |
| "<flag name=>" |
| "</flags>" |
| "<operand name=>" |
| "<register name= type= size=/>" |
| "<immediate type= value=/>" |
| "<relative_offset value=/>" |
| "<absolute_address value=>" |
| "<segment value=/>" |
| "</absolute_address>" |
| "<address_expression>" |
| "<segment value=/>" |
| "<base>" |
| "<register name= type= size=/>" |
| "</base>" |
| "<index>" |
| "<register name= type= size=/>" |
| "</index>" |
| "<scale>" |
| "<immediate value=/>" |
| "</scale>" |
| "<displacement>" |
| "<immediate value=/>" |
| "<address value=/>" |
| "</displacement>" |
| "</address_expression>" |
| "<segment_offset>" |
| "<address value=/>" |
| "</segment_offset>" |
| "</operand>" |
| "</x86_insn>" |
| ); |
| break; |
| case unknown_syntax: |
| if ( len ) { |
| buf[0] = '\0'; |
| } |
| break; |
| } |
| |
| return( strlen(buf) ); |
| } |
| |
| int x86_format_insn( x86_insn_t *insn, char *buf, int len, |
| enum x86_asm_format format ){ |
| char str[MAX_OP_STRING]; |
| x86_op_t *src, *dst; |
| int i; |
| |
| memset(buf, 0, len); |
| if ( format == intel_syntax ) { |
| /* INTEL STYLE: mnemonic dest, src, imm */ |
| STRNCAT( buf, insn->prefix_string, len ); |
| STRNCAT( buf, insn->mnemonic, len ); |
| STRNCAT( buf, "\t", len ); |
| |
| /* dest */ |
| if ( (dst = x86_operand_1st( insn )) && !(dst->flags & op_implied) ) { |
| x86_format_operand( dst, str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| } |
| |
| /* src */ |
| if ( (src = x86_operand_2nd( insn )) ) { |
| if ( !(dst->flags & op_implied) ) { |
| STRNCAT( buf, ", ", len ); |
| } |
| x86_format_operand( src, str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| } |
| |
| /* imm */ |
| if ( x86_operand_3rd( insn )) { |
| STRNCAT( buf, ", ", len ); |
| x86_format_operand( x86_operand_3rd( insn ), |
| str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| } |
| |
| } else if ( format == att_syntax ) { |
| /* ATT STYLE: mnemonic src, dest, imm */ |
| STRNCAT( buf, insn->prefix_string, len ); |
| format_att_mnemonic(insn, str, MAX_OP_STRING); |
| STRNCATF( buf, "%s\t", str, len); |
| |
| |
| /* not sure which is correct? sometimes GNU as requires |
| * an imm as the first operand, sometimes as the third... */ |
| /* imm */ |
| if ( x86_operand_3rd( insn ) ) { |
| x86_format_operand(x86_operand_3rd( insn ), |
| str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| /* there is always 'dest' operand if there is 'src' */ |
| STRNCAT( buf, ", ", len ); |
| } |
| |
| if ( (insn->note & insn_note_nonswap ) == 0 ) { |
| /* regular AT&T style swap */ |
| src = x86_operand_2nd( insn ); |
| dst = x86_operand_1st( insn ); |
| } |
| else { |
| /* special-case instructions */ |
| src = x86_operand_1st( insn ); |
| dst = x86_operand_2nd( insn ); |
| } |
| |
| /* src */ |
| if ( src ) { |
| x86_format_operand(src, str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| /* there is always 'dest' operand if there is 'src' */ |
| if ( dst && !(dst->flags & op_implied) ) { |
| STRNCAT( buf, ", ", len ); |
| } |
| } |
| |
| /* dest */ |
| if ( dst && !(dst->flags & op_implied) ) { |
| x86_format_operand( dst, str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| } |
| |
| |
| } else if ( format == raw_syntax ) { |
| format_raw_insn( insn, buf, len ); |
| } else if ( format == xml_syntax ) { |
| format_xml_insn( insn, buf, len ); |
| } else { /* default to native */ |
| /* NATIVE style: RVA\tBYTES\tMNEMONIC\tOPERANDS */ |
| /* print address */ |
| STRNCATF( buf, "%08" PRIX32 "\t", insn->addr, len ); |
| |
| /* print bytes */ |
| for ( i = 0; i < insn->size; i++ ) { |
| STRNCATF( buf, "%02X ", insn->bytes[i], len ); |
| } |
| |
| STRNCAT( buf, "\t", len ); |
| |
| /* print mnemonic */ |
| STRNCAT( buf, insn->prefix_string, len ); |
| STRNCAT( buf, insn->mnemonic, len ); |
| STRNCAT( buf, "\t", len ); |
| |
| /* print operands */ |
| /* dest */ |
| if ( x86_operand_1st( insn ) ) { |
| x86_format_operand( x86_operand_1st( insn ), |
| str, MAX_OP_STRING, format); |
| STRNCATF( buf, "%s\t", str, len ); |
| } |
| |
| /* src */ |
| if ( x86_operand_2nd( insn ) ) { |
| x86_format_operand(x86_operand_2nd( insn ), |
| str, MAX_OP_STRING, format); |
| STRNCATF( buf, "%s\t", str, len ); |
| } |
| |
| /* imm */ |
| if ( x86_operand_3rd( insn )) { |
| x86_format_operand( x86_operand_3rd( insn ), |
| str, MAX_OP_STRING, format); |
| STRNCAT( buf, str, len ); |
| } |
| } |
| |
| return( strlen( buf ) ); |
| } |
| |
