?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: make tap offloading callbacks static
[qemu/ar7.git] / target-sh4 / translate.c
blob661fc6c887c7f86e41fea3efcb1fad7a46d097f2
1 /*
2 * SH4 translation
3 *
4 * Copyright (c) 2005 Samuel Tardieu
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #define DEBUG_DISAS
21 //#define SH4_SINGLE_STEP
22
23 #include "cpu.h"
24 #include "disas/disas.h"
25 #include "tcg-op.h"
26
27 #include "helper.h"
28 #define GEN_HELPER 1
29 #include "helper.h"
30
31 typedef struct DisasContext {
32 struct TranslationBlock *tb;
33 target_ulong pc;
34 uint16_t opcode;
35 uint32_t flags;
36 int bstate;
37 int memidx;
38 uint32_t delayed_pc;
39 int singlestep_enabled;
40 uint32_t features;
41 int has_movcal;
42 } DisasContext;
43
44 #if defined(CONFIG_USER_ONLY)
45 #define IS_USER(ctx) 1
46 #else
47 #define IS_USER(ctx) (!(ctx->flags & SR_MD))
48 #endif
49
50 enum {
51 BS_NONE = 0, /* We go out of the TB without reaching a branch or an
52 * exception condition
53 */
54 BS_STOP = 1, /* We want to stop translation for any reason */
55 BS_BRANCH = 2, /* We reached a branch condition */
56 BS_EXCP = 3, /* We reached an exception condition */
57 };
58
59 /* global register indexes */
60 static TCGv_ptr cpu_env;
61 static TCGv cpu_gregs[24];
62 static TCGv cpu_pc, cpu_sr, cpu_ssr, cpu_spc, cpu_gbr;
63 static TCGv cpu_vbr, cpu_sgr, cpu_dbr, cpu_mach, cpu_macl;
64 static TCGv cpu_pr, cpu_fpscr, cpu_fpul, cpu_ldst;
65 static TCGv cpu_fregs[32];
66
67 /* internal register indexes */
68 static TCGv cpu_flags, cpu_delayed_pc;
69
70 static uint32_t gen_opc_hflags[OPC_BUF_SIZE];
71
72 #include "exec/gen-icount.h"
73
74 void sh4_translate_init(void)
75 {
76 int i;
77 static int done_init = 0;
78 static const char * const gregnames[24] = {
79 "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
80 "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
81 "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
82 "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
83 "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
84 };
85 static const char * const fregnames[32] = {
86 "FPR0_BANK0", "FPR1_BANK0", "FPR2_BANK0", "FPR3_BANK0",
87 "FPR4_BANK0", "FPR5_BANK0", "FPR6_BANK0", "FPR7_BANK0",
88 "FPR8_BANK0", "FPR9_BANK0", "FPR10_BANK0", "FPR11_BANK0",
89 "FPR12_BANK0", "FPR13_BANK0", "FPR14_BANK0", "FPR15_BANK0",
90 "FPR0_BANK1", "FPR1_BANK1", "FPR2_BANK1", "FPR3_BANK1",
91 "FPR4_BANK1", "FPR5_BANK1", "FPR6_BANK1", "FPR7_BANK1",
92 "FPR8_BANK1", "FPR9_BANK1", "FPR10_BANK1", "FPR11_BANK1",
93 "FPR12_BANK1", "FPR13_BANK1", "FPR14_BANK1", "FPR15_BANK1",
94 };
95
96 if (done_init)
97 return;
98
99 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
100
101 for (i = 0; i < 24; i++)
102 cpu_gregs[i] = tcg_global_mem_new_i32(TCG_AREG0,
103 offsetof(CPUSH4State, gregs[i]),
104 gregnames[i]);
105
106 cpu_pc = tcg_global_mem_new_i32(TCG_AREG0,
107 offsetof(CPUSH4State, pc), "PC");
108 cpu_sr = tcg_global_mem_new_i32(TCG_AREG0,
109 offsetof(CPUSH4State, sr), "SR");
110 cpu_ssr = tcg_global_mem_new_i32(TCG_AREG0,
111 offsetof(CPUSH4State, ssr), "SSR");
112 cpu_spc = tcg_global_mem_new_i32(TCG_AREG0,
113 offsetof(CPUSH4State, spc), "SPC");
114 cpu_gbr = tcg_global_mem_new_i32(TCG_AREG0,
115 offsetof(CPUSH4State, gbr), "GBR");
116 cpu_vbr = tcg_global_mem_new_i32(TCG_AREG0,
117 offsetof(CPUSH4State, vbr), "VBR");
118 cpu_sgr = tcg_global_mem_new_i32(TCG_AREG0,
119 offsetof(CPUSH4State, sgr), "SGR");
120 cpu_dbr = tcg_global_mem_new_i32(TCG_AREG0,
121 offsetof(CPUSH4State, dbr), "DBR");
122 cpu_mach = tcg_global_mem_new_i32(TCG_AREG0,
123 offsetof(CPUSH4State, mach), "MACH");
124 cpu_macl = tcg_global_mem_new_i32(TCG_AREG0,
125 offsetof(CPUSH4State, macl), "MACL");
126 cpu_pr = tcg_global_mem_new_i32(TCG_AREG0,
127 offsetof(CPUSH4State, pr), "PR");
128 cpu_fpscr = tcg_global_mem_new_i32(TCG_AREG0,
129 offsetof(CPUSH4State, fpscr), "FPSCR");
130 cpu_fpul = tcg_global_mem_new_i32(TCG_AREG0,
131 offsetof(CPUSH4State, fpul), "FPUL");
132
133 cpu_flags = tcg_global_mem_new_i32(TCG_AREG0,
134 offsetof(CPUSH4State, flags), "_flags_");
135 cpu_delayed_pc = tcg_global_mem_new_i32(TCG_AREG0,
136 offsetof(CPUSH4State, delayed_pc),
137 "_delayed_pc_");
138 cpu_ldst = tcg_global_mem_new_i32(TCG_AREG0,
139 offsetof(CPUSH4State, ldst), "_ldst_");
140
141 for (i = 0; i < 32; i++)
142 cpu_fregs[i] = tcg_global_mem_new_i32(TCG_AREG0,
143 offsetof(CPUSH4State, fregs[i]),
144 fregnames[i]);
145
146 done_init = 1;
147 }
148
149 void superh_cpu_dump_state(CPUState *cs, FILE *f,
150 fprintf_function cpu_fprintf, int flags)
151 {
152 SuperHCPU *cpu = SUPERH_CPU(cs);
153 CPUSH4State *env = &cpu->env;
154 int i;
155 cpu_fprintf(f, "pc=0x%08x sr=0x%08x pr=0x%08x fpscr=0x%08x\n",
156 env->pc, env->sr, env->pr, env->fpscr);
157 cpu_fprintf(f, "spc=0x%08x ssr=0x%08x gbr=0x%08x vbr=0x%08x\n",
158 env->spc, env->ssr, env->gbr, env->vbr);
159 cpu_fprintf(f, "sgr=0x%08x dbr=0x%08x delayed_pc=0x%08x fpul=0x%08x\n",
160 env->sgr, env->dbr, env->delayed_pc, env->fpul);
161 for (i = 0; i < 24; i += 4) {
162 cpu_fprintf(f, "r%d=0x%08x r%d=0x%08x r%d=0x%08x r%d=0x%08x\n",
163 i, env->gregs[i], i + 1, env->gregs[i + 1],
164 i + 2, env->gregs[i + 2], i + 3, env->gregs[i + 3]);
165 }
166 if (env->flags & DELAY_SLOT) {
167 cpu_fprintf(f, "in delay slot (delayed_pc=0x%08x)\n",
168 env->delayed_pc);
169 } else if (env->flags & DELAY_SLOT_CONDITIONAL) {
170 cpu_fprintf(f, "in conditional delay slot (delayed_pc=0x%08x)\n",
171 env->delayed_pc);
172 }
173 }
174
175 static void gen_goto_tb(DisasContext * ctx, int n, target_ulong dest)
176 {
177 TranslationBlock *tb;
178 tb = ctx->tb;
179
180 if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) &&
181 !ctx->singlestep_enabled) {
182 /* Use a direct jump if in same page and singlestep not enabled */
183 tcg_gen_goto_tb(n);
184 tcg_gen_movi_i32(cpu_pc, dest);
185 tcg_gen_exit_tb((uintptr_t)tb + n);
186 } else {
187 tcg_gen_movi_i32(cpu_pc, dest);
188 if (ctx->singlestep_enabled)
189 gen_helper_debug(cpu_env);
190 tcg_gen_exit_tb(0);
191 }
192 }
193
194 static void gen_jump(DisasContext * ctx)
195 {
196 if (ctx->delayed_pc == (uint32_t) - 1) {
197 /* Target is not statically known, it comes necessarily from a
198 delayed jump as immediate jump are conditinal jumps */
199 tcg_gen_mov_i32(cpu_pc, cpu_delayed_pc);
200 if (ctx->singlestep_enabled)
201 gen_helper_debug(cpu_env);
202 tcg_gen_exit_tb(0);
203 } else {
204 gen_goto_tb(ctx, 0, ctx->delayed_pc);
205 }
206 }
207
208 static inline void gen_branch_slot(uint32_t delayed_pc, int t)
209 {
210 TCGv sr;
211 int label = gen_new_label();
212 tcg_gen_movi_i32(cpu_delayed_pc, delayed_pc);
213 sr = tcg_temp_new();
214 tcg_gen_andi_i32(sr, cpu_sr, SR_T);
215 tcg_gen_brcondi_i32(t ? TCG_COND_EQ:TCG_COND_NE, sr, 0, label);
216 tcg_gen_ori_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE);
217 gen_set_label(label);
218 }
219
220 /* Immediate conditional jump (bt or bf) */
221 static void gen_conditional_jump(DisasContext * ctx,
222 target_ulong ift, target_ulong ifnott)
223 {
224 int l1;
225 TCGv sr;
226
227 l1 = gen_new_label();
228 sr = tcg_temp_new();
229 tcg_gen_andi_i32(sr, cpu_sr, SR_T);
230 tcg_gen_brcondi_i32(TCG_COND_NE, sr, 0, l1);
231 gen_goto_tb(ctx, 0, ifnott);
232 gen_set_label(l1);
233 gen_goto_tb(ctx, 1, ift);
234 }
235
236 /* Delayed conditional jump (bt or bf) */
237 static void gen_delayed_conditional_jump(DisasContext * ctx)
238 {
239 int l1;
240 TCGv ds;
241
242 l1 = gen_new_label();
243 ds = tcg_temp_new();
244 tcg_gen_andi_i32(ds, cpu_flags, DELAY_SLOT_TRUE);
245 tcg_gen_brcondi_i32(TCG_COND_NE, ds, 0, l1);
246 gen_goto_tb(ctx, 1, ctx->pc + 2);
247 gen_set_label(l1);
248 tcg_gen_andi_i32(cpu_flags, cpu_flags, ~DELAY_SLOT_TRUE);
249 gen_jump(ctx);
250 }
251
252 static inline void gen_cmp(int cond, TCGv t0, TCGv t1)
253 {
254 TCGv t;
255
256 t = tcg_temp_new();
257 tcg_gen_setcond_i32(cond, t, t1, t0);
258 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
259 tcg_gen_or_i32(cpu_sr, cpu_sr, t);
260
261 tcg_temp_free(t);
262 }
263
264 static inline void gen_cmp_imm(int cond, TCGv t0, int32_t imm)
265 {
266 TCGv t;
267
268 t = tcg_temp_new();
269 tcg_gen_setcondi_i32(cond, t, t0, imm);
270 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
271 tcg_gen_or_i32(cpu_sr, cpu_sr, t);
272
273 tcg_temp_free(t);
274 }
275
276 static inline void gen_store_flags(uint32_t flags)
277 {
278 tcg_gen_andi_i32(cpu_flags, cpu_flags, DELAY_SLOT_TRUE);
279 tcg_gen_ori_i32(cpu_flags, cpu_flags, flags);
280 }
281
282 static inline void gen_copy_bit_i32(TCGv t0, int p0, TCGv t1, int p1)
283 {
284 TCGv tmp = tcg_temp_new();
285
286 p0 &= 0x1f;
287 p1 &= 0x1f;
288
289 tcg_gen_andi_i32(tmp, t1, (1 << p1));
290 tcg_gen_andi_i32(t0, t0, ~(1 << p0));
291 if (p0 < p1)
292 tcg_gen_shri_i32(tmp, tmp, p1 - p0);
293 else if (p0 > p1)
294 tcg_gen_shli_i32(tmp, tmp, p0 - p1);
295 tcg_gen_or_i32(t0, t0, tmp);
296
297 tcg_temp_free(tmp);
298 }
299
300 static inline void gen_load_fpr64(TCGv_i64 t, int reg)
301 {
302 tcg_gen_concat_i32_i64(t, cpu_fregs[reg + 1], cpu_fregs[reg]);
303 }
304
305 static inline void gen_store_fpr64 (TCGv_i64 t, int reg)
306 {
307 TCGv_i32 tmp = tcg_temp_new_i32();
308 tcg_gen_trunc_i64_i32(tmp, t);
309 tcg_gen_mov_i32(cpu_fregs[reg + 1], tmp);
310 tcg_gen_shri_i64(t, t, 32);
311 tcg_gen_trunc_i64_i32(tmp, t);
312 tcg_gen_mov_i32(cpu_fregs[reg], tmp);
313 tcg_temp_free_i32(tmp);
314 }
315
316 #define B3_0 (ctx->opcode & 0xf)
317 #define B6_4 ((ctx->opcode >> 4) & 0x7)
318 #define B7_4 ((ctx->opcode >> 4) & 0xf)
319 #define B7_0 (ctx->opcode & 0xff)
320 #define B7_0s ((int32_t) (int8_t) (ctx->opcode & 0xff))
321 #define B11_0s (ctx->opcode & 0x800 ? 0xfffff000 | (ctx->opcode & 0xfff) : \
322 (ctx->opcode & 0xfff))
323 #define B11_8 ((ctx->opcode >> 8) & 0xf)
324 #define B15_12 ((ctx->opcode >> 12) & 0xf)
325
326 #define REG(x) ((x) < 8 && (ctx->flags & (SR_MD | SR_RB)) == (SR_MD | SR_RB) \
327 ? (cpu_gregs[x + 16]) : (cpu_gregs[x]))
328
329 #define ALTREG(x) ((x) < 8 && (ctx->flags & (SR_MD | SR_RB)) != (SR_MD | SR_RB)\
330 ? (cpu_gregs[x + 16]) : (cpu_gregs[x]))
331
332 #define FREG(x) (ctx->flags & FPSCR_FR ? (x) ^ 0x10 : (x))
333 #define XHACK(x) ((((x) & 1 ) << 4) | ((x) & 0xe))
334 #define XREG(x) (ctx->flags & FPSCR_FR ? XHACK(x) ^ 0x10 : XHACK(x))
335 #define DREG(x) FREG(x) /* Assumes lsb of (x) is always 0 */
336
337 #define CHECK_NOT_DELAY_SLOT \
338 if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) \
339 { \
340 tcg_gen_movi_i32(cpu_pc, ctx->pc); \
341 gen_helper_raise_slot_illegal_instruction(cpu_env); \
342 ctx->bstate = BS_BRANCH; \
343 return; \
344 }
345
346 #define CHECK_PRIVILEGED \
347 if (IS_USER(ctx)) { \
348 tcg_gen_movi_i32(cpu_pc, ctx->pc); \
349 if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) { \
350 gen_helper_raise_slot_illegal_instruction(cpu_env); \
351 } else { \
352 gen_helper_raise_illegal_instruction(cpu_env); \
353 } \
354 ctx->bstate = BS_BRANCH; \
355 return; \
356 }
357
358 #define CHECK_FPU_ENABLED \
359 if (ctx->flags & SR_FD) { \
360 tcg_gen_movi_i32(cpu_pc, ctx->pc); \
361 if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) { \
362 gen_helper_raise_slot_fpu_disable(cpu_env); \
363 } else { \
364 gen_helper_raise_fpu_disable(cpu_env); \
365 } \
366 ctx->bstate = BS_BRANCH; \
367 return; \
368 }
369
370 static void _decode_opc(DisasContext * ctx)
371 {
372 /* This code tries to make movcal emulation sufficiently
373 accurate for Linux purposes. This instruction writes
374 memory, and prior to that, always allocates a cache line.
375 It is used in two contexts:
376 - in memcpy, where data is copied in blocks, the first write
377 of to a block uses movca.l for performance.
378 - in arch/sh/mm/cache-sh4.c, movcal.l + ocbi combination is used
379 to flush the cache. Here, the data written by movcal.l is never
380 written to memory, and the data written is just bogus.
381
382 To simulate this, we simulate movcal.l, we store the value to memory,
383 but we also remember the previous content. If we see ocbi, we check
384 if movcal.l for that address was done previously. If so, the write should
385 not have hit the memory, so we restore the previous content.
386 When we see an instruction that is neither movca.l
387 nor ocbi, the previous content is discarded.
388
389 To optimize, we only try to flush stores when we're at the start of
390 TB, or if we already saw movca.l in this TB and did not flush stores
391 yet. */
392 if (ctx->has_movcal)
393 {
394 int opcode = ctx->opcode & 0xf0ff;
395 if (opcode != 0x0093 /* ocbi */
396 && opcode != 0x00c3 /* movca.l */)
397 {
398 gen_helper_discard_movcal_backup(cpu_env);
399 ctx->has_movcal = 0;
400 }
401 }
402
403 #if 0
404 fprintf(stderr, "Translating opcode 0x%04x\n", ctx->opcode);
405 #endif
406
407 switch (ctx->opcode) {
408 case 0x0019: /* div0u */
409 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~(SR_M | SR_Q | SR_T));
410 return;
411 case 0x000b: /* rts */
412 CHECK_NOT_DELAY_SLOT
413 tcg_gen_mov_i32(cpu_delayed_pc, cpu_pr);
414 ctx->flags |= DELAY_SLOT;
415 ctx->delayed_pc = (uint32_t) - 1;
416 return;
417 case 0x0028: /* clrmac */
418 tcg_gen_movi_i32(cpu_mach, 0);
419 tcg_gen_movi_i32(cpu_macl, 0);
420 return;
421 case 0x0048: /* clrs */
422 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_S);
423 return;
424 case 0x0008: /* clrt */
425 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
426 return;
427 case 0x0038: /* ldtlb */
428 CHECK_PRIVILEGED
429 gen_helper_ldtlb(cpu_env);
430 return;
431 case 0x002b: /* rte */
432 CHECK_PRIVILEGED
433 CHECK_NOT_DELAY_SLOT
434 tcg_gen_mov_i32(cpu_sr, cpu_ssr);
435 tcg_gen_mov_i32(cpu_delayed_pc, cpu_spc);
436 ctx->flags |= DELAY_SLOT;
437 ctx->delayed_pc = (uint32_t) - 1;
438 return;
439 case 0x0058: /* sets */
440 tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_S);
441 return;
442 case 0x0018: /* sett */
443 tcg_gen_ori_i32(cpu_sr, cpu_sr, SR_T);
444 return;
445 case 0xfbfd: /* frchg */
446 tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_FR);
447 ctx->bstate = BS_STOP;
448 return;
449 case 0xf3fd: /* fschg */
450 tcg_gen_xori_i32(cpu_fpscr, cpu_fpscr, FPSCR_SZ);
451 ctx->bstate = BS_STOP;
452 return;
453 case 0x0009: /* nop */
454 return;
455 case 0x001b: /* sleep */
456 CHECK_PRIVILEGED
457 tcg_gen_movi_i32(cpu_pc, ctx->pc + 2);
458 gen_helper_sleep(cpu_env);
459 return;
460 }
461
462 switch (ctx->opcode & 0xf000) {
463 case 0x1000: /* mov.l Rm,@(disp,Rn) */
464 {
465 TCGv addr = tcg_temp_new();
466 tcg_gen_addi_i32(addr, REG(B11_8), B3_0 * 4);
467 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUL);
468 tcg_temp_free(addr);
469 }
470 return;
471 case 0x5000: /* mov.l @(disp,Rm),Rn */
472 {
473 TCGv addr = tcg_temp_new();
474 tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 4);
475 tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESL);
476 tcg_temp_free(addr);
477 }
478 return;
479 case 0xe000: /* mov #imm,Rn */
480 tcg_gen_movi_i32(REG(B11_8), B7_0s);
481 return;
482 case 0x9000: /* mov.w @(disp,PC),Rn */
483 {
484 TCGv addr = tcg_const_i32(ctx->pc + 4 + B7_0 * 2);
485 tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESW);
486 tcg_temp_free(addr);
487 }
488 return;
489 case 0xd000: /* mov.l @(disp,PC),Rn */
490 {
491 TCGv addr = tcg_const_i32((ctx->pc + 4 + B7_0 * 4) & ~3);
492 tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESL);
493 tcg_temp_free(addr);
494 }
495 return;
496 case 0x7000: /* add #imm,Rn */
497 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), B7_0s);
498 return;
499 case 0xa000: /* bra disp */
500 CHECK_NOT_DELAY_SLOT
501 ctx->delayed_pc = ctx->pc + 4 + B11_0s * 2;
502 tcg_gen_movi_i32(cpu_delayed_pc, ctx->delayed_pc);
503 ctx->flags |= DELAY_SLOT;
504 return;
505 case 0xb000: /* bsr disp */
506 CHECK_NOT_DELAY_SLOT
507 tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
508 ctx->delayed_pc = ctx->pc + 4 + B11_0s * 2;
509 tcg_gen_movi_i32(cpu_delayed_pc, ctx->delayed_pc);
510 ctx->flags |= DELAY_SLOT;
511 return;
512 }
513
514 switch (ctx->opcode & 0xf00f) {
515 case 0x6003: /* mov Rm,Rn */
516 tcg_gen_mov_i32(REG(B11_8), REG(B7_4));
517 return;
518 case 0x2000: /* mov.b Rm,@Rn */
519 tcg_gen_qemu_st_i32(REG(B7_4), REG(B11_8), ctx->memidx, MO_UB);
520 return;
521 case 0x2001: /* mov.w Rm,@Rn */
522 tcg_gen_qemu_st_i32(REG(B7_4), REG(B11_8), ctx->memidx, MO_TEUW);
523 return;
524 case 0x2002: /* mov.l Rm,@Rn */
525 tcg_gen_qemu_st_i32(REG(B7_4), REG(B11_8), ctx->memidx, MO_TEUL);
526 return;
527 case 0x6000: /* mov.b @Rm,Rn */
528 tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_SB);
529 return;
530 case 0x6001: /* mov.w @Rm,Rn */
531 tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESW);
532 return;
533 case 0x6002: /* mov.l @Rm,Rn */
534 tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESL);
535 return;
536 case 0x2004: /* mov.b Rm,@-Rn */
537 {
538 TCGv addr = tcg_temp_new();
539 tcg_gen_subi_i32(addr, REG(B11_8), 1);
540 /* might cause re-execution */
541 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_UB);
542 tcg_gen_mov_i32(REG(B11_8), addr); /* modify register status */
543 tcg_temp_free(addr);
544 }
545 return;
546 case 0x2005: /* mov.w Rm,@-Rn */
547 {
548 TCGv addr = tcg_temp_new();
549 tcg_gen_subi_i32(addr, REG(B11_8), 2);
550 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUW);
551 tcg_gen_mov_i32(REG(B11_8), addr);
552 tcg_temp_free(addr);
553 }
554 return;
555 case 0x2006: /* mov.l Rm,@-Rn */
556 {
557 TCGv addr = tcg_temp_new();
558 tcg_gen_subi_i32(addr, REG(B11_8), 4);
559 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUL);
560 tcg_gen_mov_i32(REG(B11_8), addr);
561 }
562 return;
563 case 0x6004: /* mov.b @Rm+,Rn */
564 tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_SB);
565 if ( B11_8 != B7_4 )
566 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 1);
567 return;
568 case 0x6005: /* mov.w @Rm+,Rn */
569 tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESW);
570 if ( B11_8 != B7_4 )
571 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
572 return;
573 case 0x6006: /* mov.l @Rm+,Rn */
574 tcg_gen_qemu_ld_i32(REG(B11_8), REG(B7_4), ctx->memidx, MO_TESL);
575 if ( B11_8 != B7_4 )
576 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
577 return;
578 case 0x0004: /* mov.b Rm,@(R0,Rn) */
579 {
580 TCGv addr = tcg_temp_new();
581 tcg_gen_add_i32(addr, REG(B11_8), REG(0));
582 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_UB);
583 tcg_temp_free(addr);
584 }
585 return;
586 case 0x0005: /* mov.w Rm,@(R0,Rn) */
587 {
588 TCGv addr = tcg_temp_new();
589 tcg_gen_add_i32(addr, REG(B11_8), REG(0));
590 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUW);
591 tcg_temp_free(addr);
592 }
593 return;
594 case 0x0006: /* mov.l Rm,@(R0,Rn) */
595 {
596 TCGv addr = tcg_temp_new();
597 tcg_gen_add_i32(addr, REG(B11_8), REG(0));
598 tcg_gen_qemu_st_i32(REG(B7_4), addr, ctx->memidx, MO_TEUL);
599 tcg_temp_free(addr);
600 }
601 return;
602 case 0x000c: /* mov.b @(R0,Rm),Rn */
603 {
604 TCGv addr = tcg_temp_new();
605 tcg_gen_add_i32(addr, REG(B7_4), REG(0));
606 tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_SB);
607 tcg_temp_free(addr);
608 }
609 return;
610 case 0x000d: /* mov.w @(R0,Rm),Rn */
611 {
612 TCGv addr = tcg_temp_new();
613 tcg_gen_add_i32(addr, REG(B7_4), REG(0));
614 tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESW);
615 tcg_temp_free(addr);
616 }
617 return;
618 case 0x000e: /* mov.l @(R0,Rm),Rn */
619 {
620 TCGv addr = tcg_temp_new();
621 tcg_gen_add_i32(addr, REG(B7_4), REG(0));
622 tcg_gen_qemu_ld_i32(REG(B11_8), addr, ctx->memidx, MO_TESL);
623 tcg_temp_free(addr);
624 }
625 return;
626 case 0x6008: /* swap.b Rm,Rn */
627 {
628 TCGv high, low;
629 high = tcg_temp_new();
630 tcg_gen_andi_i32(high, REG(B7_4), 0xffff0000);
631 low = tcg_temp_new();
632 tcg_gen_ext16u_i32(low, REG(B7_4));
633 tcg_gen_bswap16_i32(low, low);
634 tcg_gen_or_i32(REG(B11_8), high, low);
635 tcg_temp_free(low);
636 tcg_temp_free(high);
637 }
638 return;
639 case 0x6009: /* swap.w Rm,Rn */
640 tcg_gen_rotli_i32(REG(B11_8), REG(B7_4), 16);
641 return;
642 case 0x200d: /* xtrct Rm,Rn */
643 {
644 TCGv high, low;
645 high = tcg_temp_new();
646 tcg_gen_shli_i32(high, REG(B7_4), 16);
647 low = tcg_temp_new();
648 tcg_gen_shri_i32(low, REG(B11_8), 16);
649 tcg_gen_or_i32(REG(B11_8), high, low);
650 tcg_temp_free(low);
651 tcg_temp_free(high);
652 }
653 return;
654 case 0x300c: /* add Rm,Rn */
655 tcg_gen_add_i32(REG(B11_8), REG(B11_8), REG(B7_4));
656 return;
657 case 0x300e: /* addc Rm,Rn */
658 {
659 TCGv t0, t1, t2;
660 t0 = tcg_temp_new();
661 tcg_gen_andi_i32(t0, cpu_sr, SR_T);
662 t1 = tcg_temp_new();
663 tcg_gen_add_i32(t1, REG(B7_4), REG(B11_8));
664 tcg_gen_add_i32(t0, t0, t1);
665 t2 = tcg_temp_new();
666 tcg_gen_setcond_i32(TCG_COND_GTU, t2, REG(B11_8), t1);
667 tcg_gen_setcond_i32(TCG_COND_GTU, t1, t1, t0);
668 tcg_gen_or_i32(t1, t1, t2);
669 tcg_temp_free(t2);
670 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
671 tcg_gen_or_i32(cpu_sr, cpu_sr, t1);
672 tcg_temp_free(t1);
673 tcg_gen_mov_i32(REG(B11_8), t0);
674 tcg_temp_free(t0);
675 }
676 return;
677 case 0x300f: /* addv Rm,Rn */
678 {
679 TCGv t0, t1, t2;
680 t0 = tcg_temp_new();
681 tcg_gen_add_i32(t0, REG(B7_4), REG(B11_8));
682 t1 = tcg_temp_new();
683 tcg_gen_xor_i32(t1, t0, REG(B11_8));
684 t2 = tcg_temp_new();
685 tcg_gen_xor_i32(t2, REG(B7_4), REG(B11_8));
686 tcg_gen_andc_i32(t1, t1, t2);
687 tcg_temp_free(t2);
688 tcg_gen_shri_i32(t1, t1, 31);
689 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
690 tcg_gen_or_i32(cpu_sr, cpu_sr, t1);
691 tcg_temp_free(t1);
692 tcg_gen_mov_i32(REG(B7_4), t0);
693 tcg_temp_free(t0);
694 }
695 return;
696 case 0x2009: /* and Rm,Rn */
697 tcg_gen_and_i32(REG(B11_8), REG(B11_8), REG(B7_4));
698 return;
699 case 0x3000: /* cmp/eq Rm,Rn */
700 gen_cmp(TCG_COND_EQ, REG(B7_4), REG(B11_8));
701 return;
702 case 0x3003: /* cmp/ge Rm,Rn */
703 gen_cmp(TCG_COND_GE, REG(B7_4), REG(B11_8));
704 return;
705 case 0x3007: /* cmp/gt Rm,Rn */
706 gen_cmp(TCG_COND_GT, REG(B7_4), REG(B11_8));
707 return;
708 case 0x3006: /* cmp/hi Rm,Rn */
709 gen_cmp(TCG_COND_GTU, REG(B7_4), REG(B11_8));
710 return;
711 case 0x3002: /* cmp/hs Rm,Rn */
712 gen_cmp(TCG_COND_GEU, REG(B7_4), REG(B11_8));
713 return;
714 case 0x200c: /* cmp/str Rm,Rn */
715 {
716 TCGv cmp1 = tcg_temp_new();
717 TCGv cmp2 = tcg_temp_new();
718 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
719 tcg_gen_xor_i32(cmp1, REG(B7_4), REG(B11_8));
720 tcg_gen_andi_i32(cmp2, cmp1, 0xff000000);
721 tcg_gen_setcondi_i32(TCG_COND_EQ, cmp2, cmp2, 0);
722 tcg_gen_or_i32(cpu_sr, cpu_sr, cmp2);
723 tcg_gen_andi_i32(cmp2, cmp1, 0x00ff0000);
724 tcg_gen_setcondi_i32(TCG_COND_EQ, cmp2, cmp2, 0);
725 tcg_gen_or_i32(cpu_sr, cpu_sr, cmp2);
726 tcg_gen_andi_i32(cmp2, cmp1, 0x0000ff00);
727 tcg_gen_setcondi_i32(TCG_COND_EQ, cmp2, cmp2, 0);
728 tcg_gen_or_i32(cpu_sr, cpu_sr, cmp2);
729 tcg_gen_andi_i32(cmp2, cmp1, 0x000000ff);
730 tcg_gen_setcondi_i32(TCG_COND_EQ, cmp2, cmp2, 0);
731 tcg_gen_or_i32(cpu_sr, cpu_sr, cmp2);
732 tcg_temp_free(cmp2);
733 tcg_temp_free(cmp1);
734 }
735 return;
736 case 0x2007: /* div0s Rm,Rn */
737 {
738 gen_copy_bit_i32(cpu_sr, 8, REG(B11_8), 31); /* SR_Q */
739 gen_copy_bit_i32(cpu_sr, 9, REG(B7_4), 31); /* SR_M */
740 TCGv val = tcg_temp_new();
741 tcg_gen_xor_i32(val, REG(B7_4), REG(B11_8));
742 gen_copy_bit_i32(cpu_sr, 0, val, 31); /* SR_T */
743 tcg_temp_free(val);
744 }
745 return;
746 case 0x3004: /* div1 Rm,Rn */
747 gen_helper_div1(REG(B11_8), cpu_env, REG(B7_4), REG(B11_8));
748 return;
749 case 0x300d: /* dmuls.l Rm,Rn */
750 tcg_gen_muls2_i32(cpu_macl, cpu_mach, REG(B7_4), REG(B11_8));
751 return;
752 case 0x3005: /* dmulu.l Rm,Rn */
753 tcg_gen_mulu2_i32(cpu_macl, cpu_mach, REG(B7_4), REG(B11_8));
754 return;
755 case 0x600e: /* exts.b Rm,Rn */
756 tcg_gen_ext8s_i32(REG(B11_8), REG(B7_4));
757 return;
758 case 0x600f: /* exts.w Rm,Rn */
759 tcg_gen_ext16s_i32(REG(B11_8), REG(B7_4));
760 return;
761 case 0x600c: /* extu.b Rm,Rn */
762 tcg_gen_ext8u_i32(REG(B11_8), REG(B7_4));
763 return;
764 case 0x600d: /* extu.w Rm,Rn */
765 tcg_gen_ext16u_i32(REG(B11_8), REG(B7_4));
766 return;
767 case 0x000f: /* mac.l @Rm+,@Rn+ */
768 {
769 TCGv arg0, arg1;
770 arg0 = tcg_temp_new();
771 tcg_gen_qemu_ld_i32(arg0, REG(B7_4), ctx->memidx, MO_TESL);
772 arg1 = tcg_temp_new();
773 tcg_gen_qemu_ld_i32(arg1, REG(B11_8), ctx->memidx, MO_TESL);
774 gen_helper_macl(cpu_env, arg0, arg1);
775 tcg_temp_free(arg1);
776 tcg_temp_free(arg0);
777 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
778 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
779 }
780 return;
781 case 0x400f: /* mac.w @Rm+,@Rn+ */
782 {
783 TCGv arg0, arg1;
784 arg0 = tcg_temp_new();
785 tcg_gen_qemu_ld_i32(arg0, REG(B7_4), ctx->memidx, MO_TESL);
786 arg1 = tcg_temp_new();
787 tcg_gen_qemu_ld_i32(arg1, REG(B11_8), ctx->memidx, MO_TESL);
788 gen_helper_macw(cpu_env, arg0, arg1);
789 tcg_temp_free(arg1);
790 tcg_temp_free(arg0);
791 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 2);
792 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 2);
793 }
794 return;
795 case 0x0007: /* mul.l Rm,Rn */
796 tcg_gen_mul_i32(cpu_macl, REG(B7_4), REG(B11_8));
797 return;
798 case 0x200f: /* muls.w Rm,Rn */
799 {
800 TCGv arg0, arg1;
801 arg0 = tcg_temp_new();
802 tcg_gen_ext16s_i32(arg0, REG(B7_4));
803 arg1 = tcg_temp_new();
804 tcg_gen_ext16s_i32(arg1, REG(B11_8));
805 tcg_gen_mul_i32(cpu_macl, arg0, arg1);
806 tcg_temp_free(arg1);
807 tcg_temp_free(arg0);
808 }
809 return;
810 case 0x200e: /* mulu.w Rm,Rn */
811 {
812 TCGv arg0, arg1;
813 arg0 = tcg_temp_new();
814 tcg_gen_ext16u_i32(arg0, REG(B7_4));
815 arg1 = tcg_temp_new();
816 tcg_gen_ext16u_i32(arg1, REG(B11_8));
817 tcg_gen_mul_i32(cpu_macl, arg0, arg1);
818 tcg_temp_free(arg1);
819 tcg_temp_free(arg0);
820 }
821 return;
822 case 0x600b: /* neg Rm,Rn */
823 tcg_gen_neg_i32(REG(B11_8), REG(B7_4));
824 return;
825 case 0x600a: /* negc Rm,Rn */
826 {
827 TCGv t0, t1;
828 t0 = tcg_temp_new();
829 tcg_gen_neg_i32(t0, REG(B7_4));
830 t1 = tcg_temp_new();
831 tcg_gen_andi_i32(t1, cpu_sr, SR_T);
832 tcg_gen_sub_i32(REG(B11_8), t0, t1);
833 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
834 tcg_gen_setcondi_i32(TCG_COND_GTU, t1, t0, 0);
835 tcg_gen_or_i32(cpu_sr, cpu_sr, t1);
836 tcg_gen_setcond_i32(TCG_COND_GTU, t1, REG(B11_8), t0);
837 tcg_gen_or_i32(cpu_sr, cpu_sr, t1);
838 tcg_temp_free(t0);
839 tcg_temp_free(t1);
840 }
841 return;
842 case 0x6007: /* not Rm,Rn */
843 tcg_gen_not_i32(REG(B11_8), REG(B7_4));
844 return;
845 case 0x200b: /* or Rm,Rn */
846 tcg_gen_or_i32(REG(B11_8), REG(B11_8), REG(B7_4));
847 return;
848 case 0x400c: /* shad Rm,Rn */
849 {
850 int label1 = gen_new_label();
851 int label2 = gen_new_label();
852 int label3 = gen_new_label();
853 int label4 = gen_new_label();
854 TCGv shift;
855 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
856 /* Rm positive, shift to the left */
857 shift = tcg_temp_new();
858 tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
859 tcg_gen_shl_i32(REG(B11_8), REG(B11_8), shift);
860 tcg_temp_free(shift);
861 tcg_gen_br(label4);
862 /* Rm negative, shift to the right */
863 gen_set_label(label1);
864 shift = tcg_temp_new();
865 tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
866 tcg_gen_brcondi_i32(TCG_COND_EQ, shift, 0, label2);
867 tcg_gen_not_i32(shift, REG(B7_4));
868 tcg_gen_andi_i32(shift, shift, 0x1f);
869 tcg_gen_addi_i32(shift, shift, 1);
870 tcg_gen_sar_i32(REG(B11_8), REG(B11_8), shift);
871 tcg_temp_free(shift);
872 tcg_gen_br(label4);
873 /* Rm = -32 */
874 gen_set_label(label2);
875 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B11_8), 0, label3);
876 tcg_gen_movi_i32(REG(B11_8), 0);
877 tcg_gen_br(label4);
878 gen_set_label(label3);
879 tcg_gen_movi_i32(REG(B11_8), 0xffffffff);
880 gen_set_label(label4);
881 }
882 return;
883 case 0x400d: /* shld Rm,Rn */
884 {
885 int label1 = gen_new_label();
886 int label2 = gen_new_label();
887 int label3 = gen_new_label();
888 TCGv shift;
889 tcg_gen_brcondi_i32(TCG_COND_LT, REG(B7_4), 0, label1);
890 /* Rm positive, shift to the left */
891 shift = tcg_temp_new();
892 tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
893 tcg_gen_shl_i32(REG(B11_8), REG(B11_8), shift);
894 tcg_temp_free(shift);
895 tcg_gen_br(label3);
896 /* Rm negative, shift to the right */
897 gen_set_label(label1);
898 shift = tcg_temp_new();
899 tcg_gen_andi_i32(shift, REG(B7_4), 0x1f);
900 tcg_gen_brcondi_i32(TCG_COND_EQ, shift, 0, label2);
901 tcg_gen_not_i32(shift, REG(B7_4));
902 tcg_gen_andi_i32(shift, shift, 0x1f);
903 tcg_gen_addi_i32(shift, shift, 1);
904 tcg_gen_shr_i32(REG(B11_8), REG(B11_8), shift);
905 tcg_temp_free(shift);
906 tcg_gen_br(label3);
907 /* Rm = -32 */
908 gen_set_label(label2);
909 tcg_gen_movi_i32(REG(B11_8), 0);
910 gen_set_label(label3);
911 }
912 return;
913 case 0x3008: /* sub Rm,Rn */
914 tcg_gen_sub_i32(REG(B11_8), REG(B11_8), REG(B7_4));
915 return;
916 case 0x300a: /* subc Rm,Rn */
917 {
918 TCGv t0, t1, t2;
919 t0 = tcg_temp_new();
920 tcg_gen_andi_i32(t0, cpu_sr, SR_T);
921 t1 = tcg_temp_new();
922 tcg_gen_sub_i32(t1, REG(B11_8), REG(B7_4));
923 tcg_gen_sub_i32(t0, t1, t0);
924 t2 = tcg_temp_new();
925 tcg_gen_setcond_i32(TCG_COND_LTU, t2, REG(B11_8), t1);
926 tcg_gen_setcond_i32(TCG_COND_LTU, t1, t1, t0);
927 tcg_gen_or_i32(t1, t1, t2);
928 tcg_temp_free(t2);
929 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
930 tcg_gen_or_i32(cpu_sr, cpu_sr, t1);
931 tcg_temp_free(t1);
932 tcg_gen_mov_i32(REG(B11_8), t0);
933 tcg_temp_free(t0);
934 }
935 return;
936 case 0x300b: /* subv Rm,Rn */
937 {
938 TCGv t0, t1, t2;
939 t0 = tcg_temp_new();
940 tcg_gen_sub_i32(t0, REG(B11_8), REG(B7_4));
941 t1 = tcg_temp_new();
942 tcg_gen_xor_i32(t1, t0, REG(B7_4));
943 t2 = tcg_temp_new();
944 tcg_gen_xor_i32(t2, REG(B11_8), REG(B7_4));
945 tcg_gen_and_i32(t1, t1, t2);
946 tcg_temp_free(t2);
947 tcg_gen_shri_i32(t1, t1, 31);
948 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
949 tcg_gen_or_i32(cpu_sr, cpu_sr, t1);
950 tcg_temp_free(t1);
951 tcg_gen_mov_i32(REG(B11_8), t0);
952 tcg_temp_free(t0);
953 }
954 return;
955 case 0x2008: /* tst Rm,Rn */
956 {
957 TCGv val = tcg_temp_new();
958 tcg_gen_and_i32(val, REG(B7_4), REG(B11_8));
959 gen_cmp_imm(TCG_COND_EQ, val, 0);
960 tcg_temp_free(val);
961 }
962 return;
963 case 0x200a: /* xor Rm,Rn */
964 tcg_gen_xor_i32(REG(B11_8), REG(B11_8), REG(B7_4));
965 return;
966 case 0xf00c: /* fmov {F,D,X}Rm,{F,D,X}Rn - FPSCR: Nothing */
967 CHECK_FPU_ENABLED
968 if (ctx->flags & FPSCR_SZ) {
969 TCGv_i64 fp = tcg_temp_new_i64();
970 gen_load_fpr64(fp, XREG(B7_4));
971 gen_store_fpr64(fp, XREG(B11_8));
972 tcg_temp_free_i64(fp);
973 } else {
974 tcg_gen_mov_i32(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B7_4)]);
975 }
976 return;
977 case 0xf00a: /* fmov {F,D,X}Rm,@Rn - FPSCR: Nothing */
978 CHECK_FPU_ENABLED
979 if (ctx->flags & FPSCR_SZ) {
980 TCGv addr_hi = tcg_temp_new();
981 int fr = XREG(B7_4);
982 tcg_gen_addi_i32(addr_hi, REG(B11_8), 4);
983 tcg_gen_qemu_st_i32(cpu_fregs[fr], REG(B11_8),
984 ctx->memidx, MO_TEUL);
985 tcg_gen_qemu_st_i32(cpu_fregs[fr+1], addr_hi,
986 ctx->memidx, MO_TEUL);
987 tcg_temp_free(addr_hi);
988 } else {
989 tcg_gen_qemu_st_i32(cpu_fregs[FREG(B7_4)], REG(B11_8),
990 ctx->memidx, MO_TEUL);
991 }
992 return;
993 case 0xf008: /* fmov @Rm,{F,D,X}Rn - FPSCR: Nothing */
994 CHECK_FPU_ENABLED
995 if (ctx->flags & FPSCR_SZ) {
996 TCGv addr_hi = tcg_temp_new();
997 int fr = XREG(B11_8);
998 tcg_gen_addi_i32(addr_hi, REG(B7_4), 4);
999 tcg_gen_qemu_ld_i32(cpu_fregs[fr], REG(B7_4), ctx->memidx, MO_TEUL);
1000 tcg_gen_qemu_ld_i32(cpu_fregs[fr+1], addr_hi, ctx->memidx, MO_TEUL);
1001 tcg_temp_free(addr_hi);
1002 } else {
1003 tcg_gen_qemu_ld_i32(cpu_fregs[FREG(B11_8)], REG(B7_4),
1004 ctx->memidx, MO_TEUL);
1005 }
1006 return;
1007 case 0xf009: /* fmov @Rm+,{F,D,X}Rn - FPSCR: Nothing */
1008 CHECK_FPU_ENABLED
1009 if (ctx->flags & FPSCR_SZ) {
1010 TCGv addr_hi = tcg_temp_new();
1011 int fr = XREG(B11_8);
1012 tcg_gen_addi_i32(addr_hi, REG(B7_4), 4);
1013 tcg_gen_qemu_ld_i32(cpu_fregs[fr], REG(B7_4), ctx->memidx, MO_TEUL);
1014 tcg_gen_qemu_ld_i32(cpu_fregs[fr+1], addr_hi, ctx->memidx, MO_TEUL);
1015 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 8);
1016 tcg_temp_free(addr_hi);
1017 } else {
1018 tcg_gen_qemu_ld_i32(cpu_fregs[FREG(B11_8)], REG(B7_4),
1019 ctx->memidx, MO_TEUL);
1020 tcg_gen_addi_i32(REG(B7_4), REG(B7_4), 4);
1021 }
1022 return;
1023 case 0xf00b: /* fmov {F,D,X}Rm,@-Rn - FPSCR: Nothing */
1024 CHECK_FPU_ENABLED
1025 if (ctx->flags & FPSCR_SZ) {
1026 TCGv addr = tcg_temp_new_i32();
1027 int fr = XREG(B7_4);
1028 tcg_gen_subi_i32(addr, REG(B11_8), 4);
1029 tcg_gen_qemu_st_i32(cpu_fregs[fr+1], addr, ctx->memidx, MO_TEUL);
1030 tcg_gen_subi_i32(addr, addr, 4);
1031 tcg_gen_qemu_st_i32(cpu_fregs[fr], addr, ctx->memidx, MO_TEUL);
1032 tcg_gen_mov_i32(REG(B11_8), addr);
1033 tcg_temp_free(addr);
1034 } else {
1035 TCGv addr;
1036 addr = tcg_temp_new_i32();
1037 tcg_gen_subi_i32(addr, REG(B11_8), 4);
1038 tcg_gen_qemu_st_i32(cpu_fregs[FREG(B7_4)], addr,
1039 ctx->memidx, MO_TEUL);
1040 tcg_gen_mov_i32(REG(B11_8), addr);
1041 tcg_temp_free(addr);
1042 }
1043 return;
1044 case 0xf006: /* fmov @(R0,Rm),{F,D,X}Rm - FPSCR: Nothing */
1045 CHECK_FPU_ENABLED
1046 {
1047 TCGv addr = tcg_temp_new_i32();
1048 tcg_gen_add_i32(addr, REG(B7_4), REG(0));
1049 if (ctx->flags & FPSCR_SZ) {
1050 int fr = XREG(B11_8);
1051 tcg_gen_qemu_ld_i32(cpu_fregs[fr], addr,
1052 ctx->memidx, MO_TEUL);
1053 tcg_gen_addi_i32(addr, addr, 4);
1054 tcg_gen_qemu_ld_i32(cpu_fregs[fr+1], addr,
1055 ctx->memidx, MO_TEUL);
1056 } else {
1057 tcg_gen_qemu_ld_i32(cpu_fregs[FREG(B11_8)], addr,
1058 ctx->memidx, MO_TEUL);
1059 }
1060 tcg_temp_free(addr);
1061 }
1062 return;
1063 case 0xf007: /* fmov {F,D,X}Rn,@(R0,Rn) - FPSCR: Nothing */
1064 CHECK_FPU_ENABLED
1065 {
1066 TCGv addr = tcg_temp_new();
1067 tcg_gen_add_i32(addr, REG(B11_8), REG(0));
1068 if (ctx->flags & FPSCR_SZ) {
1069 int fr = XREG(B7_4);
1070 tcg_gen_qemu_ld_i32(cpu_fregs[fr], addr,
1071 ctx->memidx, MO_TEUL);
1072 tcg_gen_addi_i32(addr, addr, 4);
1073 tcg_gen_qemu_ld_i32(cpu_fregs[fr+1], addr,
1074 ctx->memidx, MO_TEUL);
1075 } else {
1076 tcg_gen_qemu_st_i32(cpu_fregs[FREG(B7_4)], addr,
1077 ctx->memidx, MO_TEUL);
1078 }
1079 tcg_temp_free(addr);
1080 }
1081 return;
1082 case 0xf000: /* fadd Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1083 case 0xf001: /* fsub Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1084 case 0xf002: /* fmul Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1085 case 0xf003: /* fdiv Rm,Rn - FPSCR: R[PR,Enable.O/U/I]/W[Cause,Flag] */
1086 case 0xf004: /* fcmp/eq Rm,Rn - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1087 case 0xf005: /* fcmp/gt Rm,Rn - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1088 {
1089 CHECK_FPU_ENABLED
1090 if (ctx->flags & FPSCR_PR) {
1091 TCGv_i64 fp0, fp1;
1092
1093 if (ctx->opcode & 0x0110)
1094 break; /* illegal instruction */
1095 fp0 = tcg_temp_new_i64();
1096 fp1 = tcg_temp_new_i64();
1097 gen_load_fpr64(fp0, DREG(B11_8));
1098 gen_load_fpr64(fp1, DREG(B7_4));
1099 switch (ctx->opcode & 0xf00f) {
1100 case 0xf000: /* fadd Rm,Rn */
1101 gen_helper_fadd_DT(fp0, cpu_env, fp0, fp1);
1102 break;
1103 case 0xf001: /* fsub Rm,Rn */
1104 gen_helper_fsub_DT(fp0, cpu_env, fp0, fp1);
1105 break;
1106 case 0xf002: /* fmul Rm,Rn */
1107 gen_helper_fmul_DT(fp0, cpu_env, fp0, fp1);
1108 break;
1109 case 0xf003: /* fdiv Rm,Rn */
1110 gen_helper_fdiv_DT(fp0, cpu_env, fp0, fp1);
1111 break;
1112 case 0xf004: /* fcmp/eq Rm,Rn */
1113 gen_helper_fcmp_eq_DT(cpu_env, fp0, fp1);
1114 return;
1115 case 0xf005: /* fcmp/gt Rm,Rn */
1116 gen_helper_fcmp_gt_DT(cpu_env, fp0, fp1);
1117 return;
1118 }
1119 gen_store_fpr64(fp0, DREG(B11_8));
1120 tcg_temp_free_i64(fp0);
1121 tcg_temp_free_i64(fp1);
1122 } else {
1123 switch (ctx->opcode & 0xf00f) {
1124 case 0xf000: /* fadd Rm,Rn */
1125 gen_helper_fadd_FT(cpu_fregs[FREG(B11_8)], cpu_env,
1126 cpu_fregs[FREG(B11_8)],
1127 cpu_fregs[FREG(B7_4)]);
1128 break;
1129 case 0xf001: /* fsub Rm,Rn */
1130 gen_helper_fsub_FT(cpu_fregs[FREG(B11_8)], cpu_env,
1131 cpu_fregs[FREG(B11_8)],
1132 cpu_fregs[FREG(B7_4)]);
1133 break;
1134 case 0xf002: /* fmul Rm,Rn */
1135 gen_helper_fmul_FT(cpu_fregs[FREG(B11_8)], cpu_env,
1136 cpu_fregs[FREG(B11_8)],
1137 cpu_fregs[FREG(B7_4)]);
1138 break;
1139 case 0xf003: /* fdiv Rm,Rn */
1140 gen_helper_fdiv_FT(cpu_fregs[FREG(B11_8)], cpu_env,
1141 cpu_fregs[FREG(B11_8)],
1142 cpu_fregs[FREG(B7_4)]);
1143 break;
1144 case 0xf004: /* fcmp/eq Rm,Rn */
1145 gen_helper_fcmp_eq_FT(cpu_env, cpu_fregs[FREG(B11_8)],
1146 cpu_fregs[FREG(B7_4)]);
1147 return;
1148 case 0xf005: /* fcmp/gt Rm,Rn */
1149 gen_helper_fcmp_gt_FT(cpu_env, cpu_fregs[FREG(B11_8)],
1150 cpu_fregs[FREG(B7_4)]);
1151 return;
1152 }
1153 }
1154 }
1155 return;
1156 case 0xf00e: /* fmac FR0,RM,Rn */
1157 {
1158 CHECK_FPU_ENABLED
1159 if (ctx->flags & FPSCR_PR) {
1160 break; /* illegal instruction */
1161 } else {
1162 gen_helper_fmac_FT(cpu_fregs[FREG(B11_8)], cpu_env,
1163 cpu_fregs[FREG(0)], cpu_fregs[FREG(B7_4)],
1164 cpu_fregs[FREG(B11_8)]);
1165 return;
1166 }
1167 }
1168 }
1169
1170 switch (ctx->opcode & 0xff00) {
1171 case 0xc900: /* and #imm,R0 */
1172 tcg_gen_andi_i32(REG(0), REG(0), B7_0);
1173 return;
1174 case 0xcd00: /* and.b #imm,@(R0,GBR) */
1175 {
1176 TCGv addr, val;
1177 addr = tcg_temp_new();
1178 tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1179 val = tcg_temp_new();
1180 tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1181 tcg_gen_andi_i32(val, val, B7_0);
1182 tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1183 tcg_temp_free(val);
1184 tcg_temp_free(addr);
1185 }
1186 return;
1187 case 0x8b00: /* bf label */
1188 CHECK_NOT_DELAY_SLOT
1189 gen_conditional_jump(ctx, ctx->pc + 2,
1190 ctx->pc + 4 + B7_0s * 2);
1191 ctx->bstate = BS_BRANCH;
1192 return;
1193 case 0x8f00: /* bf/s label */
1194 CHECK_NOT_DELAY_SLOT
1195 gen_branch_slot(ctx->delayed_pc = ctx->pc + 4 + B7_0s * 2, 0);
1196 ctx->flags |= DELAY_SLOT_CONDITIONAL;
1197 return;
1198 case 0x8900: /* bt label */
1199 CHECK_NOT_DELAY_SLOT
1200 gen_conditional_jump(ctx, ctx->pc + 4 + B7_0s * 2,
1201 ctx->pc + 2);
1202 ctx->bstate = BS_BRANCH;
1203 return;
1204 case 0x8d00: /* bt/s label */
1205 CHECK_NOT_DELAY_SLOT
1206 gen_branch_slot(ctx->delayed_pc = ctx->pc + 4 + B7_0s * 2, 1);
1207 ctx->flags |= DELAY_SLOT_CONDITIONAL;
1208 return;
1209 case 0x8800: /* cmp/eq #imm,R0 */
1210 gen_cmp_imm(TCG_COND_EQ, REG(0), B7_0s);
1211 return;
1212 case 0xc400: /* mov.b @(disp,GBR),R0 */
1213 {
1214 TCGv addr = tcg_temp_new();
1215 tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
1216 tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_SB);
1217 tcg_temp_free(addr);
1218 }
1219 return;
1220 case 0xc500: /* mov.w @(disp,GBR),R0 */
1221 {
1222 TCGv addr = tcg_temp_new();
1223 tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
1224 tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_TESW);
1225 tcg_temp_free(addr);
1226 }
1227 return;
1228 case 0xc600: /* mov.l @(disp,GBR),R0 */
1229 {
1230 TCGv addr = tcg_temp_new();
1231 tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
1232 tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_TESL);
1233 tcg_temp_free(addr);
1234 }
1235 return;
1236 case 0xc000: /* mov.b R0,@(disp,GBR) */
1237 {
1238 TCGv addr = tcg_temp_new();
1239 tcg_gen_addi_i32(addr, cpu_gbr, B7_0);
1240 tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_UB);
1241 tcg_temp_free(addr);
1242 }
1243 return;
1244 case 0xc100: /* mov.w R0,@(disp,GBR) */
1245 {
1246 TCGv addr = tcg_temp_new();
1247 tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 2);
1248 tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_TEUW);
1249 tcg_temp_free(addr);
1250 }
1251 return;
1252 case 0xc200: /* mov.l R0,@(disp,GBR) */
1253 {
1254 TCGv addr = tcg_temp_new();
1255 tcg_gen_addi_i32(addr, cpu_gbr, B7_0 * 4);
1256 tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_TEUL);
1257 tcg_temp_free(addr);
1258 }
1259 return;
1260 case 0x8000: /* mov.b R0,@(disp,Rn) */
1261 {
1262 TCGv addr = tcg_temp_new();
1263 tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
1264 tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_UB);
1265 tcg_temp_free(addr);
1266 }
1267 return;
1268 case 0x8100: /* mov.w R0,@(disp,Rn) */
1269 {
1270 TCGv addr = tcg_temp_new();
1271 tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
1272 tcg_gen_qemu_st_i32(REG(0), addr, ctx->memidx, MO_TEUW);
1273 tcg_temp_free(addr);
1274 }
1275 return;
1276 case 0x8400: /* mov.b @(disp,Rn),R0 */
1277 {
1278 TCGv addr = tcg_temp_new();
1279 tcg_gen_addi_i32(addr, REG(B7_4), B3_0);
1280 tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_SB);
1281 tcg_temp_free(addr);
1282 }
1283 return;
1284 case 0x8500: /* mov.w @(disp,Rn),R0 */
1285 {
1286 TCGv addr = tcg_temp_new();
1287 tcg_gen_addi_i32(addr, REG(B7_4), B3_0 * 2);
1288 tcg_gen_qemu_ld_i32(REG(0), addr, ctx->memidx, MO_TESW);
1289 tcg_temp_free(addr);
1290 }
1291 return;
1292 case 0xc700: /* mova @(disp,PC),R0 */
1293 tcg_gen_movi_i32(REG(0), ((ctx->pc & 0xfffffffc) + 4 + B7_0 * 4) & ~3);
1294 return;
1295 case 0xcb00: /* or #imm,R0 */
1296 tcg_gen_ori_i32(REG(0), REG(0), B7_0);
1297 return;
1298 case 0xcf00: /* or.b #imm,@(R0,GBR) */
1299 {
1300 TCGv addr, val;
1301 addr = tcg_temp_new();
1302 tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1303 val = tcg_temp_new();
1304 tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1305 tcg_gen_ori_i32(val, val, B7_0);
1306 tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1307 tcg_temp_free(val);
1308 tcg_temp_free(addr);
1309 }
1310 return;
1311 case 0xc300: /* trapa #imm */
1312 {
1313 TCGv imm;
1314 CHECK_NOT_DELAY_SLOT
1315 tcg_gen_movi_i32(cpu_pc, ctx->pc);
1316 imm = tcg_const_i32(B7_0);
1317 gen_helper_trapa(cpu_env, imm);
1318 tcg_temp_free(imm);
1319 ctx->bstate = BS_BRANCH;
1320 }
1321 return;
1322 case 0xc800: /* tst #imm,R0 */
1323 {
1324 TCGv val = tcg_temp_new();
1325 tcg_gen_andi_i32(val, REG(0), B7_0);
1326 gen_cmp_imm(TCG_COND_EQ, val, 0);
1327 tcg_temp_free(val);
1328 }
1329 return;
1330 case 0xcc00: /* tst.b #imm,@(R0,GBR) */
1331 {
1332 TCGv val = tcg_temp_new();
1333 tcg_gen_add_i32(val, REG(0), cpu_gbr);
1334 tcg_gen_qemu_ld_i32(val, val, ctx->memidx, MO_UB);
1335 tcg_gen_andi_i32(val, val, B7_0);
1336 gen_cmp_imm(TCG_COND_EQ, val, 0);
1337 tcg_temp_free(val);
1338 }
1339 return;
1340 case 0xca00: /* xor #imm,R0 */
1341 tcg_gen_xori_i32(REG(0), REG(0), B7_0);
1342 return;
1343 case 0xce00: /* xor.b #imm,@(R0,GBR) */
1344 {
1345 TCGv addr, val;
1346 addr = tcg_temp_new();
1347 tcg_gen_add_i32(addr, REG(0), cpu_gbr);
1348 val = tcg_temp_new();
1349 tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1350 tcg_gen_xori_i32(val, val, B7_0);
1351 tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1352 tcg_temp_free(val);
1353 tcg_temp_free(addr);
1354 }
1355 return;
1356 }
1357
1358 switch (ctx->opcode & 0xf08f) {
1359 case 0x408e: /* ldc Rm,Rn_BANK */
1360 CHECK_PRIVILEGED
1361 tcg_gen_mov_i32(ALTREG(B6_4), REG(B11_8));
1362 return;
1363 case 0x4087: /* ldc.l @Rm+,Rn_BANK */
1364 CHECK_PRIVILEGED
1365 tcg_gen_qemu_ld_i32(ALTREG(B6_4), REG(B11_8), ctx->memidx, MO_TESL);
1366 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1367 return;
1368 case 0x0082: /* stc Rm_BANK,Rn */
1369 CHECK_PRIVILEGED
1370 tcg_gen_mov_i32(REG(B11_8), ALTREG(B6_4));
1371 return;
1372 case 0x4083: /* stc.l Rm_BANK,@-Rn */
1373 CHECK_PRIVILEGED
1374 {
1375 TCGv addr = tcg_temp_new();
1376 tcg_gen_subi_i32(addr, REG(B11_8), 4);
1377 tcg_gen_qemu_st_i32(ALTREG(B6_4), addr, ctx->memidx, MO_TEUL);
1378 tcg_gen_mov_i32(REG(B11_8), addr);
1379 tcg_temp_free(addr);
1380 }
1381 return;
1382 }
1383
1384 switch (ctx->opcode & 0xf0ff) {
1385 case 0x0023: /* braf Rn */
1386 CHECK_NOT_DELAY_SLOT
1387 tcg_gen_addi_i32(cpu_delayed_pc, REG(B11_8), ctx->pc + 4);
1388 ctx->flags |= DELAY_SLOT;
1389 ctx->delayed_pc = (uint32_t) - 1;
1390 return;
1391 case 0x0003: /* bsrf Rn */
1392 CHECK_NOT_DELAY_SLOT
1393 tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
1394 tcg_gen_add_i32(cpu_delayed_pc, REG(B11_8), cpu_pr);
1395 ctx->flags |= DELAY_SLOT;
1396 ctx->delayed_pc = (uint32_t) - 1;
1397 return;
1398 case 0x4015: /* cmp/pl Rn */
1399 gen_cmp_imm(TCG_COND_GT, REG(B11_8), 0);
1400 return;
1401 case 0x4011: /* cmp/pz Rn */
1402 gen_cmp_imm(TCG_COND_GE, REG(B11_8), 0);
1403 return;
1404 case 0x4010: /* dt Rn */
1405 tcg_gen_subi_i32(REG(B11_8), REG(B11_8), 1);
1406 gen_cmp_imm(TCG_COND_EQ, REG(B11_8), 0);
1407 return;
1408 case 0x402b: /* jmp @Rn */
1409 CHECK_NOT_DELAY_SLOT
1410 tcg_gen_mov_i32(cpu_delayed_pc, REG(B11_8));
1411 ctx->flags |= DELAY_SLOT;
1412 ctx->delayed_pc = (uint32_t) - 1;
1413 return;
1414 case 0x400b: /* jsr @Rn */
1415 CHECK_NOT_DELAY_SLOT
1416 tcg_gen_movi_i32(cpu_pr, ctx->pc + 4);
1417 tcg_gen_mov_i32(cpu_delayed_pc, REG(B11_8));
1418 ctx->flags |= DELAY_SLOT;
1419 ctx->delayed_pc = (uint32_t) - 1;
1420 return;
1421 case 0x400e: /* ldc Rm,SR */
1422 CHECK_PRIVILEGED
1423 tcg_gen_andi_i32(cpu_sr, REG(B11_8), 0x700083f3);
1424 ctx->bstate = BS_STOP;
1425 return;
1426 case 0x4007: /* ldc.l @Rm+,SR */
1427 CHECK_PRIVILEGED
1428 {
1429 TCGv val = tcg_temp_new();
1430 tcg_gen_qemu_ld_i32(val, REG(B11_8), ctx->memidx, MO_TESL);
1431 tcg_gen_andi_i32(cpu_sr, val, 0x700083f3);
1432 tcg_temp_free(val);
1433 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1434 ctx->bstate = BS_STOP;
1435 }
1436 return;
1437 case 0x0002: /* stc SR,Rn */
1438 CHECK_PRIVILEGED
1439 tcg_gen_mov_i32(REG(B11_8), cpu_sr);
1440 return;
1441 case 0x4003: /* stc SR,@-Rn */
1442 CHECK_PRIVILEGED
1443 {
1444 TCGv addr = tcg_temp_new();
1445 tcg_gen_subi_i32(addr, REG(B11_8), 4);
1446 tcg_gen_qemu_st_i32(cpu_sr, addr, ctx->memidx, MO_TEUL);
1447 tcg_gen_mov_i32(REG(B11_8), addr);
1448 tcg_temp_free(addr);
1449 }
1450 return;
1451 #define LD(reg,ldnum,ldpnum,prechk) \
1452 case ldnum: \
1453 prechk \
1454 tcg_gen_mov_i32 (cpu_##reg, REG(B11_8)); \
1455 return; \
1456 case ldpnum: \
1457 prechk \
1458 tcg_gen_qemu_ld_i32(cpu_##reg, REG(B11_8), ctx->memidx, MO_TESL); \
1459 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4); \
1460 return;
1461 #define ST(reg,stnum,stpnum,prechk) \
1462 case stnum: \
1463 prechk \
1464 tcg_gen_mov_i32 (REG(B11_8), cpu_##reg); \
1465 return; \
1466 case stpnum: \
1467 prechk \
1468 { \
1469 TCGv addr = tcg_temp_new(); \
1470 tcg_gen_subi_i32(addr, REG(B11_8), 4); \
1471 tcg_gen_qemu_st_i32(cpu_##reg, addr, ctx->memidx, MO_TEUL); \
1472 tcg_gen_mov_i32(REG(B11_8), addr); \
1473 tcg_temp_free(addr); \
1474 } \
1475 return;
1476 #define LDST(reg,ldnum,ldpnum,stnum,stpnum,prechk) \
1477 LD(reg,ldnum,ldpnum,prechk) \
1478 ST(reg,stnum,stpnum,prechk)
1479 LDST(gbr, 0x401e, 0x4017, 0x0012, 0x4013, {})
1480 LDST(vbr, 0x402e, 0x4027, 0x0022, 0x4023, CHECK_PRIVILEGED)
1481 LDST(ssr, 0x403e, 0x4037, 0x0032, 0x4033, CHECK_PRIVILEGED)
1482 LDST(spc, 0x404e, 0x4047, 0x0042, 0x4043, CHECK_PRIVILEGED)
1483 ST(sgr, 0x003a, 0x4032, CHECK_PRIVILEGED)
1484 LD(sgr, 0x403a, 0x4036, CHECK_PRIVILEGED if (!(ctx->features & SH_FEATURE_SH4A)) break;)
1485 LDST(dbr, 0x40fa, 0x40f6, 0x00fa, 0x40f2, CHECK_PRIVILEGED)
1486 LDST(mach, 0x400a, 0x4006, 0x000a, 0x4002, {})
1487 LDST(macl, 0x401a, 0x4016, 0x001a, 0x4012, {})
1488 LDST(pr, 0x402a, 0x4026, 0x002a, 0x4022, {})
1489 LDST(fpul, 0x405a, 0x4056, 0x005a, 0x4052, {CHECK_FPU_ENABLED})
1490 case 0x406a: /* lds Rm,FPSCR */
1491 CHECK_FPU_ENABLED
1492 gen_helper_ld_fpscr(cpu_env, REG(B11_8));
1493 ctx->bstate = BS_STOP;
1494 return;
1495 case 0x4066: /* lds.l @Rm+,FPSCR */
1496 CHECK_FPU_ENABLED
1497 {
1498 TCGv addr = tcg_temp_new();
1499 tcg_gen_qemu_ld_i32(addr, REG(B11_8), ctx->memidx, MO_TESL);
1500 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1501 gen_helper_ld_fpscr(cpu_env, addr);
1502 tcg_temp_free(addr);
1503 ctx->bstate = BS_STOP;
1504 }
1505 return;
1506 case 0x006a: /* sts FPSCR,Rn */
1507 CHECK_FPU_ENABLED
1508 tcg_gen_andi_i32(REG(B11_8), cpu_fpscr, 0x003fffff);
1509 return;
1510 case 0x4062: /* sts FPSCR,@-Rn */
1511 CHECK_FPU_ENABLED
1512 {
1513 TCGv addr, val;
1514 val = tcg_temp_new();
1515 tcg_gen_andi_i32(val, cpu_fpscr, 0x003fffff);
1516 addr = tcg_temp_new();
1517 tcg_gen_subi_i32(addr, REG(B11_8), 4);
1518 tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_TEUL);
1519 tcg_gen_mov_i32(REG(B11_8), addr);
1520 tcg_temp_free(addr);
1521 tcg_temp_free(val);
1522 }
1523 return;
1524 case 0x00c3: /* movca.l R0,@Rm */
1525 {
1526 TCGv val = tcg_temp_new();
1527 tcg_gen_qemu_ld_i32(val, REG(B11_8), ctx->memidx, MO_TEUL);
1528 gen_helper_movcal(cpu_env, REG(B11_8), val);
1529 tcg_gen_qemu_st_i32(REG(0), REG(B11_8), ctx->memidx, MO_TEUL);
1530 }
1531 ctx->has_movcal = 1;
1532 return;
1533 case 0x40a9:
1534 /* MOVUA.L @Rm,R0 (Rm) -> R0
1535 Load non-boundary-aligned data */
1536 tcg_gen_qemu_ld_i32(REG(0), REG(B11_8), ctx->memidx, MO_TEUL);
1537 return;
1538 case 0x40e9:
1539 /* MOVUA.L @Rm+,R0 (Rm) -> R0, Rm + 4 -> Rm
1540 Load non-boundary-aligned data */
1541 tcg_gen_qemu_ld_i32(REG(0), REG(B11_8), ctx->memidx, MO_TEUL);
1542 tcg_gen_addi_i32(REG(B11_8), REG(B11_8), 4);
1543 return;
1544 case 0x0029: /* movt Rn */
1545 tcg_gen_andi_i32(REG(B11_8), cpu_sr, SR_T);
1546 return;
1547 case 0x0073:
1548 /* MOVCO.L
1549 LDST -> T
1550 If (T == 1) R0 -> (Rn)
1551 0 -> LDST
1552 */
1553 if (ctx->features & SH_FEATURE_SH4A) {
1554 int label = gen_new_label();
1555 tcg_gen_andi_i32(cpu_sr, cpu_sr, ~SR_T);
1556 tcg_gen_or_i32(cpu_sr, cpu_sr, cpu_ldst);
1557 tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_ldst, 0, label);
1558 tcg_gen_qemu_st_i32(REG(0), REG(B11_8), ctx->memidx, MO_TEUL);
1559 gen_set_label(label);
1560 tcg_gen_movi_i32(cpu_ldst, 0);
1561 return;
1562 } else
1563 break;
1564 case 0x0063:
1565 /* MOVLI.L @Rm,R0
1566 1 -> LDST
1567 (Rm) -> R0
1568 When interrupt/exception
1569 occurred 0 -> LDST
1570 */
1571 if (ctx->features & SH_FEATURE_SH4A) {
1572 tcg_gen_movi_i32(cpu_ldst, 0);
1573 tcg_gen_qemu_ld_i32(REG(0), REG(B11_8), ctx->memidx, MO_TESL);
1574 tcg_gen_movi_i32(cpu_ldst, 1);
1575 return;
1576 } else
1577 break;
1578 case 0x0093: /* ocbi @Rn */
1579 {
1580 gen_helper_ocbi(cpu_env, REG(B11_8));
1581 }
1582 return;
1583 case 0x00a3: /* ocbp @Rn */
1584 case 0x00b3: /* ocbwb @Rn */
1585 /* These instructions are supposed to do nothing in case of
1586 a cache miss. Given that we only partially emulate caches
1587 it is safe to simply ignore them. */
1588 return;
1589 case 0x0083: /* pref @Rn */
1590 return;
1591 case 0x00d3: /* prefi @Rn */
1592 if (ctx->features & SH_FEATURE_SH4A)
1593 return;
1594 else
1595 break;
1596 case 0x00e3: /* icbi @Rn */
1597 if (ctx->features & SH_FEATURE_SH4A)
1598 return;
1599 else
1600 break;
1601 case 0x00ab: /* synco */
1602 if (ctx->features & SH_FEATURE_SH4A)
1603 return;
1604 else
1605 break;
1606 case 0x4024: /* rotcl Rn */
1607 {
1608 TCGv tmp = tcg_temp_new();
1609 tcg_gen_mov_i32(tmp, cpu_sr);
1610 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
1611 tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1612 gen_copy_bit_i32(REG(B11_8), 0, tmp, 0);
1613 tcg_temp_free(tmp);
1614 }
1615 return;
1616 case 0x4025: /* rotcr Rn */
1617 {
1618 TCGv tmp = tcg_temp_new();
1619 tcg_gen_mov_i32(tmp, cpu_sr);
1620 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1621 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1622 gen_copy_bit_i32(REG(B11_8), 31, tmp, 0);
1623 tcg_temp_free(tmp);
1624 }
1625 return;
1626 case 0x4004: /* rotl Rn */
1627 tcg_gen_rotli_i32(REG(B11_8), REG(B11_8), 1);
1628 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1629 return;
1630 case 0x4005: /* rotr Rn */
1631 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1632 tcg_gen_rotri_i32(REG(B11_8), REG(B11_8), 1);
1633 return;
1634 case 0x4000: /* shll Rn */
1635 case 0x4020: /* shal Rn */
1636 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 31);
1637 tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 1);
1638 return;
1639 case 0x4021: /* shar Rn */
1640 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1641 tcg_gen_sari_i32(REG(B11_8), REG(B11_8), 1);
1642 return;
1643 case 0x4001: /* shlr Rn */
1644 gen_copy_bit_i32(cpu_sr, 0, REG(B11_8), 0);
1645 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 1);
1646 return;
1647 case 0x4008: /* shll2 Rn */
1648 tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 2);
1649 return;
1650 case 0x4018: /* shll8 Rn */
1651 tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 8);
1652 return;
1653 case 0x4028: /* shll16 Rn */
1654 tcg_gen_shli_i32(REG(B11_8), REG(B11_8), 16);
1655 return;
1656 case 0x4009: /* shlr2 Rn */
1657 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 2);
1658 return;
1659 case 0x4019: /* shlr8 Rn */
1660 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 8);
1661 return;
1662 case 0x4029: /* shlr16 Rn */
1663 tcg_gen_shri_i32(REG(B11_8), REG(B11_8), 16);
1664 return;
1665 case 0x401b: /* tas.b @Rn */
1666 {
1667 TCGv addr, val;
1668 addr = tcg_temp_local_new();
1669 tcg_gen_mov_i32(addr, REG(B11_8));
1670 val = tcg_temp_local_new();
1671 tcg_gen_qemu_ld_i32(val, addr, ctx->memidx, MO_UB);
1672 gen_cmp_imm(TCG_COND_EQ, val, 0);
1673 tcg_gen_ori_i32(val, val, 0x80);
1674 tcg_gen_qemu_st_i32(val, addr, ctx->memidx, MO_UB);
1675 tcg_temp_free(val);
1676 tcg_temp_free(addr);
1677 }
1678 return;
1679 case 0xf00d: /* fsts FPUL,FRn - FPSCR: Nothing */
1680 CHECK_FPU_ENABLED
1681 tcg_gen_mov_i32(cpu_fregs[FREG(B11_8)], cpu_fpul);
1682 return;
1683 case 0xf01d: /* flds FRm,FPUL - FPSCR: Nothing */
1684 CHECK_FPU_ENABLED
1685 tcg_gen_mov_i32(cpu_fpul, cpu_fregs[FREG(B11_8)]);
1686 return;
1687 case 0xf02d: /* float FPUL,FRn/DRn - FPSCR: R[PR,Enable.I]/W[Cause,Flag] */
1688 CHECK_FPU_ENABLED
1689 if (ctx->flags & FPSCR_PR) {
1690 TCGv_i64 fp;
1691 if (ctx->opcode & 0x0100)
1692 break; /* illegal instruction */
1693 fp = tcg_temp_new_i64();
1694 gen_helper_float_DT(fp, cpu_env, cpu_fpul);
1695 gen_store_fpr64(fp, DREG(B11_8));
1696 tcg_temp_free_i64(fp);
1697 }
1698 else {
1699 gen_helper_float_FT(cpu_fregs[FREG(B11_8)], cpu_env, cpu_fpul);
1700 }
1701 return;
1702 case 0xf03d: /* ftrc FRm/DRm,FPUL - FPSCR: R[PR,Enable.V]/W[Cause,Flag] */
1703 CHECK_FPU_ENABLED
1704 if (ctx->flags & FPSCR_PR) {
1705 TCGv_i64 fp;
1706 if (ctx->opcode & 0x0100)
1707 break; /* illegal instruction */
1708 fp = tcg_temp_new_i64();
1709 gen_load_fpr64(fp, DREG(B11_8));
1710 gen_helper_ftrc_DT(cpu_fpul, cpu_env, fp);
1711 tcg_temp_free_i64(fp);
1712 }
1713 else {
1714 gen_helper_ftrc_FT(cpu_fpul, cpu_env, cpu_fregs[FREG(B11_8)]);
1715 }
1716 return;
1717 case 0xf04d: /* fneg FRn/DRn - FPSCR: Nothing */
1718 CHECK_FPU_ENABLED
1719 {
1720 gen_helper_fneg_T(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)]);
1721 }
1722 return;
1723 case 0xf05d: /* fabs FRn/DRn */
1724 CHECK_FPU_ENABLED
1725 if (ctx->flags & FPSCR_PR) {
1726 if (ctx->opcode & 0x0100)
1727 break; /* illegal instruction */
1728 TCGv_i64 fp = tcg_temp_new_i64();
1729 gen_load_fpr64(fp, DREG(B11_8));
1730 gen_helper_fabs_DT(fp, fp);
1731 gen_store_fpr64(fp, DREG(B11_8));
1732 tcg_temp_free_i64(fp);
1733 } else {
1734 gen_helper_fabs_FT(cpu_fregs[FREG(B11_8)], cpu_fregs[FREG(B11_8)]);
1735 }
1736 return;
1737 case 0xf06d: /* fsqrt FRn */
1738 CHECK_FPU_ENABLED
1739 if (ctx->flags & FPSCR_PR) {
1740 if (ctx->opcode & 0x0100)
1741 break; /* illegal instruction */
1742 TCGv_i64 fp = tcg_temp_new_i64();
1743 gen_load_fpr64(fp, DREG(B11_8));
1744 gen_helper_fsqrt_DT(fp, cpu_env, fp);
1745 gen_store_fpr64(fp, DREG(B11_8));
1746 tcg_temp_free_i64(fp);
1747 } else {
1748 gen_helper_fsqrt_FT(cpu_fregs[FREG(B11_8)], cpu_env,
1749 cpu_fregs[FREG(B11_8)]);
1750 }
1751 return;
1752 case 0xf07d: /* fsrra FRn */
1753 CHECK_FPU_ENABLED
1754 break;
1755 case 0xf08d: /* fldi0 FRn - FPSCR: R[PR] */
1756 CHECK_FPU_ENABLED
1757 if (!(ctx->flags & FPSCR_PR)) {
1758 tcg_gen_movi_i32(cpu_fregs[FREG(B11_8)], 0);
1759 }
1760 return;
1761 case 0xf09d: /* fldi1 FRn - FPSCR: R[PR] */
1762 CHECK_FPU_ENABLED
1763 if (!(ctx->flags & FPSCR_PR)) {
1764 tcg_gen_movi_i32(cpu_fregs[FREG(B11_8)], 0x3f800000);
1765 }
1766 return;
1767 case 0xf0ad: /* fcnvsd FPUL,DRn */
1768 CHECK_FPU_ENABLED
1769 {
1770 TCGv_i64 fp = tcg_temp_new_i64();
1771 gen_helper_fcnvsd_FT_DT(fp, cpu_env, cpu_fpul);
1772 gen_store_fpr64(fp, DREG(B11_8));
1773 tcg_temp_free_i64(fp);
1774 }
1775 return;
1776 case 0xf0bd: /* fcnvds DRn,FPUL */
1777 CHECK_FPU_ENABLED
1778 {
1779 TCGv_i64 fp = tcg_temp_new_i64();
1780 gen_load_fpr64(fp, DREG(B11_8));
1781 gen_helper_fcnvds_DT_FT(cpu_fpul, cpu_env, fp);
1782 tcg_temp_free_i64(fp);
1783 }
1784 return;
1785 case 0xf0ed: /* fipr FVm,FVn */
1786 CHECK_FPU_ENABLED
1787 if ((ctx->flags & FPSCR_PR) == 0) {
1788 TCGv m, n;
1789 m = tcg_const_i32((ctx->opcode >> 8) & 3);
1790 n = tcg_const_i32((ctx->opcode >> 10) & 3);
1791 gen_helper_fipr(cpu_env, m, n);
1792 tcg_temp_free(m);
1793 tcg_temp_free(n);
1794 return;
1795 }
1796 break;
1797 case 0xf0fd: /* ftrv XMTRX,FVn */
1798 CHECK_FPU_ENABLED
1799 if ((ctx->opcode & 0x0300) == 0x0100 &&
1800 (ctx->flags & FPSCR_PR) == 0) {
1801 TCGv n;
1802 n = tcg_const_i32((ctx->opcode >> 10) & 3);
1803 gen_helper_ftrv(cpu_env, n);
1804 tcg_temp_free(n);
1805 return;
1806 }
1807 break;
1808 }
1809 #if 0
1810 fprintf(stderr, "unknown instruction 0x%04x at pc 0x%08x\n",
1811 ctx->opcode, ctx->pc);
1812 fflush(stderr);
1813 #endif
1814 tcg_gen_movi_i32(cpu_pc, ctx->pc);
1815 if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) {
1816 gen_helper_raise_slot_illegal_instruction(cpu_env);
1817 } else {
1818 gen_helper_raise_illegal_instruction(cpu_env);
1819 }
1820 ctx->bstate = BS_BRANCH;
1821 }
1822
1823 static void decode_opc(DisasContext * ctx)
1824 {
1825 uint32_t old_flags = ctx->flags;
1826
1827 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
1828 tcg_gen_debug_insn_start(ctx->pc);
1829 }
1830
1831 _decode_opc(ctx);
1832
1833 if (old_flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL)) {
1834 if (ctx->flags & DELAY_SLOT_CLEARME) {
1835 gen_store_flags(0);
1836 } else {
1837 /* go out of the delay slot */
1838 uint32_t new_flags = ctx->flags;
1839 new_flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
1840 gen_store_flags(new_flags);
1841 }
1842 ctx->flags = 0;
1843 ctx->bstate = BS_BRANCH;
1844 if (old_flags & DELAY_SLOT_CONDITIONAL) {
1845 gen_delayed_conditional_jump(ctx);
1846 } else if (old_flags & DELAY_SLOT) {
1847 gen_jump(ctx);
1848 }
1849
1850 }
1851
1852 /* go into a delay slot */
1853 if (ctx->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL))
1854 gen_store_flags(ctx->flags);
1855 }
1856
1857 static inline void
1858 gen_intermediate_code_internal(SuperHCPU *cpu, TranslationBlock *tb,
1859 bool search_pc)
1860 {
1861 CPUState *cs = CPU(cpu);
1862 CPUSH4State *env = &cpu->env;
1863 DisasContext ctx;
1864 target_ulong pc_start;
1865 static uint16_t *gen_opc_end;
1866 CPUBreakpoint *bp;
1867 int i, ii;
1868 int num_insns;
1869 int max_insns;
1870
1871 pc_start = tb->pc;
1872 gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
1873 ctx.pc = pc_start;
1874 ctx.flags = (uint32_t)tb->flags;
1875 ctx.bstate = BS_NONE;
1876 ctx.memidx = (ctx.flags & SR_MD) == 0 ? 1 : 0;
1877 /* We don't know if the delayed pc came from a dynamic or static branch,
1878 so assume it is a dynamic branch. */
1879 ctx.delayed_pc = -1; /* use delayed pc from env pointer */
1880 ctx.tb = tb;
1881 ctx.singlestep_enabled = cs->singlestep_enabled;
1882 ctx.features = env->features;
1883 ctx.has_movcal = (ctx.flags & TB_FLAG_PENDING_MOVCA);
1884
1885 ii = -1;
1886 num_insns = 0;
1887 max_insns = tb->cflags & CF_COUNT_MASK;
1888 if (max_insns == 0)
1889 max_insns = CF_COUNT_MASK;
1890 gen_tb_start();
1891 while (ctx.bstate == BS_NONE && tcg_ctx.gen_opc_ptr < gen_opc_end) {
1892 if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
1893 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1894 if (ctx.pc == bp->pc) {
1895 /* We have hit a breakpoint - make sure PC is up-to-date */
1896 tcg_gen_movi_i32(cpu_pc, ctx.pc);
1897 gen_helper_debug(cpu_env);
1898 ctx.bstate = BS_BRANCH;
1899 break;
1900 }
1901 }
1902 }
1903 if (search_pc) {
1904 i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
1905 if (ii < i) {
1906 ii++;
1907 while (ii < i)
1908 tcg_ctx.gen_opc_instr_start[ii++] = 0;
1909 }
1910 tcg_ctx.gen_opc_pc[ii] = ctx.pc;
1911 gen_opc_hflags[ii] = ctx.flags;
1912 tcg_ctx.gen_opc_instr_start[ii] = 1;
1913 tcg_ctx.gen_opc_icount[ii] = num_insns;
1914 }
1915 if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
1916 gen_io_start();
1917 #if 0
1918 fprintf(stderr, "Loading opcode at address 0x%08x\n", ctx.pc);
1919 fflush(stderr);
1920 #endif
1921 ctx.opcode = cpu_lduw_code(env, ctx.pc);
1922 decode_opc(&ctx);
1923 num_insns++;
1924 ctx.pc += 2;
1925 if ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0)
1926 break;
1927 if (cs->singlestep_enabled) {
1928 break;
1929 }
1930 if (num_insns >= max_insns)
1931 break;
1932 if (singlestep)
1933 break;
1934 }
1935 if (tb->cflags & CF_LAST_IO)
1936 gen_io_end();
1937 if (cs->singlestep_enabled) {
1938 tcg_gen_movi_i32(cpu_pc, ctx.pc);
1939 gen_helper_debug(cpu_env);
1940 } else {
1941 switch (ctx.bstate) {
1942 case BS_STOP:
1943 /* gen_op_interrupt_restart(); */
1944 /* fall through */
1945 case BS_NONE:
1946 if (ctx.flags) {
1947 gen_store_flags(ctx.flags | DELAY_SLOT_CLEARME);
1948 }
1949 gen_goto_tb(&ctx, 0, ctx.pc);
1950 break;
1951 case BS_EXCP:
1952 /* gen_op_interrupt_restart(); */
1953 tcg_gen_exit_tb(0);
1954 break;
1955 case BS_BRANCH:
1956 default:
1957 break;
1958 }
1959 }
1960
1961 gen_tb_end(tb, num_insns);
1962 *tcg_ctx.gen_opc_ptr = INDEX_op_end;
1963 if (search_pc) {
1964 i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
1965 ii++;
1966 while (ii <= i)
1967 tcg_ctx.gen_opc_instr_start[ii++] = 0;
1968 } else {
1969 tb->size = ctx.pc - pc_start;
1970 tb->icount = num_insns;
1971 }
1972
1973 #ifdef DEBUG_DISAS
1974 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
1975 qemu_log("IN:\n"); /* , lookup_symbol(pc_start)); */
1976 log_target_disas(env, pc_start, ctx.pc - pc_start, 0);
1977 qemu_log("\n");
1978 }
1979 #endif
1980 }
1981
1982 void gen_intermediate_code(CPUSH4State * env, struct TranslationBlock *tb)
1983 {
1984 gen_intermediate_code_internal(sh_env_get_cpu(env), tb, false);
1985 }
1986
1987 void gen_intermediate_code_pc(CPUSH4State * env, struct TranslationBlock *tb)
1988 {
1989 gen_intermediate_code_internal(sh_env_get_cpu(env), tb, true);
1990 }
1991
1992 void restore_state_to_opc(CPUSH4State *env, TranslationBlock *tb, int pc_pos)
1993 {
1994 env->pc = tcg_ctx.gen_opc_pc[pc_pos];
1995 env->flags = gen_opc_hflags[pc_pos];
1996 }
AR7 emulation for QEMU