1 /* udis86 - libudis86/syn.c
2 *
3 * Copyright (c) 2002-2013 Vivek Thampi
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without modification,
7 * are permitted provided that the following conditions are met:
8 *
9 * * Redistributions of source code must retain the above copyright notice,
10 * this list of conditions and the following disclaimer.
11 * * Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
19 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
22 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26 #include "types.h"
27 #include "decode.h"
28 #include "syn.h"
29 #include "udint.h"
30
31 /*
32 * Register Table - Order Matters (types.h)!
33 *
34 */
35 const char* ud_reg_tab[] =
36 {
37 "al", "cl", "dl", "bl",
38 "ah", "ch", "dh", "bh",
39 "spl", "bpl", "sil", "dil",
40 "r8b", "r9b", "r10b", "r11b",
41 "r12b", "r13b", "r14b", "r15b",
42
43 "ax", "cx", "dx", "bx",
44 "sp", "bp", "si", "di",
45 "r8w", "r9w", "r10w", "r11w",
46 "r12w", "r13w", "r14w", "r15w",
47
48 "eax", "ecx", "edx", "ebx",
49 "esp", "ebp", "esi", "edi",
50 "r8d", "r9d", "r10d", "r11d",
51 "r12d", "r13d", "r14d", "r15d",
52
53 "rax", "rcx", "rdx", "rbx",
54 "rsp", "rbp", "rsi", "rdi",
55 "r8", "r9", "r10", "r11",
56 "r12", "r13", "r14", "r15",
57
58 "es", "cs", "ss", "ds",
59 "fs", "gs",
60
61 "cr0", "cr1", "cr2", "cr3",
62 "cr4", "cr5", "cr6", "cr7",
63 "cr8", "cr9", "cr10", "cr11",
64 "cr12", "cr13", "cr14", "cr15",
65
66 "dr0", "dr1", "dr2", "dr3",
67 "dr4", "dr5", "dr6", "dr7",
68 "dr8", "dr9", "dr10", "dr11",
69 "dr12", "dr13", "dr14", "dr15",
70
71 "mm0", "mm1", "mm2", "mm3",
72 "mm4", "mm5", "mm6", "mm7",
73
74 "st0", "st1", "st2", "st3",
75 "st4", "st5", "st6", "st7",
76
77 "xmm0", "xmm1", "xmm2", "xmm3",
78 "xmm4", "xmm5", "xmm6", "xmm7",
79 "xmm8", "xmm9", "xmm10", "xmm11",
80 "xmm12", "xmm13", "xmm14", "xmm15",
81
82 "ymm0", "ymm1", "ymm2", "ymm3",
83 "ymm4", "ymm5", "ymm6", "ymm7",
84 "ymm8", "ymm9", "ymm10", "ymm11",
85 "ymm12", "ymm13", "ymm14", "ymm15",
86
87 "rip"
88 };
89
90
91 uint64_t
ud_syn_rel_target(struct ud * u,struct ud_operand * opr)92 ud_syn_rel_target(struct ud *u, struct ud_operand *opr)
93 {
94 #if 1
95 const uint64_t trunc_mask = 0xffffffffffffffffull >> (64 - u->adr_mode);
96 #else
97 const uint64_t trunc_mask = 0xffffffffffffffffull >> (64 - u->opr_mode);
98 #endif
99 switch (opr->size) {
100 case 8 : return (u->pc + opr->lval.sbyte) & trunc_mask;
101 case 16: return (u->pc + opr->lval.sword) & trunc_mask;
102 case 32: return (u->pc + opr->lval.sdword) & trunc_mask;
103 default: UD_ASSERT(!"invalid relative offset size.");
104 return 0ull;
105 }
106 }
107
108
109 /*
110 * asmprintf
111 * Printf style function for printing translated assembly
112 * output. Returns the number of characters written and
113 * moves the buffer pointer forward. On an overflow,
114 * returns a negative number and truncates the output.
115 */
116 int
ud_asmprintf(struct ud * u,const char * fmt,...)117 ud_asmprintf(struct ud *u, const char *fmt, ...)
118 {
119 int ret;
120 int avail;
121 va_list ap;
122 va_start(ap, fmt);
123 avail = u->asm_buf_size - u->asm_buf_fill - 1 /* nullchar */;
124 ret = vsnprintf((char*) u->asm_buf + u->asm_buf_fill, avail, fmt, ap);
125 if (ret < 0 || ret > avail) {
126 u->asm_buf_fill = u->asm_buf_size - 1;
127 } else {
128 u->asm_buf_fill += ret;
129 }
130 va_end(ap);
131 return ret;
132 }
133
134
135 void
ud_syn_print_addr(struct ud * u,uint64_t addr)136 ud_syn_print_addr(struct ud *u, uint64_t addr)
137 {
138 const char *name = NULL;
139 if (u->sym_resolver) {
140 int64_t offset = 0;
141 name = u->sym_resolver(u, addr, &offset);
142 if (name) {
143 if (offset) {
144 ud_asmprintf(u, "%s%+" FMT64 "d", name, offset);
145 } else {
146 ud_asmprintf(u, "%s", name);
147 }
148 return;
149 }
150 }
151 ud_asmprintf(u, "0x%" FMT64 "x", addr);
152 }
153
154
155 void
ud_syn_print_imm(struct ud * u,const struct ud_operand * op)156 ud_syn_print_imm(struct ud* u, const struct ud_operand *op)
157 {
158 uint64_t v;
159 if (op->_oprcode == OP_sI && op->size != u->opr_mode) {
160 if (op->size == 8) {
161 v = (int64_t)op->lval.sbyte;
162 } else {
163 UD_ASSERT(op->size == 32);
164 v = (int64_t)op->lval.sdword;
165 }
166 if (u->opr_mode < 64) {
167 v = v & ((1ull << u->opr_mode) - 1ull);
168 }
169 } else {
170 switch (op->size) {
171 case 8 : v = op->lval.ubyte; break;
172 case 16: v = op->lval.uword; break;
173 case 32: v = op->lval.udword; break;
174 case 64: v = op->lval.uqword; break;
175 default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */
176 }
177 }
178 #if 1
179 if (u->sym_resolver) {
180 int64_t offset = 0;
181 const char *name = u->sym_resolver(u, v, &offset);
182 if (name) {
183 if (offset) {
184 ud_asmprintf(u, "%s%+" FMT64 "d", name, offset);
185 } else {
186 ud_asmprintf(u, "%s", name);
187 }
188 return;
189 }
190 }
191 #endif
192 ud_asmprintf(u, "0x%" FMT64 "x", v);
193 }
194
195
196 void
ud_syn_print_mem_disp(struct ud * u,const struct ud_operand * op,int sign)197 ud_syn_print_mem_disp(struct ud* u, const struct ud_operand *op, int sign)
198 {
199 UD_ASSERT(op->offset != 0);
200 if (op->base == UD_NONE && op->index == UD_NONE) {
201 uint64_t v;
202 UD_ASSERT(op->scale == UD_NONE && op->offset != 8);
203 /* unsigned mem-offset */
204 switch (op->offset) {
205 case 16: v = op->lval.uword; break;
206 case 32: v = op->lval.udword; break;
207 case 64: v = op->lval.uqword; break;
208 default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */
209 }
210 #if 1
211 if (u->sym_resolver) {
212 int64_t offset = 0;
213 const char *name = u->sym_resolver(u, v, &offset);
214 if (name) {
215 if (offset) {
216 ud_asmprintf(u, "%s%+" FMT64 "d", name, offset);
217 } else {
218 ud_asmprintf(u, "%s", name);
219 }
220 return;
221 }
222 }
223 #endif
224 ud_asmprintf(u, "0x%" FMT64 "x", v);
225 } else {
226 int64_t v;
227 UD_ASSERT(op->offset != 64);
228 switch (op->offset) {
229 case 8 : v = op->lval.sbyte; break;
230 case 16: v = op->lval.sword; break;
231 case 32: v = op->lval.sdword; break;
232 default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */
233 }
234 #if 1
235 if (u->sym_resolver) {
236 int64_t offset = 0;
237 const char *name = u->sym_resolver(u, v, &offset);
238 if (name) {
239 if (offset) {
240 ud_asmprintf(u, "%s%+" FMT64 "d", name, offset);
241 } else {
242 ud_asmprintf(u, "%s", name);
243 }
244 return;
245 }
246 }
247 #endif
248 if (v < 0) {
249 ud_asmprintf(u, "-0x%" FMT64 "x", -v);
250 } else if (v > 0) {
251 ud_asmprintf(u, "%s0x%" FMT64 "x", sign? "+" : "", v);
252 }
253 }
254 }
255
256 /*
257 vim: set ts=2 sw=2 expandtab
258 */
259
