| OLD | NEW |
|---|
| (Empty) |
| 1 %module x86disasm | |
| 2 %{ | |
| 3 #include "../../libdis.h" | |
| 4 #include "../../../config.h" | |
| 5 %} | |
| 6 | |
| 7 %rename(version_string) x86_version_string; | |
| 8 %include "../../libdis.h" | |
| 9 #include "../../../config.h" | |
| 10 | |
| 11 %inline %{ | |
| 12 const char * x86_version_string( void ) { | |
| 13 return PACKAGE_VERSION; | |
| 14 } | |
| 15 %} | |
| 16 | |
| 17 %rename(report_codes) x86_report_codes; | |
| 18 %rename(report_error) x86_report_error; | |
| 19 %rename(options) x86_options; | |
| 20 %rename(init) x86_init; | |
| 21 %rename(set_reporter) x86_set_reporter; | |
| 22 %rename(set_options) x86_set_options; | |
| 23 %rename(options) x86_get_options; | |
| 24 %rename(cleanup) x86_cleanup; | |
| 25 %rename(reg_type) x86_reg_type; | |
| 26 %rename(reg) x86_reg_t; | |
| 27 %rename(eaddr) x86_ea_t; | |
| 28 %rename(op_type) x86_op_type; | |
| 29 %rename(optype_is_address) x86_optype_is_address; | |
| 30 %rename(optype_is_relative) x86_optype_is_relative; | |
| 31 %rename(op_datatype) x86_op_datatype; | |
| 32 %rename(op_access) x86_op_access; | |
| 33 %rename(op_flags) x86_op_flags; | |
| 34 %rename(operand) x86_op_t; | |
| 35 %rename(insn_group) x86_insn_group; | |
| 36 %rename(insn_type) x86_insn_type; | |
| 37 %rename(insn_note) x86_insn_note ; | |
| 38 %rename(flag_status) x86_flag_status; | |
| 39 %rename(insn_cpu) x86_insn_cpu ; | |
| 40 %rename(insn_isa) x86_insn_isa ; | |
| 41 %rename(insn_prefix) x86_insn_prefix ; | |
| 42 %rename(insn) x86_insn_t; | |
| 43 %rename(insn_is_valid) x86_insn_is_valid; | |
| 44 %rename(i_disasm) x86_disasm; | |
| 45 %rename(i_disasm_range) x86_disasm_range; | |
| 46 %rename(i_disasm_forward) x86_disasm_forward; | |
| 47 %rename(insn_operand_count) x86_operand_count; | |
| 48 %rename(insn_operand_1st) x86_operand_1st; | |
| 49 %rename(insn_operand_2nd) x86_operand_2nd; | |
| 50 %rename(insn_operand_3rd) x86_operand_3rd; | |
| 51 %rename(insn_dest_operand) x86_get_dest_operand; | |
| 52 %rename(insn_src_operand) x86_get_src_operand; | |
| 53 %rename(insn_imm_operand) x86_get_imm_operand; | |
| 54 %rename(operand_size) x86_operand_size; | |
| 55 %rename(insn_rel_offset) x86_get_rel_offset; | |
| 56 %rename(insn_branch_target) x86_get_branch_target; | |
| 57 %rename(insn_imm) x86_get_imm; | |
| 58 %rename(insn_raw_imm) x86_get_raw_imm; | |
| 59 %rename(insn_set_addr) x86_set_insn_addr; | |
| 60 %rename(insn_set_offset) x86_set_insn_offset; | |
| 61 %rename(insn_set_function) x86_set_insn_function; | |
| 62 %rename(insn_set_block) x86_set_insn_block; | |
| 63 %rename(insn_tag) x86_tag_insn; | |
| 64 %rename(insn_untag) x86_untag_insn; | |
| 65 %rename(insn_is_tagged) x86_insn_is_tagged; | |
| 66 %rename(asm_format) x86_asm_format; | |
| 67 %rename(operand_format) x86_format_operand; | |
| 68 %rename(insn_format_mnemonic) x86_format_mnemonic; | |
| 69 %rename(insn_format) x86_format_insn; | |
| 70 %rename(header_format) x86_format_header; | |
| 71 %rename(endian) x86_endian; | |
| 72 %rename(size_default_address) x86_addr_size; | |
| 73 %rename(size_default_operand) x86_op_size; | |
| 74 %rename(size_machine_word) x86_word_size; | |
| 75 %rename(size_max_insn) x86_max_insn_size; | |
| 76 %rename(reg_sp) x86_sp_reg; | |
| 77 %rename(reg_fp) x86_fp_reg; | |
| 78 %rename(reg_ip) x86_ip_reg; | |
| 79 %rename(reg_from_id) x86_reg_from_id; | |
| 80 %rename(reg_from_alias) x86_get_aliased_reg; | |
| 81 %rename(invariant_op) x86_invariant_op_t; | |
| 82 %rename(invariant) x86_invariant_t; | |
| 83 %rename(disasm_invariant) x86_invariant_disasm; | |
| 84 %rename(disasm_size) x86_size_disasm; | |
| 85 | |
| 86 %include "carrays.i" | |
| 87 | |
| 88 %array_class( unsigned char, byteArray ); | |
| 89 | |
| 90 | |
| 91 %apply (unsigned char *STRING, int LENGTH) { | |
| 92 (unsigned char *buf, size_t buf_len) | |
| 93 }; | |
| 94 | |
| 95 | |
| 96 %newobject x86_op_copy; | |
| 97 %inline %{ | |
| 98 x86_op_t * x86_op_copy( x86_op_t * src ) { | |
| 99 x86_op_t *op; | |
| 100 | |
| 101 if (! src ) { | |
| 102 return NULL; | |
| 103 } | |
| 104 | |
| 105 op = (x86_op_t *) calloc( sizeof(x86_op_t), 1 ); | |
| 106 if ( op ) { | |
| 107 memcpy( op, src, sizeof(x86_op_t) ); | |
| 108 } | |
| 109 | |
| 110 return op; | |
| 111 } | |
| 112 | |
| 113 typedef struct x86_op_list_node { | |
| 114 x86_op_t *op; | |
| 115 struct x86_op_list_node *next, *prev; | |
| 116 } x86_op_list_node; | |
| 117 | |
| 118 typedef struct x86_op_list { | |
| 119 size_t count; | |
| 120 x86_op_list_node *head, *tail, *curr; | |
| 121 } x86_op_list; | |
| 122 | |
| 123 x86_op_list * x86_op_list_new () { | |
| 124 x86_op_list *list = (x86_op_list *) | |
| 125 calloc( sizeof(x86_op_list), 1 ); | |
| 126 list->count = 0; | |
| 127 return list; | |
| 128 } | |
| 129 | |
| 130 void x86_op_list_free(x86_op_list *list) { | |
| 131 x86_op_list_node *node, *next; | |
| 132 | |
| 133 node = list->head; | |
| 134 while ( node ) { | |
| 135 next = node->next; | |
| 136 /* free( node->insn ); */ | |
| 137 free( node ); | |
| 138 node = next; | |
| 139 } | |
| 140 | |
| 141 free( list ); | |
| 142 } | |
| 143 | |
| 144 x86_op_list_node * x86_op_list_first(x86_op_list *list) { | |
| 145 return list->head; | |
| 146 } | |
| 147 | |
| 148 x86_op_list_node * x86_op_list_last(x86_op_list *list) { | |
| 149 return list->tail; | |
| 150 } | |
| 151 | |
| 152 x86_op_list_node * x86_op_list_next(x86_op_list *list) { | |
| 153 if (! list->curr ) { | |
| 154 list->curr = list->head; | |
| 155 return list->head; | |
| 156 } | |
| 157 | |
| 158 list->curr = list->curr->next; | |
| 159 return list->curr; | |
| 160 } | |
| 161 | |
| 162 x86_op_list_node * x86_op_list_prev(x86_op_list *list) { | |
| 163 if (! list->curr ) { | |
| 164 list->curr = list->tail; | |
| 165 return list->tail; | |
| 166 } | |
| 167 | |
| 168 list->curr = list->curr->prev; | |
| 169 return list->curr; | |
| 170 } | |
| 171 | |
| 172 %} | |
| 173 | |
| 174 %newobject x86_op_list_append; | |
| 175 | |
| 176 %inline %{ | |
| 177 void x86_op_list_append( x86_op_list * list, x86_op_t *op ) { | |
| 178 x86_op_list_node *node = (x86_op_list_node *) | |
| 179 calloc( sizeof(x86_op_list_node) , 1 ); | |
| 180 if (! node ) { | |
| 181 return; | |
| 182 } | |
| 183 | |
| 184 list->count++; | |
| 185 if ( ! list->tail ) { | |
| 186 list->head = list->tail = node; | |
| 187 } else { | |
| 188 list->tail->next = node; | |
| 189 node->prev = list->tail; | |
| 190 list->tail = node; | |
| 191 } | |
| 192 | |
| 193 node->op = x86_op_copy( op ); | |
| 194 } | |
| 195 | |
| 196 x86_oplist_t * x86_op_list_node_copy( x86_oplist_t * list ) { | |
| 197 x86_oplist_t *ptr; | |
| 198 ptr = (x86_oplist_t *) calloc( sizeof(x86_oplist_t), 1 ); | |
| 199 if ( ptr ) { | |
| 200 memcpy( &ptr->op, &list->op, sizeof(x86_op_t) ); | |
| 201 } | |
| 202 | |
| 203 return ptr; | |
| 204 } | |
| 205 | |
| 206 x86_insn_t * x86_insn_new() { | |
| 207 x86_insn_t *insn = (x86_insn_t *) | |
| 208 calloc( sizeof(x86_insn_t), 1 ); | |
| 209 return insn; | |
| 210 } | |
| 211 | |
| 212 void x86_insn_free( x86_insn_t *insn ) { | |
| 213 x86_oplist_free( insn ); | |
| 214 free( insn ); | |
| 215 } | |
| 216 %} | |
| 217 | |
| 218 %newobject x86_insn_copy; | |
| 219 | |
| 220 %inline %{ | |
| 221 x86_insn_t * x86_insn_copy( x86_insn_t *src) { | |
| 222 x86_oplist_t *ptr, *list, *last = NULL; | |
| 223 x86_insn_t *insn = (x86_insn_t *) | |
| 224 calloc( sizeof(x86_insn_t), 1 ); | |
| 225 | |
| 226 if ( insn ) { | |
| 227 memcpy( insn, src, sizeof(x86_insn_t) ); | |
| 228 insn->operands = NULL; | |
| 229 insn->block = NULL; | |
| 230 insn->function = NULL; | |
| 231 | |
| 232 /* copy operand list */ | |
| 233 for ( list = src->operands; list; list = list->next ) { | |
| 234 ptr = x86_op_list_node_copy( list ); | |
| 235 | |
| 236 if (! ptr ) { | |
| 237 continue; | |
| 238 } | |
| 239 | |
| 240 if ( insn->operands ) { | |
| 241 last->next = ptr; | |
| 242 } else { | |
| 243 insn->operands = ptr; | |
| 244 } | |
| 245 last = ptr; | |
| 246 } | |
| 247 } | |
| 248 | |
| 249 return insn; | |
| 250 } | |
| 251 | |
| 252 x86_op_list * x86_insn_op_list( x86_insn_t *insn ) { | |
| 253 x86_oplist_t *list = insn->operands; | |
| 254 x86_op_list *op_list = x86_op_list_new(); | |
| 255 | |
| 256 for ( list = insn->operands; list; list = list->next ) { | |
| 257 x86_op_list_append( op_list, &list->op ); | |
| 258 } | |
| 259 | |
| 260 return op_list; | |
| 261 } | |
| 262 | |
| 263 typedef struct x86_insn_list_node { | |
| 264 x86_insn_t *insn; | |
| 265 struct x86_insn_list_node *next, *prev; | |
| 266 } x86_insn_list_node; | |
| 267 | |
| 268 typedef struct x86_insn_list { | |
| 269 size_t count; | |
| 270 x86_insn_list_node *head, *tail, *curr; | |
| 271 } x86_insn_list; | |
| 272 | |
| 273 %} | |
| 274 | |
| 275 %newobject x86_insn_list_new; | |
| 276 | |
| 277 %inline %{ | |
| 278 x86_insn_list * x86_insn_list_new () { | |
| 279 x86_insn_list *list = (x86_insn_list *) | |
| 280 calloc( sizeof(x86_insn_list), 1 ); | |
| 281 list->count = 0; | |
| 282 return list; | |
| 283 } | |
| 284 | |
| 285 void x86_insn_list_free( x86_insn_list * list ) { | |
| 286 x86_insn_list_node *node, *next; | |
| 287 | |
| 288 if (! list ) { | |
| 289 return; | |
| 290 } | |
| 291 | |
| 292 node = list->head; | |
| 293 while ( node ) { | |
| 294 next = node->next; | |
| 295 /* free( node->insn ); */ | |
| 296 free( node ); | |
| 297 node = next; | |
| 298 } | |
| 299 | |
| 300 free( list ); | |
| 301 } | |
| 302 | |
| 303 x86_insn_list_node * x86_insn_list_first( x86_insn_list *list ) { | |
| 304 if (! list ) { | |
| 305 return NULL; | |
| 306 } | |
| 307 return list->head; | |
| 308 } | |
| 309 | |
| 310 x86_insn_list_node * x86_insn_list_last( x86_insn_list *list ) { | |
| 311 if (! list ) { | |
| 312 return NULL; | |
| 313 } | |
| 314 return list->tail; | |
| 315 } | |
| 316 | |
| 317 x86_insn_list_node * x86_insn_list_next( x86_insn_list *list ) { | |
| 318 if (! list ) { | |
| 319 return NULL; | |
| 320 } | |
| 321 if (! list->curr ) { | |
| 322 list->curr = list->head; | |
| 323 return list->head; | |
| 324 } | |
| 325 | |
| 326 list->curr = list->curr->next; | |
| 327 return list->curr; | |
| 328 } | |
| 329 | |
| 330 x86_insn_list_node * x86_insn_list_prev( x86_insn_list *list ) { | |
| 331 if (! list ) { | |
| 332 return NULL; | |
| 333 } | |
| 334 if (! list->curr ) { | |
| 335 list->curr = list->tail; | |
| 336 return list->tail; | |
| 337 } | |
| 338 | |
| 339 list->curr = list->curr->prev; | |
| 340 return list->curr; | |
| 341 } | |
| 342 | |
| 343 %} | |
| 344 | |
| 345 %newobject x86_insn_list_append; | |
| 346 | |
| 347 %inline %{ | |
| 348 void x86_insn_list_append( x86_insn_list *list, x86_insn_t *insn ) { | |
| 349 x86_insn_list_node *node; | |
| 350 if (! list ) { | |
| 351 return; | |
| 352 } | |
| 353 | |
| 354 node = (x86_insn_list_node *) | |
| 355 calloc( sizeof(x86_insn_list_node) , 1 )
; | |
| 356 | |
| 357 if (! node ) { | |
| 358 return; | |
| 359 } | |
| 360 | |
| 361 list->count++; | |
| 362 if ( ! list->tail ) { | |
| 363 list->head = list->tail = node; | |
| 364 } else { | |
| 365 list->tail->next = node; | |
| 366 node->prev = list->tail; | |
| 367 list->tail = node; | |
| 368 } | |
| 369 | |
| 370 node->insn = x86_insn_copy( insn ); | |
| 371 } | |
| 372 | |
| 373 typedef struct { | |
| 374 enum x86_report_codes last_error; | |
| 375 void * last_error_data; | |
| 376 void * disasm_callback; | |
| 377 void * disasm_resolver; | |
| 378 } x86disasm; | |
| 379 | |
| 380 void x86_default_reporter( enum x86_report_codes code, | |
| 381 void *data, void *arg ) { | |
| 382 x86disasm *dis = (x86disasm *) arg; | |
| 383 if ( dis ) { | |
| 384 dis->last_error = code; | |
| 385 dis->last_error_data = data; | |
| 386 } | |
| 387 } | |
| 388 | |
| 389 void x86_default_callback( x86_insn_t *insn, void *arg ) { | |
| 390 x86_insn_list *list = (x86_insn_list *) arg; | |
| 391 if ( list ) { | |
| 392 x86_insn_list_append( list, insn ); | |
| 393 } | |
| 394 } | |
| 395 | |
| 396 /* TODO: resolver stack, maybe a callback */ | |
| 397 long x86_default_resolver( x86_op_t *op, x86_insn_t *insn, void *arg ) { | |
| 398 x86disasm *dis = (x86disasm *) arg; | |
| 399 if ( dis ) { | |
| 400 //return dis->resolver( op, insn ); | |
| 401 return 0; | |
| 402 } | |
| 403 | |
| 404 return 0; | |
| 405 } | |
| 406 | |
| 407 | |
| 408 %} | |
| 409 | |
| 410 %newobject x86disasm_new; | |
| 411 | |
| 412 %inline %{ | |
| 413 x86disasm * x86disasm_new ( enum x86_options options ) { | |
| 414 x86disasm * dis = (x86disasm *) | |
| 415 calloc( sizeof( x86disasm ), 1 ); | |
| 416 x86_init( options, x86_default_reporter, dis ); | |
| 417 return dis; | |
| 418 } | |
| 419 | |
| 420 void x86disasm_free( x86disasm * dis ) { | |
| 421 x86_cleanup(); | |
| 422 free( dis ); | |
| 423 } | |
| 424 %} | |
| 425 | |
| 426 %newobject x86_disasm; | |
| 427 | |
| 428 %inline %{ | |
| 429 x86_insn_t * disasm( unsigned char *buf, size_t buf_len, | |
| 430 unsigned long buf_rva, unsigned int offset ) { | |
| 431 x86_insn_t *insn = calloc( sizeof( x86_insn_t ), 1 ); | |
| 432 x86_disasm( buf, buf_len, buf_rva, offset, insn ); | |
| 433 return insn; | |
| 434 } | |
| 435 | |
| 436 int disasm_range( unsigned char *buf, size_t buf_len, | |
| 437 unsigned long buf_rva, unsigned int offset, | |
| 438 unsigned int len ) { | |
| 439 | |
| 440 x86_insn_list *list = x86_insn_list_new(); | |
| 441 | |
| 442 if ( len > buf_len ) { | |
| 443 len = buf_len; | |
| 444 } | |
| 445 | |
| 446 return x86_disasm_range( buf, buf_rva, offset, len, | |
| 447 x86_default_callback, list ); | |
| 448 } | |
| 449 | |
| 450 int disasm_forward( unsigned char *buf, size_t buf_len, | |
| 451 unsigned long buf_rva, unsigned int offset ) { | |
| 452 x86_insn_list *list = x86_insn_list_new(); | |
| 453 | |
| 454 /* use default resolver: damn SWIG callbacks! */ | |
| 455 return x86_disasm_forward( buf, buf_len, buf_rva, offset, | |
| 456 x86_default_callback, list, | |
| 457 x86_default_resolver, NULL ); | |
| 458 } | |
| 459 | |
| 460 size_t disasm_invariant( unsigned char *buf, size_t buf_len, | |
| 461 x86_invariant_t *inv ) { | |
| 462 return x86_invariant_disasm( buf, buf_len, inv ); | |
| 463 } | |
| 464 | |
| 465 size_t disasm_size( unsigned char *buf, size_t buf_len ) { | |
| 466 return x86_size_disasm( buf, buf_len ); | |
| 467 } | |
| 468 | |
| 469 int x86_max_operand_string( enum x86_asm_format format ) { | |
| 470 switch ( format ) { | |
| 471 case xml_syntax: | |
| 472 return MAX_OP_XML_STRING; | |
| 473 break; | |
| 474 case raw_syntax: | |
| 475 return MAX_OP_RAW_STRING; | |
| 476 break; | |
| 477 case native_syntax: | |
| 478 case intel_syntax: | |
| 479 case att_syntax: | |
| 480 case unknown_syntax: | |
| 481 default: | |
| 482 return MAX_OP_STRING; | |
| 483 break; | |
| 484 } | |
| 485 } | |
| 486 | |
| 487 | |
| 488 int x86_max_insn_string( enum x86_asm_format format ) { | |
| 489 switch ( format ) { | |
| 490 case xml_syntax: | |
| 491 return MAX_INSN_XML_STRING; | |
| 492 break; | |
| 493 case raw_syntax: | |
| 494 return MAX_INSN_RAW_STRING; | |
| 495 break; | |
| 496 case native_syntax: | |
| 497 case intel_syntax: | |
| 498 case att_syntax: | |
| 499 case unknown_syntax: | |
| 500 default: | |
| 501 return MAX_INSN_STRING; | |
| 502 break; | |
| 503 } | |
| 504 } | |
| 505 | |
| 506 int x86_max_num_operands( ) { return MAX_NUM_OPERANDS; } | |
| 507 %} | |
| 508 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1821293002:
Replace libdisasm with capstone
Base URL: https://chromium.googlesource.com/breakpad/breakpad.git@master