src/third_party/libdisasm/swig/libdisasm_oop.i - Issue 1821293002: Replace libdisasm with capstone

Side by Side Diff: src/third_party/libdisasm/swig/libdisasm_oop.i

Issue 1821293002: Replace libdisasm with capstone Base URL: https://chromium.googlesource.com/breakpad/breakpad.git@master

Patch Set: Created 4 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 %module x86disasm

2 %{

3 #ifdef _MSC_VER

4 typedef __int64 qword;

5 #else

6 typedef long long qword;

7 #endif

8

9 #include <sys/types.h>

10

11 #define MAX_REGNAME 8

12 #define MAX_PREFIX_STR 32

13 #define MAX_MNEM_STR 16

14 #define MAX_INSN_SIZE 20

15 #define MAX_OP_STRING 32

16 #define MAX_OP_RAW_STRING 64

17 #define MAX_OP_XML_STRING 256

18 #define MAX_NUM_OPERANDS 8

19 #define MAX_INSN_STRING 512

20 #define MAX_INSN_RAW_STRING 1024

21 #define MAX_INSN_XML_STRING 4096

22

23 #include "../../../config.h"

24

25

26 const char * version_string( void ) {

27 return PACKAGE_VERSION;

28 }

29

30 %}

31

32 const char * version_string( void );

33

34 %rename(X86_Register) x86_reg_t;

35 %rename(X86_EAddr) x86_ea_t;

36 %rename(X86_Operand) x86_op_t;

37 //%rename(X86_OpList) x86_oplist_t;

38 %rename(X86_Insn) x86_insn_t;

39 %rename(X86_InvOperand) x86_invariant_op_t;

40 %rename(X86_Invariant) x86_invariant_t;

41

42 %include "carrays.i"

43

44 %array_class( unsigned char, byteArray );

45

46

47 %apply (unsigned char *STRING, int LENGTH) {

48 (unsigned char *buf, size_t buf_len)

49 };

50

51

52 %inline %{

53

54

55 enum x86_asm_format {

56 unknown_syntax = 0, /* never use! */

57 native_syntax, /* header: 35 bytes */

58 intel_syntax, /* header: 23 bytes */

59 att_syntax, /* header: 23 bytes */

60 xml_syntax, /* header: 679 bytes */

61 raw_syntax /* header: 172 bytes */

62 };

63 %}

64

65 /* ================================================================== */

66 /* operand class */

67 %inline %{

68 enum x86_reg_type {

69 reg_gen = 0x00001, reg_in = 0x00002,

70 reg_out = 0x00004, reg_local = 0x00008,

71 reg_fpu = 0x00010, reg_seg = 0x00020,

72 reg_simd = 0x00040, reg_sys = 0x00080,

73 reg_sp = 0x00100, reg_fp = 0x00200,

74 reg_pc = 0x00400, reg_retaddr = 0x00800,

75 reg_cond = 0x01000, reg_zero = 0x02000,

76 reg_ret = 0x04000, reg_src = 0x10000,

77 reg_dest = 0x20000, reg_count = 0x40000

78 };

79

80 typedef struct {

81 char name[MAX_REGNAME];

82 enum x86_reg_type type;

83 unsigned int size;

84 unsigned int id;

85 unsigned int alias;

86 unsigned int shift;

87 } x86_reg_t;

88

89 void x86_reg_from_id( unsigned int id, x86_reg_t * reg );

90

91 typedef struct {

92 unsigned int scale;

93 x86_reg_t index, base;

94 long disp;

95 char disp_sign;

96 char disp_size;

97 } x86_ea_t;

98

99 enum x86_op_type {

100 op_unused = 0,

101 op_register = 1,

102 op_immediate = 2,

103 op_relative_near = 3,

104 op_relative_far = 4,

105 op_absolute = 5,

106 op_expression = 6,

107 op_offset = 7,

108 op_unknown

109 };

110

111 enum x86_op_datatype {

112 op_byte = 1, op_word = 2,

113 op_dword = 3, op_qword = 4,

114 op_dqword = 5, op_sreal = 6,

115 op_dreal = 7, op_extreal = 8,

116 op_bcd = 9, op_ssimd = 10,

117 op_dsimd = 11, op_sssimd = 12,

118 op_sdsimd = 13, op_descr32 = 14,

119 op_descr16 = 15, op_pdescr32 = 16,

120 op_pdescr16 = 17, op_fpuenv = 18,

121 op_fpregset = 19,

122 };

123

124 enum x86_op_access {

125 op_read = 1,

126 op_write = 2,

127 op_execute = 4

128 };

129

130 enum x86_op_flags {

131 op_signed = 1, op_string = 2,

132 op_constant = 4, op_pointer = 8,

133 op_sysref = 0x010, op_implied = 0x020,

134 op_hardcode = 0x40, op_es_seg = 0x100,

135 op_cs_seg = 0x200, op_ss_seg = 0x300,

136 op_ds_seg = 0x400, op_fs_seg = 0x500,

137 op_gs_seg = 0x600

138 };

139

140 typedef struct {

141 enum x86_op_type type;

142 enum x86_op_datatype datatype;

143 enum x86_op_access access;

144 enum x86_op_flags flags;

145 union {

146 char sbyte;

147 short sword;

148 long sdword;

149 qword sqword;

150 unsigned char byte;

151 unsigned short word;

152 unsigned long dword;

153 qword qword;

154 float sreal;

155 double dreal;

156 unsigned char extreal[10];

157 unsigned char bcd[10];

158 qword dqword[2];

159 unsigned char simd[16];

160 unsigned char fpuenv[28];

161 void * address;

162 unsigned long offset;

163 x86_reg_t reg;

164 char relative_near;

165 long relative_far;

166 x86_ea_t expression;

167 } data;

168 void * insn;

169 } x86_op_t;

170

171 unsigned int x86_operand_size( x86_op_t *op );

172

173 int x86_format_operand(x86_op_t op, char buf, int len,

174 enum x86_asm_format format);

175 %}

176

177 %extend x86_reg_t{

178 x86_reg_t * aliased_reg( ) {

179 x86_reg_t * reg = (x86_reg_t * )

180 calloc( sizeof(x86_reg_t), 1 );

181 x86_reg_from_id( self->id, reg );

182 return reg;

183 }

184 }

185

186 %extend x86_op_t{

187 size_t size() {

188 return x86_operand_size( self );

189 }

190 char * format( enum x86_asm_format format ) {

191 char buf, str;

192 size_t len;

193

194 switch ( format ) {

195 case xml_syntax:

196 len = MAX_OP_XML_STRING;

197 break;

198 case raw_syntax:

199 len = MAX_OP_RAW_STRING;

200 break;

201 case native_syntax:

202 case intel_syntax:

203 case att_syntax:

204 case unknown_syntax:

205 default:

206 len = MAX_OP_STRING;

207 break;

208 }

209

210 buf = (char * ) calloc( len + 1, 1 );

211 x86_format_operand( self, buf, len, format );

212

213 /* drop buffer down to a reasonable size */

214 str = strdup( buf );

215 free(buf);

216 return str;

217 }

218

219 int is_address( ) {

220 if ( self->type == op_absolute \|\|

221 self->type == op_offset ) {

222 return 1;

223 }

224

225 return 0;

226 }

227

228 int is_relative( ) {

229 if ( self->type == op_relative_near \|\|

230 self->type == op_relative_far ) {

231 return 1;

232 }

233

234 return 0;

235 }

236

237 %newobject copy;

238 x86_op_t * copy() {

239 x86_op_t op = (x86_op_t ) calloc( sizeof(x86_op_t), 1 );

240

241 if ( op ) {

242 memcpy( op, self, sizeof(x86_op_t) );

243 }

244

245 return op;

246 }

247 }

248

249 /* ================================================================== */

250 /* operand list class */

251 %inline %{

252 typedef struct X86_OpListNode {

253 x86_op_t *op;

254 struct X86_OpListNode next, prev;

255 } X86_OpListNode;

256

257 typedef struct X86_OpList {

258 size_t count;

259 X86_OpListNode head, tail, *curr;

260 } X86_OpList;

261 %}

262

263 %extend X86_OpList {

264 X86_OpList () {

265 X86_OpList list = (X86_OpList )

266 calloc( sizeof(X86_OpList), 1 );

267 list->count = 0;

268 return list;

269 }

270

271 ~X86_OpList() {

272 X86_OpListNode node, next;

273

274 node = self->head;

275 while ( node ) {

276 next = node->next;

277 /* free( node->insn ); */

278 free( node );

279 node = next;

280 }

281

282 free( self );

283 }

284

285 X86_OpListNode * first() {

286 self->curr = self->head;

287 return self->head;

288 }

289

290 X86_OpListNode * last() {

291 self->curr = self->tail;

292 return self->tail;

293 }

294

295 X86_OpListNode * next() {

296 if (! self->curr ) {

297 self->curr = self->head;

298 return self->head;

299 }

300

301 self->curr = self->curr->next;

302 return self->curr;

303 }

304

305 X86_OpListNode * prev() {

306 if (! self->curr ) {

307 self->curr = self->tail;

308 return self->tail;

309 }

310

311 self->curr = self->curr->prev;

312 return self->curr;

313 }

314

315 %newobject append;

316 void append( x86_op_t *op ) {

317 X86_OpListNode node = (X86_OpListNode )

318 calloc( sizeof(X86_OpListNode) , 1 );

319 if (! node ) {

320 return;

321 }

322

323 self->count++;

324 if ( ! self->tail ) {

325 self->head = self->tail = node;

326 } else {

327 self->tail->next = node;

328 node->prev = self->tail;

329 self->tail = node;

330 }

331

332 node->op = x86_op_t_copy( op );

333 }

334 }

335

336 %inline %{

337 typedef struct x86_operand_list {

338 x86_op_t op;

339 struct x86_operand_list *next;

340 } x86_oplist_t;

341 %}

342

343 %extend x86_oplist_t {

344 %newobject x86_oplist_node_copy;

345 }

346

347 /* ================================================================== */

348 /* instruction class */

349 %inline %{

350 x86_oplist_t * x86_oplist_node_copy( x86_oplist_t * list ) {

351 x86_oplist_t *ptr;

352 ptr = (x86_oplist_t *) calloc( sizeof(x86_oplist_t), 1 );

353 if ( ptr ) {

354 memcpy( &ptr->op, &list->op, sizeof(x86_op_t) );

355 }

356

357 return ptr;

358 }

359

360 enum x86_insn_group {

361 insn_none = 0, insn_controlflow = 1,

362 insn_arithmetic = 2, insn_logic = 3,

363 insn_stack = 4, insn_comparison = 5,

364 insn_move = 6, insn_string = 7,

365 insn_bit_manip = 8, insn_flag_manip = 9,

366 insn_fpu = 10, insn_interrupt = 13,

367 insn_system = 14, insn_other = 15

368 };

369

370 enum x86_insn_type {

371 insn_invalid = 0, insn_jmp = 0x1001,

372 insn_jcc = 0x1002, insn_call = 0x1003,

373 insn_callcc = 0x1004, insn_return = 0x1005,

374 insn_add = 0x2001, insn_sub = 0x2002,

375 insn_mul = 0x2003, insn_div = 0x2004,

376 insn_inc = 0x2005, insn_dec = 0x2006,

377 insn_shl = 0x2007, insn_shr = 0x2008,

378 insn_rol = 0x2009, insn_ror = 0x200A,

379 insn_and = 0x3001, insn_or = 0x3002,

380 insn_xor = 0x3003, insn_not = 0x3004,

381 insn_neg = 0x3005, insn_push = 0x4001,

382 insn_pop = 0x4002, insn_pushregs = 0x4003,

383 insn_popregs = 0x4004, insn_pushflags = 0x4005,

384 insn_popflags = 0x4006, insn_enter = 0x4007,

385 insn_leave = 0x4008, insn_test = 0x5001,

386 insn_cmp = 0x5002, insn_mov = 0x6001,

387 insn_movcc = 0x6002, insn_xchg = 0x6003,

388 insn_xchgcc = 0x6004, insn_strcmp = 0x7001,

389 insn_strload = 0x7002, insn_strmov = 0x7003,

390 insn_strstore = 0x7004, insn_translate = 0x7005,

391 insn_bittest = 0x8001, insn_bitset = 0x8002,

392 insn_bitclear = 0x8003, insn_clear_carry = 0x9001,

393 insn_clear_zero = 0x9002, insn_clear_oflow = 0x9003,

394 insn_clear_dir = 0x9004, insn_clear_sign = 0x9005,

395 insn_clear_parity = 0x9006, insn_set_carry = 0x9007,

396 insn_set_zero = 0x9008, insn_set_oflow = 0x9009,

397 insn_set_dir = 0x900A, insn_set_sign = 0x900B,

398 insn_set_parity = 0x900C, insn_tog_carry = 0x9010,

399 insn_tog_zero = 0x9020, insn_tog_oflow = 0x9030,

400 insn_tog_dir = 0x9040, insn_tog_sign = 0x9050,

401 insn_tog_parity = 0x9060, insn_fmov = 0xA001,

402 insn_fmovcc = 0xA002, insn_fneg = 0xA003,

403 insn_fabs = 0xA004, insn_fadd = 0xA005,

404 insn_fsub = 0xA006, insn_fmul = 0xA007,

405 insn_fdiv = 0xA008, insn_fsqrt = 0xA009,

406 insn_fcmp = 0xA00A, insn_fcos = 0xA00C,

407 insn_fldpi = 0xA00D, insn_fldz = 0xA00E,

408 insn_ftan = 0xA00F, insn_fsine = 0xA010,

409 insn_fsys = 0xA020, insn_int = 0xD001,

410 insn_intcc = 0xD002, insn_iret = 0xD003,

411 insn_bound = 0xD004, insn_debug = 0xD005,

412 insn_trace = 0xD006, insn_invalid_op = 0xD007,

413 insn_oflow = 0xD008, insn_halt = 0xE001,

414 insn_in = 0xE002, insn_out = 0xE003,

415 insn_cpuid = 0xE004, insn_nop = 0xF001,

416 insn_bcdconv = 0xF002, insn_szconv = 0xF003

417 };

418

419 enum x86_insn_note {

420 insn_note_ring0 = 1,

421 insn_note_smm = 2,

422 insn_note_serial = 4

423 };

424

425 enum x86_flag_status {

426 insn_carry_set = 0x1,

427 insn_zero_set = 0x2,

428 insn_oflow_set = 0x4,

429 insn_dir_set = 0x8,

430 insn_sign_set = 0x10,

431 insn_parity_set = 0x20,

432 insn_carry_or_zero_set = 0x40,

433 insn_zero_set_or_sign_ne_oflow = 0x80,

434 insn_carry_clear = 0x100,

435 insn_zero_clear = 0x200,

436 insn_oflow_clear = 0x400,

437 insn_dir_clear = 0x800,

438 insn_sign_clear = 0x1000,

439 insn_parity_clear = 0x2000,

440 insn_sign_eq_oflow = 0x4000,

441 insn_sign_ne_oflow = 0x8000

442 };

443

444 enum x86_insn_cpu {

445 cpu_8086 = 1, cpu_80286 = 2,

446 cpu_80386 = 3, cpu_80387 = 4,

447 cpu_80486 = 5, cpu_pentium = 6,

448 cpu_pentiumpro = 7, cpu_pentium2 = 8,

449 cpu_pentium3 = 9, cpu_pentium4 = 10,

450 cpu_k6 = 16, cpu_k7 = 32,

451 cpu_athlon = 48

452 };

453

454 enum x86_insn_isa {

455 isa_gp = 1, isa_fp = 2,

456 isa_fpumgt = 3, isa_mmx = 4,

457 isa_sse1 = 5, isa_sse2 = 6,

458 isa_sse3 = 7, isa_3dnow = 8,

459 isa_sys = 9

460 };

461

462 enum x86_insn_prefix {

463 insn_no_prefix = 0,

464 insn_rep_zero = 1,

465 insn_rep_notzero = 2,

466 insn_lock = 4

467 };

468

469

470 typedef struct {

471 unsigned long addr;

472 unsigned long offset;

473 enum x86_insn_group group;

474 enum x86_insn_type type;

475 enum x86_insn_note note;

476 unsigned char bytes[MAX_INSN_SIZE];

477 unsigned char size;

478 unsigned char addr_size;

479 unsigned char op_size;

480 enum x86_insn_cpu cpu;

481 enum x86_insn_isa isa;

482 enum x86_flag_status flags_set;

483 enum x86_flag_status flags_tested;

484 unsigned char stack_mod;

485 long stack_mod_val;

486 enum x86_insn_prefix prefix;

487 char prefix_string[MAX_PREFIX_STR];

488 char mnemonic[MAX_MNEM_STR];

489 x86_oplist_t *operands;

490 size_t operand_count;

491 size_t explicit_count;

492 void *block;

493 void *function;

494 int tag;

495 } x86_insn_t;

496

497 typedef void (x86_operand_fn)(x86_op_t op, x86_insn_t *insn,

498 void *arg);

499

500 enum x86_op_foreach_type {

501 op_any = 0,

502 op_dest = 1,

503 op_src = 2,

504 op_ro = 3,

505 op_wo = 4,

506 op_xo = 5,

507 op_rw = 6,

508 op_implicit = 0x10,

509 op_explicit = 0x20

510 };

511

512 size_t x86_operand_count( x86_insn_t *insn,

513 enum x86_op_foreach_type type );

514 x86_op_t * x86_operand_1st( x86_insn_t *insn );

515 x86_op_t * x86_operand_2nd( x86_insn_t *insn );

516 x86_op_t * x86_operand_3rd( x86_insn_t *insn );

517 long x86_get_rel_offset( x86_insn_t *insn );

518 x86_op_t * x86_get_branch_target( x86_insn_t *insn );

519 x86_op_t * x86_get_imm( x86_insn_t *insn );

520 unsigned char * x86_get_raw_imm( x86_insn_t *insn );

521 void x86_set_insn_addr( x86_insn_t *insn, unsigned long addr );

522 int x86_format_mnemonic(x86_insn_t insn, char buf, int len,

523 enum x86_asm_format format);

524 int x86_format_insn(x86_insn_t insn, char buf, int len,

525 enum x86_asm_format);

526 void x86_oplist_free( x86_insn_t *insn );

527 int x86_insn_is_valid( x86_insn_t *insn );

528 %}

529

530 %extend x86_insn_t {

531 x86_insn_t() {

532 x86_insn_t insn = (x86_insn_t )

533 calloc( sizeof(x86_insn_t), 1 );

534 return insn;

535 }

536 ~x86_insn_t() {

537 x86_oplist_free( self );

538 free( self );

539 }

540

541 int is_valid( ) {

542 return x86_insn_is_valid( self );

543 }

544

545 x86_op_t * operand_1st() {

546 return x86_operand_1st( self );

547 }

548

549 x86_op_t * operand_2nd() {

550 return x86_operand_2nd( self );

551 }

552

553 x86_op_t * operand_3rd() {

554 return x86_operand_3rd( self );

555 }

556

557 x86_op_t * operand_dest() {

558 return x86_operand_1st( self );

559 }

560

561 x86_op_t * operand_src() {

562 return x86_operand_2nd( self );

563 }

564

565 size_t num_operands( enum x86_op_foreach_type type ) {

566 return x86_operand_count( self, type );

567 }

568

569 long rel_offset() {

570 return x86_get_rel_offset( self );

571 }

572

573 x86_op_t * branch_target() {

574 return x86_get_branch_target( self );

575 }

576

577 x86_op_t * imm() {

578 return x86_get_imm( self );

579 }

580

581 unsigned char * raw_imm() {

582 return x86_get_raw_imm( self );

583 }

584

585 %newobject format;

586 char * format( enum x86_asm_format format ) {

587 char buf, str;

588 size_t len;

589

590 switch ( format ) {

591 case xml_syntax:

592 len = MAX_INSN_XML_STRING;

593 break;

594 case raw_syntax:

595 len = MAX_INSN_RAW_STRING;

596 break;

597 case native_syntax:

598 case intel_syntax:

599 case att_syntax:

600 case unknown_syntax:

601 default:

602 len = MAX_INSN_STRING;

603 break;

604 }

605

606 buf = (char * ) calloc( len + 1, 1 );

607 x86_format_insn( self, buf, len, format );

608

609 /* drop buffer down to a reasonable size */

610 str = strdup( buf );

611 free(buf);

612 return str;

613 }

614

615 %newobject format_mnemonic;

616 char * format_mnemonic( enum x86_asm_format format ) {

617 char buf, str;

618 size_t len = MAX_MNEM_STR + MAX_PREFIX_STR + 4;

619

620 buf = (char * ) calloc( len, 1 );

621 x86_format_mnemonic( self, buf, len, format );

622

623 /* drop buffer down to a reasonable size */

624 str = strdup( buf );

625 free(buf);

626

627 return str;

628 }

629

630 %newobject copy;

631 x86_insn_t * copy() {

632 x86_oplist_t ptr, list, *last = NULL;

633 x86_insn_t insn = (x86_insn_t )

634 calloc( sizeof(x86_insn_t), 1 );

635

636 if ( insn ) {

637 memcpy( insn, self, sizeof(x86_insn_t) );

638 insn->operands = NULL;

639 insn->block = NULL;

640 insn->function = NULL;

641

642 /* copy operand list */

643 for ( list = self->operands; list; list = list->next ) {

644 ptr = x86_oplist_node_copy( list );

645

646 if (! ptr ) {

647 continue;

648 }

649

650 if ( insn->operands ) {

651 last->next = ptr;

652 } else {

653 insn->operands = ptr;

654 }

655 last = ptr;

656 }

657 }

658

659 return insn;

660 }

661

662 X86_OpList * operand_list( ) {

663 x86_oplist_t *list = self->operands;

664 X86_OpList *op_list = new_X86_OpList();

665

666 for ( list = self->operands; list; list = list->next ) {

667 X86_OpList_append( op_list, &list->op );

668 }

669

670 return op_list;

671 }

672 }

673

674 /* ================================================================== */

675 /* invariant instruction class */

676 %inline %{

677 #define X86_WILDCARD_BYTE 0xF4

678

679 typedef struct {

680 enum x86_op_type type;

681 enum x86_op_datatype datatype;

682 enum x86_op_access access;

683 enum x86_op_flags flags;

684 } x86_invariant_op_t;

685

686 typedef struct {

687 unsigned char bytes[64];

688 unsigned int size;

689 enum x86_insn_group group;

690 enum x86_insn_type type;

691 x86_invariant_op_t operands[3];

692 } x86_invariant_t;

693 %}

694

695 %extend x86_invariant_t {

696

697 x86_invariant_t() {

698 x86_invariant_t inv = (x86_invariant_t )

699 calloc( sizeof(x86_invariant_t), 1 );

700 return inv;

701 }

702

703 ~x86_invariant_t() {

704 free( self );

705 }

706 }

707

708 /* ================================================================== */

709 /* instruction list class */

710 %inline %{

711 typedef struct X86_InsnListNode {

712 x86_insn_t *insn;

713 struct X86_InsnListNode next, prev;

714 } X86_InsnListNode;

715

716 typedef struct X86_InsnList {

717 size_t count;

718 X86_InsnListNode head, tail, *curr;

719 } X86_InsnList;

720 %}

721

722 %extend X86_InsnList {

723 X86_InsnList () {

724 X86_InsnList list = (X86_InsnList )

725 calloc( sizeof(X86_InsnList), 1 );

726 list->count = 0;

727 return list;

728 }

729

730 ~X86_InsnList() {

731 X86_InsnListNode node, next;

732

733 node = self->head;

734 while ( node ) {

735 next = node->next;

736 /* free( node->insn ); */

737 free( node );

738 node = next;

739 }

740

741 free( self );

742 }

743

744 X86_InsnListNode * first() { return self->head; }

745

746 X86_InsnListNode * last() { return self->tail; }

747

748 X86_InsnListNode * next() {

749 if (! self->curr ) {

750 self->curr = self->head;

751 return self->head;

752 }

753

754 self->curr = self->curr->next;

755 return self->curr;

756 }

757

758 X86_InsnListNode * prev() {

759 if (! self->curr ) {

760 self->curr = self->tail;

761 return self->tail;

762 }

763

764 self->curr = self->curr->prev;

765 return self->curr;

766 }

767

768 %newobject append;

769 void append( x86_insn_t *insn ) {

770 X86_InsnListNode node = (X86_InsnListNode )

771 calloc( sizeof(X86_InsnListNode) , 1 );

772 if (! node ) {

773 return;

774 }

775

776 self->count++;

777 if ( ! self->tail ) {

778 self->head = self->tail = node;

779 } else {

780 self->tail->next = node;

781 node->prev = self->tail;

782 self->tail = node;

783 }

784

785 node->insn = x86_insn_t_copy( insn );

786 }

787 }

788

789 /* ================================================================== */

790 /* address table class */

791 /* slight TODO */

792

793 /* ================================================================== */

794 /* Main disassembler class */

795 %inline %{

796

797 enum x86_options {

798 opt_none= 0,

799 opt_ignore_nulls=1,

800 opt_16_bit=2

801 };

802 enum x86_report_codes {

803 report_disasm_bounds,

804 report_insn_bounds,

805 report_invalid_insn,

806 report_unknown

807 };

808

809

810 typedef struct {

811 enum x86_report_codes last_error;

812 void * last_error_data;

813 void * disasm_callback;

814 void * disasm_resolver;

815 } X86_Disasm;

816

817 typedef void (*DISASM_REPORTER)( enum x86_report_codes code,

818 void data, void arg );

819 typedef void (DISASM_CALLBACK)( x86_insn_t insn, void * arg );

820 typedef long (DISASM_RESOLVER)( x86_op_t op,

821 x86_insn_t * current_insn,

822 void *arg );

823

824 void x86_report_error( enum x86_report_codes code, void *data );

825 int x86_init( enum x86_options options, DISASM_REPORTER reporter,

826 void *arg);

827 void x86_set_reporter( DISASM_REPORTER reporter, void *arg);

828 void x86_set_options( enum x86_options options );

829 enum x86_options x86_get_options( void );

830 int x86_cleanup(void);

831 int x86_format_header( char *buf, int len, enum x86_asm_format format);

832 unsigned int x86_endian(void);

833 unsigned int x86_addr_size(void);

834 unsigned int x86_op_size(void);

835 unsigned int x86_word_size(void);

836 unsigned int x86_max_insn_size(void);

837 unsigned int x86_sp_reg(void);

838 unsigned int x86_fp_reg(void);

839 unsigned int x86_ip_reg(void);

840 size_t x86_invariant_disasm( unsigned char *buf, int buf_len,

841 x86_invariant_t *inv );

842 size_t x86_size_disasm( unsigned char *buf, unsigned int buf_len );

843 int x86_disasm( unsigned char *buf, unsigned int buf_len,

844 unsigned long buf_rva, unsigned int offset,

845 x86_insn_t * insn );

846 int x86_disasm_range( unsigned char *buf, unsigned long buf_rva,

847 unsigned int offset, unsigned int len,

848 DISASM_CALLBACK func, void *arg );

849 int x86_disasm_forward( unsigned char *buf, unsigned int buf_len,

850 unsigned long buf_rva, unsigned int offset,

851 DISASM_CALLBACK func, void *arg,

852 DISASM_RESOLVER resolver, void *r_arg );

853

854 void x86_default_reporter( enum x86_report_codes code,

855 void data, void arg ) {

856 X86_Disasm dis = (X86_Disasm ) arg;

857 if ( dis ) {

858 dis->last_error = code;

859 dis->last_error_data = data;

860 }

861 }

862

863 void x86_default_callback( x86_insn_t insn, void arg ) {

864 X86_InsnList list = (X86_InsnList ) arg;

865 if ( list ) {

866 X86_InsnList_append( list, insn );

867 }

868 }

869

870 /* TODO: resolver stack, maybe a callback */

871 long x86_default_resolver( x86_op_t op, x86_insn_t insn, void *arg ) {

872 X86_Disasm dis = (X86_Disasm ) arg;

873 if ( dis ) {

874 //return dis->resolver( op, insn );

875 return 0;

876 }

877

878 return 0;

879 }

880

881 %}

882

883 %extend X86_Disasm {

884

885 X86_Disasm( ) {

886 X86_Disasm * dis = (X86_Disasm *)

887 calloc( sizeof( X86_Disasm ), 1 );

888 x86_init( opt_none, x86_default_reporter, dis );

889 return dis;

890 }

891

892 X86_Disasm( enum x86_options options ) {

893 X86_Disasm * dis = (X86_Disasm *)

894 calloc( sizeof( X86_Disasm ), 1 );

895 x86_init( options, x86_default_reporter, dis );

896 return dis;

897 }

898

899 X86_Disasm( enum x86_options options, DISASM_REPORTER reporter ) {

900 X86_Disasm * dis = (X86_Disasm *)

901 calloc( sizeof( X86_Disasm ), 1 );

902 x86_init( options, reporter, NULL );

903 return dis;

904 }

905

906 X86_Disasm( enum x86_options options, DISASM_REPORTER reporter,

907 void * arg ) {

908 X86_Disasm * dis = (X86_Disasm *)

909 calloc( sizeof( X86_Disasm ), 1 );

910 x86_init( options, reporter, arg );

911 return dis;

912 }

913

914 ~X86_Disasm() {

915 x86_cleanup();

916 free( self );

917 }

918

919 void set_options( enum x86_options options ) {

920 return x86_set_options( options );

921 }

922

923 enum x86_options options() {

924 return x86_get_options();

925 }

926

927 void set_callback( void * callback ) {

928 self->disasm_callback = callback;

929 }

930

931 void set_resolver( void * callback ) {

932 self->disasm_resolver = callback;

933 }

934

935 void report_error( enum x86_report_codes code ) {

936 x86_report_error( code, NULL );

937 }

938

939 %newobject disasm;

940 x86_insn_t * disasm( unsigned char *buf, size_t buf_len,

941 unsigned long buf_rva, unsigned int offset ) {

942 x86_insn_t *insn = calloc( sizeof( x86_insn_t ), 1 );

943 x86_disasm( buf, buf_len, buf_rva, offset, insn );

944 return insn;

945 }

946

947 int disasm_range( unsigned char *buf, size_t buf_len,

948 unsigned long buf_rva, unsigned int offset,

949 unsigned int len ) {

950

951 X86_InsnList *list = new_X86_InsnList();

952

953 if ( len > buf_len ) {

954 len = buf_len;

955 }

956

957 return x86_disasm_range( buf, buf_rva, offset, len,

958 x86_default_callback, list );

959 }

960

961 int disasm_forward( unsigned char *buf, size_t buf_len,

962 unsigned long buf_rva, unsigned int offset ) {

963 X86_InsnList *list = new_X86_InsnList();

964

965 /* use default resolver: damn SWIG callbacks! */

966 return x86_disasm_forward( buf, buf_len, buf_rva, offset,

967 x86_default_callback, list,

968 x86_default_resolver, NULL );

969 }

970

971 size_t disasm_invariant( unsigned char *buf, size_t buf_len,

972 x86_invariant_t *inv ) {

973 return x86_invariant_disasm( buf, buf_len, inv );

974 }

975

976 size_t disasm_size( unsigned char *buf, size_t buf_len ) {

977 return x86_size_disasm( buf, buf_len );

978 }

979

980 %newobject format_header;

981 char * format_header( enum x86_asm_format format) {

982 char buf, str;

983 size_t len;

984

985 switch ( format ) {

986 /* these were obtained from x86_format.c */

987 case xml_syntax:

988 len = 679; break;

989 case raw_syntax:

990 len = 172; break;

991 case native_syntax:

992 len = 35; break;

993 case intel_syntax:

994 len = 23; break;

995 case att_syntax:

996 len = 23; break;

997 case unknown_syntax:

998 default:

999 len = 23; break;

1000 }

1001

1002 buf = (char * ) calloc( len + 1, 1 );

1003 x86_format_header( buf, len, format );

1004

1005 return buf;

1006 }

1007

1008 unsigned int endian() {

1009 return x86_endian();

1010 }

1011

1012 unsigned int addr_size() {

1013 return x86_addr_size();

1014 }

1015

1016 unsigned int op_size() {

1017 return x86_op_size();

1018 }

1019

1020 unsigned int word_size() {

1021 return x86_word_size();

1022 }

1023

1024 unsigned int max_insn_size() {

1025 return x86_max_insn_size();

1026 }

1027

1028 unsigned int sp_reg() {

1029 return x86_sp_reg();

1030 }

1031

1032 unsigned int fp_reg() {

1033 return x86_fp_reg();

1034 }

1035

1036 unsigned int ip_reg() {

1037 return x86_ip_reg();

1038 }

1039

1040 %newobject reg_from_id;

1041 x86_reg_t * reg_from_id( unsigned int id ) {

1042 x86_reg_t * reg = calloc( sizeof(x86_reg_t), 1 );

1043 x86_reg_from_id( id, reg );

1044 return reg;

1045 }

1046

1047 unsigned char wildcard_byte() { return X86_WILDCARD_BYTE; }

1048

1049 int max_register_string() { return MAX_REGNAME; }

1050

1051 int max_prefix_string() { return MAX_PREFIX_STR; }

1052

1053 int max_mnemonic_string() { return MAX_MNEM_STR; }

1054

1055 int max_operand_string( enum x86_asm_format format ) {

1056 switch ( format ) {

1057 case xml_syntax:

1058 return MAX_OP_XML_STRING;

1059 break;

1060 case raw_syntax:

1061 return MAX_OP_RAW_STRING;

1062 break;

1063 case native_syntax:

1064 case intel_syntax:

1065 case att_syntax:

1066 case unknown_syntax:

1067 default:

1068 return MAX_OP_STRING;

1069 break;

1070 }

1071 }

1072

1073

1074 int max_insn_string( enum x86_asm_format format ) {

1075 switch ( format ) {

1076 case xml_syntax:

1077 return MAX_INSN_XML_STRING;

1078 break;

1079 case raw_syntax:

1080 return MAX_INSN_RAW_STRING;

1081 break;

1082 case native_syntax:

1083 case intel_syntax:

1084 case att_syntax:

1085 case unknown_syntax:

1086 default:

1087 return MAX_INSN_STRING;

1088 break;

1089 }

1090 }

1091

1092 int max_num_operands( ) { return MAX_NUM_OPERANDS; }

1093 }

1094

1095 /* python callback, per the manual */

1096 /%typemap(python,in) PyObject pyfunc {

1097 if (!PyCallable_Check($source)) {

1098 PyErr_SetString(PyExc_TypeError, "Need a callable object!");

1099 return NULL;

1100 }

1101 $target = $source;

1102 }*/

1103

1104 /* python FILE * callback, per the manual */

1105 /*

1106 %typemap(python,in) FILE * {

1107 if (!PyFile_Check($source)) {

1108 PyErr_SetString(PyExc_TypeError, "Need a file!");

1109 return NULL;

1110 }

1111 $target = PyFile_AsFile($source);

1112 }*/

1113

1114

OLD	NEW

« src/third_party/capstone.gyp ('K') | « src/third_party/libdisasm/swig/libdisasm.i ('k') | src/third_party/libdisasm/swig/perl/Makefile.PL » ('j') | no next file with comments »