1 | #include <stdio.h> |
2 | #include <stdlib.h> |
3 | #include <string.h> |
4 | |
5 | #include "libdis.h" |
6 | #include "ia32_insn.h" |
7 | #include "ia32_invariant.h" |
8 | #include "x86_operand_list.h" |
9 | |
10 | |
11 | #ifdef _MSC_VER |
12 | #define snprintf _snprintf |
13 | #define inline __inline |
14 | #endif |
15 | |
16 | unsigned int x86_disasm( unsigned char *buf, unsigned int buf_len, |
17 | uint32_t buf_rva, unsigned int offset, |
18 | x86_insn_t *insn ){ |
19 | int len, size; |
20 | unsigned char bytes[MAX_INSTRUCTION_SIZE]; |
21 | |
22 | if ( ! buf || ! insn || ! buf_len ) { |
23 | /* caller screwed up somehow */ |
24 | return 0; |
25 | } |
26 | |
27 | |
28 | /* ensure we are all NULLed up */ |
29 | memset( insn, 0, sizeof(x86_insn_t) ); |
30 | insn->addr = buf_rva + offset; |
31 | insn->offset = offset; |
32 | /* default to invalid insn */ |
33 | insn->type = insn_invalid; |
34 | insn->group = insn_none; |
35 | |
36 | if ( offset >= buf_len ) { |
37 | /* another caller screwup ;) */ |
38 | x86_report_error(report_disasm_bounds, (void*)(long)(buf_rva+offset)); |
39 | return 0; |
40 | } |
41 | |
42 | len = buf_len - offset; |
43 | |
44 | /* copy enough bytes for disassembly into buffer : this |
45 | * helps prevent buffer overruns at the end of a file */ |
46 | memset( bytes, 0, MAX_INSTRUCTION_SIZE ); |
47 | memcpy( bytes, &buf[offset], (len < MAX_INSTRUCTION_SIZE) ? len : |
48 | MAX_INSTRUCTION_SIZE ); |
49 | |
50 | /* actually do the disassembly */ |
51 | /* TODO: allow switching when more disassemblers are added */ |
52 | size = ia32_disasm_addr( bytes, len, insn); |
53 | |
54 | /* check and see if we had an invalid instruction */ |
55 | if (! size ) { |
56 | x86_report_error(report_invalid_insn, (void*)(long)(buf_rva+offset)); |
57 | return 0; |
58 | } |
59 | |
60 | /* check if we overran the end of the buffer */ |
61 | if ( size > len ) { |
62 | x86_report_error( report_insn_bounds, (void*)(long)(buf_rva + offset)); |
63 | MAKE_INVALID( insn, bytes ); |
64 | return 0; |
65 | } |
66 | |
67 | /* fill bytes field of insn */ |
68 | memcpy( insn->bytes, bytes, size ); |
69 | |
70 | return size; |
71 | } |
72 | |
73 | unsigned int x86_disasm_range( unsigned char *buf, uint32_t buf_rva, |
74 | unsigned int offset, unsigned int len, |
75 | DISASM_CALLBACK func, void *arg ) { |
76 | x86_insn_t insn; |
77 | unsigned int buf_len, size, count = 0, bytes = 0; |
78 | |
79 | /* buf_len is implied by the arguments */ |
80 | buf_len = len + offset; |
81 | |
82 | while ( bytes < len ) { |
83 | size = x86_disasm( buf, buf_len, buf_rva, offset + bytes, |
84 | &insn ); |
85 | if ( size ) { |
86 | /* invoke callback if it exists */ |
87 | if ( func ) { |
88 | (*func)( &insn, arg ); |
89 | } |
90 | bytes += size; |
91 | count ++; |
92 | } else { |
93 | /* error */ |
94 | bytes++; /* try next byte */ |
95 | } |
96 | |
97 | x86_oplist_free( &insn ); |
98 | } |
99 | |
100 | return( count ); |
101 | } |
102 | |
103 | static inline int follow_insn_dest( x86_insn_t *insn ) { |
104 | if ( insn->type == insn_jmp || insn->type == insn_jcc || |
105 | insn->type == insn_call || insn->type == insn_callcc ) { |
106 | return(1); |
107 | } |
108 | return(0); |
109 | } |
110 | |
111 | static inline int insn_doesnt_return( x86_insn_t *insn ) { |
112 | return( (insn->type == insn_jmp || insn->type == insn_return) ? 1: 0 ); |
113 | } |
114 | |
115 | static int32_t internal_resolver( x86_op_t *op, x86_insn_t *insn ){ |
116 | int32_t next_addr = -1; |
117 | if ( x86_optype_is_address(op->type) ) { |
118 | next_addr = op->data.sdword; |
119 | } else if ( op->type == op_relative_near ) { |
120 | next_addr = insn->addr + insn->size + op->data.relative_near; |
121 | } else if ( op->type == op_relative_far ) { |
122 | next_addr = insn->addr + insn->size + op->data.relative_far; |
123 | } |
124 | return( next_addr ); |
125 | } |
126 | |
127 | unsigned int x86_disasm_forward( unsigned char *buf, unsigned int buf_len, |
128 | uint32_t buf_rva, unsigned int offset, |
129 | DISASM_CALLBACK func, void *arg, |
130 | DISASM_RESOLVER resolver, void *r_arg ){ |
131 | x86_insn_t insn; |
132 | x86_op_t *op; |
133 | int32_t next_addr; |
134 | uint32_t next_offset; |
135 | unsigned int size, count = 0, bytes = 0, cont = 1; |
136 | |
137 | while ( cont && bytes < buf_len ) { |
138 | size = x86_disasm( buf, buf_len, buf_rva, offset + bytes, |
139 | &insn ); |
140 | |
141 | if ( size ) { |
142 | /* invoke callback if it exists */ |
143 | if ( func ) { |
144 | (*func)( &insn, arg ); |
145 | } |
146 | bytes += size; |
147 | count ++; |
148 | } else { |
149 | /* error */ |
150 | bytes++; /* try next byte */ |
151 | } |
152 | |
153 | if ( follow_insn_dest(&insn) ) { |
154 | op = x86_get_dest_operand( &insn ); |
155 | next_addr = -1; |
156 | |
157 | /* if caller supplied a resolver, use it to determine |
158 | * the address to disassemble */ |
159 | if ( resolver ) { |
160 | next_addr = resolver(op, &insn, r_arg); |
161 | } else { |
162 | next_addr = internal_resolver(op, &insn); |
163 | } |
164 | |
165 | if (next_addr != -1 ) { |
166 | next_offset = next_addr - buf_rva; |
167 | /* if offset is in this buffer... */ |
168 | if ( (uint32_t)next_addr >= buf_rva && |
169 | next_offset < buf_len ) { |
170 | /* go ahead and disassemble */ |
171 | count += x86_disasm_forward( buf, |
172 | buf_len, |
173 | buf_rva, |
174 | next_offset, |
175 | func, arg, |
176 | resolver, r_arg ); |
177 | } else { |
178 | /* report unresolved address */ |
179 | x86_report_error( report_disasm_bounds, |
180 | (void*)(long)next_addr ); |
181 | } |
182 | } |
183 | } /* end follow_insn */ |
184 | |
185 | if ( insn_doesnt_return(&insn) ) { |
186 | /* stop disassembling */ |
187 | cont = 0; |
188 | } |
189 | |
190 | x86_oplist_free( &insn ); |
191 | } |
192 | return( count ); |
193 | } |
194 | |
195 | /* invariant instruction representation */ |
196 | size_t x86_invariant_disasm( unsigned char *buf, int buf_len, |
197 | x86_invariant_t *inv ){ |
198 | if (! buf || ! buf_len || ! inv ) { |
199 | return(0); |
200 | } |
201 | |
202 | return ia32_disasm_invariant(buf, buf_len, inv); |
203 | } |
204 | size_t x86_size_disasm( unsigned char *buf, unsigned int buf_len ) { |
205 | if (! buf || ! buf_len ) { |
206 | return(0); |
207 | } |
208 | |
209 | return ia32_disasm_size(buf, buf_len); |
210 | } |
211 | |