The Tor Browser / file comparison

comparison: toolkit/crashreporter/google-breakpad/src/third_party/libdisasm/swig/libdisasm.i

toolkit/crashreporter/google-breakpad/src/third_party/libdisasm/swig/libdisasm.i

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:dbdc60606a65
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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial