xref: /PHP-8.3/ext/opcache/jit/libudis86/syn.c (revision 9a068760)
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