1 /* $NetBSD: db_disasm.c,v 1.23 2019/04/06 03:06:27 thorpej Exp $ */
2
3 /*
4 * Copyright (c) 1998-2000 Internet Initiative Japan Inc.
5 * All rights reserved.
6 *
7 * Author: Akinori Koketsu
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistribution with functional modification must include
15 * prominent notice stating how and when and by whom it is
16 * modified.
17 * 3. Redistributions in binary form have to be along with the source
18 * code or documentation which include above copyright notice, this
19 * list of conditions and the following disclaimer.
20 * 4. All commercial advertising materials mentioning features or use
21 * of this software must display the following acknowledgement:
22 * This product includes software developed by Internet
23 * Initiative Japan Inc.
24 *
25 * THIS SOFTWARE IS PROVIDED BY ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED.
29 */
30
31 #include <sys/cdefs.h>
32 __KERNEL_RCSID(0, "$NetBSD: db_disasm.c,v 1.23 2019/04/06 03:06:27 thorpej Exp $");
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36
37 #include <machine/db_machdep.h>
38
39 #include <ddb/db_command.h>
40 #include <ddb/db_interface.h>
41 #include <ddb/db_output.h>
42
43 static uint16_t get_insn(const void *);
44
45 static void get_opcode(const uint16_t *, char *, size_t);
46
47 static void f_02(const uint16_t *, char *, size_t);
48 static void f_03(const uint16_t *, char *, size_t);
49 static void f_04(const uint16_t *, char *, size_t);
50 static void f_08(const uint16_t *, char *, size_t);
51 static void f_09(const uint16_t *, char *, size_t);
52 static void f_0a(const uint16_t *, char *, size_t);
53 static void f_0b(const uint16_t *, char *, size_t);
54 static void f_0c(const uint16_t *, char *, size_t);
55 static void f_10(const uint16_t *, char *, size_t);
56 static void f_20(const uint16_t *, char *, size_t);
57 static void f_24(const uint16_t *, char *, size_t);
58 static void f_28(const uint16_t *, char *, size_t);
59 static void f_2c(const uint16_t *, char *, size_t);
60 static void f_30(const uint16_t *, char *, size_t);
61 static void f_34(const uint16_t *, char *, size_t);
62 static void f_38(const uint16_t *, char *, size_t);
63 static void f_3c(const uint16_t *, char *, size_t);
64 static void f_40(const uint16_t *, char *, size_t);
65 static void f_41(const uint16_t *, char *, size_t);
66 static void f_42(const uint16_t *, char *, size_t);
67 static void f_43(const uint16_t *, char *, size_t);
68 static void f_44(const uint16_t *, char *, size_t);
69 static void f_45(const uint16_t *, char *, size_t);
70 static void f_46(const uint16_t *, char *, size_t);
71 static void f_47(const uint16_t *, char *, size_t);
72 static void f_48(const uint16_t *, char *, size_t);
73 static void f_49(const uint16_t *, char *, size_t);
74 static void f_4a(const uint16_t *, char *, size_t);
75 static void f_4b(const uint16_t *, char *, size_t);
76 static void f_4c(const uint16_t *, char *, size_t);
77 static void f_4d(const uint16_t *, char *, size_t);
78 static void f_4e(const uint16_t *, char *, size_t);
79 static void f_4f(const uint16_t *, char *, size_t);
80 static void f_50(const uint16_t *, char *, size_t);
81 static void f_60(const uint16_t *, char *, size_t);
82 static void f_64(const uint16_t *, char *, size_t);
83 static void f_68(const uint16_t *, char *, size_t);
84 static void f_6c(const uint16_t *, char *, size_t);
85 static void f_70(const uint16_t *, char *, size_t);
86 static void f_80(const uint16_t *, char *, size_t);
87 static void f_90(const uint16_t *, char *, size_t);
88 static void f_a0(const uint16_t *, char *, size_t);
89 static void f_b0(const uint16_t *, char *, size_t);
90 static void f_c0(const uint16_t *, char *, size_t);
91 static void f_d0(const uint16_t *, char *, size_t);
92 static void f_e0(const uint16_t *, char *, size_t);
93 static void f_f0(const uint16_t *, char *, size_t);
94 static void f_f4(const uint16_t *, char *, size_t);
95 static void f_f8(const uint16_t *, char *, size_t);
96 static void f_fc(const uint16_t *, char *, size_t);
97 static void f_fd(const uint16_t *, char *, size_t);
98 static void f_fe(const uint16_t *, char *, size_t);
99
100 typedef void (*rasm_t)(const uint16_t *, char *, size_t);
101 static rasm_t f[16][16] = {
102 { /* [0][0-7] */ NULL, NULL, f_02, f_03, f_04, f_04, f_04, f_04,
103 /* [0][8-f] */ f_08, f_09, f_0a, f_0b, f_0c, f_0c, f_0c, f_0c },
104 { /* [1][0-7] */ f_10, f_10, f_10, f_10, f_10, f_10, f_10, f_10,
105 /* [1][8-f] */ f_10, f_10, f_10, f_10, f_10, f_10, f_10, f_10 },
106 { /* [2][0-7] */ f_20, f_20, f_20, f_20, f_24, f_24, f_24, f_24,
107 /* [2][8-f] */ f_28, f_28, f_28, f_28, f_2c, f_2c, f_2c, f_2c },
108 { /* [3][0-7] */ f_30, f_30, f_30, f_30, f_34, f_34, f_34, f_34,
109 /* [3][8-f] */ f_38, f_38, f_38, f_38, f_3c, f_3c, f_3c, f_3c },
110 { /* [4][0-7] */ f_40, f_41, f_42, f_43, f_44, f_45, f_46, f_47,
111 /* [4][8-f] */ f_48, f_49, f_4a, f_4b, f_4c, f_4d, f_4e, f_4f },
112 { /* [5][0-7] */ f_50, f_50, f_50, f_50, f_50, f_50, f_50, f_50,
113 /* [5][8-f] */ f_50, f_50, f_50, f_50, f_50, f_50, f_50, f_50 },
114 { /* [6][0-7] */ f_60, f_60, f_60, f_60, f_64, f_64, f_64, f_64,
115 /* [6][8-f] */ f_68, f_68, f_68, f_68, f_6c, f_6c, f_6c, f_6c },
116 { /* [7][0-7] */ f_70, f_70, f_70, f_70, f_70, f_70, f_70, f_70,
117 /* [7][8-f] */ f_70, f_70, f_70, f_70, f_70, f_70, f_70, f_70 },
118 { /* [8][0-7] */ f_80, f_80, f_80, f_80, f_80, f_80, f_80, f_80,
119 /* [8][8-f] */ f_80, f_80, f_80, f_80, f_80, f_80, f_80, f_80 },
120 { /* [9][0-7] */ f_90, f_90, f_90, f_90, f_90, f_90, f_90, f_90,
121 /* [9][8-f] */ f_90, f_90, f_90, f_90, f_90, f_90, f_90, f_90 },
122 { /* [a][0-7] */ f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0,
123 /* [a][8-f] */ f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0, f_a0 },
124 { /* [b][0-7] */ f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0,
125 /* [b][8-f] */ f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0, f_b0 },
126 { /* [c][0-7] */ f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0,
127 /* [c][8-f] */ f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0, f_c0 },
128 { /* [d][0-7] */ f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0,
129 /* [d][8-f] */ f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0, f_d0 },
130 { /* [e][0-7] */ f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0,
131 /* [e][8-f] */ f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0, f_e0 },
132 { /* [f][0-7] */ f_f0, f_f0, f_f0, f_f0, f_f4, f_f4, f_f4, f_f4,
133 /* [f][8-f] */ f_f8, f_f8, f_f8, f_f8, f_fc, f_fd, f_fe, NULL }
134 };
135
136 db_addr_t
db_disasm(db_addr_t loc,bool altfmt)137 db_disasm(db_addr_t loc, bool altfmt)
138 {
139 const void *pc = (void *)loc;
140 char line[40];
141
142 get_opcode(pc, line, sizeof(line));
143 db_printf("%s\n", line);
144
145 return (loc + 2);
146 }
147
148
149 static uint16_t
get_insn(const void * pc)150 get_insn(const void *pc)
151 {
152 vaddr_t addr = (uintptr_t)pc;
153 uint16_t insn;
154 int retval;
155
156 if (addr & 1)
157 db_error("Instruction address not aligned\n");
158
159 if (addr >= SH3_P4SEG_BASE) /* p4: on-chip i/o registers */
160 db_error("Instruction address in P4 area\n");
161
162 if ((intptr_t)addr >= 0) { /* p0: user-space */
163 if (ufetch_16(pc, &insn))
164 db_error("Instruction fetch fault (user)\n");
165 }
166 else { /* kernel p1/p2/p3 */
167 retval = kcopy(pc, &insn, sizeof(insn));
168 if (retval != 0)
169 db_error("Instruction fetch fault (kernel)\n");
170 }
171
172 return insn;
173 }
174
175 static void
get_opcode(const uint16_t * pc,char * buf,size_t len)176 get_opcode(const uint16_t *pc, char *buf, size_t len)
177 {
178 uint16_t insn = get_insn(pc);
179 int n0, n3;
180
181 strlcpy(buf, "????", len);
182
183 n0 = (insn & 0xf000) >> 12;
184 n3 = (insn & 0x000f);
185
186 if (f[n0][n3] != NULL) {
187 (*f[n0][n3])(pc, buf, len);
188 }
189 }
190
191 static void
f_02(const uint16_t * pc,char * buf,size_t len)192 f_02(const uint16_t *pc, char *buf, size_t len)
193 {
194 uint16_t insn = get_insn(pc);
195 int rn, type, md;
196
197 rn = (insn & 0x0f00) >> 8;
198 type = (insn & 0x00c0) >> 6;
199 md = (insn & 0x0030) >> 4;
200
201 switch (type) {
202 case 0:
203 switch (md) {
204 case 0:
205 snprintf(buf, len, "stc sr, r%d", rn);
206 break;
207
208 case 1:
209 snprintf(buf, len, "stc gbr, r%d", rn);
210 break;
211
212 case 2:
213 snprintf(buf, len, "stc vbr, r%d", rn);
214 break;
215
216 case 3:
217 snprintf(buf, len, "stc ssr, r%d", rn);
218 break;
219
220 }
221 break;
222
223 case 1:
224 switch (md) {
225 case 0:
226 snprintf(buf, len, "stc spc, r%d", rn);
227 break;
228 }
229 break;
230
231 case 2:
232 snprintf(buf, len, "stc r%d_bank, r%d", md, rn);
233 break;
234
235 case 3:
236 snprintf(buf, len, "stc r%d_bank, r%d", md+4, rn);
237 break;
238 } /* end of switch (type) */
239 }
240
241 static void
f_03(const uint16_t * pc,char * buf,size_t len)242 f_03(const uint16_t *pc, char *buf, size_t len)
243 {
244 uint16_t insn = get_insn(pc);
245 int rn, type, md;
246
247 rn = (insn & 0x0f00) >> 8;
248 type = (insn & 0x00c0) >> 6;
249 md = (insn & 0x0030) >> 4;
250
251 switch (type) {
252 case 0:
253 switch (md) {
254 case 0:
255 snprintf(buf, len, "bsrf r%d", rn);
256 break;
257
258 case 2:
259 snprintf(buf, len, "braf r%d", rn);
260 break;
261 }
262 break;
263
264 case 2:
265 switch (md) {
266 case 0:
267 snprintf(buf, len, "pref @r%d", rn);
268 break;
269 }
270 break;
271 } /* end of switch (type) */
272 }
273
274
275 static void
f_04(const uint16_t * pc,char * buf,size_t len)276 f_04(const uint16_t *pc, char *buf, size_t len)
277 {
278 uint16_t insn = get_insn(pc);
279 int rn, rm, md;
280
281 rn = (insn & 0x0f00) >> 8;
282 rm = (insn & 0x00f0) >> 4;
283 md = (insn & 0x0003);
284
285 switch (md) {
286 case 0:
287 snprintf(buf, len, "mov.b r%d, @(r0, r%d)", rm, rn);
288 break;
289
290 case 1:
291 snprintf(buf, len, "mov.w r%d, @(r0, r%d)", rm, rn);
292 break;
293
294 case 2:
295 snprintf(buf, len, "mov.l r%d, @(r0, r%d)", rm, rn);
296 break;
297
298 case 3:
299 snprintf(buf, len, "mul.l r%d, r%d)", rm, rn);
300 break;
301 } /* end of switch (md) */
302 }
303
304 static void
f_08(const uint16_t * pc,char * buf,size_t len)305 f_08(const uint16_t *pc, char *buf, size_t len)
306 {
307 uint16_t insn = get_insn(pc);
308 int n1, type, md;
309
310 n1 = (insn & 0x0f00) >> 8;
311 type = (insn & 0x00c0) >> 6;
312 md = (insn & 0x0030) >> 4;
313
314 if (n1 != 0)
315 return;
316
317 switch (type) {
318 case 0:
319 switch (md) {
320 case 0:
321 snprintf(buf, len, "clrt");
322 break;
323
324 case 1:
325 snprintf(buf, len, "sett");
326 break;
327
328 case 2:
329 snprintf(buf, len, "clrmac");
330 break;
331
332 case 3:
333 snprintf(buf, len, "ldtlb");
334 break;
335 }
336 break;
337
338 case 1:
339 switch (md) {
340 case 0:
341 snprintf(buf, len, "clrs");
342 break;
343
344 case 1:
345 snprintf(buf, len, "sets");
346 break;
347 }
348 break;
349 } /* end of switch (type) */
350 }
351
352 static void
f_09(const uint16_t * pc,char * buf,size_t len)353 f_09(const uint16_t *pc, char *buf, size_t len)
354 {
355 uint16_t insn = get_insn(pc);
356 int rn, fx;
357
358 rn = (insn & 0x0f00) >> 8;
359 fx = (insn & 0x00f0) >> 4;
360
361 switch (fx) {
362 case 0:
363 if (rn != 0)
364 return;
365 snprintf(buf, len, "nop");
366 break;
367
368 case 1:
369 if (rn != 0)
370 return;
371 snprintf(buf, len, "div0u");
372 break;
373
374 case 2:
375 snprintf(buf, len, "movt r%d", rn);
376 break;
377 } /* end of switch (fx) */
378 }
379
380 static void
f_0a(const uint16_t * pc,char * buf,size_t len)381 f_0a(const uint16_t *pc, char *buf, size_t len)
382 {
383 uint16_t insn = get_insn(pc);
384 int rn, type, md;
385
386 rn = (insn & 0x0f00) >> 8;
387 type = (insn & 0x00c0) >> 6;
388 md = (insn & 0x0030) >> 4;
389
390 switch (type) {
391 case 0:
392 switch (md) {
393 case 0:
394 snprintf(buf, len, "sts mach, r%d", rn);
395 break;
396
397 case 1:
398 snprintf(buf, len, "sts macl, r%d", rn);
399 break;
400
401 case 2:
402 snprintf(buf, len, "sts pr, r%d", rn);
403 break;
404 }
405 break;
406
407 case 1:
408 switch (md) {
409 case 1:
410 snprintf(buf, len, "sts fpul, r%d", rn);
411 break;
412
413 case 2:
414 snprintf(buf, len, "sts fpscr, r%d", rn);
415 break;
416 }
417 break;
418 } /* end of switch (type) */
419 }
420
421 static void
f_0b(const uint16_t * pc,char * buf,size_t len)422 f_0b(const uint16_t *pc, char *buf, size_t len)
423 {
424 uint16_t insn = get_insn(pc);
425 int n1, fx;
426
427 n1 = (insn & 0x0f00) >> 8;
428 if (n1 != 0)
429 return;
430
431 fx = (insn & 0x00f0) >> 4;
432 switch (fx) {
433 case 0:
434 snprintf(buf, len, "rts");
435 break;
436
437 case 1:
438 snprintf(buf, len, "sleep");
439 break;
440
441 case 2:
442 snprintf(buf, len, "rte");
443 break;
444 } /* end of switch (fx) */
445 }
446
447 static void
f_0c(const uint16_t * pc,char * buf,size_t len)448 f_0c(const uint16_t *pc, char *buf, size_t len)
449 {
450 uint16_t insn = get_insn(pc);
451 int rn, rm, md;
452
453 rn = (insn & 0x0f00) >> 8;
454 rm = (insn & 0x00f0) >> 4;
455 md = (insn & 0x0003);
456
457 switch (md) {
458 case 0:
459 snprintf(buf, len, "mov.b @(r0, r%d), r%d", rm, rn);
460 break;
461
462 case 1:
463 snprintf(buf, len, "mov.w @(r0, r%d), r%d", rm, rn);
464 break;
465
466 case 2:
467 snprintf(buf, len, "mov.l @(r0, r%d), r%d", rm, rn);
468 break;
469
470 case 3:
471 snprintf(buf, len, "mac.l @r%d+, r%d+", rm, rn);
472 break;
473 } /* end of switch (md) */
474 }
475
476 static void
f_10(const uint16_t * pc,char * buf,size_t len)477 f_10(const uint16_t *pc, char *buf, size_t len)
478 {
479 uint16_t insn = get_insn(pc);
480 int rn, rm, disp;
481
482 rn = (insn & 0x0f00) >> 8;
483 rm = (insn & 0x00f0) >> 4;
484 disp = (insn & 0x000f);
485 disp *= 4;
486
487 snprintf(buf, len, "mov.l r%d, @(%d, r%d)", rm, disp, rn);
488 }
489
490 static void
f_20(const uint16_t * pc,char * buf,size_t len)491 f_20(const uint16_t *pc, char *buf, size_t len)
492 {
493 uint16_t insn = get_insn(pc);
494 int rn, rm, md;
495
496 rn = (insn & 0x0f00) >> 8;
497 rm = (insn & 0x00f0) >> 4;
498 md = (insn & 0x0003);
499
500 switch (md) {
501 case 0:
502 snprintf(buf, len, "mov.b r%d, @r%d", rm, rn);
503 break;
504
505 case 1:
506 snprintf(buf, len, "mov.w r%d, @r%d", rm, rn);
507 break;
508
509 case 2:
510 snprintf(buf, len, "mov.l r%d, @r%d", rm, rn);
511 break;
512 } /* end of switch (md) */
513 }
514
515
516 static void
f_24(const uint16_t * pc,char * buf,size_t len)517 f_24(const uint16_t *pc, char *buf, size_t len)
518 {
519 uint16_t insn = get_insn(pc);
520 int rn, rm, md;
521
522 rn = (insn & 0x0f00) >> 8;
523 rm = (insn & 0x00f0) >> 4;
524 md = (insn & 0x0003);
525
526 switch (md) {
527 case 0:
528 snprintf(buf, len, "mov.b r%d, @-r%d", rm, rn);
529 break;
530
531 case 1:
532 snprintf(buf, len, "mov.w r%d, @-r%d", rm, rn);
533 break;
534
535 case 2:
536 snprintf(buf, len, "mov.l r%d, @-r%d", rm, rn);
537 break;
538
539 case 3:
540 snprintf(buf, len, "div0s r%d, r%d)", rm, rn);
541 break;
542 } /* end of switch (md) */
543 }
544
545 static void
f_28(const uint16_t * pc,char * buf,size_t len)546 f_28(const uint16_t *pc, char *buf, size_t len)
547 {
548 uint16_t insn = get_insn(pc);
549 int rn, rm, md;
550
551 rn = (insn & 0x0f00) >> 8;
552 rm = (insn & 0x00f0) >> 4;
553 md = (insn & 0x0003);
554
555 switch (md) {
556 case 0:
557 snprintf(buf, len, "tst r%d, r%d", rm, rn);
558 break;
559
560 case 1:
561 snprintf(buf, len, "and r%d, r%d", rm, rn);
562 break;
563
564 case 2:
565 snprintf(buf, len, "xor r%d, r%d", rm, rn);
566 break;
567
568 case 3:
569 snprintf(buf, len, "or r%d, r%d", rm, rn);
570 break;
571 } /* end of switch (md) */
572 }
573
574
575 static void
f_2c(const uint16_t * pc,char * buf,size_t len)576 f_2c(const uint16_t *pc, char *buf, size_t len)
577 {
578 uint16_t insn = get_insn(pc);
579 int rn, rm, md;
580
581 rn = (insn & 0x0f00) >> 8;
582 rm = (insn & 0x00f0) >> 4;
583 md = (insn & 0x0003);
584
585 switch (md) {
586 case 0:
587 snprintf(buf, len, "cmp/str r%d, r%d", rm, rn);
588 break;
589
590 case 1:
591 snprintf(buf, len, "xtrct r%d, r%d", rm, rn);
592 break;
593
594 case 2:
595 snprintf(buf, len, "mulu.w r%d, r%d", rm, rn);
596 break;
597
598 case 3:
599 snprintf(buf, len, "muls.w r%d, r%d", rm, rn);
600 break;
601 } /* end of switch (md) */
602 }
603
604 static void
f_30(const uint16_t * pc,char * buf,size_t len)605 f_30(const uint16_t *pc, char *buf, size_t len)
606 {
607 uint16_t insn = get_insn(pc);
608 int rn, rm, md;
609
610 rn = (insn & 0x0f00) >> 8;
611 rm = (insn & 0x00f0) >> 4;
612 md = (insn & 0x0003);
613
614 switch (md) {
615 case 0:
616 snprintf(buf, len, "cmp/eq r%d, r%d", rm, rn);
617 break;
618
619 case 2:
620 snprintf(buf, len, "cmp/hs r%d, r%d", rm, rn);
621 break;
622
623 case 3:
624 snprintf(buf, len, "cmp/ge r%d, r%d", rm, rn);
625 break;
626 } /* end of switch (md) */
627 }
628
629
630 static void
f_34(const uint16_t * pc,char * buf,size_t len)631 f_34(const uint16_t *pc, char *buf, size_t len)
632 {
633 uint16_t insn = get_insn(pc);
634 int rn, rm, md;
635
636 rn = (insn & 0x0f00) >> 8;
637 rm = (insn & 0x00f0) >> 4;
638 md = (insn & 0x0003);
639
640 switch (md) {
641 case 0:
642 snprintf(buf, len, "div1 r%d, r%d", rm, rn);
643 break;
644
645 case 1:
646 snprintf(buf, len, "dmulu.l r%d, r%d", rm, rn);
647 break;
648
649 case 2:
650 snprintf(buf, len, "cmp/hi r%d, r%d", rm, rn);
651 break;
652
653 case 3:
654 snprintf(buf, len, "cmp/gt r%d, r%d", rm, rn);
655 break;
656 } /* end of switch (md) */
657 }
658
659 static void
f_38(const uint16_t * pc,char * buf,size_t len)660 f_38(const uint16_t *pc, char *buf, size_t len)
661 {
662 uint16_t insn = get_insn(pc);
663 int rn, rm, md;
664
665 rn = (insn & 0x0f00) >> 8;
666 rm = (insn & 0x00f0) >> 4;
667 md = (insn & 0x0003);
668
669 switch (md) {
670 case 0:
671 snprintf(buf, len, "sub r%d, r%d", rm, rn);
672 break;
673
674 case 2:
675 snprintf(buf, len, "subc r%d, r%d", rm, rn);
676 break;
677
678 case 3:
679 snprintf(buf, len, "subv r%d, r%d", rm, rn);
680 break;
681 } /* end of switch (md) */
682 }
683
684
685 static void
f_3c(const uint16_t * pc,char * buf,size_t len)686 f_3c(const uint16_t *pc, char *buf, size_t len)
687 {
688 uint16_t insn = get_insn(pc);
689 int rn, rm, md;
690
691 rn = (insn & 0x0f00) >> 8;
692 rm = (insn & 0x00f0) >> 4;
693 md = (insn & 0x0003);
694
695 switch (md) {
696 case 0:
697 snprintf(buf, len, "add r%d, r%d", rm, rn);
698 break;
699
700 case 1:
701 snprintf(buf, len, "dmulu.l r%d, r%d", rm, rn);
702 break;
703
704 case 2:
705 snprintf(buf, len, "addc r%d, r%d", rm, rn);
706 break;
707
708 case 3:
709 snprintf(buf, len, "addv r%d, r%d", rm, rn);
710 break;
711 } /* end of switch (md) */
712 }
713
714
715 static void
f_40(const uint16_t * pc,char * buf,size_t len)716 f_40(const uint16_t *pc, char *buf, size_t len)
717 {
718 uint16_t insn = get_insn(pc);
719 int rn, fx;
720
721 rn = (insn & 0x0f00) >> 8;
722 fx = (insn & 0x00f0) >> 4;
723
724 switch (fx) {
725 case 0:
726 snprintf(buf, len, "shll r%d", rn);
727 break;
728
729 case 1:
730 snprintf(buf, len, "dt r%d", rn);
731 break;
732
733 case 2:
734 snprintf(buf, len, "shal r%d", rn);
735 break;
736 } /* end of switch (fx) */
737 }
738
739 static void
f_41(const uint16_t * pc,char * buf,size_t len)740 f_41(const uint16_t *pc, char *buf, size_t len)
741 {
742 uint16_t insn = get_insn(pc);
743 int rn, fx;
744
745 rn = (insn & 0x0f00) >> 8;
746 fx = (insn & 0x00f0) >> 4;
747
748 switch (fx) {
749 case 0:
750 snprintf(buf, len, "shlr r%d", rn);
751 break;
752
753 case 1:
754 snprintf(buf, len, "cmp/pz r%d", rn);
755 break;
756
757 case 2:
758 snprintf(buf, len, "shar r%d", rn);
759 break;
760 } /* end of switch (fx) */
761 }
762
763
764 static void
f_42(const uint16_t * pc,char * buf,size_t len)765 f_42(const uint16_t *pc, char *buf, size_t len)
766 {
767 uint16_t insn = get_insn(pc);
768 int rn, type, md;
769
770 rn = (insn & 0x0f00) >> 8;
771 type = (insn & 0x00c0) >> 6;
772 md = (insn & 0x0030) >> 4;
773
774 switch (type) {
775 case 0:
776 switch (md) {
777 case 0:
778 snprintf(buf, len, "sts.l mach, @-r%d", rn);
779 break;
780
781 case 1:
782 snprintf(buf, len, "sts.l macl, @-r%d", rn);
783 break;
784
785 case 2:
786 snprintf(buf, len, "sts.l pr, @-r%d", rn);
787 break;
788 }
789 break;
790
791 case 1:
792 switch (md) {
793 case 1:
794 snprintf(buf, len, "sts.l fpul, @-r%d", rn);
795 break;
796
797 case 2:
798 snprintf(buf, len, "sts.l fpscr, @-r%d", rn);
799 break;
800 }
801 break;
802 } /* end of switch (type) */
803 }
804
805 static void
f_43(const uint16_t * pc,char * buf,size_t len)806 f_43(const uint16_t *pc, char *buf, size_t len)
807 {
808 uint16_t insn = get_insn(pc);
809 int rn, type, md;
810
811 rn = (insn & 0x0f00) >> 8;
812 type = (insn & 0x00c0) >> 6;
813 md = (insn & 0x0030) >> 4;
814
815 switch (type) {
816 case 0:
817 switch (md) {
818 case 0:
819 snprintf(buf, len, "stc.l sr, @-r%d", rn);
820 break;
821
822 case 1:
823 snprintf(buf, len, "stc.l gbr, @-r%d", rn);
824 break;
825
826 case 2:
827 snprintf(buf, len, "stc.l vbr, @-r%d", rn);
828 break;
829
830 case 3:
831 snprintf(buf, len, "stc.l ssr, @-r%d", rn);
832 break;
833 }
834 break;
835
836 case 1:
837 switch (md) {
838 case 0:
839 snprintf(buf, len, "stc.l spc, @-r%d", rn);
840 break;
841 }
842 break;
843
844 case 2:
845 snprintf(buf, len, "stc.l r%d_bank, @-r%d", md, rn);
846 break;
847
848 case 3:
849 snprintf(buf, len, "stc.l r%d_bank, @-r%d", md+4, rn);
850 break;
851 } /* end of switch (type) */
852 }
853
854 static void
f_44(const uint16_t * pc,char * buf,size_t len)855 f_44(const uint16_t *pc, char *buf, size_t len)
856 {
857 uint16_t insn = get_insn(pc);
858 int rn, fx;
859
860 rn = (insn & 0x0f00) >> 8;
861 fx = (insn & 0x00f0) >> 4;
862
863 switch (fx) {
864 case 0:
865 snprintf(buf, len, "rotl r%d", rn);
866 break;
867
868 case 2:
869 snprintf(buf, len, "rotcl r%d", rn);
870 break;
871 } /* end of switch (fx) */
872 }
873
874 static void
f_45(const uint16_t * pc,char * buf,size_t len)875 f_45(const uint16_t *pc, char *buf, size_t len)
876 {
877 uint16_t insn = get_insn(pc);
878 int rn, fx;
879
880 rn = (insn & 0x0f00) >> 8;
881 fx = (insn & 0x00f0) >> 4;
882
883 switch (fx) {
884 case 0:
885 snprintf(buf, len, "rotr r%d", rn);
886 break;
887
888 case 1:
889 snprintf(buf, len, "cmp/pl r%d", rn);
890 break;
891
892 case 2:
893 snprintf(buf, len, "rotcr r%d", rn);
894 break;
895 } /* end of switch (fx) */
896 }
897
898 static void
f_46(const uint16_t * pc,char * buf,size_t len)899 f_46(const uint16_t *pc, char *buf, size_t len)
900 {
901 uint16_t insn = get_insn(pc);
902 int rm, type, md;
903
904 rm = (insn & 0x0f00) >> 8;
905 type = (insn & 0x00c0) >> 6;
906 md = (insn & 0x0030) >> 4;
907
908 switch (type) {
909 case 0:
910 switch (md) {
911 case 0:
912 snprintf(buf, len, "lds.l @r%d+, mach", rm);
913 break;
914
915 case 1:
916 snprintf(buf, len, "lds.l @r%d+, macl", rm);
917 break;
918
919 case 2:
920 snprintf(buf, len, "lds.l @r%d+, pr", rm);
921 break;
922 }
923 break;
924
925 case 1:
926 switch (md) {
927 case 1:
928 snprintf(buf, len, "lds.l @r%d+, fpul", rm);
929 break;
930
931 case 2:
932 snprintf(buf, len, "lds.l @r%d+, fpscr", rm);
933 break;
934 }
935 break;
936 } /* end of switch (type) */
937 }
938
939 static void
f_47(const uint16_t * pc,char * buf,size_t len)940 f_47(const uint16_t *pc, char *buf, size_t len)
941 {
942 uint16_t insn = get_insn(pc);
943 int rm, type, md;
944
945 rm = (insn & 0x0f00) >> 8;
946 type = (insn & 0x00c0) >> 6;
947 md = (insn & 0x0030) >> 4;
948
949 switch (type) {
950 case 0:
951 switch (md) {
952 case 0:
953 snprintf(buf, len, "ldc.l @r%d+, sr", rm);
954 break;
955
956 case 1:
957 snprintf(buf, len, "ldc.l @r%d+, gbr", rm);
958 break;
959
960 case 2:
961 snprintf(buf, len, "ldc.l @r%d+, vbr", rm);
962 break;
963
964 case 3:
965 snprintf(buf, len, "ldc.l @r%d+, ssr", rm);
966 break;
967 }
968 break;
969
970 case 1:
971 switch (md) {
972 case 0:
973 snprintf(buf, len, "ldc.l @r%d+, spc", rm);
974 break;
975 }
976 break;
977
978 case 2:
979 snprintf(buf, len, "ldc.l @r%d+, r%d_bank", rm, md);
980 break;
981
982 case 3:
983 snprintf(buf, len, "ldc.l @r%d+, r%d_bank", rm, md+4);
984 break;
985 } /* end of switch (type) */
986 }
987
988 static void
f_48(const uint16_t * pc,char * buf,size_t len)989 f_48(const uint16_t *pc, char *buf, size_t len)
990 {
991 uint16_t insn = get_insn(pc);
992 int rn, fx;
993
994 rn = (insn & 0x0f00) >> 8;
995 fx = (insn & 0x00f0) >> 4;
996
997 switch (fx) {
998 case 0:
999 snprintf(buf, len, "shll2 r%d", rn);
1000 break;
1001
1002 case 1:
1003 snprintf(buf, len, "shll8 r%d", rn);
1004 break;
1005
1006 case 2:
1007 snprintf(buf, len, "shll16 r%d", rn);
1008 break;
1009 } /* end of switch (fx) */
1010 }
1011
1012 static void
f_49(const uint16_t * pc,char * buf,size_t len)1013 f_49(const uint16_t *pc, char *buf, size_t len)
1014 {
1015 uint16_t insn = get_insn(pc);
1016 int rn, fx;
1017
1018 rn = (insn & 0x0f00) >> 8;
1019 fx = (insn & 0x00f0) >> 4;
1020
1021 switch (fx) {
1022 case 0:
1023 snprintf(buf, len, "shlr2 r%d", rn);
1024 break;
1025
1026 case 1:
1027 snprintf(buf, len, "shlr8 r%d", rn);
1028 break;
1029
1030 case 2:
1031 snprintf(buf, len, "shlr16 r%d", rn);
1032 break;
1033 } /* end of switch (fx) */
1034 }
1035
1036 static void
f_4a(const uint16_t * pc,char * buf,size_t len)1037 f_4a(const uint16_t *pc, char *buf, size_t len)
1038 {
1039 uint16_t insn = get_insn(pc);
1040 int rm, type, md;
1041
1042 rm = (insn & 0x0f00) >> 8;
1043 type = (insn & 0x00c0) >> 6;
1044 md = (insn & 0x0030) >> 4;
1045
1046 switch (type) {
1047 case 0:
1048 switch (md) {
1049 case 0:
1050 snprintf(buf, len, "lds r%d, mach", rm);
1051 break;
1052
1053 case 1:
1054 snprintf(buf, len, "lds r%d, macl", rm);
1055 break;
1056
1057 case 2:
1058 snprintf(buf, len, "lds r%d, pr", rm);
1059 break;
1060 }
1061 break;
1062
1063 case 1:
1064 switch (md) {
1065 case 1:
1066 snprintf(buf, len, "lds r%d, fpul", rm);
1067 break;
1068
1069 case 2:
1070 snprintf(buf, len, "lds r%d, fpscr", rm);
1071 break;
1072 }
1073 break;
1074 } /* end of switch (type) */
1075 }
1076
1077 static void
f_4b(const uint16_t * pc,char * buf,size_t len)1078 f_4b(const uint16_t *pc, char *buf, size_t len)
1079 {
1080 uint16_t insn = get_insn(pc);
1081 int rm, fx;
1082
1083 rm = (insn & 0x0f00) >> 8;
1084 fx = (insn & 0x00f0) >> 4;
1085
1086 switch (fx) {
1087 case 0:
1088 snprintf(buf, len, "jsr @r%d", rm);
1089 break;
1090
1091 case 1:
1092 snprintf(buf, len, "tas.b @r%d", rm);
1093 break;
1094
1095 case 2:
1096 snprintf(buf, len, "jmp @r%d", rm);
1097 break;
1098 } /* end of switch (fx) */
1099 }
1100
1101 static void
f_4c(const uint16_t * pc,char * buf,size_t len)1102 f_4c(const uint16_t *pc, char *buf, size_t len)
1103 {
1104 uint16_t insn = get_insn(pc);
1105 int rn, rm;
1106
1107 rn = (insn & 0x0f00) >> 8;
1108 rm = (insn & 0x00f0) >> 4;
1109 snprintf(buf, len, "shad r%d, r%d", rm, rn);
1110 }
1111
1112 static void
f_4d(const uint16_t * pc,char * buf,size_t len)1113 f_4d(const uint16_t *pc, char *buf, size_t len)
1114 {
1115 uint16_t insn = get_insn(pc);
1116 int rn, rm;
1117
1118 rn = (insn & 0x0f00) >> 8;
1119 rm = (insn & 0x00f0) >> 4;
1120 snprintf(buf, len, "shld r%d, r%d", rm, rn);
1121 }
1122
1123 static void
f_4e(const uint16_t * pc,char * buf,size_t len)1124 f_4e(const uint16_t *pc, char *buf, size_t len)
1125 {
1126 uint16_t insn = get_insn(pc);
1127 int rm, type, md;
1128
1129 rm = (insn & 0x0f00) >> 8;
1130 type = (insn & 0x00c0) >> 6;
1131 md = (insn & 0x0030) >> 4;
1132
1133 switch (type) {
1134 case 0:
1135 switch (md) {
1136 case 0:
1137 snprintf(buf, len, "ldc r%d, sr", rm);
1138 break;
1139
1140 case 1:
1141 snprintf(buf, len, "ldc r%d, gbr", rm);
1142 break;
1143
1144 case 2:
1145 snprintf(buf, len, "ldc r%d, vbr", rm);
1146 break;
1147
1148 case 3:
1149 snprintf(buf, len, "ldc r%d, ssr", rm);
1150 break;
1151 }
1152 break;
1153
1154 case 1:
1155 switch (md) {
1156 case 0:
1157 snprintf(buf, len, "ldc r%d, spc", rm);
1158 break;
1159 }
1160 break;
1161
1162 case 2:
1163 snprintf(buf, len, "ldc r%d, r%d_bank", rm, md);
1164 break;
1165
1166 case 3:
1167 snprintf(buf, len, "ldc r%d, r%d_bank", rm, md+4);
1168 break;
1169 } /* end of switch (type) */
1170 }
1171
1172 static void
f_4f(const uint16_t * pc,char * buf,size_t len)1173 f_4f(const uint16_t *pc, char *buf, size_t len)
1174 {
1175 uint16_t insn = get_insn(pc);
1176 int rn, rm;
1177
1178 rn = (insn & 0x0f00) >> 8;
1179 rm = (insn & 0x00f0) >> 4;
1180 snprintf(buf, len, "mac.w @r%d+, @r%d+", rm, rn);
1181 }
1182
1183 static void
f_50(const uint16_t * pc,char * buf,size_t len)1184 f_50(const uint16_t *pc, char *buf, size_t len)
1185 {
1186 uint16_t insn = get_insn(pc);
1187 int rn, rm, disp;
1188
1189 rn = (insn & 0x0f00) >> 8;
1190 rm = (insn & 0x00f0) >> 4;
1191 disp = (insn & 0x000f);
1192 disp *= 4;
1193
1194 snprintf(buf, len, "mov.l @(%d, r%d), r%d", disp, rm, rn);
1195 }
1196
1197 static void
f_60(const uint16_t * pc,char * buf,size_t len)1198 f_60(const uint16_t *pc, char *buf, size_t len)
1199 {
1200 uint16_t insn = get_insn(pc);
1201 int rn, rm, md;
1202
1203 rn = (insn & 0x0f00) >> 8;
1204 rm = (insn & 0x00f0) >> 4;
1205 md = (insn & 0x0003);
1206
1207 switch (md) {
1208 case 0:
1209 snprintf(buf, len, "mov.b @r%d, r%d", rm, rn);
1210 break;
1211
1212 case 1:
1213 snprintf(buf, len, "mov.w @r%d, r%d", rm, rn);
1214 break;
1215
1216 case 2:
1217 snprintf(buf, len, "mov.l @r%d, r%d", rm, rn);
1218 break;
1219
1220 case 3:
1221 snprintf(buf, len, "mov r%d, r%d", rm, rn);
1222 break;
1223 } /* end of switch (md) */
1224 }
1225
1226 static void
f_64(const uint16_t * pc,char * buf,size_t len)1227 f_64(const uint16_t *pc, char *buf, size_t len)
1228 {
1229 uint16_t insn = get_insn(pc);
1230 int rn, rm, md;
1231
1232 rn = (insn & 0x0f00) >> 8;
1233 rm = (insn & 0x00f0) >> 4;
1234 md = (insn & 0x0003);
1235
1236 switch (md) {
1237 case 0:
1238 snprintf(buf, len, "mov.b @r%d+, r%d", rm, rn);
1239 break;
1240
1241 case 1:
1242 snprintf(buf, len, "mov.w @r%d+, r%d", rm, rn);
1243 break;
1244
1245 case 2:
1246 snprintf(buf, len, "mov.l @r%d+, r%d", rm, rn);
1247 break;
1248
1249 case 3:
1250 snprintf(buf, len, "not r%d, r%d", rm, rn);
1251 break;
1252 } /* end of switch (md) */
1253 }
1254
1255 static void
f_68(const uint16_t * pc,char * buf,size_t len)1256 f_68(const uint16_t *pc, char *buf, size_t len)
1257 {
1258 uint16_t insn = get_insn(pc);
1259 int rn, rm, md;
1260
1261 rn = (insn & 0x0f00) >> 8;
1262 rm = (insn & 0x00f0) >> 4;
1263 md = (insn & 0x0003);
1264
1265 switch (md) {
1266 case 0:
1267 snprintf(buf, len, "swap.b r%d, r%d", rm, rn);
1268 break;
1269
1270 case 1:
1271 snprintf(buf, len, "swap.w r%d, r%d", rm, rn);
1272 break;
1273
1274 case 2:
1275 snprintf(buf, len, "negc r%d, r%d", rm, rn);
1276 break;
1277
1278 case 3:
1279 snprintf(buf, len, "neg r%d, r%d", rm, rn);
1280 break;
1281 } /* end of switch (md) */
1282 }
1283
1284 static void
f_6c(const uint16_t * pc,char * buf,size_t len)1285 f_6c(const uint16_t *pc, char *buf, size_t len)
1286 {
1287 uint16_t insn = get_insn(pc);
1288 int rn, rm, md;
1289
1290 rn = (insn & 0x0f00) >> 8;
1291 rm = (insn & 0x00f0) >> 4;
1292 md = (insn & 0x0003);
1293
1294 switch (md) {
1295 case 0:
1296 snprintf(buf, len, "extu.b r%d, r%d", rm, rn);
1297 break;
1298
1299 case 1:
1300 snprintf(buf, len, "extu.w r%d, r%d", rm, rn);
1301 break;
1302
1303 case 2:
1304 snprintf(buf, len, "exts.b r%d, r%d", rm, rn);
1305 break;
1306
1307 case 3:
1308 snprintf(buf, len, "exts.w r%d, r%d", rm, rn);
1309 break;
1310 } /* end of switch (md) */
1311 }
1312
1313 static void
f_70(const uint16_t * pc,char * buf,size_t len)1314 f_70(const uint16_t *pc, char *buf, size_t len)
1315 {
1316 uint16_t insn = get_insn(pc);
1317 int rn, imm;
1318
1319 rn = (insn & 0x0f00) >> 8;
1320 imm = (int) ((char) (insn & 0x00ff));
1321
1322 snprintf(buf, len, "add #0x%x, r%d", imm, rn);
1323 }
1324
1325 static void
f_80(const uint16_t * pc,char * buf,size_t len)1326 f_80(const uint16_t *pc, char *buf, size_t len)
1327 {
1328 uint16_t insn = get_insn(pc);
1329 int type, md, rn, disp;
1330
1331 type = (insn & 0x0c00) >> 10;
1332 md = (insn & 0x0300) >> 8;
1333
1334 switch (type) {
1335 case 0:
1336 rn = (insn & 0x00f0) >> 4;
1337 disp = (insn & 0x000f);
1338
1339 switch (md) {
1340 case 0:
1341 snprintf(buf, len, "mov.b r0, @(%d, r%d)", disp, rn);
1342 break;
1343
1344 case 1:
1345 disp *= 2;
1346 snprintf(buf, len, "mov.w r0, @(%d, r%d)", disp, rn);
1347 break;
1348 }
1349 break;
1350
1351 case 1:
1352 rn = (insn & 0x00f0) >> 4;
1353 disp = (insn & 0x000f);
1354
1355 switch (md) {
1356 case 0:
1357 snprintf(buf, len, "mov.b @(%d, r%d), r0", disp, rn);
1358 break;
1359
1360 case 1:
1361 disp *= 2;
1362 snprintf(buf, len, "mov.w @(%d, r%d), r0", disp, rn);
1363 break;
1364 }
1365 break;
1366
1367 case 2:
1368 disp = (insn & 0x00ff);
1369
1370 switch (md) {
1371 case 0:
1372 snprintf(buf, len, "cmp/eq #%d, r0", disp);
1373 break;
1374
1375 case 1:
1376 disp = (int) ((char) disp);
1377 disp *= 2;
1378 snprintf(buf, len, "bt 0x%x", disp);
1379 break;
1380
1381 case 3:
1382 disp = (int) ((char) disp);
1383 disp *= 2;
1384 snprintf(buf, len, "bf 0x%x", disp);
1385 break;
1386 }
1387 break;
1388
1389 case 3:
1390 disp = (int) ((char) (insn & 0x00ff));
1391 disp *= 2;
1392
1393 switch (md) {
1394 case 1:
1395 snprintf(buf, len, "bt/s 0x%x", disp);
1396 break;
1397
1398 case 3:
1399 snprintf(buf, len, "bf/s 0x%x", disp);
1400 break;
1401 }
1402 break;
1403 } /* end of switch (type) */
1404 }
1405
1406 static void
f_90(const uint16_t * pc,char * buf,size_t len)1407 f_90(const uint16_t *pc, char *buf, size_t len)
1408 {
1409 uint16_t insn = get_insn(pc);
1410 int rn, disp;
1411
1412 rn = (insn & 0x0f00) >> 8;
1413 disp = (insn & 0x00ff);
1414 disp *= 2;
1415
1416 snprintf(buf, len, "mov.w @(%d, pc), r%d", disp, rn);
1417 }
1418
1419 static void
f_a0(const uint16_t * pc,char * buf,size_t len)1420 f_a0(const uint16_t *pc, char *buf, size_t len)
1421 {
1422 uint16_t insn = get_insn(pc);
1423 int disp;
1424
1425 disp = (insn & 0x0fff);
1426 if (disp & 0x0800) /* negative displacement? */
1427 disp |= 0xfffff000; /* sign extend */
1428 disp *= 2;
1429
1430 snprintf(buf, len, "bra %d(0x%x)", disp, disp);
1431 }
1432
1433 static void
f_b0(const uint16_t * pc,char * buf,size_t len)1434 f_b0(const uint16_t *pc, char *buf, size_t len)
1435 {
1436 uint16_t insn = get_insn(pc);
1437 int disp;
1438
1439 disp = (insn & 0x0fff);
1440 if (disp & 0x0800) /* negative displacement? */
1441 disp |= 0xfffff000; /* sign extend */
1442 disp *= 2;
1443
1444 snprintf(buf, len, "bsr %d(0x%x)", disp, disp);
1445 }
1446
1447 static void
f_c0(const uint16_t * pc,char * buf,size_t len)1448 f_c0(const uint16_t *pc, char *buf, size_t len)
1449 {
1450 uint16_t insn = get_insn(pc);
1451 int type, md, imm;
1452
1453 type = (insn & 0x0c00) >> 10;
1454 md = (insn & 0x0300) >> 8;
1455 imm = (insn & 0x00ff);
1456
1457 switch (type) {
1458 case 0:
1459 switch (md) {
1460 case 0:
1461 snprintf(buf, len, "mov.b r0, @(%d, gbr)", imm);
1462 break;
1463
1464 case 1:
1465 imm *= 2;
1466 snprintf(buf, len, "mov.w r0, @(%d, gbr)", imm);
1467 break;
1468
1469 case 2:
1470 imm *= 4;
1471 snprintf(buf, len, "mov.l r0, @(%d, gbr)", imm);
1472 break;
1473
1474 case 3:
1475 snprintf(buf, len, "trapa #0x%x", imm);
1476 break;
1477 }
1478 break;
1479
1480 case 1:
1481 switch (md) {
1482 case 0:
1483 snprintf(buf, len, "mov.b @(%d, gbr), r0", imm);
1484 break;
1485
1486 case 1:
1487 imm *= 2;
1488 snprintf(buf, len, "mov.w @(%d, gbr), r0", imm);
1489 break;
1490
1491 case 2:
1492 imm *= 4;
1493 snprintf(buf, len, "mov.l @(%d, gbr), r0", imm);
1494 break;
1495
1496 case 3:
1497 imm *= 4;
1498 snprintf(buf, len, "mova @(%d, pc), r0", imm);
1499 break;
1500 }
1501 break;
1502
1503 case 2:
1504 switch (md) {
1505 case 0:
1506 snprintf(buf, len, "tst #%d, r0", imm);
1507 break;
1508
1509 case 1:
1510 snprintf(buf, len, "and #%d, r0", imm);
1511 break;
1512
1513 case 2:
1514 snprintf(buf, len, "xor #%d, r0", imm);
1515 break;
1516
1517 case 3:
1518 snprintf(buf, len, "or #%d, r0", imm);
1519 break;
1520 }
1521 break;
1522
1523 case 3:
1524 switch (md) {
1525 case 0:
1526 snprintf(buf, len, "tst.b #%d, @(r0, gbr)", imm);
1527 break;
1528
1529 case 1:
1530 snprintf(buf, len, "and.b #%d, @(r0, gbr)", imm);
1531 break;
1532
1533 case 2:
1534 snprintf(buf, len, "xor.b #%d, @(r0, gbr)", imm);
1535 break;
1536
1537 case 3:
1538 snprintf(buf, len, "or.b #%d, @(r0, gbr)", imm);
1539 break;
1540 }
1541 break;
1542 } /* end of switch (type) */
1543 }
1544
1545
1546 static void
f_d0(const uint16_t * pc,char * buf,size_t len)1547 f_d0(const uint16_t *pc, char *buf, size_t len)
1548 {
1549 uint16_t insn = get_insn(pc);
1550 int rn, disp;
1551
1552 rn = (insn & 0x0f00) >> 8;
1553 disp = (insn & 0x00ff);
1554 disp *= 4;
1555
1556 snprintf(buf, len, "mov.l @(%d, pc), r%d", disp, rn);
1557 }
1558
1559 static void
f_e0(const uint16_t * pc,char * buf,size_t len)1560 f_e0(const uint16_t *pc, char *buf, size_t len)
1561 {
1562 uint16_t insn = get_insn(pc);
1563 int rn, imm;
1564
1565 rn = (insn & 0x0f00) >> 8;
1566 imm = (int) ((char) (insn & 0x00ff));
1567
1568 snprintf(buf, len, "mov #0x%x, r%d", imm, rn);
1569 }
1570
1571 static void
f_f0(const uint16_t * pc,char * buf,size_t len)1572 f_f0(const uint16_t *pc, char *buf, size_t len)
1573 {
1574 uint16_t insn = get_insn(pc);
1575 int rn, rm, md;
1576
1577 rn = (insn & 0x0f00) >> 8;
1578 rm = (insn & 0x00f0) >> 4;
1579 md = (insn & 0x0003);
1580
1581 switch (md) {
1582 case 0:
1583 snprintf(buf, len, "fadd fr%d, fr%d", rm, rn);
1584 break;
1585
1586 case 1:
1587 snprintf(buf, len, "fsub fr%d, fr%d", rm, rn);
1588 break;
1589
1590 case 2:
1591 snprintf(buf, len, "fmul fr%d, fr%d", rm, rn);
1592 break;
1593
1594 case 3:
1595 snprintf(buf, len, "fdiv fr%d, fr%d", rm, rn);
1596 break;
1597 } /* end of switch (md) */
1598 }
1599
1600 static void
f_f4(const uint16_t * pc,char * buf,size_t len)1601 f_f4(const uint16_t *pc, char *buf, size_t len)
1602 {
1603 uint16_t insn = get_insn(pc);
1604 int rn, rm, md;
1605
1606 rn = (insn & 0x0f00) >> 8;
1607 rm = (insn & 0x00f0) >> 4;
1608 md = (insn & 0x0003);
1609
1610 switch (md) {
1611 case 0:
1612 snprintf(buf, len, "fcmp/eq fr%d, fr%d", rm, rn);
1613 break;
1614
1615 case 1:
1616 snprintf(buf, len, "fcmp/gt fr%d, fr%d", rm, rn);
1617 break;
1618
1619 case 2:
1620 snprintf(buf, len, "fmov.s @(r0, r%d), fr%d", rm, rn);
1621 break;
1622
1623 case 3:
1624 snprintf(buf, len, "fmov.s fr%d, @(r0, r%d)", rm, rn);
1625 break;
1626 } /* end of switch (md) */
1627 }
1628
1629 static void
f_f8(const uint16_t * pc,char * buf,size_t len)1630 f_f8(const uint16_t *pc, char *buf, size_t len)
1631 {
1632 uint16_t insn = get_insn(pc);
1633 int rn, rm, md;
1634
1635 rn = (insn & 0x0f00) >> 8;
1636 rm = (insn & 0x00f0) >> 4;
1637 md = (insn & 0x0003);
1638
1639 switch (md) {
1640 case 0:
1641 snprintf(buf, len, "fmov.s @r%d, fr%d", rm, rn);
1642 break;
1643
1644 case 1:
1645 snprintf(buf, len, "fmov.s @r%d+, fr%d", rm, rn);
1646 break;
1647
1648 case 2:
1649 snprintf(buf, len, "fmov.s fr%d, @r%d", rm, rn);
1650 break;
1651
1652 case 3:
1653 snprintf(buf, len, "fmov.s fr%d, @-r%d", rm, rn);
1654 break;
1655 } /* end of switch (md) */
1656 }
1657
1658 static void
f_fc(const uint16_t * pc,char * buf,size_t len)1659 f_fc(const uint16_t *pc, char *buf, size_t len)
1660 {
1661 uint16_t insn = get_insn(pc);
1662 int rn, rm;
1663
1664 rn = (insn & 0x0f00) >> 8;
1665 rm = (insn & 0x00f0) >> 4;
1666
1667 snprintf(buf, len, "fmov fr%d, fr%d", rm, rn);
1668 }
1669
1670 static void
f_fd(const uint16_t * pc,char * buf,size_t len)1671 f_fd(const uint16_t *pc, char *buf, size_t len)
1672 {
1673 uint16_t insn = get_insn(pc);
1674 int rn, type, md;
1675
1676 rn = (insn & 0x0f00) >> 8;
1677 type = (insn & 0x00c0) >> 6;
1678 md = (insn & 0x0030) >> 4;
1679
1680 switch (type) {
1681 case 0:
1682 switch (md) {
1683 case 0:
1684 snprintf(buf, len, "fsts fpul, fr%d", rn);
1685 break;
1686
1687 case 1:
1688 snprintf(buf, len, "flds fr%d, fpul", rn);
1689 break;
1690
1691 case 2:
1692 snprintf(buf, len, "float fpul, fr%d", rn);
1693 break;
1694
1695 case 3:
1696 snprintf(buf, len, "ftrc fr%d, fpul", rn);
1697 break;
1698 }
1699 break;
1700
1701 case 1:
1702 switch (md) {
1703 case 0:
1704 snprintf(buf, len, "fneg fr%d", rn);
1705 break;
1706
1707 case 1:
1708 snprintf(buf, len, "fabs fr%d", rn);
1709 break;
1710
1711 case 2:
1712 snprintf(buf, len, "fsqrt fr%d", rn);
1713 break;
1714 }
1715 break;
1716
1717 case 2:
1718 switch (md) {
1719 case 0:
1720 case 1:
1721 snprintf(buf, len, "fldi%d fr%d", md, rn);
1722 break;
1723 }
1724 break;
1725 } /* end of switch (type) */
1726 }
1727
1728 static void
f_fe(const uint16_t * pc,char * buf,size_t len)1729 f_fe(const uint16_t *pc, char *buf, size_t len)
1730 {
1731 uint16_t insn = get_insn(pc);
1732 int rn, rm;
1733
1734 rn = (insn & 0x0f00) >> 8;
1735 rm = (insn & 0x00f0) >> 4;
1736
1737 snprintf(buf, len, "fmac fr0, fr%d, fr%d", rm, rn);
1738 }
1739