/src/capstonenext/arch/M68K/M68KInstPrinter.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Capstone Disassembly Engine */ |
2 | | /* M68K Backend by Daniel Collin <daniel@collin.com> 2015-2016 */ |
3 | | |
4 | | #ifdef _MSC_VER |
5 | | // Disable security warnings for strcat & sprintf |
6 | | #ifndef _CRT_SECURE_NO_WARNINGS |
7 | | #define _CRT_SECURE_NO_WARNINGS |
8 | | #endif |
9 | | |
10 | | //Banned API Usage : strcat / sprintf is a Banned API as listed in dontuse.h for |
11 | | //security purposes. |
12 | | #pragma warning(disable:28719) |
13 | | #endif |
14 | | |
15 | | #include <stdio.h> // DEBUG |
16 | | #include <stdlib.h> |
17 | | #include <string.h> |
18 | | |
19 | | #include "M68KInstPrinter.h" |
20 | | |
21 | | #include "M68KDisassembler.h" |
22 | | |
23 | | #include "../../cs_priv.h" |
24 | | #include "../../Mapping.h" |
25 | | #include "../../utils.h" |
26 | | |
27 | | #include "../../MCInst.h" |
28 | | #include "../../MCInstrDesc.h" |
29 | | #include "../../MCRegisterInfo.h" |
30 | | |
31 | | #ifndef CAPSTONE_DIET |
32 | | static const char s_spacing[] = " "; |
33 | | |
34 | | static const char* const s_reg_names[] = { |
35 | | "invalid", |
36 | | "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", |
37 | | "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", |
38 | | "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", |
39 | | "pc", |
40 | | "sr", "ccr", "sfc", "dfc", "usp", "vbr", "cacr", |
41 | | "caar", "msp", "isp", "tc", "itt0", "itt1", "dtt0", |
42 | | "dtt1", "mmusr", "urp", "srp", |
43 | | |
44 | | "fpcr", "fpsr", "fpiar", |
45 | | }; |
46 | | |
47 | | static const char* const s_instruction_names[] = { |
48 | | "invalid", |
49 | | "abcd", "add", "adda", "addi", "addq", "addx", "and", "andi", "asl", "asr", "bhs", "blo", "bhi", "bls", "bcc", "bcs", "bne", "beq", "bvc", |
50 | | "bvs", "bpl", "bmi", "bge", "blt", "bgt", "ble", "bra", "bsr", "bchg", "bclr", "bset", "btst", "bfchg", "bfclr", "bfexts", "bfextu", "bfffo", "bfins", |
51 | | "bfset", "bftst", "bkpt", "callm", "cas", "cas2", "chk", "chk2", "clr", "cmp", "cmpa", "cmpi", "cmpm", "cmp2", "cinvl", "cinvp", "cinva", "cpushl", "cpushp", |
52 | | "cpusha", "dbt", "dbf", "dbhi", "dbls", "dbcc", "dbcs", "dbne", "dbeq", "dbvc", "dbvs", "dbpl", "dbmi", "dbge", "dblt", "dbgt", "dble", "dbra", |
53 | | "divs", "divsl", "divu", "divul", "eor", "eori", "exg", "ext", "extb", "fabs", "fsabs", "fdabs", "facos", "fadd", "fsadd", "fdadd", "fasin", |
54 | | "fatan", "fatanh", "fbf", "fbeq", "fbogt", "fboge", "fbolt", "fbole", "fbogl", "fbor", "fbun", "fbueq", "fbugt", "fbuge", "fbult", "fbule", "fbne", "fbt", |
55 | | "fbsf", "fbseq", "fbgt", "fbge", "fblt", "fble", "fbgl", "fbgle", "fbngle", "fbngl", "fbnle", "fbnlt", "fbnge", "fbngt", "fbsne", "fbst", "fcmp", "fcos", |
56 | | "fcosh", "fdbf", "fdbeq", "fdbogt", "fdboge", "fdbolt", "fdbole", "fdbogl", "fdbor", "fdbun", "fdbueq", "fdbugt", "fdbuge", "fdbult", "fdbule", "fdbne", |
57 | | "fdbt", "fdbsf", "fdbseq", "fdbgt", "fdbge", "fdblt", "fdble", "fdbgl", "fdbgle", "fdbngle", "fdbngl", "fdbnle", "fdbnlt", "fdbnge", "fdbngt", "fdbsne", |
58 | | "fdbst", "fdiv", "fsdiv", "fddiv", "fetox", "fetoxm1", "fgetexp", "fgetman", "fint", "fintrz", "flog10", "flog2", "flogn", "flognp1", "fmod", "fmove", |
59 | | "fsmove", "fdmove", "fmovecr", "fmovem", "fmul", "fsmul", "fdmul", "fneg", "fsneg", "fdneg", "fnop", "frem", "frestore", "fsave", "fscale", "fsgldiv", |
60 | | "fsglmul", "fsin", "fsincos", "fsinh", "fsqrt", "fssqrt", "fdsqrt", "fsf", "fseq", "fsogt", "fsoge", "fsolt", "fsole", "fsogl", "fsor", "fsun", "fsueq", |
61 | | "fsugt", "fsuge", "fsult", "fsule", "fsne", "fst", "fssf", "fsseq", "fsgt", "fsge", "fslt", "fsle", "fsgl", "fsgle", "fsngle", |
62 | | "fsngl", "fsnle", "fsnlt", "fsnge", "fsngt", "fssne", "fsst", "fsub", "fssub", "fdsub", "ftan", "ftanh", "ftentox", "ftrapf", "ftrapeq", "ftrapogt", |
63 | | "ftrapoge", "ftrapolt", "ftrapole", "ftrapogl", "ftrapor", "ftrapun", "ftrapueq", "ftrapugt", "ftrapuge", "ftrapult", "ftrapule", "ftrapne", "ftrapt", |
64 | | "ftrapsf", "ftrapseq", "ftrapgt", "ftrapge", "ftraplt", "ftraple", "ftrapgl", "ftrapgle", "ftrapngle", "ftrapngl", "ftrapnle", "ftrapnlt", "ftrapnge", |
65 | | "ftrapngt", "ftrapsne", "ftrapst", "ftst", "ftwotox", "halt", "illegal", "jmp", "jsr", "lea", "link", "lpstop", "lsl", "lsr", "move", "movea", "movec", |
66 | | "movem", "movep", "moveq", "moves", "move16", "muls", "mulu", "nbcd", "neg", "negx", "nop", "not", "or", "ori", "pack", "pea", "pflush", "pflusha", |
67 | | "pflushan", "pflushn", "ploadr", "ploadw", "plpar", "plpaw", "pmove", "pmovefd", "ptestr", "ptestw", "pulse", "rems", "remu", "reset", "rol", "ror", |
68 | | "roxl", "roxr", "rtd", "rte", "rtm", "rtr", "rts", "sbcd", "st", "sf", "shi", "sls", "scc", "shs", "scs", "slo", "sne", "seq", "svc", "svs", "spl", "smi", |
69 | | "sge", "slt", "sgt", "sle", "stop", "sub", "suba", "subi", "subq", "subx", "swap", "tas", "trap", "trapv", "trapt", "trapf", "traphi", "trapls", |
70 | | "trapcc", "traphs", "trapcs", "traplo", "trapne", "trapeq", "trapvc", "trapvs", "trappl", "trapmi", "trapge", "traplt", "trapgt", "traple", "tst", "unlk", "unpk", |
71 | | }; |
72 | | #endif |
73 | | |
74 | | |
75 | | #ifndef CAPSTONE_DIET |
76 | | static const char* getRegName(m68k_reg reg) |
77 | 75.2k | { |
78 | 75.2k | return s_reg_names[(int)reg]; |
79 | 75.2k | } |
80 | | |
81 | | static void printRegbitsRange(char* buffer, uint32_t data, const char* prefix) |
82 | 28.6k | { |
83 | 28.6k | unsigned int first = 0; |
84 | 28.6k | unsigned int run_length = 0; |
85 | 28.6k | int i; |
86 | | |
87 | 234k | for (i = 0; i < 8; ++i) { |
88 | 206k | if (data & (1 << i)) { |
89 | 28.4k | first = i; |
90 | 28.4k | run_length = 0; |
91 | | |
92 | 51.7k | while (i < 7 && (data & (1 << (i + 1)))) { |
93 | 23.3k | i++; |
94 | 23.3k | run_length++; |
95 | 23.3k | } |
96 | | |
97 | 28.4k | if (buffer[0] != 0) |
98 | 18.8k | strcat(buffer, "/"); |
99 | | |
100 | 28.4k | sprintf(buffer + strlen(buffer), "%s%d", prefix, first); |
101 | 28.4k | if (run_length > 0) |
102 | 10.6k | sprintf(buffer + strlen(buffer), "-%s%d", prefix, first + run_length); |
103 | 28.4k | } |
104 | 206k | } |
105 | 28.6k | } |
106 | | |
107 | | static void registerBits(SStream* O, const cs_m68k_op* op) |
108 | 10.2k | { |
109 | 10.2k | char buffer[128]; |
110 | 10.2k | unsigned int data = op->register_bits; |
111 | | |
112 | 10.2k | buffer[0] = 0; |
113 | | |
114 | 10.2k | if (!data) { |
115 | 637 | SStream_concat(O, "%s", "#$0"); |
116 | 637 | return; |
117 | 637 | } |
118 | | |
119 | 9.56k | printRegbitsRange(buffer, data & 0xff, "d"); |
120 | 9.56k | printRegbitsRange(buffer, (data >> 8) & 0xff, "a"); |
121 | 9.56k | printRegbitsRange(buffer, (data >> 16) & 0xff, "fp"); |
122 | | |
123 | 9.56k | SStream_concat(O, "%s", buffer); |
124 | 9.56k | } |
125 | | |
126 | | static void registerPair(SStream* O, const cs_m68k_op* op) |
127 | 3.86k | { |
128 | 3.86k | SStream_concat(O, "%s:%s", s_reg_names[op->reg_pair.reg_0], |
129 | 3.86k | s_reg_names[op->reg_pair.reg_1]); |
130 | 3.86k | } |
131 | | |
132 | | static void printAddressingMode(SStream* O, unsigned int pc, const cs_m68k* inst, const cs_m68k_op* op) |
133 | 929k | { |
134 | 929k | switch (op->address_mode) { |
135 | 73.9k | case M68K_AM_NONE: |
136 | 73.9k | switch (op->type) { |
137 | 10.2k | case M68K_OP_REG_BITS: |
138 | 10.2k | registerBits(O, op); |
139 | 10.2k | break; |
140 | 3.86k | case M68K_OP_REG_PAIR: |
141 | 3.86k | registerPair(O, op); |
142 | 3.86k | break; |
143 | 58.3k | case M68K_OP_REG: |
144 | 58.3k | SStream_concat(O, "%s", s_reg_names[op->reg]); |
145 | 58.3k | break; |
146 | 1.49k | default: |
147 | 1.49k | break; |
148 | 73.9k | } |
149 | 73.9k | break; |
150 | | |
151 | 316k | case M68K_AM_REG_DIRECT_DATA: SStream_concat(O, "d%d", (op->reg - M68K_REG_D0)); break; |
152 | 46.8k | case M68K_AM_REG_DIRECT_ADDR: SStream_concat(O, "a%d", (op->reg - M68K_REG_A0)); break; |
153 | 49.4k | case M68K_AM_REGI_ADDR: SStream_concat(O, "(a%d)", (op->reg - M68K_REG_A0)); break; |
154 | 53.1k | case M68K_AM_REGI_ADDR_POST_INC: SStream_concat(O, "(a%d)+", (op->reg - M68K_REG_A0)); break; |
155 | 98.4k | case M68K_AM_REGI_ADDR_PRE_DEC: SStream_concat(O, "-(a%d)", (op->reg - M68K_REG_A0)); break; |
156 | 37.5k | case M68K_AM_REGI_ADDR_DISP: SStream_concat(O, "%s$%x(a%d)", op->mem.disp < 0 ? "-" : "", abs(op->mem.disp), (op->mem.base_reg - M68K_REG_A0)); break; |
157 | 3.62k | case M68K_AM_PCI_DISP: SStream_concat(O, "$%x(pc)", pc + 2 + op->mem.disp); break; |
158 | 7.42k | case M68K_AM_ABSOLUTE_DATA_SHORT: SStream_concat(O, "$%x.w", op->imm); break; |
159 | 4.46k | case M68K_AM_ABSOLUTE_DATA_LONG: SStream_concat(O, "$%x.l", op->imm); break; |
160 | 136k | case M68K_AM_IMMEDIATE: |
161 | 136k | if (inst->op_size.type == M68K_SIZE_TYPE_FPU) { |
162 | | #if defined(_KERNEL_MODE) |
163 | | // Issue #681: Windows kernel does not support formatting float point |
164 | | SStream_concat(O, "#<float_point_unsupported>"); |
165 | | break; |
166 | | #else |
167 | 315 | if (inst->op_size.fpu_size == M68K_FPU_SIZE_SINGLE) |
168 | 76 | SStream_concat(O, "#%f", op->simm); |
169 | 239 | else if (inst->op_size.fpu_size == M68K_FPU_SIZE_DOUBLE) |
170 | 239 | SStream_concat(O, "#%f", op->dimm); |
171 | 0 | else |
172 | 0 | SStream_concat(O, "#<unsupported>"); |
173 | 315 | break; |
174 | 315 | #endif |
175 | 315 | } |
176 | 136k | SStream_concat(O, "#$%x", op->imm); |
177 | 136k | break; |
178 | 1.48k | case M68K_AM_PCI_INDEX_8_BIT_DISP: |
179 | 1.48k | SStream_concat(O, "$%x(pc,%s%s.%c)", pc + 2 + op->mem.disp, s_spacing, getRegName(op->mem.index_reg), op->mem.index_size ? 'l' : 'w'); |
180 | 1.48k | break; |
181 | 24.8k | case M68K_AM_AREGI_INDEX_8_BIT_DISP: |
182 | 24.8k | SStream_concat(O, "%s$%x(%s,%s%s.%c)", op->mem.disp < 0 ? "-" : "", abs(op->mem.disp), getRegName(op->mem.base_reg), s_spacing, getRegName(op->mem.index_reg), op->mem.index_size ? 'l' : 'w'); |
183 | 24.8k | break; |
184 | 153 | case M68K_AM_PCI_INDEX_BASE_DISP: |
185 | 7.87k | case M68K_AM_AREGI_INDEX_BASE_DISP: |
186 | | |
187 | 7.87k | if (op->address_mode == M68K_AM_PCI_INDEX_BASE_DISP) { |
188 | 153 | SStream_concat(O, "$%x", pc + 2 + op->mem.in_disp); |
189 | 7.71k | } else { |
190 | 7.71k | if (op->mem.in_disp > 0) |
191 | 3.26k | SStream_concat(O, "$%x", op->mem.in_disp); |
192 | 7.71k | } |
193 | | |
194 | 7.87k | SStream_concat0(O, "("); |
195 | | |
196 | 7.87k | if (op->address_mode == M68K_AM_PCI_INDEX_BASE_DISP) { |
197 | 153 | SStream_concat(O, "pc,%s.%c", getRegName(op->mem.index_reg), op->mem.index_size ? 'l' : 'w'); |
198 | 7.71k | } else { |
199 | 7.71k | if (op->mem.base_reg != M68K_REG_INVALID) |
200 | 5.31k | SStream_concat(O, "a%d,%s", op->mem.base_reg - M68K_REG_A0, s_spacing); |
201 | 7.71k | SStream_concat(O, "%s.%c", getRegName(op->mem.index_reg), op->mem.index_size ? 'l' : 'w'); |
202 | 7.71k | } |
203 | | |
204 | 7.87k | if (op->mem.scale > 0) |
205 | 2.79k | SStream_concat(O, "%s*%s%d)", s_spacing, s_spacing, op->mem.scale); |
206 | 5.07k | else |
207 | 5.07k | SStream_concat0(O, ")"); |
208 | 7.87k | break; |
209 | | // It's ok to just use PCMI here as is as we set base_reg to PC in the disassembler. While this is not strictly correct it makes the code |
210 | | // easier and that is what actually happens when the code is executed anyway. |
211 | | |
212 | 394 | case M68K_AM_PC_MEMI_POST_INDEX: |
213 | 1.26k | case M68K_AM_PC_MEMI_PRE_INDEX: |
214 | 7.27k | case M68K_AM_MEMI_PRE_INDEX: |
215 | 13.4k | case M68K_AM_MEMI_POST_INDEX: |
216 | 13.4k | SStream_concat0(O, "(["); |
217 | | |
218 | 13.4k | if (op->address_mode == M68K_AM_PC_MEMI_POST_INDEX || op->address_mode == M68K_AM_PC_MEMI_PRE_INDEX) { |
219 | 1.26k | SStream_concat(O, "$%x", pc + 2 + op->mem.in_disp); |
220 | 12.1k | } else { |
221 | 12.1k | if (op->mem.in_disp > 0) |
222 | 9.03k | SStream_concat(O, "$%x", op->mem.in_disp); |
223 | 12.1k | } |
224 | | |
225 | 13.4k | if (op->mem.base_reg != M68K_REG_INVALID) { |
226 | 7.47k | if (op->mem.in_disp > 0) |
227 | 5.59k | SStream_concat(O, ",%s%s", s_spacing, getRegName(op->mem.base_reg)); |
228 | 1.87k | else |
229 | 1.87k | SStream_concat(O, "%s", getRegName(op->mem.base_reg)); |
230 | 7.47k | } |
231 | | |
232 | 13.4k | if (op->address_mode == M68K_AM_MEMI_POST_INDEX || op->address_mode == M68K_AM_PC_MEMI_POST_INDEX) |
233 | 6.52k | SStream_concat0(O, "]"); |
234 | | |
235 | 13.4k | if (op->mem.index_reg != M68K_REG_INVALID) |
236 | 8.71k | SStream_concat(O, ",%s%s.%c", s_spacing, getRegName(op->mem.index_reg), op->mem.index_size ? 'l' : 'w'); |
237 | | |
238 | 13.4k | if (op->mem.scale > 0) |
239 | 6.10k | SStream_concat(O, "%s*%s%d", s_spacing, s_spacing, op->mem.scale); |
240 | | |
241 | 13.4k | if (op->address_mode == M68K_AM_MEMI_PRE_INDEX || op->address_mode == M68K_AM_PC_MEMI_PRE_INDEX) |
242 | 6.88k | SStream_concat0(O, "]"); |
243 | | |
244 | 13.4k | if (op->mem.out_disp > 0) |
245 | 5.30k | SStream_concat(O, ",%s$%x", s_spacing, op->mem.out_disp); |
246 | | |
247 | 13.4k | SStream_concat0(O, ")"); |
248 | 13.4k | break; |
249 | 53.8k | case M68K_AM_BRANCH_DISPLACEMENT: |
250 | 53.8k | SStream_concat(O, "$%x", pc + 2 + op->br_disp.disp); |
251 | 53.8k | default: |
252 | 53.8k | break; |
253 | 929k | } |
254 | | |
255 | 929k | if (op->mem.bitfield) |
256 | 1.80k | SStream_concat(O, "{%d:%d}", op->mem.offset, op->mem.width); |
257 | 929k | } |
258 | | #endif |
259 | | |
260 | | #define m68k_sizeof_array(array) (int)(sizeof(array)/sizeof(array[0])) |
261 | 1.78M | #define m68k_min(a, b) (a < b) ? a : b |
262 | | |
263 | | void M68K_printInst(MCInst* MI, SStream* O, void* PrinterInfo) |
264 | 595k | { |
265 | 595k | #ifndef CAPSTONE_DIET |
266 | 595k | m68k_info *info = (m68k_info *)PrinterInfo; |
267 | 595k | cs_m68k *ext = &info->extension; |
268 | 595k | cs_detail *detail = NULL; |
269 | 595k | int i = 0; |
270 | | |
271 | 595k | detail = MI->flat_insn->detail; |
272 | 595k | if (detail) { |
273 | 595k | int regs_read_count = m68k_min(m68k_sizeof_array(detail->regs_read), info->regs_read_count); |
274 | 595k | int regs_write_count = m68k_min(m68k_sizeof_array(detail->regs_write), info->regs_write_count); |
275 | 595k | int groups_count = m68k_min(m68k_sizeof_array(detail->groups), info->groups_count); |
276 | | |
277 | 595k | memcpy(&detail->m68k, ext, sizeof(cs_m68k)); |
278 | | |
279 | 595k | memcpy(&detail->regs_read, &info->regs_read, regs_read_count * sizeof(info->regs_read[0])); |
280 | 595k | detail->regs_read_count = regs_read_count; |
281 | | |
282 | 595k | memcpy(&detail->regs_write, &info->regs_write, regs_write_count * sizeof(info->regs_write[0])); |
283 | 595k | detail->regs_write_count = regs_write_count; |
284 | | |
285 | 595k | memcpy(&detail->groups, &info->groups, groups_count); |
286 | 595k | detail->groups_count = groups_count; |
287 | 595k | } |
288 | | |
289 | 595k | if (MI->Opcode == M68K_INS_INVALID) { |
290 | 80.1k | if (ext->op_count) |
291 | 80.1k | SStream_concat(O, "dc.w $%x", ext->operands[0].imm); |
292 | 0 | else |
293 | 0 | SStream_concat(O, "dc.w $<unknown>"); |
294 | 80.1k | return; |
295 | 80.1k | } |
296 | | |
297 | 514k | SStream_concat0(O, (char*)s_instruction_names[MI->Opcode]); |
298 | | |
299 | 514k | switch (ext->op_size.type) { |
300 | 0 | case M68K_SIZE_TYPE_INVALID : |
301 | 0 | break; |
302 | | |
303 | 511k | case M68K_SIZE_TYPE_CPU : |
304 | 511k | switch (ext->op_size.cpu_size) { |
305 | 170k | case M68K_CPU_SIZE_BYTE: SStream_concat0(O, ".b"); break; |
306 | 133k | case M68K_CPU_SIZE_WORD: SStream_concat0(O, ".w"); break; |
307 | 141k | case M68K_CPU_SIZE_LONG: SStream_concat0(O, ".l"); break; |
308 | 65.8k | case M68K_CPU_SIZE_NONE: break; |
309 | 511k | } |
310 | 511k | break; |
311 | | |
312 | 511k | case M68K_SIZE_TYPE_FPU : |
313 | 3.50k | switch (ext->op_size.fpu_size) { |
314 | 224 | case M68K_FPU_SIZE_SINGLE: SStream_concat0(O, ".s"); break; |
315 | 2.03k | case M68K_FPU_SIZE_DOUBLE: SStream_concat0(O, ".d"); break; |
316 | 1.24k | case M68K_FPU_SIZE_EXTENDED: SStream_concat0(O, ".x"); break; |
317 | 0 | case M68K_FPU_SIZE_NONE: break; |
318 | 3.50k | } |
319 | 3.50k | break; |
320 | 514k | } |
321 | | |
322 | 514k | SStream_concat0(O, " "); |
323 | | |
324 | | // this one is a bit spacial so we do special things |
325 | | |
326 | 514k | if (MI->Opcode == M68K_INS_CAS2) { |
327 | 1.73k | int reg_value_0, reg_value_1; |
328 | 1.73k | printAddressingMode(O, info->pc, ext, &ext->operands[0]); SStream_concat0(O, ","); |
329 | 1.73k | printAddressingMode(O, info->pc, ext, &ext->operands[1]); SStream_concat0(O, ","); |
330 | 1.73k | reg_value_0 = ext->operands[2].register_bits >> 4; |
331 | 1.73k | reg_value_1 = ext->operands[2].register_bits & 0xf; |
332 | 1.73k | SStream_concat(O, "(%s):(%s)", s_reg_names[M68K_REG_D0 + reg_value_0], s_reg_names[M68K_REG_D0 + reg_value_1]); |
333 | 1.73k | return; |
334 | 1.73k | } |
335 | | |
336 | 1.43M | for (i = 0; i < ext->op_count; ++i) { |
337 | 925k | printAddressingMode(O, info->pc, ext, &ext->operands[i]); |
338 | 925k | if ((i + 1) != ext->op_count) |
339 | 414k | SStream_concat(O, ",%s", s_spacing); |
340 | 925k | } |
341 | 513k | #endif |
342 | 513k | } |
343 | | |
344 | | const char* M68K_reg_name(csh handle, unsigned int reg) |
345 | 751k | { |
346 | | #ifdef CAPSTONE_DIET |
347 | | return NULL; |
348 | | #else |
349 | 751k | if (reg >= ARR_SIZE(s_reg_names)) { |
350 | 0 | return NULL; |
351 | 0 | } |
352 | 751k | return s_reg_names[(int)reg]; |
353 | 751k | #endif |
354 | 751k | } |
355 | | |
356 | | void M68K_get_insn_id(cs_struct* h, cs_insn* insn, unsigned int id) |
357 | 595k | { |
358 | 595k | insn->id = id; // These id's matches for 68k |
359 | 595k | } |
360 | | |
361 | | const char* M68K_insn_name(csh handle, unsigned int id) |
362 | 595k | { |
363 | | #ifdef CAPSTONE_DIET |
364 | | return NULL; |
365 | | #else |
366 | 595k | return s_instruction_names[id]; |
367 | 595k | #endif |
368 | 595k | } |
369 | | |
370 | | #ifndef CAPSTONE_DIET |
371 | | static const name_map group_name_maps[] = { |
372 | | { M68K_GRP_INVALID , NULL }, |
373 | | { M68K_GRP_JUMP, "jump" }, |
374 | | { M68K_GRP_RET , "ret" }, |
375 | | { M68K_GRP_IRET, "iret" }, |
376 | | { M68K_GRP_BRANCH_RELATIVE, "branch_relative" }, |
377 | | }; |
378 | | #endif |
379 | | |
380 | | const char *M68K_group_name(csh handle, unsigned int id) |
381 | 115k | { |
382 | 115k | #ifndef CAPSTONE_DIET |
383 | 115k | return id2name(group_name_maps, ARR_SIZE(group_name_maps), id); |
384 | | #else |
385 | | return NULL; |
386 | | #endif |
387 | 115k | } |
388 | | |