?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qapi: add qapi-visit.py code generator
[qemu/aliguori.git] / target-alpha / translate.c
blobc61906a8b38160a898230ee23a04fa790be139c2
1 /*
2 * Alpha emulation cpu translation for qemu.
3 *
4 * Copyright (c) 2007 Jocelyn Mayer
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 #include <stdint.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23
24 #include "cpu.h"
25 #include "disas.h"
26 #include "host-utils.h"
27 #include "tcg-op.h"
28 #include "qemu-common.h"
29
30 #include "helper.h"
31 #define GEN_HELPER 1
32 #include "helper.h"
33
34 #undef ALPHA_DEBUG_DISAS
35 #define CONFIG_SOFTFLOAT_INLINE
36
37 #ifdef ALPHA_DEBUG_DISAS
38 # define LOG_DISAS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
39 #else
40 # define LOG_DISAS(...) do { } while (0)
41 #endif
42
43 typedef struct DisasContext DisasContext;
44 struct DisasContext {
45 struct TranslationBlock *tb;
46 CPUAlphaState *env;
47 uint64_t pc;
48 int mem_idx;
49
50 /* Current rounding mode for this TB. */
51 int tb_rm;
52 /* Current flush-to-zero setting for this TB. */
53 int tb_ftz;
54 };
55
56 /* Return values from translate_one, indicating the state of the TB.
57 Note that zero indicates that we are not exiting the TB. */
58
59 typedef enum {
60 NO_EXIT,
61
62 /* We have emitted one or more goto_tb. No fixup required. */
63 EXIT_GOTO_TB,
64
65 /* We are not using a goto_tb (for whatever reason), but have updated
66 the PC (for whatever reason), so there's no need to do it again on
67 exiting the TB. */
68 EXIT_PC_UPDATED,
69
70 /* We are exiting the TB, but have neither emitted a goto_tb, nor
71 updated the PC for the next instruction to be executed. */
72 EXIT_PC_STALE,
73
74 /* We are ending the TB with a noreturn function call, e.g. longjmp.
75 No following code will be executed. */
76 EXIT_NORETURN,
77 } ExitStatus;
78
79 /* global register indexes */
80 static TCGv_ptr cpu_env;
81 static TCGv cpu_ir[31];
82 static TCGv cpu_fir[31];
83 static TCGv cpu_pc;
84 static TCGv cpu_lock_addr;
85 static TCGv cpu_lock_st_addr;
86 static TCGv cpu_lock_value;
87 static TCGv cpu_unique;
88 #ifndef CONFIG_USER_ONLY
89 static TCGv cpu_sysval;
90 static TCGv cpu_usp;
91 #endif
92
93 /* register names */
94 static char cpu_reg_names[10*4+21*5 + 10*5+21*6];
95
96 #include "gen-icount.h"
97
98 static void alpha_translate_init(void)
99 {
100 int i;
101 char *p;
102 static int done_init = 0;
103
104 if (done_init)
105 return;
106
107 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
108
109 p = cpu_reg_names;
110 for (i = 0; i < 31; i++) {
111 sprintf(p, "ir%d", i);
112 cpu_ir[i] = tcg_global_mem_new_i64(TCG_AREG0,
113 offsetof(CPUState, ir[i]), p);
114 p += (i < 10) ? 4 : 5;
115
116 sprintf(p, "fir%d", i);
117 cpu_fir[i] = tcg_global_mem_new_i64(TCG_AREG0,
118 offsetof(CPUState, fir[i]), p);
119 p += (i < 10) ? 5 : 6;
120 }
121
122 cpu_pc = tcg_global_mem_new_i64(TCG_AREG0,
123 offsetof(CPUState, pc), "pc");
124
125 cpu_lock_addr = tcg_global_mem_new_i64(TCG_AREG0,
126 offsetof(CPUState, lock_addr),
127 "lock_addr");
128 cpu_lock_st_addr = tcg_global_mem_new_i64(TCG_AREG0,
129 offsetof(CPUState, lock_st_addr),
130 "lock_st_addr");
131 cpu_lock_value = tcg_global_mem_new_i64(TCG_AREG0,
132 offsetof(CPUState, lock_value),
133 "lock_value");
134
135 cpu_unique = tcg_global_mem_new_i64(TCG_AREG0,
136 offsetof(CPUState, unique), "unique");
137 #ifndef CONFIG_USER_ONLY
138 cpu_sysval = tcg_global_mem_new_i64(TCG_AREG0,
139 offsetof(CPUState, sysval), "sysval");
140 cpu_usp = tcg_global_mem_new_i64(TCG_AREG0,
141 offsetof(CPUState, usp), "usp");
142 #endif
143
144 /* register helpers */
145 #define GEN_HELPER 2
146 #include "helper.h"
147
148 done_init = 1;
149 }
150
151 static void gen_excp_1(int exception, int error_code)
152 {
153 TCGv_i32 tmp1, tmp2;
154
155 tmp1 = tcg_const_i32(exception);
156 tmp2 = tcg_const_i32(error_code);
157 gen_helper_excp(tmp1, tmp2);
158 tcg_temp_free_i32(tmp2);
159 tcg_temp_free_i32(tmp1);
160 }
161
162 static ExitStatus gen_excp(DisasContext *ctx, int exception, int error_code)
163 {
164 tcg_gen_movi_i64(cpu_pc, ctx->pc);
165 gen_excp_1(exception, error_code);
166 return EXIT_NORETURN;
167 }
168
169 static inline ExitStatus gen_invalid(DisasContext *ctx)
170 {
171 return gen_excp(ctx, EXCP_OPCDEC, 0);
172 }
173
174 static inline void gen_qemu_ldf(TCGv t0, TCGv t1, int flags)
175 {
176 TCGv tmp = tcg_temp_new();
177 TCGv_i32 tmp32 = tcg_temp_new_i32();
178 tcg_gen_qemu_ld32u(tmp, t1, flags);
179 tcg_gen_trunc_i64_i32(tmp32, tmp);
180 gen_helper_memory_to_f(t0, tmp32);
181 tcg_temp_free_i32(tmp32);
182 tcg_temp_free(tmp);
183 }
184
185 static inline void gen_qemu_ldg(TCGv t0, TCGv t1, int flags)
186 {
187 TCGv tmp = tcg_temp_new();
188 tcg_gen_qemu_ld64(tmp, t1, flags);
189 gen_helper_memory_to_g(t0, tmp);
190 tcg_temp_free(tmp);
191 }
192
193 static inline void gen_qemu_lds(TCGv t0, TCGv t1, int flags)
194 {
195 TCGv tmp = tcg_temp_new();
196 TCGv_i32 tmp32 = tcg_temp_new_i32();
197 tcg_gen_qemu_ld32u(tmp, t1, flags);
198 tcg_gen_trunc_i64_i32(tmp32, tmp);
199 gen_helper_memory_to_s(t0, tmp32);
200 tcg_temp_free_i32(tmp32);
201 tcg_temp_free(tmp);
202 }
203
204 static inline void gen_qemu_ldl_l(TCGv t0, TCGv t1, int flags)
205 {
206 tcg_gen_qemu_ld32s(t0, t1, flags);
207 tcg_gen_mov_i64(cpu_lock_addr, t1);
208 tcg_gen_mov_i64(cpu_lock_value, t0);
209 }
210
211 static inline void gen_qemu_ldq_l(TCGv t0, TCGv t1, int flags)
212 {
213 tcg_gen_qemu_ld64(t0, t1, flags);
214 tcg_gen_mov_i64(cpu_lock_addr, t1);
215 tcg_gen_mov_i64(cpu_lock_value, t0);
216 }
217
218 static inline void gen_load_mem(DisasContext *ctx,
219 void (*tcg_gen_qemu_load)(TCGv t0, TCGv t1,
220 int flags),
221 int ra, int rb, int32_t disp16, int fp,
222 int clear)
223 {
224 TCGv addr, va;
225
226 /* LDQ_U with ra $31 is UNOP. Other various loads are forms of
227 prefetches, which we can treat as nops. No worries about
228 missed exceptions here. */
229 if (unlikely(ra == 31)) {
230 return;
231 }
232
233 addr = tcg_temp_new();
234 if (rb != 31) {
235 tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
236 if (clear) {
237 tcg_gen_andi_i64(addr, addr, ~0x7);
238 }
239 } else {
240 if (clear) {
241 disp16 &= ~0x7;
242 }
243 tcg_gen_movi_i64(addr, disp16);
244 }
245
246 va = (fp ? cpu_fir[ra] : cpu_ir[ra]);
247 tcg_gen_qemu_load(va, addr, ctx->mem_idx);
248
249 tcg_temp_free(addr);
250 }
251
252 static inline void gen_qemu_stf(TCGv t0, TCGv t1, int flags)
253 {
254 TCGv_i32 tmp32 = tcg_temp_new_i32();
255 TCGv tmp = tcg_temp_new();
256 gen_helper_f_to_memory(tmp32, t0);
257 tcg_gen_extu_i32_i64(tmp, tmp32);
258 tcg_gen_qemu_st32(tmp, t1, flags);
259 tcg_temp_free(tmp);
260 tcg_temp_free_i32(tmp32);
261 }
262
263 static inline void gen_qemu_stg(TCGv t0, TCGv t1, int flags)
264 {
265 TCGv tmp = tcg_temp_new();
266 gen_helper_g_to_memory(tmp, t0);
267 tcg_gen_qemu_st64(tmp, t1, flags);
268 tcg_temp_free(tmp);
269 }
270
271 static inline void gen_qemu_sts(TCGv t0, TCGv t1, int flags)
272 {
273 TCGv_i32 tmp32 = tcg_temp_new_i32();
274 TCGv tmp = tcg_temp_new();
275 gen_helper_s_to_memory(tmp32, t0);
276 tcg_gen_extu_i32_i64(tmp, tmp32);
277 tcg_gen_qemu_st32(tmp, t1, flags);
278 tcg_temp_free(tmp);
279 tcg_temp_free_i32(tmp32);
280 }
281
282 static inline void gen_store_mem(DisasContext *ctx,
283 void (*tcg_gen_qemu_store)(TCGv t0, TCGv t1,
284 int flags),
285 int ra, int rb, int32_t disp16, int fp,
286 int clear)
287 {
288 TCGv addr, va;
289
290 addr = tcg_temp_new();
291 if (rb != 31) {
292 tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
293 if (clear) {
294 tcg_gen_andi_i64(addr, addr, ~0x7);
295 }
296 } else {
297 if (clear) {
298 disp16 &= ~0x7;
299 }
300 tcg_gen_movi_i64(addr, disp16);
301 }
302
303 if (ra == 31) {
304 va = tcg_const_i64(0);
305 } else {
306 va = (fp ? cpu_fir[ra] : cpu_ir[ra]);
307 }
308 tcg_gen_qemu_store(va, addr, ctx->mem_idx);
309
310 tcg_temp_free(addr);
311 if (ra == 31) {
312 tcg_temp_free(va);
313 }
314 }
315
316 static ExitStatus gen_store_conditional(DisasContext *ctx, int ra, int rb,
317 int32_t disp16, int quad)
318 {
319 TCGv addr;
320
321 if (ra == 31) {
322 /* ??? Don't bother storing anything. The user can't tell
323 the difference, since the zero register always reads zero. */
324 return NO_EXIT;
325 }
326
327 #if defined(CONFIG_USER_ONLY)
328 addr = cpu_lock_st_addr;
329 #else
330 addr = tcg_temp_local_new();
331 #endif
332
333 if (rb != 31) {
334 tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
335 } else {
336 tcg_gen_movi_i64(addr, disp16);
337 }
338
339 #if defined(CONFIG_USER_ONLY)
340 /* ??? This is handled via a complicated version of compare-and-swap
341 in the cpu_loop. Hopefully one day we'll have a real CAS opcode
342 in TCG so that this isn't necessary. */
343 return gen_excp(ctx, quad ? EXCP_STQ_C : EXCP_STL_C, ra);
344 #else
345 /* ??? In system mode we are never multi-threaded, so CAS can be
346 implemented via a non-atomic load-compare-store sequence. */
347 {
348 int lab_fail, lab_done;
349 TCGv val;
350
351 lab_fail = gen_new_label();
352 lab_done = gen_new_label();
353 tcg_gen_brcond_i64(TCG_COND_NE, addr, cpu_lock_addr, lab_fail);
354
355 val = tcg_temp_new();
356 if (quad) {
357 tcg_gen_qemu_ld64(val, addr, ctx->mem_idx);
358 } else {
359 tcg_gen_qemu_ld32s(val, addr, ctx->mem_idx);
360 }
361 tcg_gen_brcond_i64(TCG_COND_NE, val, cpu_lock_value, lab_fail);
362
363 if (quad) {
364 tcg_gen_qemu_st64(cpu_ir[ra], addr, ctx->mem_idx);
365 } else {
366 tcg_gen_qemu_st32(cpu_ir[ra], addr, ctx->mem_idx);
367 }
368 tcg_gen_movi_i64(cpu_ir[ra], 1);
369 tcg_gen_br(lab_done);
370
371 gen_set_label(lab_fail);
372 tcg_gen_movi_i64(cpu_ir[ra], 0);
373
374 gen_set_label(lab_done);
375 tcg_gen_movi_i64(cpu_lock_addr, -1);
376
377 tcg_temp_free(addr);
378 return NO_EXIT;
379 }
380 #endif
381 }
382
383 static int use_goto_tb(DisasContext *ctx, uint64_t dest)
384 {
385 /* Check for the dest on the same page as the start of the TB. We
386 also want to suppress goto_tb in the case of single-steping and IO. */
387 return (((ctx->tb->pc ^ dest) & TARGET_PAGE_MASK) == 0
388 && !ctx->env->singlestep_enabled
389 && !(ctx->tb->cflags & CF_LAST_IO));
390 }
391
392 static ExitStatus gen_bdirect(DisasContext *ctx, int ra, int32_t disp)
393 {
394 uint64_t dest = ctx->pc + (disp << 2);
395
396 if (ra != 31) {
397 tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
398 }
399
400 /* Notice branch-to-next; used to initialize RA with the PC. */
401 if (disp == 0) {
402 return 0;
403 } else if (use_goto_tb(ctx, dest)) {
404 tcg_gen_goto_tb(0);
405 tcg_gen_movi_i64(cpu_pc, dest);
406 tcg_gen_exit_tb((tcg_target_long)ctx->tb);
407 return EXIT_GOTO_TB;
408 } else {
409 tcg_gen_movi_i64(cpu_pc, dest);
410 return EXIT_PC_UPDATED;
411 }
412 }
413
414 static ExitStatus gen_bcond_internal(DisasContext *ctx, TCGCond cond,
415 TCGv cmp, int32_t disp)
416 {
417 uint64_t dest = ctx->pc + (disp << 2);
418 int lab_true = gen_new_label();
419
420 if (use_goto_tb(ctx, dest)) {
421 tcg_gen_brcondi_i64(cond, cmp, 0, lab_true);
422
423 tcg_gen_goto_tb(0);
424 tcg_gen_movi_i64(cpu_pc, ctx->pc);
425 tcg_gen_exit_tb((tcg_target_long)ctx->tb);
426
427 gen_set_label(lab_true);
428 tcg_gen_goto_tb(1);
429 tcg_gen_movi_i64(cpu_pc, dest);
430 tcg_gen_exit_tb((tcg_target_long)ctx->tb + 1);
431
432 return EXIT_GOTO_TB;
433 } else {
434 int lab_over = gen_new_label();
435
436 /* ??? Consider using either
437 movi pc, next
438 addi tmp, pc, disp
439 movcond pc, cond, 0, tmp, pc
440 or
441 setcond tmp, cond, 0
442 movi pc, next
443 neg tmp, tmp
444 andi tmp, tmp, disp
445 add pc, pc, tmp
446 The current diamond subgraph surely isn't efficient. */
447
448 tcg_gen_brcondi_i64(cond, cmp, 0, lab_true);
449 tcg_gen_movi_i64(cpu_pc, ctx->pc);
450 tcg_gen_br(lab_over);
451 gen_set_label(lab_true);
452 tcg_gen_movi_i64(cpu_pc, dest);
453 gen_set_label(lab_over);
454
455 return EXIT_PC_UPDATED;
456 }
457 }
458
459 static ExitStatus gen_bcond(DisasContext *ctx, TCGCond cond, int ra,
460 int32_t disp, int mask)
461 {
462 TCGv cmp_tmp;
463
464 if (unlikely(ra == 31)) {
465 cmp_tmp = tcg_const_i64(0);
466 } else {
467 cmp_tmp = tcg_temp_new();
468 if (mask) {
469 tcg_gen_andi_i64(cmp_tmp, cpu_ir[ra], 1);
470 } else {
471 tcg_gen_mov_i64(cmp_tmp, cpu_ir[ra]);
472 }
473 }
474
475 return gen_bcond_internal(ctx, cond, cmp_tmp, disp);
476 }
477
478 /* Fold -0.0 for comparison with COND. */
479
480 static void gen_fold_mzero(TCGCond cond, TCGv dest, TCGv src)
481 {
482 uint64_t mzero = 1ull << 63;
483
484 switch (cond) {
485 case TCG_COND_LE:
486 case TCG_COND_GT:
487 /* For <= or >, the -0.0 value directly compares the way we want. */
488 tcg_gen_mov_i64(dest, src);
489 break;
490
491 case TCG_COND_EQ:
492 case TCG_COND_NE:
493 /* For == or !=, we can simply mask off the sign bit and compare. */
494 tcg_gen_andi_i64(dest, src, mzero - 1);
495 break;
496
497 case TCG_COND_GE:
498 case TCG_COND_LT:
499 /* For >= or <, map -0.0 to +0.0 via comparison and mask. */
500 tcg_gen_setcondi_i64(TCG_COND_NE, dest, src, mzero);
501 tcg_gen_neg_i64(dest, dest);
502 tcg_gen_and_i64(dest, dest, src);
503 break;
504
505 default:
506 abort();
507 }
508 }
509
510 static ExitStatus gen_fbcond(DisasContext *ctx, TCGCond cond, int ra,
511 int32_t disp)
512 {
513 TCGv cmp_tmp;
514
515 if (unlikely(ra == 31)) {
516 /* Very uncommon case, but easier to optimize it to an integer
517 comparison than continuing with the floating point comparison. */
518 return gen_bcond(ctx, cond, ra, disp, 0);
519 }
520
521 cmp_tmp = tcg_temp_new();
522 gen_fold_mzero(cond, cmp_tmp, cpu_fir[ra]);
523 return gen_bcond_internal(ctx, cond, cmp_tmp, disp);
524 }
525
526 static void gen_cmov(TCGCond cond, int ra, int rb, int rc,
527 int islit, uint8_t lit, int mask)
528 {
529 TCGCond inv_cond = tcg_invert_cond(cond);
530 int l1;
531
532 if (unlikely(rc == 31))
533 return;
534
535 l1 = gen_new_label();
536
537 if (ra != 31) {
538 if (mask) {
539 TCGv tmp = tcg_temp_new();
540 tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);
541 tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
542 tcg_temp_free(tmp);
543 } else
544 tcg_gen_brcondi_i64(inv_cond, cpu_ir[ra], 0, l1);
545 } else {
546 /* Very uncommon case - Do not bother to optimize. */
547 TCGv tmp = tcg_const_i64(0);
548 tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
549 tcg_temp_free(tmp);
550 }
551
552 if (islit)
553 tcg_gen_movi_i64(cpu_ir[rc], lit);
554 else
555 tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
556 gen_set_label(l1);
557 }
558
559 static void gen_fcmov(TCGCond cond, int ra, int rb, int rc)
560 {
561 TCGv cmp_tmp;
562 int l1;
563
564 if (unlikely(rc == 31)) {
565 return;
566 }
567
568 cmp_tmp = tcg_temp_new();
569 if (unlikely(ra == 31)) {
570 tcg_gen_movi_i64(cmp_tmp, 0);
571 } else {
572 gen_fold_mzero(cond, cmp_tmp, cpu_fir[ra]);
573 }
574
575 l1 = gen_new_label();
576 tcg_gen_brcondi_i64(tcg_invert_cond(cond), cmp_tmp, 0, l1);
577 tcg_temp_free(cmp_tmp);
578
579 if (rb != 31)
580 tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[rb]);
581 else
582 tcg_gen_movi_i64(cpu_fir[rc], 0);
583 gen_set_label(l1);
584 }
585
586 #define QUAL_RM_N 0x080 /* Round mode nearest even */
587 #define QUAL_RM_C 0x000 /* Round mode chopped */
588 #define QUAL_RM_M 0x040 /* Round mode minus infinity */
589 #define QUAL_RM_D 0x0c0 /* Round mode dynamic */
590 #define QUAL_RM_MASK 0x0c0
591
592 #define QUAL_U 0x100 /* Underflow enable (fp output) */
593 #define QUAL_V 0x100 /* Overflow enable (int output) */
594 #define QUAL_S 0x400 /* Software completion enable */
595 #define QUAL_I 0x200 /* Inexact detection enable */
596
597 static void gen_qual_roundmode(DisasContext *ctx, int fn11)
598 {
599 TCGv_i32 tmp;
600
601 fn11 &= QUAL_RM_MASK;
602 if (fn11 == ctx->tb_rm) {
603 return;
604 }
605 ctx->tb_rm = fn11;
606
607 tmp = tcg_temp_new_i32();
608 switch (fn11) {
609 case QUAL_RM_N:
610 tcg_gen_movi_i32(tmp, float_round_nearest_even);
611 break;
612 case QUAL_RM_C:
613 tcg_gen_movi_i32(tmp, float_round_to_zero);
614 break;
615 case QUAL_RM_M:
616 tcg_gen_movi_i32(tmp, float_round_down);
617 break;
618 case QUAL_RM_D:
619 tcg_gen_ld8u_i32(tmp, cpu_env, offsetof(CPUState, fpcr_dyn_round));
620 break;
621 }
622
623 #if defined(CONFIG_SOFTFLOAT_INLINE)
624 /* ??? The "softfloat.h" interface is to call set_float_rounding_mode.
625 With CONFIG_SOFTFLOAT that expands to an out-of-line call that just
626 sets the one field. */
627 tcg_gen_st8_i32(tmp, cpu_env,
628 offsetof(CPUState, fp_status.float_rounding_mode));
629 #else
630 gen_helper_setroundmode(tmp);
631 #endif
632
633 tcg_temp_free_i32(tmp);
634 }
635
636 static void gen_qual_flushzero(DisasContext *ctx, int fn11)
637 {
638 TCGv_i32 tmp;
639
640 fn11 &= QUAL_U;
641 if (fn11 == ctx->tb_ftz) {
642 return;
643 }
644 ctx->tb_ftz = fn11;
645
646 tmp = tcg_temp_new_i32();
647 if (fn11) {
648 /* Underflow is enabled, use the FPCR setting. */
649 tcg_gen_ld8u_i32(tmp, cpu_env, offsetof(CPUState, fpcr_flush_to_zero));
650 } else {
651 /* Underflow is disabled, force flush-to-zero. */
652 tcg_gen_movi_i32(tmp, 1);
653 }
654
655 #if defined(CONFIG_SOFTFLOAT_INLINE)
656 tcg_gen_st8_i32(tmp, cpu_env,
657 offsetof(CPUState, fp_status.flush_to_zero));
658 #else
659 gen_helper_setflushzero(tmp);
660 #endif
661
662 tcg_temp_free_i32(tmp);
663 }
664
665 static TCGv gen_ieee_input(int reg, int fn11, int is_cmp)
666 {
667 TCGv val = tcg_temp_new();
668 if (reg == 31) {
669 tcg_gen_movi_i64(val, 0);
670 } else if (fn11 & QUAL_S) {
671 gen_helper_ieee_input_s(val, cpu_fir[reg]);
672 } else if (is_cmp) {
673 gen_helper_ieee_input_cmp(val, cpu_fir[reg]);
674 } else {
675 gen_helper_ieee_input(val, cpu_fir[reg]);
676 }
677 return val;
678 }
679
680 static void gen_fp_exc_clear(void)
681 {
682 #if defined(CONFIG_SOFTFLOAT_INLINE)
683 TCGv_i32 zero = tcg_const_i32(0);
684 tcg_gen_st8_i32(zero, cpu_env,
685 offsetof(CPUState, fp_status.float_exception_flags));
686 tcg_temp_free_i32(zero);
687 #else
688 gen_helper_fp_exc_clear();
689 #endif
690 }
691
692 static void gen_fp_exc_raise_ignore(int rc, int fn11, int ignore)
693 {
694 /* ??? We ought to be able to do something with imprecise exceptions.
695 E.g. notice we're still in the trap shadow of something within the
696 TB and do not generate the code to signal the exception; end the TB
697 when an exception is forced to arrive, either by consumption of a
698 register value or TRAPB or EXCB. */
699 TCGv_i32 exc = tcg_temp_new_i32();
700 TCGv_i32 reg;
701
702 #if defined(CONFIG_SOFTFLOAT_INLINE)
703 tcg_gen_ld8u_i32(exc, cpu_env,
704 offsetof(CPUState, fp_status.float_exception_flags));
705 #else
706 gen_helper_fp_exc_get(exc);
707 #endif
708
709 if (ignore) {
710 tcg_gen_andi_i32(exc, exc, ~ignore);
711 }
712
713 /* ??? Pass in the regno of the destination so that the helper can
714 set EXC_MASK, which contains a bitmask of destination registers
715 that have caused arithmetic traps. A simple userspace emulation
716 does not require this. We do need it for a guest kernel's entArith,
717 or if we were to do something clever with imprecise exceptions. */
718 reg = tcg_const_i32(rc + 32);
719
720 if (fn11 & QUAL_S) {
721 gen_helper_fp_exc_raise_s(exc, reg);
722 } else {
723 gen_helper_fp_exc_raise(exc, reg);
724 }
725
726 tcg_temp_free_i32(reg);
727 tcg_temp_free_i32(exc);
728 }
729
730 static inline void gen_fp_exc_raise(int rc, int fn11)
731 {
732 gen_fp_exc_raise_ignore(rc, fn11, fn11 & QUAL_I ? 0 : float_flag_inexact);
733 }
734
735 static void gen_fcvtlq(int rb, int rc)
736 {
737 if (unlikely(rc == 31)) {
738 return;
739 }
740 if (unlikely(rb == 31)) {
741 tcg_gen_movi_i64(cpu_fir[rc], 0);
742 } else {
743 TCGv tmp = tcg_temp_new();
744
745 /* The arithmetic right shift here, plus the sign-extended mask below
746 yields a sign-extended result without an explicit ext32s_i64. */
747 tcg_gen_sari_i64(tmp, cpu_fir[rb], 32);
748 tcg_gen_shri_i64(cpu_fir[rc], cpu_fir[rb], 29);
749 tcg_gen_andi_i64(tmp, tmp, (int32_t)0xc0000000);
750 tcg_gen_andi_i64(cpu_fir[rc], cpu_fir[rc], 0x3fffffff);
751 tcg_gen_or_i64(cpu_fir[rc], cpu_fir[rc], tmp);
752
753 tcg_temp_free(tmp);
754 }
755 }
756
757 static void gen_fcvtql(int rb, int rc)
758 {
759 if (unlikely(rc == 31)) {
760 return;
761 }
762 if (unlikely(rb == 31)) {
763 tcg_gen_movi_i64(cpu_fir[rc], 0);
764 } else {
765 TCGv tmp = tcg_temp_new();
766
767 tcg_gen_andi_i64(tmp, cpu_fir[rb], 0xC0000000);
768 tcg_gen_andi_i64(cpu_fir[rc], cpu_fir[rb], 0x3FFFFFFF);
769 tcg_gen_shli_i64(tmp, tmp, 32);
770 tcg_gen_shli_i64(cpu_fir[rc], cpu_fir[rc], 29);
771 tcg_gen_or_i64(cpu_fir[rc], cpu_fir[rc], tmp);
772
773 tcg_temp_free(tmp);
774 }
775 }
776
777 static void gen_fcvtql_v(DisasContext *ctx, int rb, int rc)
778 {
779 if (rb != 31) {
780 int lab = gen_new_label();
781 TCGv tmp = tcg_temp_new();
782
783 tcg_gen_ext32s_i64(tmp, cpu_fir[rb]);
784 tcg_gen_brcond_i64(TCG_COND_EQ, tmp, cpu_fir[rb], lab);
785 gen_excp(ctx, EXCP_ARITH, EXC_M_IOV);
786
787 gen_set_label(lab);
788 }
789 gen_fcvtql(rb, rc);
790 }
791
792 #define FARITH2(name) \
793 static inline void glue(gen_f, name)(int rb, int rc) \
794 { \
795 if (unlikely(rc == 31)) { \
796 return; \
797 } \
798 if (rb != 31) { \
799 gen_helper_ ## name (cpu_fir[rc], cpu_fir[rb]); \
800 } else { \
801 TCGv tmp = tcg_const_i64(0); \
802 gen_helper_ ## name (cpu_fir[rc], tmp); \
803 tcg_temp_free(tmp); \
804 } \
805 }
806
807 /* ??? VAX instruction qualifiers ignored. */
808 FARITH2(sqrtf)
809 FARITH2(sqrtg)
810 FARITH2(cvtgf)
811 FARITH2(cvtgq)
812 FARITH2(cvtqf)
813 FARITH2(cvtqg)
814
815 static void gen_ieee_arith2(DisasContext *ctx, void (*helper)(TCGv, TCGv),
816 int rb, int rc, int fn11)
817 {
818 TCGv vb;
819
820 /* ??? This is wrong: the instruction is not a nop, it still may
821 raise exceptions. */
822 if (unlikely(rc == 31)) {
823 return;
824 }
825
826 gen_qual_roundmode(ctx, fn11);
827 gen_qual_flushzero(ctx, fn11);
828 gen_fp_exc_clear();
829
830 vb = gen_ieee_input(rb, fn11, 0);
831 helper(cpu_fir[rc], vb);
832 tcg_temp_free(vb);
833
834 gen_fp_exc_raise(rc, fn11);
835 }
836
837 #define IEEE_ARITH2(name) \
838 static inline void glue(gen_f, name)(DisasContext *ctx, \
839 int rb, int rc, int fn11) \
840 { \
841 gen_ieee_arith2(ctx, gen_helper_##name, rb, rc, fn11); \
842 }
843 IEEE_ARITH2(sqrts)
844 IEEE_ARITH2(sqrtt)
845 IEEE_ARITH2(cvtst)
846 IEEE_ARITH2(cvtts)
847
848 static void gen_fcvttq(DisasContext *ctx, int rb, int rc, int fn11)
849 {
850 TCGv vb;
851 int ignore = 0;
852
853 /* ??? This is wrong: the instruction is not a nop, it still may
854 raise exceptions. */
855 if (unlikely(rc == 31)) {
856 return;
857 }
858
859 /* No need to set flushzero, since we have an integer output. */
860 gen_fp_exc_clear();
861 vb = gen_ieee_input(rb, fn11, 0);
862
863 /* Almost all integer conversions use cropped rounding, and most
864 also do not have integer overflow enabled. Special case that. */
865 switch (fn11) {
866 case QUAL_RM_C:
867 gen_helper_cvttq_c(cpu_fir[rc], vb);
868 break;
869 case QUAL_V | QUAL_RM_C:
870 case QUAL_S | QUAL_V | QUAL_RM_C:
871 ignore = float_flag_inexact;
872 /* FALLTHRU */
873 case QUAL_S | QUAL_V | QUAL_I | QUAL_RM_C:
874 gen_helper_cvttq_svic(cpu_fir[rc], vb);
875 break;
876 default:
877 gen_qual_roundmode(ctx, fn11);
878 gen_helper_cvttq(cpu_fir[rc], vb);
879 ignore |= (fn11 & QUAL_V ? 0 : float_flag_overflow);
880 ignore |= (fn11 & QUAL_I ? 0 : float_flag_inexact);
881 break;
882 }
883 tcg_temp_free(vb);
884
885 gen_fp_exc_raise_ignore(rc, fn11, ignore);
886 }
887
888 static void gen_ieee_intcvt(DisasContext *ctx, void (*helper)(TCGv, TCGv),
889 int rb, int rc, int fn11)
890 {
891 TCGv vb;
892
893 /* ??? This is wrong: the instruction is not a nop, it still may
894 raise exceptions. */
895 if (unlikely(rc == 31)) {
896 return;
897 }
898
899 gen_qual_roundmode(ctx, fn11);
900
901 if (rb == 31) {
902 vb = tcg_const_i64(0);
903 } else {
904 vb = cpu_fir[rb];
905 }
906
907 /* The only exception that can be raised by integer conversion
908 is inexact. Thus we only need to worry about exceptions when
909 inexact handling is requested. */
910 if (fn11 & QUAL_I) {
911 gen_fp_exc_clear();
912 helper(cpu_fir[rc], vb);
913 gen_fp_exc_raise(rc, fn11);
914 } else {
915 helper(cpu_fir[rc], vb);
916 }
917
918 if (rb == 31) {
919 tcg_temp_free(vb);
920 }
921 }
922
923 #define IEEE_INTCVT(name) \
924 static inline void glue(gen_f, name)(DisasContext *ctx, \
925 int rb, int rc, int fn11) \
926 { \
927 gen_ieee_intcvt(ctx, gen_helper_##name, rb, rc, fn11); \
928 }
929 IEEE_INTCVT(cvtqs)
930 IEEE_INTCVT(cvtqt)
931
932 static void gen_cpys_internal(int ra, int rb, int rc, int inv_a, uint64_t mask)
933 {
934 TCGv va, vb, vmask;
935 int za = 0, zb = 0;
936
937 if (unlikely(rc == 31)) {
938 return;
939 }
940
941 vmask = tcg_const_i64(mask);
942
943 TCGV_UNUSED_I64(va);
944 if (ra == 31) {
945 if (inv_a) {
946 va = vmask;
947 } else {
948 za = 1;
949 }
950 } else {
951 va = tcg_temp_new_i64();
952 tcg_gen_mov_i64(va, cpu_fir[ra]);
953 if (inv_a) {
954 tcg_gen_andc_i64(va, vmask, va);
955 } else {
956 tcg_gen_and_i64(va, va, vmask);
957 }
958 }
959
960 TCGV_UNUSED_I64(vb);
961 if (rb == 31) {
962 zb = 1;
963 } else {
964 vb = tcg_temp_new_i64();
965 tcg_gen_andc_i64(vb, cpu_fir[rb], vmask);
966 }
967
968 switch (za << 1 | zb) {
969 case 0 | 0:
970 tcg_gen_or_i64(cpu_fir[rc], va, vb);
971 break;
972 case 0 | 1:
973 tcg_gen_mov_i64(cpu_fir[rc], va);
974 break;
975 case 2 | 0:
976 tcg_gen_mov_i64(cpu_fir[rc], vb);
977 break;
978 case 2 | 1:
979 tcg_gen_movi_i64(cpu_fir[rc], 0);
980 break;
981 }
982
983 tcg_temp_free(vmask);
984 if (ra != 31) {
985 tcg_temp_free(va);
986 }
987 if (rb != 31) {
988 tcg_temp_free(vb);
989 }
990 }
991
992 static inline void gen_fcpys(int ra, int rb, int rc)
993 {
994 gen_cpys_internal(ra, rb, rc, 0, 0x8000000000000000ULL);
995 }
996
997 static inline void gen_fcpysn(int ra, int rb, int rc)
998 {
999 gen_cpys_internal(ra, rb, rc, 1, 0x8000000000000000ULL);
1000 }
1001
1002 static inline void gen_fcpyse(int ra, int rb, int rc)
1003 {
1004 gen_cpys_internal(ra, rb, rc, 0, 0xFFF0000000000000ULL);
1005 }
1006
1007 #define FARITH3(name) \
1008 static inline void glue(gen_f, name)(int ra, int rb, int rc) \
1009 { \
1010 TCGv va, vb; \
1011 \
1012 if (unlikely(rc == 31)) { \
1013 return; \
1014 } \
1015 if (ra == 31) { \
1016 va = tcg_const_i64(0); \
1017 } else { \
1018 va = cpu_fir[ra]; \
1019 } \
1020 if (rb == 31) { \
1021 vb = tcg_const_i64(0); \
1022 } else { \
1023 vb = cpu_fir[rb]; \
1024 } \
1025 \
1026 gen_helper_ ## name (cpu_fir[rc], va, vb); \
1027 \
1028 if (ra == 31) { \
1029 tcg_temp_free(va); \
1030 } \
1031 if (rb == 31) { \
1032 tcg_temp_free(vb); \
1033 } \
1034 }
1035
1036 /* ??? VAX instruction qualifiers ignored. */
1037 FARITH3(addf)
1038 FARITH3(subf)
1039 FARITH3(mulf)
1040 FARITH3(divf)
1041 FARITH3(addg)
1042 FARITH3(subg)
1043 FARITH3(mulg)
1044 FARITH3(divg)
1045 FARITH3(cmpgeq)
1046 FARITH3(cmpglt)
1047 FARITH3(cmpgle)
1048
1049 static void gen_ieee_arith3(DisasContext *ctx,
1050 void (*helper)(TCGv, TCGv, TCGv),
1051 int ra, int rb, int rc, int fn11)
1052 {
1053 TCGv va, vb;
1054
1055 /* ??? This is wrong: the instruction is not a nop, it still may
1056 raise exceptions. */
1057 if (unlikely(rc == 31)) {
1058 return;
1059 }
1060
1061 gen_qual_roundmode(ctx, fn11);
1062 gen_qual_flushzero(ctx, fn11);
1063 gen_fp_exc_clear();
1064
1065 va = gen_ieee_input(ra, fn11, 0);
1066 vb = gen_ieee_input(rb, fn11, 0);
1067 helper(cpu_fir[rc], va, vb);
1068 tcg_temp_free(va);
1069 tcg_temp_free(vb);
1070
1071 gen_fp_exc_raise(rc, fn11);
1072 }
1073
1074 #define IEEE_ARITH3(name) \
1075 static inline void glue(gen_f, name)(DisasContext *ctx, \
1076 int ra, int rb, int rc, int fn11) \
1077 { \
1078 gen_ieee_arith3(ctx, gen_helper_##name, ra, rb, rc, fn11); \
1079 }
1080 IEEE_ARITH3(adds)
1081 IEEE_ARITH3(subs)
1082 IEEE_ARITH3(muls)
1083 IEEE_ARITH3(divs)
1084 IEEE_ARITH3(addt)
1085 IEEE_ARITH3(subt)
1086 IEEE_ARITH3(mult)
1087 IEEE_ARITH3(divt)
1088
1089 static void gen_ieee_compare(DisasContext *ctx,
1090 void (*helper)(TCGv, TCGv, TCGv),
1091 int ra, int rb, int rc, int fn11)
1092 {
1093 TCGv va, vb;
1094
1095 /* ??? This is wrong: the instruction is not a nop, it still may
1096 raise exceptions. */
1097 if (unlikely(rc == 31)) {
1098 return;
1099 }
1100
1101 gen_fp_exc_clear();
1102
1103 va = gen_ieee_input(ra, fn11, 1);
1104 vb = gen_ieee_input(rb, fn11, 1);
1105 helper(cpu_fir[rc], va, vb);
1106 tcg_temp_free(va);
1107 tcg_temp_free(vb);
1108
1109 gen_fp_exc_raise(rc, fn11);
1110 }
1111
1112 #define IEEE_CMP3(name) \
1113 static inline void glue(gen_f, name)(DisasContext *ctx, \
1114 int ra, int rb, int rc, int fn11) \
1115 { \
1116 gen_ieee_compare(ctx, gen_helper_##name, ra, rb, rc, fn11); \
1117 }
1118 IEEE_CMP3(cmptun)
1119 IEEE_CMP3(cmpteq)
1120 IEEE_CMP3(cmptlt)
1121 IEEE_CMP3(cmptle)
1122
1123 static inline uint64_t zapnot_mask(uint8_t lit)
1124 {
1125 uint64_t mask = 0;
1126 int i;
1127
1128 for (i = 0; i < 8; ++i) {
1129 if ((lit >> i) & 1)
1130 mask |= 0xffull << (i * 8);
1131 }
1132 return mask;
1133 }
1134
1135 /* Implement zapnot with an immediate operand, which expands to some
1136 form of immediate AND. This is a basic building block in the
1137 definition of many of the other byte manipulation instructions. */
1138 static void gen_zapnoti(TCGv dest, TCGv src, uint8_t lit)
1139 {
1140 switch (lit) {
1141 case 0x00:
1142 tcg_gen_movi_i64(dest, 0);
1143 break;
1144 case 0x01:
1145 tcg_gen_ext8u_i64(dest, src);
1146 break;
1147 case 0x03:
1148 tcg_gen_ext16u_i64(dest, src);
1149 break;
1150 case 0x0f:
1151 tcg_gen_ext32u_i64(dest, src);
1152 break;
1153 case 0xff:
1154 tcg_gen_mov_i64(dest, src);
1155 break;
1156 default:
1157 tcg_gen_andi_i64 (dest, src, zapnot_mask (lit));
1158 break;
1159 }
1160 }
1161
1162 static inline void gen_zapnot(int ra, int rb, int rc, int islit, uint8_t lit)
1163 {
1164 if (unlikely(rc == 31))
1165 return;
1166 else if (unlikely(ra == 31))
1167 tcg_gen_movi_i64(cpu_ir[rc], 0);
1168 else if (islit)
1169 gen_zapnoti(cpu_ir[rc], cpu_ir[ra], lit);
1170 else
1171 gen_helper_zapnot (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1172 }
1173
1174 static inline void gen_zap(int ra, int rb, int rc, int islit, uint8_t lit)
1175 {
1176 if (unlikely(rc == 31))
1177 return;
1178 else if (unlikely(ra == 31))
1179 tcg_gen_movi_i64(cpu_ir[rc], 0);
1180 else if (islit)
1181 gen_zapnoti(cpu_ir[rc], cpu_ir[ra], ~lit);
1182 else
1183 gen_helper_zap (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1184 }
1185
1186
1187 /* EXTWH, EXTLH, EXTQH */
1188 static void gen_ext_h(int ra, int rb, int rc, int islit,
1189 uint8_t lit, uint8_t byte_mask)
1190 {
1191 if (unlikely(rc == 31))
1192 return;
1193 else if (unlikely(ra == 31))
1194 tcg_gen_movi_i64(cpu_ir[rc], 0);
1195 else {
1196 if (islit) {
1197 lit = (64 - (lit & 7) * 8) & 0x3f;
1198 tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], lit);
1199 } else {
1200 TCGv tmp1 = tcg_temp_new();
1201 tcg_gen_andi_i64(tmp1, cpu_ir[rb], 7);
1202 tcg_gen_shli_i64(tmp1, tmp1, 3);
1203 tcg_gen_neg_i64(tmp1, tmp1);
1204 tcg_gen_andi_i64(tmp1, tmp1, 0x3f);
1205 tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], tmp1);
1206 tcg_temp_free(tmp1);
1207 }
1208 gen_zapnoti(cpu_ir[rc], cpu_ir[rc], byte_mask);
1209 }
1210 }
1211
1212 /* EXTBL, EXTWL, EXTLL, EXTQL */
1213 static void gen_ext_l(int ra, int rb, int rc, int islit,
1214 uint8_t lit, uint8_t byte_mask)
1215 {
1216 if (unlikely(rc == 31))
1217 return;
1218 else if (unlikely(ra == 31))
1219 tcg_gen_movi_i64(cpu_ir[rc], 0);
1220 else {
1221 if (islit) {
1222 tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], (lit & 7) * 8);
1223 } else {
1224 TCGv tmp = tcg_temp_new();
1225 tcg_gen_andi_i64(tmp, cpu_ir[rb], 7);
1226 tcg_gen_shli_i64(tmp, tmp, 3);
1227 tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], tmp);
1228 tcg_temp_free(tmp);
1229 }
1230 gen_zapnoti(cpu_ir[rc], cpu_ir[rc], byte_mask);
1231 }
1232 }
1233
1234 /* INSWH, INSLH, INSQH */
1235 static void gen_ins_h(int ra, int rb, int rc, int islit,
1236 uint8_t lit, uint8_t byte_mask)
1237 {
1238 if (unlikely(rc == 31))
1239 return;
1240 else if (unlikely(ra == 31) || (islit && (lit & 7) == 0))
1241 tcg_gen_movi_i64(cpu_ir[rc], 0);
1242 else {
1243 TCGv tmp = tcg_temp_new();
1244
1245 /* The instruction description has us left-shift the byte mask
1246 and extract bits <15:8> and apply that zap at the end. This
1247 is equivalent to simply performing the zap first and shifting
1248 afterward. */
1249 gen_zapnoti (tmp, cpu_ir[ra], byte_mask);
1250
1251 if (islit) {
1252 /* Note that we have handled the lit==0 case above. */
1253 tcg_gen_shri_i64 (cpu_ir[rc], tmp, 64 - (lit & 7) * 8);
1254 } else {
1255 TCGv shift = tcg_temp_new();
1256
1257 /* If (B & 7) == 0, we need to shift by 64 and leave a zero.
1258 Do this portably by splitting the shift into two parts:
1259 shift_count-1 and 1. Arrange for the -1 by using
1260 ones-complement instead of twos-complement in the negation:
1261 ~((B & 7) * 8) & 63. */
1262
1263 tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1264 tcg_gen_shli_i64(shift, shift, 3);
1265 tcg_gen_not_i64(shift, shift);
1266 tcg_gen_andi_i64(shift, shift, 0x3f);
1267
1268 tcg_gen_shr_i64(cpu_ir[rc], tmp, shift);
1269 tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[rc], 1);
1270 tcg_temp_free(shift);
1271 }
1272 tcg_temp_free(tmp);
1273 }
1274 }
1275
1276 /* INSBL, INSWL, INSLL, INSQL */
1277 static void gen_ins_l(int ra, int rb, int rc, int islit,
1278 uint8_t lit, uint8_t byte_mask)
1279 {
1280 if (unlikely(rc == 31))
1281 return;
1282 else if (unlikely(ra == 31))
1283 tcg_gen_movi_i64(cpu_ir[rc], 0);
1284 else {
1285 TCGv tmp = tcg_temp_new();
1286
1287 /* The instruction description has us left-shift the byte mask
1288 the same number of byte slots as the data and apply the zap
1289 at the end. This is equivalent to simply performing the zap
1290 first and shifting afterward. */
1291 gen_zapnoti (tmp, cpu_ir[ra], byte_mask);
1292
1293 if (islit) {
1294 tcg_gen_shli_i64(cpu_ir[rc], tmp, (lit & 7) * 8);
1295 } else {
1296 TCGv shift = tcg_temp_new();
1297 tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1298 tcg_gen_shli_i64(shift, shift, 3);
1299 tcg_gen_shl_i64(cpu_ir[rc], tmp, shift);
1300 tcg_temp_free(shift);
1301 }
1302 tcg_temp_free(tmp);
1303 }
1304 }
1305
1306 /* MSKWH, MSKLH, MSKQH */
1307 static void gen_msk_h(int ra, int rb, int rc, int islit,
1308 uint8_t lit, uint8_t byte_mask)
1309 {
1310 if (unlikely(rc == 31))
1311 return;
1312 else if (unlikely(ra == 31))
1313 tcg_gen_movi_i64(cpu_ir[rc], 0);
1314 else if (islit) {
1315 gen_zapnoti (cpu_ir[rc], cpu_ir[ra], ~((byte_mask << (lit & 7)) >> 8));
1316 } else {
1317 TCGv shift = tcg_temp_new();
1318 TCGv mask = tcg_temp_new();
1319
1320 /* The instruction description is as above, where the byte_mask
1321 is shifted left, and then we extract bits <15:8>. This can be
1322 emulated with a right-shift on the expanded byte mask. This
1323 requires extra care because for an input <2:0> == 0 we need a
1324 shift of 64 bits in order to generate a zero. This is done by
1325 splitting the shift into two parts, the variable shift - 1
1326 followed by a constant 1 shift. The code we expand below is
1327 equivalent to ~((B & 7) * 8) & 63. */
1328
1329 tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1330 tcg_gen_shli_i64(shift, shift, 3);
1331 tcg_gen_not_i64(shift, shift);
1332 tcg_gen_andi_i64(shift, shift, 0x3f);
1333 tcg_gen_movi_i64(mask, zapnot_mask (byte_mask));
1334 tcg_gen_shr_i64(mask, mask, shift);
1335 tcg_gen_shri_i64(mask, mask, 1);
1336
1337 tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], mask);
1338
1339 tcg_temp_free(mask);
1340 tcg_temp_free(shift);
1341 }
1342 }
1343
1344 /* MSKBL, MSKWL, MSKLL, MSKQL */
1345 static void gen_msk_l(int ra, int rb, int rc, int islit,
1346 uint8_t lit, uint8_t byte_mask)
1347 {
1348 if (unlikely(rc == 31))
1349 return;
1350 else if (unlikely(ra == 31))
1351 tcg_gen_movi_i64(cpu_ir[rc], 0);
1352 else if (islit) {
1353 gen_zapnoti (cpu_ir[rc], cpu_ir[ra], ~(byte_mask << (lit & 7)));
1354 } else {
1355 TCGv shift = tcg_temp_new();
1356 TCGv mask = tcg_temp_new();
1357
1358 tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1359 tcg_gen_shli_i64(shift, shift, 3);
1360 tcg_gen_movi_i64(mask, zapnot_mask (byte_mask));
1361 tcg_gen_shl_i64(mask, mask, shift);
1362
1363 tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], mask);
1364
1365 tcg_temp_free(mask);
1366 tcg_temp_free(shift);
1367 }
1368 }
1369
1370 /* Code to call arith3 helpers */
1371 #define ARITH3(name) \
1372 static inline void glue(gen_, name)(int ra, int rb, int rc, int islit,\
1373 uint8_t lit) \
1374 { \
1375 if (unlikely(rc == 31)) \
1376 return; \
1377 \
1378 if (ra != 31) { \
1379 if (islit) { \
1380 TCGv tmp = tcg_const_i64(lit); \
1381 gen_helper_ ## name(cpu_ir[rc], cpu_ir[ra], tmp); \
1382 tcg_temp_free(tmp); \
1383 } else \
1384 gen_helper_ ## name (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]); \
1385 } else { \
1386 TCGv tmp1 = tcg_const_i64(0); \
1387 if (islit) { \
1388 TCGv tmp2 = tcg_const_i64(lit); \
1389 gen_helper_ ## name (cpu_ir[rc], tmp1, tmp2); \
1390 tcg_temp_free(tmp2); \
1391 } else \
1392 gen_helper_ ## name (cpu_ir[rc], tmp1, cpu_ir[rb]); \
1393 tcg_temp_free(tmp1); \
1394 } \
1395 }
1396 ARITH3(cmpbge)
1397 ARITH3(addlv)
1398 ARITH3(sublv)
1399 ARITH3(addqv)
1400 ARITH3(subqv)
1401 ARITH3(umulh)
1402 ARITH3(mullv)
1403 ARITH3(mulqv)
1404 ARITH3(minub8)
1405 ARITH3(minsb8)
1406 ARITH3(minuw4)
1407 ARITH3(minsw4)
1408 ARITH3(maxub8)
1409 ARITH3(maxsb8)
1410 ARITH3(maxuw4)
1411 ARITH3(maxsw4)
1412 ARITH3(perr)
1413
1414 #define MVIOP2(name) \
1415 static inline void glue(gen_, name)(int rb, int rc) \
1416 { \
1417 if (unlikely(rc == 31)) \
1418 return; \
1419 if (unlikely(rb == 31)) \
1420 tcg_gen_movi_i64(cpu_ir[rc], 0); \
1421 else \
1422 gen_helper_ ## name (cpu_ir[rc], cpu_ir[rb]); \
1423 }
1424 MVIOP2(pklb)
1425 MVIOP2(pkwb)
1426 MVIOP2(unpkbl)
1427 MVIOP2(unpkbw)
1428
1429 static void gen_cmp(TCGCond cond, int ra, int rb, int rc,
1430 int islit, uint8_t lit)
1431 {
1432 TCGv va, vb;
1433
1434 if (unlikely(rc == 31)) {
1435 return;
1436 }
1437
1438 if (ra == 31) {
1439 va = tcg_const_i64(0);
1440 } else {
1441 va = cpu_ir[ra];
1442 }
1443 if (islit) {
1444 vb = tcg_const_i64(lit);
1445 } else {
1446 vb = cpu_ir[rb];
1447 }
1448
1449 tcg_gen_setcond_i64(cond, cpu_ir[rc], va, vb);
1450
1451 if (ra == 31) {
1452 tcg_temp_free(va);
1453 }
1454 if (islit) {
1455 tcg_temp_free(vb);
1456 }
1457 }
1458
1459 static void gen_rx(int ra, int set)
1460 {
1461 TCGv_i32 tmp;
1462
1463 if (ra != 31) {
1464 tcg_gen_ld8u_i64(cpu_ir[ra], cpu_env, offsetof(CPUState, intr_flag));
1465 }
1466
1467 tmp = tcg_const_i32(set);
1468 tcg_gen_st8_i32(tmp, cpu_env, offsetof(CPUState, intr_flag));
1469 tcg_temp_free_i32(tmp);
1470 }
1471
1472 static ExitStatus gen_call_pal(DisasContext *ctx, int palcode)
1473 {
1474 /* We're emulating OSF/1 PALcode. Many of these are trivial access
1475 to internal cpu registers. */
1476
1477 /* Unprivileged PAL call */
1478 if (palcode >= 0x80 && palcode < 0xC0) {
1479 switch (palcode) {
1480 case 0x86:
1481 /* IMB */
1482 /* No-op inside QEMU. */
1483 break;
1484 case 0x9E:
1485 /* RDUNIQUE */
1486 tcg_gen_mov_i64(cpu_ir[IR_V0], cpu_unique);
1487 break;
1488 case 0x9F:
1489 /* WRUNIQUE */
1490 tcg_gen_mov_i64(cpu_unique, cpu_ir[IR_A0]);
1491 break;
1492 default:
1493 return gen_excp(ctx, EXCP_CALL_PAL, palcode & 0xbf);
1494 }
1495 return NO_EXIT;
1496 }
1497
1498 #ifndef CONFIG_USER_ONLY
1499 /* Privileged PAL code */
1500 if (palcode < 0x40 && (ctx->tb->flags & TB_FLAGS_USER_MODE) == 0) {
1501 switch (palcode) {
1502 case 0x01:
1503 /* CFLUSH */
1504 /* No-op inside QEMU. */
1505 break;
1506 case 0x02:
1507 /* DRAINA */
1508 /* No-op inside QEMU. */
1509 break;
1510 case 0x2D:
1511 /* WRVPTPTR */
1512 tcg_gen_st_i64(cpu_ir[IR_A0], cpu_env, offsetof(CPUState, vptptr));
1513 break;
1514 case 0x31:
1515 /* WRVAL */
1516 tcg_gen_mov_i64(cpu_sysval, cpu_ir[IR_A0]);
1517 break;
1518 case 0x32:
1519 /* RDVAL */
1520 tcg_gen_mov_i64(cpu_ir[IR_V0], cpu_sysval);
1521 break;
1522
1523 case 0x35: {
1524 /* SWPIPL */
1525 TCGv tmp;
1526
1527 /* Note that we already know we're in kernel mode, so we know
1528 that PS only contains the 3 IPL bits. */
1529 tcg_gen_ld8u_i64(cpu_ir[IR_V0], cpu_env, offsetof(CPUState, ps));
1530
1531 /* But make sure and store only the 3 IPL bits from the user. */
1532 tmp = tcg_temp_new();
1533 tcg_gen_andi_i64(tmp, cpu_ir[IR_A0], PS_INT_MASK);
1534 tcg_gen_st8_i64(tmp, cpu_env, offsetof(CPUState, ps));
1535 tcg_temp_free(tmp);
1536 break;
1537 }
1538
1539 case 0x36:
1540 /* RDPS */
1541 tcg_gen_ld8u_i64(cpu_ir[IR_V0], cpu_env, offsetof(CPUState, ps));
1542 break;
1543 case 0x38:
1544 /* WRUSP */
1545 tcg_gen_mov_i64(cpu_usp, cpu_ir[IR_A0]);
1546 break;
1547 case 0x3A:
1548 /* RDUSP */
1549 tcg_gen_mov_i64(cpu_ir[IR_V0], cpu_usp);
1550 break;
1551 case 0x3C:
1552 /* WHAMI */
1553 tcg_gen_ld32s_i64(cpu_ir[IR_V0], cpu_env,
1554 offsetof(CPUState, cpu_index));
1555 break;
1556
1557 default:
1558 return gen_excp(ctx, EXCP_CALL_PAL, palcode & 0x3f);
1559 }
1560 return NO_EXIT;
1561 }
1562 #endif
1563
1564 return gen_invalid(ctx);
1565 }
1566
1567 #ifndef CONFIG_USER_ONLY
1568
1569 #define PR_BYTE 0x100000
1570 #define PR_LONG 0x200000
1571
1572 static int cpu_pr_data(int pr)
1573 {
1574 switch (pr) {
1575 case 0: return offsetof(CPUAlphaState, ps) | PR_BYTE;
1576 case 1: return offsetof(CPUAlphaState, fen) | PR_BYTE;
1577 case 2: return offsetof(CPUAlphaState, pcc_ofs) | PR_LONG;
1578 case 3: return offsetof(CPUAlphaState, trap_arg0);
1579 case 4: return offsetof(CPUAlphaState, trap_arg1);
1580 case 5: return offsetof(CPUAlphaState, trap_arg2);
1581 case 6: return offsetof(CPUAlphaState, exc_addr);
1582 case 7: return offsetof(CPUAlphaState, palbr);
1583 case 8: return offsetof(CPUAlphaState, ptbr);
1584 case 9: return offsetof(CPUAlphaState, vptptr);
1585 case 10: return offsetof(CPUAlphaState, unique);
1586 case 11: return offsetof(CPUAlphaState, sysval);
1587 case 12: return offsetof(CPUAlphaState, usp);
1588
1589 case 32 ... 39:
1590 return offsetof(CPUAlphaState, shadow[pr - 32]);
1591 case 40 ... 63:
1592 return offsetof(CPUAlphaState, scratch[pr - 40]);
1593 }
1594 return 0;
1595 }
1596
1597 static void gen_mfpr(int ra, int regno)
1598 {
1599 int data = cpu_pr_data(regno);
1600
1601 /* In our emulated PALcode, these processor registers have no
1602 side effects from reading. */
1603 if (ra == 31) {
1604 return;
1605 }
1606
1607 /* The basic registers are data only, and unknown registers
1608 are read-zero, write-ignore. */
1609 if (data == 0) {
1610 tcg_gen_movi_i64(cpu_ir[ra], 0);
1611 } else if (data & PR_BYTE) {
1612 tcg_gen_ld8u_i64(cpu_ir[ra], cpu_env, data & ~PR_BYTE);
1613 } else if (data & PR_LONG) {
1614 tcg_gen_ld32s_i64(cpu_ir[ra], cpu_env, data & ~PR_LONG);
1615 } else {
1616 tcg_gen_ld_i64(cpu_ir[ra], cpu_env, data);
1617 }
1618 }
1619
1620 static void gen_mtpr(int rb, int regno)
1621 {
1622 TCGv tmp;
1623
1624 if (rb == 31) {
1625 tmp = tcg_const_i64(0);
1626 } else {
1627 tmp = cpu_ir[rb];
1628 }
1629
1630 /* These two register numbers perform a TLB cache flush. Thankfully we
1631 can only do this inside PALmode, which means that the current basic
1632 block cannot be affected by the change in mappings. */
1633 if (regno == 255) {
1634 /* TBIA */
1635 gen_helper_tbia();
1636 } else if (regno == 254) {
1637 /* TBIS */
1638 gen_helper_tbis(tmp);
1639 } else {
1640 /* The basic registers are data only, and unknown registers
1641 are read-zero, write-ignore. */
1642 int data = cpu_pr_data(regno);
1643 if (data != 0) {
1644 if (data & PR_BYTE) {
1645 tcg_gen_st8_i64(tmp, cpu_env, data & ~PR_BYTE);
1646 } else if (data & PR_LONG) {
1647 tcg_gen_st32_i64(tmp, cpu_env, data & ~PR_LONG);
1648 } else {
1649 tcg_gen_st_i64(tmp, cpu_env, data);
1650 }
1651 }
1652 }
1653
1654 if (rb == 31) {
1655 tcg_temp_free(tmp);
1656 }
1657 }
1658 #endif /* !USER_ONLY*/
1659
1660 static ExitStatus translate_one(DisasContext *ctx, uint32_t insn)
1661 {
1662 uint32_t palcode;
1663 int32_t disp21, disp16;
1664 #ifndef CONFIG_USER_ONLY
1665 int32_t disp12;
1666 #endif
1667 uint16_t fn11;
1668 uint8_t opc, ra, rb, rc, fpfn, fn7, islit, real_islit;
1669 uint8_t lit;
1670 ExitStatus ret;
1671
1672 /* Decode all instruction fields */
1673 opc = insn >> 26;
1674 ra = (insn >> 21) & 0x1F;
1675 rb = (insn >> 16) & 0x1F;
1676 rc = insn & 0x1F;
1677 real_islit = islit = (insn >> 12) & 1;
1678 if (rb == 31 && !islit) {
1679 islit = 1;
1680 lit = 0;
1681 } else
1682 lit = (insn >> 13) & 0xFF;
1683 palcode = insn & 0x03FFFFFF;
1684 disp21 = ((int32_t)((insn & 0x001FFFFF) << 11)) >> 11;
1685 disp16 = (int16_t)(insn & 0x0000FFFF);
1686 #ifndef CONFIG_USER_ONLY
1687 disp12 = (int32_t)((insn & 0x00000FFF) << 20) >> 20;
1688 #endif
1689 fn11 = (insn >> 5) & 0x000007FF;
1690 fpfn = fn11 & 0x3F;
1691 fn7 = (insn >> 5) & 0x0000007F;
1692 LOG_DISAS("opc %02x ra %2d rb %2d rc %2d disp16 %6d\n",
1693 opc, ra, rb, rc, disp16);
1694
1695 ret = NO_EXIT;
1696 switch (opc) {
1697 case 0x00:
1698 /* CALL_PAL */
1699 ret = gen_call_pal(ctx, palcode);
1700 break;
1701 case 0x01:
1702 /* OPC01 */
1703 goto invalid_opc;
1704 case 0x02:
1705 /* OPC02 */
1706 goto invalid_opc;
1707 case 0x03:
1708 /* OPC03 */
1709 goto invalid_opc;
1710 case 0x04:
1711 /* OPC04 */
1712 goto invalid_opc;
1713 case 0x05:
1714 /* OPC05 */
1715 goto invalid_opc;
1716 case 0x06:
1717 /* OPC06 */
1718 goto invalid_opc;
1719 case 0x07:
1720 /* OPC07 */
1721 goto invalid_opc;
1722 case 0x08:
1723 /* LDA */
1724 if (likely(ra != 31)) {
1725 if (rb != 31)
1726 tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16);
1727 else
1728 tcg_gen_movi_i64(cpu_ir[ra], disp16);
1729 }
1730 break;
1731 case 0x09:
1732 /* LDAH */
1733 if (likely(ra != 31)) {
1734 if (rb != 31)
1735 tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16 << 16);
1736 else
1737 tcg_gen_movi_i64(cpu_ir[ra], disp16 << 16);
1738 }
1739 break;
1740 case 0x0A:
1741 /* LDBU */
1742 if (ctx->tb->flags & TB_FLAGS_AMASK_BWX) {
1743 gen_load_mem(ctx, &tcg_gen_qemu_ld8u, ra, rb, disp16, 0, 0);
1744 break;
1745 }
1746 goto invalid_opc;
1747 case 0x0B:
1748 /* LDQ_U */
1749 gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 0, 1);
1750 break;
1751 case 0x0C:
1752 /* LDWU */
1753 if (ctx->tb->flags & TB_FLAGS_AMASK_BWX) {
1754 gen_load_mem(ctx, &tcg_gen_qemu_ld16u, ra, rb, disp16, 0, 0);
1755 break;
1756 }
1757 goto invalid_opc;
1758 case 0x0D:
1759 /* STW */
1760 gen_store_mem(ctx, &tcg_gen_qemu_st16, ra, rb, disp16, 0, 0);
1761 break;
1762 case 0x0E:
1763 /* STB */
1764 gen_store_mem(ctx, &tcg_gen_qemu_st8, ra, rb, disp16, 0, 0);
1765 break;
1766 case 0x0F:
1767 /* STQ_U */
1768 gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 0, 1);
1769 break;
1770 case 0x10:
1771 switch (fn7) {
1772 case 0x00:
1773 /* ADDL */
1774 if (likely(rc != 31)) {
1775 if (ra != 31) {
1776 if (islit) {
1777 tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1778 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1779 } else {
1780 tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1781 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1782 }
1783 } else {
1784 if (islit)
1785 tcg_gen_movi_i64(cpu_ir[rc], lit);
1786 else
1787 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
1788 }
1789 }
1790 break;
1791 case 0x02:
1792 /* S4ADDL */
1793 if (likely(rc != 31)) {
1794 if (ra != 31) {
1795 TCGv tmp = tcg_temp_new();
1796 tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1797 if (islit)
1798 tcg_gen_addi_i64(tmp, tmp, lit);
1799 else
1800 tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
1801 tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1802 tcg_temp_free(tmp);
1803 } else {
1804 if (islit)
1805 tcg_gen_movi_i64(cpu_ir[rc], lit);
1806 else
1807 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
1808 }
1809 }
1810 break;
1811 case 0x09:
1812 /* SUBL */
1813 if (likely(rc != 31)) {
1814 if (ra != 31) {
1815 if (islit)
1816 tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1817 else
1818 tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1819 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1820 } else {
1821 if (islit)
1822 tcg_gen_movi_i64(cpu_ir[rc], -lit);
1823 else {
1824 tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1825 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1826 }
1827 }
1828 break;
1829 case 0x0B:
1830 /* S4SUBL */
1831 if (likely(rc != 31)) {
1832 if (ra != 31) {
1833 TCGv tmp = tcg_temp_new();
1834 tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1835 if (islit)
1836 tcg_gen_subi_i64(tmp, tmp, lit);
1837 else
1838 tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
1839 tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1840 tcg_temp_free(tmp);
1841 } else {
1842 if (islit)
1843 tcg_gen_movi_i64(cpu_ir[rc], -lit);
1844 else {
1845 tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1846 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1847 }
1848 }
1849 }
1850 break;
1851 case 0x0F:
1852 /* CMPBGE */
1853 gen_cmpbge(ra, rb, rc, islit, lit);
1854 break;
1855 case 0x12:
1856 /* S8ADDL */
1857 if (likely(rc != 31)) {
1858 if (ra != 31) {
1859 TCGv tmp = tcg_temp_new();
1860 tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
1861 if (islit)
1862 tcg_gen_addi_i64(tmp, tmp, lit);
1863 else
1864 tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
1865 tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1866 tcg_temp_free(tmp);
1867 } else {
1868 if (islit)
1869 tcg_gen_movi_i64(cpu_ir[rc], lit);
1870 else
1871 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
1872 }
1873 }
1874 break;
1875 case 0x1B:
1876 /* S8SUBL */
1877 if (likely(rc != 31)) {
1878 if (ra != 31) {
1879 TCGv tmp = tcg_temp_new();
1880 tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
1881 if (islit)
1882 tcg_gen_subi_i64(tmp, tmp, lit);
1883 else
1884 tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
1885 tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1886 tcg_temp_free(tmp);
1887 } else {
1888 if (islit)
1889 tcg_gen_movi_i64(cpu_ir[rc], -lit);
1890 else
1891 tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1892 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1893 }
1894 }
1895 }
1896 break;
1897 case 0x1D:
1898 /* CMPULT */
1899 gen_cmp(TCG_COND_LTU, ra, rb, rc, islit, lit);
1900 break;
1901 case 0x20:
1902 /* ADDQ */
1903 if (likely(rc != 31)) {
1904 if (ra != 31) {
1905 if (islit)
1906 tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1907 else
1908 tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1909 } else {
1910 if (islit)
1911 tcg_gen_movi_i64(cpu_ir[rc], lit);
1912 else
1913 tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1914 }
1915 }
1916 break;
1917 case 0x22:
1918 /* S4ADDQ */
1919 if (likely(rc != 31)) {
1920 if (ra != 31) {
1921 TCGv tmp = tcg_temp_new();
1922 tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1923 if (islit)
1924 tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
1925 else
1926 tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
1927 tcg_temp_free(tmp);
1928 } else {
1929 if (islit)
1930 tcg_gen_movi_i64(cpu_ir[rc], lit);
1931 else
1932 tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1933 }
1934 }
1935 break;
1936 case 0x29:
1937 /* SUBQ */
1938 if (likely(rc != 31)) {
1939 if (ra != 31) {
1940 if (islit)
1941 tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1942 else
1943 tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1944 } else {
1945 if (islit)
1946 tcg_gen_movi_i64(cpu_ir[rc], -lit);
1947 else
1948 tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1949 }
1950 }
1951 break;
1952 case 0x2B:
1953 /* S4SUBQ */
1954 if (likely(rc != 31)) {
1955 if (ra != 31) {
1956 TCGv tmp = tcg_temp_new();
1957 tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1958 if (islit)
1959 tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
1960 else
1961 tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
1962 tcg_temp_free(tmp);
1963 } else {
1964 if (islit)
1965 tcg_gen_movi_i64(cpu_ir[rc], -lit);
1966 else
1967 tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1968 }
1969 }
1970 break;
1971 case 0x2D:
1972 /* CMPEQ */
1973 gen_cmp(TCG_COND_EQ, ra, rb, rc, islit, lit);
1974 break;
1975 case 0x32:
1976 /* S8ADDQ */
1977 if (likely(rc != 31)) {
1978 if (ra != 31) {
1979 TCGv tmp = tcg_temp_new();
1980 tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
1981 if (islit)
1982 tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
1983 else
1984 tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
1985 tcg_temp_free(tmp);
1986 } else {
1987 if (islit)
1988 tcg_gen_movi_i64(cpu_ir[rc], lit);
1989 else
1990 tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1991 }
1992 }
1993 break;
1994 case 0x3B:
1995 /* S8SUBQ */
1996 if (likely(rc != 31)) {
1997 if (ra != 31) {
1998 TCGv tmp = tcg_temp_new();
1999 tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
2000 if (islit)
2001 tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
2002 else
2003 tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
2004 tcg_temp_free(tmp);
2005 } else {
2006 if (islit)
2007 tcg_gen_movi_i64(cpu_ir[rc], -lit);
2008 else
2009 tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
2010 }
2011 }
2012 break;
2013 case 0x3D:
2014 /* CMPULE */
2015 gen_cmp(TCG_COND_LEU, ra, rb, rc, islit, lit);
2016 break;
2017 case 0x40:
2018 /* ADDL/V */
2019 gen_addlv(ra, rb, rc, islit, lit);
2020 break;
2021 case 0x49:
2022 /* SUBL/V */
2023 gen_sublv(ra, rb, rc, islit, lit);
2024 break;
2025 case 0x4D:
2026 /* CMPLT */
2027 gen_cmp(TCG_COND_LT, ra, rb, rc, islit, lit);
2028 break;
2029 case 0x60:
2030 /* ADDQ/V */
2031 gen_addqv(ra, rb, rc, islit, lit);
2032 break;
2033 case 0x69:
2034 /* SUBQ/V */
2035 gen_subqv(ra, rb, rc, islit, lit);
2036 break;
2037 case 0x6D:
2038 /* CMPLE */
2039 gen_cmp(TCG_COND_LE, ra, rb, rc, islit, lit);
2040 break;
2041 default:
2042 goto invalid_opc;
2043 }
2044 break;
2045 case 0x11:
2046 switch (fn7) {
2047 case 0x00:
2048 /* AND */
2049 if (likely(rc != 31)) {
2050 if (ra == 31)
2051 tcg_gen_movi_i64(cpu_ir[rc], 0);
2052 else if (islit)
2053 tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], lit);
2054 else
2055 tcg_gen_and_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2056 }
2057 break;
2058 case 0x08:
2059 /* BIC */
2060 if (likely(rc != 31)) {
2061 if (ra != 31) {
2062 if (islit)
2063 tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
2064 else
2065 tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2066 } else
2067 tcg_gen_movi_i64(cpu_ir[rc], 0);
2068 }
2069 break;
2070 case 0x14:
2071 /* CMOVLBS */
2072 gen_cmov(TCG_COND_NE, ra, rb, rc, islit, lit, 1);
2073 break;
2074 case 0x16:
2075 /* CMOVLBC */
2076 gen_cmov(TCG_COND_EQ, ra, rb, rc, islit, lit, 1);
2077 break;
2078 case 0x20:
2079 /* BIS */
2080 if (likely(rc != 31)) {
2081 if (ra != 31) {
2082 if (islit)
2083 tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], lit);
2084 else
2085 tcg_gen_or_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2086 } else {
2087 if (islit)
2088 tcg_gen_movi_i64(cpu_ir[rc], lit);
2089 else
2090 tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
2091 }
2092 }
2093 break;
2094 case 0x24:
2095 /* CMOVEQ */
2096 gen_cmov(TCG_COND_EQ, ra, rb, rc, islit, lit, 0);
2097 break;
2098 case 0x26:
2099 /* CMOVNE */
2100 gen_cmov(TCG_COND_NE, ra, rb, rc, islit, lit, 0);
2101 break;
2102 case 0x28:
2103 /* ORNOT */
2104 if (likely(rc != 31)) {
2105 if (ra != 31) {
2106 if (islit)
2107 tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
2108 else
2109 tcg_gen_orc_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2110 } else {
2111 if (islit)
2112 tcg_gen_movi_i64(cpu_ir[rc], ~lit);
2113 else
2114 tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
2115 }
2116 }
2117 break;
2118 case 0x40:
2119 /* XOR */
2120 if (likely(rc != 31)) {
2121 if (ra != 31) {
2122 if (islit)
2123 tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], lit);
2124 else
2125 tcg_gen_xor_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2126 } else {
2127 if (islit)
2128 tcg_gen_movi_i64(cpu_ir[rc], lit);
2129 else
2130 tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
2131 }
2132 }
2133 break;
2134 case 0x44:
2135 /* CMOVLT */
2136 gen_cmov(TCG_COND_LT, ra, rb, rc, islit, lit, 0);
2137 break;
2138 case 0x46:
2139 /* CMOVGE */
2140 gen_cmov(TCG_COND_GE, ra, rb, rc, islit, lit, 0);
2141 break;
2142 case 0x48:
2143 /* EQV */
2144 if (likely(rc != 31)) {
2145 if (ra != 31) {
2146 if (islit)
2147 tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
2148 else
2149 tcg_gen_eqv_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2150 } else {
2151 if (islit)
2152 tcg_gen_movi_i64(cpu_ir[rc], ~lit);
2153 else
2154 tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
2155 }
2156 }
2157 break;
2158 case 0x61:
2159 /* AMASK */
2160 if (likely(rc != 31)) {
2161 uint64_t amask = ctx->tb->flags >> TB_FLAGS_AMASK_SHIFT;
2162
2163 if (islit) {
2164 tcg_gen_movi_i64(cpu_ir[rc], lit & ~amask);
2165 } else {
2166 tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[rb], ~amask);
2167 }
2168 }
2169 break;
2170 case 0x64:
2171 /* CMOVLE */
2172 gen_cmov(TCG_COND_LE, ra, rb, rc, islit, lit, 0);
2173 break;
2174 case 0x66:
2175 /* CMOVGT */
2176 gen_cmov(TCG_COND_GT, ra, rb, rc, islit, lit, 0);
2177 break;
2178 case 0x6C:
2179 /* IMPLVER */
2180 if (rc != 31)
2181 tcg_gen_movi_i64(cpu_ir[rc], ctx->env->implver);
2182 break;
2183 default:
2184 goto invalid_opc;
2185 }
2186 break;
2187 case 0x12:
2188 switch (fn7) {
2189 case 0x02:
2190 /* MSKBL */
2191 gen_msk_l(ra, rb, rc, islit, lit, 0x01);
2192 break;
2193 case 0x06:
2194 /* EXTBL */
2195 gen_ext_l(ra, rb, rc, islit, lit, 0x01);
2196 break;
2197 case 0x0B:
2198 /* INSBL */
2199 gen_ins_l(ra, rb, rc, islit, lit, 0x01);
2200 break;
2201 case 0x12:
2202 /* MSKWL */
2203 gen_msk_l(ra, rb, rc, islit, lit, 0x03);
2204 break;
2205 case 0x16:
2206 /* EXTWL */
2207 gen_ext_l(ra, rb, rc, islit, lit, 0x03);
2208 break;
2209 case 0x1B:
2210 /* INSWL */
2211 gen_ins_l(ra, rb, rc, islit, lit, 0x03);
2212 break;
2213 case 0x22:
2214 /* MSKLL */
2215 gen_msk_l(ra, rb, rc, islit, lit, 0x0f);
2216 break;
2217 case 0x26:
2218 /* EXTLL */
2219 gen_ext_l(ra, rb, rc, islit, lit, 0x0f);
2220 break;
2221 case 0x2B:
2222 /* INSLL */
2223 gen_ins_l(ra, rb, rc, islit, lit, 0x0f);
2224 break;
2225 case 0x30:
2226 /* ZAP */
2227 gen_zap(ra, rb, rc, islit, lit);
2228 break;
2229 case 0x31:
2230 /* ZAPNOT */
2231 gen_zapnot(ra, rb, rc, islit, lit);
2232 break;
2233 case 0x32:
2234 /* MSKQL */
2235 gen_msk_l(ra, rb, rc, islit, lit, 0xff);
2236 break;
2237 case 0x34:
2238 /* SRL */
2239 if (likely(rc != 31)) {
2240 if (ra != 31) {
2241 if (islit)
2242 tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
2243 else {
2244 TCGv shift = tcg_temp_new();
2245 tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
2246 tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], shift);
2247 tcg_temp_free(shift);
2248 }
2249 } else
2250 tcg_gen_movi_i64(cpu_ir[rc], 0);
2251 }
2252 break;
2253 case 0x36:
2254 /* EXTQL */
2255 gen_ext_l(ra, rb, rc, islit, lit, 0xff);
2256 break;
2257 case 0x39:
2258 /* SLL */
2259 if (likely(rc != 31)) {
2260 if (ra != 31) {
2261 if (islit)
2262 tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
2263 else {
2264 TCGv shift = tcg_temp_new();
2265 tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
2266 tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], shift);
2267 tcg_temp_free(shift);
2268 }
2269 } else
2270 tcg_gen_movi_i64(cpu_ir[rc], 0);
2271 }
2272 break;
2273 case 0x3B:
2274 /* INSQL */
2275 gen_ins_l(ra, rb, rc, islit, lit, 0xff);
2276 break;
2277 case 0x3C:
2278 /* SRA */
2279 if (likely(rc != 31)) {
2280 if (ra != 31) {
2281 if (islit)
2282 tcg_gen_sari_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
2283 else {
2284 TCGv shift = tcg_temp_new();
2285 tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
2286 tcg_gen_sar_i64(cpu_ir[rc], cpu_ir[ra], shift);
2287 tcg_temp_free(shift);
2288 }
2289 } else
2290 tcg_gen_movi_i64(cpu_ir[rc], 0);
2291 }
2292 break;
2293 case 0x52:
2294 /* MSKWH */
2295 gen_msk_h(ra, rb, rc, islit, lit, 0x03);
2296 break;
2297 case 0x57:
2298 /* INSWH */
2299 gen_ins_h(ra, rb, rc, islit, lit, 0x03);
2300 break;
2301 case 0x5A:
2302 /* EXTWH */
2303 gen_ext_h(ra, rb, rc, islit, lit, 0x03);
2304 break;
2305 case 0x62:
2306 /* MSKLH */
2307 gen_msk_h(ra, rb, rc, islit, lit, 0x0f);
2308 break;
2309 case 0x67:
2310 /* INSLH */
2311 gen_ins_h(ra, rb, rc, islit, lit, 0x0f);
2312 break;
2313 case 0x6A:
2314 /* EXTLH */
2315 gen_ext_h(ra, rb, rc, islit, lit, 0x0f);
2316 break;
2317 case 0x72:
2318 /* MSKQH */
2319 gen_msk_h(ra, rb, rc, islit, lit, 0xff);
2320 break;
2321 case 0x77:
2322 /* INSQH */
2323 gen_ins_h(ra, rb, rc, islit, lit, 0xff);
2324 break;
2325 case 0x7A:
2326 /* EXTQH */
2327 gen_ext_h(ra, rb, rc, islit, lit, 0xff);
2328 break;
2329 default:
2330 goto invalid_opc;
2331 }
2332 break;
2333 case 0x13:
2334 switch (fn7) {
2335 case 0x00:
2336 /* MULL */
2337 if (likely(rc != 31)) {
2338 if (ra == 31)
2339 tcg_gen_movi_i64(cpu_ir[rc], 0);
2340 else {
2341 if (islit)
2342 tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
2343 else
2344 tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2345 tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
2346 }
2347 }
2348 break;
2349 case 0x20:
2350 /* MULQ */
2351 if (likely(rc != 31)) {
2352 if (ra == 31)
2353 tcg_gen_movi_i64(cpu_ir[rc], 0);
2354 else if (islit)
2355 tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
2356 else
2357 tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2358 }
2359 break;
2360 case 0x30:
2361 /* UMULH */
2362 gen_umulh(ra, rb, rc, islit, lit);
2363 break;
2364 case 0x40:
2365 /* MULL/V */
2366 gen_mullv(ra, rb, rc, islit, lit);
2367 break;
2368 case 0x60:
2369 /* MULQ/V */
2370 gen_mulqv(ra, rb, rc, islit, lit);
2371 break;
2372 default:
2373 goto invalid_opc;
2374 }
2375 break;
2376 case 0x14:
2377 switch (fpfn) { /* fn11 & 0x3F */
2378 case 0x04:
2379 /* ITOFS */
2380 if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
2381 goto invalid_opc;
2382 }
2383 if (likely(rc != 31)) {
2384 if (ra != 31) {
2385 TCGv_i32 tmp = tcg_temp_new_i32();
2386 tcg_gen_trunc_i64_i32(tmp, cpu_ir[ra]);
2387 gen_helper_memory_to_s(cpu_fir[rc], tmp);
2388 tcg_temp_free_i32(tmp);
2389 } else
2390 tcg_gen_movi_i64(cpu_fir[rc], 0);
2391 }
2392 break;
2393 case 0x0A:
2394 /* SQRTF */
2395 if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2396 gen_fsqrtf(rb, rc);
2397 break;
2398 }
2399 goto invalid_opc;
2400 case 0x0B:
2401 /* SQRTS */
2402 if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2403 gen_fsqrts(ctx, rb, rc, fn11);
2404 break;
2405 }
2406 goto invalid_opc;
2407 case 0x14:
2408 /* ITOFF */
2409 if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
2410 goto invalid_opc;
2411 }
2412 if (likely(rc != 31)) {
2413 if (ra != 31) {
2414 TCGv_i32 tmp = tcg_temp_new_i32();
2415 tcg_gen_trunc_i64_i32(tmp, cpu_ir[ra]);
2416 gen_helper_memory_to_f(cpu_fir[rc], tmp);
2417 tcg_temp_free_i32(tmp);
2418 } else
2419 tcg_gen_movi_i64(cpu_fir[rc], 0);
2420 }
2421 break;
2422 case 0x24:
2423 /* ITOFT */
2424 if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
2425 goto invalid_opc;
2426 }
2427 if (likely(rc != 31)) {
2428 if (ra != 31)
2429 tcg_gen_mov_i64(cpu_fir[rc], cpu_ir[ra]);
2430 else
2431 tcg_gen_movi_i64(cpu_fir[rc], 0);
2432 }
2433 break;
2434 case 0x2A:
2435 /* SQRTG */
2436 if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2437 gen_fsqrtg(rb, rc);
2438 break;
2439 }
2440 goto invalid_opc;
2441 case 0x02B:
2442 /* SQRTT */
2443 if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2444 gen_fsqrtt(ctx, rb, rc, fn11);
2445 break;
2446 }
2447 goto invalid_opc;
2448 default:
2449 goto invalid_opc;
2450 }
2451 break;
2452 case 0x15:
2453 /* VAX floating point */
2454 /* XXX: rounding mode and trap are ignored (!) */
2455 switch (fpfn) { /* fn11 & 0x3F */
2456 case 0x00:
2457 /* ADDF */
2458 gen_faddf(ra, rb, rc);
2459 break;
2460 case 0x01:
2461 /* SUBF */
2462 gen_fsubf(ra, rb, rc);
2463 break;
2464 case 0x02:
2465 /* MULF */
2466 gen_fmulf(ra, rb, rc);
2467 break;
2468 case 0x03:
2469 /* DIVF */
2470 gen_fdivf(ra, rb, rc);
2471 break;
2472 case 0x1E:
2473 /* CVTDG */
2474 #if 0 // TODO
2475 gen_fcvtdg(rb, rc);
2476 #else
2477 goto invalid_opc;
2478 #endif
2479 break;
2480 case 0x20:
2481 /* ADDG */
2482 gen_faddg(ra, rb, rc);
2483 break;
2484 case 0x21:
2485 /* SUBG */
2486 gen_fsubg(ra, rb, rc);
2487 break;
2488 case 0x22:
2489 /* MULG */
2490 gen_fmulg(ra, rb, rc);
2491 break;
2492 case 0x23:
2493 /* DIVG */
2494 gen_fdivg(ra, rb, rc);
2495 break;
2496 case 0x25:
2497 /* CMPGEQ */
2498 gen_fcmpgeq(ra, rb, rc);
2499 break;
2500 case 0x26:
2501 /* CMPGLT */
2502 gen_fcmpglt(ra, rb, rc);
2503 break;
2504 case 0x27:
2505 /* CMPGLE */
2506 gen_fcmpgle(ra, rb, rc);
2507 break;
2508 case 0x2C:
2509 /* CVTGF */
2510 gen_fcvtgf(rb, rc);
2511 break;
2512 case 0x2D:
2513 /* CVTGD */
2514 #if 0 // TODO
2515 gen_fcvtgd(rb, rc);
2516 #else
2517 goto invalid_opc;
2518 #endif
2519 break;
2520 case 0x2F:
2521 /* CVTGQ */
2522 gen_fcvtgq(rb, rc);
2523 break;
2524 case 0x3C:
2525 /* CVTQF */
2526 gen_fcvtqf(rb, rc);
2527 break;
2528 case 0x3E:
2529 /* CVTQG */
2530 gen_fcvtqg(rb, rc);
2531 break;
2532 default:
2533 goto invalid_opc;
2534 }
2535 break;
2536 case 0x16:
2537 /* IEEE floating-point */
2538 switch (fpfn) { /* fn11 & 0x3F */
2539 case 0x00:
2540 /* ADDS */
2541 gen_fadds(ctx, ra, rb, rc, fn11);
2542 break;
2543 case 0x01:
2544 /* SUBS */
2545 gen_fsubs(ctx, ra, rb, rc, fn11);
2546 break;
2547 case 0x02:
2548 /* MULS */
2549 gen_fmuls(ctx, ra, rb, rc, fn11);
2550 break;
2551 case 0x03:
2552 /* DIVS */
2553 gen_fdivs(ctx, ra, rb, rc, fn11);
2554 break;
2555 case 0x20:
2556 /* ADDT */
2557 gen_faddt(ctx, ra, rb, rc, fn11);
2558 break;
2559 case 0x21:
2560 /* SUBT */
2561 gen_fsubt(ctx, ra, rb, rc, fn11);
2562 break;
2563 case 0x22:
2564 /* MULT */
2565 gen_fmult(ctx, ra, rb, rc, fn11);
2566 break;
2567 case 0x23:
2568 /* DIVT */
2569 gen_fdivt(ctx, ra, rb, rc, fn11);
2570 break;
2571 case 0x24:
2572 /* CMPTUN */
2573 gen_fcmptun(ctx, ra, rb, rc, fn11);
2574 break;
2575 case 0x25:
2576 /* CMPTEQ */
2577 gen_fcmpteq(ctx, ra, rb, rc, fn11);
2578 break;
2579 case 0x26:
2580 /* CMPTLT */
2581 gen_fcmptlt(ctx, ra, rb, rc, fn11);
2582 break;
2583 case 0x27:
2584 /* CMPTLE */
2585 gen_fcmptle(ctx, ra, rb, rc, fn11);
2586 break;
2587 case 0x2C:
2588 if (fn11 == 0x2AC || fn11 == 0x6AC) {
2589 /* CVTST */
2590 gen_fcvtst(ctx, rb, rc, fn11);
2591 } else {
2592 /* CVTTS */
2593 gen_fcvtts(ctx, rb, rc, fn11);
2594 }
2595 break;
2596 case 0x2F:
2597 /* CVTTQ */
2598 gen_fcvttq(ctx, rb, rc, fn11);
2599 break;
2600 case 0x3C:
2601 /* CVTQS */
2602 gen_fcvtqs(ctx, rb, rc, fn11);
2603 break;
2604 case 0x3E:
2605 /* CVTQT */
2606 gen_fcvtqt(ctx, rb, rc, fn11);
2607 break;
2608 default:
2609 goto invalid_opc;
2610 }
2611 break;
2612 case 0x17:
2613 switch (fn11) {
2614 case 0x010:
2615 /* CVTLQ */
2616 gen_fcvtlq(rb, rc);
2617 break;
2618 case 0x020:
2619 if (likely(rc != 31)) {
2620 if (ra == rb) {
2621 /* FMOV */
2622 if (ra == 31)
2623 tcg_gen_movi_i64(cpu_fir[rc], 0);
2624 else
2625 tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[ra]);
2626 } else {
2627 /* CPYS */
2628 gen_fcpys(ra, rb, rc);
2629 }
2630 }
2631 break;
2632 case 0x021:
2633 /* CPYSN */
2634 gen_fcpysn(ra, rb, rc);
2635 break;
2636 case 0x022:
2637 /* CPYSE */
2638 gen_fcpyse(ra, rb, rc);
2639 break;
2640 case 0x024:
2641 /* MT_FPCR */
2642 if (likely(ra != 31))
2643 gen_helper_store_fpcr(cpu_fir[ra]);
2644 else {
2645 TCGv tmp = tcg_const_i64(0);
2646 gen_helper_store_fpcr(tmp);
2647 tcg_temp_free(tmp);
2648 }
2649 break;
2650 case 0x025:
2651 /* MF_FPCR */
2652 if (likely(ra != 31))
2653 gen_helper_load_fpcr(cpu_fir[ra]);
2654 break;
2655 case 0x02A:
2656 /* FCMOVEQ */
2657 gen_fcmov(TCG_COND_EQ, ra, rb, rc);
2658 break;
2659 case 0x02B:
2660 /* FCMOVNE */
2661 gen_fcmov(TCG_COND_NE, ra, rb, rc);
2662 break;
2663 case 0x02C:
2664 /* FCMOVLT */
2665 gen_fcmov(TCG_COND_LT, ra, rb, rc);
2666 break;
2667 case 0x02D:
2668 /* FCMOVGE */
2669 gen_fcmov(TCG_COND_GE, ra, rb, rc);
2670 break;
2671 case 0x02E:
2672 /* FCMOVLE */
2673 gen_fcmov(TCG_COND_LE, ra, rb, rc);
2674 break;
2675 case 0x02F:
2676 /* FCMOVGT */
2677 gen_fcmov(TCG_COND_GT, ra, rb, rc);
2678 break;
2679 case 0x030:
2680 /* CVTQL */
2681 gen_fcvtql(rb, rc);
2682 break;
2683 case 0x130:
2684 /* CVTQL/V */
2685 case 0x530:
2686 /* CVTQL/SV */
2687 /* ??? I'm pretty sure there's nothing that /sv needs to do that
2688 /v doesn't do. The only thing I can think is that /sv is a
2689 valid instruction merely for completeness in the ISA. */
2690 gen_fcvtql_v(ctx, rb, rc);
2691 break;
2692 default:
2693 goto invalid_opc;
2694 }
2695 break;
2696 case 0x18:
2697 switch ((uint16_t)disp16) {
2698 case 0x0000:
2699 /* TRAPB */
2700 /* No-op. */
2701 break;
2702 case 0x0400:
2703 /* EXCB */
2704 /* No-op. */
2705 break;
2706 case 0x4000:
2707 /* MB */
2708 /* No-op */
2709 break;
2710 case 0x4400:
2711 /* WMB */
2712 /* No-op */
2713 break;
2714 case 0x8000:
2715 /* FETCH */
2716 /* No-op */
2717 break;
2718 case 0xA000:
2719 /* FETCH_M */
2720 /* No-op */
2721 break;
2722 case 0xC000:
2723 /* RPCC */
2724 if (ra != 31)
2725 gen_helper_load_pcc(cpu_ir[ra]);
2726 break;
2727 case 0xE000:
2728 /* RC */
2729 gen_rx(ra, 0);
2730 break;
2731 case 0xE800:
2732 /* ECB */
2733 break;
2734 case 0xF000:
2735 /* RS */
2736 gen_rx(ra, 1);
2737 break;
2738 case 0xF800:
2739 /* WH64 */
2740 /* No-op */
2741 break;
2742 default:
2743 goto invalid_opc;
2744 }
2745 break;
2746 case 0x19:
2747 /* HW_MFPR (PALcode) */
2748 #ifndef CONFIG_USER_ONLY
2749 if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
2750 gen_mfpr(ra, insn & 0xffff);
2751 break;
2752 }
2753 #endif
2754 goto invalid_opc;
2755 case 0x1A:
2756 /* JMP, JSR, RET, JSR_COROUTINE. These only differ by the branch
2757 prediction stack action, which of course we don't implement. */
2758 if (rb != 31) {
2759 tcg_gen_andi_i64(cpu_pc, cpu_ir[rb], ~3);
2760 } else {
2761 tcg_gen_movi_i64(cpu_pc, 0);
2762 }
2763 if (ra != 31) {
2764 tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
2765 }
2766 ret = EXIT_PC_UPDATED;
2767 break;
2768 case 0x1B:
2769 /* HW_LD (PALcode) */
2770 #ifndef CONFIG_USER_ONLY
2771 if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
2772 TCGv addr;
2773
2774 if (ra == 31) {
2775 break;
2776 }
2777
2778 addr = tcg_temp_new();
2779 if (rb != 31)
2780 tcg_gen_addi_i64(addr, cpu_ir[rb], disp12);
2781 else
2782 tcg_gen_movi_i64(addr, disp12);
2783 switch ((insn >> 12) & 0xF) {
2784 case 0x0:
2785 /* Longword physical access (hw_ldl/p) */
2786 gen_helper_ldl_phys(cpu_ir[ra], addr);
2787 break;
2788 case 0x1:
2789 /* Quadword physical access (hw_ldq/p) */
2790 gen_helper_ldq_phys(cpu_ir[ra], addr);
2791 break;
2792 case 0x2:
2793 /* Longword physical access with lock (hw_ldl_l/p) */
2794 gen_helper_ldl_l_phys(cpu_ir[ra], addr);
2795 break;
2796 case 0x3:
2797 /* Quadword physical access with lock (hw_ldq_l/p) */
2798 gen_helper_ldq_l_phys(cpu_ir[ra], addr);
2799 break;
2800 case 0x4:
2801 /* Longword virtual PTE fetch (hw_ldl/v) */
2802 goto invalid_opc;
2803 case 0x5:
2804 /* Quadword virtual PTE fetch (hw_ldq/v) */
2805 goto invalid_opc;
2806 break;
2807 case 0x6:
2808 /* Incpu_ir[ra]id */
2809 goto invalid_opc;
2810 case 0x7:
2811 /* Incpu_ir[ra]id */
2812 goto invalid_opc;
2813 case 0x8:
2814 /* Longword virtual access (hw_ldl) */
2815 goto invalid_opc;
2816 case 0x9:
2817 /* Quadword virtual access (hw_ldq) */
2818 goto invalid_opc;
2819 case 0xA:
2820 /* Longword virtual access with protection check (hw_ldl/w) */
2821 tcg_gen_qemu_ld32s(cpu_ir[ra], addr, MMU_KERNEL_IDX);
2822 break;
2823 case 0xB:
2824 /* Quadword virtual access with protection check (hw_ldq/w) */
2825 tcg_gen_qemu_ld64(cpu_ir[ra], addr, MMU_KERNEL_IDX);
2826 break;
2827 case 0xC:
2828 /* Longword virtual access with alt access mode (hw_ldl/a)*/
2829 goto invalid_opc;
2830 case 0xD:
2831 /* Quadword virtual access with alt access mode (hw_ldq/a) */
2832 goto invalid_opc;
2833 case 0xE:
2834 /* Longword virtual access with alternate access mode and
2835 protection checks (hw_ldl/wa) */
2836 tcg_gen_qemu_ld32s(cpu_ir[ra], addr, MMU_USER_IDX);
2837 break;
2838 case 0xF:
2839 /* Quadword virtual access with alternate access mode and
2840 protection checks (hw_ldq/wa) */
2841 tcg_gen_qemu_ld64(cpu_ir[ra], addr, MMU_USER_IDX);
2842 break;
2843 }
2844 tcg_temp_free(addr);
2845 break;
2846 }
2847 #endif
2848 goto invalid_opc;
2849 case 0x1C:
2850 switch (fn7) {
2851 case 0x00:
2852 /* SEXTB */
2853 if ((ctx->tb->flags & TB_FLAGS_AMASK_BWX) == 0) {
2854 goto invalid_opc;
2855 }
2856 if (likely(rc != 31)) {
2857 if (islit)
2858 tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int8_t)lit));
2859 else
2860 tcg_gen_ext8s_i64(cpu_ir[rc], cpu_ir[rb]);
2861 }
2862 break;
2863 case 0x01:
2864 /* SEXTW */
2865 if (ctx->tb->flags & TB_FLAGS_AMASK_BWX) {
2866 if (likely(rc != 31)) {
2867 if (islit) {
2868 tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int16_t)lit));
2869 } else {
2870 tcg_gen_ext16s_i64(cpu_ir[rc], cpu_ir[rb]);
2871 }
2872 }
2873 break;
2874 }
2875 goto invalid_opc;
2876 case 0x30:
2877 /* CTPOP */
2878 if (ctx->tb->flags & TB_FLAGS_AMASK_CIX) {
2879 if (likely(rc != 31)) {
2880 if (islit) {
2881 tcg_gen_movi_i64(cpu_ir[rc], ctpop64(lit));
2882 } else {
2883 gen_helper_ctpop(cpu_ir[rc], cpu_ir[rb]);
2884 }
2885 }
2886 break;
2887 }
2888 goto invalid_opc;
2889 case 0x31:
2890 /* PERR */
2891 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2892 gen_perr(ra, rb, rc, islit, lit);
2893 break;
2894 }
2895 goto invalid_opc;
2896 case 0x32:
2897 /* CTLZ */
2898 if (ctx->tb->flags & TB_FLAGS_AMASK_CIX) {
2899 if (likely(rc != 31)) {
2900 if (islit) {
2901 tcg_gen_movi_i64(cpu_ir[rc], clz64(lit));
2902 } else {
2903 gen_helper_ctlz(cpu_ir[rc], cpu_ir[rb]);
2904 }
2905 }
2906 break;
2907 }
2908 goto invalid_opc;
2909 case 0x33:
2910 /* CTTZ */
2911 if (ctx->tb->flags & TB_FLAGS_AMASK_CIX) {
2912 if (likely(rc != 31)) {
2913 if (islit) {
2914 tcg_gen_movi_i64(cpu_ir[rc], ctz64(lit));
2915 } else {
2916 gen_helper_cttz(cpu_ir[rc], cpu_ir[rb]);
2917 }
2918 }
2919 break;
2920 }
2921 goto invalid_opc;
2922 case 0x34:
2923 /* UNPKBW */
2924 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2925 if (real_islit || ra != 31) {
2926 goto invalid_opc;
2927 }
2928 gen_unpkbw(rb, rc);
2929 break;
2930 }
2931 goto invalid_opc;
2932 case 0x35:
2933 /* UNPKBL */
2934 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2935 if (real_islit || ra != 31) {
2936 goto invalid_opc;
2937 }
2938 gen_unpkbl(rb, rc);
2939 break;
2940 }
2941 goto invalid_opc;
2942 case 0x36:
2943 /* PKWB */
2944 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2945 if (real_islit || ra != 31) {
2946 goto invalid_opc;
2947 }
2948 gen_pkwb(rb, rc);
2949 break;
2950 }
2951 goto invalid_opc;
2952 case 0x37:
2953 /* PKLB */
2954 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2955 if (real_islit || ra != 31) {
2956 goto invalid_opc;
2957 }
2958 gen_pklb(rb, rc);
2959 break;
2960 }
2961 goto invalid_opc;
2962 case 0x38:
2963 /* MINSB8 */
2964 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2965 gen_minsb8(ra, rb, rc, islit, lit);
2966 break;
2967 }
2968 goto invalid_opc;
2969 case 0x39:
2970 /* MINSW4 */
2971 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2972 gen_minsw4(ra, rb, rc, islit, lit);
2973 break;
2974 }
2975 goto invalid_opc;
2976 case 0x3A:
2977 /* MINUB8 */
2978 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2979 gen_minub8(ra, rb, rc, islit, lit);
2980 break;
2981 }
2982 goto invalid_opc;
2983 case 0x3B:
2984 /* MINUW4 */
2985 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2986 gen_minuw4(ra, rb, rc, islit, lit);
2987 break;
2988 }
2989 goto invalid_opc;
2990 case 0x3C:
2991 /* MAXUB8 */
2992 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2993 gen_maxub8(ra, rb, rc, islit, lit);
2994 break;
2995 }
2996 goto invalid_opc;
2997 case 0x3D:
2998 /* MAXUW4 */
2999 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3000 gen_maxuw4(ra, rb, rc, islit, lit);
3001 break;
3002 }
3003 goto invalid_opc;
3004 case 0x3E:
3005 /* MAXSB8 */
3006 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3007 gen_maxsb8(ra, rb, rc, islit, lit);
3008 break;
3009 }
3010 goto invalid_opc;
3011 case 0x3F:
3012 /* MAXSW4 */
3013 if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3014 gen_maxsw4(ra, rb, rc, islit, lit);
3015 break;
3016 }
3017 goto invalid_opc;
3018 case 0x70:
3019 /* FTOIT */
3020 if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
3021 goto invalid_opc;
3022 }
3023 if (likely(rc != 31)) {
3024 if (ra != 31)
3025 tcg_gen_mov_i64(cpu_ir[rc], cpu_fir[ra]);
3026 else
3027 tcg_gen_movi_i64(cpu_ir[rc], 0);
3028 }
3029 break;
3030 case 0x78:
3031 /* FTOIS */
3032 if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
3033 goto invalid_opc;
3034 }
3035 if (rc != 31) {
3036 TCGv_i32 tmp1 = tcg_temp_new_i32();
3037 if (ra != 31)
3038 gen_helper_s_to_memory(tmp1, cpu_fir[ra]);
3039 else {
3040 TCGv tmp2 = tcg_const_i64(0);
3041 gen_helper_s_to_memory(tmp1, tmp2);
3042 tcg_temp_free(tmp2);
3043 }
3044 tcg_gen_ext_i32_i64(cpu_ir[rc], tmp1);
3045 tcg_temp_free_i32(tmp1);
3046 }
3047 break;
3048 default:
3049 goto invalid_opc;
3050 }
3051 break;
3052 case 0x1D:
3053 /* HW_MTPR (PALcode) */
3054 #ifndef CONFIG_USER_ONLY
3055 if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
3056 gen_mtpr(rb, insn & 0xffff);
3057 break;
3058 }
3059 #endif
3060 goto invalid_opc;
3061 case 0x1E:
3062 /* HW_RET (PALcode) */
3063 #ifndef CONFIG_USER_ONLY
3064 if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
3065 if (rb == 31) {
3066 /* Pre-EV6 CPUs interpreted this as HW_REI, loading the return
3067 address from EXC_ADDR. This turns out to be useful for our
3068 emulation PALcode, so continue to accept it. */
3069 TCGv tmp = tcg_temp_new();
3070 tcg_gen_ld_i64(tmp, cpu_env, offsetof(CPUState, exc_addr));
3071 gen_helper_hw_ret(tmp);
3072 tcg_temp_free(tmp);
3073 } else {
3074 gen_helper_hw_ret(cpu_ir[rb]);
3075 }
3076 ret = EXIT_PC_UPDATED;
3077 break;
3078 }
3079 #endif
3080 goto invalid_opc;
3081 case 0x1F:
3082 /* HW_ST (PALcode) */
3083 #ifndef CONFIG_USER_ONLY
3084 if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
3085 TCGv addr, val;
3086 addr = tcg_temp_new();
3087 if (rb != 31)
3088 tcg_gen_addi_i64(addr, cpu_ir[rb], disp12);
3089 else
3090 tcg_gen_movi_i64(addr, disp12);
3091 if (ra != 31)
3092 val = cpu_ir[ra];
3093 else {
3094 val = tcg_temp_new();
3095 tcg_gen_movi_i64(val, 0);
3096 }
3097 switch ((insn >> 12) & 0xF) {
3098 case 0x0:
3099 /* Longword physical access */
3100 gen_helper_stl_phys(addr, val);
3101 break;
3102 case 0x1:
3103 /* Quadword physical access */
3104 gen_helper_stq_phys(addr, val);
3105 break;
3106 case 0x2:
3107 /* Longword physical access with lock */
3108 gen_helper_stl_c_phys(val, addr, val);
3109 break;
3110 case 0x3:
3111 /* Quadword physical access with lock */
3112 gen_helper_stq_c_phys(val, addr, val);
3113 break;
3114 case 0x4:
3115 /* Longword virtual access */
3116 goto invalid_opc;
3117 case 0x5:
3118 /* Quadword virtual access */
3119 goto invalid_opc;
3120 case 0x6:
3121 /* Invalid */
3122 goto invalid_opc;
3123 case 0x7:
3124 /* Invalid */
3125 goto invalid_opc;
3126 case 0x8:
3127 /* Invalid */
3128 goto invalid_opc;
3129 case 0x9:
3130 /* Invalid */
3131 goto invalid_opc;
3132 case 0xA:
3133 /* Invalid */
3134 goto invalid_opc;
3135 case 0xB:
3136 /* Invalid */
3137 goto invalid_opc;
3138 case 0xC:
3139 /* Longword virtual access with alternate access mode */
3140 goto invalid_opc;
3141 case 0xD:
3142 /* Quadword virtual access with alternate access mode */
3143 goto invalid_opc;
3144 case 0xE:
3145 /* Invalid */
3146 goto invalid_opc;
3147 case 0xF:
3148 /* Invalid */
3149 goto invalid_opc;
3150 }
3151 if (ra == 31)
3152 tcg_temp_free(val);
3153 tcg_temp_free(addr);
3154 break;
3155 }
3156 #endif
3157 goto invalid_opc;
3158 case 0x20:
3159 /* LDF */
3160 gen_load_mem(ctx, &gen_qemu_ldf, ra, rb, disp16, 1, 0);
3161 break;
3162 case 0x21:
3163 /* LDG */
3164 gen_load_mem(ctx, &gen_qemu_ldg, ra, rb, disp16, 1, 0);
3165 break;
3166 case 0x22:
3167 /* LDS */
3168 gen_load_mem(ctx, &gen_qemu_lds, ra, rb, disp16, 1, 0);
3169 break;
3170 case 0x23:
3171 /* LDT */
3172 gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 1, 0);
3173 break;
3174 case 0x24:
3175 /* STF */
3176 gen_store_mem(ctx, &gen_qemu_stf, ra, rb, disp16, 1, 0);
3177 break;
3178 case 0x25:
3179 /* STG */
3180 gen_store_mem(ctx, &gen_qemu_stg, ra, rb, disp16, 1, 0);
3181 break;
3182 case 0x26:
3183 /* STS */
3184 gen_store_mem(ctx, &gen_qemu_sts, ra, rb, disp16, 1, 0);
3185 break;
3186 case 0x27:
3187 /* STT */
3188 gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 1, 0);
3189 break;
3190 case 0x28:
3191 /* LDL */
3192 gen_load_mem(ctx, &tcg_gen_qemu_ld32s, ra, rb, disp16, 0, 0);
3193 break;
3194 case 0x29:
3195 /* LDQ */
3196 gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 0, 0);
3197 break;
3198 case 0x2A:
3199 /* LDL_L */
3200 gen_load_mem(ctx, &gen_qemu_ldl_l, ra, rb, disp16, 0, 0);
3201 break;
3202 case 0x2B:
3203 /* LDQ_L */
3204 gen_load_mem(ctx, &gen_qemu_ldq_l, ra, rb, disp16, 0, 0);
3205 break;
3206 case 0x2C:
3207 /* STL */
3208 gen_store_mem(ctx, &tcg_gen_qemu_st32, ra, rb, disp16, 0, 0);
3209 break;
3210 case 0x2D:
3211 /* STQ */
3212 gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 0, 0);
3213 break;
3214 case 0x2E:
3215 /* STL_C */
3216 ret = gen_store_conditional(ctx, ra, rb, disp16, 0);
3217 break;
3218 case 0x2F:
3219 /* STQ_C */
3220 ret = gen_store_conditional(ctx, ra, rb, disp16, 1);
3221 break;
3222 case 0x30:
3223 /* BR */
3224 ret = gen_bdirect(ctx, ra, disp21);
3225 break;
3226 case 0x31: /* FBEQ */
3227 ret = gen_fbcond(ctx, TCG_COND_EQ, ra, disp21);
3228 break;
3229 case 0x32: /* FBLT */
3230 ret = gen_fbcond(ctx, TCG_COND_LT, ra, disp21);
3231 break;
3232 case 0x33: /* FBLE */
3233 ret = gen_fbcond(ctx, TCG_COND_LE, ra, disp21);
3234 break;
3235 case 0x34:
3236 /* BSR */
3237 ret = gen_bdirect(ctx, ra, disp21);
3238 break;
3239 case 0x35: /* FBNE */
3240 ret = gen_fbcond(ctx, TCG_COND_NE, ra, disp21);
3241 break;
3242 case 0x36: /* FBGE */
3243 ret = gen_fbcond(ctx, TCG_COND_GE, ra, disp21);
3244 break;
3245 case 0x37: /* FBGT */
3246 ret = gen_fbcond(ctx, TCG_COND_GT, ra, disp21);
3247 break;
3248 case 0x38:
3249 /* BLBC */
3250 ret = gen_bcond(ctx, TCG_COND_EQ, ra, disp21, 1);
3251 break;
3252 case 0x39:
3253 /* BEQ */
3254 ret = gen_bcond(ctx, TCG_COND_EQ, ra, disp21, 0);
3255 break;
3256 case 0x3A:
3257 /* BLT */
3258 ret = gen_bcond(ctx, TCG_COND_LT, ra, disp21, 0);
3259 break;
3260 case 0x3B:
3261 /* BLE */
3262 ret = gen_bcond(ctx, TCG_COND_LE, ra, disp21, 0);
3263 break;
3264 case 0x3C:
3265 /* BLBS */
3266 ret = gen_bcond(ctx, TCG_COND_NE, ra, disp21, 1);
3267 break;
3268 case 0x3D:
3269 /* BNE */
3270 ret = gen_bcond(ctx, TCG_COND_NE, ra, disp21, 0);
3271 break;
3272 case 0x3E:
3273 /* BGE */
3274 ret = gen_bcond(ctx, TCG_COND_GE, ra, disp21, 0);
3275 break;
3276 case 0x3F:
3277 /* BGT */
3278 ret = gen_bcond(ctx, TCG_COND_GT, ra, disp21, 0);
3279 break;
3280 invalid_opc:
3281 ret = gen_invalid(ctx);
3282 break;
3283 }
3284
3285 return ret;
3286 }
3287
3288 static inline void gen_intermediate_code_internal(CPUState *env,
3289 TranslationBlock *tb,
3290 int search_pc)
3291 {
3292 DisasContext ctx, *ctxp = &ctx;
3293 target_ulong pc_start;
3294 uint32_t insn;
3295 uint16_t *gen_opc_end;
3296 CPUBreakpoint *bp;
3297 int j, lj = -1;
3298 ExitStatus ret;
3299 int num_insns;
3300 int max_insns;
3301
3302 pc_start = tb->pc;
3303 gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
3304
3305 ctx.tb = tb;
3306 ctx.env = env;
3307 ctx.pc = pc_start;
3308 ctx.mem_idx = cpu_mmu_index(env);
3309
3310 /* ??? Every TB begins with unset rounding mode, to be initialized on
3311 the first fp insn of the TB. Alternately we could define a proper
3312 default for every TB (e.g. QUAL_RM_N or QUAL_RM_D) and make sure
3313 to reset the FP_STATUS to that default at the end of any TB that
3314 changes the default. We could even (gasp) dynamiclly figure out
3315 what default would be most efficient given the running program. */
3316 ctx.tb_rm = -1;
3317 /* Similarly for flush-to-zero. */
3318 ctx.tb_ftz = -1;
3319
3320 num_insns = 0;
3321 max_insns = tb->cflags & CF_COUNT_MASK;
3322 if (max_insns == 0)
3323 max_insns = CF_COUNT_MASK;
3324
3325 gen_icount_start();
3326 do {
3327 if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
3328 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
3329 if (bp->pc == ctx.pc) {
3330 gen_excp(&ctx, EXCP_DEBUG, 0);
3331 break;
3332 }
3333 }
3334 }
3335 if (search_pc) {
3336 j = gen_opc_ptr - gen_opc_buf;
3337 if (lj < j) {
3338 lj++;
3339 while (lj < j)
3340 gen_opc_instr_start[lj++] = 0;
3341 }
3342 gen_opc_pc[lj] = ctx.pc;
3343 gen_opc_instr_start[lj] = 1;
3344 gen_opc_icount[lj] = num_insns;
3345 }
3346 if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
3347 gen_io_start();
3348 insn = ldl_code(ctx.pc);
3349 num_insns++;
3350
3351 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
3352 tcg_gen_debug_insn_start(ctx.pc);
3353 }
3354
3355 ctx.pc += 4;
3356 ret = translate_one(ctxp, insn);
3357
3358 /* If we reach a page boundary, are single stepping,
3359 or exhaust instruction count, stop generation. */
3360 if (ret == NO_EXIT
3361 && ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0
3362 || gen_opc_ptr >= gen_opc_end
3363 || num_insns >= max_insns
3364 || singlestep
3365 || env->singlestep_enabled)) {
3366 ret = EXIT_PC_STALE;
3367 }
3368 } while (ret == NO_EXIT);
3369
3370 if (tb->cflags & CF_LAST_IO) {
3371 gen_io_end();
3372 }
3373
3374 switch (ret) {
3375 case EXIT_GOTO_TB:
3376 case EXIT_NORETURN:
3377 break;
3378 case EXIT_PC_STALE:
3379 tcg_gen_movi_i64(cpu_pc, ctx.pc);
3380 /* FALLTHRU */
3381 case EXIT_PC_UPDATED:
3382 if (env->singlestep_enabled) {
3383 gen_excp_1(EXCP_DEBUG, 0);
3384 } else {
3385 tcg_gen_exit_tb(0);
3386 }
3387 break;
3388 default:
3389 abort();
3390 }
3391
3392 gen_icount_end(tb, num_insns);
3393 *gen_opc_ptr = INDEX_op_end;
3394 if (search_pc) {
3395 j = gen_opc_ptr - gen_opc_buf;
3396 lj++;
3397 while (lj <= j)
3398 gen_opc_instr_start[lj++] = 0;
3399 } else {
3400 tb->size = ctx.pc - pc_start;
3401 tb->icount = num_insns;
3402 }
3403
3404 #ifdef DEBUG_DISAS
3405 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
3406 qemu_log("IN: %s\n", lookup_symbol(pc_start));
3407 log_target_disas(pc_start, ctx.pc - pc_start, 1);
3408 qemu_log("\n");
3409 }
3410 #endif
3411 }
3412
3413 void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
3414 {
3415 gen_intermediate_code_internal(env, tb, 0);
3416 }
3417
3418 void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
3419 {
3420 gen_intermediate_code_internal(env, tb, 1);
3421 }
3422
3423 struct cpu_def_t {
3424 const char *name;
3425 int implver, amask;
3426 };
3427
3428 static const struct cpu_def_t cpu_defs[] = {
3429 { "ev4", IMPLVER_2106x, 0 },
3430 { "ev5", IMPLVER_21164, 0 },
3431 { "ev56", IMPLVER_21164, AMASK_BWX },
3432 { "pca56", IMPLVER_21164, AMASK_BWX | AMASK_MVI },
3433 { "ev6", IMPLVER_21264, AMASK_BWX | AMASK_FIX | AMASK_MVI | AMASK_TRAP },
3434 { "ev67", IMPLVER_21264, (AMASK_BWX | AMASK_FIX | AMASK_CIX
3435 | AMASK_MVI | AMASK_TRAP | AMASK_PREFETCH), },
3436 { "ev68", IMPLVER_21264, (AMASK_BWX | AMASK_FIX | AMASK_CIX
3437 | AMASK_MVI | AMASK_TRAP | AMASK_PREFETCH), },
3438 { "21064", IMPLVER_2106x, 0 },
3439 { "21164", IMPLVER_21164, 0 },
3440 { "21164a", IMPLVER_21164, AMASK_BWX },
3441 { "21164pc", IMPLVER_21164, AMASK_BWX | AMASK_MVI },
3442 { "21264", IMPLVER_21264, AMASK_BWX | AMASK_FIX | AMASK_MVI | AMASK_TRAP },
3443 { "21264a", IMPLVER_21264, (AMASK_BWX | AMASK_FIX | AMASK_CIX
3444 | AMASK_MVI | AMASK_TRAP | AMASK_PREFETCH), }
3445 };
3446
3447 CPUAlphaState * cpu_alpha_init (const char *cpu_model)
3448 {
3449 CPUAlphaState *env;
3450 int implver, amask, i, max;
3451
3452 env = qemu_mallocz(sizeof(CPUAlphaState));
3453 cpu_exec_init(env);
3454 alpha_translate_init();
3455 tlb_flush(env, 1);
3456
3457 /* Default to ev67; no reason not to emulate insns by default. */
3458 implver = IMPLVER_21264;
3459 amask = (AMASK_BWX | AMASK_FIX | AMASK_CIX | AMASK_MVI
3460 | AMASK_TRAP | AMASK_PREFETCH);
3461
3462 max = ARRAY_SIZE(cpu_defs);
3463 for (i = 0; i < max; i++) {
3464 if (strcmp (cpu_model, cpu_defs[i].name) == 0) {
3465 implver = cpu_defs[i].implver;
3466 amask = cpu_defs[i].amask;
3467 break;
3468 }
3469 }
3470 env->implver = implver;
3471 env->amask = amask;
3472
3473 #if defined (CONFIG_USER_ONLY)
3474 env->ps = PS_USER_MODE;
3475 cpu_alpha_store_fpcr(env, (FPCR_INVD | FPCR_DZED | FPCR_OVFD
3476 | FPCR_UNFD | FPCR_INED | FPCR_DNOD));
3477 #endif
3478 env->lock_addr = -1;
3479 env->fen = 1;
3480
3481 qemu_init_vcpu(env);
3482 return env;
3483 }
3484
3485 void restore_state_to_opc(CPUState *env, TranslationBlock *tb, int pc_pos)
3486 {
3487 env->pc = gen_opc_pc[pc_pos];
3488 }
Anthony Liguori's QEMU tree