2 * Copyright (c) 2002 Sergey Chaban <serge@wildwestsoftware.com>
9 #include "arm-codegen.h"
12 static ARMDis* gdisasm = NULL;
14 static int use_reg_alias = 1;
16 const static char* cond[] = {
17 "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
18 "hi", "ls", "ge", "lt", "gt", "le", "", "nv"
21 const static char* ops[] = {
22 "and", "eor", "sub", "rsb", "add", "adc", "sbc", "rsc",
23 "tst", "teq", "cmp", "cmn", "orr", "mov", "bic", "mvn"
26 const static char* shift_types[] = {"lsl", "lsr", "asr", "ror"};
28 const static char* mul_ops[] = {
29 "mul", "mla", "?", "?", "umull", "umlal", "smull", "smlal"
32 const static char* reg_alias[] = {
33 "a1", "a2", "a3", "a4",
34 "r4", "r5", "r6", "r7", "r8", "r9", "r10",
35 "fp", "ip", "sp", "lr", "pc"
38 const static char* msr_fld[] = {"f", "c", "x", "?", "s"};
41 /* private functions prototypes (to keep compiler happy) */
42 void chk_out(ARMDis* dis);
43 void dump_reg(ARMDis* dis, int reg);
44 void dump_creg(ARMDis* dis, int creg);
45 void dump_reglist(ARMDis* dis, int reg_list);
46 void init_gdisasm(void);
48 void dump_br(ARMDis* dis, ARMInstr i);
49 void dump_cdp(ARMDis* dis, ARMInstr i);
50 void dump_cdt(ARMDis* dis, ARMInstr i);
51 void dump_crt(ARMDis* dis, ARMInstr i);
52 void dump_dpi(ARMDis* dis, ARMInstr i);
53 void dump_hxfer(ARMDis* dis, ARMInstr i);
54 void dump_mrs(ARMDis* dis, ARMInstr i);
55 void dump_mrt(ARMDis* dis, ARMInstr i);
56 void dump_msr(ARMDis* dis, ARMInstr i);
57 void dump_mul(ARMDis* dis, ARMInstr i);
58 void dump_swi(ARMDis* dis, ARMInstr i);
59 void dump_swp(ARMDis* dis, ARMInstr i);
60 void dump_wxfer(ARMDis* dis, ARMInstr i);
61 void dump_clz(ARMDis* dis, ARMInstr i);
65 void out(ARMDis* dis, const char* format, ...) {
67 va_start(arglist, format);
68 fprintf(dis->dis_out, format, arglist);
74 void chk_out(ARMDis* dis) {
75 if (dis != NULL && dis->dis_out == NULL) dis->dis_out = stdout;
79 void armdis_set_output(ARMDis* dis, FILE* f) {
86 FILE* armdis_get_output(ARMDis* dis) {
87 return (dis != NULL ? dis->dis_out : NULL);
93 void dump_reg(ARMDis* dis, int reg) {
95 if (!use_reg_alias || (reg > 3 && reg < 11)) {
96 fprintf(dis->dis_out, "r%d", reg);
98 fprintf(dis->dis_out, reg_alias[reg]);
102 void dump_creg(ARMDis* dis, int creg) {
105 fprintf(dis->dis_out, "c%d", creg);
109 void dump_reglist(ARMDis* dis, int reg_list) {
113 if ((reg_list & m1) != 0) {
114 if (n != 0) fprintf(dis->dis_out, ", ");
117 for (j = i+1, rn = 0, m2 = m1<<1; j < 16; ++j, m2<<=1) {
118 if ((reg_list & m2) != 0) ++rn;
123 fprintf(dis->dis_out, "-");
125 } else if (rn == 1) {
126 fprintf(dis->dis_out, ", ");
139 void dump_br(ARMDis* dis, ARMInstr i) {
140 fprintf(dis->dis_out, "b%s%s\t%x\t; %p -> %p",
141 (i.br.link == 1) ? "l" : "",
142 cond[i.br.cond], i.br.offset, dis->pi, (int)dis->pi + 4*2 + ((int)(i.br.offset << 8) >> 6));
146 void dump_dpi(ARMDis* dis, ARMInstr i) {
147 fprintf(dis->dis_out, "%s%s", ops[i.dpi.all.opcode], cond[i.dpi.all.cond]);
149 if ((i.dpi.all.opcode < ARMOP_TST || i.dpi.all.opcode > ARMOP_CMN) && (i.dpi.all.s != 0)) {
150 fprintf(dis->dis_out, "s");
153 fprintf(dis->dis_out, "\t");
155 if ((i.dpi.all.opcode < ARMOP_TST) || (i.dpi.all.opcode > ARMOP_CMN)) {
156 /* for comparison operations Rd is ignored */
157 dump_reg(dis, i.dpi.all.rd);
158 fprintf(dis->dis_out, ", ");
161 if ((i.dpi.all.opcode != ARMOP_MOV) && (i.dpi.all.opcode != ARMOP_MVN)) {
162 /* for MOV/MVN Rn is ignored */
163 dump_reg(dis, i.dpi.all.rn);
164 fprintf(dis->dis_out, ", ");
167 if (i.dpi.all.type == 1) {
169 if (i.dpi.op2_imm.rot != 0) {
170 fprintf(dis->dis_out, "#%d, %d\t; 0x%x", i.dpi.op2_imm.imm, i.dpi.op2_imm.rot << 1,
171 ARM_SCALE(i.dpi.op2_imm.imm, (i.dpi.op2_imm.rot << 1)) );
173 fprintf(dis->dis_out, "#%d\t; 0x%x", i.dpi.op2_imm.imm, i.dpi.op2_imm.imm);
177 if (i.dpi.op2_reg.tag == 0) {
178 /* op2 is reg shift by imm */
179 dump_reg(dis, i.dpi.op2_reg_imm.r2.rm);
180 if (i.dpi.op2_reg_imm.imm.shift != 0) {
181 fprintf(dis->dis_out, " %s #%d", shift_types[i.dpi.op2_reg_imm.r2.type], i.dpi.op2_reg_imm.imm.shift);
184 /* op2 is reg shift by reg */
185 dump_reg(dis, i.dpi.op2_reg_reg.r2.rm);
186 fprintf(dis->dis_out, " %s ", shift_types[i.dpi.op2_reg_reg.r2.type]);
187 dump_reg(dis, i.dpi.op2_reg_reg.reg.rs);
193 void dump_wxfer(ARMDis* dis, ARMInstr i) {
194 fprintf(dis->dis_out, "%s%s%s%s\t",
195 (i.wxfer.all.ls == 0) ? "str" : "ldr",
196 cond[i.generic.cond],
197 (i.wxfer.all.b == 0) ? "" : "b",
198 (i.wxfer.all.ls != 0 && i.wxfer.all.wb != 0) ? "t" : "");
199 dump_reg(dis, i.wxfer.all.rd);
200 fprintf(dis->dis_out, ", [");
201 dump_reg(dis, i.wxfer.all.rn);
202 fprintf(dis->dis_out, "%s, ", (i.wxfer.all.p == 0) ? "]" : "");
204 if (i.wxfer.all.type == 0) { /* imm */
205 fprintf(dis->dis_out, "#%s%d", (i.wxfer.all.u == 0) ? "-" : "", i.wxfer.all.op2_imm);
207 dump_reg(dis, i.wxfer.op2_reg_imm.r2.rm);
208 if (i.wxfer.op2_reg_imm.imm.shift != 0) {
209 fprintf(dis->dis_out, " %s #%d", shift_types[i.wxfer.op2_reg_imm.r2.type], i.wxfer.op2_reg_imm.imm.shift);
213 if (i.wxfer.all.p != 0) {
214 /* close pre-index instr, also check for write-back */
215 fprintf(dis->dis_out, "]%s", (i.wxfer.all.wb != 0) ? "!" : "");
219 void dump_hxfer(ARMDis* dis, ARMInstr i) {
220 fprintf(dis->dis_out, "%s%s%s%s\t",
221 (i.hxfer.ls == 0) ? "str" : "ldr",
222 cond[i.generic.cond],
223 (i.hxfer.s != 0) ? "s" : "",
224 (i.hxfer.h != 0) ? "h" : "b");
225 dump_reg(dis, i.hxfer.rd);
226 fprintf(dis->dis_out, ", [");
227 dump_reg(dis, i.hxfer.rn);
228 fprintf(dis->dis_out, "%s, ", (i.hxfer.p == 0) ? "]" : "");
230 if (i.hxfer.type != 0) { /* imm */
231 fprintf(dis->dis_out, "#%s%d", (i.hxfer.u == 0) ? "-" : "", (i.hxfer.imm_hi << 4) | i.hxfer.rm);
233 dump_reg(dis, i.hxfer.rm);
236 if (i.hxfer.p != 0) {
237 /* close pre-index instr, also check for write-back */
238 fprintf(dis->dis_out, "]%s", (i.hxfer.wb != 0) ? "!" : "");
243 void dump_mrt(ARMDis* dis, ARMInstr i) {
244 fprintf(dis->dis_out, "%s%s%s%s\t", (i.mrt.ls == 0) ? "stm" : "ldm", cond[i.mrt.cond],
245 (i.mrt.u == 0) ? "d" : "i", (i.mrt.p == 0) ? "a" : "b");
246 dump_reg(dis, i.mrt.rn);
247 fprintf(dis->dis_out, "%s, {", (i.mrt.wb != 0) ? "!" : "");
248 dump_reglist(dis, i.mrt.reg_list);
249 fprintf(dis->dis_out, "}");
253 void dump_swp(ARMDis* dis, ARMInstr i) {
254 fprintf(dis->dis_out, "swp%s%s ", cond[i.swp.cond], (i.swp.b != 0) ? "b" : "");
255 dump_reg(dis, i.swp.rd);
256 fprintf(dis->dis_out, ", ");
257 dump_reg(dis, i.swp.rm);
258 fprintf(dis->dis_out, ", [");
259 dump_reg(dis, i.swp.rn);
260 fprintf(dis->dis_out, "]");
264 void dump_mul(ARMDis* dis, ARMInstr i) {
265 fprintf(dis->dis_out, "%s%s%s\t", mul_ops[i.mul.opcode], cond[i.mul.cond], (i.mul.s != 0) ? "s" : "");
266 switch (i.mul.opcode) {
268 dump_reg(dis, i.mul.rd);
269 fprintf(dis->dis_out, ", ");
270 dump_reg(dis, i.mul.rm);
271 fprintf(dis->dis_out, ", ");
272 dump_reg(dis, i.mul.rs);
275 dump_reg(dis, i.mul.rd);
276 fprintf(dis->dis_out, ", ");
277 dump_reg(dis, i.mul.rm);
278 fprintf(dis->dis_out, ", ");
279 dump_reg(dis, i.mul.rs);
280 fprintf(dis->dis_out, ", ");
281 dump_reg(dis, i.mul.rn);
287 dump_reg(dis, i.mul.rd);
288 fprintf(dis->dis_out, ", ");
289 dump_reg(dis, i.mul.rn);
290 fprintf(dis->dis_out, ", ");
291 dump_reg(dis, i.mul.rm);
292 fprintf(dis->dis_out, ", ");
293 dump_reg(dis, i.mul.rs);
296 fprintf(dis->dis_out, "DCD 0x%x\t; <unknown>", i.raw);
302 void dump_cdp(ARMDis* dis, ARMInstr i) {
303 fprintf(dis->dis_out, "cdp%s\tp%d, %d, ", cond[i.generic.cond], i.cdp.cpn, i.cdp.op);
304 dump_creg(dis, i.cdp.crd);
305 fprintf(dis->dis_out, ", ");
306 dump_creg(dis, i.cdp.crn);
307 fprintf(dis->dis_out, ", ");
308 dump_creg(dis, i.cdp.crm);
310 if (i.cdp.op2 != 0) {
311 fprintf(dis->dis_out, ", %d", i.cdp.op2);
316 void dump_cdt(ARMDis* dis, ARMInstr i) {
317 fprintf(dis->dis_out, "%s%s%s\tp%d, ", (i.cdt.ls == 0) ? "stc" : "ldc",
318 cond[i.generic.cond], (i.cdt.n != 0) ? "l" : "", i.cdt.cpn);
319 dump_creg(dis, i.cdt.crd);
320 fprintf(dis->dis_out, ", ");
321 dump_reg(dis, i.cdt.rn);
324 fprintf(dis->dis_out, "]");
327 if (i.cdt.offs != 0) {
328 fprintf(dis->dis_out, ", #%d", i.cdt.offs);
332 fprintf(dis->dis_out, "]%s", (i.cdt.wb != 0) ? "!" : "");
337 void dump_crt(ARMDis* dis, ARMInstr i) {
338 fprintf(dis->dis_out, "%s%s\tp%d, %d, ", (i.crt.ls == 0) ? "mrc" : "mcr",
339 cond[i.generic.cond], i.crt.cpn, i.crt.op1);
340 dump_reg(dis, i.crt.rd);
341 fprintf(dis->dis_out, ", ");
342 dump_creg(dis, i.crt.crn);
343 fprintf(dis->dis_out, ", ");
344 dump_creg(dis, i.crt.crm);
346 if (i.crt.op2 != 0) {
347 fprintf(dis->dis_out, ", %d", i.crt.op2);
352 void dump_msr(ARMDis* dis, ARMInstr i) {
353 fprintf(dis->dis_out, "msr%s\t%spsr_, ", cond[i.generic.cond],
354 (i.msr.all.sel == 0) ? "s" : "c");
355 if (i.msr.all.type == 0) {
357 fprintf(dis->dis_out, "%s, ", msr_fld[i.msr.all.fld]);
358 dump_reg(dis, i.msr.all.rm);
361 fprintf(dis->dis_out, "f, #%d", i.msr.op2_imm.imm << i.msr.op2_imm.rot);
366 void dump_mrs(ARMDis* dis, ARMInstr i) {
367 fprintf(dis->dis_out, "mrs%s\t", cond[i.generic.cond]);
368 dump_reg(dis, i.mrs.rd);
369 fprintf(dis->dis_out, ", %spsr", (i.mrs.sel == 0) ? "s" : "c");
373 void dump_swi(ARMDis* dis, ARMInstr i) {
374 fprintf(dis->dis_out, "swi%s\t%d", cond[i.generic.cond], i.swi.num);
378 void dump_clz(ARMDis* dis, ARMInstr i) {
379 fprintf(dis->dis_out, "clz%s\t");
380 dump_reg(dis, i.clz.rd);
381 fprintf(dis->dis_out, ", ");
382 dump_reg(dis, i.clz.rm);
383 fprintf(dis->dis_out, "\n");
388 void armdis_decode(ARMDis* dis, void* p, int size) {
390 arminstr_t* pi = (arminstr_t*)p;
393 if (dis == NULL) return;
397 size/=sizeof(arminstr_t);
399 for (i=0; i<size; ++i) {
400 fprintf(dis->dis_out, "%p:\t%08x\t", pi, *pi);
404 if ((instr.raw & ARM_BR_MASK) == ARM_BR_TAG) {
406 } else if ((instr.raw & ARM_SWP_MASK) == ARM_SWP_TAG) {
407 dump_swp(dis, instr);
408 } else if ((instr.raw & ARM_MUL_MASK) == ARM_MUL_TAG) {
409 dump_mul(dis, instr);
410 } else if ((instr.raw & ARM_CLZ_MASK) == ARM_CLZ_TAG) {
411 dump_clz(dis, instr);
412 } else if ((instr.raw & ARM_WXFER_MASK) == ARM_WXFER_TAG) {
413 dump_wxfer(dis, instr);
414 } else if ((instr.raw & ARM_HXFER_MASK) == ARM_HXFER_TAG) {
415 dump_hxfer(dis, instr);
416 } else if ((instr.raw & ARM_DPI_MASK) == ARM_DPI_TAG) {
417 dump_dpi(dis, instr);
418 } else if ((instr.raw & ARM_MRT_MASK) == ARM_MRT_TAG) {
419 dump_mrt(dis, instr);
420 } else if ((instr.raw & ARM_CDP_MASK) == ARM_CDP_TAG) {
421 dump_cdp(dis, instr);
422 } else if ((instr.raw & ARM_CDT_MASK) == ARM_CDT_TAG) {
423 dump_cdt(dis, instr);
424 } else if ((instr.raw & ARM_CRT_MASK) == ARM_CRT_TAG) {
425 dump_crt(dis, instr);
426 } else if ((instr.raw & ARM_MSR_MASK) == ARM_MSR_TAG) {
427 dump_msr(dis, instr);
428 } else if ((instr.raw & ARM_MRS_MASK) == ARM_MRS_TAG) {
429 dump_mrs(dis, instr);
430 } else if ((instr.raw & ARM_SWI_MASK) == ARM_SWI_TAG) {
431 dump_swi(dis, instr);
433 fprintf(dis->dis_out, "DCD 0x%x\t; <unknown>", instr.raw);
436 fprintf(dis->dis_out, "\n");
441 void armdis_open(ARMDis* dis, const char* dump_name) {
442 if (dis != NULL && dump_name != NULL) {
443 armdis_set_output(dis, fopen(dump_name, "w"));
448 void armdis_close(ARMDis* dis) {
449 if (dis->dis_out != NULL && dis->dis_out != stdout && dis->dis_out != stderr) {
450 fclose(dis->dis_out);
456 void armdis_dump(ARMDis* dis, const char* dump_name, void* p, int size) {
457 armdis_open(dis, dump_name);
458 armdis_decode(dis, p, size);
463 void armdis_init(ARMDis* dis) {
466 armdis_set_output(dis, NULL);
473 void init_gdisasm() {
474 if (gdisasm == NULL) {
475 gdisasm = (ARMDis*)malloc(sizeof(ARMDis));
476 armdis_init(gdisasm);
480 void _armdis_set_output(FILE* f) {
482 armdis_set_output(gdisasm, f);
485 FILE* _armdis_get_output() {
487 return armdis_get_output(gdisasm);
490 void _armdis_decode(void* p, int size) {
492 armdis_decode(gdisasm, p, size);
495 void _armdis_open(const char* dump_name) {
497 armdis_open(gdisasm, dump_name);
500 void _armdis_close() {
502 armdis_close(gdisasm);
505 void _armdis_dump(const char* dump_name, void* p, int size) {
507 armdis_dump(gdisasm, dump_name, p, size);