notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
cdrom: adjust timing
[pcsx_rearmed.git] / deps / lightrec / disassembler.c
... / ...
CommitLineData
1// SPDX-License-Identifier: LGPL-2.1-or-later
2/*
3 * Copyright (C) 2014-2021 Paul Cercueil <paul@crapouillou.net>
4 */
5
6#include <stdbool.h>
7#include <stdio.h>
8#include <stdlib.h>
9#include <string.h>
10
11#include "lightrec-private.h"
12#include "regcache.h"
13
14static const char * const std_opcodes[] = {
15 [OP_J] = "j ",
16 [OP_JAL] = "jal ",
17 [OP_BEQ] = "beq ",
18 [OP_BNE] = "bne ",
19 [OP_BLEZ] = "blez ",
20 [OP_BGTZ] = "bgtz ",
21 [OP_ADDI] = "addi ",
22 [OP_ADDIU] = "addiu ",
23 [OP_SLTI] = "slti ",
24 [OP_SLTIU] = "sltiu ",
25 [OP_ANDI] = "andi ",
26 [OP_ORI] = "ori ",
27 [OP_XORI] = "xori ",
28 [OP_LUI] = "lui ",
29 [OP_LB] = "lb ",
30 [OP_LH] = "lh ",
31 [OP_LWL] = "lwl ",
32 [OP_LW] = "lw ",
33 [OP_LBU] = "lbu ",
34 [OP_LHU] = "lhu ",
35 [OP_LWR] = "lwr ",
36 [OP_SB] = "sb ",
37 [OP_SH] = "sh ",
38 [OP_SWL] = "swl ",
39 [OP_SW] = "sw ",
40 [OP_SWR] = "swr ",
41 [OP_LWC2] = "lwc2 ",
42 [OP_SWC2] = "swc2 ",
43 [OP_META_MULT2] = "mult2 ",
44 [OP_META_MULTU2] = "multu2 ",
45 [OP_META_LWU] = "lwu ",
46 [OP_META_SWU] = "swu ",
47};
48
49static const char * const special_opcodes[] = {
50 [OP_SPECIAL_SLL] = "sll ",
51 [OP_SPECIAL_SRL] = "srl ",
52 [OP_SPECIAL_SRA] = "sra ",
53 [OP_SPECIAL_SLLV] = "sllv ",
54 [OP_SPECIAL_SRLV] = "srlv ",
55 [OP_SPECIAL_SRAV] = "srav ",
56 [OP_SPECIAL_JR] = "jr ",
57 [OP_SPECIAL_JALR] = "jalr ",
58 [OP_SPECIAL_SYSCALL] = "syscall ",
59 [OP_SPECIAL_BREAK] = "break ",
60 [OP_SPECIAL_MFHI] = "mfhi ",
61 [OP_SPECIAL_MTHI] = "mthi ",
62 [OP_SPECIAL_MFLO] = "mflo ",
63 [OP_SPECIAL_MTLO] = "mtlo ",
64 [OP_SPECIAL_MULT] = "mult ",
65 [OP_SPECIAL_MULTU] = "multu ",
66 [OP_SPECIAL_DIV] = "div ",
67 [OP_SPECIAL_DIVU] = "divu ",
68 [OP_SPECIAL_ADD] = "add ",
69 [OP_SPECIAL_ADDU] = "addu ",
70 [OP_SPECIAL_SUB] = "sub ",
71 [OP_SPECIAL_SUBU] = "subu ",
72 [OP_SPECIAL_AND] = "and ",
73 [OP_SPECIAL_OR] = "or ",
74 [OP_SPECIAL_XOR] = "xor ",
75 [OP_SPECIAL_NOR] = "nor ",
76 [OP_SPECIAL_SLT] = "slt ",
77 [OP_SPECIAL_SLTU] = "sltu ",
78};
79
80static const char * const regimm_opcodes[] = {
81 [OP_REGIMM_BLTZ] = "bltz ",
82 [OP_REGIMM_BGEZ] = "bgez ",
83 [OP_REGIMM_BLTZAL] = "bltzal ",
84 [OP_REGIMM_BGEZAL] = "bgezal ",
85};
86
87static const char * const cp0_opcodes[] = {
88 [OP_CP0_MFC0] = "mfc0 ",
89 [OP_CP0_CFC0] = "cfc0 ",
90 [OP_CP0_MTC0] = "mtc0 ",
91 [OP_CP0_CTC0] = "ctc0 ",
92 [OP_CP0_RFE] = "rfe",
93};
94
95static const char * const cp2_basic_opcodes[] = {
96 [OP_CP2_BASIC_MFC2] = "mfc2 ",
97 [OP_CP2_BASIC_CFC2] = "cfc2 ",
98 [OP_CP2_BASIC_MTC2] = "mtc2 ",
99 [OP_CP2_BASIC_CTC2] = "ctc2 ",
100};
101
102static const char * const cp2_opcodes[] = {
103 [OP_CP2_RTPS] = "rtps ",
104 [OP_CP2_NCLIP] = "nclip ",
105 [OP_CP2_OP] = "op ",
106 [OP_CP2_DPCS] = "dpcs ",
107 [OP_CP2_INTPL] = "intpl ",
108 [OP_CP2_MVMVA] = "mvmva ",
109 [OP_CP2_NCDS] = "ncds ",
110 [OP_CP2_CDP] = "cdp ",
111 [OP_CP2_NCDT] = "ncdt ",
112 [OP_CP2_NCCS] = "nccs ",
113 [OP_CP2_CC] = "cc ",
114 [OP_CP2_NCS] = "ncs ",
115 [OP_CP2_NCT] = "nct ",
116 [OP_CP2_SQR] = "sqr ",
117 [OP_CP2_DCPL] = "dcpl ",
118 [OP_CP2_DPCT] = "dpct ",
119 [OP_CP2_AVSZ3] = "avsz3 ",
120 [OP_CP2_AVSZ4] = "avsz4 ",
121 [OP_CP2_RTPT] = "rtpt ",
122 [OP_CP2_GPF] = "gpf ",
123 [OP_CP2_GPL] = "gpl ",
124 [OP_CP2_NCCT] = "ncct ",
125};
126
127static const char * const meta_opcodes[] = {
128 [OP_META_MOV] = "move ",
129 [OP_META_EXTC] = "extc ",
130 [OP_META_EXTS] = "exts ",
131 [OP_META_COM] = "com ",
132};
133
134static const char * const mult2_opcodes[] = {
135 "mult2 ", "multu2 ",
136};
137
138static const char * const opcode_flags[] = {
139 "switched branch/DS",
140 "sync point",
141};
142
143static const char * const opcode_io_flags[] = {
144 "self-modifying code",
145 "no invalidation",
146 "no mask",
147 "load delay",
148};
149
150static const char * const opcode_io_modes[] = {
151 "Memory access",
152 "I/O access",
153 "RAM access",
154 "BIOS access",
155 "Scratchpad access",
156 "Mapped I/O access"
157};
158
159static const char * const opcode_branch_flags[] = {
160 "emulate branch",
161 "local branch",
162};
163
164static const char * const opcode_movi_flags[] = {
165 "movi",
166};
167
168static const char * const opcode_multdiv_flags[] = {
169 "No LO",
170 "No HI",
171 "No div check",
172};
173
174static size_t do_snprintf(char *buf, size_t len, bool *first,
175 const char *arg1, const char *arg2)
176{
177 size_t bytes;
178
179 if (*first)
180 bytes = snprintf(buf, len, "(%s%s", arg1, arg2);
181 else
182 bytes = snprintf(buf, len, ", %s%s", arg1, arg2);
183
184 *first = false;
185
186 return bytes;
187}
188
189static const char * const reg_op_token[3] = {
190 "-", "*", "~",
191};
192
193static int print_flags(char *buf, size_t len, const struct opcode *op,
194 const char * const *array, size_t array_size,
195 bool is_io)
196{
197 const char *flag_name, *io_mode_name;
198 unsigned int i, io_mode;
199 size_t count = 0, bytes;
200 bool first = true;
201 u32 flags = op->flags;
202 unsigned int reg_op;
203
204 for (i = 0; i < array_size + ARRAY_SIZE(opcode_flags); i++) {
205 if (!(flags & BIT(i)))
206 continue;
207
208 if (i < ARRAY_SIZE(opcode_flags))
209 flag_name = opcode_flags[i];
210 else
211 flag_name = array[i - ARRAY_SIZE(opcode_flags)];
212
213 bytes = do_snprintf(buf, len, &first, "", flag_name);
214 buf += bytes;
215 len -= bytes;
216 count += bytes;
217 }
218
219 if (is_io) {
220 io_mode = LIGHTREC_FLAGS_GET_IO_MODE(flags);
221 if (io_mode > 0) {
222 io_mode_name = opcode_io_modes[io_mode - 1];
223
224 bytes = do_snprintf(buf, len, &first, "", io_mode_name);
225 buf += bytes;
226 len -= bytes;
227 count += bytes;
228 }
229 }
230
231 if (OPT_EARLY_UNLOAD) {
232 reg_op = LIGHTREC_FLAGS_GET_RS(flags);
233 if (reg_op) {
234 bytes = do_snprintf(buf, len, &first,
235 reg_op_token[reg_op - 1],
236 lightrec_reg_name(op->i.rs));
237 buf += bytes;
238 len -= bytes;
239 count += bytes;
240 }
241
242 reg_op = LIGHTREC_FLAGS_GET_RT(flags);
243 if (reg_op) {
244 bytes = do_snprintf(buf, len, &first,
245 reg_op_token[reg_op - 1],
246 lightrec_reg_name(op->i.rt));
247 buf += bytes;
248 len -= bytes;
249 count += bytes;
250 }
251
252 reg_op = LIGHTREC_FLAGS_GET_RD(flags);
253 if (reg_op) {
254 bytes = do_snprintf(buf, len, &first,
255 reg_op_token[reg_op - 1],
256 lightrec_reg_name(op->r.rd));
257 buf += bytes;
258 len -= bytes;
259 count += bytes;
260 }
261 }
262
263 if (!first)
264 count += snprintf(buf, len, ")");
265 else
266 *buf = '\0';
267
268 return count;
269}
270
271static int print_op_special(union code c, char *buf, size_t len,
272 const char * const **flags_ptr, size_t *nb_flags)
273{
274 switch (c.r.op) {
275 case OP_SPECIAL_SLL:
276 case OP_SPECIAL_SRL:
277 case OP_SPECIAL_SRA:
278 return snprintf(buf, len, "%s%s,%s,%u",
279 special_opcodes[c.r.op],
280 lightrec_reg_name(c.r.rd),
281 lightrec_reg_name(c.r.rt),
282 c.r.imm);
283 case OP_SPECIAL_SLLV:
284 case OP_SPECIAL_SRLV:
285 case OP_SPECIAL_SRAV:
286 case OP_SPECIAL_ADD:
287 case OP_SPECIAL_ADDU:
288 case OP_SPECIAL_SUB:
289 case OP_SPECIAL_SUBU:
290 case OP_SPECIAL_AND:
291 case OP_SPECIAL_OR:
292 case OP_SPECIAL_XOR:
293 case OP_SPECIAL_NOR:
294 case OP_SPECIAL_SLT:
295 case OP_SPECIAL_SLTU:
296 return snprintf(buf, len, "%s%s,%s,%s",
297 special_opcodes[c.r.op],
298 lightrec_reg_name(c.r.rd),
299 lightrec_reg_name(c.r.rt),
300 lightrec_reg_name(c.r.rs));
301 case OP_SPECIAL_JR:
302 *flags_ptr = opcode_branch_flags;
303 *nb_flags = ARRAY_SIZE(opcode_branch_flags);
304 fallthrough;
305 case OP_SPECIAL_MTHI:
306 case OP_SPECIAL_MTLO:
307 return snprintf(buf, len, "%s%s",
308 special_opcodes[c.r.op],
309 lightrec_reg_name(c.r.rs));
310 case OP_SPECIAL_JALR:
311 return snprintf(buf, len, "%s%s,%s",
312 special_opcodes[c.r.op],
313 lightrec_reg_name(c.r.rd),
314 lightrec_reg_name(c.r.rs));
315 case OP_SPECIAL_SYSCALL:
316 case OP_SPECIAL_BREAK:
317 return snprintf(buf, len, "%s", special_opcodes[c.r.op]);
318 case OP_SPECIAL_MFHI:
319 case OP_SPECIAL_MFLO:
320 return snprintf(buf, len, "%s%s",
321 special_opcodes[c.r.op],
322 lightrec_reg_name(c.r.rd));
323 case OP_SPECIAL_MULT:
324 case OP_SPECIAL_MULTU:
325 case OP_SPECIAL_DIV:
326 case OP_SPECIAL_DIVU:
327 *flags_ptr = opcode_multdiv_flags;
328 *nb_flags = ARRAY_SIZE(opcode_multdiv_flags);
329 return snprintf(buf, len, "%s%s,%s,%s,%s",
330 special_opcodes[c.r.op],
331 lightrec_reg_name(get_mult_div_hi(c)),
332 lightrec_reg_name(get_mult_div_lo(c)),
333 lightrec_reg_name(c.r.rs),
334 lightrec_reg_name(c.r.rt));
335 default:
336 return snprintf(buf, len, "unknown (0x%08x)", c.opcode);
337 }
338}
339
340static int print_op_cp(union code c, char *buf, size_t len, unsigned int cp)
341{
342 if (cp == 2) {
343 switch (c.r.op) {
344 case OP_CP2_BASIC:
345 return snprintf(buf, len, "%s%s,%u",
346 cp2_basic_opcodes[c.i.rs],
347 lightrec_reg_name(c.i.rt),
348 c.r.rd);
349 default:
350 return snprintf(buf, len, "%s", cp2_opcodes[c.r.op]);
351 }
352 } else {
353 switch (c.i.rs) {
354 case OP_CP0_MFC0:
355 case OP_CP0_CFC0:
356 case OP_CP0_MTC0:
357 case OP_CP0_CTC0:
358 return snprintf(buf, len, "%s%s,%u",
359 cp0_opcodes[c.i.rs],
360 lightrec_reg_name(c.i.rt),
361 c.r.rd);
362 case OP_CP0_RFE:
363 return snprintf(buf, len, "rfe ");
364 default:
365 return snprintf(buf, len, "unknown (0x%08x)", c.opcode);
366 }
367 }
368}
369
370static int print_op(union code c, u32 pc, char *buf, size_t len,
371 const char * const **flags_ptr, size_t *nb_flags,
372 bool *is_io)
373{
374 if (c.opcode == 0)
375 return snprintf(buf, len, "nop ");
376
377 switch (c.i.op) {
378 case OP_SPECIAL:
379 return print_op_special(c, buf, len, flags_ptr, nb_flags);
380 case OP_REGIMM:
381 *flags_ptr = opcode_branch_flags;
382 *nb_flags = ARRAY_SIZE(opcode_branch_flags);
383 return snprintf(buf, len, "%s%s,0x%x",
384 regimm_opcodes[c.i.rt],
385 lightrec_reg_name(c.i.rs),
386 pc + 4 + ((s16)c.i.imm << 2));
387 case OP_J:
388 case OP_JAL:
389 *flags_ptr = opcode_branch_flags;
390 *nb_flags = ARRAY_SIZE(opcode_branch_flags);
391 return snprintf(buf, len, "%s0x%x",
392 std_opcodes[c.i.op],
393 (pc & 0xf0000000) | (c.j.imm << 2));
394 case OP_BEQ:
395 if (c.i.rs == c.i.rt) {
396 *flags_ptr = opcode_branch_flags;
397 *nb_flags = ARRAY_SIZE(opcode_branch_flags);
398 return snprintf(buf, len, "b 0x%x",
399 pc + 4 + ((s16)c.i.imm << 2));
400 }
401 fallthrough;
402 case OP_BNE:
403 case OP_BLEZ:
404 case OP_BGTZ:
405 *flags_ptr = opcode_branch_flags;
406 *nb_flags = ARRAY_SIZE(opcode_branch_flags);
407 return snprintf(buf, len, "%s%s,%s,0x%x",
408 std_opcodes[c.i.op],
409 lightrec_reg_name(c.i.rs),
410 lightrec_reg_name(c.i.rt),
411 pc + 4 + ((s16)c.i.imm << 2));
412 case OP_ADDI:
413 case OP_ADDIU:
414 case OP_ORI:
415 *flags_ptr = opcode_movi_flags;
416 *nb_flags = ARRAY_SIZE(opcode_movi_flags);
417 fallthrough;
418 case OP_SLTI:
419 case OP_SLTIU:
420 case OP_ANDI:
421 case OP_XORI:
422 return snprintf(buf, len, "%s%s,%s,0x%04hx",
423 std_opcodes[c.i.op],
424 lightrec_reg_name(c.i.rt),
425 lightrec_reg_name(c.i.rs),
426 (u16)c.i.imm);
427
428 case OP_LUI:
429 *flags_ptr = opcode_movi_flags;
430 *nb_flags = ARRAY_SIZE(opcode_movi_flags);
431 return snprintf(buf, len, "%s%s,0x%04hx",
432 std_opcodes[c.i.op],
433 lightrec_reg_name(c.i.rt),
434 (u16)c.i.imm);
435 case OP_CP0:
436 return print_op_cp(c, buf, len, 0);
437 case OP_CP2:
438 return print_op_cp(c, buf, len, 2);
439 case OP_LB:
440 case OP_LH:
441 case OP_LWL:
442 case OP_LW:
443 case OP_LBU:
444 case OP_LHU:
445 case OP_LWR:
446 case OP_SB:
447 case OP_SH:
448 case OP_SWL:
449 case OP_SW:
450 case OP_SWR:
451 case OP_META_LWU:
452 case OP_META_SWU:
453 *flags_ptr = opcode_io_flags;
454 *nb_flags = ARRAY_SIZE(opcode_io_flags);
455 *is_io = true;
456 return snprintf(buf, len, "%s%s,%hd(%s)",
457 std_opcodes[c.i.op],
458 lightrec_reg_name(c.i.rt),
459 (s16)c.i.imm,
460 lightrec_reg_name(c.i.rs));
461 case OP_LWC2:
462 case OP_SWC2:
463 *flags_ptr = opcode_io_flags;
464 *nb_flags = ARRAY_SIZE(opcode_io_flags);
465 return snprintf(buf, len, "%s%s,%hd(%s)",
466 std_opcodes[c.i.op],
467 lightrec_reg_name(c.i.rt),
468 (s16)c.i.imm,
469 lightrec_reg_name(c.i.rs));
470 case OP_META:
471 return snprintf(buf, len, "%s%s,%s",
472 meta_opcodes[c.m.op],
473 lightrec_reg_name(c.m.rd),
474 lightrec_reg_name(c.m.rs));
475 case OP_META_MULT2:
476 case OP_META_MULTU2:
477 *flags_ptr = opcode_multdiv_flags;
478 *nb_flags = ARRAY_SIZE(opcode_multdiv_flags);
479 return snprintf(buf, len, "%s%s,%s,%s,%u",
480 mult2_opcodes[c.i.op == OP_META_MULTU2],
481 lightrec_reg_name(get_mult_div_hi(c)),
482 lightrec_reg_name(get_mult_div_lo(c)),
483 lightrec_reg_name(c.r.rs), c.r.op);
484 default:
485 return snprintf(buf, len, "unknown (0x%08x)", c.opcode);
486 }
487}
488
489void lightrec_print_disassembly(const struct block *block, const u32 *code_ptr)
490{
491 const struct opcode *op;
492 const char * const *flags_ptr;
493 size_t nb_flags, count, count2;
494 char buf[256], buf2[256], buf3[256];
495 unsigned int i;
496 u32 pc, branch_pc, code;
497 bool is_io;
498
499 for (i = 0; i < block->nb_ops; i++) {
500 op = &block->opcode_list[i];
501 branch_pc = get_branch_pc(block, i, 0);
502 pc = block->pc + (i << 2);
503 code = LE32TOH(code_ptr[i]);
504
505 count = print_op((union code)code, pc, buf, sizeof(buf),
506 &flags_ptr, &nb_flags, &is_io);
507
508 flags_ptr = NULL;
509 nb_flags = 0;
510 is_io = false;
511 count2 = print_op(op->c, branch_pc, buf2, sizeof(buf2),
512 &flags_ptr, &nb_flags, &is_io);
513
514 if (code == op->c.opcode) {
515 *buf2 = '\0';
516 count2 = 0;
517 }
518
519 print_flags(buf3, sizeof(buf3), op, flags_ptr, nb_flags, is_io);
520
521 printf("0x%08x (0x%x)\t%s%*c%s%*c%s\n", pc, i << 2,
522 buf, 30 - (int)count, ' ', buf2, 30 - (int)count2, ' ', buf3);
523 }
524}
ARM optimized PCSX fork