Mercurial > projects > ddbg_continued

comparison udis86-1.4/libudis86/syn-intel.c @ 1:4a9dcbd9e54f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
-files of 0.13 beta -fixes so that it now compiles with the current dmd version
author marton@basel.hu
date Tue, 05 Apr 2011 20:44:01 +0200
parents
children
comparison
equal deleted inserted replaced
0:586e4a649642 1:4a9dcbd9e54f
1 /* -----------------------------------------------------------------------------
2 * syn-intel.c
3 *
4 * Copyright (c) 2002, 2003, 2004 Vivek Mohan <vivek@sig9.com>
5 * All rights reserved. See (LICENSE)
6 * -----------------------------------------------------------------------------
7 */
8
9 #include "types.h"
10 #include "extern.h"
11 #include "opcmap.h"
12 #include "syn.h"
13
14 /* -----------------------------------------------------------------------------
15 * opr_cast() - Prints an operand cast.
16 * -----------------------------------------------------------------------------
17 */
18 static void
19 opr_cast(struct ud* u, struct ud_operand* op)
20 {
21 switch(op->size) {
22 case 8: mkasm(u, "byte " ); break;
23 case 16: mkasm(u, "word " ); break;
24 case 32: mkasm(u, "dword "); break;
25 case 64: mkasm(u, "qword "); break;
26 case 80: mkasm(u, "tbyte "); break;
27 default: break;
28 }
29 if (u->br_far)
30 mkasm(u, "far ");
31 else if (u->br_near)
32 mkasm(u, "near ");
33 }
34
35 /* -----------------------------------------------------------------------------
36 * gen_operand() - Generates assembly output for each operand.
37 * -----------------------------------------------------------------------------
38 */
39 static void gen_operand(struct ud* u, struct ud_operand* op, int syn_cast)
40 {
41 switch(op->type) {
42 case UD_OP_REG:
43 mkasm(u, ud_reg_tab[op->base - UD_R_AL]);
44 break;
45
46 case UD_OP_MEM: {
47
48 int op_f = 0;
49
50 if (syn_cast)
51 opr_cast(u, op);
52
53 mkasm(u, "[");
54
55 if (u->pfx_seg)
56 mkasm(u, "%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]);
57
58 if (op->base) {
59 mkasm(u, "%s", ud_reg_tab[op->base - UD_R_AL]);
60 op_f = 1;
61 }
62
63 if (op->index) {
64 if (op_f)
65 mkasm(u, "+");
66 mkasm(u, "%s", ud_reg_tab[op->index - UD_R_AL]);
67 op_f = 1;
68 }
69
70 if (op->scale)
71 mkasm(u, "*%d", op->scale);
72
73 if (op->offset == 8) {
74 if (op->lval.sbyte < 0)
75 mkasm(u, "-0x%x", -op->lval.sbyte);
76 else mkasm(u, "%s0x%x", (op_f) ? "+" : "", op->lval.sbyte);
77 }
78 else if (op->offset == 16)
79 mkasm(u, "%s0x%x", (op_f) ? "+" : "", op->lval.uword);
80 else if (op->offset == 32) {
81 if (u->adr_mode == 64) {
82 if (op->lval.sdword < 0)
83 mkasm(u, "-0x%x", -op->lval.sdword);
84 else mkasm(u, "%s0x%x", (op_f) ? "+" : "", op->lval.sdword);
85 }
86 else mkasm(u, "%s0x%lx", (op_f) ? "+" : "", op->lval.udword);
87 }
88 else if (op->offset == 64)
89 mkasm(u, "%s0x" FMT64 "x", (op_f) ? "+" : "", op->lval.uqword);
90
91 mkasm(u, "]");
92 break;
93 }
94
95 case UD_OP_IMM:
96 if (syn_cast) opr_cast(u, op);
97 switch (op->size) {
98 case 8: mkasm(u, "0x%x", op->lval.ubyte); break;
99 case 16: mkasm(u, "0x%x", op->lval.uword); break;
100 case 32: mkasm(u, "0x%lx", op->lval.udword); break;
101 case 64: mkasm(u, "0x" FMT64 "x", op->lval.uqword); break;
102 default: break;
103 }
104 break;
105
106 case UD_OP_JIMM:
107 if (syn_cast) opr_cast(u, op);
108 switch (op->size) {
109 case 8:
110 mkasm(u, "0x" FMT64 "x", u->pc + op->lval.sbyte);
111 break;
112 case 16:
113 mkasm(u, "0x" FMT64 "x", u->pc + op->lval.sword);
114 break;
115 case 32:
116 mkasm(u, "0x" FMT64 "x", u->pc + op->lval.sdword);
117 break;
118 default:break;
119 }
120 break;
121
122 case UD_OP_PTR:
123 switch (op->size) {
124 case 32:
125 mkasm(u, "word 0x%x:0x%x", op->lval.ptr.seg,
126 op->lval.ptr.off & 0xFFFF);
127 break;
128 case 48:
129 mkasm(u, "dword 0x%x:0x%lx", op->lval.ptr.seg,
130 op->lval.ptr.off);
131 break;
132 }
133 break;
134
135 case UD_OP_CONST:
136 if (syn_cast) opr_cast(u, op);
137 mkasm(u, "%d", op->lval.udword);
138 break;
139
140 default: return;
141 }
142 }
143
144 /* =============================================================================
145 * translates to intel syntax
146 * =============================================================================
147 */
148 extern void ud_translate_intel(struct ud* u)
149 {
150 /* -- prefixes -- */
151
152 /* check if P_O32 prefix is used */
153 if (! P_O32(u->mapen->prefix) && u->pfx_opr) {
154 switch (u->dis_mode) {
155 case 16:
156 mkasm(u, "o32 ");
157 break;
158 case 32:
159 case 64:
160 mkasm(u, "o16 ");
161 break;
162 }
163 }
164
165 /* check if P_A32 prefix was used */
166 if (! P_A32(u->mapen->prefix) && u->pfx_adr) {
167 switch (u->dis_mode) {
168 case 16:
169 mkasm(u, "a32 ");
170 break;
171 case 32:
172 mkasm(u, "a16 ");
173 break;
174 case 64:
175 mkasm(u, "a32 ");
176 break;
177 }
178 }
179
180 if (u->pfx_lock)
181 mkasm(u, "lock ");
182 if (u->pfx_rep)
183 mkasm(u, "rep ");
184 if (u->pfx_repne)
185 mkasm(u, "repne ");
186
187 /* print the instruction mnemonic */
188 mkasm(u, "%s ", ud_lookup_mnemonic(u->mnemonic));
189
190 /* operand 1 */
191 if (u->operand[0].type != UD_NONE) {
192 gen_operand(u, &u->operand[0], u->c1);
193 }
194 /* operand 2 */
195 if (u->operand[1].type != UD_NONE) {
196 mkasm(u, ", ");
197 gen_operand(u, &u->operand[1], u->c2);
198 }
199
200 /* operand 3 */
201 if (u->operand[2].type != UD_NONE) {
202 mkasm(u, ", ");
203 gen_operand(u, &u->operand[2], u->c3);
204 }
205 }