static int format_operand_raw( x86_op_t *op, x86_insn_t *insn, char *buf,
int len){
char str[MAX_OP_RAW_STRING];
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, "%hhd|", 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, "%hd|", op->data.sword, len);
break;
} else {
STRNCATF( buf, "%d|", op->data.sdword, len );
}
break;
case op_absolute:
STRNCAT( buf, "absolute_address|", len );
STRNCATF( buf, "%s|", datatype, len );
STRNCATF( buf, "$0x%04hX:", op->data.absolute.segment,
len );
if (op->datatype == op_descr16) {
STRNCATF( buf, "0x%04hX|",
op->data.absolute.offset.off16, len );
} else {
STRNCATF( buf, "0x%08X|",
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, "%08X|", op->data.sdword, len );
break;
case op_unused:
case op_unknown:
/* return 0-truncated buffer */
break;
}
return( strlen( buf ) );
}
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%X", 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%X" "\"/>\n", ea->disp,
len);
} else {
STRNCAT (buf, "\t\t\t\t<immediate ", len);
STRNCATF (buf, "value=%d" "/>\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, "*%d", 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_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%08X\"/>\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%08X\"/>\n",
(unsigned int)(op->data.sword +
insn->addr + insn->size), len);
break;
} else {
STRNCATF( buf, "value=\"0x%08X\"/>\n",
op->data.sdword + insn->addr + insn->size,
len );
}
break;
case op_absolute:
STRNCATF( buf,
"\t\t<absolute_address segment=\"0x%04hX\"",
op->data.absolute.segment, len );
if (op->datatype == op_descr16) {
STRNCATF( buf, "offset=\"0x%04hX\">",
op->data.absolute.offset.off16, len );
} else {
STRNCATF( buf, "offset=\"0x%08X\">",
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%08X\"/>\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];
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:
STRNCAT( buf, "relative|", len );
STRNCATF( buf, "%s|", datatype, len );
STRNCATF( buf, "%08X|",
(unsigned int)(op->data.sbyte +
insn->addr + insn->size), len );
break;
case op_relative_far:
STRNCAT( buf, "relative|", len );
STRNCATF( buf, "%s|", datatype, len );
if (op->datatype == op_word) {
STRNCATF( buf, "%08X",
(unsigned int)(op->data.sword +
insn->addr + insn->size), len);
break;
} else {
STRNCATF( buf, "%08lX|",
op->data.sdword + insn->addr + insn->size,
len );
}
break;
case op_absolute:
STRNCAT( buf, "absolute_address|", len );
STRNCATF( buf, "%s|", datatype, len );
len -= format_seg( op, buf, len, native_syntax );
STRNCATF( buf, "%08lX|", op->data.sdword, 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, "%08lX|", op->data.sdword, len );
break;
case op_unused:
case op_unknown:
/* return 0-truncated buffer */
break;
}
return( strlen( buf ) );
}
