notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git subrepo clone https://github.com/pcercuei/lightrec.git deps/lightrec
[pcsx_rearmed.git] / deps / lightrec / emitter.c
CommitLineData
d16005f8
PC		 1/*
2 * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 */
14
15#include "blockcache.h"
16#include "debug.h"
17#include "disassembler.h"
18#include "emitter.h"
19#include "optimizer.h"
20#include "regcache.h"
21
22#include <lightning.h>
23#include <stdbool.h>
24#include <stddef.h>
25
26typedef void (*lightrec_rec_func_t)(const struct block *,
27 const struct opcode *, u32);
28
29/* Forward declarations */
30static void rec_SPECIAL(const struct block *block,
31 const struct opcode *op, u32 pc);
32static void rec_REGIMM(const struct block *block,
33 const struct opcode *op, u32 pc);
34static void rec_CP0(const struct block *block, const struct opcode *op, u32 pc);
35static void rec_CP2(const struct block *block, const struct opcode *op, u32 pc);
36
37
38static void unknown_opcode(const struct block *block,
39 const struct opcode *op, u32 pc)
40{
41 pr_warn("Unknown opcode: 0x%08x at PC 0x%08x\n", op->opcode, pc);
42}
43
44static void lightrec_emit_end_of_block(const struct block *block,
45 const struct opcode *op, u32 pc,
46 s8 reg_new_pc, u32 imm, u8 ra_reg,
47 u32 link, bool update_cycles)
48{
49 struct lightrec_state *state = block->state;
50 struct regcache *reg_cache = state->reg_cache;
51 u32 cycles = state->cycles;
52 jit_state_t *_jit = block->_jit;
53
54 jit_note(__FILE__, __LINE__);
55
56 if (link) {
57 /* Update the $ra register */
58 u8 link_reg = lightrec_alloc_reg_out(reg_cache, _jit, ra_reg);
59 jit_movi(link_reg, link);
60 lightrec_free_reg(reg_cache, link_reg);
61 }
62
63 if (reg_new_pc < 0) {
64 reg_new_pc = lightrec_alloc_reg(reg_cache, _jit, JIT_V0);
65 lightrec_lock_reg(reg_cache, _jit, reg_new_pc);
66
67 jit_movi(reg_new_pc, imm);
68 }
69
70 if (has_delay_slot(op->c) &&
71 !(op->flags & (LIGHTREC_NO_DS | LIGHTREC_LOCAL_BRANCH))) {
72 cycles += lightrec_cycles_of_opcode(op->next->c);
73
74 /* Recompile the delay slot */
75 if (op->next->c.opcode)
76 lightrec_rec_opcode(block, op->next, pc + 4);
77 }
78
79 /* Store back remaining registers */
80 lightrec_storeback_regs(reg_cache, _jit);
81
82 jit_movr(JIT_V0, reg_new_pc);
83
84 if (cycles && update_cycles) {
85 jit_subi(LIGHTREC_REG_CYCLE, LIGHTREC_REG_CYCLE, cycles);
86 pr_debug("EOB: %u cycles\n", cycles);
87 }
88
89 if (op->next && ((op->flags & LIGHTREC_NO_DS) || op->next->next))
90 state->branches[state->nb_branches++] = jit_jmpi();
91}
92
93void lightrec_emit_eob(const struct block *block,
94 const struct opcode *op, u32 pc)
95{
96 struct lightrec_state *state = block->state;
97 struct regcache *reg_cache = state->reg_cache;
98 jit_state_t *_jit = block->_jit;
99
100 lightrec_storeback_regs(reg_cache, _jit);
101
102 jit_movi(JIT_V0, pc);
103 jit_subi(LIGHTREC_REG_CYCLE, LIGHTREC_REG_CYCLE,
104 state->cycles - lightrec_cycles_of_opcode(op->c));
105
106 state->branches[state->nb_branches++] = jit_jmpi();
107}
108
109static void rec_special_JR(const struct block *block,
110 const struct opcode *op, u32 pc)
111{
112 struct regcache *reg_cache = block->state->reg_cache;
113 jit_state_t *_jit = block->_jit;
114 u8 rs = lightrec_request_reg_in(reg_cache, _jit, op->r.rs, JIT_V0);
115
116 _jit_name(block->_jit, __func__);
117 lightrec_lock_reg(reg_cache, _jit, rs);
118 lightrec_emit_end_of_block(block, op, pc, rs, 0, 31, 0, true);
119}
120
121static void rec_special_JALR(const struct block *block,
122 const struct opcode *op, u32 pc)
123{
124 struct regcache *reg_cache = block->state->reg_cache;
125 jit_state_t *_jit = block->_jit;
126 u8 rs = lightrec_request_reg_in(reg_cache, _jit, op->r.rs, JIT_V0);
127
128 _jit_name(block->_jit, __func__);
129 lightrec_lock_reg(reg_cache, _jit, rs);
130 lightrec_emit_end_of_block(block, op, pc, rs, 0, op->r.rd, pc + 8, true);
131}
132
133static void rec_J(const struct block *block, const struct opcode *op, u32 pc)
134{
135 _jit_name(block->_jit, __func__);
136 lightrec_emit_end_of_block(block, op, pc, -1,
137 (pc & 0xf0000000) | (op->j.imm << 2), 31, 0, true);
138}
139
140static void rec_JAL(const struct block *block, const struct opcode *op, u32 pc)
141{
142 _jit_name(block->_jit, __func__);
143 lightrec_emit_end_of_block(block, op, pc, -1,
144 (pc & 0xf0000000) | (op->j.imm << 2),
145 31, pc + 8, true);
146}
147
148static void rec_b(const struct block *block, const struct opcode *op, u32 pc,
149 jit_code_t code, u32 link, bool unconditional, bool bz)
150{
151 struct regcache *reg_cache = block->state->reg_cache;
152 struct native_register *regs_backup;
153 jit_state_t *_jit = block->_jit;
154 struct lightrec_branch *branch;
155 jit_node_t *addr;
156 u8 link_reg;
157 u32 offset, cycles = block->state->cycles;
158 bool is_forward = (s16)op->i.imm >= -1;
159
160 jit_note(__FILE__, __LINE__);
161
162 if (!(op->flags & LIGHTREC_NO_DS))
163 cycles += lightrec_cycles_of_opcode(op->next->c);
164
165 block->state->cycles = 0;
166
167 if (cycles)
168 jit_subi(LIGHTREC_REG_CYCLE, LIGHTREC_REG_CYCLE, cycles);
169
170 if (!unconditional) {
171 u8 rs = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->i.rs),
172 rt = bz ? 0 : lightrec_alloc_reg_in_ext(reg_cache,
173 _jit, op->i.rt);
174
175 /* Generate the branch opcode */
176 addr = jit_new_node_pww(code, NULL, rs, rt);
177
178 lightrec_free_regs(reg_cache);
179 regs_backup = lightrec_regcache_enter_branch(reg_cache);
180 }
181
182 if (op->flags & LIGHTREC_LOCAL_BRANCH) {
183 if (op->next && !(op->flags & LIGHTREC_NO_DS)) {
184 /* Recompile the delay slot */
185 if (op->next->opcode)
186 lightrec_rec_opcode(block, op->next, pc + 4);
187 }
188
189 if (link) {
190 /* Update the $ra register */
191 link_reg = lightrec_alloc_reg_out(reg_cache, _jit, 31);
192 jit_movi(link_reg, link);
193 lightrec_free_reg(reg_cache, link_reg);
194 }
195
196 /* Store back remaining registers */
197 lightrec_storeback_regs(reg_cache, _jit);
198
199 offset = op->offset + 1 + (s16)op->i.imm;
200 pr_debug("Adding local branch to offset 0x%x\n", offset << 2);
201 branch = &block->state->local_branches[
202 block->state->nb_local_branches++];
203
204 branch->target = offset;
205 if (is_forward)
206 branch->branch = jit_jmpi();
207 else
208 branch->branch = jit_bgti(LIGHTREC_REG_CYCLE, 0);
209 }
210
211 if (!(op->flags & LIGHTREC_LOCAL_BRANCH) || !is_forward) {
212 lightrec_emit_end_of_block(block, op, pc, -1,
213 pc + 4 + ((s16)op->i.imm << 2),
214 31, link, false);
215 }
216
217 if (!unconditional) {
218 jit_patch(addr);
219 lightrec_regcache_leave_branch(reg_cache, regs_backup);
220
221 if (bz && link) {
222 /* Update the $ra register */
223 link_reg = lightrec_alloc_reg_out_ext(reg_cache,
224 _jit, 31);
225 jit_movi(link_reg, (s32)link);
226 lightrec_free_reg(reg_cache, link_reg);
227 }
228
229 if (!(op->flags & LIGHTREC_NO_DS) && op->next->opcode)
230 lightrec_rec_opcode(block, op->next, pc + 4);
231 }
232}
233
234static void rec_BNE(const struct block *block, const struct opcode *op, u32 pc)
235{
236 _jit_name(block->_jit, __func__);
237 rec_b(block, op, pc, jit_code_beqr, 0, false, false);
238}
239
240static void rec_BEQ(const struct block *block, const struct opcode *op, u32 pc)
241{
242 _jit_name(block->_jit, __func__);
243 rec_b(block, op, pc, jit_code_bner, 0,
244 op->i.rs == op->i.rt, false);
245}
246
247static void rec_BLEZ(const struct block *block, const struct opcode *op, u32 pc)
248{
249 _jit_name(block->_jit, __func__);
250 rec_b(block, op, pc, jit_code_bgti, 0, op->i.rs == 0, true);
251}
252
253static void rec_BGTZ(const struct block *block, const struct opcode *op, u32 pc)
254{
255 _jit_name(block->_jit, __func__);
256 rec_b(block, op, pc, jit_code_blei, 0, false, true);
257}
258
259static void rec_regimm_BLTZ(const struct block *block,
260 const struct opcode *op, u32 pc)
261{
262 _jit_name(block->_jit, __func__);
263 rec_b(block, op, pc, jit_code_bgei, 0, false, true);
264}
265
266static void rec_regimm_BLTZAL(const struct block *block,
267 const struct opcode *op, u32 pc)
268{
269 _jit_name(block->_jit, __func__);
270 rec_b(block, op, pc, jit_code_bgei, pc + 8, false, true);
271}
272
273static void rec_regimm_BGEZ(const struct block *block,
274 const struct opcode *op, u32 pc)
275{
276 _jit_name(block->_jit, __func__);
277 rec_b(block, op, pc, jit_code_blti, 0, !op->i.rs, true);
278}
279
280static void rec_regimm_BGEZAL(const struct block *block,
281 const struct opcode *op, u32 pc)
282{
283 _jit_name(block->_jit, __func__);
284 rec_b(block, op, pc, jit_code_blti, pc + 8, !op->i.rs, true);
285}
286
287static void rec_alu_imm(const struct block *block, const struct opcode *op,
288 jit_code_t code, bool sign_extend)
289{
290 struct regcache *reg_cache = block->state->reg_cache;
291 jit_state_t *_jit = block->_jit;
292 u8 rs, rt;
293
294 jit_note(__FILE__, __LINE__);
295 rs = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->i.rs);
296 rt = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->i.rt);
297
298 if (sign_extend)
299 jit_new_node_www(code, rt, rs, (s32)(s16) op->i.imm);
300 else
301 jit_new_node_www(code, rt, rs, (u32)(u16) op->i.imm);
302
303 lightrec_free_reg(reg_cache, rs);
304 lightrec_free_reg(reg_cache, rt);
305}
306
307static void rec_alu_special(const struct block *block, const struct opcode *op,
308 jit_code_t code, bool out_ext)
309{
310 struct regcache *reg_cache = block->state->reg_cache;
311 jit_state_t *_jit = block->_jit;
312 u8 rd, rt, rs;
313
314 jit_note(__FILE__, __LINE__);
315 rs = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rs);
316 rt = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rt);
317
318 if (out_ext)
319 rd = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->r.rd);
320 else
321 rd = lightrec_alloc_reg_out(reg_cache, _jit, op->r.rd);
322
323 jit_new_node_www(code, rd, rs, rt);
324
325 lightrec_free_reg(reg_cache, rs);
326 lightrec_free_reg(reg_cache, rt);
327 lightrec_free_reg(reg_cache, rd);
328}
329
330static void rec_alu_shiftv(const struct block *block,
331 const struct opcode *op, jit_code_t code)
332{
333 struct regcache *reg_cache = block->state->reg_cache;
334 jit_state_t *_jit = block->_jit;
335 u8 rd, rt, rs, temp;
336
337 jit_note(__FILE__, __LINE__);
338 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rs);
339 temp = lightrec_alloc_reg_temp(reg_cache, _jit);
340
341 if (code == jit_code_rshr) {
342 rt = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rt);
343 rd = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->r.rd);
344 } else {
345 rt = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rt);
346 rd = lightrec_alloc_reg_out(reg_cache, _jit, op->r.rd);
347 }
348
349 jit_andi(temp, rs, 0x1f);
350
351#if __WORDSIZE == 64
352 if (code == jit_code_rshr_u) {
353 jit_extr_ui(rd, rt);
354 jit_new_node_www(code, rd, rd, temp);
355 }
356#endif
357
358 if (__WORDSIZE == 32 || code != jit_code_rshr_u)
359 jit_new_node_www(code, rd, rt, temp);
360
361 lightrec_free_reg(reg_cache, rs);
362 lightrec_free_reg(reg_cache, temp);
363 lightrec_free_reg(reg_cache, rt);
364 lightrec_free_reg(reg_cache, rd);
365}
366
367static void rec_ADDIU(const struct block *block,
368 const struct opcode *op, u32 pc)
369{
370 _jit_name(block->_jit, __func__);
371 rec_alu_imm(block, op, jit_code_addi, true);
372}
373
374static void rec_ADDI(const struct block *block, const struct opcode *op, u32 pc)
375{
376 /* TODO: Handle the exception? */
377 _jit_name(block->_jit, __func__);
378 rec_alu_imm(block, op, jit_code_addi, true);
379}
380
381static void rec_SLTIU(const struct block *block,
382 const struct opcode *op, u32 pc)
383{
384 _jit_name(block->_jit, __func__);
385 rec_alu_imm(block, op, jit_code_lti_u, true);
386}
387
388static void rec_SLTI(const struct block *block, const struct opcode *op, u32 pc)
389{
390 _jit_name(block->_jit, __func__);
391 rec_alu_imm(block, op, jit_code_lti, true);
392}
393
394static void rec_ANDI(const struct block *block, const struct opcode *op, u32 pc)
395{
396 struct regcache *reg_cache = block->state->reg_cache;
397 jit_state_t *_jit = block->_jit;
398 u8 rs, rt;
399
400 _jit_name(block->_jit, __func__);
401 jit_note(__FILE__, __LINE__);
402 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->i.rs);
403 rt = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->i.rt);
404
405 /* PSX code uses ANDI 0xff / ANDI 0xffff a lot, which are basically
406 * casts to uint8_t / uint16_t. */
407 if (op->i.imm == 0xff)
408 jit_extr_uc(rt, rs);
409 else if (op->i.imm == 0xffff)
410 jit_extr_us(rt, rs);
411 else
412 jit_andi(rt, rs, (u32)(u16) op->i.imm);
413
414 lightrec_free_reg(reg_cache, rs);
415 lightrec_free_reg(reg_cache, rt);
416}
417
418static void rec_ORI(const struct block *block, const struct opcode *op, u32 pc)
419{
420 _jit_name(block->_jit, __func__);
421 rec_alu_imm(block, op, jit_code_ori, false);
422}
423
424static void rec_XORI(const struct block *block, const struct opcode *op, u32 pc)
425{
426 _jit_name(block->_jit, __func__);
427 rec_alu_imm(block, op, jit_code_xori, false);
428}
429
430static void rec_LUI(const struct block *block, const struct opcode *op, u32 pc)
431{
432 struct regcache *reg_cache = block->state->reg_cache;
433 jit_state_t *_jit = block->_jit;
434 u8 rt;
435
436 jit_name(__func__);
437 jit_note(__FILE__, __LINE__);
438 rt = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->i.rt);
439
440 jit_movi(rt, (s32)(op->i.imm << 16));
441
442 lightrec_free_reg(reg_cache, rt);
443}
444
445static void rec_special_ADDU(const struct block *block,
446 const struct opcode *op, u32 pc)
447{
448 _jit_name(block->_jit, __func__);
449 rec_alu_special(block, op, jit_code_addr, false);
450}
451
452static void rec_special_ADD(const struct block *block,
453 const struct opcode *op, u32 pc)
454{
455 /* TODO: Handle the exception? */
456 _jit_name(block->_jit, __func__);
457 rec_alu_special(block, op, jit_code_addr, false);
458}
459
460static void rec_special_SUBU(const struct block *block,
461 const struct opcode *op, u32 pc)
462{
463 _jit_name(block->_jit, __func__);
464 rec_alu_special(block, op, jit_code_subr, false);
465}
466
467static void rec_special_SUB(const struct block *block,
468 const struct opcode *op, u32 pc)
469{
470 /* TODO: Handle the exception? */
471 _jit_name(block->_jit, __func__);
472 rec_alu_special(block, op, jit_code_subr, false);
473}
474
475static void rec_special_AND(const struct block *block,
476 const struct opcode *op, u32 pc)
477{
478 _jit_name(block->_jit, __func__);
479 rec_alu_special(block, op, jit_code_andr, false);
480}
481
482static void rec_special_OR(const struct block *block,
483 const struct opcode *op, u32 pc)
484{
485 _jit_name(block->_jit, __func__);
486 rec_alu_special(block, op, jit_code_orr, false);
487}
488
489static void rec_special_XOR(const struct block *block,
490 const struct opcode *op, u32 pc)
491{
492 _jit_name(block->_jit, __func__);
493 rec_alu_special(block, op, jit_code_xorr, false);
494}
495
496static void rec_special_NOR(const struct block *block,
497 const struct opcode *op, u32 pc)
498{
499 struct regcache *reg_cache = block->state->reg_cache;
500 jit_state_t *_jit = block->_jit;
501 u8 rd;
502
503 jit_name(__func__);
504 rec_alu_special(block, op, jit_code_orr, false);
505 rd = lightrec_alloc_reg_out(reg_cache, _jit, op->r.rd);
506
507 jit_comr(rd, rd);
508
509 lightrec_free_reg(reg_cache, rd);
510}
511
512static void rec_special_SLTU(const struct block *block,
513 const struct opcode *op, u32 pc)
514{
515 _jit_name(block->_jit, __func__);
516 rec_alu_special(block, op, jit_code_ltr_u, true);
517}
518
519static void rec_special_SLT(const struct block *block,
520 const struct opcode *op, u32 pc)
521{
522 _jit_name(block->_jit, __func__);
523 rec_alu_special(block, op, jit_code_ltr, true);
524}
525
526static void rec_special_SLLV(const struct block *block,
527 const struct opcode *op, u32 pc)
528{
529 _jit_name(block->_jit, __func__);
530 rec_alu_shiftv(block, op, jit_code_lshr);
531}
532
533static void rec_special_SRLV(const struct block *block,
534 const struct opcode *op, u32 pc)
535{
536 _jit_name(block->_jit, __func__);
537 rec_alu_shiftv(block, op, jit_code_rshr_u);
538}
539
540static void rec_special_SRAV(const struct block *block,
541 const struct opcode *op, u32 pc)
542{
543 _jit_name(block->_jit, __func__);
544 rec_alu_shiftv(block, op, jit_code_rshr);
545}
546
547static void rec_alu_shift(const struct block *block,
548 const struct opcode *op, jit_code_t code)
549{
550 struct regcache *reg_cache = block->state->reg_cache;
551 jit_state_t *_jit = block->_jit;
552 u8 rd, rt;
553
554 jit_note(__FILE__, __LINE__);
555
556 if (code == jit_code_rshi) {
557 rt = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rt);
558 rd = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->r.rd);
559 } else {
560 rt = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rt);
561 rd = lightrec_alloc_reg_out(reg_cache, _jit, op->r.rd);
562 }
563
564#if __WORDSIZE == 64
565 if (code == jit_code_rshi_u) {
566 jit_extr_ui(rd, rt);
567 jit_new_node_www(code, rd, rd, op->r.imm);
568 }
569#endif
570 if (__WORDSIZE == 32 || code != jit_code_rshi_u)
571 jit_new_node_www(code, rd, rt, op->r.imm);
572
573 lightrec_free_reg(reg_cache, rt);
574 lightrec_free_reg(reg_cache, rd);
575}
576
577static void rec_special_SLL(const struct block *block,
578 const struct opcode *op, u32 pc)
579{
580 _jit_name(block->_jit, __func__);
581 rec_alu_shift(block, op, jit_code_lshi);
582}
583
584static void rec_special_SRL(const struct block *block,
585 const struct opcode *op, u32 pc)
586{
587 _jit_name(block->_jit, __func__);
588 rec_alu_shift(block, op, jit_code_rshi_u);
589}
590
591static void rec_special_SRA(const struct block *block,
592 const struct opcode *op, u32 pc)
593{
594 _jit_name(block->_jit, __func__);
595 rec_alu_shift(block, op, jit_code_rshi);
596}
597
598static void rec_alu_mult(const struct block *block,
599 const struct opcode *op, bool is_signed)
600{
601 struct regcache *reg_cache = block->state->reg_cache;
602 jit_state_t *_jit = block->_jit;
603 u8 lo, hi, rs, rt;
604
605 jit_note(__FILE__, __LINE__);
606
607 lo = lightrec_alloc_reg_out(reg_cache, _jit, REG_LO);
608 if (!(op->flags & LIGHTREC_MULT32))
609 hi = lightrec_alloc_reg_out_ext(reg_cache, _jit, REG_HI);
610 else if (__WORDSIZE == 64)
611 hi = lightrec_alloc_reg_temp(reg_cache, _jit);
612
613 if (__WORDSIZE == 32 || !is_signed) {
614 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rs);
615 rt = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rt);
616 } else {
617 rs = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rs);
618 rt = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rt);
619 }
620
621#if __WORDSIZE == 32
622 /* On 32-bit systems, do a 32*32->64 bit operation, or a 32*32->32 bit
623 * operation if the MULT was detected a 32-bit only. */
624 if (!(op->flags & LIGHTREC_MULT32)) {
625 if (is_signed)
626 jit_qmulr(lo, hi, rs, rt);
627 else
628 jit_qmulr_u(lo, hi, rs, rt);
629 } else {
630 jit_mulr(lo, rs, rt);
631 }
632#else
633 /* On 64-bit systems, do a 64*64->64 bit operation.
634 * The input registers must be 32 bits, so we first sign-extend (if
635 * mult) or clear (if multu) the input registers. */
636 if (is_signed) {
637 jit_mulr(lo, rs, rt);
638 } else {
639 jit_extr_ui(lo, rt);
640 jit_extr_ui(hi, rs);
641 jit_mulr(lo, hi, lo);
642 }
643
644 /* The 64-bit output value is in $lo, store the upper 32 bits in $hi */
645 if (!(op->flags & LIGHTREC_MULT32))
646 jit_rshi(hi, lo, 32);
647#endif
648
649 lightrec_free_reg(reg_cache, rs);
650 lightrec_free_reg(reg_cache, rt);
651 lightrec_free_reg(reg_cache, lo);
652 if (__WORDSIZE == 64 || !(op->flags & LIGHTREC_MULT32))
653 lightrec_free_reg(reg_cache, hi);
654}
655
656static void rec_alu_div(const struct block *block,
657 const struct opcode *op, bool is_signed)
658{
659 struct regcache *reg_cache = block->state->reg_cache;
660 jit_state_t *_jit = block->_jit;
661 jit_node_t *branch, *to_end;
662 u8 lo, hi, rs, rt;
663
664 jit_note(__FILE__, __LINE__);
665 lo = lightrec_alloc_reg_out(reg_cache, _jit, REG_LO);
666 hi = lightrec_alloc_reg_out(reg_cache, _jit, REG_HI);
667
668 if (__WORDSIZE == 32 || !is_signed) {
669 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rs);
670 rt = lightrec_alloc_reg_in(reg_cache, _jit, op->r.rt);
671 } else {
672 rs = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rs);
673 rt = lightrec_alloc_reg_in_ext(reg_cache, _jit, op->r.rt);
674 }
675
676 /* Jump to special handler if dividing by zero */
677 branch = jit_beqi(rt, 0);
678
679#if __WORDSIZE == 32
680 if (is_signed)
681 jit_qdivr(lo, hi, rs, rt);
682 else
683 jit_qdivr_u(lo, hi, rs, rt);
684#else
685 /* On 64-bit systems, the input registers must be 32 bits, so we first sign-extend
686 * (if div) or clear (if divu) the input registers. */
687 if (is_signed) {
688 jit_qdivr(lo, hi, rs, rt);
689 } else {
690 jit_extr_ui(lo, rt);
691 jit_extr_ui(hi, rs);
692 jit_qdivr_u(lo, hi, hi, lo);
693 }
694#endif
695
696 /* Jump above the div-by-zero handler */
697 to_end = jit_jmpi();
698
699 jit_patch(branch);
700
701 if (is_signed) {
702 jit_lti(lo, rs, 0);
703 jit_lshi(lo, lo, 1);
704 jit_subi(lo, lo, 1);
705 } else {
706 jit_movi(lo, 0xffffffff);
707 }
708
709 jit_movr(hi, rs);
710
711 jit_patch(to_end);
712
713 lightrec_free_reg(reg_cache, rs);
714 lightrec_free_reg(reg_cache, rt);
715 lightrec_free_reg(reg_cache, lo);
716 lightrec_free_reg(reg_cache, hi);
717}
718
719static void rec_special_MULT(const struct block *block,
720 const struct opcode *op, u32 pc)
721{
722 _jit_name(block->_jit, __func__);
723 rec_alu_mult(block, op, true);
724}
725
726static void rec_special_MULTU(const struct block *block,
727 const struct opcode *op, u32 pc)
728{
729 _jit_name(block->_jit, __func__);
730 rec_alu_mult(block, op, false);
731}
732
733static void rec_special_DIV(const struct block *block,
734 const struct opcode *op, u32 pc)
735{
736 _jit_name(block->_jit, __func__);
737 rec_alu_div(block, op, true);
738}
739
740static void rec_special_DIVU(const struct block *block,
741 const struct opcode *op, u32 pc)
742{
743 _jit_name(block->_jit, __func__);
744 rec_alu_div(block, op, false);
745}
746
747static void rec_alu_mv_lo_hi(const struct block *block, u8 dst, u8 src)
748{
749 struct regcache *reg_cache = block->state->reg_cache;
750 jit_state_t *_jit = block->_jit;
751
752 jit_note(__FILE__, __LINE__);
753 src = lightrec_alloc_reg_in(reg_cache, _jit, src);
754 dst = lightrec_alloc_reg_out_ext(reg_cache, _jit, dst);
755
756#if __WORDSIZE == 32
757 jit_movr(dst, src);
758#else
759 jit_extr_i(dst, src);
760#endif
761
762 lightrec_free_reg(reg_cache, src);
763 lightrec_free_reg(reg_cache, dst);
764}
765
766static void rec_special_MFHI(const struct block *block,
767 const struct opcode *op, u32 pc)
768{
769 _jit_name(block->_jit, __func__);
770 rec_alu_mv_lo_hi(block, op->r.rd, REG_HI);
771}
772
773static void rec_special_MTHI(const struct block *block,
774 const struct opcode *op, u32 pc)
775{
776 _jit_name(block->_jit, __func__);
777 rec_alu_mv_lo_hi(block, REG_HI, op->r.rs);
778}
779
780static void rec_special_MFLO(const struct block *block,
781 const struct opcode *op, u32 pc)
782{
783 _jit_name(block->_jit, __func__);
784 rec_alu_mv_lo_hi(block, op->r.rd, REG_LO);
785}
786
787static void rec_special_MTLO(const struct block *block,
788 const struct opcode *op, u32 pc)
789{
790 _jit_name(block->_jit, __func__);
791 rec_alu_mv_lo_hi(block, REG_LO, op->r.rs);
792}
793
794static void rec_io(const struct block *block, const struct opcode *op,
795 bool load_rt, bool read_rt)
796{
797 struct regcache *reg_cache = block->state->reg_cache;
798 jit_state_t *_jit = block->_jit;
799 bool is_tagged = op->flags & (LIGHTREC_HW_IO | LIGHTREC_DIRECT_IO);
800 u32 offset;
801 u8 tmp, tmp2, tmp3;
802
803 jit_note(__FILE__, __LINE__);
804
805 tmp = lightrec_alloc_reg(reg_cache, _jit, JIT_R0);
806
807 if (is_tagged) {
808 offset = offsetof(struct lightrec_state, rw_func);
809 } else {
810 tmp3 = lightrec_alloc_reg(reg_cache, _jit, JIT_R1);
811 offset = offsetof(struct lightrec_state, rw_generic_func);
812 }
813
814 tmp2 = lightrec_alloc_reg_temp(reg_cache, _jit);
815 jit_ldxi(tmp2, LIGHTREC_REG_STATE, offset);
816
817 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rs, false);
818
819 if (read_rt && likely(op->i.rt))
820 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rt, true);
821 else if (load_rt)
822 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rt, false);
823
824 if (is_tagged) {
825 jit_movi(tmp, op->opcode);
826 } else {
827 jit_movi(tmp, (uintptr_t)op);
828 jit_movi(tmp3, (uintptr_t)block);
829 }
830
831 jit_callr(tmp2);
832
833 lightrec_free_reg(reg_cache, tmp);
834 lightrec_free_reg(reg_cache, tmp2);
835 if (!is_tagged)
836 lightrec_free_reg(reg_cache, tmp3);
837 lightrec_regcache_mark_live(reg_cache, _jit);
838}
839
840static void rec_store_direct_no_invalidate(const struct block *block,
841 const struct opcode *op,
842 jit_code_t code)
843{
844 struct lightrec_state *state = block->state;
845 struct regcache *reg_cache = state->reg_cache;
846 jit_state_t *_jit = block->_jit;
847 jit_node_t *to_not_ram, *to_end;
848 u8 tmp, tmp2, rs, rt;
849 s16 imm;
850
851 jit_note(__FILE__, __LINE__);
852 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->i.rs);
853 tmp = lightrec_alloc_reg_temp(reg_cache, _jit);
854 tmp2 = lightrec_alloc_reg_temp(reg_cache, _jit);
855
856 /* Convert to KUNSEG and avoid RAM mirrors */
857 if (state->mirrors_mapped) {
858 imm = (s16)op->i.imm;
859 jit_andi(tmp, rs, 0x1f800000 | (4 * RAM_SIZE - 1));
860 } else if (op->i.imm) {
861 imm = 0;
862 jit_addi(tmp, rs, (s16)op->i.imm);
863 jit_andi(tmp, tmp, 0x1f800000 | (RAM_SIZE - 1));
864 } else {
865 imm = 0;
866 jit_andi(tmp, rs, 0x1f800000 | (RAM_SIZE - 1));
867 }
868
869 lightrec_free_reg(reg_cache, rs);
870
871 if (state->offset_ram != state->offset_scratch) {
872 to_not_ram = jit_bmsi(tmp, BIT(28));
873
874 jit_movi(tmp2, state->offset_ram);
875
876 to_end = jit_jmpi();
877 jit_patch(to_not_ram);
878
879 jit_movi(tmp2, state->offset_scratch);
880 jit_patch(to_end);
881 } else if (state->offset_ram) {
882 jit_movi(tmp2, state->offset_ram);
883 }
884
885 if (state->offset_ram || state->offset_scratch)
886 jit_addr(tmp, tmp, tmp2);
887
888 lightrec_free_reg(reg_cache, tmp2);
889
890 rt = lightrec_alloc_reg_in(reg_cache, _jit, op->i.rt);
891 jit_new_node_www(code, imm, tmp, rt);
892
893 lightrec_free_reg(reg_cache, rt);
894 lightrec_free_reg(reg_cache, tmp);
895}
896
897static void rec_store_direct(const struct block *block, const struct opcode *op,
898 jit_code_t code)
899{
900 struct lightrec_state *state = block->state;
901 struct regcache *reg_cache = state->reg_cache;
902 jit_state_t *_jit = block->_jit;
903 jit_node_t *to_not_ram, *to_end;
904 u8 tmp, tmp2, tmp3, rs, rt;
905
906 jit_note(__FILE__, __LINE__);
907
908 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->i.rs);
909 tmp2 = lightrec_alloc_reg_temp(reg_cache, _jit);
910 tmp3 = lightrec_alloc_reg_in(reg_cache, _jit, 0);
911
912 /* Convert to KUNSEG and avoid RAM mirrors */
913 if (op->i.imm) {
914 jit_addi(tmp2, rs, (s16)op->i.imm);
915 jit_andi(tmp2, tmp2, 0x1f800000 | (RAM_SIZE - 1));
916 } else {
917 jit_andi(tmp2, rs, 0x1f800000 | (RAM_SIZE - 1));
918 }
919
920 lightrec_free_reg(reg_cache, rs);
921 tmp = lightrec_alloc_reg_temp(reg_cache, _jit);
922
923 to_not_ram = jit_bgti(tmp2, RAM_SIZE);
924
925 /* Compute the offset to the code LUT */
926 jit_andi(tmp, tmp2, (RAM_SIZE - 1) & ~3);
927#if __WORDSIZE == 64
928 jit_lshi(tmp, tmp, 1);
929#endif
930 jit_addr(tmp, LIGHTREC_REG_STATE, tmp);
931
932 /* Write NULL to the code LUT to invalidate any block that's there */
933 jit_stxi(offsetof(struct lightrec_state, code_lut), tmp, tmp3);
934
935 if (state->offset_ram != state->offset_scratch) {
936 jit_movi(tmp, state->offset_ram);
937
938 to_end = jit_jmpi();
939 }
940
941 jit_patch(to_not_ram);
942
943 if (state->offset_ram || state->offset_scratch)
944 jit_movi(tmp, state->offset_scratch);
945
946 if (state->offset_ram != state->offset_scratch)
947 jit_patch(to_end);
948
949 if (state->offset_ram || state->offset_scratch)
950 jit_addr(tmp2, tmp2, tmp);
951
952 lightrec_free_reg(reg_cache, tmp);
953 lightrec_free_reg(reg_cache, tmp3);
954
955 rt = lightrec_alloc_reg_in(reg_cache, _jit, op->i.rt);
956 jit_new_node_www(code, 0, tmp2, rt);
957
958 lightrec_free_reg(reg_cache, rt);
959 lightrec_free_reg(reg_cache, tmp2);
960}
961
962static void rec_store(const struct block *block, const struct opcode *op,
963 jit_code_t code)
964{
965 if (op->flags & LIGHTREC_NO_INVALIDATE) {
966 rec_store_direct_no_invalidate(block, op, code);
967 } else if (op->flags & LIGHTREC_DIRECT_IO) {
968 if (block->state->invalidate_from_dma_only)
969 rec_store_direct_no_invalidate(block, op, code);
970 else
971 rec_store_direct(block, op, code);
972 } else {
973 rec_io(block, op, true, false);
974 }
975}
976
977static void rec_SB(const struct block *block, const struct opcode *op, u32 pc)
978{
979 _jit_name(block->_jit, __func__);
980 rec_store(block, op, jit_code_stxi_c);
981}
982
983static void rec_SH(const struct block *block, const struct opcode *op, u32 pc)
984{
985 _jit_name(block->_jit, __func__);
986 rec_store(block, op, jit_code_stxi_s);
987}
988
989static void rec_SW(const struct block *block, const struct opcode *op, u32 pc)
990{
991 _jit_name(block->_jit, __func__);
992 rec_store(block, op, jit_code_stxi_i);
993}
994
995static void rec_SWL(const struct block *block, const struct opcode *op, u32 pc)
996{
997 _jit_name(block->_jit, __func__);
998 rec_io(block, op, true, false);
999}
1000
1001static void rec_SWR(const struct block *block, const struct opcode *op, u32 pc)
1002{
1003 _jit_name(block->_jit, __func__);
1004 rec_io(block, op, true, false);
1005}
1006
1007static void rec_SWC2(const struct block *block, const struct opcode *op, u32 pc)
1008{
1009 _jit_name(block->_jit, __func__);
1010 rec_io(block, op, false, false);
1011}
1012
1013static void rec_load_direct(const struct block *block, const struct opcode *op,
1014 jit_code_t code)
1015{
1016 struct lightrec_state *state = block->state;
1017 struct regcache *reg_cache = state->reg_cache;
1018 jit_state_t *_jit = block->_jit;
1019 jit_node_t *to_not_ram, *to_not_bios, *to_end, *to_end2;
1020 u8 tmp, rs, rt, addr_reg;
1021 s16 imm;
1022
1023 if (!op->i.rt)
1024 return;
1025
1026 jit_note(__FILE__, __LINE__);
1027 rs = lightrec_alloc_reg_in(reg_cache, _jit, op->i.rs);
1028 rt = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->i.rt);
1029
1030 if ((state->offset_ram == state->offset_bios &&
1031 state->offset_ram == state->offset_scratch &&
1032 state->mirrors_mapped) || !op->i.imm) {
1033 addr_reg = rs;
1034 imm = (s16)op->i.imm;
1035 } else {
1036 jit_addi(rt, rs, (s16)op->i.imm);
1037 addr_reg = rt;
1038 imm = 0;
1039
1040 if (op->i.rs != op->i.rt)
1041 lightrec_free_reg(reg_cache, rs);
1042 }
1043
1044 tmp = lightrec_alloc_reg_temp(reg_cache, _jit);
1045
1046 if (state->offset_ram == state->offset_bios &&
1047 state->offset_ram == state->offset_scratch) {
1048 if (!state->mirrors_mapped) {
1049 jit_andi(tmp, addr_reg, BIT(28));
1050 jit_rshi_u(tmp, tmp, 28 - 22);
1051 jit_ori(tmp, tmp, 0x1f800000 | (RAM_SIZE - 1));
1052 jit_andr(rt, addr_reg, tmp);
1053 } else {
1054 jit_andi(rt, addr_reg, 0x1fffffff);
1055 }
1056
1057 if (state->offset_ram)
1058 jit_movi(tmp, state->offset_ram);
1059 } else {
1060 to_not_ram = jit_bmsi(addr_reg, BIT(28));
1061
1062 /* Convert to KUNSEG and avoid RAM mirrors */
1063 jit_andi(rt, addr_reg, RAM_SIZE - 1);
1064
1065 if (state->offset_ram)
1066 jit_movi(tmp, state->offset_ram);
1067
1068 to_end = jit_jmpi();
1069
1070 jit_patch(to_not_ram);
1071
1072 if (state->offset_bios != state->offset_scratch)
1073 to_not_bios = jit_bmci(addr_reg, BIT(22));
1074
1075 /* Convert to KUNSEG */
1076 jit_andi(rt, addr_reg, 0x1fc00000 | (BIOS_SIZE - 1));
1077
1078 jit_movi(tmp, state->offset_bios);
1079
1080 if (state->offset_bios != state->offset_scratch) {
1081 to_end2 = jit_jmpi();
1082
1083 jit_patch(to_not_bios);
1084
1085 /* Convert to KUNSEG */
1086 jit_andi(rt, addr_reg, 0x1f800fff);
1087
1088 if (state->offset_scratch)
1089 jit_movi(tmp, state->offset_scratch);
1090
1091 jit_patch(to_end2);
1092 }
1093
1094 jit_patch(to_end);
1095 }
1096
1097 if (state->offset_ram || state->offset_bios || state->offset_scratch)
1098 jit_addr(rt, rt, tmp);
1099
1100 jit_new_node_www(code, rt, rt, imm);
1101
1102 lightrec_free_reg(reg_cache, addr_reg);
1103 lightrec_free_reg(reg_cache, rt);
1104 lightrec_free_reg(reg_cache, tmp);
1105}
1106
1107static void rec_load(const struct block *block, const struct opcode *op,
1108 jit_code_t code)
1109{
1110 if (op->flags & LIGHTREC_DIRECT_IO)
1111 rec_load_direct(block, op, code);
1112 else
1113 rec_io(block, op, false, true);
1114}
1115
1116static void rec_LB(const struct block *block, const struct opcode *op, u32 pc)
1117{
1118 _jit_name(block->_jit, __func__);
1119 rec_load(block, op, jit_code_ldxi_c);
1120}
1121
1122static void rec_LBU(const struct block *block, const struct opcode *op, u32 pc)
1123{
1124 _jit_name(block->_jit, __func__);
1125 rec_load(block, op, jit_code_ldxi_uc);
1126}
1127
1128static void rec_LH(const struct block *block, const struct opcode *op, u32 pc)
1129{
1130 _jit_name(block->_jit, __func__);
1131 rec_load(block, op, jit_code_ldxi_s);
1132}
1133
1134static void rec_LHU(const struct block *block, const struct opcode *op, u32 pc)
1135{
1136 _jit_name(block->_jit, __func__);
1137 rec_load(block, op, jit_code_ldxi_us);
1138}
1139
1140static void rec_LWL(const struct block *block, const struct opcode *op, u32 pc)
1141{
1142 _jit_name(block->_jit, __func__);
1143 rec_io(block, op, true, true);
1144}
1145
1146static void rec_LWR(const struct block *block, const struct opcode *op, u32 pc)
1147{
1148 _jit_name(block->_jit, __func__);
1149 rec_io(block, op, true, true);
1150}
1151
1152static void rec_LW(const struct block *block, const struct opcode *op, u32 pc)
1153{
1154 _jit_name(block->_jit, __func__);
1155 rec_load(block, op, jit_code_ldxi_i);
1156}
1157
1158static void rec_LWC2(const struct block *block, const struct opcode *op, u32 pc)
1159{
1160 _jit_name(block->_jit, __func__);
1161 rec_io(block, op, false, false);
1162}
1163
1164static void rec_break_syscall(const struct block *block,
1165 const struct opcode *op, u32 pc, bool is_break)
1166{
1167 struct regcache *reg_cache = block->state->reg_cache;
1168 jit_state_t *_jit = block->_jit;
1169 u32 offset;
1170 u8 tmp;
1171
1172 jit_note(__FILE__, __LINE__);
1173
1174 if (is_break)
1175 offset = offsetof(struct lightrec_state, break_func);
1176 else
1177 offset = offsetof(struct lightrec_state, syscall_func);
1178
1179 tmp = lightrec_alloc_reg_temp(reg_cache, _jit);
1180 jit_ldxi(tmp, LIGHTREC_REG_STATE, offset);
1181 jit_callr(tmp);
1182 lightrec_free_reg(reg_cache, tmp);
1183
1184 lightrec_regcache_mark_live(reg_cache, _jit);
1185
1186 /* TODO: the return address should be "pc - 4" if we're a delay slot */
1187 lightrec_emit_end_of_block(block, op, pc, -1, pc, 31, 0, true);
1188}
1189
1190static void rec_special_SYSCALL(const struct block *block,
1191 const struct opcode *op, u32 pc)
1192{
1193 _jit_name(block->_jit, __func__);
1194 rec_break_syscall(block, op, pc, false);
1195}
1196
1197static void rec_special_BREAK(const struct block *block,
1198 const struct opcode *op, u32 pc)
1199{
1200 _jit_name(block->_jit, __func__);
1201 rec_break_syscall(block, op, pc, true);
1202}
1203
1204static void rec_mfc(const struct block *block, const struct opcode *op)
1205{
1206 u8 tmp, tmp2;
1207 struct lightrec_state *state = block->state;
1208 struct regcache *reg_cache = state->reg_cache;
1209 jit_state_t *_jit = block->_jit;
1210
1211 jit_note(__FILE__, __LINE__);
1212
1213 tmp = lightrec_alloc_reg(reg_cache, _jit, JIT_R0);
1214 tmp2 = lightrec_alloc_reg_temp(reg_cache, _jit);
1215
1216 jit_ldxi(tmp2, LIGHTREC_REG_STATE,
1217 offsetof(struct lightrec_state, mfc_func));
1218
1219 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rt, true);
1220
1221 jit_movi(tmp, op->opcode);
1222 jit_callr(tmp2);
1223 lightrec_free_reg(reg_cache, tmp);
1224 lightrec_free_reg(reg_cache, tmp2);
1225
1226 lightrec_regcache_mark_live(reg_cache, _jit);
1227}
1228
1229static void rec_mtc(const struct block *block, const struct opcode *op, u32 pc)
1230{
1231 struct lightrec_state *state = block->state;
1232 struct regcache *reg_cache = state->reg_cache;
1233 jit_state_t *_jit = block->_jit;
1234 u8 tmp, tmp2;
1235
1236 jit_note(__FILE__, __LINE__);
1237
1238 tmp = lightrec_alloc_reg(reg_cache, _jit, JIT_R0);
1239 tmp2 = lightrec_alloc_reg_temp(reg_cache, _jit);
1240 jit_ldxi(tmp2, LIGHTREC_REG_STATE,
1241 offsetof(struct lightrec_state, mtc_func));
1242
1243 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rs, false);
1244 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rt, false);
1245
1246 jit_movi(tmp, op->opcode);
1247 jit_callr(tmp2);
1248 lightrec_free_reg(reg_cache, tmp);
1249 lightrec_free_reg(reg_cache, tmp2);
1250
1251 lightrec_regcache_mark_live(reg_cache, _jit);
1252
1253 if (op->i.op == OP_CP0 && (op->r.rd == 12 || op->r.rd == 13))
1254 lightrec_emit_end_of_block(block, op, pc, -1, pc + 4, 0, 0, true);
1255}
1256
1257static void rec_cp0_MFC0(const struct block *block,
1258 const struct opcode *op, u32 pc)
1259{
1260 _jit_name(block->_jit, __func__);
1261 rec_mfc(block, op);
1262}
1263
1264static void rec_cp0_CFC0(const struct block *block,
1265 const struct opcode *op, u32 pc)
1266{
1267 _jit_name(block->_jit, __func__);
1268 rec_mfc(block, op);
1269}
1270
1271static void rec_cp0_MTC0(const struct block *block,
1272 const struct opcode *op, u32 pc)
1273{
1274 _jit_name(block->_jit, __func__);
1275 rec_mtc(block, op, pc);
1276}
1277
1278static void rec_cp0_CTC0(const struct block *block,
1279 const struct opcode *op, u32 pc)
1280{
1281 _jit_name(block->_jit, __func__);
1282 rec_mtc(block, op, pc);
1283}
1284
1285static void rec_cp2_basic_MFC2(const struct block *block,
1286 const struct opcode *op, u32 pc)
1287{
1288 _jit_name(block->_jit, __func__);
1289 rec_mfc(block, op);
1290}
1291
1292static void rec_cp2_basic_CFC2(const struct block *block,
1293 const struct opcode *op, u32 pc)
1294{
1295 _jit_name(block->_jit, __func__);
1296 rec_mfc(block, op);
1297}
1298
1299static void rec_cp2_basic_MTC2(const struct block *block,
1300 const struct opcode *op, u32 pc)
1301{
1302 _jit_name(block->_jit, __func__);
1303 rec_mtc(block, op, pc);
1304}
1305
1306static void rec_cp2_basic_CTC2(const struct block *block,
1307 const struct opcode *op, u32 pc)
1308{
1309 _jit_name(block->_jit, __func__);
1310 rec_mtc(block, op, pc);
1311}
1312
1313static void rec_cp0_RFE(const struct block *block,
1314 const struct opcode *op, u32 pc)
1315{
1316 struct lightrec_state *state = block->state;
1317 jit_state_t *_jit = block->_jit;
1318 u8 tmp;
1319
1320 jit_name(__func__);
1321 jit_note(__FILE__, __LINE__);
1322
1323 tmp = lightrec_alloc_reg_temp(state->reg_cache, _jit);
1324 jit_ldxi(tmp, LIGHTREC_REG_STATE,
1325 offsetof(struct lightrec_state, rfe_func));
1326 jit_callr(tmp);
1327 lightrec_free_reg(state->reg_cache, tmp);
1328
1329 lightrec_regcache_mark_live(state->reg_cache, _jit);
1330}
1331
1332static void rec_CP(const struct block *block, const struct opcode *op, u32 pc)
1333{
1334 struct regcache *reg_cache = block->state->reg_cache;
1335 jit_state_t *_jit = block->_jit;
1336 u8 tmp, tmp2;
1337
1338 jit_name(__func__);
1339 jit_note(__FILE__, __LINE__);
1340
1341 tmp = lightrec_alloc_reg(reg_cache, _jit, JIT_R0);
1342 tmp2 = lightrec_alloc_reg_temp(reg_cache, _jit);
1343
1344 jit_ldxi(tmp2, LIGHTREC_REG_STATE,
1345 offsetof(struct lightrec_state, cp_func));
1346
1347 jit_movi(tmp, op->opcode);
1348 jit_callr(tmp2);
1349 lightrec_free_reg(reg_cache, tmp);
1350 lightrec_free_reg(reg_cache, tmp2);
1351
1352 lightrec_regcache_mark_live(reg_cache, _jit);
1353}
1354
1355static void rec_meta_unload(const struct block *block,
1356 const struct opcode *op, u32 pc)
1357{
1358 struct lightrec_state *state = block->state;
1359 struct regcache *reg_cache = state->reg_cache;
1360 jit_state_t *_jit = block->_jit;
1361
1362 jit_name(__func__);
1363 jit_note(__FILE__, __LINE__);
1364
1365 pr_debug("Unloading reg %s\n", lightrec_reg_name(op->i.rs));
1366 lightrec_clean_reg_if_loaded(reg_cache, _jit, op->i.rs, true);
1367}
1368
1369static void rec_meta_BEQZ(const struct block *block,
1370 const struct opcode *op, u32 pc)
1371{
1372 _jit_name(block->_jit, __func__);
1373 rec_b(block, op, pc, jit_code_bnei, 0, false, true);
1374}
1375
1376static void rec_meta_BNEZ(const struct block *block,
1377 const struct opcode *op, u32 pc)
1378{
1379 _jit_name(block->_jit, __func__);
1380 rec_b(block, op, pc, jit_code_beqi, 0, false, true);
1381}
1382
1383static void rec_meta_MOV(const struct block *block,
1384 const struct opcode *op, u32 pc)
1385{
1386 struct lightrec_state *state = block->state;
1387 struct regcache *reg_cache = state->reg_cache;
1388 jit_state_t *_jit = block->_jit;
1389 u8 rs, rd;
1390
1391 _jit_name(block->_jit, __func__);
1392 jit_note(__FILE__, __LINE__);
1393 rs = op->r.rs ? lightrec_alloc_reg_in(reg_cache, _jit, op->r.rs) : 0;
1394 rd = lightrec_alloc_reg_out_ext(reg_cache, _jit, op->r.rd);
1395
1396 if (op->r.rs == 0) {
1397 jit_movi(rd, 0);
1398 } else {
1399#if __WORDSIZE == 32
1400 jit_movr(rd, rs);
1401#else
1402 jit_extr_i(rd, rs);
1403#endif
1404 }
1405
1406 lightrec_free_reg(state->reg_cache, rs);
1407 lightrec_free_reg(state->reg_cache, rd);
1408}
1409
1410static void rec_meta_sync(const struct block *block,
1411 const struct opcode *op, u32 pc)
1412{
1413 struct lightrec_state *state = block->state;
1414 struct lightrec_branch_target *target;
1415 jit_state_t *_jit = block->_jit;
1416
1417 jit_name(__func__);
1418 jit_note(__FILE__, __LINE__);
1419
1420 jit_subi(LIGHTREC_REG_CYCLE, LIGHTREC_REG_CYCLE, state->cycles);
1421 state->cycles = 0;
1422
1423 lightrec_storeback_regs(state->reg_cache, _jit);
1424 lightrec_regcache_reset(state->reg_cache);
1425
1426 pr_debug("Adding branch target at offset 0x%x\n",
1427 op->offset << 2);
1428 target = &state->targets[state->nb_targets++];
1429 target->offset = op->offset;
1430 target->label = jit_label();
1431}
1432
1433static const lightrec_rec_func_t rec_standard[64] = {
1434 [OP_SPECIAL] = rec_SPECIAL,
1435 [OP_REGIMM] = rec_REGIMM,
1436 [OP_J] = rec_J,
1437 [OP_JAL] = rec_JAL,
1438 [OP_BEQ] = rec_BEQ,
1439 [OP_BNE] = rec_BNE,
1440 [OP_BLEZ] = rec_BLEZ,
1441 [OP_BGTZ] = rec_BGTZ,
1442 [OP_ADDI] = rec_ADDI,
1443 [OP_ADDIU] = rec_ADDIU,
1444 [OP_SLTI] = rec_SLTI,
1445 [OP_SLTIU] = rec_SLTIU,
1446 [OP_ANDI] = rec_ANDI,
1447 [OP_ORI] = rec_ORI,
1448 [OP_XORI] = rec_XORI,
1449 [OP_LUI] = rec_LUI,
1450 [OP_CP0] = rec_CP0,
1451 [OP_CP2] = rec_CP2,
1452 [OP_LB] = rec_LB,
1453 [OP_LH] = rec_LH,
1454 [OP_LWL] = rec_LWL,
1455 [OP_LW] = rec_LW,
1456 [OP_LBU] = rec_LBU,
1457 [OP_LHU] = rec_LHU,
1458 [OP_LWR] = rec_LWR,
1459 [OP_SB] = rec_SB,
1460 [OP_SH] = rec_SH,
1461 [OP_SWL] = rec_SWL,
1462 [OP_SW] = rec_SW,
1463 [OP_SWR] = rec_SWR,
1464 [OP_LWC2] = rec_LWC2,
1465 [OP_SWC2] = rec_SWC2,
1466
1467 [OP_META_REG_UNLOAD] = rec_meta_unload,
1468 [OP_META_BEQZ] = rec_meta_BEQZ,
1469 [OP_META_BNEZ] = rec_meta_BNEZ,
1470 [OP_META_MOV] = rec_meta_MOV,
1471 [OP_META_SYNC] = rec_meta_sync,
1472};
1473
1474static const lightrec_rec_func_t rec_special[64] = {
1475 [OP_SPECIAL_SLL] = rec_special_SLL,
1476 [OP_SPECIAL_SRL] = rec_special_SRL,
1477 [OP_SPECIAL_SRA] = rec_special_SRA,
1478 [OP_SPECIAL_SLLV] = rec_special_SLLV,
1479 [OP_SPECIAL_SRLV] = rec_special_SRLV,
1480 [OP_SPECIAL_SRAV] = rec_special_SRAV,
1481 [OP_SPECIAL_JR] = rec_special_JR,
1482 [OP_SPECIAL_JALR] = rec_special_JALR,
1483 [OP_SPECIAL_SYSCALL] = rec_special_SYSCALL,
1484 [OP_SPECIAL_BREAK] = rec_special_BREAK,
1485 [OP_SPECIAL_MFHI] = rec_special_MFHI,
1486 [OP_SPECIAL_MTHI] = rec_special_MTHI,
1487 [OP_SPECIAL_MFLO] = rec_special_MFLO,
1488 [OP_SPECIAL_MTLO] = rec_special_MTLO,
1489 [OP_SPECIAL_MULT] = rec_special_MULT,
1490 [OP_SPECIAL_MULTU] = rec_special_MULTU,
1491 [OP_SPECIAL_DIV] = rec_special_DIV,
1492 [OP_SPECIAL_DIVU] = rec_special_DIVU,
1493 [OP_SPECIAL_ADD] = rec_special_ADD,
1494 [OP_SPECIAL_ADDU] = rec_special_ADDU,
1495 [OP_SPECIAL_SUB] = rec_special_SUB,
1496 [OP_SPECIAL_SUBU] = rec_special_SUBU,
1497 [OP_SPECIAL_AND] = rec_special_AND,
1498 [OP_SPECIAL_OR] = rec_special_OR,
1499 [OP_SPECIAL_XOR] = rec_special_XOR,
1500 [OP_SPECIAL_NOR] = rec_special_NOR,
1501 [OP_SPECIAL_SLT] = rec_special_SLT,
1502 [OP_SPECIAL_SLTU] = rec_special_SLTU,
1503};
1504
1505static const lightrec_rec_func_t rec_regimm[64] = {
1506 [OP_REGIMM_BLTZ] = rec_regimm_BLTZ,
1507 [OP_REGIMM_BGEZ] = rec_regimm_BGEZ,
1508 [OP_REGIMM_BLTZAL] = rec_regimm_BLTZAL,
1509 [OP_REGIMM_BGEZAL] = rec_regimm_BGEZAL,
1510};
1511
1512static const lightrec_rec_func_t rec_cp0[64] = {
1513 [OP_CP0_MFC0] = rec_cp0_MFC0,
1514 [OP_CP0_CFC0] = rec_cp0_CFC0,
1515 [OP_CP0_MTC0] = rec_cp0_MTC0,
1516 [OP_CP0_CTC0] = rec_cp0_CTC0,
1517 [OP_CP0_RFE] = rec_cp0_RFE,
1518};
1519
1520static const lightrec_rec_func_t rec_cp2_basic[64] = {
1521 [OP_CP2_BASIC_MFC2] = rec_cp2_basic_MFC2,
1522 [OP_CP2_BASIC_CFC2] = rec_cp2_basic_CFC2,
1523 [OP_CP2_BASIC_MTC2] = rec_cp2_basic_MTC2,
1524 [OP_CP2_BASIC_CTC2] = rec_cp2_basic_CTC2,
1525};
1526
1527static void rec_SPECIAL(const struct block *block,
1528 const struct opcode *op, u32 pc)
1529{
1530 lightrec_rec_func_t f = rec_special[op->r.op];
1531 if (likely(f))
1532 (*f)(block, op, pc);
1533 else
1534 unknown_opcode(block, op, pc);
1535}
1536
1537static void rec_REGIMM(const struct block *block,
1538 const struct opcode *op, u32 pc)
1539{
1540 lightrec_rec_func_t f = rec_regimm[op->r.rt];
1541 if (likely(f))
1542 (*f)(block, op, pc);
1543 else
1544 unknown_opcode(block, op, pc);
1545}
1546
1547static void rec_CP0(const struct block *block, const struct opcode *op, u32 pc)
1548{
1549 lightrec_rec_func_t f = rec_cp0[op->r.rs];
1550 if (likely(f))
1551 (*f)(block, op, pc);
1552 else
1553 rec_CP(block, op, pc);
1554}
1555
1556static void rec_CP2(const struct block *block, const struct opcode *op, u32 pc)
1557{
1558 if (op->r.op == OP_CP2_BASIC) {
1559 lightrec_rec_func_t f = rec_cp2_basic[op->r.rs];
1560 if (likely(f)) {
1561 (*f)(block, op, pc);
1562 return;
1563 }
1564 }
1565
1566 rec_CP(block, op, pc);
1567}
1568
1569void lightrec_rec_opcode(const struct block *block,
1570 const struct opcode *op, u32 pc)
1571{
1572 lightrec_rec_func_t f = rec_standard[op->i.op];
1573 if (likely(f))
1574 (*f)(block, op, pc);
1575 else
1576 unknown_opcode(block, op, pc);
1577}
ARM optimized PCSX fork