meson: target
[qemu.git] / target / rx / translate.c
1 /*
2 * RX translation
3 *
4 * Copyright (c) 2019 Yoshinori Sato
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2 or later, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include "qemu/osdep.h"
20 #include "qemu/bswap.h"
21 #include "qemu/qemu-print.h"
22 #include "cpu.h"
23 #include "exec/exec-all.h"
24 #include "tcg/tcg-op.h"
25 #include "exec/cpu_ldst.h"
26 #include "exec/helper-proto.h"
27 #include "exec/helper-gen.h"
28 #include "exec/translator.h"
29 #include "trace-tcg.h"
30 #include "exec/log.h"
31
32 typedef struct DisasContext {
33 DisasContextBase base;
34 CPURXState *env;
35 uint32_t pc;
36 } DisasContext;
37
38 typedef struct DisasCompare {
39 TCGv value;
40 TCGv temp;
41 TCGCond cond;
42 } DisasCompare;
43
44 const char *rx_crname(uint8_t cr)
45 {
46 static const char *cr_names[] = {
47 "psw", "pc", "usp", "fpsw", "", "", "", "",
48 "bpsw", "bpc", "isp", "fintv", "intb", "", "", ""
49 };
50 if (cr >= ARRAY_SIZE(cr_names)) {
51 return "illegal";
52 }
53 return cr_names[cr];
54 }
55
56 /* Target-specific values for dc->base.is_jmp. */
57 #define DISAS_JUMP DISAS_TARGET_0
58 #define DISAS_UPDATE DISAS_TARGET_1
59 #define DISAS_EXIT DISAS_TARGET_2
60
61 /* global register indexes */
62 static TCGv cpu_regs[16];
63 static TCGv cpu_psw_o, cpu_psw_s, cpu_psw_z, cpu_psw_c;
64 static TCGv cpu_psw_i, cpu_psw_pm, cpu_psw_u, cpu_psw_ipl;
65 static TCGv cpu_usp, cpu_fpsw, cpu_bpsw, cpu_bpc, cpu_isp;
66 static TCGv cpu_fintv, cpu_intb, cpu_pc;
67 static TCGv_i64 cpu_acc;
68
69 #define cpu_sp cpu_regs[0]
70
71 #include "exec/gen-icount.h"
72
73 /* decoder helper */
74 static uint32_t decode_load_bytes(DisasContext *ctx, uint32_t insn,
75 int i, int n)
76 {
77 while (++i <= n) {
78 uint8_t b = cpu_ldub_code(ctx->env, ctx->base.pc_next++);
79 insn |= b << (32 - i * 8);
80 }
81 return insn;
82 }
83
84 static uint32_t li(DisasContext *ctx, int sz)
85 {
86 int32_t tmp, addr;
87 CPURXState *env = ctx->env;
88 addr = ctx->base.pc_next;
89
90 tcg_debug_assert(sz < 4);
91 switch (sz) {
92 case 1:
93 ctx->base.pc_next += 1;
94 return cpu_ldsb_code(env, addr);
95 case 2:
96 ctx->base.pc_next += 2;
97 return cpu_ldsw_code(env, addr);
98 case 3:
99 ctx->base.pc_next += 3;
100 tmp = cpu_ldsb_code(env, addr + 2) << 16;
101 tmp |= cpu_lduw_code(env, addr) & 0xffff;
102 return tmp;
103 case 0:
104 ctx->base.pc_next += 4;
105 return cpu_ldl_code(env, addr);
106 }
107 return 0;
108 }
109
110 static int bdsp_s(DisasContext *ctx, int d)
111 {
112 /*
113 * 0 -> 8
114 * 1 -> 9
115 * 2 -> 10
116 * 3 -> 3
117 * :
118 * 7 -> 7
119 */
120 if (d < 3) {
121 d += 8;
122 }
123 return d;
124 }
125
126 /* Include the auto-generated decoder. */
127 #include "decode-insns.c.inc"
128
129 void rx_cpu_dump_state(CPUState *cs, FILE *f, int flags)
130 {
131 RXCPU *cpu = RXCPU(cs);
132 CPURXState *env = &cpu->env;
133 int i;
134 uint32_t psw;
135
136 psw = rx_cpu_pack_psw(env);
137 qemu_fprintf(f, "pc=0x%08x psw=0x%08x\n",
138 env->pc, psw);
139 for (i = 0; i < 16; i += 4) {
140 qemu_fprintf(f, "r%d=0x%08x r%d=0x%08x r%d=0x%08x r%d=0x%08x\n",
141 i, env->regs[i], i + 1, env->regs[i + 1],
142 i + 2, env->regs[i + 2], i + 3, env->regs[i + 3]);
143 }
144 }
145
146 static bool use_goto_tb(DisasContext *dc, target_ulong dest)
147 {
148 if (unlikely(dc->base.singlestep_enabled)) {
149 return false;
150 } else {
151 return true;
152 }
153 }
154
155 static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
156 {
157 if (use_goto_tb(dc, dest)) {
158 tcg_gen_goto_tb(n);
159 tcg_gen_movi_i32(cpu_pc, dest);
160 tcg_gen_exit_tb(dc->base.tb, n);
161 } else {
162 tcg_gen_movi_i32(cpu_pc, dest);
163 if (dc->base.singlestep_enabled) {
164 gen_helper_debug(cpu_env);
165 } else {
166 tcg_gen_lookup_and_goto_ptr();
167 }
168 }
169 dc->base.is_jmp = DISAS_NORETURN;
170 }
171
172 /* generic load wrapper */
173 static inline void rx_gen_ld(unsigned int size, TCGv reg, TCGv mem)
174 {
175 tcg_gen_qemu_ld_i32(reg, mem, 0, size | MO_SIGN | MO_TE);
176 }
177
178 /* unsigned load wrapper */
179 static inline void rx_gen_ldu(unsigned int size, TCGv reg, TCGv mem)
180 {
181 tcg_gen_qemu_ld_i32(reg, mem, 0, size | MO_TE);
182 }
183
184 /* generic store wrapper */
185 static inline void rx_gen_st(unsigned int size, TCGv reg, TCGv mem)
186 {
187 tcg_gen_qemu_st_i32(reg, mem, 0, size | MO_TE);
188 }
189
190 /* [ri, rb] */
191 static inline void rx_gen_regindex(DisasContext *ctx, TCGv mem,
192 int size, int ri, int rb)
193 {
194 tcg_gen_shli_i32(mem, cpu_regs[ri], size);
195 tcg_gen_add_i32(mem, mem, cpu_regs[rb]);
196 }
197
198 /* dsp[reg] */
199 static inline TCGv rx_index_addr(DisasContext *ctx, TCGv mem,
200 int ld, int size, int reg)
201 {
202 uint32_t dsp;
203
204 tcg_debug_assert(ld < 3);
205 switch (ld) {
206 case 0:
207 return cpu_regs[reg];
208 case 1:
209 dsp = cpu_ldub_code(ctx->env, ctx->base.pc_next) << size;
210 tcg_gen_addi_i32(mem, cpu_regs[reg], dsp);
211 ctx->base.pc_next += 1;
212 return mem;
213 case 2:
214 dsp = cpu_lduw_code(ctx->env, ctx->base.pc_next) << size;
215 tcg_gen_addi_i32(mem, cpu_regs[reg], dsp);
216 ctx->base.pc_next += 2;
217 return mem;
218 }
219 return NULL;
220 }
221
222 static inline MemOp mi_to_mop(unsigned mi)
223 {
224 static const MemOp mop[5] = { MO_SB, MO_SW, MO_UL, MO_UW, MO_UB };
225 tcg_debug_assert(mi < 5);
226 return mop[mi];
227 }
228
229 /* load source operand */
230 static inline TCGv rx_load_source(DisasContext *ctx, TCGv mem,
231 int ld, int mi, int rs)
232 {
233 TCGv addr;
234 MemOp mop;
235 if (ld < 3) {
236 mop = mi_to_mop(mi);
237 addr = rx_index_addr(ctx, mem, ld, mop & MO_SIZE, rs);
238 tcg_gen_qemu_ld_i32(mem, addr, 0, mop | MO_TE);
239 return mem;
240 } else {
241 return cpu_regs[rs];
242 }
243 }
244
245 /* Processor mode check */
246 static int is_privileged(DisasContext *ctx, int is_exception)
247 {
248 if (FIELD_EX32(ctx->base.tb->flags, PSW, PM)) {
249 if (is_exception) {
250 gen_helper_raise_privilege_violation(cpu_env);
251 }
252 return 0;
253 } else {
254 return 1;
255 }
256 }
257
258 /* generate QEMU condition */
259 static void psw_cond(DisasCompare *dc, uint32_t cond)
260 {
261 tcg_debug_assert(cond < 16);
262 switch (cond) {
263 case 0: /* z */
264 dc->cond = TCG_COND_EQ;
265 dc->value = cpu_psw_z;
266 break;
267 case 1: /* nz */
268 dc->cond = TCG_COND_NE;
269 dc->value = cpu_psw_z;
270 break;
271 case 2: /* c */
272 dc->cond = TCG_COND_NE;
273 dc->value = cpu_psw_c;
274 break;
275 case 3: /* nc */
276 dc->cond = TCG_COND_EQ;
277 dc->value = cpu_psw_c;
278 break;
279 case 4: /* gtu (C& ~Z) == 1 */
280 case 5: /* leu (C& ~Z) == 0 */
281 tcg_gen_setcondi_i32(TCG_COND_NE, dc->temp, cpu_psw_z, 0);
282 tcg_gen_and_i32(dc->temp, dc->temp, cpu_psw_c);
283 dc->cond = (cond == 4) ? TCG_COND_NE : TCG_COND_EQ;
284 dc->value = dc->temp;
285 break;
286 case 6: /* pz (S == 0) */
287 dc->cond = TCG_COND_GE;
288 dc->value = cpu_psw_s;
289 break;
290 case 7: /* n (S == 1) */
291 dc->cond = TCG_COND_LT;
292 dc->value = cpu_psw_s;
293 break;
294 case 8: /* ge (S^O)==0 */
295 case 9: /* lt (S^O)==1 */
296 tcg_gen_xor_i32(dc->temp, cpu_psw_o, cpu_psw_s);
297 dc->cond = (cond == 8) ? TCG_COND_GE : TCG_COND_LT;
298 dc->value = dc->temp;
299 break;
300 case 10: /* gt ((S^O)|Z)==0 */
301 case 11: /* le ((S^O)|Z)==1 */
302 tcg_gen_xor_i32(dc->temp, cpu_psw_o, cpu_psw_s);
303 tcg_gen_sari_i32(dc->temp, dc->temp, 31);
304 tcg_gen_andc_i32(dc->temp, cpu_psw_z, dc->temp);
305 dc->cond = (cond == 10) ? TCG_COND_NE : TCG_COND_EQ;
306 dc->value = dc->temp;
307 break;
308 case 12: /* o */
309 dc->cond = TCG_COND_LT;
310 dc->value = cpu_psw_o;
311 break;
312 case 13: /* no */
313 dc->cond = TCG_COND_GE;
314 dc->value = cpu_psw_o;
315 break;
316 case 14: /* always true */
317 dc->cond = TCG_COND_ALWAYS;
318 dc->value = dc->temp;
319 break;
320 case 15: /* always false */
321 dc->cond = TCG_COND_NEVER;
322 dc->value = dc->temp;
323 break;
324 }
325 }
326
327 static void move_from_cr(TCGv ret, int cr, uint32_t pc)
328 {
329 TCGv z = tcg_const_i32(0);
330 switch (cr) {
331 case 0: /* PSW */
332 gen_helper_pack_psw(ret, cpu_env);
333 break;
334 case 1: /* PC */
335 tcg_gen_movi_i32(ret, pc);
336 break;
337 case 2: /* USP */
338 tcg_gen_movcond_i32(TCG_COND_NE, ret,
339 cpu_psw_u, z, cpu_sp, cpu_usp);
340 break;
341 case 3: /* FPSW */
342 tcg_gen_mov_i32(ret, cpu_fpsw);
343 break;
344 case 8: /* BPSW */
345 tcg_gen_mov_i32(ret, cpu_bpsw);
346 break;
347 case 9: /* BPC */
348 tcg_gen_mov_i32(ret, cpu_bpc);
349 break;
350 case 10: /* ISP */
351 tcg_gen_movcond_i32(TCG_COND_EQ, ret,
352 cpu_psw_u, z, cpu_sp, cpu_isp);
353 break;
354 case 11: /* FINTV */
355 tcg_gen_mov_i32(ret, cpu_fintv);
356 break;
357 case 12: /* INTB */
358 tcg_gen_mov_i32(ret, cpu_intb);
359 break;
360 default:
361 qemu_log_mask(LOG_GUEST_ERROR, "Unimplement control register %d", cr);
362 /* Unimplement registers return 0 */
363 tcg_gen_movi_i32(ret, 0);
364 break;
365 }
366 tcg_temp_free(z);
367 }
368
369 static void move_to_cr(DisasContext *ctx, TCGv val, int cr)
370 {
371 TCGv z;
372 if (cr >= 8 && !is_privileged(ctx, 0)) {
373 /* Some control registers can only be written in privileged mode. */
374 qemu_log_mask(LOG_GUEST_ERROR,
375 "disallow control register write %s", rx_crname(cr));
376 return;
377 }
378 z = tcg_const_i32(0);
379 switch (cr) {
380 case 0: /* PSW */
381 gen_helper_set_psw(cpu_env, val);
382 break;
383 /* case 1: to PC not supported */
384 case 2: /* USP */
385 tcg_gen_mov_i32(cpu_usp, val);
386 tcg_gen_movcond_i32(TCG_COND_NE, cpu_sp,
387 cpu_psw_u, z, cpu_usp, cpu_sp);
388 break;
389 case 3: /* FPSW */
390 gen_helper_set_fpsw(cpu_env, val);
391 break;
392 case 8: /* BPSW */
393 tcg_gen_mov_i32(cpu_bpsw, val);
394 break;
395 case 9: /* BPC */
396 tcg_gen_mov_i32(cpu_bpc, val);
397 break;
398 case 10: /* ISP */
399 tcg_gen_mov_i32(cpu_isp, val);
400 /* if PSW.U is 0, copy isp to r0 */
401 tcg_gen_movcond_i32(TCG_COND_EQ, cpu_sp,
402 cpu_psw_u, z, cpu_isp, cpu_sp);
403 break;
404 case 11: /* FINTV */
405 tcg_gen_mov_i32(cpu_fintv, val);
406 break;
407 case 12: /* INTB */
408 tcg_gen_mov_i32(cpu_intb, val);
409 break;
410 default:
411 qemu_log_mask(LOG_GUEST_ERROR,
412 "Unimplement control register %d", cr);
413 break;
414 }
415 tcg_temp_free(z);
416 }
417
418 static void push(TCGv val)
419 {
420 tcg_gen_subi_i32(cpu_sp, cpu_sp, 4);
421 rx_gen_st(MO_32, val, cpu_sp);
422 }
423
424 static void pop(TCGv ret)
425 {
426 rx_gen_ld(MO_32, ret, cpu_sp);
427 tcg_gen_addi_i32(cpu_sp, cpu_sp, 4);
428 }
429
430 /* mov.<bwl> rs,dsp5[rd] */
431 static bool trans_MOV_rm(DisasContext *ctx, arg_MOV_rm *a)
432 {
433 TCGv mem;
434 mem = tcg_temp_new();
435 tcg_gen_addi_i32(mem, cpu_regs[a->rd], a->dsp << a->sz);
436 rx_gen_st(a->sz, cpu_regs[a->rs], mem);
437 tcg_temp_free(mem);
438 return true;
439 }
440
441 /* mov.<bwl> dsp5[rs],rd */
442 static bool trans_MOV_mr(DisasContext *ctx, arg_MOV_mr *a)
443 {
444 TCGv mem;
445 mem = tcg_temp_new();
446 tcg_gen_addi_i32(mem, cpu_regs[a->rs], a->dsp << a->sz);
447 rx_gen_ld(a->sz, cpu_regs[a->rd], mem);
448 tcg_temp_free(mem);
449 return true;
450 }
451
452 /* mov.l #uimm4,rd */
453 /* mov.l #uimm8,rd */
454 /* mov.l #imm,rd */
455 static bool trans_MOV_ir(DisasContext *ctx, arg_MOV_ir *a)
456 {
457 tcg_gen_movi_i32(cpu_regs[a->rd], a->imm);
458 return true;
459 }
460
461 /* mov.<bwl> #uimm8,dsp[rd] */
462 /* mov.<bwl> #imm, dsp[rd] */
463 static bool trans_MOV_im(DisasContext *ctx, arg_MOV_im *a)
464 {
465 TCGv imm, mem;
466 imm = tcg_const_i32(a->imm);
467 mem = tcg_temp_new();
468 tcg_gen_addi_i32(mem, cpu_regs[a->rd], a->dsp << a->sz);
469 rx_gen_st(a->sz, imm, mem);
470 tcg_temp_free(imm);
471 tcg_temp_free(mem);
472 return true;
473 }
474
475 /* mov.<bwl> [ri,rb],rd */
476 static bool trans_MOV_ar(DisasContext *ctx, arg_MOV_ar *a)
477 {
478 TCGv mem;
479 mem = tcg_temp_new();
480 rx_gen_regindex(ctx, mem, a->sz, a->ri, a->rb);
481 rx_gen_ld(a->sz, cpu_regs[a->rd], mem);
482 tcg_temp_free(mem);
483 return true;
484 }
485
486 /* mov.<bwl> rd,[ri,rb] */
487 static bool trans_MOV_ra(DisasContext *ctx, arg_MOV_ra *a)
488 {
489 TCGv mem;
490 mem = tcg_temp_new();
491 rx_gen_regindex(ctx, mem, a->sz, a->ri, a->rb);
492 rx_gen_st(a->sz, cpu_regs[a->rs], mem);
493 tcg_temp_free(mem);
494 return true;
495 }
496
497 /* mov.<bwl> dsp[rs],dsp[rd] */
498 /* mov.<bwl> rs,dsp[rd] */
499 /* mov.<bwl> dsp[rs],rd */
500 /* mov.<bwl> rs,rd */
501 static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a)
502 {
503 static void (* const mov[])(TCGv ret, TCGv arg) = {
504 tcg_gen_ext8s_i32, tcg_gen_ext16s_i32, tcg_gen_mov_i32,
505 };
506 TCGv tmp, mem, addr;
507 if (a->lds == 3 && a->ldd == 3) {
508 /* mov.<bwl> rs,rd */
509 mov[a->sz](cpu_regs[a->rd], cpu_regs[a->rs]);
510 return true;
511 }
512
513 mem = tcg_temp_new();
514 if (a->lds == 3) {
515 /* mov.<bwl> rs,dsp[rd] */
516 addr = rx_index_addr(ctx, mem, a->ldd, a->sz, a->rs);
517 rx_gen_st(a->sz, cpu_regs[a->rd], addr);
518 } else if (a->ldd == 3) {
519 /* mov.<bwl> dsp[rs],rd */
520 addr = rx_index_addr(ctx, mem, a->lds, a->sz, a->rs);
521 rx_gen_ld(a->sz, cpu_regs[a->rd], addr);
522 } else {
523 /* mov.<bwl> dsp[rs],dsp[rd] */
524 tmp = tcg_temp_new();
525 addr = rx_index_addr(ctx, mem, a->lds, a->sz, a->rs);
526 rx_gen_ld(a->sz, tmp, addr);
527 addr = rx_index_addr(ctx, mem, a->ldd, a->sz, a->rd);
528 rx_gen_st(a->sz, tmp, addr);
529 tcg_temp_free(tmp);
530 }
531 tcg_temp_free(mem);
532 return true;
533 }
534
535 /* mov.<bwl> rs,[rd+] */
536 /* mov.<bwl> rs,[-rd] */
537 static bool trans_MOV_rp(DisasContext *ctx, arg_MOV_rp *a)
538 {
539 TCGv val;
540 val = tcg_temp_new();
541 tcg_gen_mov_i32(val, cpu_regs[a->rs]);
542 if (a->ad == 1) {
543 tcg_gen_subi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1 << a->sz);
544 }
545 rx_gen_st(a->sz, val, cpu_regs[a->rd]);
546 if (a->ad == 0) {
547 tcg_gen_addi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1 << a->sz);
548 }
549 tcg_temp_free(val);
550 return true;
551 }
552
553 /* mov.<bwl> [rd+],rs */
554 /* mov.<bwl> [-rd],rs */
555 static bool trans_MOV_pr(DisasContext *ctx, arg_MOV_pr *a)
556 {
557 TCGv val;
558 val = tcg_temp_new();
559 if (a->ad == 1) {
560 tcg_gen_subi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1 << a->sz);
561 }
562 rx_gen_ld(a->sz, val, cpu_regs[a->rd]);
563 if (a->ad == 0) {
564 tcg_gen_addi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1 << a->sz);
565 }
566 tcg_gen_mov_i32(cpu_regs[a->rs], val);
567 tcg_temp_free(val);
568 return true;
569 }
570
571 /* movu.<bw> dsp5[rs],rd */
572 /* movu.<bw> dsp[rs],rd */
573 static bool trans_MOVU_mr(DisasContext *ctx, arg_MOVU_mr *a)
574 {
575 TCGv mem;
576 mem = tcg_temp_new();
577 tcg_gen_addi_i32(mem, cpu_regs[a->rs], a->dsp << a->sz);
578 rx_gen_ldu(a->sz, cpu_regs[a->rd], mem);
579 tcg_temp_free(mem);
580 return true;
581 }
582
583 /* movu.<bw> rs,rd */
584 static bool trans_MOVU_rr(DisasContext *ctx, arg_MOVU_rr *a)
585 {
586 static void (* const ext[])(TCGv ret, TCGv arg) = {
587 tcg_gen_ext8u_i32, tcg_gen_ext16u_i32,
588 };
589 ext[a->sz](cpu_regs[a->rd], cpu_regs[a->rs]);
590 return true;
591 }
592
593 /* movu.<bw> [ri,rb],rd */
594 static bool trans_MOVU_ar(DisasContext *ctx, arg_MOVU_ar *a)
595 {
596 TCGv mem;
597 mem = tcg_temp_new();
598 rx_gen_regindex(ctx, mem, a->sz, a->ri, a->rb);
599 rx_gen_ldu(a->sz, cpu_regs[a->rd], mem);
600 tcg_temp_free(mem);
601 return true;
602 }
603
604 /* movu.<bw> [rd+],rs */
605 /* mov.<bw> [-rd],rs */
606 static bool trans_MOVU_pr(DisasContext *ctx, arg_MOVU_pr *a)
607 {
608 TCGv val;
609 val = tcg_temp_new();
610 if (a->ad == 1) {
611 tcg_gen_subi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1 << a->sz);
612 }
613 rx_gen_ldu(a->sz, val, cpu_regs[a->rd]);
614 if (a->ad == 0) {
615 tcg_gen_addi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1 << a->sz);
616 }
617 tcg_gen_mov_i32(cpu_regs[a->rs], val);
618 tcg_temp_free(val);
619 return true;
620 }
621
622
623 /* pop rd */
624 static bool trans_POP(DisasContext *ctx, arg_POP *a)
625 {
626 /* mov.l [r0+], rd */
627 arg_MOV_rp mov_a;
628 mov_a.rd = 0;
629 mov_a.rs = a->rd;
630 mov_a.ad = 0;
631 mov_a.sz = MO_32;
632 trans_MOV_pr(ctx, &mov_a);
633 return true;
634 }
635
636 /* popc cr */
637 static bool trans_POPC(DisasContext *ctx, arg_POPC *a)
638 {
639 TCGv val;
640 val = tcg_temp_new();
641 pop(val);
642 move_to_cr(ctx, val, a->cr);
643 if (a->cr == 0 && is_privileged(ctx, 0)) {
644 /* PSW.I may be updated here. exit TB. */
645 ctx->base.is_jmp = DISAS_UPDATE;
646 }
647 tcg_temp_free(val);
648 return true;
649 }
650
651 /* popm rd-rd2 */
652 static bool trans_POPM(DisasContext *ctx, arg_POPM *a)
653 {
654 int r;
655 if (a->rd == 0 || a->rd >= a->rd2) {
656 qemu_log_mask(LOG_GUEST_ERROR,
657 "Invalid register ranges r%d-r%d", a->rd, a->rd2);
658 }
659 r = a->rd;
660 while (r <= a->rd2 && r < 16) {
661 pop(cpu_regs[r++]);
662 }
663 return true;
664 }
665
666
667 /* push.<bwl> rs */
668 static bool trans_PUSH_r(DisasContext *ctx, arg_PUSH_r *a)
669 {
670 TCGv val;
671 val = tcg_temp_new();
672 tcg_gen_mov_i32(val, cpu_regs[a->rs]);
673 tcg_gen_subi_i32(cpu_sp, cpu_sp, 4);
674 rx_gen_st(a->sz, val, cpu_sp);
675 tcg_temp_free(val);
676 return true;
677 }
678
679 /* push.<bwl> dsp[rs] */
680 static bool trans_PUSH_m(DisasContext *ctx, arg_PUSH_m *a)
681 {
682 TCGv mem, val, addr;
683 mem = tcg_temp_new();
684 val = tcg_temp_new();
685 addr = rx_index_addr(ctx, mem, a->ld, a->sz, a->rs);
686 rx_gen_ld(a->sz, val, addr);
687 tcg_gen_subi_i32(cpu_sp, cpu_sp, 4);
688 rx_gen_st(a->sz, val, cpu_sp);
689 tcg_temp_free(mem);
690 tcg_temp_free(val);
691 return true;
692 }
693
694 /* pushc rx */
695 static bool trans_PUSHC(DisasContext *ctx, arg_PUSHC *a)
696 {
697 TCGv val;
698 val = tcg_temp_new();
699 move_from_cr(val, a->cr, ctx->pc);
700 push(val);
701 tcg_temp_free(val);
702 return true;
703 }
704
705 /* pushm rs-rs2 */
706 static bool trans_PUSHM(DisasContext *ctx, arg_PUSHM *a)
707 {
708 int r;
709
710 if (a->rs == 0 || a->rs >= a->rs2) {
711 qemu_log_mask(LOG_GUEST_ERROR,
712 "Invalid register ranges r%d-r%d", a->rs, a->rs2);
713 }
714 r = a->rs2;
715 while (r >= a->rs && r >= 0) {
716 push(cpu_regs[r--]);
717 }
718 return true;
719 }
720
721 /* xchg rs,rd */
722 static bool trans_XCHG_rr(DisasContext *ctx, arg_XCHG_rr *a)
723 {
724 TCGv tmp;
725 tmp = tcg_temp_new();
726 tcg_gen_mov_i32(tmp, cpu_regs[a->rs]);
727 tcg_gen_mov_i32(cpu_regs[a->rs], cpu_regs[a->rd]);
728 tcg_gen_mov_i32(cpu_regs[a->rd], tmp);
729 tcg_temp_free(tmp);
730 return true;
731 }
732
733 /* xchg dsp[rs].<mi>,rd */
734 static bool trans_XCHG_mr(DisasContext *ctx, arg_XCHG_mr *a)
735 {
736 TCGv mem, addr;
737 mem = tcg_temp_new();
738 switch (a->mi) {
739 case 0: /* dsp[rs].b */
740 case 1: /* dsp[rs].w */
741 case 2: /* dsp[rs].l */
742 addr = rx_index_addr(ctx, mem, a->ld, a->mi, a->rs);
743 break;
744 case 3: /* dsp[rs].uw */
745 case 4: /* dsp[rs].ub */
746 addr = rx_index_addr(ctx, mem, a->ld, 4 - a->mi, a->rs);
747 break;
748 default:
749 g_assert_not_reached();
750 }
751 tcg_gen_atomic_xchg_i32(cpu_regs[a->rd], addr, cpu_regs[a->rd],
752 0, mi_to_mop(a->mi));
753 tcg_temp_free(mem);
754 return true;
755 }
756
757 static inline void stcond(TCGCond cond, int rd, int imm)
758 {
759 TCGv z;
760 TCGv _imm;
761 z = tcg_const_i32(0);
762 _imm = tcg_const_i32(imm);
763 tcg_gen_movcond_i32(cond, cpu_regs[rd], cpu_psw_z, z,
764 _imm, cpu_regs[rd]);
765 tcg_temp_free(z);
766 tcg_temp_free(_imm);
767 }
768
769 /* stz #imm,rd */
770 static bool trans_STZ(DisasContext *ctx, arg_STZ *a)
771 {
772 stcond(TCG_COND_EQ, a->rd, a->imm);
773 return true;
774 }
775
776 /* stnz #imm,rd */
777 static bool trans_STNZ(DisasContext *ctx, arg_STNZ *a)
778 {
779 stcond(TCG_COND_NE, a->rd, a->imm);
780 return true;
781 }
782
783 /* sccnd.<bwl> rd */
784 /* sccnd.<bwl> dsp:[rd] */
785 static bool trans_SCCnd(DisasContext *ctx, arg_SCCnd *a)
786 {
787 DisasCompare dc;
788 TCGv val, mem, addr;
789 dc.temp = tcg_temp_new();
790 psw_cond(&dc, a->cd);
791 if (a->ld < 3) {
792 val = tcg_temp_new();
793 mem = tcg_temp_new();
794 tcg_gen_setcondi_i32(dc.cond, val, dc.value, 0);
795 addr = rx_index_addr(ctx, mem, a->sz, a->ld, a->rd);
796 rx_gen_st(a->sz, val, addr);
797 tcg_temp_free(val);
798 tcg_temp_free(mem);
799 } else {
800 tcg_gen_setcondi_i32(dc.cond, cpu_regs[a->rd], dc.value, 0);
801 }
802 tcg_temp_free(dc.temp);
803 return true;
804 }
805
806 /* rtsd #imm */
807 static bool trans_RTSD_i(DisasContext *ctx, arg_RTSD_i *a)
808 {
809 tcg_gen_addi_i32(cpu_sp, cpu_sp, a->imm << 2);
810 pop(cpu_pc);
811 ctx->base.is_jmp = DISAS_JUMP;
812 return true;
813 }
814
815 /* rtsd #imm, rd-rd2 */
816 static bool trans_RTSD_irr(DisasContext *ctx, arg_RTSD_irr *a)
817 {
818 int dst;
819 int adj;
820
821 if (a->rd2 >= a->rd) {
822 adj = a->imm - (a->rd2 - a->rd + 1);
823 } else {
824 adj = a->imm - (15 - a->rd + 1);
825 }
826
827 tcg_gen_addi_i32(cpu_sp, cpu_sp, adj << 2);
828 dst = a->rd;
829 while (dst <= a->rd2 && dst < 16) {
830 pop(cpu_regs[dst++]);
831 }
832 pop(cpu_pc);
833 ctx->base.is_jmp = DISAS_JUMP;
834 return true;
835 }
836
837 typedef void (*op2fn)(TCGv ret, TCGv arg1);
838 typedef void (*op3fn)(TCGv ret, TCGv arg1, TCGv arg2);
839
840 static inline void rx_gen_op_rr(op2fn opr, int dst, int src)
841 {
842 opr(cpu_regs[dst], cpu_regs[src]);
843 }
844
845 static inline void rx_gen_op_rrr(op3fn opr, int dst, int src, int src2)
846 {
847 opr(cpu_regs[dst], cpu_regs[src], cpu_regs[src2]);
848 }
849
850 static inline void rx_gen_op_irr(op3fn opr, int dst, int src, uint32_t src2)
851 {
852 TCGv imm = tcg_const_i32(src2);
853 opr(cpu_regs[dst], cpu_regs[src], imm);
854 tcg_temp_free(imm);
855 }
856
857 static inline void rx_gen_op_mr(op3fn opr, DisasContext *ctx,
858 int dst, int src, int ld, int mi)
859 {
860 TCGv val, mem;
861 mem = tcg_temp_new();
862 val = rx_load_source(ctx, mem, ld, mi, src);
863 opr(cpu_regs[dst], cpu_regs[dst], val);
864 tcg_temp_free(mem);
865 }
866
867 static void rx_and(TCGv ret, TCGv arg1, TCGv arg2)
868 {
869 tcg_gen_and_i32(cpu_psw_s, arg1, arg2);
870 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
871 tcg_gen_mov_i32(ret, cpu_psw_s);
872 }
873
874 /* and #uimm:4, rd */
875 /* and #imm, rd */
876 static bool trans_AND_ir(DisasContext *ctx, arg_AND_ir *a)
877 {
878 rx_gen_op_irr(rx_and, a->rd, a->rd, a->imm);
879 return true;
880 }
881
882 /* and dsp[rs], rd */
883 /* and rs,rd */
884 static bool trans_AND_mr(DisasContext *ctx, arg_AND_mr *a)
885 {
886 rx_gen_op_mr(rx_and, ctx, a->rd, a->rs, a->ld, a->mi);
887 return true;
888 }
889
890 /* and rs,rs2,rd */
891 static bool trans_AND_rrr(DisasContext *ctx, arg_AND_rrr *a)
892 {
893 rx_gen_op_rrr(rx_and, a->rd, a->rs, a->rs2);
894 return true;
895 }
896
897 static void rx_or(TCGv ret, TCGv arg1, TCGv arg2)
898 {
899 tcg_gen_or_i32(cpu_psw_s, arg1, arg2);
900 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
901 tcg_gen_mov_i32(ret, cpu_psw_s);
902 }
903
904 /* or #uimm:4, rd */
905 /* or #imm, rd */
906 static bool trans_OR_ir(DisasContext *ctx, arg_OR_ir *a)
907 {
908 rx_gen_op_irr(rx_or, a->rd, a->rd, a->imm);
909 return true;
910 }
911
912 /* or dsp[rs], rd */
913 /* or rs,rd */
914 static bool trans_OR_mr(DisasContext *ctx, arg_OR_mr *a)
915 {
916 rx_gen_op_mr(rx_or, ctx, a->rd, a->rs, a->ld, a->mi);
917 return true;
918 }
919
920 /* or rs,rs2,rd */
921 static bool trans_OR_rrr(DisasContext *ctx, arg_OR_rrr *a)
922 {
923 rx_gen_op_rrr(rx_or, a->rd, a->rs, a->rs2);
924 return true;
925 }
926
927 static void rx_xor(TCGv ret, TCGv arg1, TCGv arg2)
928 {
929 tcg_gen_xor_i32(cpu_psw_s, arg1, arg2);
930 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
931 tcg_gen_mov_i32(ret, cpu_psw_s);
932 }
933
934 /* xor #imm, rd */
935 static bool trans_XOR_ir(DisasContext *ctx, arg_XOR_ir *a)
936 {
937 rx_gen_op_irr(rx_xor, a->rd, a->rd, a->imm);
938 return true;
939 }
940
941 /* xor dsp[rs], rd */
942 /* xor rs,rd */
943 static bool trans_XOR_mr(DisasContext *ctx, arg_XOR_mr *a)
944 {
945 rx_gen_op_mr(rx_xor, ctx, a->rd, a->rs, a->ld, a->mi);
946 return true;
947 }
948
949 static void rx_tst(TCGv ret, TCGv arg1, TCGv arg2)
950 {
951 tcg_gen_and_i32(cpu_psw_s, arg1, arg2);
952 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
953 }
954
955 /* tst #imm, rd */
956 static bool trans_TST_ir(DisasContext *ctx, arg_TST_ir *a)
957 {
958 rx_gen_op_irr(rx_tst, a->rd, a->rd, a->imm);
959 return true;
960 }
961
962 /* tst dsp[rs], rd */
963 /* tst rs, rd */
964 static bool trans_TST_mr(DisasContext *ctx, arg_TST_mr *a)
965 {
966 rx_gen_op_mr(rx_tst, ctx, a->rd, a->rs, a->ld, a->mi);
967 return true;
968 }
969
970 static void rx_not(TCGv ret, TCGv arg1)
971 {
972 tcg_gen_not_i32(ret, arg1);
973 tcg_gen_mov_i32(cpu_psw_z, ret);
974 tcg_gen_mov_i32(cpu_psw_s, ret);
975 }
976
977 /* not rd */
978 /* not rs, rd */
979 static bool trans_NOT_rr(DisasContext *ctx, arg_NOT_rr *a)
980 {
981 rx_gen_op_rr(rx_not, a->rd, a->rs);
982 return true;
983 }
984
985 static void rx_neg(TCGv ret, TCGv arg1)
986 {
987 tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_psw_o, arg1, 0x80000000);
988 tcg_gen_neg_i32(ret, arg1);
989 tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_psw_c, ret, 0);
990 tcg_gen_mov_i32(cpu_psw_z, ret);
991 tcg_gen_mov_i32(cpu_psw_s, ret);
992 }
993
994
995 /* neg rd */
996 /* neg rs, rd */
997 static bool trans_NEG_rr(DisasContext *ctx, arg_NEG_rr *a)
998 {
999 rx_gen_op_rr(rx_neg, a->rd, a->rs);
1000 return true;
1001 }
1002
1003 /* ret = arg1 + arg2 + psw_c */
1004 static void rx_adc(TCGv ret, TCGv arg1, TCGv arg2)
1005 {
1006 TCGv z;
1007 z = tcg_const_i32(0);
1008 tcg_gen_add2_i32(cpu_psw_s, cpu_psw_c, arg1, z, cpu_psw_c, z);
1009 tcg_gen_add2_i32(cpu_psw_s, cpu_psw_c, cpu_psw_s, cpu_psw_c, arg2, z);
1010 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
1011 tcg_gen_xor_i32(cpu_psw_o, cpu_psw_s, arg1);
1012 tcg_gen_xor_i32(z, arg1, arg2);
1013 tcg_gen_andc_i32(cpu_psw_o, cpu_psw_o, z);
1014 tcg_gen_mov_i32(ret, cpu_psw_s);
1015 tcg_temp_free(z);
1016 }
1017
1018 /* adc #imm, rd */
1019 static bool trans_ADC_ir(DisasContext *ctx, arg_ADC_ir *a)
1020 {
1021 rx_gen_op_irr(rx_adc, a->rd, a->rd, a->imm);
1022 return true;
1023 }
1024
1025 /* adc rs, rd */
1026 static bool trans_ADC_rr(DisasContext *ctx, arg_ADC_rr *a)
1027 {
1028 rx_gen_op_rrr(rx_adc, a->rd, a->rd, a->rs);
1029 return true;
1030 }
1031
1032 /* adc dsp[rs], rd */
1033 static bool trans_ADC_mr(DisasContext *ctx, arg_ADC_mr *a)
1034 {
1035 /* mi only 2 */
1036 if (a->mi != 2) {
1037 return false;
1038 }
1039 rx_gen_op_mr(rx_adc, ctx, a->rd, a->rs, a->ld, a->mi);
1040 return true;
1041 }
1042
1043 /* ret = arg1 + arg2 */
1044 static void rx_add(TCGv ret, TCGv arg1, TCGv arg2)
1045 {
1046 TCGv z;
1047 z = tcg_const_i32(0);
1048 tcg_gen_add2_i32(cpu_psw_s, cpu_psw_c, arg1, z, arg2, z);
1049 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
1050 tcg_gen_xor_i32(cpu_psw_o, cpu_psw_s, arg1);
1051 tcg_gen_xor_i32(z, arg1, arg2);
1052 tcg_gen_andc_i32(cpu_psw_o, cpu_psw_o, z);
1053 tcg_gen_mov_i32(ret, cpu_psw_s);
1054 tcg_temp_free(z);
1055 }
1056
1057 /* add #uimm4, rd */
1058 /* add #imm, rs, rd */
1059 static bool trans_ADD_irr(DisasContext *ctx, arg_ADD_irr *a)
1060 {
1061 rx_gen_op_irr(rx_add, a->rd, a->rs2, a->imm);
1062 return true;
1063 }
1064
1065 /* add rs, rd */
1066 /* add dsp[rs], rd */
1067 static bool trans_ADD_mr(DisasContext *ctx, arg_ADD_mr *a)
1068 {
1069 rx_gen_op_mr(rx_add, ctx, a->rd, a->rs, a->ld, a->mi);
1070 return true;
1071 }
1072
1073 /* add rs, rs2, rd */
1074 static bool trans_ADD_rrr(DisasContext *ctx, arg_ADD_rrr *a)
1075 {
1076 rx_gen_op_rrr(rx_add, a->rd, a->rs, a->rs2);
1077 return true;
1078 }
1079
1080 /* ret = arg1 - arg2 */
1081 static void rx_sub(TCGv ret, TCGv arg1, TCGv arg2)
1082 {
1083 TCGv temp;
1084 tcg_gen_sub_i32(cpu_psw_s, arg1, arg2);
1085 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_s);
1086 tcg_gen_setcond_i32(TCG_COND_GEU, cpu_psw_c, arg1, arg2);
1087 tcg_gen_xor_i32(cpu_psw_o, cpu_psw_s, arg1);
1088 temp = tcg_temp_new_i32();
1089 tcg_gen_xor_i32(temp, arg1, arg2);
1090 tcg_gen_and_i32(cpu_psw_o, cpu_psw_o, temp);
1091 tcg_temp_free_i32(temp);
1092 /* CMP not requred return */
1093 if (ret) {
1094 tcg_gen_mov_i32(ret, cpu_psw_s);
1095 }
1096 }
1097 static void rx_cmp(TCGv dummy, TCGv arg1, TCGv arg2)
1098 {
1099 rx_sub(NULL, arg1, arg2);
1100 }
1101 /* ret = arg1 - arg2 - !psw_c */
1102 /* -> ret = arg1 + ~arg2 + psw_c */
1103 static void rx_sbb(TCGv ret, TCGv arg1, TCGv arg2)
1104 {
1105 TCGv temp;
1106 temp = tcg_temp_new();
1107 tcg_gen_not_i32(temp, arg2);
1108 rx_adc(ret, arg1, temp);
1109 tcg_temp_free(temp);
1110 }
1111
1112 /* cmp #imm4, rs2 */
1113 /* cmp #imm8, rs2 */
1114 /* cmp #imm, rs2 */
1115 static bool trans_CMP_ir(DisasContext *ctx, arg_CMP_ir *a)
1116 {
1117 rx_gen_op_irr(rx_cmp, 0, a->rs2, a->imm);
1118 return true;
1119 }
1120
1121 /* cmp rs, rs2 */
1122 /* cmp dsp[rs], rs2 */
1123 static bool trans_CMP_mr(DisasContext *ctx, arg_CMP_mr *a)
1124 {
1125 rx_gen_op_mr(rx_cmp, ctx, a->rd, a->rs, a->ld, a->mi);
1126 return true;
1127 }
1128
1129 /* sub #imm4, rd */
1130 static bool trans_SUB_ir(DisasContext *ctx, arg_SUB_ir *a)
1131 {
1132 rx_gen_op_irr(rx_sub, a->rd, a->rd, a->imm);
1133 return true;
1134 }
1135
1136 /* sub rs, rd */
1137 /* sub dsp[rs], rd */
1138 static bool trans_SUB_mr(DisasContext *ctx, arg_SUB_mr *a)
1139 {
1140 rx_gen_op_mr(rx_sub, ctx, a->rd, a->rs, a->ld, a->mi);
1141 return true;
1142 }
1143
1144 /* sub rs2, rs, rd */
1145 static bool trans_SUB_rrr(DisasContext *ctx, arg_SUB_rrr *a)
1146 {
1147 rx_gen_op_rrr(rx_sub, a->rd, a->rs2, a->rs);
1148 return true;
1149 }
1150
1151 /* sbb rs, rd */
1152 static bool trans_SBB_rr(DisasContext *ctx, arg_SBB_rr *a)
1153 {
1154 rx_gen_op_rrr(rx_sbb, a->rd, a->rd, a->rs);
1155 return true;
1156 }
1157
1158 /* sbb dsp[rs], rd */
1159 static bool trans_SBB_mr(DisasContext *ctx, arg_SBB_mr *a)
1160 {
1161 /* mi only 2 */
1162 if (a->mi != 2) {
1163 return false;
1164 }
1165 rx_gen_op_mr(rx_sbb, ctx, a->rd, a->rs, a->ld, a->mi);
1166 return true;
1167 }
1168
1169 static void rx_abs(TCGv ret, TCGv arg1)
1170 {
1171 TCGv neg;
1172 TCGv zero;
1173 neg = tcg_temp_new();
1174 zero = tcg_const_i32(0);
1175 tcg_gen_neg_i32(neg, arg1);
1176 tcg_gen_movcond_i32(TCG_COND_LT, ret, arg1, zero, neg, arg1);
1177 tcg_temp_free(neg);
1178 tcg_temp_free(zero);
1179 }
1180
1181 /* abs rd */
1182 /* abs rs, rd */
1183 static bool trans_ABS_rr(DisasContext *ctx, arg_ABS_rr *a)
1184 {
1185 rx_gen_op_rr(rx_abs, a->rd, a->rs);
1186 return true;
1187 }
1188
1189 /* max #imm, rd */
1190 static bool trans_MAX_ir(DisasContext *ctx, arg_MAX_ir *a)
1191 {
1192 rx_gen_op_irr(tcg_gen_smax_i32, a->rd, a->rd, a->imm);
1193 return true;
1194 }
1195
1196 /* max rs, rd */
1197 /* max dsp[rs], rd */
1198 static bool trans_MAX_mr(DisasContext *ctx, arg_MAX_mr *a)
1199 {
1200 rx_gen_op_mr(tcg_gen_smax_i32, ctx, a->rd, a->rs, a->ld, a->mi);
1201 return true;
1202 }
1203
1204 /* min #imm, rd */
1205 static bool trans_MIN_ir(DisasContext *ctx, arg_MIN_ir *a)
1206 {
1207 rx_gen_op_irr(tcg_gen_smin_i32, a->rd, a->rd, a->imm);
1208 return true;
1209 }
1210
1211 /* min rs, rd */
1212 /* min dsp[rs], rd */
1213 static bool trans_MIN_mr(DisasContext *ctx, arg_MIN_mr *a)
1214 {
1215 rx_gen_op_mr(tcg_gen_smin_i32, ctx, a->rd, a->rs, a->ld, a->mi);
1216 return true;
1217 }
1218
1219 /* mul #uimm4, rd */
1220 /* mul #imm, rd */
1221 static bool trans_MUL_ir(DisasContext *ctx, arg_MUL_ir *a)
1222 {
1223 rx_gen_op_irr(tcg_gen_mul_i32, a->rd, a->rd, a->imm);
1224 return true;
1225 }
1226
1227 /* mul rs, rd */
1228 /* mul dsp[rs], rd */
1229 static bool trans_MUL_mr(DisasContext *ctx, arg_MUL_mr *a)
1230 {
1231 rx_gen_op_mr(tcg_gen_mul_i32, ctx, a->rd, a->rs, a->ld, a->mi);
1232 return true;
1233 }
1234
1235 /* mul rs, rs2, rd */
1236 static bool trans_MUL_rrr(DisasContext *ctx, arg_MUL_rrr *a)
1237 {
1238 rx_gen_op_rrr(tcg_gen_mul_i32, a->rd, a->rs, a->rs2);
1239 return true;
1240 }
1241
1242 /* emul #imm, rd */
1243 static bool trans_EMUL_ir(DisasContext *ctx, arg_EMUL_ir *a)
1244 {
1245 TCGv imm = tcg_const_i32(a->imm);
1246 if (a->rd > 14) {
1247 qemu_log_mask(LOG_GUEST_ERROR, "rd too large %d", a->rd);
1248 }
1249 tcg_gen_muls2_i32(cpu_regs[a->rd], cpu_regs[(a->rd + 1) & 15],
1250 cpu_regs[a->rd], imm);
1251 tcg_temp_free(imm);
1252 return true;
1253 }
1254
1255 /* emul rs, rd */
1256 /* emul dsp[rs], rd */
1257 static bool trans_EMUL_mr(DisasContext *ctx, arg_EMUL_mr *a)
1258 {
1259 TCGv val, mem;
1260 if (a->rd > 14) {
1261 qemu_log_mask(LOG_GUEST_ERROR, "rd too large %d", a->rd);
1262 }
1263 mem = tcg_temp_new();
1264 val = rx_load_source(ctx, mem, a->ld, a->mi, a->rs);
1265 tcg_gen_muls2_i32(cpu_regs[a->rd], cpu_regs[(a->rd + 1) & 15],
1266 cpu_regs[a->rd], val);
1267 tcg_temp_free(mem);
1268 return true;
1269 }
1270
1271 /* emulu #imm, rd */
1272 static bool trans_EMULU_ir(DisasContext *ctx, arg_EMULU_ir *a)
1273 {
1274 TCGv imm = tcg_const_i32(a->imm);
1275 if (a->rd > 14) {
1276 qemu_log_mask(LOG_GUEST_ERROR, "rd too large %d", a->rd);
1277 }
1278 tcg_gen_mulu2_i32(cpu_regs[a->rd], cpu_regs[(a->rd + 1) & 15],
1279 cpu_regs[a->rd], imm);
1280 tcg_temp_free(imm);
1281 return true;
1282 }
1283
1284 /* emulu rs, rd */
1285 /* emulu dsp[rs], rd */
1286 static bool trans_EMULU_mr(DisasContext *ctx, arg_EMULU_mr *a)
1287 {
1288 TCGv val, mem;
1289 if (a->rd > 14) {
1290 qemu_log_mask(LOG_GUEST_ERROR, "rd too large %d", a->rd);
1291 }
1292 mem = tcg_temp_new();
1293 val = rx_load_source(ctx, mem, a->ld, a->mi, a->rs);
1294 tcg_gen_mulu2_i32(cpu_regs[a->rd], cpu_regs[(a->rd + 1) & 15],
1295 cpu_regs[a->rd], val);
1296 tcg_temp_free(mem);
1297 return true;
1298 }
1299
1300 static void rx_div(TCGv ret, TCGv arg1, TCGv arg2)
1301 {
1302 gen_helper_div(ret, cpu_env, arg1, arg2);
1303 }
1304
1305 static void rx_divu(TCGv ret, TCGv arg1, TCGv arg2)
1306 {
1307 gen_helper_divu(ret, cpu_env, arg1, arg2);
1308 }
1309
1310 /* div #imm, rd */
1311 static bool trans_DIV_ir(DisasContext *ctx, arg_DIV_ir *a)
1312 {
1313 rx_gen_op_irr(rx_div, a->rd, a->rd, a->imm);
1314 return true;
1315 }
1316
1317 /* div rs, rd */
1318 /* div dsp[rs], rd */
1319 static bool trans_DIV_mr(DisasContext *ctx, arg_DIV_mr *a)
1320 {
1321 rx_gen_op_mr(rx_div, ctx, a->rd, a->rs, a->ld, a->mi);
1322 return true;
1323 }
1324
1325 /* divu #imm, rd */
1326 static bool trans_DIVU_ir(DisasContext *ctx, arg_DIVU_ir *a)
1327 {
1328 rx_gen_op_irr(rx_divu, a->rd, a->rd, a->imm);
1329 return true;
1330 }
1331
1332 /* divu rs, rd */
1333 /* divu dsp[rs], rd */
1334 static bool trans_DIVU_mr(DisasContext *ctx, arg_DIVU_mr *a)
1335 {
1336 rx_gen_op_mr(rx_divu, ctx, a->rd, a->rs, a->ld, a->mi);
1337 return true;
1338 }
1339
1340
1341 /* shll #imm:5, rd */
1342 /* shll #imm:5, rs2, rd */
1343 static bool trans_SHLL_irr(DisasContext *ctx, arg_SHLL_irr *a)
1344 {
1345 TCGv tmp;
1346 tmp = tcg_temp_new();
1347 if (a->imm) {
1348 tcg_gen_sari_i32(cpu_psw_c, cpu_regs[a->rs2], 32 - a->imm);
1349 tcg_gen_shli_i32(cpu_regs[a->rd], cpu_regs[a->rs2], a->imm);
1350 tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_psw_o, cpu_psw_c, 0);
1351 tcg_gen_setcondi_i32(TCG_COND_EQ, tmp, cpu_psw_c, 0xffffffff);
1352 tcg_gen_or_i32(cpu_psw_o, cpu_psw_o, tmp);
1353 tcg_gen_setcondi_i32(TCG_COND_NE, cpu_psw_c, cpu_psw_c, 0);
1354 } else {
1355 tcg_gen_mov_i32(cpu_regs[a->rd], cpu_regs[a->rs2]);
1356 tcg_gen_movi_i32(cpu_psw_c, 0);
1357 tcg_gen_movi_i32(cpu_psw_o, 0);
1358 }
1359 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[a->rd]);
1360 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[a->rd]);
1361 return true;
1362 }
1363
1364 /* shll rs, rd */
1365 static bool trans_SHLL_rr(DisasContext *ctx, arg_SHLL_rr *a)
1366 {
1367 TCGLabel *noshift, *done;
1368 TCGv count, tmp;
1369
1370 noshift = gen_new_label();
1371 done = gen_new_label();
1372 /* if (cpu_regs[a->rs]) { */
1373 tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_regs[a->rs], 0, noshift);
1374 count = tcg_const_i32(32);
1375 tmp = tcg_temp_new();
1376 tcg_gen_andi_i32(tmp, cpu_regs[a->rs], 31);
1377 tcg_gen_sub_i32(count, count, tmp);
1378 tcg_gen_sar_i32(cpu_psw_c, cpu_regs[a->rd], count);
1379 tcg_gen_shl_i32(cpu_regs[a->rd], cpu_regs[a->rd], tmp);
1380 tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_psw_o, cpu_psw_c, 0);
1381 tcg_gen_setcondi_i32(TCG_COND_EQ, tmp, cpu_psw_c, 0xffffffff);
1382 tcg_gen_or_i32(cpu_psw_o, cpu_psw_o, tmp);
1383 tcg_gen_setcondi_i32(TCG_COND_NE, cpu_psw_c, cpu_psw_c, 0);
1384 tcg_gen_br(done);
1385 /* } else { */
1386 gen_set_label(noshift);
1387 tcg_gen_movi_i32(cpu_psw_c, 0);
1388 tcg_gen_movi_i32(cpu_psw_o, 0);
1389 /* } */
1390 gen_set_label(done);
1391 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[a->rd]);
1392 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[a->rd]);
1393 tcg_temp_free(count);
1394 tcg_temp_free(tmp);
1395 return true;
1396 }
1397
1398 static inline void shiftr_imm(uint32_t rd, uint32_t rs, uint32_t imm,
1399 unsigned int alith)
1400 {
1401 static void (* const gen_sXri[])(TCGv ret, TCGv arg1, int arg2) = {
1402 tcg_gen_shri_i32, tcg_gen_sari_i32,
1403 };
1404 tcg_debug_assert(alith < 2);
1405 if (imm) {
1406 gen_sXri[alith](cpu_regs[rd], cpu_regs[rs], imm - 1);
1407 tcg_gen_andi_i32(cpu_psw_c, cpu_regs[rd], 0x00000001);
1408 gen_sXri[alith](cpu_regs[rd], cpu_regs[rd], 1);
1409 } else {
1410 tcg_gen_mov_i32(cpu_regs[rd], cpu_regs[rs]);
1411 tcg_gen_movi_i32(cpu_psw_c, 0);
1412 }
1413 tcg_gen_movi_i32(cpu_psw_o, 0);
1414 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[rd]);
1415 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[rd]);
1416 }
1417
1418 static inline void shiftr_reg(uint32_t rd, uint32_t rs, unsigned int alith)
1419 {
1420 TCGLabel *noshift, *done;
1421 TCGv count;
1422 static void (* const gen_sXri[])(TCGv ret, TCGv arg1, int arg2) = {
1423 tcg_gen_shri_i32, tcg_gen_sari_i32,
1424 };
1425 static void (* const gen_sXr[])(TCGv ret, TCGv arg1, TCGv arg2) = {
1426 tcg_gen_shr_i32, tcg_gen_sar_i32,
1427 };
1428 tcg_debug_assert(alith < 2);
1429 noshift = gen_new_label();
1430 done = gen_new_label();
1431 count = tcg_temp_new();
1432 /* if (cpu_regs[rs]) { */
1433 tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_regs[rs], 0, noshift);
1434 tcg_gen_andi_i32(count, cpu_regs[rs], 31);
1435 tcg_gen_subi_i32(count, count, 1);
1436 gen_sXr[alith](cpu_regs[rd], cpu_regs[rd], count);
1437 tcg_gen_andi_i32(cpu_psw_c, cpu_regs[rd], 0x00000001);
1438 gen_sXri[alith](cpu_regs[rd], cpu_regs[rd], 1);
1439 tcg_gen_br(done);
1440 /* } else { */
1441 gen_set_label(noshift);
1442 tcg_gen_movi_i32(cpu_psw_c, 0);
1443 /* } */
1444 gen_set_label(done);
1445 tcg_gen_movi_i32(cpu_psw_o, 0);
1446 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[rd]);
1447 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[rd]);
1448 tcg_temp_free(count);
1449 }
1450
1451 /* shar #imm:5, rd */
1452 /* shar #imm:5, rs2, rd */
1453 static bool trans_SHAR_irr(DisasContext *ctx, arg_SHAR_irr *a)
1454 {
1455 shiftr_imm(a->rd, a->rs2, a->imm, 1);
1456 return true;
1457 }
1458
1459 /* shar rs, rd */
1460 static bool trans_SHAR_rr(DisasContext *ctx, arg_SHAR_rr *a)
1461 {
1462 shiftr_reg(a->rd, a->rs, 1);
1463 return true;
1464 }
1465
1466 /* shlr #imm:5, rd */
1467 /* shlr #imm:5, rs2, rd */
1468 static bool trans_SHLR_irr(DisasContext *ctx, arg_SHLR_irr *a)
1469 {
1470 shiftr_imm(a->rd, a->rs2, a->imm, 0);
1471 return true;
1472 }
1473
1474 /* shlr rs, rd */
1475 static bool trans_SHLR_rr(DisasContext *ctx, arg_SHLR_rr *a)
1476 {
1477 shiftr_reg(a->rd, a->rs, 0);
1478 return true;
1479 }
1480
1481 /* rolc rd */
1482 static bool trans_ROLC(DisasContext *ctx, arg_ROLC *a)
1483 {
1484 TCGv tmp;
1485 tmp = tcg_temp_new();
1486 tcg_gen_shri_i32(tmp, cpu_regs[a->rd], 31);
1487 tcg_gen_shli_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1);
1488 tcg_gen_or_i32(cpu_regs[a->rd], cpu_regs[a->rd], cpu_psw_c);
1489 tcg_gen_mov_i32(cpu_psw_c, tmp);
1490 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[a->rd]);
1491 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[a->rd]);
1492 tcg_temp_free(tmp);
1493 return true;
1494 }
1495
1496 /* rorc rd */
1497 static bool trans_RORC(DisasContext *ctx, arg_RORC *a)
1498 {
1499 TCGv tmp;
1500 tmp = tcg_temp_new();
1501 tcg_gen_andi_i32(tmp, cpu_regs[a->rd], 0x00000001);
1502 tcg_gen_shri_i32(cpu_regs[a->rd], cpu_regs[a->rd], 1);
1503 tcg_gen_shli_i32(cpu_psw_c, cpu_psw_c, 31);
1504 tcg_gen_or_i32(cpu_regs[a->rd], cpu_regs[a->rd], cpu_psw_c);
1505 tcg_gen_mov_i32(cpu_psw_c, tmp);
1506 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[a->rd]);
1507 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[a->rd]);
1508 return true;
1509 }
1510
1511 enum {ROTR = 0, ROTL = 1};
1512 enum {ROT_IMM = 0, ROT_REG = 1};
1513 static inline void rx_rot(int ir, int dir, int rd, int src)
1514 {
1515 switch (dir) {
1516 case ROTL:
1517 if (ir == ROT_IMM) {
1518 tcg_gen_rotli_i32(cpu_regs[rd], cpu_regs[rd], src);
1519 } else {
1520 tcg_gen_rotl_i32(cpu_regs[rd], cpu_regs[rd], cpu_regs[src]);
1521 }
1522 tcg_gen_andi_i32(cpu_psw_c, cpu_regs[rd], 0x00000001);
1523 break;
1524 case ROTR:
1525 if (ir == ROT_IMM) {
1526 tcg_gen_rotri_i32(cpu_regs[rd], cpu_regs[rd], src);
1527 } else {
1528 tcg_gen_rotr_i32(cpu_regs[rd], cpu_regs[rd], cpu_regs[src]);
1529 }
1530 tcg_gen_shri_i32(cpu_psw_c, cpu_regs[rd], 31);
1531 break;
1532 }
1533 tcg_gen_mov_i32(cpu_psw_z, cpu_regs[rd]);
1534 tcg_gen_mov_i32(cpu_psw_s, cpu_regs[rd]);
1535 }
1536
1537 /* rotl #imm, rd */
1538 static bool trans_ROTL_ir(DisasContext *ctx, arg_ROTL_ir *a)
1539 {
1540 rx_rot(ROT_IMM, ROTL, a->rd, a->imm);
1541 return true;
1542 }
1543
1544 /* rotl rs, rd */
1545 static bool trans_ROTL_rr(DisasContext *ctx, arg_ROTL_rr *a)
1546 {
1547 rx_rot(ROT_REG, ROTL, a->rd, a->rs);
1548 return true;
1549 }
1550
1551 /* rotr #imm, rd */
1552 static bool trans_ROTR_ir(DisasContext *ctx, arg_ROTR_ir *a)
1553 {
1554 rx_rot(ROT_IMM, ROTR, a->rd, a->imm);
1555 return true;
1556 }
1557
1558 /* rotr rs, rd */
1559 static bool trans_ROTR_rr(DisasContext *ctx, arg_ROTR_rr *a)
1560 {
1561 rx_rot(ROT_REG, ROTR, a->rd, a->rs);
1562 return true;
1563 }
1564
1565 /* revl rs, rd */
1566 static bool trans_REVL(DisasContext *ctx, arg_REVL *a)
1567 {
1568 tcg_gen_bswap32_i32(cpu_regs[a->rd], cpu_regs[a->rs]);
1569 return true;
1570 }
1571
1572 /* revw rs, rd */
1573 static bool trans_REVW(DisasContext *ctx, arg_REVW *a)
1574 {
1575 TCGv tmp;
1576 tmp = tcg_temp_new();
1577 tcg_gen_andi_i32(tmp, cpu_regs[a->rs], 0x00ff00ff);
1578 tcg_gen_shli_i32(tmp, tmp, 8);
1579 tcg_gen_shri_i32(cpu_regs[a->rd], cpu_regs[a->rs], 8);
1580 tcg_gen_andi_i32(cpu_regs[a->rd], cpu_regs[a->rd], 0x00ff00ff);
1581 tcg_gen_or_i32(cpu_regs[a->rd], cpu_regs[a->rd], tmp);
1582 tcg_temp_free(tmp);
1583 return true;
1584 }
1585
1586 /* conditional branch helper */
1587 static void rx_bcnd_main(DisasContext *ctx, int cd, int dst)
1588 {
1589 DisasCompare dc;
1590 TCGLabel *t, *done;
1591
1592 switch (cd) {
1593 case 0 ... 13:
1594 dc.temp = tcg_temp_new();
1595 psw_cond(&dc, cd);
1596 t = gen_new_label();
1597 done = gen_new_label();
1598 tcg_gen_brcondi_i32(dc.cond, dc.value, 0, t);
1599 gen_goto_tb(ctx, 0, ctx->base.pc_next);
1600 tcg_gen_br(done);
1601 gen_set_label(t);
1602 gen_goto_tb(ctx, 1, ctx->pc + dst);
1603 gen_set_label(done);
1604 tcg_temp_free(dc.temp);
1605 break;
1606 case 14:
1607 /* always true case */
1608 gen_goto_tb(ctx, 0, ctx->pc + dst);
1609 break;
1610 case 15:
1611 /* always false case */
1612 /* Nothing do */
1613 break;
1614 }
1615 }
1616
1617 /* beq dsp:3 / bne dsp:3 */
1618 /* beq dsp:8 / bne dsp:8 */
1619 /* bc dsp:8 / bnc dsp:8 */
1620 /* bgtu dsp:8 / bleu dsp:8 */
1621 /* bpz dsp:8 / bn dsp:8 */
1622 /* bge dsp:8 / blt dsp:8 */
1623 /* bgt dsp:8 / ble dsp:8 */
1624 /* bo dsp:8 / bno dsp:8 */
1625 /* beq dsp:16 / bne dsp:16 */
1626 static bool trans_BCnd(DisasContext *ctx, arg_BCnd *a)
1627 {
1628 rx_bcnd_main(ctx, a->cd, a->dsp);
1629 return true;
1630 }
1631
1632 /* bra dsp:3 */
1633 /* bra dsp:8 */
1634 /* bra dsp:16 */
1635 /* bra dsp:24 */
1636 static bool trans_BRA(DisasContext *ctx, arg_BRA *a)
1637 {
1638 rx_bcnd_main(ctx, 14, a->dsp);
1639 return true;
1640 }
1641
1642 /* bra rs */
1643 static bool trans_BRA_l(DisasContext *ctx, arg_BRA_l *a)
1644 {
1645 tcg_gen_addi_i32(cpu_pc, cpu_regs[a->rd], ctx->pc);
1646 ctx->base.is_jmp = DISAS_JUMP;
1647 return true;
1648 }
1649
1650 static inline void rx_save_pc(DisasContext *ctx)
1651 {
1652 TCGv pc = tcg_const_i32(ctx->base.pc_next);
1653 push(pc);
1654 tcg_temp_free(pc);
1655 }
1656
1657 /* jmp rs */
1658 static bool trans_JMP(DisasContext *ctx, arg_JMP *a)
1659 {
1660 tcg_gen_mov_i32(cpu_pc, cpu_regs[a->rs]);
1661 ctx->base.is_jmp = DISAS_JUMP;
1662 return true;
1663 }
1664
1665 /* jsr rs */
1666 static bool trans_JSR(DisasContext *ctx, arg_JSR *a)
1667 {
1668 rx_save_pc(ctx);
1669 tcg_gen_mov_i32(cpu_pc, cpu_regs[a->rs]);
1670 ctx->base.is_jmp = DISAS_JUMP;
1671 return true;
1672 }
1673
1674 /* bsr dsp:16 */
1675 /* bsr dsp:24 */
1676 static bool trans_BSR(DisasContext *ctx, arg_BSR *a)
1677 {
1678 rx_save_pc(ctx);
1679 rx_bcnd_main(ctx, 14, a->dsp);
1680 return true;
1681 }
1682
1683 /* bsr rs */
1684 static bool trans_BSR_l(DisasContext *ctx, arg_BSR_l *a)
1685 {
1686 rx_save_pc(ctx);
1687 tcg_gen_addi_i32(cpu_pc, cpu_regs[a->rd], ctx->pc);
1688 ctx->base.is_jmp = DISAS_JUMP;
1689 return true;
1690 }
1691
1692 /* rts */
1693 static bool trans_RTS(DisasContext *ctx, arg_RTS *a)
1694 {
1695 pop(cpu_pc);
1696 ctx->base.is_jmp = DISAS_JUMP;
1697 return true;
1698 }
1699
1700 /* nop */
1701 static bool trans_NOP(DisasContext *ctx, arg_NOP *a)
1702 {
1703 return true;
1704 }
1705
1706 /* scmpu */
1707 static bool trans_SCMPU(DisasContext *ctx, arg_SCMPU *a)
1708 {
1709 gen_helper_scmpu(cpu_env);
1710 return true;
1711 }
1712
1713 /* smovu */
1714 static bool trans_SMOVU(DisasContext *ctx, arg_SMOVU *a)
1715 {
1716 gen_helper_smovu(cpu_env);
1717 return true;
1718 }
1719
1720 /* smovf */
1721 static bool trans_SMOVF(DisasContext *ctx, arg_SMOVF *a)
1722 {
1723 gen_helper_smovf(cpu_env);
1724 return true;
1725 }
1726
1727 /* smovb */
1728 static bool trans_SMOVB(DisasContext *ctx, arg_SMOVB *a)
1729 {
1730 gen_helper_smovb(cpu_env);
1731 return true;
1732 }
1733
1734 #define STRING(op) \
1735 do { \
1736 TCGv size = tcg_const_i32(a->sz); \
1737 gen_helper_##op(cpu_env, size); \
1738 tcg_temp_free(size); \
1739 } while (0)
1740
1741 /* suntile.<bwl> */
1742 static bool trans_SUNTIL(DisasContext *ctx, arg_SUNTIL *a)
1743 {
1744 STRING(suntil);
1745 return true;
1746 }
1747
1748 /* swhile.<bwl> */
1749 static bool trans_SWHILE(DisasContext *ctx, arg_SWHILE *a)
1750 {
1751 STRING(swhile);
1752 return true;
1753 }
1754 /* sstr.<bwl> */
1755 static bool trans_SSTR(DisasContext *ctx, arg_SSTR *a)
1756 {
1757 STRING(sstr);
1758 return true;
1759 }
1760
1761 /* rmpa.<bwl> */
1762 static bool trans_RMPA(DisasContext *ctx, arg_RMPA *a)
1763 {
1764 STRING(rmpa);
1765 return true;
1766 }
1767
1768 static void rx_mul64hi(TCGv_i64 ret, int rs, int rs2)
1769 {
1770 TCGv_i64 tmp0, tmp1;
1771 tmp0 = tcg_temp_new_i64();
1772 tmp1 = tcg_temp_new_i64();
1773 tcg_gen_ext_i32_i64(tmp0, cpu_regs[rs]);
1774 tcg_gen_sari_i64(tmp0, tmp0, 16);
1775 tcg_gen_ext_i32_i64(tmp1, cpu_regs[rs2]);
1776 tcg_gen_sari_i64(tmp1, tmp1, 16);
1777 tcg_gen_mul_i64(ret, tmp0, tmp1);
1778 tcg_gen_shli_i64(ret, ret, 16);
1779 tcg_temp_free_i64(tmp0);
1780 tcg_temp_free_i64(tmp1);
1781 }
1782
1783 static void rx_mul64lo(TCGv_i64 ret, int rs, int rs2)
1784 {
1785 TCGv_i64 tmp0, tmp1;
1786 tmp0 = tcg_temp_new_i64();
1787 tmp1 = tcg_temp_new_i64();
1788 tcg_gen_ext_i32_i64(tmp0, cpu_regs[rs]);
1789 tcg_gen_ext16s_i64(tmp0, tmp0);
1790 tcg_gen_ext_i32_i64(tmp1, cpu_regs[rs2]);
1791 tcg_gen_ext16s_i64(tmp1, tmp1);
1792 tcg_gen_mul_i64(ret, tmp0, tmp1);
1793 tcg_gen_shli_i64(ret, ret, 16);
1794 tcg_temp_free_i64(tmp0);
1795 tcg_temp_free_i64(tmp1);
1796 }
1797
1798 /* mulhi rs,rs2 */
1799 static bool trans_MULHI(DisasContext *ctx, arg_MULHI *a)
1800 {
1801 rx_mul64hi(cpu_acc, a->rs, a->rs2);
1802 return true;
1803 }
1804
1805 /* mullo rs,rs2 */
1806 static bool trans_MULLO(DisasContext *ctx, arg_MULLO *a)
1807 {
1808 rx_mul64lo(cpu_acc, a->rs, a->rs2);
1809 return true;
1810 }
1811
1812 /* machi rs,rs2 */
1813 static bool trans_MACHI(DisasContext *ctx, arg_MACHI *a)
1814 {
1815 TCGv_i64 tmp;
1816 tmp = tcg_temp_new_i64();
1817 rx_mul64hi(tmp, a->rs, a->rs2);
1818 tcg_gen_add_i64(cpu_acc, cpu_acc, tmp);
1819 tcg_temp_free_i64(tmp);
1820 return true;
1821 }
1822
1823 /* maclo rs,rs2 */
1824 static bool trans_MACLO(DisasContext *ctx, arg_MACLO *a)
1825 {
1826 TCGv_i64 tmp;
1827 tmp = tcg_temp_new_i64();
1828 rx_mul64lo(tmp, a->rs, a->rs2);
1829 tcg_gen_add_i64(cpu_acc, cpu_acc, tmp);
1830 tcg_temp_free_i64(tmp);
1831 return true;
1832 }
1833
1834 /* mvfachi rd */
1835 static bool trans_MVFACHI(DisasContext *ctx, arg_MVFACHI *a)
1836 {
1837 tcg_gen_extrh_i64_i32(cpu_regs[a->rd], cpu_acc);
1838 return true;
1839 }
1840
1841 /* mvfacmi rd */
1842 static bool trans_MVFACMI(DisasContext *ctx, arg_MVFACMI *a)
1843 {
1844 TCGv_i64 rd64;
1845 rd64 = tcg_temp_new_i64();
1846 tcg_gen_extract_i64(rd64, cpu_acc, 16, 32);
1847 tcg_gen_extrl_i64_i32(cpu_regs[a->rd], rd64);
1848 tcg_temp_free_i64(rd64);
1849 return true;
1850 }
1851
1852 /* mvtachi rs */
1853 static bool trans_MVTACHI(DisasContext *ctx, arg_MVTACHI *a)
1854 {
1855 TCGv_i64 rs64;
1856 rs64 = tcg_temp_new_i64();
1857 tcg_gen_extu_i32_i64(rs64, cpu_regs[a->rs]);
1858 tcg_gen_deposit_i64(cpu_acc, cpu_acc, rs64, 32, 32);
1859 tcg_temp_free_i64(rs64);
1860 return true;
1861 }
1862
1863 /* mvtaclo rs */
1864 static bool trans_MVTACLO(DisasContext *ctx, arg_MVTACLO *a)
1865 {
1866 TCGv_i64 rs64;
1867 rs64 = tcg_temp_new_i64();
1868 tcg_gen_extu_i32_i64(rs64, cpu_regs[a->rs]);
1869 tcg_gen_deposit_i64(cpu_acc, cpu_acc, rs64, 0, 32);
1870 tcg_temp_free_i64(rs64);
1871 return true;
1872 }
1873
1874 /* racw #imm */
1875 static bool trans_RACW(DisasContext *ctx, arg_RACW *a)
1876 {
1877 TCGv imm = tcg_const_i32(a->imm + 1);
1878 gen_helper_racw(cpu_env, imm);
1879 tcg_temp_free(imm);
1880 return true;
1881 }
1882
1883 /* sat rd */
1884 static bool trans_SAT(DisasContext *ctx, arg_SAT *a)
1885 {
1886 TCGv tmp, z;
1887 tmp = tcg_temp_new();
1888 z = tcg_const_i32(0);
1889 /* S == 1 -> 0xffffffff / S == 0 -> 0x00000000 */
1890 tcg_gen_sari_i32(tmp, cpu_psw_s, 31);
1891 /* S == 1 -> 0x7fffffff / S == 0 -> 0x80000000 */
1892 tcg_gen_xori_i32(tmp, tmp, 0x80000000);
1893 tcg_gen_movcond_i32(TCG_COND_LT, cpu_regs[a->rd],
1894 cpu_psw_o, z, tmp, cpu_regs[a->rd]);
1895 tcg_temp_free(tmp);
1896 tcg_temp_free(z);
1897 return true;
1898 }
1899
1900 /* satr */
1901 static bool trans_SATR(DisasContext *ctx, arg_SATR *a)
1902 {
1903 gen_helper_satr(cpu_env);
1904 return true;
1905 }
1906
1907 #define cat3(a, b, c) a##b##c
1908 #define FOP(name, op) \
1909 static bool cat3(trans_, name, _ir)(DisasContext *ctx, \
1910 cat3(arg_, name, _ir) * a) \
1911 { \
1912 TCGv imm = tcg_const_i32(li(ctx, 0)); \
1913 gen_helper_##op(cpu_regs[a->rd], cpu_env, \
1914 cpu_regs[a->rd], imm); \
1915 tcg_temp_free(imm); \
1916 return true; \
1917 } \
1918 static bool cat3(trans_, name, _mr)(DisasContext *ctx, \
1919 cat3(arg_, name, _mr) * a) \
1920 { \
1921 TCGv val, mem; \
1922 mem = tcg_temp_new(); \
1923 val = rx_load_source(ctx, mem, a->ld, MO_32, a->rs); \
1924 gen_helper_##op(cpu_regs[a->rd], cpu_env, \
1925 cpu_regs[a->rd], val); \
1926 tcg_temp_free(mem); \
1927 return true; \
1928 }
1929
1930 #define FCONVOP(name, op) \
1931 static bool trans_##name(DisasContext *ctx, arg_##name * a) \
1932 { \
1933 TCGv val, mem; \
1934 mem = tcg_temp_new(); \
1935 val = rx_load_source(ctx, mem, a->ld, MO_32, a->rs); \
1936 gen_helper_##op(cpu_regs[a->rd], cpu_env, val); \
1937 tcg_temp_free(mem); \
1938 return true; \
1939 }
1940
1941 FOP(FADD, fadd)
1942 FOP(FSUB, fsub)
1943 FOP(FMUL, fmul)
1944 FOP(FDIV, fdiv)
1945
1946 /* fcmp #imm, rd */
1947 static bool trans_FCMP_ir(DisasContext *ctx, arg_FCMP_ir * a)
1948 {
1949 TCGv imm = tcg_const_i32(li(ctx, 0));
1950 gen_helper_fcmp(cpu_env, cpu_regs[a->rd], imm);
1951 tcg_temp_free(imm);
1952 return true;
1953 }
1954
1955 /* fcmp dsp[rs], rd */
1956 /* fcmp rs, rd */
1957 static bool trans_FCMP_mr(DisasContext *ctx, arg_FCMP_mr *a)
1958 {
1959 TCGv val, mem;
1960 mem = tcg_temp_new();
1961 val = rx_load_source(ctx, mem, a->ld, MO_32, a->rs);
1962 gen_helper_fcmp(cpu_env, cpu_regs[a->rd], val);
1963 tcg_temp_free(mem);
1964 return true;
1965 }
1966
1967 FCONVOP(FTOI, ftoi)
1968 FCONVOP(ROUND, round)
1969
1970 /* itof rs, rd */
1971 /* itof dsp[rs], rd */
1972 static bool trans_ITOF(DisasContext *ctx, arg_ITOF * a)
1973 {
1974 TCGv val, mem;
1975 mem = tcg_temp_new();
1976 val = rx_load_source(ctx, mem, a->ld, a->mi, a->rs);
1977 gen_helper_itof(cpu_regs[a->rd], cpu_env, val);
1978 tcg_temp_free(mem);
1979 return true;
1980 }
1981
1982 static void rx_bsetm(TCGv mem, TCGv mask)
1983 {
1984 TCGv val;
1985 val = tcg_temp_new();
1986 rx_gen_ld(MO_8, val, mem);
1987 tcg_gen_or_i32(val, val, mask);
1988 rx_gen_st(MO_8, val, mem);
1989 tcg_temp_free(val);
1990 }
1991
1992 static void rx_bclrm(TCGv mem, TCGv mask)
1993 {
1994 TCGv val;
1995 val = tcg_temp_new();
1996 rx_gen_ld(MO_8, val, mem);
1997 tcg_gen_andc_i32(val, val, mask);
1998 rx_gen_st(MO_8, val, mem);
1999 tcg_temp_free(val);
2000 }
2001
2002 static void rx_btstm(TCGv mem, TCGv mask)
2003 {
2004 TCGv val;
2005 val = tcg_temp_new();
2006 rx_gen_ld(MO_8, val, mem);
2007 tcg_gen_and_i32(val, val, mask);
2008 tcg_gen_setcondi_i32(TCG_COND_NE, cpu_psw_c, val, 0);
2009 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_c);
2010 tcg_temp_free(val);
2011 }
2012
2013 static void rx_bnotm(TCGv mem, TCGv mask)
2014 {
2015 TCGv val;
2016 val = tcg_temp_new();
2017 rx_gen_ld(MO_8, val, mem);
2018 tcg_gen_xor_i32(val, val, mask);
2019 rx_gen_st(MO_8, val, mem);
2020 tcg_temp_free(val);
2021 }
2022
2023 static void rx_bsetr(TCGv reg, TCGv mask)
2024 {
2025 tcg_gen_or_i32(reg, reg, mask);
2026 }
2027
2028 static void rx_bclrr(TCGv reg, TCGv mask)
2029 {
2030 tcg_gen_andc_i32(reg, reg, mask);
2031 }
2032
2033 static inline void rx_btstr(TCGv reg, TCGv mask)
2034 {
2035 TCGv t0;
2036 t0 = tcg_temp_new();
2037 tcg_gen_and_i32(t0, reg, mask);
2038 tcg_gen_setcondi_i32(TCG_COND_NE, cpu_psw_c, t0, 0);
2039 tcg_gen_mov_i32(cpu_psw_z, cpu_psw_c);
2040 tcg_temp_free(t0);
2041 }
2042
2043 static inline void rx_bnotr(TCGv reg, TCGv mask)
2044 {
2045 tcg_gen_xor_i32(reg, reg, mask);
2046 }
2047
2048 #define BITOP(name, op) \
2049 static bool cat3(trans_, name, _im)(DisasContext *ctx, \
2050 cat3(arg_, name, _im) * a) \
2051 { \
2052 TCGv mask, mem, addr; \
2053 mem = tcg_temp_new(); \
2054 mask = tcg_const_i32(1 << a->imm); \
2055 addr = rx_index_addr(ctx, mem, a->ld, MO_8, a->rs); \
2056 cat3(rx_, op, m)(addr, mask); \
2057 tcg_temp_free(mask); \
2058 tcg_temp_free(mem); \
2059 return true; \
2060 } \
2061 static bool cat3(trans_, name, _ir)(DisasContext *ctx, \
2062 cat3(arg_, name, _ir) * a) \
2063 { \
2064 TCGv mask; \
2065 mask = tcg_const_i32(1 << a->imm); \
2066 cat3(rx_, op, r)(cpu_regs[a->rd], mask); \
2067 tcg_temp_free(mask); \
2068 return true; \
2069 } \
2070 static bool cat3(trans_, name, _rr)(DisasContext *ctx, \
2071 cat3(arg_, name, _rr) * a) \
2072 { \
2073 TCGv mask, b; \
2074 mask = tcg_const_i32(1); \
2075 b = tcg_temp_new(); \
2076 tcg_gen_andi_i32(b, cpu_regs[a->rs], 31); \
2077 tcg_gen_shl_i32(mask, mask, b); \
2078 cat3(rx_, op, r)(cpu_regs[a->rd], mask); \
2079 tcg_temp_free(mask); \
2080 tcg_temp_free(b); \
2081 return true; \
2082 } \
2083 static bool cat3(trans_, name, _rm)(DisasContext *ctx, \
2084 cat3(arg_, name, _rm) * a) \
2085 { \
2086 TCGv mask, mem, addr, b; \
2087 mask = tcg_const_i32(1); \
2088 b = tcg_temp_new(); \
2089 tcg_gen_andi_i32(b, cpu_regs[a->rd], 7); \
2090 tcg_gen_shl_i32(mask, mask, b); \
2091 mem = tcg_temp_new(); \
2092 addr = rx_index_addr(ctx, mem, a->ld, MO_8, a->rs); \
2093 cat3(rx_, op, m)(addr, mask); \
2094 tcg_temp_free(mem); \
2095 tcg_temp_free(mask); \
2096 tcg_temp_free(b); \
2097 return true; \
2098 }
2099
2100 BITOP(BSET, bset)
2101 BITOP(BCLR, bclr)
2102 BITOP(BTST, btst)
2103 BITOP(BNOT, bnot)
2104
2105 static inline void bmcnd_op(TCGv val, TCGCond cond, int pos)
2106 {
2107 TCGv bit;
2108 DisasCompare dc;
2109 dc.temp = tcg_temp_new();
2110 bit = tcg_temp_new();
2111 psw_cond(&dc, cond);
2112 tcg_gen_andi_i32(val, val, ~(1 << pos));
2113 tcg_gen_setcondi_i32(dc.cond, bit, dc.value, 0);
2114 tcg_gen_deposit_i32(val, val, bit, pos, 1);
2115 tcg_temp_free(bit);
2116 tcg_temp_free(dc.temp);
2117 }
2118
2119 /* bmcnd #imm, dsp[rd] */
2120 static bool trans_BMCnd_im(DisasContext *ctx, arg_BMCnd_im *a)
2121 {
2122 TCGv val, mem, addr;
2123 val = tcg_temp_new();
2124 mem = tcg_temp_new();
2125 addr = rx_index_addr(ctx, mem, a->ld, MO_8, a->rd);
2126 rx_gen_ld(MO_8, val, addr);
2127 bmcnd_op(val, a->cd, a->imm);
2128 rx_gen_st(MO_8, val, addr);
2129 tcg_temp_free(val);
2130 tcg_temp_free(mem);
2131 return true;
2132 }
2133
2134 /* bmcond #imm, rd */
2135 static bool trans_BMCnd_ir(DisasContext *ctx, arg_BMCnd_ir *a)
2136 {
2137 bmcnd_op(cpu_regs[a->rd], a->cd, a->imm);
2138 return true;
2139 }
2140
2141 enum {
2142 PSW_C = 0,
2143 PSW_Z = 1,
2144 PSW_S = 2,
2145 PSW_O = 3,
2146 PSW_I = 8,
2147 PSW_U = 9,
2148 };
2149
2150 static inline void clrsetpsw(DisasContext *ctx, int cb, int val)
2151 {
2152 if (cb < 8) {
2153 switch (cb) {
2154 case PSW_C:
2155 tcg_gen_movi_i32(cpu_psw_c, val);
2156 break;
2157 case PSW_Z:
2158 tcg_gen_movi_i32(cpu_psw_z, val == 0);
2159 break;
2160 case PSW_S:
2161 tcg_gen_movi_i32(cpu_psw_s, val ? -1 : 0);
2162 break;
2163 case PSW_O:
2164 tcg_gen_movi_i32(cpu_psw_o, val << 31);
2165 break;
2166 default:
2167 qemu_log_mask(LOG_GUEST_ERROR, "Invalid distination %d", cb);
2168 break;
2169 }
2170 } else if (is_privileged(ctx, 0)) {
2171 switch (cb) {
2172 case PSW_I:
2173 tcg_gen_movi_i32(cpu_psw_i, val);
2174 ctx->base.is_jmp = DISAS_UPDATE;
2175 break;
2176 case PSW_U:
2177 tcg_gen_movi_i32(cpu_psw_u, val);
2178 break;
2179 default:
2180 qemu_log_mask(LOG_GUEST_ERROR, "Invalid distination %d", cb);
2181 break;
2182 }
2183 }
2184 }
2185
2186 /* clrpsw psw */
2187 static bool trans_CLRPSW(DisasContext *ctx, arg_CLRPSW *a)
2188 {
2189 clrsetpsw(ctx, a->cb, 0);
2190 return true;
2191 }
2192
2193 /* setpsw psw */
2194 static bool trans_SETPSW(DisasContext *ctx, arg_SETPSW *a)
2195 {
2196 clrsetpsw(ctx, a->cb, 1);
2197 return true;
2198 }
2199
2200 /* mvtipl #imm */
2201 static bool trans_MVTIPL(DisasContext *ctx, arg_MVTIPL *a)
2202 {
2203 if (is_privileged(ctx, 1)) {
2204 tcg_gen_movi_i32(cpu_psw_ipl, a->imm);
2205 ctx->base.is_jmp = DISAS_UPDATE;
2206 }
2207 return true;
2208 }
2209
2210 /* mvtc #imm, rd */
2211 static bool trans_MVTC_i(DisasContext *ctx, arg_MVTC_i *a)
2212 {
2213 TCGv imm;
2214
2215 imm = tcg_const_i32(a->imm);
2216 move_to_cr(ctx, imm, a->cr);
2217 if (a->cr == 0 && is_privileged(ctx, 0)) {
2218 ctx->base.is_jmp = DISAS_UPDATE;
2219 }
2220 tcg_temp_free(imm);
2221 return true;
2222 }
2223
2224 /* mvtc rs, rd */
2225 static bool trans_MVTC_r(DisasContext *ctx, arg_MVTC_r *a)
2226 {
2227 move_to_cr(ctx, cpu_regs[a->rs], a->cr);
2228 if (a->cr == 0 && is_privileged(ctx, 0)) {
2229 ctx->base.is_jmp = DISAS_UPDATE;
2230 }
2231 return true;
2232 }
2233
2234 /* mvfc rs, rd */
2235 static bool trans_MVFC(DisasContext *ctx, arg_MVFC *a)
2236 {
2237 move_from_cr(cpu_regs[a->rd], a->cr, ctx->pc);
2238 return true;
2239 }
2240
2241 /* rtfi */
2242 static bool trans_RTFI(DisasContext *ctx, arg_RTFI *a)
2243 {
2244 TCGv psw;
2245 if (is_privileged(ctx, 1)) {
2246 psw = tcg_temp_new();
2247 tcg_gen_mov_i32(cpu_pc, cpu_bpc);
2248 tcg_gen_mov_i32(psw, cpu_bpsw);
2249 gen_helper_set_psw_rte(cpu_env, psw);
2250 ctx->base.is_jmp = DISAS_EXIT;
2251 tcg_temp_free(psw);
2252 }
2253 return true;
2254 }
2255
2256 /* rte */
2257 static bool trans_RTE(DisasContext *ctx, arg_RTE *a)
2258 {
2259 TCGv psw;
2260 if (is_privileged(ctx, 1)) {
2261 psw = tcg_temp_new();
2262 pop(cpu_pc);
2263 pop(psw);
2264 gen_helper_set_psw_rte(cpu_env, psw);
2265 ctx->base.is_jmp = DISAS_EXIT;
2266 tcg_temp_free(psw);
2267 }
2268 return true;
2269 }
2270
2271 /* brk */
2272 static bool trans_BRK(DisasContext *ctx, arg_BRK *a)
2273 {
2274 tcg_gen_movi_i32(cpu_pc, ctx->base.pc_next);
2275 gen_helper_rxbrk(cpu_env);
2276 ctx->base.is_jmp = DISAS_NORETURN;
2277 return true;
2278 }
2279
2280 /* int #imm */
2281 static bool trans_INT(DisasContext *ctx, arg_INT *a)
2282 {
2283 TCGv vec;
2284
2285 tcg_debug_assert(a->imm < 0x100);
2286 vec = tcg_const_i32(a->imm);
2287 tcg_gen_movi_i32(cpu_pc, ctx->base.pc_next);
2288 gen_helper_rxint(cpu_env, vec);
2289 tcg_temp_free(vec);
2290 ctx->base.is_jmp = DISAS_NORETURN;
2291 return true;
2292 }
2293
2294 /* wait */
2295 static bool trans_WAIT(DisasContext *ctx, arg_WAIT *a)
2296 {
2297 if (is_privileged(ctx, 1)) {
2298 tcg_gen_addi_i32(cpu_pc, cpu_pc, 2);
2299 gen_helper_wait(cpu_env);
2300 }
2301 return true;
2302 }
2303
2304 static void rx_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
2305 {
2306 CPURXState *env = cs->env_ptr;
2307 DisasContext *ctx = container_of(dcbase, DisasContext, base);
2308 ctx->env = env;
2309 }
2310
2311 static void rx_tr_tb_start(DisasContextBase *dcbase, CPUState *cs)
2312 {
2313 }
2314
2315 static void rx_tr_insn_start(DisasContextBase *dcbase, CPUState *cs)
2316 {
2317 DisasContext *ctx = container_of(dcbase, DisasContext, base);
2318
2319 tcg_gen_insn_start(ctx->base.pc_next);
2320 }
2321
2322 static bool rx_tr_breakpoint_check(DisasContextBase *dcbase, CPUState *cs,
2323 const CPUBreakpoint *bp)
2324 {
2325 DisasContext *ctx = container_of(dcbase, DisasContext, base);
2326
2327 /* We have hit a breakpoint - make sure PC is up-to-date */
2328 tcg_gen_movi_i32(cpu_pc, ctx->base.pc_next);
2329 gen_helper_debug(cpu_env);
2330 ctx->base.is_jmp = DISAS_NORETURN;
2331 ctx->base.pc_next += 1;
2332 return true;
2333 }
2334
2335 static void rx_tr_translate_insn(DisasContextBase *dcbase, CPUState *cs)
2336 {
2337 DisasContext *ctx = container_of(dcbase, DisasContext, base);
2338 uint32_t insn;
2339
2340 ctx->pc = ctx->base.pc_next;
2341 insn = decode_load(ctx);
2342 if (!decode(ctx, insn)) {
2343 gen_helper_raise_illegal_instruction(cpu_env);
2344 }
2345 }
2346
2347 static void rx_tr_tb_stop(DisasContextBase *dcbase, CPUState *cs)
2348 {
2349 DisasContext *ctx = container_of(dcbase, DisasContext, base);
2350
2351 switch (ctx->base.is_jmp) {
2352 case DISAS_NEXT:
2353 case DISAS_TOO_MANY:
2354 gen_goto_tb(ctx, 0, dcbase->pc_next);
2355 break;
2356 case DISAS_JUMP:
2357 if (ctx->base.singlestep_enabled) {
2358 gen_helper_debug(cpu_env);
2359 } else {
2360 tcg_gen_lookup_and_goto_ptr();
2361 }
2362 break;
2363 case DISAS_UPDATE:
2364 tcg_gen_movi_i32(cpu_pc, ctx->base.pc_next);
2365 /* fall through */
2366 case DISAS_EXIT:
2367 tcg_gen_exit_tb(NULL, 0);
2368 break;
2369 case DISAS_NORETURN:
2370 break;
2371 default:
2372 g_assert_not_reached();
2373 }
2374 }
2375
2376 static void rx_tr_disas_log(const DisasContextBase *dcbase, CPUState *cs)
2377 {
2378 qemu_log("IN:\n"); /* , lookup_symbol(dcbase->pc_first)); */
2379 log_target_disas(cs, dcbase->pc_first, dcbase->tb->size);
2380 }
2381
2382 static const TranslatorOps rx_tr_ops = {
2383 .init_disas_context = rx_tr_init_disas_context,
2384 .tb_start = rx_tr_tb_start,
2385 .insn_start = rx_tr_insn_start,
2386 .breakpoint_check = rx_tr_breakpoint_check,
2387 .translate_insn = rx_tr_translate_insn,
2388 .tb_stop = rx_tr_tb_stop,
2389 .disas_log = rx_tr_disas_log,
2390 };
2391
2392 void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int max_insns)
2393 {
2394 DisasContext dc;
2395
2396 translator_loop(&rx_tr_ops, &dc.base, cs, tb, max_insns);
2397 }
2398
2399 void restore_state_to_opc(CPURXState *env, TranslationBlock *tb,
2400 target_ulong *data)
2401 {
2402 env->pc = data[0];
2403 }
2404
2405 #define ALLOC_REGISTER(sym, name) \
2406 cpu_##sym = tcg_global_mem_new_i32(cpu_env, \
2407 offsetof(CPURXState, sym), name)
2408
2409 void rx_translate_init(void)
2410 {
2411 static const char * const regnames[NUM_REGS] = {
2412 "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
2413 "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"
2414 };
2415 int i;
2416
2417 for (i = 0; i < NUM_REGS; i++) {
2418 cpu_regs[i] = tcg_global_mem_new_i32(cpu_env,
2419 offsetof(CPURXState, regs[i]),
2420 regnames[i]);
2421 }
2422 ALLOC_REGISTER(pc, "PC");
2423 ALLOC_REGISTER(psw_o, "PSW(O)");
2424 ALLOC_REGISTER(psw_s, "PSW(S)");
2425 ALLOC_REGISTER(psw_z, "PSW(Z)");
2426 ALLOC_REGISTER(psw_c, "PSW(C)");
2427 ALLOC_REGISTER(psw_u, "PSW(U)");
2428 ALLOC_REGISTER(psw_i, "PSW(I)");
2429 ALLOC_REGISTER(psw_pm, "PSW(PM)");
2430 ALLOC_REGISTER(psw_ipl, "PSW(IPL)");
2431 ALLOC_REGISTER(usp, "USP");
2432 ALLOC_REGISTER(fpsw, "FPSW");
2433 ALLOC_REGISTER(bpsw, "BPSW");
2434 ALLOC_REGISTER(bpc, "BPC");
2435 ALLOC_REGISTER(isp, "ISP");
2436 ALLOC_REGISTER(fintv, "FINTV");
2437 ALLOC_REGISTER(intb, "INTB");
2438 cpu_acc = tcg_global_mem_new_i64(cpu_env,
2439 offsetof(CPURXState, acc), "ACC");
2440 }