Index: src/third_party/libdisasm/x86_operand_list.c |
diff --git a/src/third_party/libdisasm/x86_operand_list.c b/src/third_party/libdisasm/x86_operand_list.c |
deleted file mode 100644 |
index 95409e0698f3fc38a97560cd1177342bf4062b13..0000000000000000000000000000000000000000 |
--- a/src/third_party/libdisasm/x86_operand_list.c |
+++ /dev/null |
@@ -1,191 +0,0 @@ |
-#include <stdlib.h> |
-#include "libdis.h" |
- |
- |
-static void x86_oplist_append( x86_insn_t *insn, x86_oplist_t *op ) { |
- x86_oplist_t *list; |
- |
- if (! insn ) { |
- return; |
- } |
- |
- list = insn->operands; |
- if (! list ) { |
- insn->operand_count = 1; |
- /* Note that we have no way of knowing if this is an |
- * exlicit operand or not, since the caller fills |
- * the x86_op_t after we return. We increase the |
- * explicit count automatically, and ia32_insn_implicit_ops |
- * decrements it */ |
- insn->explicit_count = 1; |
- insn->operands = op; |
- return; |
- } |
- |
- /* get to end of list */ |
- for ( ; list->next; list = list->next ) |
- ; |
- |
- insn->operand_count = insn->operand_count + 1; |
- insn->explicit_count = insn->explicit_count + 1; |
- list->next = op; |
- |
- return; |
-} |
- |
-x86_op_t * x86_operand_new( x86_insn_t *insn ) { |
- x86_oplist_t *op; |
- |
- if (! insn ) { |
- return(NULL); |
- } |
- op = calloc( sizeof(x86_oplist_t), 1 ); |
- op->op.insn = insn; |
- x86_oplist_append( insn, op ); |
- return( &(op->op) ); |
-} |
- |
-void x86_oplist_free( x86_insn_t *insn ) { |
- x86_oplist_t *op, *list; |
- |
- if (! insn ) { |
- return; |
- } |
- |
- for ( list = insn->operands; list; ) { |
- op = list; |
- list = list->next; |
- free(op); |
- } |
- |
- insn->operands = NULL; |
- insn->operand_count = 0; |
- insn->explicit_count = 0; |
- |
- return; |
-} |
- |
-/* ================================================== LIBDISASM API */ |
-/* these could probably just be #defines, but that means exposing the |
- enum... yet one more confusing thing in the API */ |
-int x86_operand_foreach( x86_insn_t *insn, x86_operand_fn func, void *arg, |
- enum x86_op_foreach_type type ){ |
- x86_oplist_t *list; |
- char explicit = 1, implicit = 1; |
- |
- if (! insn || ! func ) { |
- return 0; |
- } |
- |
- /* note: explicit and implicit can be ORed together to |
- * allow an "all" limited by access type, even though the |
- * user is stupid to do this since it is default behavior :) */ |
- if ( (type & op_explicit) && ! (type & op_implicit) ) { |
- implicit = 0; |
- } |
- if ( (type & op_implicit) && ! (type & op_explicit) ) { |
- explicit = 0; |
- } |
- |
- type = type & 0x0F; /* mask out explicit/implicit operands */ |
- |
- for ( list = insn->operands; list; list = list->next ) { |
- if (! implicit && (list->op.flags & op_implied) ) { |
- /* operand is implicit */ |
- continue; |
- } |
- |
- if (! explicit && ! (list->op.flags & op_implied) ) { |
- /* operand is not implicit */ |
- continue; |
- } |
- |
- switch ( type ) { |
- case op_any: |
- break; |
- case op_dest: |
- if (! (list->op.access & op_write) ) { |
- continue; |
- } |
- break; |
- case op_src: |
- if (! (list->op.access & op_read) ) { |
- continue; |
- } |
- break; |
- case op_ro: |
- if (! (list->op.access & op_read) || |
- (list->op.access & op_write ) ) { |
- continue; |
- } |
- break; |
- case op_wo: |
- if (! (list->op.access & op_write) || |
- (list->op.access & op_read ) ) { |
- continue; |
- } |
- break; |
- case op_xo: |
- if (! (list->op.access & op_execute) ) { |
- continue; |
- } |
- break; |
- case op_rw: |
- if (! (list->op.access & op_write) || |
- ! (list->op.access & op_read ) ) { |
- continue; |
- } |
- break; |
- case op_implicit: case op_explicit: /* make gcc happy */ |
- break; |
- } |
- /* any non-continue ends up here: invoke the callback */ |
- (*func)( &list->op, insn, arg ); |
- } |
- |
- return 1; |
-} |
- |
-static void count_operand( x86_op_t *op, x86_insn_t *insn, void *arg ) { |
- size_t * count = (size_t *) arg; |
- *count = *count + 1; |
-} |
- |
-size_t x86_operand_count( x86_insn_t *insn, enum x86_op_foreach_type type ) { |
- size_t count = 0; |
- |
- /* save us a list traversal for common counts... */ |
- if ( type == op_any ) { |
- return insn->operand_count; |
- } else if ( type == op_explicit ) { |
- return insn->explicit_count; |
- } |
- |
- x86_operand_foreach( insn, count_operand, &count, type ); |
- return count; |
-} |
- |
-/* accessor functions */ |
-x86_op_t * x86_operand_1st( x86_insn_t *insn ) { |
- if (! insn->explicit_count ) { |
- return NULL; |
- } |
- |
- return &(insn->operands->op); |
-} |
- |
-x86_op_t * x86_operand_2nd( x86_insn_t *insn ) { |
- if ( insn->explicit_count < 2 ) { |
- return NULL; |
- } |
- |
- return &(insn->operands->next->op); |
-} |
- |
-x86_op_t * x86_operand_3rd( x86_insn_t *insn ) { |
- if ( insn->explicit_count < 3 ) { |
- return NULL; |
- } |
- |
- return &(insn->operands->next->next->op); |
-} |