]> git.proxmox.com Git - qemu.git/blame_incremental - target-ppc/translate.c
projects / qemu.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
target-ppc: retain l{w,d}arx loaded value
[qemu.git] / target-ppc / translate.c
... / ...
CommitLineData
1/*
2 * PowerPC emulation for qemu: main translation routines.
3 *
4 * Copyright (c) 2003-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#include <stdarg.h>
20#include <stdlib.h>
21#include <stdio.h>
22#include <string.h>
23#include <inttypes.h>
24
25#include "cpu.h"
26#include "exec-all.h"
27#include "disas.h"
28#include "tcg-op.h"
29#include "qemu-common.h"
30#include "host-utils.h"
31
32#include "helper.h"
33#define GEN_HELPER 1
34#include "helper.h"
35
36#define CPU_SINGLE_STEP 0x1
37#define CPU_BRANCH_STEP 0x2
38#define GDBSTUB_SINGLE_STEP 0x4
39
40/* Include definitions for instructions classes and implementations flags */
41//#define PPC_DEBUG_DISAS
42//#define DO_PPC_STATISTICS
43
44#ifdef PPC_DEBUG_DISAS
45# define LOG_DISAS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
46#else
47# define LOG_DISAS(...) do { } while (0)
48#endif
49/*****************************************************************************/
50/* Code translation helpers */
51
52/* global register indexes */
53static TCGv_ptr cpu_env;
54static char cpu_reg_names[10*3 + 22*4 /* GPR */
55#if !defined(TARGET_PPC64)
56 + 10*4 + 22*5 /* SPE GPRh */
57#endif
58 + 10*4 + 22*5 /* FPR */
59 + 2*(10*6 + 22*7) /* AVRh, AVRl */
60 + 8*5 /* CRF */];
61static TCGv cpu_gpr[32];
62#if !defined(TARGET_PPC64)
63static TCGv cpu_gprh[32];
64#endif
65static TCGv_i64 cpu_fpr[32];
66static TCGv_i64 cpu_avrh[32], cpu_avrl[32];
67static TCGv_i32 cpu_crf[8];
68static TCGv cpu_nip;
69static TCGv cpu_msr;
70static TCGv cpu_ctr;
71static TCGv cpu_lr;
72static TCGv cpu_xer;
73static TCGv cpu_reserve;
74static TCGv_i32 cpu_fpscr;
75static TCGv_i32 cpu_access_type;
76
77#include "gen-icount.h"
78
79void ppc_translate_init(void)
80{
81 int i;
82 char* p;
83 size_t cpu_reg_names_size;
84 static int done_init = 0;
85
86 if (done_init)
87 return;
88
89 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
90
91 p = cpu_reg_names;
92 cpu_reg_names_size = sizeof(cpu_reg_names);
93
94 for (i = 0; i < 8; i++) {
95 snprintf(p, cpu_reg_names_size, "crf%d", i);
96 cpu_crf[i] = tcg_global_mem_new_i32(TCG_AREG0,
97 offsetof(CPUState, crf[i]), p);
98 p += 5;
99 cpu_reg_names_size -= 5;
100 }
101
102 for (i = 0; i < 32; i++) {
103 snprintf(p, cpu_reg_names_size, "r%d", i);
104 cpu_gpr[i] = tcg_global_mem_new(TCG_AREG0,
105 offsetof(CPUState, gpr[i]), p);
106 p += (i < 10) ? 3 : 4;
107 cpu_reg_names_size -= (i < 10) ? 3 : 4;
108#if !defined(TARGET_PPC64)
109 snprintf(p, cpu_reg_names_size, "r%dH", i);
110 cpu_gprh[i] = tcg_global_mem_new_i32(TCG_AREG0,
111 offsetof(CPUState, gprh[i]), p);
112 p += (i < 10) ? 4 : 5;
113 cpu_reg_names_size -= (i < 10) ? 4 : 5;
114#endif
115
116 snprintf(p, cpu_reg_names_size, "fp%d", i);
117 cpu_fpr[i] = tcg_global_mem_new_i64(TCG_AREG0,
118 offsetof(CPUState, fpr[i]), p);
119 p += (i < 10) ? 4 : 5;
120 cpu_reg_names_size -= (i < 10) ? 4 : 5;
121
122 snprintf(p, cpu_reg_names_size, "avr%dH", i);
123#ifdef HOST_WORDS_BIGENDIAN
124 cpu_avrh[i] = tcg_global_mem_new_i64(TCG_AREG0,
125 offsetof(CPUState, avr[i].u64[0]), p);
126#else
127 cpu_avrh[i] = tcg_global_mem_new_i64(TCG_AREG0,
128 offsetof(CPUState, avr[i].u64[1]), p);
129#endif
130 p += (i < 10) ? 6 : 7;
131 cpu_reg_names_size -= (i < 10) ? 6 : 7;
132
133 snprintf(p, cpu_reg_names_size, "avr%dL", i);
134#ifdef HOST_WORDS_BIGENDIAN
135 cpu_avrl[i] = tcg_global_mem_new_i64(TCG_AREG0,
136 offsetof(CPUState, avr[i].u64[1]), p);
137#else
138 cpu_avrl[i] = tcg_global_mem_new_i64(TCG_AREG0,
139 offsetof(CPUState, avr[i].u64[0]), p);
140#endif
141 p += (i < 10) ? 6 : 7;
142 cpu_reg_names_size -= (i < 10) ? 6 : 7;
143 }
144
145 cpu_nip = tcg_global_mem_new(TCG_AREG0,
146 offsetof(CPUState, nip), "nip");
147
148 cpu_msr = tcg_global_mem_new(TCG_AREG0,
149 offsetof(CPUState, msr), "msr");
150
151 cpu_ctr = tcg_global_mem_new(TCG_AREG0,
152 offsetof(CPUState, ctr), "ctr");
153
154 cpu_lr = tcg_global_mem_new(TCG_AREG0,
155 offsetof(CPUState, lr), "lr");
156
157 cpu_xer = tcg_global_mem_new(TCG_AREG0,
158 offsetof(CPUState, xer), "xer");
159
160 cpu_reserve = tcg_global_mem_new(TCG_AREG0,
161 offsetof(CPUState, reserve_addr),
162 "reserve_addr");
163
164 cpu_fpscr = tcg_global_mem_new_i32(TCG_AREG0,
165 offsetof(CPUState, fpscr), "fpscr");
166
167 cpu_access_type = tcg_global_mem_new_i32(TCG_AREG0,
168 offsetof(CPUState, access_type), "access_type");
169
170 /* register helpers */
171#define GEN_HELPER 2
172#include "helper.h"
173
174 done_init = 1;
175}
176
177/* internal defines */
178typedef struct DisasContext {
179 struct TranslationBlock *tb;
180 target_ulong nip;
181 uint32_t opcode;
182 uint32_t exception;
183 /* Routine used to access memory */
184 int mem_idx;
185 int access_type;
186 /* Translation flags */
187 int le_mode;
188#if defined(TARGET_PPC64)
189 int sf_mode;
190#endif
191 int fpu_enabled;
192 int altivec_enabled;
193 int spe_enabled;
194 ppc_spr_t *spr_cb; /* Needed to check rights for mfspr/mtspr */
195 int singlestep_enabled;
196} DisasContext;
197
198struct opc_handler_t {
199 /* invalid bits */
200 uint32_t inval;
201 /* instruction type */
202 uint64_t type;
203 /* handler */
204 void (*handler)(DisasContext *ctx);
205#if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
206 const char *oname;
207#endif
208#if defined(DO_PPC_STATISTICS)
209 uint64_t count;
210#endif
211};
212
213static always_inline void gen_reset_fpstatus (void)
214{
215#ifdef CONFIG_SOFTFLOAT
216 gen_helper_reset_fpstatus();
217#endif
218}
219
220static always_inline void gen_compute_fprf (TCGv_i64 arg, int set_fprf, int set_rc)
221{
222 TCGv_i32 t0 = tcg_temp_new_i32();
223
224 if (set_fprf != 0) {
225 /* This case might be optimized later */
226 tcg_gen_movi_i32(t0, 1);
227 gen_helper_compute_fprf(t0, arg, t0);
228 if (unlikely(set_rc)) {
229 tcg_gen_mov_i32(cpu_crf[1], t0);
230 }
231 gen_helper_float_check_status();
232 } else if (unlikely(set_rc)) {
233 /* We always need to compute fpcc */
234 tcg_gen_movi_i32(t0, 0);
235 gen_helper_compute_fprf(t0, arg, t0);
236 tcg_gen_mov_i32(cpu_crf[1], t0);
237 }
238
239 tcg_temp_free_i32(t0);
240}
241
242static always_inline void gen_set_access_type (DisasContext *ctx, int access_type)
243{
244 if (ctx->access_type != access_type) {
245 tcg_gen_movi_i32(cpu_access_type, access_type);
246 ctx->access_type = access_type;
247 }
248}
249
250static always_inline void gen_update_nip (DisasContext *ctx, target_ulong nip)
251{
252#if defined(TARGET_PPC64)
253 if (ctx->sf_mode)
254 tcg_gen_movi_tl(cpu_nip, nip);
255 else
256#endif
257 tcg_gen_movi_tl(cpu_nip, (uint32_t)nip);
258}
259
260static always_inline void gen_exception_err (DisasContext *ctx, uint32_t excp, uint32_t error)
261{
262 TCGv_i32 t0, t1;
263 if (ctx->exception == POWERPC_EXCP_NONE) {
264 gen_update_nip(ctx, ctx->nip);
265 }
266 t0 = tcg_const_i32(excp);
267 t1 = tcg_const_i32(error);
268 gen_helper_raise_exception_err(t0, t1);
269 tcg_temp_free_i32(t0);
270 tcg_temp_free_i32(t1);
271 ctx->exception = (excp);
272}
273
274static always_inline void gen_exception (DisasContext *ctx, uint32_t excp)
275{
276 TCGv_i32 t0;
277 if (ctx->exception == POWERPC_EXCP_NONE) {
278 gen_update_nip(ctx, ctx->nip);
279 }
280 t0 = tcg_const_i32(excp);
281 gen_helper_raise_exception(t0);
282 tcg_temp_free_i32(t0);
283 ctx->exception = (excp);
284}
285
286static always_inline void gen_debug_exception (DisasContext *ctx)
287{
288 TCGv_i32 t0;
289
290 if (ctx->exception != POWERPC_EXCP_BRANCH)
291 gen_update_nip(ctx, ctx->nip);
292 t0 = tcg_const_i32(EXCP_DEBUG);
293 gen_helper_raise_exception(t0);
294 tcg_temp_free_i32(t0);
295}
296
297static always_inline void gen_inval_exception (DisasContext *ctx, uint32_t error)
298{
299 gen_exception_err(ctx, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_INVAL | error);
300}
301
302/* Stop translation */
303static always_inline void gen_stop_exception (DisasContext *ctx)
304{
305 gen_update_nip(ctx, ctx->nip);
306 ctx->exception = POWERPC_EXCP_STOP;
307}
308
309/* No need to update nip here, as execution flow will change */
310static always_inline void gen_sync_exception (DisasContext *ctx)
311{
312 ctx->exception = POWERPC_EXCP_SYNC;
313}
314
315#define GEN_HANDLER(name, opc1, opc2, opc3, inval, type) \
316GEN_OPCODE(name, opc1, opc2, opc3, inval, type)
317
318#define GEN_HANDLER2(name, onam, opc1, opc2, opc3, inval, type) \
319GEN_OPCODE2(name, onam, opc1, opc2, opc3, inval, type)
320
321typedef struct opcode_t {
322 unsigned char opc1, opc2, opc3;
323#if HOST_LONG_BITS == 64 /* Explicitly align to 64 bits */
324 unsigned char pad[5];
325#else
326 unsigned char pad[1];
327#endif
328 opc_handler_t handler;
329 const char *oname;
330} opcode_t;
331
332/*****************************************************************************/
333/*** Instruction decoding ***/
334#define EXTRACT_HELPER(name, shift, nb) \
335static always_inline uint32_t name (uint32_t opcode) \
336{ \
337 return (opcode >> (shift)) & ((1 << (nb)) - 1); \
338}
339
340#define EXTRACT_SHELPER(name, shift, nb) \
341static always_inline int32_t name (uint32_t opcode) \
342{ \
343 return (int16_t)((opcode >> (shift)) & ((1 << (nb)) - 1)); \
344}
345
346/* Opcode part 1 */
347EXTRACT_HELPER(opc1, 26, 6);
348/* Opcode part 2 */
349EXTRACT_HELPER(opc2, 1, 5);
350/* Opcode part 3 */
351EXTRACT_HELPER(opc3, 6, 5);
352/* Update Cr0 flags */
353EXTRACT_HELPER(Rc, 0, 1);
354/* Destination */
355EXTRACT_HELPER(rD, 21, 5);
356/* Source */
357EXTRACT_HELPER(rS, 21, 5);
358/* First operand */
359EXTRACT_HELPER(rA, 16, 5);
360/* Second operand */
361EXTRACT_HELPER(rB, 11, 5);
362/* Third operand */
363EXTRACT_HELPER(rC, 6, 5);
364/*** Get CRn ***/
365EXTRACT_HELPER(crfD, 23, 3);
366EXTRACT_HELPER(crfS, 18, 3);
367EXTRACT_HELPER(crbD, 21, 5);
368EXTRACT_HELPER(crbA, 16, 5);
369EXTRACT_HELPER(crbB, 11, 5);
370/* SPR / TBL */
371EXTRACT_HELPER(_SPR, 11, 10);
372static always_inline uint32_t SPR (uint32_t opcode)
373{
374 uint32_t sprn = _SPR(opcode);
375
376 return ((sprn >> 5) & 0x1F) | ((sprn & 0x1F) << 5);
377}
378/*** Get constants ***/
379EXTRACT_HELPER(IMM, 12, 8);
380/* 16 bits signed immediate value */
381EXTRACT_SHELPER(SIMM, 0, 16);
382/* 16 bits unsigned immediate value */
383EXTRACT_HELPER(UIMM, 0, 16);
384/* 5 bits signed immediate value */
385EXTRACT_HELPER(SIMM5, 16, 5);
386/* 5 bits signed immediate value */
387EXTRACT_HELPER(UIMM5, 16, 5);
388/* Bit count */
389EXTRACT_HELPER(NB, 11, 5);
390/* Shift count */
391EXTRACT_HELPER(SH, 11, 5);
392/* Vector shift count */
393EXTRACT_HELPER(VSH, 6, 4);
394/* Mask start */
395EXTRACT_HELPER(MB, 6, 5);
396/* Mask end */
397EXTRACT_HELPER(ME, 1, 5);
398/* Trap operand */
399EXTRACT_HELPER(TO, 21, 5);
400
401EXTRACT_HELPER(CRM, 12, 8);
402EXTRACT_HELPER(FM, 17, 8);
403EXTRACT_HELPER(SR, 16, 4);
404EXTRACT_HELPER(FPIMM, 12, 4);
405
406/*** Jump target decoding ***/
407/* Displacement */
408EXTRACT_SHELPER(d, 0, 16);
409/* Immediate address */
410static always_inline target_ulong LI (uint32_t opcode)
411{
412 return (opcode >> 0) & 0x03FFFFFC;
413}
414
415static always_inline uint32_t BD (uint32_t opcode)
416{
417 return (opcode >> 0) & 0xFFFC;
418}
419
420EXTRACT_HELPER(BO, 21, 5);
421EXTRACT_HELPER(BI, 16, 5);
422/* Absolute/relative address */
423EXTRACT_HELPER(AA, 1, 1);
424/* Link */
425EXTRACT_HELPER(LK, 0, 1);
426
427/* Create a mask between <start> and <end> bits */
428static always_inline target_ulong MASK (uint32_t start, uint32_t end)
429{
430 target_ulong ret;
431
432#if defined(TARGET_PPC64)
433 if (likely(start == 0)) {
434 ret = UINT64_MAX << (63 - end);
435 } else if (likely(end == 63)) {
436 ret = UINT64_MAX >> start;
437 }
438#else
439 if (likely(start == 0)) {
440 ret = UINT32_MAX << (31 - end);
441 } else if (likely(end == 31)) {
442 ret = UINT32_MAX >> start;
443 }
444#endif
445 else {
446 ret = (((target_ulong)(-1ULL)) >> (start)) ^
447 (((target_ulong)(-1ULL) >> (end)) >> 1);
448 if (unlikely(start > end))
449 return ~ret;
450 }
451
452 return ret;
453}
454
455/*****************************************************************************/
456/* PowerPC instructions table */
457
458#if defined(DO_PPC_STATISTICS)
459#define GEN_OPCODE(name, op1, op2, op3, invl, _typ) \
460{ \
461 .opc1 = op1, \
462 .opc2 = op2, \
463 .opc3 = op3, \
464 .pad = { 0, }, \
465 .handler = { \
466 .inval = invl, \
467 .type = _typ, \
468 .handler = &gen_##name, \
469 .oname = stringify(name), \
470 }, \
471 .oname = stringify(name), \
472}
473#define GEN_OPCODE2(name, onam, op1, op2, op3, invl, _typ) \
474{ \
475 .opc1 = op1, \
476 .opc2 = op2, \
477 .opc3 = op3, \
478 .pad = { 0, }, \
479 .handler = { \
480 .inval = invl, \
481 .type = _typ, \
482 .handler = &gen_##name, \
483 .oname = onam, \
484 }, \
485 .oname = onam, \
486}
487#else
488#define GEN_OPCODE(name, op1, op2, op3, invl, _typ) \
489{ \
490 .opc1 = op1, \
491 .opc2 = op2, \
492 .opc3 = op3, \
493 .pad = { 0, }, \
494 .handler = { \
495 .inval = invl, \
496 .type = _typ, \
497 .handler = &gen_##name, \
498 }, \
499 .oname = stringify(name), \
500}
501#define GEN_OPCODE2(name, onam, op1, op2, op3, invl, _typ) \
502{ \
503 .opc1 = op1, \
504 .opc2 = op2, \
505 .opc3 = op3, \
506 .pad = { 0, }, \
507 .handler = { \
508 .inval = invl, \
509 .type = _typ, \
510 .handler = &gen_##name, \
511 }, \
512 .oname = onam, \
513}
514#endif
515
516/* SPR load/store helpers */
517static always_inline void gen_load_spr(TCGv t, int reg)
518{
519 tcg_gen_ld_tl(t, cpu_env, offsetof(CPUState, spr[reg]));
520}
521
522static always_inline void gen_store_spr(int reg, TCGv t)
523{
524 tcg_gen_st_tl(t, cpu_env, offsetof(CPUState, spr[reg]));
525}
526
527/* Invalid instruction */
528static void gen_invalid(DisasContext *ctx)
529{
530 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
531}
532
533static opc_handler_t invalid_handler = {
534 .inval = 0xFFFFFFFF,
535 .type = PPC_NONE,
536 .handler = gen_invalid,
537};
538
539/*** Integer comparison ***/
540
541static always_inline void gen_op_cmp(TCGv arg0, TCGv arg1, int s, int crf)
542{
543 int l1, l2, l3;
544
545 tcg_gen_trunc_tl_i32(cpu_crf[crf], cpu_xer);
546 tcg_gen_shri_i32(cpu_crf[crf], cpu_crf[crf], XER_SO);
547 tcg_gen_andi_i32(cpu_crf[crf], cpu_crf[crf], 1);
548
549 l1 = gen_new_label();
550 l2 = gen_new_label();
551 l3 = gen_new_label();
552 if (s) {
553 tcg_gen_brcond_tl(TCG_COND_LT, arg0, arg1, l1);
554 tcg_gen_brcond_tl(TCG_COND_GT, arg0, arg1, l2);
555 } else {
556 tcg_gen_brcond_tl(TCG_COND_LTU, arg0, arg1, l1);
557 tcg_gen_brcond_tl(TCG_COND_GTU, arg0, arg1, l2);
558 }
559 tcg_gen_ori_i32(cpu_crf[crf], cpu_crf[crf], 1 << CRF_EQ);
560 tcg_gen_br(l3);
561 gen_set_label(l1);
562 tcg_gen_ori_i32(cpu_crf[crf], cpu_crf[crf], 1 << CRF_LT);
563 tcg_gen_br(l3);
564 gen_set_label(l2);
565 tcg_gen_ori_i32(cpu_crf[crf], cpu_crf[crf], 1 << CRF_GT);
566 gen_set_label(l3);
567}
568
569static always_inline void gen_op_cmpi(TCGv arg0, target_ulong arg1, int s, int crf)
570{
571 TCGv t0 = tcg_const_local_tl(arg1);
572 gen_op_cmp(arg0, t0, s, crf);
573 tcg_temp_free(t0);
574}
575
576#if defined(TARGET_PPC64)
577static always_inline void gen_op_cmp32(TCGv arg0, TCGv arg1, int s, int crf)
578{
579 TCGv t0, t1;
580 t0 = tcg_temp_local_new();
581 t1 = tcg_temp_local_new();
582 if (s) {
583 tcg_gen_ext32s_tl(t0, arg0);
584 tcg_gen_ext32s_tl(t1, arg1);
585 } else {
586 tcg_gen_ext32u_tl(t0, arg0);
587 tcg_gen_ext32u_tl(t1, arg1);
588 }
589 gen_op_cmp(t0, t1, s, crf);
590 tcg_temp_free(t1);
591 tcg_temp_free(t0);
592}
593
594static always_inline void gen_op_cmpi32(TCGv arg0, target_ulong arg1, int s, int crf)
595{
596 TCGv t0 = tcg_const_local_tl(arg1);
597 gen_op_cmp32(arg0, t0, s, crf);
598 tcg_temp_free(t0);
599}
600#endif
601
602static always_inline void gen_set_Rc0 (DisasContext *ctx, TCGv reg)
603{
604#if defined(TARGET_PPC64)
605 if (!(ctx->sf_mode))
606 gen_op_cmpi32(reg, 0, 1, 0);
607 else
608#endif
609 gen_op_cmpi(reg, 0, 1, 0);
610}
611
612/* cmp */
613static void gen_cmp(DisasContext *ctx)
614{
615#if defined(TARGET_PPC64)
616 if (!(ctx->sf_mode && (ctx->opcode & 0x00200000)))
617 gen_op_cmp32(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],
618 1, crfD(ctx->opcode));
619 else
620#endif
621 gen_op_cmp(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],
622 1, crfD(ctx->opcode));
623}
624
625/* cmpi */
626static void gen_cmpi(DisasContext *ctx)
627{
628#if defined(TARGET_PPC64)
629 if (!(ctx->sf_mode && (ctx->opcode & 0x00200000)))
630 gen_op_cmpi32(cpu_gpr[rA(ctx->opcode)], SIMM(ctx->opcode),
631 1, crfD(ctx->opcode));
632 else
633#endif
634 gen_op_cmpi(cpu_gpr[rA(ctx->opcode)], SIMM(ctx->opcode),
635 1, crfD(ctx->opcode));
636}
637
638/* cmpl */
639static void gen_cmpl(DisasContext *ctx)
640{
641#if defined(TARGET_PPC64)
642 if (!(ctx->sf_mode && (ctx->opcode & 0x00200000)))
643 gen_op_cmp32(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],
644 0, crfD(ctx->opcode));
645 else
646#endif
647 gen_op_cmp(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],
648 0, crfD(ctx->opcode));
649}
650
651/* cmpli */
652static void gen_cmpli(DisasContext *ctx)
653{
654#if defined(TARGET_PPC64)
655 if (!(ctx->sf_mode && (ctx->opcode & 0x00200000)))
656 gen_op_cmpi32(cpu_gpr[rA(ctx->opcode)], UIMM(ctx->opcode),
657 0, crfD(ctx->opcode));
658 else
659#endif
660 gen_op_cmpi(cpu_gpr[rA(ctx->opcode)], UIMM(ctx->opcode),
661 0, crfD(ctx->opcode));
662}
663
664/* isel (PowerPC 2.03 specification) */
665static void gen_isel(DisasContext *ctx)
666{
667 int l1, l2;
668 uint32_t bi = rC(ctx->opcode);
669 uint32_t mask;
670 TCGv_i32 t0;
671
672 l1 = gen_new_label();
673 l2 = gen_new_label();
674
675 mask = 1 << (3 - (bi & 0x03));
676 t0 = tcg_temp_new_i32();
677 tcg_gen_andi_i32(t0, cpu_crf[bi >> 2], mask);
678 tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l1);
679 if (rA(ctx->opcode) == 0)
680 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], 0);
681 else
682 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
683 tcg_gen_br(l2);
684 gen_set_label(l1);
685 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
686 gen_set_label(l2);
687 tcg_temp_free_i32(t0);
688}
689
690/*** Integer arithmetic ***/
691
692static always_inline void gen_op_arith_compute_ov(DisasContext *ctx, TCGv arg0, TCGv arg1, TCGv arg2, int sub)
693{
694 int l1;
695 TCGv t0;
696
697 l1 = gen_new_label();
698 /* Start with XER OV disabled, the most likely case */
699 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
700 t0 = tcg_temp_local_new();
701 tcg_gen_xor_tl(t0, arg0, arg1);
702#if defined(TARGET_PPC64)
703 if (!ctx->sf_mode)
704 tcg_gen_ext32s_tl(t0, t0);
705#endif
706 if (sub)
707 tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0, l1);
708 else
709 tcg_gen_brcondi_tl(TCG_COND_GE, t0, 0, l1);
710 tcg_gen_xor_tl(t0, arg1, arg2);
711#if defined(TARGET_PPC64)
712 if (!ctx->sf_mode)
713 tcg_gen_ext32s_tl(t0, t0);
714#endif
715 if (sub)
716 tcg_gen_brcondi_tl(TCG_COND_GE, t0, 0, l1);
717 else
718 tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0, l1);
719 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
720 gen_set_label(l1);
721 tcg_temp_free(t0);
722}
723
724static always_inline void gen_op_arith_compute_ca(DisasContext *ctx, TCGv arg1, TCGv arg2, int sub)
725{
726 int l1 = gen_new_label();
727
728#if defined(TARGET_PPC64)
729 if (!(ctx->sf_mode)) {
730 TCGv t0, t1;
731 t0 = tcg_temp_new();
732 t1 = tcg_temp_new();
733
734 tcg_gen_ext32u_tl(t0, arg1);
735 tcg_gen_ext32u_tl(t1, arg2);
736 if (sub) {
737 tcg_gen_brcond_tl(TCG_COND_GTU, t0, t1, l1);
738 } else {
739 tcg_gen_brcond_tl(TCG_COND_GEU, t0, t1, l1);
740 }
741 tcg_gen_ori_tl(cpu_xer, cpu_xer, 1 << XER_CA);
742 gen_set_label(l1);
743 tcg_temp_free(t0);
744 tcg_temp_free(t1);
745 } else
746#endif
747 {
748 if (sub) {
749 tcg_gen_brcond_tl(TCG_COND_GTU, arg1, arg2, l1);
750 } else {
751 tcg_gen_brcond_tl(TCG_COND_GEU, arg1, arg2, l1);
752 }
753 tcg_gen_ori_tl(cpu_xer, cpu_xer, 1 << XER_CA);
754 gen_set_label(l1);
755 }
756}
757
758/* Common add function */
759static always_inline void gen_op_arith_add(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,
760 int add_ca, int compute_ca, int compute_ov)
761{
762 TCGv t0, t1;
763
764 if ((!compute_ca && !compute_ov) ||
765 (!TCGV_EQUAL(ret,arg1) && !TCGV_EQUAL(ret, arg2))) {
766 t0 = ret;
767 } else {
768 t0 = tcg_temp_local_new();
769 }
770
771 if (add_ca) {
772 t1 = tcg_temp_local_new();
773 tcg_gen_andi_tl(t1, cpu_xer, (1 << XER_CA));
774 tcg_gen_shri_tl(t1, t1, XER_CA);
775 } else {
776 TCGV_UNUSED(t1);
777 }
778
779 if (compute_ca && compute_ov) {
780 /* Start with XER CA and OV disabled, the most likely case */
781 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~((1 << XER_CA) | (1 << XER_OV)));
782 } else if (compute_ca) {
783 /* Start with XER CA disabled, the most likely case */
784 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
785 } else if (compute_ov) {
786 /* Start with XER OV disabled, the most likely case */
787 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
788 }
789
790 tcg_gen_add_tl(t0, arg1, arg2);
791
792 if (compute_ca) {
793 gen_op_arith_compute_ca(ctx, t0, arg1, 0);
794 }
795 if (add_ca) {
796 tcg_gen_add_tl(t0, t0, t1);
797 gen_op_arith_compute_ca(ctx, t0, t1, 0);
798 tcg_temp_free(t1);
799 }
800 if (compute_ov) {
801 gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 0);
802 }
803
804 if (unlikely(Rc(ctx->opcode) != 0))
805 gen_set_Rc0(ctx, t0);
806
807 if (!TCGV_EQUAL(t0, ret)) {
808 tcg_gen_mov_tl(ret, t0);
809 tcg_temp_free(t0);
810 }
811}
812/* Add functions with two operands */
813#define GEN_INT_ARITH_ADD(name, opc3, add_ca, compute_ca, compute_ov) \
814static void glue(gen_, name)(DisasContext *ctx) \
815{ \
816 gen_op_arith_add(ctx, cpu_gpr[rD(ctx->opcode)], \
817 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], \
818 add_ca, compute_ca, compute_ov); \
819}
820/* Add functions with one operand and one immediate */
821#define GEN_INT_ARITH_ADD_CONST(name, opc3, const_val, \
822 add_ca, compute_ca, compute_ov) \
823static void glue(gen_, name)(DisasContext *ctx) \
824{ \
825 TCGv t0 = tcg_const_local_tl(const_val); \
826 gen_op_arith_add(ctx, cpu_gpr[rD(ctx->opcode)], \
827 cpu_gpr[rA(ctx->opcode)], t0, \
828 add_ca, compute_ca, compute_ov); \
829 tcg_temp_free(t0); \
830}
831
832/* add add. addo addo. */
833GEN_INT_ARITH_ADD(add, 0x08, 0, 0, 0)
834GEN_INT_ARITH_ADD(addo, 0x18, 0, 0, 1)
835/* addc addc. addco addco. */
836GEN_INT_ARITH_ADD(addc, 0x00, 0, 1, 0)
837GEN_INT_ARITH_ADD(addco, 0x10, 0, 1, 1)
838/* adde adde. addeo addeo. */
839GEN_INT_ARITH_ADD(adde, 0x04, 1, 1, 0)
840GEN_INT_ARITH_ADD(addeo, 0x14, 1, 1, 1)
841/* addme addme. addmeo addmeo. */
842GEN_INT_ARITH_ADD_CONST(addme, 0x07, -1LL, 1, 1, 0)
843GEN_INT_ARITH_ADD_CONST(addmeo, 0x17, -1LL, 1, 1, 1)
844/* addze addze. addzeo addzeo.*/
845GEN_INT_ARITH_ADD_CONST(addze, 0x06, 0, 1, 1, 0)
846GEN_INT_ARITH_ADD_CONST(addzeo, 0x16, 0, 1, 1, 1)
847/* addi */
848static void gen_addi(DisasContext *ctx)
849{
850 target_long simm = SIMM(ctx->opcode);
851
852 if (rA(ctx->opcode) == 0) {
853 /* li case */
854 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], simm);
855 } else {
856 tcg_gen_addi_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], simm);
857 }
858}
859/* addic addic.*/
860static always_inline void gen_op_addic (DisasContext *ctx, TCGv ret, TCGv arg1,
861 int compute_Rc0)
862{
863 target_long simm = SIMM(ctx->opcode);
864
865 /* Start with XER CA and OV disabled, the most likely case */
866 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
867
868 if (likely(simm != 0)) {
869 TCGv t0 = tcg_temp_local_new();
870 tcg_gen_addi_tl(t0, arg1, simm);
871 gen_op_arith_compute_ca(ctx, t0, arg1, 0);
872 tcg_gen_mov_tl(ret, t0);
873 tcg_temp_free(t0);
874 } else {
875 tcg_gen_mov_tl(ret, arg1);
876 }
877 if (compute_Rc0) {
878 gen_set_Rc0(ctx, ret);
879 }
880}
881
882static void gen_addic(DisasContext *ctx)
883{
884 gen_op_addic(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0);
885}
886
887static void gen_addic_(DisasContext *ctx)
888{
889 gen_op_addic(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 1);
890}
891
892/* addis */
893static void gen_addis(DisasContext *ctx)
894{
895 target_long simm = SIMM(ctx->opcode);
896
897 if (rA(ctx->opcode) == 0) {
898 /* lis case */
899 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], simm << 16);
900 } else {
901 tcg_gen_addi_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], simm << 16);
902 }
903}
904
905static always_inline void gen_op_arith_divw (DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,
906 int sign, int compute_ov)
907{
908 int l1 = gen_new_label();
909 int l2 = gen_new_label();
910 TCGv_i32 t0 = tcg_temp_local_new_i32();
911 TCGv_i32 t1 = tcg_temp_local_new_i32();
912
913 tcg_gen_trunc_tl_i32(t0, arg1);
914 tcg_gen_trunc_tl_i32(t1, arg2);
915 tcg_gen_brcondi_i32(TCG_COND_EQ, t1, 0, l1);
916 if (sign) {
917 int l3 = gen_new_label();
918 tcg_gen_brcondi_i32(TCG_COND_NE, t1, -1, l3);
919 tcg_gen_brcondi_i32(TCG_COND_EQ, t0, INT32_MIN, l1);
920 gen_set_label(l3);
921 tcg_gen_div_i32(t0, t0, t1);
922 } else {
923 tcg_gen_divu_i32(t0, t0, t1);
924 }
925 if (compute_ov) {
926 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
927 }
928 tcg_gen_br(l2);
929 gen_set_label(l1);
930 if (sign) {
931 tcg_gen_sari_i32(t0, t0, 31);
932 } else {
933 tcg_gen_movi_i32(t0, 0);
934 }
935 if (compute_ov) {
936 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
937 }
938 gen_set_label(l2);
939 tcg_gen_extu_i32_tl(ret, t0);
940 tcg_temp_free_i32(t0);
941 tcg_temp_free_i32(t1);
942 if (unlikely(Rc(ctx->opcode) != 0))
943 gen_set_Rc0(ctx, ret);
944}
945/* Div functions */
946#define GEN_INT_ARITH_DIVW(name, opc3, sign, compute_ov) \
947static void glue(gen_, name)(DisasContext *ctx) \
948{ \
949 gen_op_arith_divw(ctx, cpu_gpr[rD(ctx->opcode)], \
950 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], \
951 sign, compute_ov); \
952}
953/* divwu divwu. divwuo divwuo. */
954GEN_INT_ARITH_DIVW(divwu, 0x0E, 0, 0);
955GEN_INT_ARITH_DIVW(divwuo, 0x1E, 0, 1);
956/* divw divw. divwo divwo. */
957GEN_INT_ARITH_DIVW(divw, 0x0F, 1, 0);
958GEN_INT_ARITH_DIVW(divwo, 0x1F, 1, 1);
959#if defined(TARGET_PPC64)
960static always_inline void gen_op_arith_divd (DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,
961 int sign, int compute_ov)
962{
963 int l1 = gen_new_label();
964 int l2 = gen_new_label();
965
966 tcg_gen_brcondi_i64(TCG_COND_EQ, arg2, 0, l1);
967 if (sign) {
968 int l3 = gen_new_label();
969 tcg_gen_brcondi_i64(TCG_COND_NE, arg2, -1, l3);
970 tcg_gen_brcondi_i64(TCG_COND_EQ, arg1, INT64_MIN, l1);
971 gen_set_label(l3);
972 tcg_gen_div_i64(ret, arg1, arg2);
973 } else {
974 tcg_gen_divu_i64(ret, arg1, arg2);
975 }
976 if (compute_ov) {
977 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
978 }
979 tcg_gen_br(l2);
980 gen_set_label(l1);
981 if (sign) {
982 tcg_gen_sari_i64(ret, arg1, 63);
983 } else {
984 tcg_gen_movi_i64(ret, 0);
985 }
986 if (compute_ov) {
987 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
988 }
989 gen_set_label(l2);
990 if (unlikely(Rc(ctx->opcode) != 0))
991 gen_set_Rc0(ctx, ret);
992}
993#define GEN_INT_ARITH_DIVD(name, opc3, sign, compute_ov) \
994static void glue(gen_, name)(DisasContext *ctx) \
995{ \
996 gen_op_arith_divd(ctx, cpu_gpr[rD(ctx->opcode)], \
997 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], \
998 sign, compute_ov); \
999}
1000/* divwu divwu. divwuo divwuo. */
1001GEN_INT_ARITH_DIVD(divdu, 0x0E, 0, 0);
1002GEN_INT_ARITH_DIVD(divduo, 0x1E, 0, 1);
1003/* divw divw. divwo divwo. */
1004GEN_INT_ARITH_DIVD(divd, 0x0F, 1, 0);
1005GEN_INT_ARITH_DIVD(divdo, 0x1F, 1, 1);
1006#endif
1007
1008/* mulhw mulhw. */
1009static void gen_mulhw(DisasContext *ctx)
1010{
1011 TCGv_i64 t0, t1;
1012
1013 t0 = tcg_temp_new_i64();
1014 t1 = tcg_temp_new_i64();
1015#if defined(TARGET_PPC64)
1016 tcg_gen_ext32s_tl(t0, cpu_gpr[rA(ctx->opcode)]);
1017 tcg_gen_ext32s_tl(t1, cpu_gpr[rB(ctx->opcode)]);
1018 tcg_gen_mul_i64(t0, t0, t1);
1019 tcg_gen_shri_i64(cpu_gpr[rD(ctx->opcode)], t0, 32);
1020#else
1021 tcg_gen_ext_tl_i64(t0, cpu_gpr[rA(ctx->opcode)]);
1022 tcg_gen_ext_tl_i64(t1, cpu_gpr[rB(ctx->opcode)]);
1023 tcg_gen_mul_i64(t0, t0, t1);
1024 tcg_gen_shri_i64(t0, t0, 32);
1025 tcg_gen_trunc_i64_tl(cpu_gpr[rD(ctx->opcode)], t0);
1026#endif
1027 tcg_temp_free_i64(t0);
1028 tcg_temp_free_i64(t1);
1029 if (unlikely(Rc(ctx->opcode) != 0))
1030 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1031}
1032
1033/* mulhwu mulhwu. */
1034static void gen_mulhwu(DisasContext *ctx)
1035{
1036 TCGv_i64 t0, t1;
1037
1038 t0 = tcg_temp_new_i64();
1039 t1 = tcg_temp_new_i64();
1040#if defined(TARGET_PPC64)
1041 tcg_gen_ext32u_i64(t0, cpu_gpr[rA(ctx->opcode)]);
1042 tcg_gen_ext32u_i64(t1, cpu_gpr[rB(ctx->opcode)]);
1043 tcg_gen_mul_i64(t0, t0, t1);
1044 tcg_gen_shri_i64(cpu_gpr[rD(ctx->opcode)], t0, 32);
1045#else
1046 tcg_gen_extu_tl_i64(t0, cpu_gpr[rA(ctx->opcode)]);
1047 tcg_gen_extu_tl_i64(t1, cpu_gpr[rB(ctx->opcode)]);
1048 tcg_gen_mul_i64(t0, t0, t1);
1049 tcg_gen_shri_i64(t0, t0, 32);
1050 tcg_gen_trunc_i64_tl(cpu_gpr[rD(ctx->opcode)], t0);
1051#endif
1052 tcg_temp_free_i64(t0);
1053 tcg_temp_free_i64(t1);
1054 if (unlikely(Rc(ctx->opcode) != 0))
1055 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1056}
1057
1058/* mullw mullw. */
1059static void gen_mullw(DisasContext *ctx)
1060{
1061 tcg_gen_mul_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
1062 cpu_gpr[rB(ctx->opcode)]);
1063 tcg_gen_ext32s_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)]);
1064 if (unlikely(Rc(ctx->opcode) != 0))
1065 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1066}
1067
1068/* mullwo mullwo. */
1069static void gen_mullwo(DisasContext *ctx)
1070{
1071 int l1;
1072 TCGv_i64 t0, t1;
1073
1074 t0 = tcg_temp_new_i64();
1075 t1 = tcg_temp_new_i64();
1076 l1 = gen_new_label();
1077 /* Start with XER OV disabled, the most likely case */
1078 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
1079#if defined(TARGET_PPC64)
1080 tcg_gen_ext32s_i64(t0, cpu_gpr[rA(ctx->opcode)]);
1081 tcg_gen_ext32s_i64(t1, cpu_gpr[rB(ctx->opcode)]);
1082#else
1083 tcg_gen_ext_tl_i64(t0, cpu_gpr[rA(ctx->opcode)]);
1084 tcg_gen_ext_tl_i64(t1, cpu_gpr[rB(ctx->opcode)]);
1085#endif
1086 tcg_gen_mul_i64(t0, t0, t1);
1087#if defined(TARGET_PPC64)
1088 tcg_gen_ext32s_i64(cpu_gpr[rD(ctx->opcode)], t0);
1089 tcg_gen_brcond_i64(TCG_COND_EQ, t0, cpu_gpr[rD(ctx->opcode)], l1);
1090#else
1091 tcg_gen_trunc_i64_tl(cpu_gpr[rD(ctx->opcode)], t0);
1092 tcg_gen_ext32s_i64(t1, t0);
1093 tcg_gen_brcond_i64(TCG_COND_EQ, t0, t1, l1);
1094#endif
1095 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
1096 gen_set_label(l1);
1097 tcg_temp_free_i64(t0);
1098 tcg_temp_free_i64(t1);
1099 if (unlikely(Rc(ctx->opcode) != 0))
1100 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1101}
1102
1103/* mulli */
1104static void gen_mulli(DisasContext *ctx)
1105{
1106 tcg_gen_muli_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
1107 SIMM(ctx->opcode));
1108}
1109#if defined(TARGET_PPC64)
1110#define GEN_INT_ARITH_MUL_HELPER(name, opc3) \
1111static void glue(gen_, name)(DisasContext *ctx) \
1112{ \
1113 gen_helper_##name (cpu_gpr[rD(ctx->opcode)], \
1114 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); \
1115 if (unlikely(Rc(ctx->opcode) != 0)) \
1116 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]); \
1117}
1118/* mulhd mulhd. */
1119GEN_INT_ARITH_MUL_HELPER(mulhdu, 0x00);
1120/* mulhdu mulhdu. */
1121GEN_INT_ARITH_MUL_HELPER(mulhd, 0x02);
1122
1123/* mulld mulld. */
1124static void gen_mulld(DisasContext *ctx)
1125{
1126 tcg_gen_mul_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
1127 cpu_gpr[rB(ctx->opcode)]);
1128 if (unlikely(Rc(ctx->opcode) != 0))
1129 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1130}
1131/* mulldo mulldo. */
1132GEN_INT_ARITH_MUL_HELPER(mulldo, 0x17);
1133#endif
1134
1135/* neg neg. nego nego. */
1136static always_inline void gen_op_arith_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)
1137{
1138 int l1 = gen_new_label();
1139 int l2 = gen_new_label();
1140 TCGv t0 = tcg_temp_local_new();
1141#if defined(TARGET_PPC64)
1142 if (ctx->sf_mode) {
1143 tcg_gen_mov_tl(t0, arg1);
1144 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, INT64_MIN, l1);
1145 } else
1146#endif
1147 {
1148 tcg_gen_ext32s_tl(t0, arg1);
1149 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, INT32_MIN, l1);
1150 }
1151 tcg_gen_neg_tl(ret, arg1);
1152 if (ov_check) {
1153 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
1154 }
1155 tcg_gen_br(l2);
1156 gen_set_label(l1);
1157 tcg_gen_mov_tl(ret, t0);
1158 if (ov_check) {
1159 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
1160 }
1161 gen_set_label(l2);
1162 tcg_temp_free(t0);
1163 if (unlikely(Rc(ctx->opcode) != 0))
1164 gen_set_Rc0(ctx, ret);
1165}
1166
1167static void gen_neg(DisasContext *ctx)
1168{
1169 gen_op_arith_neg(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0);
1170}
1171
1172static void gen_nego(DisasContext *ctx)
1173{
1174 gen_op_arith_neg(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 1);
1175}
1176
1177/* Common subf function */
1178static always_inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,
1179 int add_ca, int compute_ca, int compute_ov)
1180{
1181 TCGv t0, t1;
1182
1183 if ((!compute_ca && !compute_ov) ||
1184 (!TCGV_EQUAL(ret, arg1) && !TCGV_EQUAL(ret, arg2))) {
1185 t0 = ret;
1186 } else {
1187 t0 = tcg_temp_local_new();
1188 }
1189
1190 if (add_ca) {
1191 t1 = tcg_temp_local_new();
1192 tcg_gen_andi_tl(t1, cpu_xer, (1 << XER_CA));
1193 tcg_gen_shri_tl(t1, t1, XER_CA);
1194 } else {
1195 TCGV_UNUSED(t1);
1196 }
1197
1198 if (compute_ca && compute_ov) {
1199 /* Start with XER CA and OV disabled, the most likely case */
1200 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~((1 << XER_CA) | (1 << XER_OV)));
1201 } else if (compute_ca) {
1202 /* Start with XER CA disabled, the most likely case */
1203 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
1204 } else if (compute_ov) {
1205 /* Start with XER OV disabled, the most likely case */
1206 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
1207 }
1208
1209 if (add_ca) {
1210 tcg_gen_not_tl(t0, arg1);
1211 tcg_gen_add_tl(t0, t0, arg2);
1212 gen_op_arith_compute_ca(ctx, t0, arg2, 0);
1213 tcg_gen_add_tl(t0, t0, t1);
1214 gen_op_arith_compute_ca(ctx, t0, t1, 0);
1215 tcg_temp_free(t1);
1216 } else {
1217 tcg_gen_sub_tl(t0, arg2, arg1);
1218 if (compute_ca) {
1219 gen_op_arith_compute_ca(ctx, t0, arg2, 1);
1220 }
1221 }
1222 if (compute_ov) {
1223 gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 1);
1224 }
1225
1226 if (unlikely(Rc(ctx->opcode) != 0))
1227 gen_set_Rc0(ctx, t0);
1228
1229 if (!TCGV_EQUAL(t0, ret)) {
1230 tcg_gen_mov_tl(ret, t0);
1231 tcg_temp_free(t0);
1232 }
1233}
1234/* Sub functions with Two operands functions */
1235#define GEN_INT_ARITH_SUBF(name, opc3, add_ca, compute_ca, compute_ov) \
1236static void glue(gen_, name)(DisasContext *ctx) \
1237{ \
1238 gen_op_arith_subf(ctx, cpu_gpr[rD(ctx->opcode)], \
1239 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], \
1240 add_ca, compute_ca, compute_ov); \
1241}
1242/* Sub functions with one operand and one immediate */
1243#define GEN_INT_ARITH_SUBF_CONST(name, opc3, const_val, \
1244 add_ca, compute_ca, compute_ov) \
1245static void glue(gen_, name)(DisasContext *ctx) \
1246{ \
1247 TCGv t0 = tcg_const_local_tl(const_val); \
1248 gen_op_arith_subf(ctx, cpu_gpr[rD(ctx->opcode)], \
1249 cpu_gpr[rA(ctx->opcode)], t0, \
1250 add_ca, compute_ca, compute_ov); \
1251 tcg_temp_free(t0); \
1252}
1253/* subf subf. subfo subfo. */
1254GEN_INT_ARITH_SUBF(subf, 0x01, 0, 0, 0)
1255GEN_INT_ARITH_SUBF(subfo, 0x11, 0, 0, 1)
1256/* subfc subfc. subfco subfco. */
1257GEN_INT_ARITH_SUBF(subfc, 0x00, 0, 1, 0)
1258GEN_INT_ARITH_SUBF(subfco, 0x10, 0, 1, 1)
1259/* subfe subfe. subfeo subfo. */
1260GEN_INT_ARITH_SUBF(subfe, 0x04, 1, 1, 0)
1261GEN_INT_ARITH_SUBF(subfeo, 0x14, 1, 1, 1)
1262/* subfme subfme. subfmeo subfmeo. */
1263GEN_INT_ARITH_SUBF_CONST(subfme, 0x07, -1LL, 1, 1, 0)
1264GEN_INT_ARITH_SUBF_CONST(subfmeo, 0x17, -1LL, 1, 1, 1)
1265/* subfze subfze. subfzeo subfzeo.*/
1266GEN_INT_ARITH_SUBF_CONST(subfze, 0x06, 0, 1, 1, 0)
1267GEN_INT_ARITH_SUBF_CONST(subfzeo, 0x16, 0, 1, 1, 1)
1268
1269/* subfic */
1270static void gen_subfic(DisasContext *ctx)
1271{
1272 /* Start with XER CA and OV disabled, the most likely case */
1273 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
1274 TCGv t0 = tcg_temp_local_new();
1275 TCGv t1 = tcg_const_local_tl(SIMM(ctx->opcode));
1276 tcg_gen_sub_tl(t0, t1, cpu_gpr[rA(ctx->opcode)]);
1277 gen_op_arith_compute_ca(ctx, t0, t1, 1);
1278 tcg_temp_free(t1);
1279 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], t0);
1280 tcg_temp_free(t0);
1281}
1282
1283/*** Integer logical ***/
1284#define GEN_LOGICAL2(name, tcg_op, opc, type) \
1285static void glue(gen_, name)(DisasContext *ctx) \
1286{ \
1287 tcg_op(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], \
1288 cpu_gpr[rB(ctx->opcode)]); \
1289 if (unlikely(Rc(ctx->opcode) != 0)) \
1290 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]); \
1291}
1292
1293#define GEN_LOGICAL1(name, tcg_op, opc, type) \
1294static void glue(gen_, name)(DisasContext *ctx) \
1295{ \
1296 tcg_op(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]); \
1297 if (unlikely(Rc(ctx->opcode) != 0)) \
1298 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]); \
1299}
1300
1301/* and & and. */
1302GEN_LOGICAL2(and, tcg_gen_and_tl, 0x00, PPC_INTEGER);
1303/* andc & andc. */
1304GEN_LOGICAL2(andc, tcg_gen_andc_tl, 0x01, PPC_INTEGER);
1305
1306/* andi. */
1307static void gen_andi_(DisasContext *ctx)
1308{
1309 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], UIMM(ctx->opcode));
1310 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1311}
1312
1313/* andis. */
1314static void gen_andis_(DisasContext *ctx)
1315{
1316 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], UIMM(ctx->opcode) << 16);
1317 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1318}
1319
1320/* cntlzw */
1321static void gen_cntlzw(DisasContext *ctx)
1322{
1323 gen_helper_cntlzw(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1324 if (unlikely(Rc(ctx->opcode) != 0))
1325 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1326}
1327/* eqv & eqv. */
1328GEN_LOGICAL2(eqv, tcg_gen_eqv_tl, 0x08, PPC_INTEGER);
1329/* extsb & extsb. */
1330GEN_LOGICAL1(extsb, tcg_gen_ext8s_tl, 0x1D, PPC_INTEGER);
1331/* extsh & extsh. */
1332GEN_LOGICAL1(extsh, tcg_gen_ext16s_tl, 0x1C, PPC_INTEGER);
1333/* nand & nand. */
1334GEN_LOGICAL2(nand, tcg_gen_nand_tl, 0x0E, PPC_INTEGER);
1335/* nor & nor. */
1336GEN_LOGICAL2(nor, tcg_gen_nor_tl, 0x03, PPC_INTEGER);
1337
1338/* or & or. */
1339static void gen_or(DisasContext *ctx)
1340{
1341 int rs, ra, rb;
1342
1343 rs = rS(ctx->opcode);
1344 ra = rA(ctx->opcode);
1345 rb = rB(ctx->opcode);
1346 /* Optimisation for mr. ri case */
1347 if (rs != ra || rs != rb) {
1348 if (rs != rb)
1349 tcg_gen_or_tl(cpu_gpr[ra], cpu_gpr[rs], cpu_gpr[rb]);
1350 else
1351 tcg_gen_mov_tl(cpu_gpr[ra], cpu_gpr[rs]);
1352 if (unlikely(Rc(ctx->opcode) != 0))
1353 gen_set_Rc0(ctx, cpu_gpr[ra]);
1354 } else if (unlikely(Rc(ctx->opcode) != 0)) {
1355 gen_set_Rc0(ctx, cpu_gpr[rs]);
1356#if defined(TARGET_PPC64)
1357 } else {
1358 int prio = 0;
1359
1360 switch (rs) {
1361 case 1:
1362 /* Set process priority to low */
1363 prio = 2;
1364 break;
1365 case 6:
1366 /* Set process priority to medium-low */
1367 prio = 3;
1368 break;
1369 case 2:
1370 /* Set process priority to normal */
1371 prio = 4;
1372 break;
1373#if !defined(CONFIG_USER_ONLY)
1374 case 31:
1375 if (ctx->mem_idx > 0) {
1376 /* Set process priority to very low */
1377 prio = 1;
1378 }
1379 break;
1380 case 5:
1381 if (ctx->mem_idx > 0) {
1382 /* Set process priority to medium-hight */
1383 prio = 5;
1384 }
1385 break;
1386 case 3:
1387 if (ctx->mem_idx > 0) {
1388 /* Set process priority to high */
1389 prio = 6;
1390 }
1391 break;
1392 case 7:
1393 if (ctx->mem_idx > 1) {
1394 /* Set process priority to very high */
1395 prio = 7;
1396 }
1397 break;
1398#endif
1399 default:
1400 /* nop */
1401 break;
1402 }
1403 if (prio) {
1404 TCGv t0 = tcg_temp_new();
1405 gen_load_spr(t0, SPR_PPR);
1406 tcg_gen_andi_tl(t0, t0, ~0x001C000000000000ULL);
1407 tcg_gen_ori_tl(t0, t0, ((uint64_t)prio) << 50);
1408 gen_store_spr(SPR_PPR, t0);
1409 tcg_temp_free(t0);
1410 }
1411#endif
1412 }
1413}
1414/* orc & orc. */
1415GEN_LOGICAL2(orc, tcg_gen_orc_tl, 0x0C, PPC_INTEGER);
1416
1417/* xor & xor. */
1418static void gen_xor(DisasContext *ctx)
1419{
1420 /* Optimisation for "set to zero" case */
1421 if (rS(ctx->opcode) != rB(ctx->opcode))
1422 tcg_gen_xor_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
1423 else
1424 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
1425 if (unlikely(Rc(ctx->opcode) != 0))
1426 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1427}
1428
1429/* ori */
1430static void gen_ori(DisasContext *ctx)
1431{
1432 target_ulong uimm = UIMM(ctx->opcode);
1433
1434 if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
1435 /* NOP */
1436 /* XXX: should handle special NOPs for POWER series */
1437 return;
1438 }
1439 tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], uimm);
1440}
1441
1442/* oris */
1443static void gen_oris(DisasContext *ctx)
1444{
1445 target_ulong uimm = UIMM(ctx->opcode);
1446
1447 if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
1448 /* NOP */
1449 return;
1450 }
1451 tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], uimm << 16);
1452}
1453
1454/* xori */
1455static void gen_xori(DisasContext *ctx)
1456{
1457 target_ulong uimm = UIMM(ctx->opcode);
1458
1459 if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
1460 /* NOP */
1461 return;
1462 }
1463 tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], uimm);
1464}
1465
1466/* xoris */
1467static void gen_xoris(DisasContext *ctx)
1468{
1469 target_ulong uimm = UIMM(ctx->opcode);
1470
1471 if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
1472 /* NOP */
1473 return;
1474 }
1475 tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], uimm << 16);
1476}
1477
1478/* popcntb : PowerPC 2.03 specification */
1479static void gen_popcntb(DisasContext *ctx)
1480{
1481#if defined(TARGET_PPC64)
1482 if (ctx->sf_mode)
1483 gen_helper_popcntb_64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1484 else
1485#endif
1486 gen_helper_popcntb(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1487}
1488
1489#if defined(TARGET_PPC64)
1490/* extsw & extsw. */
1491GEN_LOGICAL1(extsw, tcg_gen_ext32s_tl, 0x1E, PPC_64B);
1492
1493/* cntlzd */
1494static void gen_cntlzd(DisasContext *ctx)
1495{
1496 gen_helper_cntlzd(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1497 if (unlikely(Rc(ctx->opcode) != 0))
1498 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1499}
1500#endif
1501
1502/*** Integer rotate ***/
1503
1504/* rlwimi & rlwimi. */
1505static void gen_rlwimi(DisasContext *ctx)
1506{
1507 uint32_t mb, me, sh;
1508
1509 mb = MB(ctx->opcode);
1510 me = ME(ctx->opcode);
1511 sh = SH(ctx->opcode);
1512 if (likely(sh == 0 && mb == 0 && me == 31)) {
1513 tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1514 } else {
1515 target_ulong mask;
1516 TCGv t1;
1517 TCGv t0 = tcg_temp_new();
1518#if defined(TARGET_PPC64)
1519 TCGv_i32 t2 = tcg_temp_new_i32();
1520 tcg_gen_trunc_i64_i32(t2, cpu_gpr[rS(ctx->opcode)]);
1521 tcg_gen_rotli_i32(t2, t2, sh);
1522 tcg_gen_extu_i32_i64(t0, t2);
1523 tcg_temp_free_i32(t2);
1524#else
1525 tcg_gen_rotli_i32(t0, cpu_gpr[rS(ctx->opcode)], sh);
1526#endif
1527#if defined(TARGET_PPC64)
1528 mb += 32;
1529 me += 32;
1530#endif
1531 mask = MASK(mb, me);
1532 t1 = tcg_temp_new();
1533 tcg_gen_andi_tl(t0, t0, mask);
1534 tcg_gen_andi_tl(t1, cpu_gpr[rA(ctx->opcode)], ~mask);
1535 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
1536 tcg_temp_free(t0);
1537 tcg_temp_free(t1);
1538 }
1539 if (unlikely(Rc(ctx->opcode) != 0))
1540 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1541}
1542
1543/* rlwinm & rlwinm. */
1544static void gen_rlwinm(DisasContext *ctx)
1545{
1546 uint32_t mb, me, sh;
1547
1548 sh = SH(ctx->opcode);
1549 mb = MB(ctx->opcode);
1550 me = ME(ctx->opcode);
1551
1552 if (likely(mb == 0 && me == (31 - sh))) {
1553 if (likely(sh == 0)) {
1554 tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1555 } else {
1556 TCGv t0 = tcg_temp_new();
1557 tcg_gen_ext32u_tl(t0, cpu_gpr[rS(ctx->opcode)]);
1558 tcg_gen_shli_tl(t0, t0, sh);
1559 tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], t0);
1560 tcg_temp_free(t0);
1561 }
1562 } else if (likely(sh != 0 && me == 31 && sh == (32 - mb))) {
1563 TCGv t0 = tcg_temp_new();
1564 tcg_gen_ext32u_tl(t0, cpu_gpr[rS(ctx->opcode)]);
1565 tcg_gen_shri_tl(t0, t0, mb);
1566 tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], t0);
1567 tcg_temp_free(t0);
1568 } else {
1569 TCGv t0 = tcg_temp_new();
1570#if defined(TARGET_PPC64)
1571 TCGv_i32 t1 = tcg_temp_new_i32();
1572 tcg_gen_trunc_i64_i32(t1, cpu_gpr[rS(ctx->opcode)]);
1573 tcg_gen_rotli_i32(t1, t1, sh);
1574 tcg_gen_extu_i32_i64(t0, t1);
1575 tcg_temp_free_i32(t1);
1576#else
1577 tcg_gen_rotli_i32(t0, cpu_gpr[rS(ctx->opcode)], sh);
1578#endif
1579#if defined(TARGET_PPC64)
1580 mb += 32;
1581 me += 32;
1582#endif
1583 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], t0, MASK(mb, me));
1584 tcg_temp_free(t0);
1585 }
1586 if (unlikely(Rc(ctx->opcode) != 0))
1587 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1588}
1589
1590/* rlwnm & rlwnm. */
1591static void gen_rlwnm(DisasContext *ctx)
1592{
1593 uint32_t mb, me;
1594 TCGv t0;
1595#if defined(TARGET_PPC64)
1596 TCGv_i32 t1, t2;
1597#endif
1598
1599 mb = MB(ctx->opcode);
1600 me = ME(ctx->opcode);
1601 t0 = tcg_temp_new();
1602 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1f);
1603#if defined(TARGET_PPC64)
1604 t1 = tcg_temp_new_i32();
1605 t2 = tcg_temp_new_i32();
1606 tcg_gen_trunc_i64_i32(t1, cpu_gpr[rS(ctx->opcode)]);
1607 tcg_gen_trunc_i64_i32(t2, t0);
1608 tcg_gen_rotl_i32(t1, t1, t2);
1609 tcg_gen_extu_i32_i64(t0, t1);
1610 tcg_temp_free_i32(t1);
1611 tcg_temp_free_i32(t2);
1612#else
1613 tcg_gen_rotl_i32(t0, cpu_gpr[rS(ctx->opcode)], t0);
1614#endif
1615 if (unlikely(mb != 0 || me != 31)) {
1616#if defined(TARGET_PPC64)
1617 mb += 32;
1618 me += 32;
1619#endif
1620 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], t0, MASK(mb, me));
1621 } else {
1622 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
1623 }
1624 tcg_temp_free(t0);
1625 if (unlikely(Rc(ctx->opcode) != 0))
1626 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1627}
1628
1629#if defined(TARGET_PPC64)
1630#define GEN_PPC64_R2(name, opc1, opc2) \
1631static void glue(gen_, name##0)(DisasContext *ctx) \
1632{ \
1633 gen_##name(ctx, 0); \
1634} \
1635 \
1636static void glue(gen_, name##1)(DisasContext *ctx) \
1637{ \
1638 gen_##name(ctx, 1); \
1639}
1640#define GEN_PPC64_R4(name, opc1, opc2) \
1641static void glue(gen_, name##0)(DisasContext *ctx) \
1642{ \
1643 gen_##name(ctx, 0, 0); \
1644} \
1645 \
1646static void glue(gen_, name##1)(DisasContext *ctx) \
1647{ \
1648 gen_##name(ctx, 0, 1); \
1649} \
1650 \
1651static void glue(gen_, name##2)(DisasContext *ctx) \
1652{ \
1653 gen_##name(ctx, 1, 0); \
1654} \
1655 \
1656static void glue(gen_, name##3)(DisasContext *ctx) \
1657{ \
1658 gen_##name(ctx, 1, 1); \
1659}
1660
1661static always_inline void gen_rldinm (DisasContext *ctx, uint32_t mb,
1662 uint32_t me, uint32_t sh)
1663{
1664 if (likely(sh != 0 && mb == 0 && me == (63 - sh))) {
1665 tcg_gen_shli_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], sh);
1666 } else if (likely(sh != 0 && me == 63 && sh == (64 - mb))) {
1667 tcg_gen_shri_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], mb);
1668 } else {
1669 TCGv t0 = tcg_temp_new();
1670 tcg_gen_rotli_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
1671 if (likely(mb == 0 && me == 63)) {
1672 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
1673 } else {
1674 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], t0, MASK(mb, me));
1675 }
1676 tcg_temp_free(t0);
1677 }
1678 if (unlikely(Rc(ctx->opcode) != 0))
1679 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1680}
1681/* rldicl - rldicl. */
1682static always_inline void gen_rldicl (DisasContext *ctx, int mbn, int shn)
1683{
1684 uint32_t sh, mb;
1685
1686 sh = SH(ctx->opcode) | (shn << 5);
1687 mb = MB(ctx->opcode) | (mbn << 5);
1688 gen_rldinm(ctx, mb, 63, sh);
1689}
1690GEN_PPC64_R4(rldicl, 0x1E, 0x00);
1691/* rldicr - rldicr. */
1692static always_inline void gen_rldicr (DisasContext *ctx, int men, int shn)
1693{
1694 uint32_t sh, me;
1695
1696 sh = SH(ctx->opcode) | (shn << 5);
1697 me = MB(ctx->opcode) | (men << 5);
1698 gen_rldinm(ctx, 0, me, sh);
1699}
1700GEN_PPC64_R4(rldicr, 0x1E, 0x02);
1701/* rldic - rldic. */
1702static always_inline void gen_rldic (DisasContext *ctx, int mbn, int shn)
1703{
1704 uint32_t sh, mb;
1705
1706 sh = SH(ctx->opcode) | (shn << 5);
1707 mb = MB(ctx->opcode) | (mbn << 5);
1708 gen_rldinm(ctx, mb, 63 - sh, sh);
1709}
1710GEN_PPC64_R4(rldic, 0x1E, 0x04);
1711
1712static always_inline void gen_rldnm (DisasContext *ctx, uint32_t mb,
1713 uint32_t me)
1714{
1715 TCGv t0;
1716
1717 mb = MB(ctx->opcode);
1718 me = ME(ctx->opcode);
1719 t0 = tcg_temp_new();
1720 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3f);
1721 tcg_gen_rotl_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
1722 if (unlikely(mb != 0 || me != 63)) {
1723 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], t0, MASK(mb, me));
1724 } else {
1725 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
1726 }
1727 tcg_temp_free(t0);
1728 if (unlikely(Rc(ctx->opcode) != 0))
1729 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1730}
1731
1732/* rldcl - rldcl. */
1733static always_inline void gen_rldcl (DisasContext *ctx, int mbn)
1734{
1735 uint32_t mb;
1736
1737 mb = MB(ctx->opcode) | (mbn << 5);
1738 gen_rldnm(ctx, mb, 63);
1739}
1740GEN_PPC64_R2(rldcl, 0x1E, 0x08);
1741/* rldcr - rldcr. */
1742static always_inline void gen_rldcr (DisasContext *ctx, int men)
1743{
1744 uint32_t me;
1745
1746 me = MB(ctx->opcode) | (men << 5);
1747 gen_rldnm(ctx, 0, me);
1748}
1749GEN_PPC64_R2(rldcr, 0x1E, 0x09);
1750/* rldimi - rldimi. */
1751static always_inline void gen_rldimi (DisasContext *ctx, int mbn, int shn)
1752{
1753 uint32_t sh, mb, me;
1754
1755 sh = SH(ctx->opcode) | (shn << 5);
1756 mb = MB(ctx->opcode) | (mbn << 5);
1757 me = 63 - sh;
1758 if (unlikely(sh == 0 && mb == 0)) {
1759 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1760 } else {
1761 TCGv t0, t1;
1762 target_ulong mask;
1763
1764 t0 = tcg_temp_new();
1765 tcg_gen_rotli_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
1766 t1 = tcg_temp_new();
1767 mask = MASK(mb, me);
1768 tcg_gen_andi_tl(t0, t0, mask);
1769 tcg_gen_andi_tl(t1, cpu_gpr[rA(ctx->opcode)], ~mask);
1770 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
1771 tcg_temp_free(t0);
1772 tcg_temp_free(t1);
1773 }
1774 if (unlikely(Rc(ctx->opcode) != 0))
1775 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1776}
1777GEN_PPC64_R4(rldimi, 0x1E, 0x06);
1778#endif
1779
1780/*** Integer shift ***/
1781
1782/* slw & slw. */
1783static void gen_slw(DisasContext *ctx)
1784{
1785 TCGv t0;
1786 int l1, l2;
1787 l1 = gen_new_label();
1788 l2 = gen_new_label();
1789
1790 t0 = tcg_temp_local_new();
1791 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3f);
1792 tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x20, l1);
1793 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
1794 tcg_gen_br(l2);
1795 gen_set_label(l1);
1796 tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t0);
1797 tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
1798 gen_set_label(l2);
1799 tcg_temp_free(t0);
1800 if (unlikely(Rc(ctx->opcode) != 0))
1801 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1802}
1803
1804/* sraw & sraw. */
1805static void gen_sraw(DisasContext *ctx)
1806{
1807 gen_helper_sraw(cpu_gpr[rA(ctx->opcode)],
1808 cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
1809 if (unlikely(Rc(ctx->opcode) != 0))
1810 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1811}
1812
1813/* srawi & srawi. */
1814static void gen_srawi(DisasContext *ctx)
1815{
1816 int sh = SH(ctx->opcode);
1817 if (sh != 0) {
1818 int l1, l2;
1819 TCGv t0;
1820 l1 = gen_new_label();
1821 l2 = gen_new_label();
1822 t0 = tcg_temp_local_new();
1823 tcg_gen_ext32s_tl(t0, cpu_gpr[rS(ctx->opcode)]);
1824 tcg_gen_brcondi_tl(TCG_COND_GE, t0, 0, l1);
1825 tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], (1ULL << sh) - 1);
1826 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
1827 tcg_gen_ori_tl(cpu_xer, cpu_xer, 1 << XER_CA);
1828 tcg_gen_br(l2);
1829 gen_set_label(l1);
1830 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
1831 gen_set_label(l2);
1832 tcg_gen_ext32s_tl(t0, cpu_gpr[rS(ctx->opcode)]);
1833 tcg_gen_sari_tl(cpu_gpr[rA(ctx->opcode)], t0, sh);
1834 tcg_temp_free(t0);
1835 } else {
1836 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1837 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
1838 }
1839 if (unlikely(Rc(ctx->opcode) != 0))
1840 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1841}
1842
1843/* srw & srw. */
1844static void gen_srw(DisasContext *ctx)
1845{
1846 TCGv t0, t1;
1847 int l1, l2;
1848 l1 = gen_new_label();
1849 l2 = gen_new_label();
1850
1851 t0 = tcg_temp_local_new();
1852 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3f);
1853 tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x20, l1);
1854 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
1855 tcg_gen_br(l2);
1856 gen_set_label(l1);
1857 t1 = tcg_temp_new();
1858 tcg_gen_ext32u_tl(t1, cpu_gpr[rS(ctx->opcode)]);
1859 tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], t1, t0);
1860 tcg_temp_free(t1);
1861 gen_set_label(l2);
1862 tcg_temp_free(t0);
1863 if (unlikely(Rc(ctx->opcode) != 0))
1864 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1865}
1866
1867#if defined(TARGET_PPC64)
1868/* sld & sld. */
1869static void gen_sld(DisasContext *ctx)
1870{
1871 TCGv t0;
1872 int l1, l2;
1873 l1 = gen_new_label();
1874 l2 = gen_new_label();
1875
1876 t0 = tcg_temp_local_new();
1877 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x7f);
1878 tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x40, l1);
1879 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
1880 tcg_gen_br(l2);
1881 gen_set_label(l1);
1882 tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t0);
1883 gen_set_label(l2);
1884 tcg_temp_free(t0);
1885 if (unlikely(Rc(ctx->opcode) != 0))
1886 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1887}
1888
1889/* srad & srad. */
1890static void gen_srad(DisasContext *ctx)
1891{
1892 gen_helper_srad(cpu_gpr[rA(ctx->opcode)],
1893 cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
1894 if (unlikely(Rc(ctx->opcode) != 0))
1895 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1896}
1897/* sradi & sradi. */
1898static always_inline void gen_sradi (DisasContext *ctx, int n)
1899{
1900 int sh = SH(ctx->opcode) + (n << 5);
1901 if (sh != 0) {
1902 int l1, l2;
1903 TCGv t0;
1904 l1 = gen_new_label();
1905 l2 = gen_new_label();
1906 t0 = tcg_temp_local_new();
1907 tcg_gen_brcondi_tl(TCG_COND_GE, cpu_gpr[rS(ctx->opcode)], 0, l1);
1908 tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], (1ULL << sh) - 1);
1909 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
1910 tcg_gen_ori_tl(cpu_xer, cpu_xer, 1 << XER_CA);
1911 tcg_gen_br(l2);
1912 gen_set_label(l1);
1913 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
1914 gen_set_label(l2);
1915 tcg_temp_free(t0);
1916 tcg_gen_sari_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], sh);
1917 } else {
1918 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
1919 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
1920 }
1921 if (unlikely(Rc(ctx->opcode) != 0))
1922 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1923}
1924
1925static void gen_sradi0(DisasContext *ctx)
1926{
1927 gen_sradi(ctx, 0);
1928}
1929
1930static void gen_sradi1(DisasContext *ctx)
1931{
1932 gen_sradi(ctx, 1);
1933}
1934
1935/* srd & srd. */
1936static void gen_srd(DisasContext *ctx)
1937{
1938 TCGv t0;
1939 int l1, l2;
1940 l1 = gen_new_label();
1941 l2 = gen_new_label();
1942
1943 t0 = tcg_temp_local_new();
1944 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x7f);
1945 tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x40, l1);
1946 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
1947 tcg_gen_br(l2);
1948 gen_set_label(l1);
1949 tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t0);
1950 gen_set_label(l2);
1951 tcg_temp_free(t0);
1952 if (unlikely(Rc(ctx->opcode) != 0))
1953 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
1954}
1955#endif
1956
1957/*** Floating-Point arithmetic ***/
1958#define _GEN_FLOAT_ACB(name, op, op1, op2, isfloat, set_fprf, type) \
1959static void gen_f##name(DisasContext *ctx) \
1960{ \
1961 if (unlikely(!ctx->fpu_enabled)) { \
1962 gen_exception(ctx, POWERPC_EXCP_FPU); \
1963 return; \
1964 } \
1965 /* NIP cannot be restored if the memory exception comes from an helper */ \
1966 gen_update_nip(ctx, ctx->nip - 4); \
1967 gen_reset_fpstatus(); \
1968 gen_helper_f##op(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rA(ctx->opcode)], \
1969 cpu_fpr[rC(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]); \
1970 if (isfloat) { \
1971 gen_helper_frsp(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rD(ctx->opcode)]); \
1972 } \
1973 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], set_fprf, \
1974 Rc(ctx->opcode) != 0); \
1975}
1976
1977#define GEN_FLOAT_ACB(name, op2, set_fprf, type) \
1978_GEN_FLOAT_ACB(name, name, 0x3F, op2, 0, set_fprf, type); \
1979_GEN_FLOAT_ACB(name##s, name, 0x3B, op2, 1, set_fprf, type);
1980
1981#define _GEN_FLOAT_AB(name, op, op1, op2, inval, isfloat, set_fprf, type) \
1982static void gen_f##name(DisasContext *ctx) \
1983{ \
1984 if (unlikely(!ctx->fpu_enabled)) { \
1985 gen_exception(ctx, POWERPC_EXCP_FPU); \
1986 return; \
1987 } \
1988 /* NIP cannot be restored if the memory exception comes from an helper */ \
1989 gen_update_nip(ctx, ctx->nip - 4); \
1990 gen_reset_fpstatus(); \
1991 gen_helper_f##op(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rA(ctx->opcode)], \
1992 cpu_fpr[rB(ctx->opcode)]); \
1993 if (isfloat) { \
1994 gen_helper_frsp(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rD(ctx->opcode)]); \
1995 } \
1996 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], \
1997 set_fprf, Rc(ctx->opcode) != 0); \
1998}
1999#define GEN_FLOAT_AB(name, op2, inval, set_fprf, type) \
2000_GEN_FLOAT_AB(name, name, 0x3F, op2, inval, 0, set_fprf, type); \
2001_GEN_FLOAT_AB(name##s, name, 0x3B, op2, inval, 1, set_fprf, type);
2002
2003#define _GEN_FLOAT_AC(name, op, op1, op2, inval, isfloat, set_fprf, type) \
2004static void gen_f##name(DisasContext *ctx) \
2005{ \
2006 if (unlikely(!ctx->fpu_enabled)) { \
2007 gen_exception(ctx, POWERPC_EXCP_FPU); \
2008 return; \
2009 } \
2010 /* NIP cannot be restored if the memory exception comes from an helper */ \
2011 gen_update_nip(ctx, ctx->nip - 4); \
2012 gen_reset_fpstatus(); \
2013 gen_helper_f##op(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rA(ctx->opcode)], \
2014 cpu_fpr[rC(ctx->opcode)]); \
2015 if (isfloat) { \
2016 gen_helper_frsp(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rD(ctx->opcode)]); \
2017 } \
2018 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], \
2019 set_fprf, Rc(ctx->opcode) != 0); \
2020}
2021#define GEN_FLOAT_AC(name, op2, inval, set_fprf, type) \
2022_GEN_FLOAT_AC(name, name, 0x3F, op2, inval, 0, set_fprf, type); \
2023_GEN_FLOAT_AC(name##s, name, 0x3B, op2, inval, 1, set_fprf, type);
2024
2025#define GEN_FLOAT_B(name, op2, op3, set_fprf, type) \
2026static void gen_f##name(DisasContext *ctx) \
2027{ \
2028 if (unlikely(!ctx->fpu_enabled)) { \
2029 gen_exception(ctx, POWERPC_EXCP_FPU); \
2030 return; \
2031 } \
2032 /* NIP cannot be restored if the memory exception comes from an helper */ \
2033 gen_update_nip(ctx, ctx->nip - 4); \
2034 gen_reset_fpstatus(); \
2035 gen_helper_f##name(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]); \
2036 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], \
2037 set_fprf, Rc(ctx->opcode) != 0); \
2038}
2039
2040#define GEN_FLOAT_BS(name, op1, op2, set_fprf, type) \
2041static void gen_f##name(DisasContext *ctx) \
2042{ \
2043 if (unlikely(!ctx->fpu_enabled)) { \
2044 gen_exception(ctx, POWERPC_EXCP_FPU); \
2045 return; \
2046 } \
2047 /* NIP cannot be restored if the memory exception comes from an helper */ \
2048 gen_update_nip(ctx, ctx->nip - 4); \
2049 gen_reset_fpstatus(); \
2050 gen_helper_f##name(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]); \
2051 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], \
2052 set_fprf, Rc(ctx->opcode) != 0); \
2053}
2054
2055/* fadd - fadds */
2056GEN_FLOAT_AB(add, 0x15, 0x000007C0, 1, PPC_FLOAT);
2057/* fdiv - fdivs */
2058GEN_FLOAT_AB(div, 0x12, 0x000007C0, 1, PPC_FLOAT);
2059/* fmul - fmuls */
2060GEN_FLOAT_AC(mul, 0x19, 0x0000F800, 1, PPC_FLOAT);
2061
2062/* fre */
2063GEN_FLOAT_BS(re, 0x3F, 0x18, 1, PPC_FLOAT_EXT);
2064
2065/* fres */
2066GEN_FLOAT_BS(res, 0x3B, 0x18, 1, PPC_FLOAT_FRES);
2067
2068/* frsqrte */
2069GEN_FLOAT_BS(rsqrte, 0x3F, 0x1A, 1, PPC_FLOAT_FRSQRTE);
2070
2071/* frsqrtes */
2072static void gen_frsqrtes(DisasContext *ctx)
2073{
2074 if (unlikely(!ctx->fpu_enabled)) {
2075 gen_exception(ctx, POWERPC_EXCP_FPU);
2076 return;
2077 }
2078 /* NIP cannot be restored if the memory exception comes from an helper */
2079 gen_update_nip(ctx, ctx->nip - 4);
2080 gen_reset_fpstatus();
2081 gen_helper_frsqrte(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]);
2082 gen_helper_frsp(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rD(ctx->opcode)]);
2083 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], 1, Rc(ctx->opcode) != 0);
2084}
2085
2086/* fsel */
2087_GEN_FLOAT_ACB(sel, sel, 0x3F, 0x17, 0, 0, PPC_FLOAT_FSEL);
2088/* fsub - fsubs */
2089GEN_FLOAT_AB(sub, 0x14, 0x000007C0, 1, PPC_FLOAT);
2090/* Optional: */
2091
2092/* fsqrt */
2093static void gen_fsqrt(DisasContext *ctx)
2094{
2095 if (unlikely(!ctx->fpu_enabled)) {
2096 gen_exception(ctx, POWERPC_EXCP_FPU);
2097 return;
2098 }
2099 /* NIP cannot be restored if the memory exception comes from an helper */
2100 gen_update_nip(ctx, ctx->nip - 4);
2101 gen_reset_fpstatus();
2102 gen_helper_fsqrt(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]);
2103 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], 1, Rc(ctx->opcode) != 0);
2104}
2105
2106static void gen_fsqrts(DisasContext *ctx)
2107{
2108 if (unlikely(!ctx->fpu_enabled)) {
2109 gen_exception(ctx, POWERPC_EXCP_FPU);
2110 return;
2111 }
2112 /* NIP cannot be restored if the memory exception comes from an helper */
2113 gen_update_nip(ctx, ctx->nip - 4);
2114 gen_reset_fpstatus();
2115 gen_helper_fsqrt(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]);
2116 gen_helper_frsp(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rD(ctx->opcode)]);
2117 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], 1, Rc(ctx->opcode) != 0);
2118}
2119
2120/*** Floating-Point multiply-and-add ***/
2121/* fmadd - fmadds */
2122GEN_FLOAT_ACB(madd, 0x1D, 1, PPC_FLOAT);
2123/* fmsub - fmsubs */
2124GEN_FLOAT_ACB(msub, 0x1C, 1, PPC_FLOAT);
2125/* fnmadd - fnmadds */
2126GEN_FLOAT_ACB(nmadd, 0x1F, 1, PPC_FLOAT);
2127/* fnmsub - fnmsubs */
2128GEN_FLOAT_ACB(nmsub, 0x1E, 1, PPC_FLOAT);
2129
2130/*** Floating-Point round & convert ***/
2131/* fctiw */
2132GEN_FLOAT_B(ctiw, 0x0E, 0x00, 0, PPC_FLOAT);
2133/* fctiwz */
2134GEN_FLOAT_B(ctiwz, 0x0F, 0x00, 0, PPC_FLOAT);
2135/* frsp */
2136GEN_FLOAT_B(rsp, 0x0C, 0x00, 1, PPC_FLOAT);
2137#if defined(TARGET_PPC64)
2138/* fcfid */
2139GEN_FLOAT_B(cfid, 0x0E, 0x1A, 1, PPC_64B);
2140/* fctid */
2141GEN_FLOAT_B(ctid, 0x0E, 0x19, 0, PPC_64B);
2142/* fctidz */
2143GEN_FLOAT_B(ctidz, 0x0F, 0x19, 0, PPC_64B);
2144#endif
2145
2146/* frin */
2147GEN_FLOAT_B(rin, 0x08, 0x0C, 1, PPC_FLOAT_EXT);
2148/* friz */
2149GEN_FLOAT_B(riz, 0x08, 0x0D, 1, PPC_FLOAT_EXT);
2150/* frip */
2151GEN_FLOAT_B(rip, 0x08, 0x0E, 1, PPC_FLOAT_EXT);
2152/* frim */
2153GEN_FLOAT_B(rim, 0x08, 0x0F, 1, PPC_FLOAT_EXT);
2154
2155/*** Floating-Point compare ***/
2156
2157/* fcmpo */
2158static void gen_fcmpo(DisasContext *ctx)
2159{
2160 TCGv_i32 crf;
2161 if (unlikely(!ctx->fpu_enabled)) {
2162 gen_exception(ctx, POWERPC_EXCP_FPU);
2163 return;
2164 }
2165 /* NIP cannot be restored if the memory exception comes from an helper */
2166 gen_update_nip(ctx, ctx->nip - 4);
2167 gen_reset_fpstatus();
2168 crf = tcg_const_i32(crfD(ctx->opcode));
2169 gen_helper_fcmpo(cpu_fpr[rA(ctx->opcode)], cpu_fpr[rB(ctx->opcode)], crf);
2170 tcg_temp_free_i32(crf);
2171 gen_helper_float_check_status();
2172}
2173
2174/* fcmpu */
2175static void gen_fcmpu(DisasContext *ctx)
2176{
2177 TCGv_i32 crf;
2178 if (unlikely(!ctx->fpu_enabled)) {
2179 gen_exception(ctx, POWERPC_EXCP_FPU);
2180 return;
2181 }
2182 /* NIP cannot be restored if the memory exception comes from an helper */
2183 gen_update_nip(ctx, ctx->nip - 4);
2184 gen_reset_fpstatus();
2185 crf = tcg_const_i32(crfD(ctx->opcode));
2186 gen_helper_fcmpu(cpu_fpr[rA(ctx->opcode)], cpu_fpr[rB(ctx->opcode)], crf);
2187 tcg_temp_free_i32(crf);
2188 gen_helper_float_check_status();
2189}
2190
2191/*** Floating-point move ***/
2192/* fabs */
2193/* XXX: beware that fabs never checks for NaNs nor update FPSCR */
2194GEN_FLOAT_B(abs, 0x08, 0x08, 0, PPC_FLOAT);
2195
2196/* fmr - fmr. */
2197/* XXX: beware that fmr never checks for NaNs nor update FPSCR */
2198static void gen_fmr(DisasContext *ctx)
2199{
2200 if (unlikely(!ctx->fpu_enabled)) {
2201 gen_exception(ctx, POWERPC_EXCP_FPU);
2202 return;
2203 }
2204 tcg_gen_mov_i64(cpu_fpr[rD(ctx->opcode)], cpu_fpr[rB(ctx->opcode)]);
2205 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], 0, Rc(ctx->opcode) != 0);
2206}
2207
2208/* fnabs */
2209/* XXX: beware that fnabs never checks for NaNs nor update FPSCR */
2210GEN_FLOAT_B(nabs, 0x08, 0x04, 0, PPC_FLOAT);
2211/* fneg */
2212/* XXX: beware that fneg never checks for NaNs nor update FPSCR */
2213GEN_FLOAT_B(neg, 0x08, 0x01, 0, PPC_FLOAT);
2214
2215/*** Floating-Point status & ctrl register ***/
2216
2217/* mcrfs */
2218static void gen_mcrfs(DisasContext *ctx)
2219{
2220 int bfa;
2221
2222 if (unlikely(!ctx->fpu_enabled)) {
2223 gen_exception(ctx, POWERPC_EXCP_FPU);
2224 return;
2225 }
2226 bfa = 4 * (7 - crfS(ctx->opcode));
2227 tcg_gen_shri_i32(cpu_crf[crfD(ctx->opcode)], cpu_fpscr, bfa);
2228 tcg_gen_andi_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfD(ctx->opcode)], 0xf);
2229 tcg_gen_andi_i32(cpu_fpscr, cpu_fpscr, ~(0xF << bfa));
2230}
2231
2232/* mffs */
2233static void gen_mffs(DisasContext *ctx)
2234{
2235 if (unlikely(!ctx->fpu_enabled)) {
2236 gen_exception(ctx, POWERPC_EXCP_FPU);
2237 return;
2238 }
2239 gen_reset_fpstatus();
2240 tcg_gen_extu_i32_i64(cpu_fpr[rD(ctx->opcode)], cpu_fpscr);
2241 gen_compute_fprf(cpu_fpr[rD(ctx->opcode)], 0, Rc(ctx->opcode) != 0);
2242}
2243
2244/* mtfsb0 */
2245static void gen_mtfsb0(DisasContext *ctx)
2246{
2247 uint8_t crb;
2248
2249 if (unlikely(!ctx->fpu_enabled)) {
2250 gen_exception(ctx, POWERPC_EXCP_FPU);
2251 return;
2252 }
2253 crb = 31 - crbD(ctx->opcode);
2254 gen_reset_fpstatus();
2255 if (likely(crb != FPSCR_FEX && crb != FPSCR_VX)) {
2256 TCGv_i32 t0;
2257 /* NIP cannot be restored if the memory exception comes from an helper */
2258 gen_update_nip(ctx, ctx->nip - 4);
2259 t0 = tcg_const_i32(crb);
2260 gen_helper_fpscr_clrbit(t0);
2261 tcg_temp_free_i32(t0);
2262 }
2263 if (unlikely(Rc(ctx->opcode) != 0)) {
2264 tcg_gen_shri_i32(cpu_crf[1], cpu_fpscr, FPSCR_OX);
2265 }
2266}
2267
2268/* mtfsb1 */
2269static void gen_mtfsb1(DisasContext *ctx)
2270{
2271 uint8_t crb;
2272
2273 if (unlikely(!ctx->fpu_enabled)) {
2274 gen_exception(ctx, POWERPC_EXCP_FPU);
2275 return;
2276 }
2277 crb = 31 - crbD(ctx->opcode);
2278 gen_reset_fpstatus();
2279 /* XXX: we pretend we can only do IEEE floating-point computations */
2280 if (likely(crb != FPSCR_FEX && crb != FPSCR_VX && crb != FPSCR_NI)) {
2281 TCGv_i32 t0;
2282 /* NIP cannot be restored if the memory exception comes from an helper */
2283 gen_update_nip(ctx, ctx->nip - 4);
2284 t0 = tcg_const_i32(crb);
2285 gen_helper_fpscr_setbit(t0);
2286 tcg_temp_free_i32(t0);
2287 }
2288 if (unlikely(Rc(ctx->opcode) != 0)) {
2289 tcg_gen_shri_i32(cpu_crf[1], cpu_fpscr, FPSCR_OX);
2290 }
2291 /* We can raise a differed exception */
2292 gen_helper_float_check_status();
2293}
2294
2295/* mtfsf */
2296static void gen_mtfsf(DisasContext *ctx)
2297{
2298 TCGv_i32 t0;
2299 int L = ctx->opcode & 0x02000000;
2300
2301 if (unlikely(!ctx->fpu_enabled)) {
2302 gen_exception(ctx, POWERPC_EXCP_FPU);
2303 return;
2304 }
2305 /* NIP cannot be restored if the memory exception comes from an helper */
2306 gen_update_nip(ctx, ctx->nip - 4);
2307 gen_reset_fpstatus();
2308 if (L)
2309 t0 = tcg_const_i32(0xff);
2310 else
2311 t0 = tcg_const_i32(FM(ctx->opcode));
2312 gen_helper_store_fpscr(cpu_fpr[rB(ctx->opcode)], t0);
2313 tcg_temp_free_i32(t0);
2314 if (unlikely(Rc(ctx->opcode) != 0)) {
2315 tcg_gen_shri_i32(cpu_crf[1], cpu_fpscr, FPSCR_OX);
2316 }
2317 /* We can raise a differed exception */
2318 gen_helper_float_check_status();
2319}
2320
2321/* mtfsfi */
2322static void gen_mtfsfi(DisasContext *ctx)
2323{
2324 int bf, sh;
2325 TCGv_i64 t0;
2326 TCGv_i32 t1;
2327
2328 if (unlikely(!ctx->fpu_enabled)) {
2329 gen_exception(ctx, POWERPC_EXCP_FPU);
2330 return;
2331 }
2332 bf = crbD(ctx->opcode) >> 2;
2333 sh = 7 - bf;
2334 /* NIP cannot be restored if the memory exception comes from an helper */
2335 gen_update_nip(ctx, ctx->nip - 4);
2336 gen_reset_fpstatus();
2337 t0 = tcg_const_i64(FPIMM(ctx->opcode) << (4 * sh));
2338 t1 = tcg_const_i32(1 << sh);
2339 gen_helper_store_fpscr(t0, t1);
2340 tcg_temp_free_i64(t0);
2341 tcg_temp_free_i32(t1);
2342 if (unlikely(Rc(ctx->opcode) != 0)) {
2343 tcg_gen_shri_i32(cpu_crf[1], cpu_fpscr, FPSCR_OX);
2344 }
2345 /* We can raise a differed exception */
2346 gen_helper_float_check_status();
2347}
2348
2349/*** Addressing modes ***/
2350/* Register indirect with immediate index : EA = (rA|0) + SIMM */
2351static always_inline void gen_addr_imm_index (DisasContext *ctx, TCGv EA, target_long maskl)
2352{
2353 target_long simm = SIMM(ctx->opcode);
2354
2355 simm &= ~maskl;
2356 if (rA(ctx->opcode) == 0) {
2357#if defined(TARGET_PPC64)
2358 if (!ctx->sf_mode) {
2359 tcg_gen_movi_tl(EA, (uint32_t)simm);
2360 } else
2361#endif
2362 tcg_gen_movi_tl(EA, simm);
2363 } else if (likely(simm != 0)) {
2364 tcg_gen_addi_tl(EA, cpu_gpr[rA(ctx->opcode)], simm);
2365#if defined(TARGET_PPC64)
2366 if (!ctx->sf_mode) {
2367 tcg_gen_ext32u_tl(EA, EA);
2368 }
2369#endif
2370 } else {
2371#if defined(TARGET_PPC64)
2372 if (!ctx->sf_mode) {
2373 tcg_gen_ext32u_tl(EA, cpu_gpr[rA(ctx->opcode)]);
2374 } else
2375#endif
2376 tcg_gen_mov_tl(EA, cpu_gpr[rA(ctx->opcode)]);
2377 }
2378}
2379
2380static always_inline void gen_addr_reg_index (DisasContext *ctx, TCGv EA)
2381{
2382 if (rA(ctx->opcode) == 0) {
2383#if defined(TARGET_PPC64)
2384 if (!ctx->sf_mode) {
2385 tcg_gen_ext32u_tl(EA, cpu_gpr[rB(ctx->opcode)]);
2386 } else
2387#endif
2388 tcg_gen_mov_tl(EA, cpu_gpr[rB(ctx->opcode)]);
2389 } else {
2390 tcg_gen_add_tl(EA, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
2391#if defined(TARGET_PPC64)
2392 if (!ctx->sf_mode) {
2393 tcg_gen_ext32u_tl(EA, EA);
2394 }
2395#endif
2396 }
2397}
2398
2399static always_inline void gen_addr_register (DisasContext *ctx, TCGv EA)
2400{
2401 if (rA(ctx->opcode) == 0) {
2402 tcg_gen_movi_tl(EA, 0);
2403 } else {
2404#if defined(TARGET_PPC64)
2405 if (!ctx->sf_mode) {
2406 tcg_gen_ext32u_tl(EA, cpu_gpr[rA(ctx->opcode)]);
2407 } else
2408#endif
2409 tcg_gen_mov_tl(EA, cpu_gpr[rA(ctx->opcode)]);
2410 }
2411}
2412
2413static always_inline void gen_addr_add (DisasContext *ctx, TCGv ret, TCGv arg1, target_long val)
2414{
2415 tcg_gen_addi_tl(ret, arg1, val);
2416#if defined(TARGET_PPC64)
2417 if (!ctx->sf_mode) {
2418 tcg_gen_ext32u_tl(ret, ret);
2419 }
2420#endif
2421}
2422
2423static always_inline void gen_check_align (DisasContext *ctx, TCGv EA, int mask)
2424{
2425 int l1 = gen_new_label();
2426 TCGv t0 = tcg_temp_new();
2427 TCGv_i32 t1, t2;
2428 /* NIP cannot be restored if the memory exception comes from an helper */
2429 gen_update_nip(ctx, ctx->nip - 4);
2430 tcg_gen_andi_tl(t0, EA, mask);
2431 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
2432 t1 = tcg_const_i32(POWERPC_EXCP_ALIGN);
2433 t2 = tcg_const_i32(0);
2434 gen_helper_raise_exception_err(t1, t2);
2435 tcg_temp_free_i32(t1);
2436 tcg_temp_free_i32(t2);
2437 gen_set_label(l1);
2438 tcg_temp_free(t0);
2439}
2440
2441/*** Integer load ***/
2442static always_inline void gen_qemu_ld8u(DisasContext *ctx, TCGv arg1, TCGv arg2)
2443{
2444 tcg_gen_qemu_ld8u(arg1, arg2, ctx->mem_idx);
2445}
2446
2447static always_inline void gen_qemu_ld8s(DisasContext *ctx, TCGv arg1, TCGv arg2)
2448{
2449 tcg_gen_qemu_ld8s(arg1, arg2, ctx->mem_idx);
2450}
2451
2452static always_inline void gen_qemu_ld16u(DisasContext *ctx, TCGv arg1, TCGv arg2)
2453{
2454 tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);
2455 if (unlikely(ctx->le_mode)) {
2456 tcg_gen_bswap16_tl(arg1, arg1);
2457 }
2458}
2459
2460static always_inline void gen_qemu_ld16s(DisasContext *ctx, TCGv arg1, TCGv arg2)
2461{
2462 if (unlikely(ctx->le_mode)) {
2463 tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);
2464 tcg_gen_bswap16_tl(arg1, arg1);
2465 tcg_gen_ext16s_tl(arg1, arg1);
2466 } else {
2467 tcg_gen_qemu_ld16s(arg1, arg2, ctx->mem_idx);
2468 }
2469}
2470
2471static always_inline void gen_qemu_ld32u(DisasContext *ctx, TCGv arg1, TCGv arg2)
2472{
2473 tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
2474 if (unlikely(ctx->le_mode)) {
2475 tcg_gen_bswap32_tl(arg1, arg1);
2476 }
2477}
2478
2479#if defined(TARGET_PPC64)
2480static always_inline void gen_qemu_ld32s(DisasContext *ctx, TCGv arg1, TCGv arg2)
2481{
2482 if (unlikely(ctx->le_mode)) {
2483 tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
2484 tcg_gen_bswap32_tl(arg1, arg1);
2485 tcg_gen_ext32s_tl(arg1, arg1);
2486 } else
2487 tcg_gen_qemu_ld32s(arg1, arg2, ctx->mem_idx);
2488}
2489#endif
2490
2491static always_inline void gen_qemu_ld64(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
2492{
2493 tcg_gen_qemu_ld64(arg1, arg2, ctx->mem_idx);
2494 if (unlikely(ctx->le_mode)) {
2495 tcg_gen_bswap64_i64(arg1, arg1);
2496 }
2497}
2498
2499static always_inline void gen_qemu_st8(DisasContext *ctx, TCGv arg1, TCGv arg2)
2500{
2501 tcg_gen_qemu_st8(arg1, arg2, ctx->mem_idx);
2502}
2503
2504static always_inline void gen_qemu_st16(DisasContext *ctx, TCGv arg1, TCGv arg2)
2505{
2506 if (unlikely(ctx->le_mode)) {
2507 TCGv t0 = tcg_temp_new();
2508 tcg_gen_ext16u_tl(t0, arg1);
2509 tcg_gen_bswap16_tl(t0, t0);
2510 tcg_gen_qemu_st16(t0, arg2, ctx->mem_idx);
2511 tcg_temp_free(t0);
2512 } else {
2513 tcg_gen_qemu_st16(arg1, arg2, ctx->mem_idx);
2514 }
2515}
2516
2517static always_inline void gen_qemu_st32(DisasContext *ctx, TCGv arg1, TCGv arg2)
2518{
2519 if (unlikely(ctx->le_mode)) {
2520 TCGv t0 = tcg_temp_new();
2521 tcg_gen_ext32u_tl(t0, arg1);
2522 tcg_gen_bswap32_tl(t0, t0);
2523 tcg_gen_qemu_st32(t0, arg2, ctx->mem_idx);
2524 tcg_temp_free(t0);
2525 } else {
2526 tcg_gen_qemu_st32(arg1, arg2, ctx->mem_idx);
2527 }
2528}
2529
2530static always_inline void gen_qemu_st64(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
2531{
2532 if (unlikely(ctx->le_mode)) {
2533 TCGv_i64 t0 = tcg_temp_new_i64();
2534 tcg_gen_bswap64_i64(t0, arg1);
2535 tcg_gen_qemu_st64(t0, arg2, ctx->mem_idx);
2536 tcg_temp_free_i64(t0);
2537 } else
2538 tcg_gen_qemu_st64(arg1, arg2, ctx->mem_idx);
2539}
2540
2541#define GEN_LD(name, ldop, opc, type) \
2542static void glue(gen_, name)(DisasContext *ctx) \
2543{ \
2544 TCGv EA; \
2545 gen_set_access_type(ctx, ACCESS_INT); \
2546 EA = tcg_temp_new(); \
2547 gen_addr_imm_index(ctx, EA, 0); \
2548 gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA); \
2549 tcg_temp_free(EA); \
2550}
2551
2552#define GEN_LDU(name, ldop, opc, type) \
2553static void glue(gen_, name##u)(DisasContext *ctx) \
2554{ \
2555 TCGv EA; \
2556 if (unlikely(rA(ctx->opcode) == 0 || \
2557 rA(ctx->opcode) == rD(ctx->opcode))) { \
2558 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
2559 return; \
2560 } \
2561 gen_set_access_type(ctx, ACCESS_INT); \
2562 EA = tcg_temp_new(); \
2563 if (type == PPC_64B) \
2564 gen_addr_imm_index(ctx, EA, 0x03); \
2565 else \
2566 gen_addr_imm_index(ctx, EA, 0); \
2567 gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA); \
2568 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
2569 tcg_temp_free(EA); \
2570}
2571
2572#define GEN_LDUX(name, ldop, opc2, opc3, type) \
2573static void glue(gen_, name##ux)(DisasContext *ctx) \
2574{ \
2575 TCGv EA; \
2576 if (unlikely(rA(ctx->opcode) == 0 || \
2577 rA(ctx->opcode) == rD(ctx->opcode))) { \
2578 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
2579 return; \
2580 } \
2581 gen_set_access_type(ctx, ACCESS_INT); \
2582 EA = tcg_temp_new(); \
2583 gen_addr_reg_index(ctx, EA); \
2584 gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA); \
2585 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
2586 tcg_temp_free(EA); \
2587}
2588
2589#define GEN_LDX(name, ldop, opc2, opc3, type) \
2590static void glue(gen_, name##x)(DisasContext *ctx) \
2591{ \
2592 TCGv EA; \
2593 gen_set_access_type(ctx, ACCESS_INT); \
2594 EA = tcg_temp_new(); \
2595 gen_addr_reg_index(ctx, EA); \
2596 gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA); \
2597 tcg_temp_free(EA); \
2598}
2599
2600#define GEN_LDS(name, ldop, op, type) \
2601GEN_LD(name, ldop, op | 0x20, type); \
2602GEN_LDU(name, ldop, op | 0x21, type); \
2603GEN_LDUX(name, ldop, 0x17, op | 0x01, type); \
2604GEN_LDX(name, ldop, 0x17, op | 0x00, type)
2605
2606/* lbz lbzu lbzux lbzx */
2607GEN_LDS(lbz, ld8u, 0x02, PPC_INTEGER);
2608/* lha lhau lhaux lhax */
2609GEN_LDS(lha, ld16s, 0x0A, PPC_INTEGER);
2610/* lhz lhzu lhzux lhzx */
2611GEN_LDS(lhz, ld16u, 0x08, PPC_INTEGER);
2612/* lwz lwzu lwzux lwzx */
2613GEN_LDS(lwz, ld32u, 0x00, PPC_INTEGER);
2614#if defined(TARGET_PPC64)
2615/* lwaux */
2616GEN_LDUX(lwa, ld32s, 0x15, 0x0B, PPC_64B);
2617/* lwax */
2618GEN_LDX(lwa, ld32s, 0x15, 0x0A, PPC_64B);
2619/* ldux */
2620GEN_LDUX(ld, ld64, 0x15, 0x01, PPC_64B);
2621/* ldx */
2622GEN_LDX(ld, ld64, 0x15, 0x00, PPC_64B);
2623
2624static void gen_ld(DisasContext *ctx)
2625{
2626 TCGv EA;
2627 if (Rc(ctx->opcode)) {
2628 if (unlikely(rA(ctx->opcode) == 0 ||
2629 rA(ctx->opcode) == rD(ctx->opcode))) {
2630 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
2631 return;
2632 }
2633 }
2634 gen_set_access_type(ctx, ACCESS_INT);
2635 EA = tcg_temp_new();
2636 gen_addr_imm_index(ctx, EA, 0x03);
2637 if (ctx->opcode & 0x02) {
2638 /* lwa (lwau is undefined) */
2639 gen_qemu_ld32s(ctx, cpu_gpr[rD(ctx->opcode)], EA);
2640 } else {
2641 /* ld - ldu */
2642 gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], EA);
2643 }
2644 if (Rc(ctx->opcode))
2645 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA);
2646 tcg_temp_free(EA);
2647}
2648
2649/* lq */
2650static void gen_lq(DisasContext *ctx)
2651{
2652#if defined(CONFIG_USER_ONLY)
2653 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
2654#else
2655 int ra, rd;
2656 TCGv EA;
2657
2658 /* Restore CPU state */
2659 if (unlikely(ctx->mem_idx == 0)) {
2660 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
2661 return;
2662 }
2663 ra = rA(ctx->opcode);
2664 rd = rD(ctx->opcode);
2665 if (unlikely((rd & 1) || rd == ra)) {
2666 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
2667 return;
2668 }
2669 if (unlikely(ctx->le_mode)) {
2670 /* Little-endian mode is not handled */
2671 gen_exception_err(ctx, POWERPC_EXCP_ALIGN, POWERPC_EXCP_ALIGN_LE);
2672 return;
2673 }
2674 gen_set_access_type(ctx, ACCESS_INT);
2675 EA = tcg_temp_new();
2676 gen_addr_imm_index(ctx, EA, 0x0F);
2677 gen_qemu_ld64(ctx, cpu_gpr[rd], EA);
2678 gen_addr_add(ctx, EA, EA, 8);
2679 gen_qemu_ld64(ctx, cpu_gpr[rd+1], EA);
2680 tcg_temp_free(EA);
2681#endif
2682}
2683#endif
2684
2685/*** Integer store ***/
2686#define GEN_ST(name, stop, opc, type) \
2687static void glue(gen_, name)(DisasContext *ctx) \
2688{ \
2689 TCGv EA; \
2690 gen_set_access_type(ctx, ACCESS_INT); \
2691 EA = tcg_temp_new(); \
2692 gen_addr_imm_index(ctx, EA, 0); \
2693 gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA); \
2694 tcg_temp_free(EA); \
2695}
2696
2697#define GEN_STU(name, stop, opc, type) \
2698static void glue(gen_, stop##u)(DisasContext *ctx) \
2699{ \
2700 TCGv EA; \
2701 if (unlikely(rA(ctx->opcode) == 0)) { \
2702 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
2703 return; \
2704 } \
2705 gen_set_access_type(ctx, ACCESS_INT); \
2706 EA = tcg_temp_new(); \
2707 if (type == PPC_64B) \
2708 gen_addr_imm_index(ctx, EA, 0x03); \
2709 else \
2710 gen_addr_imm_index(ctx, EA, 0); \
2711 gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA); \
2712 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
2713 tcg_temp_free(EA); \
2714}
2715
2716#define GEN_STUX(name, stop, opc2, opc3, type) \
2717static void glue(gen_, name##ux)(DisasContext *ctx) \
2718{ \
2719 TCGv EA; \
2720 if (unlikely(rA(ctx->opcode) == 0)) { \
2721 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
2722 return; \
2723 } \
2724 gen_set_access_type(ctx, ACCESS_INT); \
2725 EA = tcg_temp_new(); \
2726 gen_addr_reg_index(ctx, EA); \
2727 gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA); \
2728 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
2729 tcg_temp_free(EA); \
2730}
2731
2732#define GEN_STX(name, stop, opc2, opc3, type) \
2733static void glue(gen_, name##x)(DisasContext *ctx) \
2734{ \
2735 TCGv EA; \
2736 gen_set_access_type(ctx, ACCESS_INT); \
2737 EA = tcg_temp_new(); \
2738 gen_addr_reg_index(ctx, EA); \
2739 gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA); \
2740 tcg_temp_free(EA); \
2741}
2742
2743#define GEN_STS(name, stop, op, type) \
2744GEN_ST(name, stop, op | 0x20, type); \
2745GEN_STU(name, stop, op | 0x21, type); \
2746GEN_STUX(name, stop, 0x17, op | 0x01, type); \
2747GEN_STX(name, stop, 0x17, op | 0x00, type)
2748
2749/* stb stbu stbux stbx */
2750GEN_STS(stb, st8, 0x06, PPC_INTEGER);
2751/* sth sthu sthux sthx */
2752GEN_STS(sth, st16, 0x0C, PPC_INTEGER);
2753/* stw stwu stwux stwx */
2754GEN_STS(stw, st32, 0x04, PPC_INTEGER);
2755#if defined(TARGET_PPC64)
2756GEN_STUX(std, st64, 0x15, 0x05, PPC_64B);
2757GEN_STX(std, st64, 0x15, 0x04, PPC_64B);
2758
2759static void gen_std(DisasContext *ctx)
2760{
2761 int rs;
2762 TCGv EA;
2763
2764 rs = rS(ctx->opcode);
2765 if ((ctx->opcode & 0x3) == 0x2) {
2766#if defined(CONFIG_USER_ONLY)
2767 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
2768#else
2769 /* stq */
2770 if (unlikely(ctx->mem_idx == 0)) {
2771 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
2772 return;
2773 }
2774 if (unlikely(rs & 1)) {
2775 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
2776 return;
2777 }
2778 if (unlikely(ctx->le_mode)) {
2779 /* Little-endian mode is not handled */
2780 gen_exception_err(ctx, POWERPC_EXCP_ALIGN, POWERPC_EXCP_ALIGN_LE);
2781 return;
2782 }
2783 gen_set_access_type(ctx, ACCESS_INT);
2784 EA = tcg_temp_new();
2785 gen_addr_imm_index(ctx, EA, 0x03);
2786 gen_qemu_st64(ctx, cpu_gpr[rs], EA);
2787 gen_addr_add(ctx, EA, EA, 8);
2788 gen_qemu_st64(ctx, cpu_gpr[rs+1], EA);
2789 tcg_temp_free(EA);
2790#endif
2791 } else {
2792 /* std / stdu */
2793 if (Rc(ctx->opcode)) {
2794 if (unlikely(rA(ctx->opcode) == 0)) {
2795 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
2796 return;
2797 }
2798 }
2799 gen_set_access_type(ctx, ACCESS_INT);
2800 EA = tcg_temp_new();
2801 gen_addr_imm_index(ctx, EA, 0x03);
2802 gen_qemu_st64(ctx, cpu_gpr[rs], EA);
2803 if (Rc(ctx->opcode))
2804 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA);
2805 tcg_temp_free(EA);
2806 }
2807}
2808#endif
2809/*** Integer load and store with byte reverse ***/
2810/* lhbrx */
2811static void always_inline gen_qemu_ld16ur(DisasContext *ctx, TCGv arg1, TCGv arg2)
2812{
2813 tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);
2814 if (likely(!ctx->le_mode)) {
2815 tcg_gen_bswap16_tl(arg1, arg1);
2816 }
2817}
2818GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER);
2819
2820/* lwbrx */
2821static void always_inline gen_qemu_ld32ur(DisasContext *ctx, TCGv arg1, TCGv arg2)
2822{
2823 tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
2824 if (likely(!ctx->le_mode)) {
2825 tcg_gen_bswap32_tl(arg1, arg1);
2826 }
2827}
2828GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER);
2829
2830/* sthbrx */
2831static void always_inline gen_qemu_st16r(DisasContext *ctx, TCGv arg1, TCGv arg2)
2832{
2833 if (likely(!ctx->le_mode)) {
2834 TCGv t0 = tcg_temp_new();
2835 tcg_gen_ext16u_tl(t0, arg1);
2836 tcg_gen_bswap16_tl(t0, t0);
2837 tcg_gen_qemu_st16(t0, arg2, ctx->mem_idx);
2838 tcg_temp_free(t0);
2839 } else {
2840 tcg_gen_qemu_st16(arg1, arg2, ctx->mem_idx);
2841 }
2842}
2843GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER);
2844
2845/* stwbrx */
2846static void always_inline gen_qemu_st32r(DisasContext *ctx, TCGv arg1, TCGv arg2)
2847{
2848 if (likely(!ctx->le_mode)) {
2849 TCGv t0 = tcg_temp_new();
2850 tcg_gen_ext32u_tl(t0, arg1);
2851 tcg_gen_bswap32_tl(t0, t0);
2852 tcg_gen_qemu_st32(t0, arg2, ctx->mem_idx);
2853 tcg_temp_free(t0);
2854 } else {
2855 tcg_gen_qemu_st32(arg1, arg2, ctx->mem_idx);
2856 }
2857}
2858GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER);
2859
2860/*** Integer load and store multiple ***/
2861
2862/* lmw */
2863static void gen_lmw(DisasContext *ctx)
2864{
2865 TCGv t0;
2866 TCGv_i32 t1;
2867 gen_set_access_type(ctx, ACCESS_INT);
2868 /* NIP cannot be restored if the memory exception comes from an helper */
2869 gen_update_nip(ctx, ctx->nip - 4);
2870 t0 = tcg_temp_new();
2871 t1 = tcg_const_i32(rD(ctx->opcode));
2872 gen_addr_imm_index(ctx, t0, 0);
2873 gen_helper_lmw(t0, t1);
2874 tcg_temp_free(t0);
2875 tcg_temp_free_i32(t1);
2876}
2877
2878/* stmw */
2879static void gen_stmw(DisasContext *ctx)
2880{
2881 TCGv t0;
2882 TCGv_i32 t1;
2883 gen_set_access_type(ctx, ACCESS_INT);
2884 /* NIP cannot be restored if the memory exception comes from an helper */
2885 gen_update_nip(ctx, ctx->nip - 4);
2886 t0 = tcg_temp_new();
2887 t1 = tcg_const_i32(rS(ctx->opcode));
2888 gen_addr_imm_index(ctx, t0, 0);
2889 gen_helper_stmw(t0, t1);
2890 tcg_temp_free(t0);
2891 tcg_temp_free_i32(t1);
2892}
2893
2894/*** Integer load and store strings ***/
2895
2896/* lswi */
2897/* PowerPC32 specification says we must generate an exception if
2898 * rA is in the range of registers to be loaded.
2899 * In an other hand, IBM says this is valid, but rA won't be loaded.
2900 * For now, I'll follow the spec...
2901 */
2902static void gen_lswi(DisasContext *ctx)
2903{
2904 TCGv t0;
2905 TCGv_i32 t1, t2;
2906 int nb = NB(ctx->opcode);
2907 int start = rD(ctx->opcode);
2908 int ra = rA(ctx->opcode);
2909 int nr;
2910
2911 if (nb == 0)
2912 nb = 32;
2913 nr = nb / 4;
2914 if (unlikely(((start + nr) > 32 &&
2915 start <= ra && (start + nr - 32) > ra) ||
2916 ((start + nr) <= 32 && start <= ra && (start + nr) > ra))) {
2917 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_LSWX);
2918 return;
2919 }
2920 gen_set_access_type(ctx, ACCESS_INT);
2921 /* NIP cannot be restored if the memory exception comes from an helper */
2922 gen_update_nip(ctx, ctx->nip - 4);
2923 t0 = tcg_temp_new();
2924 gen_addr_register(ctx, t0);
2925 t1 = tcg_const_i32(nb);
2926 t2 = tcg_const_i32(start);
2927 gen_helper_lsw(t0, t1, t2);
2928 tcg_temp_free(t0);
2929 tcg_temp_free_i32(t1);
2930 tcg_temp_free_i32(t2);
2931}
2932
2933/* lswx */
2934static void gen_lswx(DisasContext *ctx)
2935{
2936 TCGv t0;
2937 TCGv_i32 t1, t2, t3;
2938 gen_set_access_type(ctx, ACCESS_INT);
2939 /* NIP cannot be restored if the memory exception comes from an helper */
2940 gen_update_nip(ctx, ctx->nip - 4);
2941 t0 = tcg_temp_new();
2942 gen_addr_reg_index(ctx, t0);
2943 t1 = tcg_const_i32(rD(ctx->opcode));
2944 t2 = tcg_const_i32(rA(ctx->opcode));
2945 t3 = tcg_const_i32(rB(ctx->opcode));
2946 gen_helper_lswx(t0, t1, t2, t3);
2947 tcg_temp_free(t0);
2948 tcg_temp_free_i32(t1);
2949 tcg_temp_free_i32(t2);
2950 tcg_temp_free_i32(t3);
2951}
2952
2953/* stswi */
2954static void gen_stswi(DisasContext *ctx)
2955{
2956 TCGv t0;
2957 TCGv_i32 t1, t2;
2958 int nb = NB(ctx->opcode);
2959 gen_set_access_type(ctx, ACCESS_INT);
2960 /* NIP cannot be restored if the memory exception comes from an helper */
2961 gen_update_nip(ctx, ctx->nip - 4);
2962 t0 = tcg_temp_new();
2963 gen_addr_register(ctx, t0);
2964 if (nb == 0)
2965 nb = 32;
2966 t1 = tcg_const_i32(nb);
2967 t2 = tcg_const_i32(rS(ctx->opcode));
2968 gen_helper_stsw(t0, t1, t2);
2969 tcg_temp_free(t0);
2970 tcg_temp_free_i32(t1);
2971 tcg_temp_free_i32(t2);
2972}
2973
2974/* stswx */
2975static void gen_stswx(DisasContext *ctx)
2976{
2977 TCGv t0;
2978 TCGv_i32 t1, t2;
2979 gen_set_access_type(ctx, ACCESS_INT);
2980 /* NIP cannot be restored if the memory exception comes from an helper */
2981 gen_update_nip(ctx, ctx->nip - 4);
2982 t0 = tcg_temp_new();
2983 gen_addr_reg_index(ctx, t0);
2984 t1 = tcg_temp_new_i32();
2985 tcg_gen_trunc_tl_i32(t1, cpu_xer);
2986 tcg_gen_andi_i32(t1, t1, 0x7F);
2987 t2 = tcg_const_i32(rS(ctx->opcode));
2988 gen_helper_stsw(t0, t1, t2);
2989 tcg_temp_free(t0);
2990 tcg_temp_free_i32(t1);
2991 tcg_temp_free_i32(t2);
2992}
2993
2994/*** Memory synchronisation ***/
2995/* eieio */
2996static void gen_eieio(DisasContext *ctx)
2997{
2998}
2999
3000/* isync */
3001static void gen_isync(DisasContext *ctx)
3002{
3003 gen_stop_exception(ctx);
3004}
3005
3006/* lwarx */
3007static void gen_lwarx(DisasContext *ctx)
3008{
3009 TCGv t0;
3010 TCGv gpr = cpu_gpr[rD(ctx->opcode)];
3011 gen_set_access_type(ctx, ACCESS_RES);
3012 t0 = tcg_temp_local_new();
3013 gen_addr_reg_index(ctx, t0);
3014 gen_check_align(ctx, t0, 0x03);
3015 gen_qemu_ld32u(ctx, gpr, t0);
3016 tcg_gen_mov_tl(cpu_reserve, t0);
3017 tcg_gen_st_tl(gpr, cpu_env, offsetof(CPUState, reserve_val));
3018 tcg_temp_free(t0);
3019}
3020
3021/* stwcx. */
3022static void gen_stwcx_(DisasContext *ctx)
3023{
3024 int l1;
3025 TCGv t0;
3026 gen_set_access_type(ctx, ACCESS_RES);
3027 t0 = tcg_temp_local_new();
3028 gen_addr_reg_index(ctx, t0);
3029 gen_check_align(ctx, t0, 0x03);
3030 tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);
3031 tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);
3032 tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);
3033 l1 = gen_new_label();
3034 tcg_gen_brcond_tl(TCG_COND_NE, t0, cpu_reserve, l1);
3035 tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ);
3036 gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], t0);
3037 gen_set_label(l1);
3038 tcg_gen_movi_tl(cpu_reserve, -1);
3039 tcg_temp_free(t0);
3040}
3041
3042#if defined(TARGET_PPC64)
3043/* ldarx */
3044static void gen_ldarx(DisasContext *ctx)
3045{
3046 TCGv t0;
3047 TCGv gpr = cpu_gpr[rD(ctx->opcode)];
3048 gen_set_access_type(ctx, ACCESS_RES);
3049 t0 = tcg_temp_local_new();
3050 gen_addr_reg_index(ctx, t0);
3051 gen_check_align(ctx, t0, 0x07);
3052 gen_qemu_ld64(ctx, gpr, t0);
3053 tcg_gen_mov_tl(cpu_reserve, t0);
3054 tcg_gen_st_tl(gpr, cpu_env, offsetof(CPUState, reserve_val));
3055 tcg_temp_free(t0);
3056}
3057
3058/* stdcx. */
3059static void gen_stdcx_(DisasContext *ctx)
3060{
3061 int l1;
3062 TCGv t0;
3063 gen_set_access_type(ctx, ACCESS_RES);
3064 t0 = tcg_temp_local_new();
3065 gen_addr_reg_index(ctx, t0);
3066 gen_check_align(ctx, t0, 0x07);
3067 tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);
3068 tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);
3069 tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);
3070 l1 = gen_new_label();
3071 tcg_gen_brcond_tl(TCG_COND_NE, t0, cpu_reserve, l1);
3072 tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ);
3073 gen_qemu_st64(ctx, cpu_gpr[rS(ctx->opcode)], t0);
3074 gen_set_label(l1);
3075 tcg_gen_movi_tl(cpu_reserve, -1);
3076 tcg_temp_free(t0);
3077}
3078#endif /* defined(TARGET_PPC64) */
3079
3080/* sync */
3081static void gen_sync(DisasContext *ctx)
3082{
3083}
3084
3085/* wait */
3086static void gen_wait(DisasContext *ctx)
3087{
3088 TCGv_i32 t0 = tcg_temp_new_i32();
3089 tcg_gen_st_i32(t0, cpu_env, offsetof(CPUState, halted));
3090 tcg_temp_free_i32(t0);
3091 /* Stop translation, as the CPU is supposed to sleep from now */
3092 gen_exception_err(ctx, EXCP_HLT, 1);
3093}
3094
3095/*** Floating-point load ***/
3096#define GEN_LDF(name, ldop, opc, type) \
3097static void glue(gen_, name)(DisasContext *ctx) \
3098{ \
3099 TCGv EA; \
3100 if (unlikely(!ctx->fpu_enabled)) { \
3101 gen_exception(ctx, POWERPC_EXCP_FPU); \
3102 return; \
3103 } \
3104 gen_set_access_type(ctx, ACCESS_FLOAT); \
3105 EA = tcg_temp_new(); \
3106 gen_addr_imm_index(ctx, EA, 0); \
3107 gen_qemu_##ldop(ctx, cpu_fpr[rD(ctx->opcode)], EA); \
3108 tcg_temp_free(EA); \
3109}
3110
3111#define GEN_LDUF(name, ldop, opc, type) \
3112static void glue(gen_, name##u)(DisasContext *ctx) \
3113{ \
3114 TCGv EA; \
3115 if (unlikely(!ctx->fpu_enabled)) { \
3116 gen_exception(ctx, POWERPC_EXCP_FPU); \
3117 return; \
3118 } \
3119 if (unlikely(rA(ctx->opcode) == 0)) { \
3120 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
3121 return; \
3122 } \
3123 gen_set_access_type(ctx, ACCESS_FLOAT); \
3124 EA = tcg_temp_new(); \
3125 gen_addr_imm_index(ctx, EA, 0); \
3126 gen_qemu_##ldop(ctx, cpu_fpr[rD(ctx->opcode)], EA); \
3127 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
3128 tcg_temp_free(EA); \
3129}
3130
3131#define GEN_LDUXF(name, ldop, opc, type) \
3132static void glue(gen_, name##ux)(DisasContext *ctx) \
3133{ \
3134 TCGv EA; \
3135 if (unlikely(!ctx->fpu_enabled)) { \
3136 gen_exception(ctx, POWERPC_EXCP_FPU); \
3137 return; \
3138 } \
3139 if (unlikely(rA(ctx->opcode) == 0)) { \
3140 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
3141 return; \
3142 } \
3143 gen_set_access_type(ctx, ACCESS_FLOAT); \
3144 EA = tcg_temp_new(); \
3145 gen_addr_reg_index(ctx, EA); \
3146 gen_qemu_##ldop(ctx, cpu_fpr[rD(ctx->opcode)], EA); \
3147 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
3148 tcg_temp_free(EA); \
3149}
3150
3151#define GEN_LDXF(name, ldop, opc2, opc3, type) \
3152static void glue(gen_, name##x)(DisasContext *ctx) \
3153{ \
3154 TCGv EA; \
3155 if (unlikely(!ctx->fpu_enabled)) { \
3156 gen_exception(ctx, POWERPC_EXCP_FPU); \
3157 return; \
3158 } \
3159 gen_set_access_type(ctx, ACCESS_FLOAT); \
3160 EA = tcg_temp_new(); \
3161 gen_addr_reg_index(ctx, EA); \
3162 gen_qemu_##ldop(ctx, cpu_fpr[rD(ctx->opcode)], EA); \
3163 tcg_temp_free(EA); \
3164}
3165
3166#define GEN_LDFS(name, ldop, op, type) \
3167GEN_LDF(name, ldop, op | 0x20, type); \
3168GEN_LDUF(name, ldop, op | 0x21, type); \
3169GEN_LDUXF(name, ldop, op | 0x01, type); \
3170GEN_LDXF(name, ldop, 0x17, op | 0x00, type)
3171
3172static always_inline void gen_qemu_ld32fs(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
3173{
3174 TCGv t0 = tcg_temp_new();
3175 TCGv_i32 t1 = tcg_temp_new_i32();
3176 gen_qemu_ld32u(ctx, t0, arg2);
3177 tcg_gen_trunc_tl_i32(t1, t0);
3178 tcg_temp_free(t0);
3179 gen_helper_float32_to_float64(arg1, t1);
3180 tcg_temp_free_i32(t1);
3181}
3182
3183 /* lfd lfdu lfdux lfdx */
3184GEN_LDFS(lfd, ld64, 0x12, PPC_FLOAT);
3185 /* lfs lfsu lfsux lfsx */
3186GEN_LDFS(lfs, ld32fs, 0x10, PPC_FLOAT);
3187
3188/*** Floating-point store ***/
3189#define GEN_STF(name, stop, opc, type) \
3190static void glue(gen_, name)(DisasContext *ctx) \
3191{ \
3192 TCGv EA; \
3193 if (unlikely(!ctx->fpu_enabled)) { \
3194 gen_exception(ctx, POWERPC_EXCP_FPU); \
3195 return; \
3196 } \
3197 gen_set_access_type(ctx, ACCESS_FLOAT); \
3198 EA = tcg_temp_new(); \
3199 gen_addr_imm_index(ctx, EA, 0); \
3200 gen_qemu_##stop(ctx, cpu_fpr[rS(ctx->opcode)], EA); \
3201 tcg_temp_free(EA); \
3202}
3203
3204#define GEN_STUF(name, stop, opc, type) \
3205static void glue(gen_, name##u)(DisasContext *ctx) \
3206{ \
3207 TCGv EA; \
3208 if (unlikely(!ctx->fpu_enabled)) { \
3209 gen_exception(ctx, POWERPC_EXCP_FPU); \
3210 return; \
3211 } \
3212 if (unlikely(rA(ctx->opcode) == 0)) { \
3213 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
3214 return; \
3215 } \
3216 gen_set_access_type(ctx, ACCESS_FLOAT); \
3217 EA = tcg_temp_new(); \
3218 gen_addr_imm_index(ctx, EA, 0); \
3219 gen_qemu_##stop(ctx, cpu_fpr[rS(ctx->opcode)], EA); \
3220 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
3221 tcg_temp_free(EA); \
3222}
3223
3224#define GEN_STUXF(name, stop, opc, type) \
3225static void glue(gen_, name##ux)(DisasContext *ctx) \
3226{ \
3227 TCGv EA; \
3228 if (unlikely(!ctx->fpu_enabled)) { \
3229 gen_exception(ctx, POWERPC_EXCP_FPU); \
3230 return; \
3231 } \
3232 if (unlikely(rA(ctx->opcode) == 0)) { \
3233 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
3234 return; \
3235 } \
3236 gen_set_access_type(ctx, ACCESS_FLOAT); \
3237 EA = tcg_temp_new(); \
3238 gen_addr_reg_index(ctx, EA); \
3239 gen_qemu_##stop(ctx, cpu_fpr[rS(ctx->opcode)], EA); \
3240 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], EA); \
3241 tcg_temp_free(EA); \
3242}
3243
3244#define GEN_STXF(name, stop, opc2, opc3, type) \
3245static void glue(gen_, name##x)(DisasContext *ctx) \
3246{ \
3247 TCGv EA; \
3248 if (unlikely(!ctx->fpu_enabled)) { \
3249 gen_exception(ctx, POWERPC_EXCP_FPU); \
3250 return; \
3251 } \
3252 gen_set_access_type(ctx, ACCESS_FLOAT); \
3253 EA = tcg_temp_new(); \
3254 gen_addr_reg_index(ctx, EA); \
3255 gen_qemu_##stop(ctx, cpu_fpr[rS(ctx->opcode)], EA); \
3256 tcg_temp_free(EA); \
3257}
3258
3259#define GEN_STFS(name, stop, op, type) \
3260GEN_STF(name, stop, op | 0x20, type); \
3261GEN_STUF(name, stop, op | 0x21, type); \
3262GEN_STUXF(name, stop, op | 0x01, type); \
3263GEN_STXF(name, stop, 0x17, op | 0x00, type)
3264
3265static always_inline void gen_qemu_st32fs(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
3266{
3267 TCGv_i32 t0 = tcg_temp_new_i32();
3268 TCGv t1 = tcg_temp_new();
3269 gen_helper_float64_to_float32(t0, arg1);
3270 tcg_gen_extu_i32_tl(t1, t0);
3271 tcg_temp_free_i32(t0);
3272 gen_qemu_st32(ctx, t1, arg2);
3273 tcg_temp_free(t1);
3274}
3275
3276/* stfd stfdu stfdux stfdx */
3277GEN_STFS(stfd, st64, 0x16, PPC_FLOAT);
3278/* stfs stfsu stfsux stfsx */
3279GEN_STFS(stfs, st32fs, 0x14, PPC_FLOAT);
3280
3281/* Optional: */
3282static always_inline void gen_qemu_st32fiw(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
3283{
3284 TCGv t0 = tcg_temp_new();
3285 tcg_gen_trunc_i64_tl(t0, arg1),
3286 gen_qemu_st32(ctx, t0, arg2);
3287 tcg_temp_free(t0);
3288}
3289/* stfiwx */
3290GEN_STXF(stfiw, st32fiw, 0x17, 0x1E, PPC_FLOAT_STFIWX);
3291
3292/*** Branch ***/
3293static always_inline void gen_goto_tb (DisasContext *ctx, int n,
3294 target_ulong dest)
3295{
3296 TranslationBlock *tb;
3297 tb = ctx->tb;
3298#if defined(TARGET_PPC64)
3299 if (!ctx->sf_mode)
3300 dest = (uint32_t) dest;
3301#endif
3302 if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) &&
3303 likely(!ctx->singlestep_enabled)) {
3304 tcg_gen_goto_tb(n);
3305 tcg_gen_movi_tl(cpu_nip, dest & ~3);
3306 tcg_gen_exit_tb((long)tb + n);
3307 } else {
3308 tcg_gen_movi_tl(cpu_nip, dest & ~3);
3309 if (unlikely(ctx->singlestep_enabled)) {
3310 if ((ctx->singlestep_enabled &
3311 (CPU_BRANCH_STEP | CPU_SINGLE_STEP)) &&
3312 ctx->exception == POWERPC_EXCP_BRANCH) {
3313 target_ulong tmp = ctx->nip;
3314 ctx->nip = dest;
3315 gen_exception(ctx, POWERPC_EXCP_TRACE);
3316 ctx->nip = tmp;
3317 }
3318 if (ctx->singlestep_enabled & GDBSTUB_SINGLE_STEP) {
3319 gen_debug_exception(ctx);
3320 }
3321 }
3322 tcg_gen_exit_tb(0);
3323 }
3324}
3325
3326static always_inline void gen_setlr (DisasContext *ctx, target_ulong nip)
3327{
3328#if defined(TARGET_PPC64)
3329 if (ctx->sf_mode == 0)
3330 tcg_gen_movi_tl(cpu_lr, (uint32_t)nip);
3331 else
3332#endif
3333 tcg_gen_movi_tl(cpu_lr, nip);
3334}
3335
3336/* b ba bl bla */
3337static void gen_b(DisasContext *ctx)
3338{
3339 target_ulong li, target;
3340
3341 ctx->exception = POWERPC_EXCP_BRANCH;
3342 /* sign extend LI */
3343#if defined(TARGET_PPC64)
3344 if (ctx->sf_mode)
3345 li = ((int64_t)LI(ctx->opcode) << 38) >> 38;
3346 else
3347#endif
3348 li = ((int32_t)LI(ctx->opcode) << 6) >> 6;
3349 if (likely(AA(ctx->opcode) == 0))
3350 target = ctx->nip + li - 4;
3351 else
3352 target = li;
3353 if (LK(ctx->opcode))
3354 gen_setlr(ctx, ctx->nip);
3355 gen_goto_tb(ctx, 0, target);
3356}
3357
3358#define BCOND_IM 0
3359#define BCOND_LR 1
3360#define BCOND_CTR 2
3361
3362static always_inline void gen_bcond (DisasContext *ctx, int type)
3363{
3364 uint32_t bo = BO(ctx->opcode);
3365 int l1 = gen_new_label();
3366 TCGv target;
3367
3368 ctx->exception = POWERPC_EXCP_BRANCH;
3369 if (type == BCOND_LR || type == BCOND_CTR) {
3370 target = tcg_temp_local_new();
3371 if (type == BCOND_CTR)
3372 tcg_gen_mov_tl(target, cpu_ctr);
3373 else
3374 tcg_gen_mov_tl(target, cpu_lr);
3375 } else {
3376 TCGV_UNUSED(target);
3377 }
3378 if (LK(ctx->opcode))
3379 gen_setlr(ctx, ctx->nip);
3380 l1 = gen_new_label();
3381 if ((bo & 0x4) == 0) {
3382 /* Decrement and test CTR */
3383 TCGv temp = tcg_temp_new();
3384 if (unlikely(type == BCOND_CTR)) {
3385 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
3386 return;
3387 }
3388 tcg_gen_subi_tl(cpu_ctr, cpu_ctr, 1);
3389#if defined(TARGET_PPC64)
3390 if (!ctx->sf_mode)
3391 tcg_gen_ext32u_tl(temp, cpu_ctr);
3392 else
3393#endif
3394 tcg_gen_mov_tl(temp, cpu_ctr);
3395 if (bo & 0x2) {
3396 tcg_gen_brcondi_tl(TCG_COND_NE, temp, 0, l1);
3397 } else {
3398 tcg_gen_brcondi_tl(TCG_COND_EQ, temp, 0, l1);
3399 }
3400 tcg_temp_free(temp);
3401 }
3402 if ((bo & 0x10) == 0) {
3403 /* Test CR */
3404 uint32_t bi = BI(ctx->opcode);
3405 uint32_t mask = 1 << (3 - (bi & 0x03));
3406 TCGv_i32 temp = tcg_temp_new_i32();
3407
3408 if (bo & 0x8) {
3409 tcg_gen_andi_i32(temp, cpu_crf[bi >> 2], mask);
3410 tcg_gen_brcondi_i32(TCG_COND_EQ, temp, 0, l1);
3411 } else {
3412 tcg_gen_andi_i32(temp, cpu_crf[bi >> 2], mask);
3413 tcg_gen_brcondi_i32(TCG_COND_NE, temp, 0, l1);
3414 }
3415 tcg_temp_free_i32(temp);
3416 }
3417 if (type == BCOND_IM) {
3418 target_ulong li = (target_long)((int16_t)(BD(ctx->opcode)));
3419 if (likely(AA(ctx->opcode) == 0)) {
3420 gen_goto_tb(ctx, 0, ctx->nip + li - 4);
3421 } else {
3422 gen_goto_tb(ctx, 0, li);
3423 }
3424 gen_set_label(l1);
3425 gen_goto_tb(ctx, 1, ctx->nip);
3426 } else {
3427#if defined(TARGET_PPC64)
3428 if (!(ctx->sf_mode))
3429 tcg_gen_andi_tl(cpu_nip, target, (uint32_t)~3);
3430 else
3431#endif
3432 tcg_gen_andi_tl(cpu_nip, target, ~3);
3433 tcg_gen_exit_tb(0);
3434 gen_set_label(l1);
3435#if defined(TARGET_PPC64)
3436 if (!(ctx->sf_mode))
3437 tcg_gen_movi_tl(cpu_nip, (uint32_t)ctx->nip);
3438 else
3439#endif
3440 tcg_gen_movi_tl(cpu_nip, ctx->nip);
3441 tcg_gen_exit_tb(0);
3442 }
3443}
3444
3445static void gen_bc(DisasContext *ctx)
3446{
3447 gen_bcond(ctx, BCOND_IM);
3448}
3449
3450static void gen_bcctr(DisasContext *ctx)
3451{
3452 gen_bcond(ctx, BCOND_CTR);
3453}
3454
3455static void gen_bclr(DisasContext *ctx)
3456{
3457 gen_bcond(ctx, BCOND_LR);
3458}
3459
3460/*** Condition register logical ***/
3461#define GEN_CRLOGIC(name, tcg_op, opc) \
3462static void glue(gen_, name)(DisasContext *ctx) \
3463{ \
3464 uint8_t bitmask; \
3465 int sh; \
3466 TCGv_i32 t0, t1; \
3467 sh = (crbD(ctx->opcode) & 0x03) - (crbA(ctx->opcode) & 0x03); \
3468 t0 = tcg_temp_new_i32(); \
3469 if (sh > 0) \
3470 tcg_gen_shri_i32(t0, cpu_crf[crbA(ctx->opcode) >> 2], sh); \
3471 else if (sh < 0) \
3472 tcg_gen_shli_i32(t0, cpu_crf[crbA(ctx->opcode) >> 2], -sh); \
3473 else \
3474 tcg_gen_mov_i32(t0, cpu_crf[crbA(ctx->opcode) >> 2]); \
3475 t1 = tcg_temp_new_i32(); \
3476 sh = (crbD(ctx->opcode) & 0x03) - (crbB(ctx->opcode) & 0x03); \
3477 if (sh > 0) \
3478 tcg_gen_shri_i32(t1, cpu_crf[crbB(ctx->opcode) >> 2], sh); \
3479 else if (sh < 0) \
3480 tcg_gen_shli_i32(t1, cpu_crf[crbB(ctx->opcode) >> 2], -sh); \
3481 else \
3482 tcg_gen_mov_i32(t1, cpu_crf[crbB(ctx->opcode) >> 2]); \
3483 tcg_op(t0, t0, t1); \
3484 bitmask = 1 << (3 - (crbD(ctx->opcode) & 0x03)); \
3485 tcg_gen_andi_i32(t0, t0, bitmask); \
3486 tcg_gen_andi_i32(t1, cpu_crf[crbD(ctx->opcode) >> 2], ~bitmask); \
3487 tcg_gen_or_i32(cpu_crf[crbD(ctx->opcode) >> 2], t0, t1); \
3488 tcg_temp_free_i32(t0); \
3489 tcg_temp_free_i32(t1); \
3490}
3491
3492/* crand */
3493GEN_CRLOGIC(crand, tcg_gen_and_i32, 0x08);
3494/* crandc */
3495GEN_CRLOGIC(crandc, tcg_gen_andc_i32, 0x04);
3496/* creqv */
3497GEN_CRLOGIC(creqv, tcg_gen_eqv_i32, 0x09);
3498/* crnand */
3499GEN_CRLOGIC(crnand, tcg_gen_nand_i32, 0x07);
3500/* crnor */
3501GEN_CRLOGIC(crnor, tcg_gen_nor_i32, 0x01);
3502/* cror */
3503GEN_CRLOGIC(cror, tcg_gen_or_i32, 0x0E);
3504/* crorc */
3505GEN_CRLOGIC(crorc, tcg_gen_orc_i32, 0x0D);
3506/* crxor */
3507GEN_CRLOGIC(crxor, tcg_gen_xor_i32, 0x06);
3508
3509/* mcrf */
3510static void gen_mcrf(DisasContext *ctx)
3511{
3512 tcg_gen_mov_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfS(ctx->opcode)]);
3513}
3514
3515/*** System linkage ***/
3516
3517/* rfi (mem_idx only) */
3518static void gen_rfi(DisasContext *ctx)
3519{
3520#if defined(CONFIG_USER_ONLY)
3521 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3522#else
3523 /* Restore CPU state */
3524 if (unlikely(!ctx->mem_idx)) {
3525 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3526 return;
3527 }
3528 gen_helper_rfi();
3529 gen_sync_exception(ctx);
3530#endif
3531}
3532
3533#if defined(TARGET_PPC64)
3534static void gen_rfid(DisasContext *ctx)
3535{
3536#if defined(CONFIG_USER_ONLY)
3537 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3538#else
3539 /* Restore CPU state */
3540 if (unlikely(!ctx->mem_idx)) {
3541 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3542 return;
3543 }
3544 gen_helper_rfid();
3545 gen_sync_exception(ctx);
3546#endif
3547}
3548
3549static void gen_hrfid(DisasContext *ctx)
3550{
3551#if defined(CONFIG_USER_ONLY)
3552 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3553#else
3554 /* Restore CPU state */
3555 if (unlikely(ctx->mem_idx <= 1)) {
3556 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3557 return;
3558 }
3559 gen_helper_hrfid();
3560 gen_sync_exception(ctx);
3561#endif
3562}
3563#endif
3564
3565/* sc */
3566#if defined(CONFIG_USER_ONLY)
3567#define POWERPC_SYSCALL POWERPC_EXCP_SYSCALL_USER
3568#else
3569#define POWERPC_SYSCALL POWERPC_EXCP_SYSCALL
3570#endif
3571static void gen_sc(DisasContext *ctx)
3572{
3573 uint32_t lev;
3574
3575 lev = (ctx->opcode >> 5) & 0x7F;
3576 gen_exception_err(ctx, POWERPC_SYSCALL, lev);
3577}
3578
3579/*** Trap ***/
3580
3581/* tw */
3582static void gen_tw(DisasContext *ctx)
3583{
3584 TCGv_i32 t0 = tcg_const_i32(TO(ctx->opcode));
3585 /* Update the nip since this might generate a trap exception */
3586 gen_update_nip(ctx, ctx->nip);
3587 gen_helper_tw(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], t0);
3588 tcg_temp_free_i32(t0);
3589}
3590
3591/* twi */
3592static void gen_twi(DisasContext *ctx)
3593{
3594 TCGv t0 = tcg_const_tl(SIMM(ctx->opcode));
3595 TCGv_i32 t1 = tcg_const_i32(TO(ctx->opcode));
3596 /* Update the nip since this might generate a trap exception */
3597 gen_update_nip(ctx, ctx->nip);
3598 gen_helper_tw(cpu_gpr[rA(ctx->opcode)], t0, t1);
3599 tcg_temp_free(t0);
3600 tcg_temp_free_i32(t1);
3601}
3602
3603#if defined(TARGET_PPC64)
3604/* td */
3605static void gen_td(DisasContext *ctx)
3606{
3607 TCGv_i32 t0 = tcg_const_i32(TO(ctx->opcode));
3608 /* Update the nip since this might generate a trap exception */
3609 gen_update_nip(ctx, ctx->nip);
3610 gen_helper_td(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], t0);
3611 tcg_temp_free_i32(t0);
3612}
3613
3614/* tdi */
3615static void gen_tdi(DisasContext *ctx)
3616{
3617 TCGv t0 = tcg_const_tl(SIMM(ctx->opcode));
3618 TCGv_i32 t1 = tcg_const_i32(TO(ctx->opcode));
3619 /* Update the nip since this might generate a trap exception */
3620 gen_update_nip(ctx, ctx->nip);
3621 gen_helper_td(cpu_gpr[rA(ctx->opcode)], t0, t1);
3622 tcg_temp_free(t0);
3623 tcg_temp_free_i32(t1);
3624}
3625#endif
3626
3627/*** Processor control ***/
3628
3629/* mcrxr */
3630static void gen_mcrxr(DisasContext *ctx)
3631{
3632 tcg_gen_trunc_tl_i32(cpu_crf[crfD(ctx->opcode)], cpu_xer);
3633 tcg_gen_shri_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfD(ctx->opcode)], XER_CA);
3634 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_SO | 1 << XER_OV | 1 << XER_CA));
3635}
3636
3637/* mfcr mfocrf */
3638static void gen_mfcr(DisasContext *ctx)
3639{
3640 uint32_t crm, crn;
3641
3642 if (likely(ctx->opcode & 0x00100000)) {
3643 crm = CRM(ctx->opcode);
3644 if (likely(crm && ((crm & (crm - 1)) == 0))) {
3645 crn = ctz32 (crm);
3646 tcg_gen_extu_i32_tl(cpu_gpr[rD(ctx->opcode)], cpu_crf[7 - crn]);
3647 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)],
3648 cpu_gpr[rD(ctx->opcode)], crn * 4);
3649 }
3650 } else {
3651 TCGv_i32 t0 = tcg_temp_new_i32();
3652 tcg_gen_mov_i32(t0, cpu_crf[0]);
3653 tcg_gen_shli_i32(t0, t0, 4);
3654 tcg_gen_or_i32(t0, t0, cpu_crf[1]);
3655 tcg_gen_shli_i32(t0, t0, 4);
3656 tcg_gen_or_i32(t0, t0, cpu_crf[2]);
3657 tcg_gen_shli_i32(t0, t0, 4);
3658 tcg_gen_or_i32(t0, t0, cpu_crf[3]);
3659 tcg_gen_shli_i32(t0, t0, 4);
3660 tcg_gen_or_i32(t0, t0, cpu_crf[4]);
3661 tcg_gen_shli_i32(t0, t0, 4);
3662 tcg_gen_or_i32(t0, t0, cpu_crf[5]);
3663 tcg_gen_shli_i32(t0, t0, 4);
3664 tcg_gen_or_i32(t0, t0, cpu_crf[6]);
3665 tcg_gen_shli_i32(t0, t0, 4);
3666 tcg_gen_or_i32(t0, t0, cpu_crf[7]);
3667 tcg_gen_extu_i32_tl(cpu_gpr[rD(ctx->opcode)], t0);
3668 tcg_temp_free_i32(t0);
3669 }
3670}
3671
3672/* mfmsr */
3673static void gen_mfmsr(DisasContext *ctx)
3674{
3675#if defined(CONFIG_USER_ONLY)
3676 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3677#else
3678 if (unlikely(!ctx->mem_idx)) {
3679 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3680 return;
3681 }
3682 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_msr);
3683#endif
3684}
3685
3686#if 1
3687#define SPR_NOACCESS ((void *)(-1UL))
3688#else
3689static void spr_noaccess (void *opaque, int sprn)
3690{
3691 sprn = ((sprn >> 5) & 0x1F) | ((sprn & 0x1F) << 5);
3692 printf("ERROR: try to access SPR %d !\n", sprn);
3693}
3694#define SPR_NOACCESS (&spr_noaccess)
3695#endif
3696
3697/* mfspr */
3698static always_inline void gen_op_mfspr (DisasContext *ctx)
3699{
3700 void (*read_cb)(void *opaque, int gprn, int sprn);
3701 uint32_t sprn = SPR(ctx->opcode);
3702
3703#if !defined(CONFIG_USER_ONLY)
3704 if (ctx->mem_idx == 2)
3705 read_cb = ctx->spr_cb[sprn].hea_read;
3706 else if (ctx->mem_idx)
3707 read_cb = ctx->spr_cb[sprn].oea_read;
3708 else
3709#endif
3710 read_cb = ctx->spr_cb[sprn].uea_read;
3711 if (likely(read_cb != NULL)) {
3712 if (likely(read_cb != SPR_NOACCESS)) {
3713 (*read_cb)(ctx, rD(ctx->opcode), sprn);
3714 } else {
3715 /* Privilege exception */
3716 /* This is a hack to avoid warnings when running Linux:
3717 * this OS breaks the PowerPC virtualisation model,
3718 * allowing userland application to read the PVR
3719 */
3720 if (sprn != SPR_PVR) {
3721 qemu_log("Trying to read privileged spr %d %03x at "
3722 ADDRX "\n", sprn, sprn, ctx->nip);
3723 printf("Trying to read privileged spr %d %03x at " ADDRX "\n",
3724 sprn, sprn, ctx->nip);
3725 }
3726 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3727 }
3728 } else {
3729 /* Not defined */
3730 qemu_log("Trying to read invalid spr %d %03x at "
3731 ADDRX "\n", sprn, sprn, ctx->nip);
3732 printf("Trying to read invalid spr %d %03x at " ADDRX "\n",
3733 sprn, sprn, ctx->nip);
3734 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_SPR);
3735 }
3736}
3737
3738static void gen_mfspr(DisasContext *ctx)
3739{
3740 gen_op_mfspr(ctx);
3741}
3742
3743/* mftb */
3744static void gen_mftb(DisasContext *ctx)
3745{
3746 gen_op_mfspr(ctx);
3747}
3748
3749/* mtcrf mtocrf*/
3750static void gen_mtcrf(DisasContext *ctx)
3751{
3752 uint32_t crm, crn;
3753
3754 crm = CRM(ctx->opcode);
3755 if (likely((ctx->opcode & 0x00100000))) {
3756 if (crm && ((crm & (crm - 1)) == 0)) {
3757 TCGv_i32 temp = tcg_temp_new_i32();
3758 crn = ctz32 (crm);
3759 tcg_gen_trunc_tl_i32(temp, cpu_gpr[rS(ctx->opcode)]);
3760 tcg_gen_shri_i32(temp, temp, crn * 4);
3761 tcg_gen_andi_i32(cpu_crf[7 - crn], temp, 0xf);
3762 tcg_temp_free_i32(temp);
3763 }
3764 } else {
3765 TCGv_i32 temp = tcg_temp_new_i32();
3766 tcg_gen_trunc_tl_i32(temp, cpu_gpr[rS(ctx->opcode)]);
3767 for (crn = 0 ; crn < 8 ; crn++) {
3768 if (crm & (1 << crn)) {
3769 tcg_gen_shri_i32(cpu_crf[7 - crn], temp, crn * 4);
3770 tcg_gen_andi_i32(cpu_crf[7 - crn], cpu_crf[7 - crn], 0xf);
3771 }
3772 }
3773 tcg_temp_free_i32(temp);
3774 }
3775}
3776
3777/* mtmsr */
3778#if defined(TARGET_PPC64)
3779static void gen_mtmsrd(DisasContext *ctx)
3780{
3781#if defined(CONFIG_USER_ONLY)
3782 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3783#else
3784 if (unlikely(!ctx->mem_idx)) {
3785 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3786 return;
3787 }
3788 if (ctx->opcode & 0x00010000) {
3789 /* Special form that does not need any synchronisation */
3790 TCGv t0 = tcg_temp_new();
3791 tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], (1 << MSR_RI) | (1 << MSR_EE));
3792 tcg_gen_andi_tl(cpu_msr, cpu_msr, ~((1 << MSR_RI) | (1 << MSR_EE)));
3793 tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
3794 tcg_temp_free(t0);
3795 } else {
3796 /* XXX: we need to update nip before the store
3797 * if we enter power saving mode, we will exit the loop
3798 * directly from ppc_store_msr
3799 */
3800 gen_update_nip(ctx, ctx->nip);
3801 gen_helper_store_msr(cpu_gpr[rS(ctx->opcode)]);
3802 /* Must stop the translation as machine state (may have) changed */
3803 /* Note that mtmsr is not always defined as context-synchronizing */
3804 gen_stop_exception(ctx);
3805 }
3806#endif
3807}
3808#endif
3809
3810static void gen_mtmsr(DisasContext *ctx)
3811{
3812#if defined(CONFIG_USER_ONLY)
3813 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3814#else
3815 if (unlikely(!ctx->mem_idx)) {
3816 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3817 return;
3818 }
3819 if (ctx->opcode & 0x00010000) {
3820 /* Special form that does not need any synchronisation */
3821 TCGv t0 = tcg_temp_new();
3822 tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], (1 << MSR_RI) | (1 << MSR_EE));
3823 tcg_gen_andi_tl(cpu_msr, cpu_msr, ~((1 << MSR_RI) | (1 << MSR_EE)));
3824 tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
3825 tcg_temp_free(t0);
3826 } else {
3827 /* XXX: we need to update nip before the store
3828 * if we enter power saving mode, we will exit the loop
3829 * directly from ppc_store_msr
3830 */
3831 gen_update_nip(ctx, ctx->nip);
3832#if defined(TARGET_PPC64)
3833 if (!ctx->sf_mode) {
3834 TCGv t0 = tcg_temp_new();
3835 TCGv t1 = tcg_temp_new();
3836 tcg_gen_andi_tl(t0, cpu_msr, 0xFFFFFFFF00000000ULL);
3837 tcg_gen_ext32u_tl(t1, cpu_gpr[rS(ctx->opcode)]);
3838 tcg_gen_or_tl(t0, t0, t1);
3839 tcg_temp_free(t1);
3840 gen_helper_store_msr(t0);
3841 tcg_temp_free(t0);
3842 } else
3843#endif
3844 gen_helper_store_msr(cpu_gpr[rS(ctx->opcode)]);
3845 /* Must stop the translation as machine state (may have) changed */
3846 /* Note that mtmsr is not always defined as context-synchronizing */
3847 gen_stop_exception(ctx);
3848 }
3849#endif
3850}
3851
3852/* mtspr */
3853static void gen_mtspr(DisasContext *ctx)
3854{
3855 void (*write_cb)(void *opaque, int sprn, int gprn);
3856 uint32_t sprn = SPR(ctx->opcode);
3857
3858#if !defined(CONFIG_USER_ONLY)
3859 if (ctx->mem_idx == 2)
3860 write_cb = ctx->spr_cb[sprn].hea_write;
3861 else if (ctx->mem_idx)
3862 write_cb = ctx->spr_cb[sprn].oea_write;
3863 else
3864#endif
3865 write_cb = ctx->spr_cb[sprn].uea_write;
3866 if (likely(write_cb != NULL)) {
3867 if (likely(write_cb != SPR_NOACCESS)) {
3868 (*write_cb)(ctx, sprn, rS(ctx->opcode));
3869 } else {
3870 /* Privilege exception */
3871 qemu_log("Trying to write privileged spr %d %03x at "
3872 ADDRX "\n", sprn, sprn, ctx->nip);
3873 printf("Trying to write privileged spr %d %03x at " ADDRX "\n",
3874 sprn, sprn, ctx->nip);
3875 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
3876 }
3877 } else {
3878 /* Not defined */
3879 qemu_log("Trying to write invalid spr %d %03x at "
3880 ADDRX "\n", sprn, sprn, ctx->nip);
3881 printf("Trying to write invalid spr %d %03x at " ADDRX "\n",
3882 sprn, sprn, ctx->nip);
3883 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_SPR);
3884 }
3885}
3886
3887/*** Cache management ***/
3888
3889/* dcbf */
3890static void gen_dcbf(DisasContext *ctx)
3891{
3892 /* XXX: specification says this is treated as a load by the MMU */
3893 TCGv t0;
3894 gen_set_access_type(ctx, ACCESS_CACHE);
3895 t0 = tcg_temp_new();
3896 gen_addr_reg_index(ctx, t0);
3897 gen_qemu_ld8u(ctx, t0, t0);
3898 tcg_temp_free(t0);
3899}
3900
3901/* dcbi (Supervisor only) */
3902static void gen_dcbi(DisasContext *ctx)
3903{
3904#if defined(CONFIG_USER_ONLY)
3905 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3906#else
3907 TCGv EA, val;
3908 if (unlikely(!ctx->mem_idx)) {
3909 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
3910 return;
3911 }
3912 EA = tcg_temp_new();
3913 gen_set_access_type(ctx, ACCESS_CACHE);
3914 gen_addr_reg_index(ctx, EA);
3915 val = tcg_temp_new();
3916 /* XXX: specification says this should be treated as a store by the MMU */
3917 gen_qemu_ld8u(ctx, val, EA);
3918 gen_qemu_st8(ctx, val, EA);
3919 tcg_temp_free(val);
3920 tcg_temp_free(EA);
3921#endif
3922}
3923
3924/* dcdst */
3925static void gen_dcbst(DisasContext *ctx)
3926{
3927 /* XXX: specification say this is treated as a load by the MMU */
3928 TCGv t0;
3929 gen_set_access_type(ctx, ACCESS_CACHE);
3930 t0 = tcg_temp_new();
3931 gen_addr_reg_index(ctx, t0);
3932 gen_qemu_ld8u(ctx, t0, t0);
3933 tcg_temp_free(t0);
3934}
3935
3936/* dcbt */
3937static void gen_dcbt(DisasContext *ctx)
3938{
3939 /* interpreted as no-op */
3940 /* XXX: specification say this is treated as a load by the MMU
3941 * but does not generate any exception
3942 */
3943}
3944
3945/* dcbtst */
3946static void gen_dcbtst(DisasContext *ctx)
3947{
3948 /* interpreted as no-op */
3949 /* XXX: specification say this is treated as a load by the MMU
3950 * but does not generate any exception
3951 */
3952}
3953
3954/* dcbz */
3955static void gen_dcbz(DisasContext *ctx)
3956{
3957 TCGv t0;
3958 gen_set_access_type(ctx, ACCESS_CACHE);
3959 /* NIP cannot be restored if the memory exception comes from an helper */
3960 gen_update_nip(ctx, ctx->nip - 4);
3961 t0 = tcg_temp_new();
3962 gen_addr_reg_index(ctx, t0);
3963 gen_helper_dcbz(t0);
3964 tcg_temp_free(t0);
3965}
3966
3967static void gen_dcbz_970(DisasContext *ctx)
3968{
3969 TCGv t0;
3970 gen_set_access_type(ctx, ACCESS_CACHE);
3971 /* NIP cannot be restored if the memory exception comes from an helper */
3972 gen_update_nip(ctx, ctx->nip - 4);
3973 t0 = tcg_temp_new();
3974 gen_addr_reg_index(ctx, t0);
3975 if (ctx->opcode & 0x00200000)
3976 gen_helper_dcbz(t0);
3977 else
3978 gen_helper_dcbz_970(t0);
3979 tcg_temp_free(t0);
3980}
3981
3982/* dst / dstt */
3983static void gen_dst(DisasContext *ctx)
3984{
3985 if (rA(ctx->opcode) == 0) {
3986 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_LSWX);
3987 } else {
3988 /* interpreted as no-op */
3989 }
3990}
3991
3992/* dstst /dststt */
3993static void gen_dstst(DisasContext *ctx)
3994{
3995 if (rA(ctx->opcode) == 0) {
3996 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_LSWX);
3997 } else {
3998 /* interpreted as no-op */
3999 }
4000
4001}
4002
4003/* dss / dssall */
4004static void gen_dss(DisasContext *ctx)
4005{
4006 /* interpreted as no-op */
4007}
4008
4009/* icbi */
4010static void gen_icbi(DisasContext *ctx)
4011{
4012 TCGv t0;
4013 gen_set_access_type(ctx, ACCESS_CACHE);
4014 /* NIP cannot be restored if the memory exception comes from an helper */
4015 gen_update_nip(ctx, ctx->nip - 4);
4016 t0 = tcg_temp_new();
4017 gen_addr_reg_index(ctx, t0);
4018 gen_helper_icbi(t0);
4019 tcg_temp_free(t0);
4020}
4021
4022/* Optional: */
4023/* dcba */
4024static void gen_dcba(DisasContext *ctx)
4025{
4026 /* interpreted as no-op */
4027 /* XXX: specification say this is treated as a store by the MMU
4028 * but does not generate any exception
4029 */
4030}
4031
4032/*** Segment register manipulation ***/
4033/* Supervisor only: */
4034
4035/* mfsr */
4036static void gen_mfsr(DisasContext *ctx)
4037{
4038#if defined(CONFIG_USER_ONLY)
4039 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4040#else
4041 TCGv t0;
4042 if (unlikely(!ctx->mem_idx)) {
4043 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4044 return;
4045 }
4046 t0 = tcg_const_tl(SR(ctx->opcode));
4047 gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], t0);
4048 tcg_temp_free(t0);
4049#endif
4050}
4051
4052/* mfsrin */
4053static void gen_mfsrin(DisasContext *ctx)
4054{
4055#if defined(CONFIG_USER_ONLY)
4056 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4057#else
4058 TCGv t0;
4059 if (unlikely(!ctx->mem_idx)) {
4060 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4061 return;
4062 }
4063 t0 = tcg_temp_new();
4064 tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 28);
4065 tcg_gen_andi_tl(t0, t0, 0xF);
4066 gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], t0);
4067 tcg_temp_free(t0);
4068#endif
4069}
4070
4071/* mtsr */
4072static void gen_mtsr(DisasContext *ctx)
4073{
4074#if defined(CONFIG_USER_ONLY)
4075 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4076#else
4077 TCGv t0;
4078 if (unlikely(!ctx->mem_idx)) {
4079 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4080 return;
4081 }
4082 t0 = tcg_const_tl(SR(ctx->opcode));
4083 gen_helper_store_sr(t0, cpu_gpr[rS(ctx->opcode)]);
4084 tcg_temp_free(t0);
4085#endif
4086}
4087
4088/* mtsrin */
4089static void gen_mtsrin(DisasContext *ctx)
4090{
4091#if defined(CONFIG_USER_ONLY)
4092 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4093#else
4094 TCGv t0;
4095 if (unlikely(!ctx->mem_idx)) {
4096 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4097 return;
4098 }
4099 t0 = tcg_temp_new();
4100 tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 28);
4101 tcg_gen_andi_tl(t0, t0, 0xF);
4102 gen_helper_store_sr(t0, cpu_gpr[rD(ctx->opcode)]);
4103 tcg_temp_free(t0);
4104#endif
4105}
4106
4107#if defined(TARGET_PPC64)
4108/* Specific implementation for PowerPC 64 "bridge" emulation using SLB */
4109
4110/* mfsr */
4111static void gen_mfsr_64b(DisasContext *ctx)
4112{
4113#if defined(CONFIG_USER_ONLY)
4114 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4115#else
4116 TCGv t0;
4117 if (unlikely(!ctx->mem_idx)) {
4118 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4119 return;
4120 }
4121 t0 = tcg_const_tl(SR(ctx->opcode));
4122 gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], t0);
4123 tcg_temp_free(t0);
4124#endif
4125}
4126
4127/* mfsrin */
4128static void gen_mfsrin_64b(DisasContext *ctx)
4129{
4130#if defined(CONFIG_USER_ONLY)
4131 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4132#else
4133 TCGv t0;
4134 if (unlikely(!ctx->mem_idx)) {
4135 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4136 return;
4137 }
4138 t0 = tcg_temp_new();
4139 tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 28);
4140 tcg_gen_andi_tl(t0, t0, 0xF);
4141 gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], t0);
4142 tcg_temp_free(t0);
4143#endif
4144}
4145
4146/* mtsr */
4147static void gen_mtsr_64b(DisasContext *ctx)
4148{
4149#if defined(CONFIG_USER_ONLY)
4150 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4151#else
4152 TCGv t0;
4153 if (unlikely(!ctx->mem_idx)) {
4154 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4155 return;
4156 }
4157 t0 = tcg_const_tl(SR(ctx->opcode));
4158 gen_helper_store_sr(t0, cpu_gpr[rS(ctx->opcode)]);
4159 tcg_temp_free(t0);
4160#endif
4161}
4162
4163/* mtsrin */
4164static void gen_mtsrin_64b(DisasContext *ctx)
4165{
4166#if defined(CONFIG_USER_ONLY)
4167 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4168#else
4169 TCGv t0;
4170 if (unlikely(!ctx->mem_idx)) {
4171 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4172 return;
4173 }
4174 t0 = tcg_temp_new();
4175 tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 28);
4176 tcg_gen_andi_tl(t0, t0, 0xF);
4177 gen_helper_store_sr(t0, cpu_gpr[rS(ctx->opcode)]);
4178 tcg_temp_free(t0);
4179#endif
4180}
4181
4182/* slbmte */
4183static void gen_slbmte(DisasContext *ctx)
4184{
4185#if defined(CONFIG_USER_ONLY)
4186 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4187#else
4188 if (unlikely(!ctx->mem_idx)) {
4189 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
4190 return;
4191 }
4192 gen_helper_store_slb(cpu_gpr[rB(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
4193#endif
4194}
4195
4196#endif /* defined(TARGET_PPC64) */
4197
4198/*** Lookaside buffer management ***/
4199/* Optional & mem_idx only: */
4200
4201/* tlbia */
4202static void gen_tlbia(DisasContext *ctx)
4203{
4204#if defined(CONFIG_USER_ONLY)
4205 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4206#else
4207 if (unlikely(!ctx->mem_idx)) {
4208 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4209 return;
4210 }
4211 gen_helper_tlbia();
4212#endif
4213}
4214
4215/* tlbiel */
4216static void gen_tlbiel(DisasContext *ctx)
4217{
4218#if defined(CONFIG_USER_ONLY)
4219 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4220#else
4221 if (unlikely(!ctx->mem_idx)) {
4222 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4223 return;
4224 }
4225 gen_helper_tlbie(cpu_gpr[rB(ctx->opcode)]);
4226#endif
4227}
4228
4229/* tlbie */
4230static void gen_tlbie(DisasContext *ctx)
4231{
4232#if defined(CONFIG_USER_ONLY)
4233 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4234#else
4235 if (unlikely(!ctx->mem_idx)) {
4236 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4237 return;
4238 }
4239#if defined(TARGET_PPC64)
4240 if (!ctx->sf_mode) {
4241 TCGv t0 = tcg_temp_new();
4242 tcg_gen_ext32u_tl(t0, cpu_gpr[rB(ctx->opcode)]);
4243 gen_helper_tlbie(t0);
4244 tcg_temp_free(t0);
4245 } else
4246#endif
4247 gen_helper_tlbie(cpu_gpr[rB(ctx->opcode)]);
4248#endif
4249}
4250
4251/* tlbsync */
4252static void gen_tlbsync(DisasContext *ctx)
4253{
4254#if defined(CONFIG_USER_ONLY)
4255 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4256#else
4257 if (unlikely(!ctx->mem_idx)) {
4258 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4259 return;
4260 }
4261 /* This has no effect: it should ensure that all previous
4262 * tlbie have completed
4263 */
4264 gen_stop_exception(ctx);
4265#endif
4266}
4267
4268#if defined(TARGET_PPC64)
4269/* slbia */
4270static void gen_slbia(DisasContext *ctx)
4271{
4272#if defined(CONFIG_USER_ONLY)
4273 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4274#else
4275 if (unlikely(!ctx->mem_idx)) {
4276 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4277 return;
4278 }
4279 gen_helper_slbia();
4280#endif
4281}
4282
4283/* slbie */
4284static void gen_slbie(DisasContext *ctx)
4285{
4286#if defined(CONFIG_USER_ONLY)
4287 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4288#else
4289 if (unlikely(!ctx->mem_idx)) {
4290 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4291 return;
4292 }
4293 gen_helper_slbie(cpu_gpr[rB(ctx->opcode)]);
4294#endif
4295}
4296#endif
4297
4298/*** External control ***/
4299/* Optional: */
4300
4301/* eciwx */
4302static void gen_eciwx(DisasContext *ctx)
4303{
4304 TCGv t0;
4305 /* Should check EAR[E] ! */
4306 gen_set_access_type(ctx, ACCESS_EXT);
4307 t0 = tcg_temp_new();
4308 gen_addr_reg_index(ctx, t0);
4309 gen_check_align(ctx, t0, 0x03);
4310 gen_qemu_ld32u(ctx, cpu_gpr[rD(ctx->opcode)], t0);
4311 tcg_temp_free(t0);
4312}
4313
4314/* ecowx */
4315static void gen_ecowx(DisasContext *ctx)
4316{
4317 TCGv t0;
4318 /* Should check EAR[E] ! */
4319 gen_set_access_type(ctx, ACCESS_EXT);
4320 t0 = tcg_temp_new();
4321 gen_addr_reg_index(ctx, t0);
4322 gen_check_align(ctx, t0, 0x03);
4323 gen_qemu_st32(ctx, cpu_gpr[rD(ctx->opcode)], t0);
4324 tcg_temp_free(t0);
4325}
4326
4327/* PowerPC 601 specific instructions */
4328
4329/* abs - abs. */
4330static void gen_abs(DisasContext *ctx)
4331{
4332 int l1 = gen_new_label();
4333 int l2 = gen_new_label();
4334 tcg_gen_brcondi_tl(TCG_COND_GE, cpu_gpr[rA(ctx->opcode)], 0, l1);
4335 tcg_gen_neg_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4336 tcg_gen_br(l2);
4337 gen_set_label(l1);
4338 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4339 gen_set_label(l2);
4340 if (unlikely(Rc(ctx->opcode) != 0))
4341 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4342}
4343
4344/* abso - abso. */
4345static void gen_abso(DisasContext *ctx)
4346{
4347 int l1 = gen_new_label();
4348 int l2 = gen_new_label();
4349 int l3 = gen_new_label();
4350 /* Start with XER OV disabled, the most likely case */
4351 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
4352 tcg_gen_brcondi_tl(TCG_COND_GE, cpu_gpr[rA(ctx->opcode)], 0, l2);
4353 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_gpr[rA(ctx->opcode)], 0x80000000, l1);
4354 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
4355 tcg_gen_br(l2);
4356 gen_set_label(l1);
4357 tcg_gen_neg_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4358 tcg_gen_br(l3);
4359 gen_set_label(l2);
4360 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4361 gen_set_label(l3);
4362 if (unlikely(Rc(ctx->opcode) != 0))
4363 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4364}
4365
4366/* clcs */
4367static void gen_clcs(DisasContext *ctx)
4368{
4369 TCGv_i32 t0 = tcg_const_i32(rA(ctx->opcode));
4370 gen_helper_clcs(cpu_gpr[rD(ctx->opcode)], t0);
4371 tcg_temp_free_i32(t0);
4372 /* Rc=1 sets CR0 to an undefined state */
4373}
4374
4375/* div - div. */
4376static void gen_div(DisasContext *ctx)
4377{
4378 gen_helper_div(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
4379 if (unlikely(Rc(ctx->opcode) != 0))
4380 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4381}
4382
4383/* divo - divo. */
4384static void gen_divo(DisasContext *ctx)
4385{
4386 gen_helper_divo(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
4387 if (unlikely(Rc(ctx->opcode) != 0))
4388 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4389}
4390
4391/* divs - divs. */
4392static void gen_divs(DisasContext *ctx)
4393{
4394 gen_helper_divs(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
4395 if (unlikely(Rc(ctx->opcode) != 0))
4396 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4397}
4398
4399/* divso - divso. */
4400static void gen_divso(DisasContext *ctx)
4401{
4402 gen_helper_divso(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
4403 if (unlikely(Rc(ctx->opcode) != 0))
4404 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4405}
4406
4407/* doz - doz. */
4408static void gen_doz(DisasContext *ctx)
4409{
4410 int l1 = gen_new_label();
4411 int l2 = gen_new_label();
4412 tcg_gen_brcond_tl(TCG_COND_GE, cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], l1);
4413 tcg_gen_sub_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4414 tcg_gen_br(l2);
4415 gen_set_label(l1);
4416 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], 0);
4417 gen_set_label(l2);
4418 if (unlikely(Rc(ctx->opcode) != 0))
4419 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4420}
4421
4422/* dozo - dozo. */
4423static void gen_dozo(DisasContext *ctx)
4424{
4425 int l1 = gen_new_label();
4426 int l2 = gen_new_label();
4427 TCGv t0 = tcg_temp_new();
4428 TCGv t1 = tcg_temp_new();
4429 TCGv t2 = tcg_temp_new();
4430 /* Start with XER OV disabled, the most likely case */
4431 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
4432 tcg_gen_brcond_tl(TCG_COND_GE, cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], l1);
4433 tcg_gen_sub_tl(t0, cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4434 tcg_gen_xor_tl(t1, cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4435 tcg_gen_xor_tl(t2, cpu_gpr[rA(ctx->opcode)], t0);
4436 tcg_gen_andc_tl(t1, t1, t2);
4437 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], t0);
4438 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l2);
4439 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
4440 tcg_gen_br(l2);
4441 gen_set_label(l1);
4442 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], 0);
4443 gen_set_label(l2);
4444 tcg_temp_free(t0);
4445 tcg_temp_free(t1);
4446 tcg_temp_free(t2);
4447 if (unlikely(Rc(ctx->opcode) != 0))
4448 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4449}
4450
4451/* dozi */
4452static void gen_dozi(DisasContext *ctx)
4453{
4454 target_long simm = SIMM(ctx->opcode);
4455 int l1 = gen_new_label();
4456 int l2 = gen_new_label();
4457 tcg_gen_brcondi_tl(TCG_COND_LT, cpu_gpr[rA(ctx->opcode)], simm, l1);
4458 tcg_gen_subfi_tl(cpu_gpr[rD(ctx->opcode)], simm, cpu_gpr[rA(ctx->opcode)]);
4459 tcg_gen_br(l2);
4460 gen_set_label(l1);
4461 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], 0);
4462 gen_set_label(l2);
4463 if (unlikely(Rc(ctx->opcode) != 0))
4464 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4465}
4466
4467/* lscbx - lscbx. */
4468static void gen_lscbx(DisasContext *ctx)
4469{
4470 TCGv t0 = tcg_temp_new();
4471 TCGv_i32 t1 = tcg_const_i32(rD(ctx->opcode));
4472 TCGv_i32 t2 = tcg_const_i32(rA(ctx->opcode));
4473 TCGv_i32 t3 = tcg_const_i32(rB(ctx->opcode));
4474
4475 gen_addr_reg_index(ctx, t0);
4476 /* NIP cannot be restored if the memory exception comes from an helper */
4477 gen_update_nip(ctx, ctx->nip - 4);
4478 gen_helper_lscbx(t0, t0, t1, t2, t3);
4479 tcg_temp_free_i32(t1);
4480 tcg_temp_free_i32(t2);
4481 tcg_temp_free_i32(t3);
4482 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~0x7F);
4483 tcg_gen_or_tl(cpu_xer, cpu_xer, t0);
4484 if (unlikely(Rc(ctx->opcode) != 0))
4485 gen_set_Rc0(ctx, t0);
4486 tcg_temp_free(t0);
4487}
4488
4489/* maskg - maskg. */
4490static void gen_maskg(DisasContext *ctx)
4491{
4492 int l1 = gen_new_label();
4493 TCGv t0 = tcg_temp_new();
4494 TCGv t1 = tcg_temp_new();
4495 TCGv t2 = tcg_temp_new();
4496 TCGv t3 = tcg_temp_new();
4497 tcg_gen_movi_tl(t3, 0xFFFFFFFF);
4498 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F);
4499 tcg_gen_andi_tl(t1, cpu_gpr[rS(ctx->opcode)], 0x1F);
4500 tcg_gen_addi_tl(t2, t0, 1);
4501 tcg_gen_shr_tl(t2, t3, t2);
4502 tcg_gen_shr_tl(t3, t3, t1);
4503 tcg_gen_xor_tl(cpu_gpr[rA(ctx->opcode)], t2, t3);
4504 tcg_gen_brcond_tl(TCG_COND_GE, t0, t1, l1);
4505 tcg_gen_neg_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4506 gen_set_label(l1);
4507 tcg_temp_free(t0);
4508 tcg_temp_free(t1);
4509 tcg_temp_free(t2);
4510 tcg_temp_free(t3);
4511 if (unlikely(Rc(ctx->opcode) != 0))
4512 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4513}
4514
4515/* maskir - maskir. */
4516static void gen_maskir(DisasContext *ctx)
4517{
4518 TCGv t0 = tcg_temp_new();
4519 TCGv t1 = tcg_temp_new();
4520 tcg_gen_and_tl(t0, cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
4521 tcg_gen_andc_tl(t1, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
4522 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4523 tcg_temp_free(t0);
4524 tcg_temp_free(t1);
4525 if (unlikely(Rc(ctx->opcode) != 0))
4526 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4527}
4528
4529/* mul - mul. */
4530static void gen_mul(DisasContext *ctx)
4531{
4532 TCGv_i64 t0 = tcg_temp_new_i64();
4533 TCGv_i64 t1 = tcg_temp_new_i64();
4534 TCGv t2 = tcg_temp_new();
4535 tcg_gen_extu_tl_i64(t0, cpu_gpr[rA(ctx->opcode)]);
4536 tcg_gen_extu_tl_i64(t1, cpu_gpr[rB(ctx->opcode)]);
4537 tcg_gen_mul_i64(t0, t0, t1);
4538 tcg_gen_trunc_i64_tl(t2, t0);
4539 gen_store_spr(SPR_MQ, t2);
4540 tcg_gen_shri_i64(t1, t0, 32);
4541 tcg_gen_trunc_i64_tl(cpu_gpr[rD(ctx->opcode)], t1);
4542 tcg_temp_free_i64(t0);
4543 tcg_temp_free_i64(t1);
4544 tcg_temp_free(t2);
4545 if (unlikely(Rc(ctx->opcode) != 0))
4546 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4547}
4548
4549/* mulo - mulo. */
4550static void gen_mulo(DisasContext *ctx)
4551{
4552 int l1 = gen_new_label();
4553 TCGv_i64 t0 = tcg_temp_new_i64();
4554 TCGv_i64 t1 = tcg_temp_new_i64();
4555 TCGv t2 = tcg_temp_new();
4556 /* Start with XER OV disabled, the most likely case */
4557 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
4558 tcg_gen_extu_tl_i64(t0, cpu_gpr[rA(ctx->opcode)]);
4559 tcg_gen_extu_tl_i64(t1, cpu_gpr[rB(ctx->opcode)]);
4560 tcg_gen_mul_i64(t0, t0, t1);
4561 tcg_gen_trunc_i64_tl(t2, t0);
4562 gen_store_spr(SPR_MQ, t2);
4563 tcg_gen_shri_i64(t1, t0, 32);
4564 tcg_gen_trunc_i64_tl(cpu_gpr[rD(ctx->opcode)], t1);
4565 tcg_gen_ext32s_i64(t1, t0);
4566 tcg_gen_brcond_i64(TCG_COND_EQ, t0, t1, l1);
4567 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
4568 gen_set_label(l1);
4569 tcg_temp_free_i64(t0);
4570 tcg_temp_free_i64(t1);
4571 tcg_temp_free(t2);
4572 if (unlikely(Rc(ctx->opcode) != 0))
4573 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4574}
4575
4576/* nabs - nabs. */
4577static void gen_nabs(DisasContext *ctx)
4578{
4579 int l1 = gen_new_label();
4580 int l2 = gen_new_label();
4581 tcg_gen_brcondi_tl(TCG_COND_GT, cpu_gpr[rA(ctx->opcode)], 0, l1);
4582 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4583 tcg_gen_br(l2);
4584 gen_set_label(l1);
4585 tcg_gen_neg_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4586 gen_set_label(l2);
4587 if (unlikely(Rc(ctx->opcode) != 0))
4588 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4589}
4590
4591/* nabso - nabso. */
4592static void gen_nabso(DisasContext *ctx)
4593{
4594 int l1 = gen_new_label();
4595 int l2 = gen_new_label();
4596 tcg_gen_brcondi_tl(TCG_COND_GT, cpu_gpr[rA(ctx->opcode)], 0, l1);
4597 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4598 tcg_gen_br(l2);
4599 gen_set_label(l1);
4600 tcg_gen_neg_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4601 gen_set_label(l2);
4602 /* nabs never overflows */
4603 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
4604 if (unlikely(Rc(ctx->opcode) != 0))
4605 gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
4606}
4607
4608/* rlmi - rlmi. */
4609static void gen_rlmi(DisasContext *ctx)
4610{
4611 uint32_t mb = MB(ctx->opcode);
4612 uint32_t me = ME(ctx->opcode);
4613 TCGv t0 = tcg_temp_new();
4614 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F);
4615 tcg_gen_rotl_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
4616 tcg_gen_andi_tl(t0, t0, MASK(mb, me));
4617 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], ~MASK(mb, me));
4618 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], t0);
4619 tcg_temp_free(t0);
4620 if (unlikely(Rc(ctx->opcode) != 0))
4621 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4622}
4623
4624/* rrib - rrib. */
4625static void gen_rrib(DisasContext *ctx)
4626{
4627 TCGv t0 = tcg_temp_new();
4628 TCGv t1 = tcg_temp_new();
4629 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F);
4630 tcg_gen_movi_tl(t1, 0x80000000);
4631 tcg_gen_shr_tl(t1, t1, t0);
4632 tcg_gen_shr_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
4633 tcg_gen_and_tl(t0, t0, t1);
4634 tcg_gen_andc_tl(t1, cpu_gpr[rA(ctx->opcode)], t1);
4635 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4636 tcg_temp_free(t0);
4637 tcg_temp_free(t1);
4638 if (unlikely(Rc(ctx->opcode) != 0))
4639 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4640}
4641
4642/* sle - sle. */
4643static void gen_sle(DisasContext *ctx)
4644{
4645 TCGv t0 = tcg_temp_new();
4646 TCGv t1 = tcg_temp_new();
4647 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1F);
4648 tcg_gen_shl_tl(t0, cpu_gpr[rS(ctx->opcode)], t1);
4649 tcg_gen_subfi_tl(t1, 32, t1);
4650 tcg_gen_shr_tl(t1, cpu_gpr[rS(ctx->opcode)], t1);
4651 tcg_gen_or_tl(t1, t0, t1);
4652 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
4653 gen_store_spr(SPR_MQ, t1);
4654 tcg_temp_free(t0);
4655 tcg_temp_free(t1);
4656 if (unlikely(Rc(ctx->opcode) != 0))
4657 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4658}
4659
4660/* sleq - sleq. */
4661static void gen_sleq(DisasContext *ctx)
4662{
4663 TCGv t0 = tcg_temp_new();
4664 TCGv t1 = tcg_temp_new();
4665 TCGv t2 = tcg_temp_new();
4666 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F);
4667 tcg_gen_movi_tl(t2, 0xFFFFFFFF);
4668 tcg_gen_shl_tl(t2, t2, t0);
4669 tcg_gen_rotl_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
4670 gen_load_spr(t1, SPR_MQ);
4671 gen_store_spr(SPR_MQ, t0);
4672 tcg_gen_and_tl(t0, t0, t2);
4673 tcg_gen_andc_tl(t1, t1, t2);
4674 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4675 tcg_temp_free(t0);
4676 tcg_temp_free(t1);
4677 tcg_temp_free(t2);
4678 if (unlikely(Rc(ctx->opcode) != 0))
4679 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4680}
4681
4682/* sliq - sliq. */
4683static void gen_sliq(DisasContext *ctx)
4684{
4685 int sh = SH(ctx->opcode);
4686 TCGv t0 = tcg_temp_new();
4687 TCGv t1 = tcg_temp_new();
4688 tcg_gen_shli_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
4689 tcg_gen_shri_tl(t1, cpu_gpr[rS(ctx->opcode)], 32 - sh);
4690 tcg_gen_or_tl(t1, t0, t1);
4691 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
4692 gen_store_spr(SPR_MQ, t1);
4693 tcg_temp_free(t0);
4694 tcg_temp_free(t1);
4695 if (unlikely(Rc(ctx->opcode) != 0))
4696 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4697}
4698
4699/* slliq - slliq. */
4700static void gen_slliq(DisasContext *ctx)
4701{
4702 int sh = SH(ctx->opcode);
4703 TCGv t0 = tcg_temp_new();
4704 TCGv t1 = tcg_temp_new();
4705 tcg_gen_rotli_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
4706 gen_load_spr(t1, SPR_MQ);
4707 gen_store_spr(SPR_MQ, t0);
4708 tcg_gen_andi_tl(t0, t0, (0xFFFFFFFFU << sh));
4709 tcg_gen_andi_tl(t1, t1, ~(0xFFFFFFFFU << sh));
4710 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4711 tcg_temp_free(t0);
4712 tcg_temp_free(t1);
4713 if (unlikely(Rc(ctx->opcode) != 0))
4714 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4715}
4716
4717/* sllq - sllq. */
4718static void gen_sllq(DisasContext *ctx)
4719{
4720 int l1 = gen_new_label();
4721 int l2 = gen_new_label();
4722 TCGv t0 = tcg_temp_local_new();
4723 TCGv t1 = tcg_temp_local_new();
4724 TCGv t2 = tcg_temp_local_new();
4725 tcg_gen_andi_tl(t2, cpu_gpr[rB(ctx->opcode)], 0x1F);
4726 tcg_gen_movi_tl(t1, 0xFFFFFFFF);
4727 tcg_gen_shl_tl(t1, t1, t2);
4728 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x20);
4729 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
4730 gen_load_spr(t0, SPR_MQ);
4731 tcg_gen_and_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4732 tcg_gen_br(l2);
4733 gen_set_label(l1);
4734 tcg_gen_shl_tl(t0, cpu_gpr[rS(ctx->opcode)], t2);
4735 gen_load_spr(t2, SPR_MQ);
4736 tcg_gen_andc_tl(t1, t2, t1);
4737 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4738 gen_set_label(l2);
4739 tcg_temp_free(t0);
4740 tcg_temp_free(t1);
4741 tcg_temp_free(t2);
4742 if (unlikely(Rc(ctx->opcode) != 0))
4743 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4744}
4745
4746/* slq - slq. */
4747static void gen_slq(DisasContext *ctx)
4748{
4749 int l1 = gen_new_label();
4750 TCGv t0 = tcg_temp_new();
4751 TCGv t1 = tcg_temp_new();
4752 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1F);
4753 tcg_gen_shl_tl(t0, cpu_gpr[rS(ctx->opcode)], t1);
4754 tcg_gen_subfi_tl(t1, 32, t1);
4755 tcg_gen_shr_tl(t1, cpu_gpr[rS(ctx->opcode)], t1);
4756 tcg_gen_or_tl(t1, t0, t1);
4757 gen_store_spr(SPR_MQ, t1);
4758 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x20);
4759 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
4760 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
4761 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
4762 gen_set_label(l1);
4763 tcg_temp_free(t0);
4764 tcg_temp_free(t1);
4765 if (unlikely(Rc(ctx->opcode) != 0))
4766 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4767}
4768
4769/* sraiq - sraiq. */
4770static void gen_sraiq(DisasContext *ctx)
4771{
4772 int sh = SH(ctx->opcode);
4773 int l1 = gen_new_label();
4774 TCGv t0 = tcg_temp_new();
4775 TCGv t1 = tcg_temp_new();
4776 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
4777 tcg_gen_shli_tl(t1, cpu_gpr[rS(ctx->opcode)], 32 - sh);
4778 tcg_gen_or_tl(t0, t0, t1);
4779 gen_store_spr(SPR_MQ, t0);
4780 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
4781 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
4782 tcg_gen_brcondi_tl(TCG_COND_GE, cpu_gpr[rS(ctx->opcode)], 0, l1);
4783 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_CA));
4784 gen_set_label(l1);
4785 tcg_gen_sari_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], sh);
4786 tcg_temp_free(t0);
4787 tcg_temp_free(t1);
4788 if (unlikely(Rc(ctx->opcode) != 0))
4789 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4790}
4791
4792/* sraq - sraq. */
4793static void gen_sraq(DisasContext *ctx)
4794{
4795 int l1 = gen_new_label();
4796 int l2 = gen_new_label();
4797 TCGv t0 = tcg_temp_new();
4798 TCGv t1 = tcg_temp_local_new();
4799 TCGv t2 = tcg_temp_local_new();
4800 tcg_gen_andi_tl(t2, cpu_gpr[rB(ctx->opcode)], 0x1F);
4801 tcg_gen_shr_tl(t0, cpu_gpr[rS(ctx->opcode)], t2);
4802 tcg_gen_sar_tl(t1, cpu_gpr[rS(ctx->opcode)], t2);
4803 tcg_gen_subfi_tl(t2, 32, t2);
4804 tcg_gen_shl_tl(t2, cpu_gpr[rS(ctx->opcode)], t2);
4805 tcg_gen_or_tl(t0, t0, t2);
4806 gen_store_spr(SPR_MQ, t0);
4807 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x20);
4808 tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, l1);
4809 tcg_gen_mov_tl(t2, cpu_gpr[rS(ctx->opcode)]);
4810 tcg_gen_sari_tl(t1, cpu_gpr[rS(ctx->opcode)], 31);
4811 gen_set_label(l1);
4812 tcg_temp_free(t0);
4813 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t1);
4814 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));
4815 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l2);
4816 tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, l2);
4817 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_CA));
4818 gen_set_label(l2);
4819 tcg_temp_free(t1);
4820 tcg_temp_free(t2);
4821 if (unlikely(Rc(ctx->opcode) != 0))
4822 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4823}
4824
4825/* sre - sre. */
4826static void gen_sre(DisasContext *ctx)
4827{
4828 TCGv t0 = tcg_temp_new();
4829 TCGv t1 = tcg_temp_new();
4830 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1F);
4831 tcg_gen_shr_tl(t0, cpu_gpr[rS(ctx->opcode)], t1);
4832 tcg_gen_subfi_tl(t1, 32, t1);
4833 tcg_gen_shl_tl(t1, cpu_gpr[rS(ctx->opcode)], t1);
4834 tcg_gen_or_tl(t1, t0, t1);
4835 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
4836 gen_store_spr(SPR_MQ, t1);
4837 tcg_temp_free(t0);
4838 tcg_temp_free(t1);
4839 if (unlikely(Rc(ctx->opcode) != 0))
4840 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4841}
4842
4843/* srea - srea. */
4844static void gen_srea(DisasContext *ctx)
4845{
4846 TCGv t0 = tcg_temp_new();
4847 TCGv t1 = tcg_temp_new();
4848 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1F);
4849 tcg_gen_rotr_tl(t0, cpu_gpr[rS(ctx->opcode)], t1);
4850 gen_store_spr(SPR_MQ, t0);
4851 tcg_gen_sar_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t1);
4852 tcg_temp_free(t0);
4853 tcg_temp_free(t1);
4854 if (unlikely(Rc(ctx->opcode) != 0))
4855 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4856}
4857
4858/* sreq */
4859static void gen_sreq(DisasContext *ctx)
4860{
4861 TCGv t0 = tcg_temp_new();
4862 TCGv t1 = tcg_temp_new();
4863 TCGv t2 = tcg_temp_new();
4864 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F);
4865 tcg_gen_movi_tl(t1, 0xFFFFFFFF);
4866 tcg_gen_shr_tl(t1, t1, t0);
4867 tcg_gen_rotr_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
4868 gen_load_spr(t2, SPR_MQ);
4869 gen_store_spr(SPR_MQ, t0);
4870 tcg_gen_and_tl(t0, t0, t1);
4871 tcg_gen_andc_tl(t2, t2, t1);
4872 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t2);
4873 tcg_temp_free(t0);
4874 tcg_temp_free(t1);
4875 tcg_temp_free(t2);
4876 if (unlikely(Rc(ctx->opcode) != 0))
4877 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4878}
4879
4880/* sriq */
4881static void gen_sriq(DisasContext *ctx)
4882{
4883 int sh = SH(ctx->opcode);
4884 TCGv t0 = tcg_temp_new();
4885 TCGv t1 = tcg_temp_new();
4886 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
4887 tcg_gen_shli_tl(t1, cpu_gpr[rS(ctx->opcode)], 32 - sh);
4888 tcg_gen_or_tl(t1, t0, t1);
4889 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
4890 gen_store_spr(SPR_MQ, t1);
4891 tcg_temp_free(t0);
4892 tcg_temp_free(t1);
4893 if (unlikely(Rc(ctx->opcode) != 0))
4894 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4895}
4896
4897/* srliq */
4898static void gen_srliq(DisasContext *ctx)
4899{
4900 int sh = SH(ctx->opcode);
4901 TCGv t0 = tcg_temp_new();
4902 TCGv t1 = tcg_temp_new();
4903 tcg_gen_rotri_tl(t0, cpu_gpr[rS(ctx->opcode)], sh);
4904 gen_load_spr(t1, SPR_MQ);
4905 gen_store_spr(SPR_MQ, t0);
4906 tcg_gen_andi_tl(t0, t0, (0xFFFFFFFFU >> sh));
4907 tcg_gen_andi_tl(t1, t1, ~(0xFFFFFFFFU >> sh));
4908 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4909 tcg_temp_free(t0);
4910 tcg_temp_free(t1);
4911 if (unlikely(Rc(ctx->opcode) != 0))
4912 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4913}
4914
4915/* srlq */
4916static void gen_srlq(DisasContext *ctx)
4917{
4918 int l1 = gen_new_label();
4919 int l2 = gen_new_label();
4920 TCGv t0 = tcg_temp_local_new();
4921 TCGv t1 = tcg_temp_local_new();
4922 TCGv t2 = tcg_temp_local_new();
4923 tcg_gen_andi_tl(t2, cpu_gpr[rB(ctx->opcode)], 0x1F);
4924 tcg_gen_movi_tl(t1, 0xFFFFFFFF);
4925 tcg_gen_shr_tl(t2, t1, t2);
4926 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x20);
4927 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
4928 gen_load_spr(t0, SPR_MQ);
4929 tcg_gen_and_tl(cpu_gpr[rA(ctx->opcode)], t0, t2);
4930 tcg_gen_br(l2);
4931 gen_set_label(l1);
4932 tcg_gen_shr_tl(t0, cpu_gpr[rS(ctx->opcode)], t2);
4933 tcg_gen_and_tl(t0, t0, t2);
4934 gen_load_spr(t1, SPR_MQ);
4935 tcg_gen_andc_tl(t1, t1, t2);
4936 tcg_gen_or_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
4937 gen_set_label(l2);
4938 tcg_temp_free(t0);
4939 tcg_temp_free(t1);
4940 tcg_temp_free(t2);
4941 if (unlikely(Rc(ctx->opcode) != 0))
4942 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4943}
4944
4945/* srq */
4946static void gen_srq(DisasContext *ctx)
4947{
4948 int l1 = gen_new_label();
4949 TCGv t0 = tcg_temp_new();
4950 TCGv t1 = tcg_temp_new();
4951 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1F);
4952 tcg_gen_shr_tl(t0, cpu_gpr[rS(ctx->opcode)], t1);
4953 tcg_gen_subfi_tl(t1, 32, t1);
4954 tcg_gen_shl_tl(t1, cpu_gpr[rS(ctx->opcode)], t1);
4955 tcg_gen_or_tl(t1, t0, t1);
4956 gen_store_spr(SPR_MQ, t1);
4957 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x20);
4958 tcg_gen_mov_tl(cpu_gpr[rA(ctx->opcode)], t0);
4959 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
4960 tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
4961 gen_set_label(l1);
4962 tcg_temp_free(t0);
4963 tcg_temp_free(t1);
4964 if (unlikely(Rc(ctx->opcode) != 0))
4965 gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
4966}
4967
4968/* PowerPC 602 specific instructions */
4969
4970/* dsa */
4971static void gen_dsa(DisasContext *ctx)
4972{
4973 /* XXX: TODO */
4974 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
4975}
4976
4977/* esa */
4978static void gen_esa(DisasContext *ctx)
4979{
4980 /* XXX: TODO */
4981 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
4982}
4983
4984/* mfrom */
4985static void gen_mfrom(DisasContext *ctx)
4986{
4987#if defined(CONFIG_USER_ONLY)
4988 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4989#else
4990 if (unlikely(!ctx->mem_idx)) {
4991 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
4992 return;
4993 }
4994 gen_helper_602_mfrom(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
4995#endif
4996}
4997
4998/* 602 - 603 - G2 TLB management */
4999
5000/* tlbld */
5001static void gen_tlbld_6xx(DisasContext *ctx)
5002{
5003#if defined(CONFIG_USER_ONLY)
5004 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5005#else
5006 if (unlikely(!ctx->mem_idx)) {
5007 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5008 return;
5009 }
5010 gen_helper_6xx_tlbd(cpu_gpr[rB(ctx->opcode)]);
5011#endif
5012}
5013
5014/* tlbli */
5015static void gen_tlbli_6xx(DisasContext *ctx)
5016{
5017#if defined(CONFIG_USER_ONLY)
5018 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5019#else
5020 if (unlikely(!ctx->mem_idx)) {
5021 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5022 return;
5023 }
5024 gen_helper_6xx_tlbi(cpu_gpr[rB(ctx->opcode)]);
5025#endif
5026}
5027
5028/* 74xx TLB management */
5029
5030/* tlbld */
5031static void gen_tlbld_74xx(DisasContext *ctx)
5032{
5033#if defined(CONFIG_USER_ONLY)
5034 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5035#else
5036 if (unlikely(!ctx->mem_idx)) {
5037 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5038 return;
5039 }
5040 gen_helper_74xx_tlbd(cpu_gpr[rB(ctx->opcode)]);
5041#endif
5042}
5043
5044/* tlbli */
5045static void gen_tlbli_74xx(DisasContext *ctx)
5046{
5047#if defined(CONFIG_USER_ONLY)
5048 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5049#else
5050 if (unlikely(!ctx->mem_idx)) {
5051 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5052 return;
5053 }
5054 gen_helper_74xx_tlbi(cpu_gpr[rB(ctx->opcode)]);
5055#endif
5056}
5057
5058/* POWER instructions not in PowerPC 601 */
5059
5060/* clf */
5061static void gen_clf(DisasContext *ctx)
5062{
5063 /* Cache line flush: implemented as no-op */
5064}
5065
5066/* cli */
5067static void gen_cli(DisasContext *ctx)
5068{
5069 /* Cache line invalidate: privileged and treated as no-op */
5070#if defined(CONFIG_USER_ONLY)
5071 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5072#else
5073 if (unlikely(!ctx->mem_idx)) {
5074 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5075 return;
5076 }
5077#endif
5078}
5079
5080/* dclst */
5081static void gen_dclst(DisasContext *ctx)
5082{
5083 /* Data cache line store: treated as no-op */
5084}
5085
5086static void gen_mfsri(DisasContext *ctx)
5087{
5088#if defined(CONFIG_USER_ONLY)
5089 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5090#else
5091 int ra = rA(ctx->opcode);
5092 int rd = rD(ctx->opcode);
5093 TCGv t0;
5094 if (unlikely(!ctx->mem_idx)) {
5095 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5096 return;
5097 }
5098 t0 = tcg_temp_new();
5099 gen_addr_reg_index(ctx, t0);
5100 tcg_gen_shri_tl(t0, t0, 28);
5101 tcg_gen_andi_tl(t0, t0, 0xF);
5102 gen_helper_load_sr(cpu_gpr[rd], t0);
5103 tcg_temp_free(t0);
5104 if (ra != 0 && ra != rd)
5105 tcg_gen_mov_tl(cpu_gpr[ra], cpu_gpr[rd]);
5106#endif
5107}
5108
5109static void gen_rac(DisasContext *ctx)
5110{
5111#if defined(CONFIG_USER_ONLY)
5112 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5113#else
5114 TCGv t0;
5115 if (unlikely(!ctx->mem_idx)) {
5116 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5117 return;
5118 }
5119 t0 = tcg_temp_new();
5120 gen_addr_reg_index(ctx, t0);
5121 gen_helper_rac(cpu_gpr[rD(ctx->opcode)], t0);
5122 tcg_temp_free(t0);
5123#endif
5124}
5125
5126static void gen_rfsvc(DisasContext *ctx)
5127{
5128#if defined(CONFIG_USER_ONLY)
5129 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5130#else
5131 if (unlikely(!ctx->mem_idx)) {
5132 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5133 return;
5134 }
5135 gen_helper_rfsvc();
5136 gen_sync_exception(ctx);
5137#endif
5138}
5139
5140/* svc is not implemented for now */
5141
5142/* POWER2 specific instructions */
5143/* Quad manipulation (load/store two floats at a time) */
5144
5145/* lfq */
5146static void gen_lfq(DisasContext *ctx)
5147{
5148 int rd = rD(ctx->opcode);
5149 TCGv t0;
5150 gen_set_access_type(ctx, ACCESS_FLOAT);
5151 t0 = tcg_temp_new();
5152 gen_addr_imm_index(ctx, t0, 0);
5153 gen_qemu_ld64(ctx, cpu_fpr[rd], t0);
5154 gen_addr_add(ctx, t0, t0, 8);
5155 gen_qemu_ld64(ctx, cpu_fpr[(rd + 1) % 32], t0);
5156 tcg_temp_free(t0);
5157}
5158
5159/* lfqu */
5160static void gen_lfqu(DisasContext *ctx)
5161{
5162 int ra = rA(ctx->opcode);
5163 int rd = rD(ctx->opcode);
5164 TCGv t0, t1;
5165 gen_set_access_type(ctx, ACCESS_FLOAT);
5166 t0 = tcg_temp_new();
5167 t1 = tcg_temp_new();
5168 gen_addr_imm_index(ctx, t0, 0);
5169 gen_qemu_ld64(ctx, cpu_fpr[rd], t0);
5170 gen_addr_add(ctx, t1, t0, 8);
5171 gen_qemu_ld64(ctx, cpu_fpr[(rd + 1) % 32], t1);
5172 if (ra != 0)
5173 tcg_gen_mov_tl(cpu_gpr[ra], t0);
5174 tcg_temp_free(t0);
5175 tcg_temp_free(t1);
5176}
5177
5178/* lfqux */
5179static void gen_lfqux(DisasContext *ctx)
5180{
5181 int ra = rA(ctx->opcode);
5182 int rd = rD(ctx->opcode);
5183 gen_set_access_type(ctx, ACCESS_FLOAT);
5184 TCGv t0, t1;
5185 t0 = tcg_temp_new();
5186 gen_addr_reg_index(ctx, t0);
5187 gen_qemu_ld64(ctx, cpu_fpr[rd], t0);
5188 t1 = tcg_temp_new();
5189 gen_addr_add(ctx, t1, t0, 8);
5190 gen_qemu_ld64(ctx, cpu_fpr[(rd + 1) % 32], t1);
5191 tcg_temp_free(t1);
5192 if (ra != 0)
5193 tcg_gen_mov_tl(cpu_gpr[ra], t0);
5194 tcg_temp_free(t0);
5195}
5196
5197/* lfqx */
5198static void gen_lfqx(DisasContext *ctx)
5199{
5200 int rd = rD(ctx->opcode);
5201 TCGv t0;
5202 gen_set_access_type(ctx, ACCESS_FLOAT);
5203 t0 = tcg_temp_new();
5204 gen_addr_reg_index(ctx, t0);
5205 gen_qemu_ld64(ctx, cpu_fpr[rd], t0);
5206 gen_addr_add(ctx, t0, t0, 8);
5207 gen_qemu_ld64(ctx, cpu_fpr[(rd + 1) % 32], t0);
5208 tcg_temp_free(t0);
5209}
5210
5211/* stfq */
5212static void gen_stfq(DisasContext *ctx)
5213{
5214 int rd = rD(ctx->opcode);
5215 TCGv t0;
5216 gen_set_access_type(ctx, ACCESS_FLOAT);
5217 t0 = tcg_temp_new();
5218 gen_addr_imm_index(ctx, t0, 0);
5219 gen_qemu_st64(ctx, cpu_fpr[rd], t0);
5220 gen_addr_add(ctx, t0, t0, 8);
5221 gen_qemu_st64(ctx, cpu_fpr[(rd + 1) % 32], t0);
5222 tcg_temp_free(t0);
5223}
5224
5225/* stfqu */
5226static void gen_stfqu(DisasContext *ctx)
5227{
5228 int ra = rA(ctx->opcode);
5229 int rd = rD(ctx->opcode);
5230 TCGv t0, t1;
5231 gen_set_access_type(ctx, ACCESS_FLOAT);
5232 t0 = tcg_temp_new();
5233 gen_addr_imm_index(ctx, t0, 0);
5234 gen_qemu_st64(ctx, cpu_fpr[rd], t0);
5235 t1 = tcg_temp_new();
5236 gen_addr_add(ctx, t1, t0, 8);
5237 gen_qemu_st64(ctx, cpu_fpr[(rd + 1) % 32], t1);
5238 tcg_temp_free(t1);
5239 if (ra != 0)
5240 tcg_gen_mov_tl(cpu_gpr[ra], t0);
5241 tcg_temp_free(t0);
5242}
5243
5244/* stfqux */
5245static void gen_stfqux(DisasContext *ctx)
5246{
5247 int ra = rA(ctx->opcode);
5248 int rd = rD(ctx->opcode);
5249 TCGv t0, t1;
5250 gen_set_access_type(ctx, ACCESS_FLOAT);
5251 t0 = tcg_temp_new();
5252 gen_addr_reg_index(ctx, t0);
5253 gen_qemu_st64(ctx, cpu_fpr[rd], t0);
5254 t1 = tcg_temp_new();
5255 gen_addr_add(ctx, t1, t0, 8);
5256 gen_qemu_st64(ctx, cpu_fpr[(rd + 1) % 32], t1);
5257 tcg_temp_free(t1);
5258 if (ra != 0)
5259 tcg_gen_mov_tl(cpu_gpr[ra], t0);
5260 tcg_temp_free(t0);
5261}
5262
5263/* stfqx */
5264static void gen_stfqx(DisasContext *ctx)
5265{
5266 int rd = rD(ctx->opcode);
5267 TCGv t0;
5268 gen_set_access_type(ctx, ACCESS_FLOAT);
5269 t0 = tcg_temp_new();
5270 gen_addr_reg_index(ctx, t0);
5271 gen_qemu_st64(ctx, cpu_fpr[rd], t0);
5272 gen_addr_add(ctx, t0, t0, 8);
5273 gen_qemu_st64(ctx, cpu_fpr[(rd + 1) % 32], t0);
5274 tcg_temp_free(t0);
5275}
5276
5277/* BookE specific instructions */
5278
5279/* XXX: not implemented on 440 ? */
5280static void gen_mfapidi(DisasContext *ctx)
5281{
5282 /* XXX: TODO */
5283 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5284}
5285
5286/* XXX: not implemented on 440 ? */
5287static void gen_tlbiva(DisasContext *ctx)
5288{
5289#if defined(CONFIG_USER_ONLY)
5290 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5291#else
5292 TCGv t0;
5293 if (unlikely(!ctx->mem_idx)) {
5294 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5295 return;
5296 }
5297 t0 = tcg_temp_new();
5298 gen_addr_reg_index(ctx, t0);
5299 gen_helper_tlbie(cpu_gpr[rB(ctx->opcode)]);
5300 tcg_temp_free(t0);
5301#endif
5302}
5303
5304/* All 405 MAC instructions are translated here */
5305static always_inline void gen_405_mulladd_insn (DisasContext *ctx,
5306 int opc2, int opc3,
5307 int ra, int rb, int rt, int Rc)
5308{
5309 TCGv t0, t1;
5310
5311 t0 = tcg_temp_local_new();
5312 t1 = tcg_temp_local_new();
5313
5314 switch (opc3 & 0x0D) {
5315 case 0x05:
5316 /* macchw - macchw. - macchwo - macchwo. */
5317 /* macchws - macchws. - macchwso - macchwso. */
5318 /* nmacchw - nmacchw. - nmacchwo - nmacchwo. */
5319 /* nmacchws - nmacchws. - nmacchwso - nmacchwso. */
5320 /* mulchw - mulchw. */
5321 tcg_gen_ext16s_tl(t0, cpu_gpr[ra]);
5322 tcg_gen_sari_tl(t1, cpu_gpr[rb], 16);
5323 tcg_gen_ext16s_tl(t1, t1);
5324 break;
5325 case 0x04:
5326 /* macchwu - macchwu. - macchwuo - macchwuo. */
5327 /* macchwsu - macchwsu. - macchwsuo - macchwsuo. */
5328 /* mulchwu - mulchwu. */
5329 tcg_gen_ext16u_tl(t0, cpu_gpr[ra]);
5330 tcg_gen_shri_tl(t1, cpu_gpr[rb], 16);
5331 tcg_gen_ext16u_tl(t1, t1);
5332 break;
5333 case 0x01:
5334 /* machhw - machhw. - machhwo - machhwo. */
5335 /* machhws - machhws. - machhwso - machhwso. */
5336 /* nmachhw - nmachhw. - nmachhwo - nmachhwo. */
5337 /* nmachhws - nmachhws. - nmachhwso - nmachhwso. */
5338 /* mulhhw - mulhhw. */
5339 tcg_gen_sari_tl(t0, cpu_gpr[ra], 16);
5340 tcg_gen_ext16s_tl(t0, t0);
5341 tcg_gen_sari_tl(t1, cpu_gpr[rb], 16);
5342 tcg_gen_ext16s_tl(t1, t1);
5343 break;
5344 case 0x00:
5345 /* machhwu - machhwu. - machhwuo - machhwuo. */
5346 /* machhwsu - machhwsu. - machhwsuo - machhwsuo. */
5347 /* mulhhwu - mulhhwu. */
5348 tcg_gen_shri_tl(t0, cpu_gpr[ra], 16);
5349 tcg_gen_ext16u_tl(t0, t0);
5350 tcg_gen_shri_tl(t1, cpu_gpr[rb], 16);
5351 tcg_gen_ext16u_tl(t1, t1);
5352 break;
5353 case 0x0D:
5354 /* maclhw - maclhw. - maclhwo - maclhwo. */
5355 /* maclhws - maclhws. - maclhwso - maclhwso. */
5356 /* nmaclhw - nmaclhw. - nmaclhwo - nmaclhwo. */
5357 /* nmaclhws - nmaclhws. - nmaclhwso - nmaclhwso. */
5358 /* mullhw - mullhw. */
5359 tcg_gen_ext16s_tl(t0, cpu_gpr[ra]);
5360 tcg_gen_ext16s_tl(t1, cpu_gpr[rb]);
5361 break;
5362 case 0x0C:
5363 /* maclhwu - maclhwu. - maclhwuo - maclhwuo. */
5364 /* maclhwsu - maclhwsu. - maclhwsuo - maclhwsuo. */
5365 /* mullhwu - mullhwu. */
5366 tcg_gen_ext16u_tl(t0, cpu_gpr[ra]);
5367 tcg_gen_ext16u_tl(t1, cpu_gpr[rb]);
5368 break;
5369 }
5370 if (opc2 & 0x04) {
5371 /* (n)multiply-and-accumulate (0x0C / 0x0E) */
5372 tcg_gen_mul_tl(t1, t0, t1);
5373 if (opc2 & 0x02) {
5374 /* nmultiply-and-accumulate (0x0E) */
5375 tcg_gen_sub_tl(t0, cpu_gpr[rt], t1);
5376 } else {
5377 /* multiply-and-accumulate (0x0C) */
5378 tcg_gen_add_tl(t0, cpu_gpr[rt], t1);
5379 }
5380
5381 if (opc3 & 0x12) {
5382 /* Check overflow and/or saturate */
5383 int l1 = gen_new_label();
5384
5385 if (opc3 & 0x10) {
5386 /* Start with XER OV disabled, the most likely case */
5387 tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
5388 }
5389 if (opc3 & 0x01) {
5390 /* Signed */
5391 tcg_gen_xor_tl(t1, cpu_gpr[rt], t1);
5392 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
5393 tcg_gen_xor_tl(t1, cpu_gpr[rt], t0);
5394 tcg_gen_brcondi_tl(TCG_COND_LT, t1, 0, l1);
5395 if (opc3 & 0x02) {
5396 /* Saturate */
5397 tcg_gen_sari_tl(t0, cpu_gpr[rt], 31);
5398 tcg_gen_xori_tl(t0, t0, 0x7fffffff);
5399 }
5400 } else {
5401 /* Unsigned */
5402 tcg_gen_brcond_tl(TCG_COND_GEU, t0, t1, l1);
5403 if (opc3 & 0x02) {
5404 /* Saturate */
5405 tcg_gen_movi_tl(t0, UINT32_MAX);
5406 }
5407 }
5408 if (opc3 & 0x10) {
5409 /* Check overflow */
5410 tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
5411 }
5412 gen_set_label(l1);
5413 tcg_gen_mov_tl(cpu_gpr[rt], t0);
5414 }
5415 } else {
5416 tcg_gen_mul_tl(cpu_gpr[rt], t0, t1);
5417 }
5418 tcg_temp_free(t0);
5419 tcg_temp_free(t1);
5420 if (unlikely(Rc) != 0) {
5421 /* Update Rc0 */
5422 gen_set_Rc0(ctx, cpu_gpr[rt]);
5423 }
5424}
5425
5426#define GEN_MAC_HANDLER(name, opc2, opc3) \
5427static void glue(gen_, name)(DisasContext *ctx) \
5428{ \
5429 gen_405_mulladd_insn(ctx, opc2, opc3, rA(ctx->opcode), rB(ctx->opcode), \
5430 rD(ctx->opcode), Rc(ctx->opcode)); \
5431}
5432
5433/* macchw - macchw. */
5434GEN_MAC_HANDLER(macchw, 0x0C, 0x05);
5435/* macchwo - macchwo. */
5436GEN_MAC_HANDLER(macchwo, 0x0C, 0x15);
5437/* macchws - macchws. */
5438GEN_MAC_HANDLER(macchws, 0x0C, 0x07);
5439/* macchwso - macchwso. */
5440GEN_MAC_HANDLER(macchwso, 0x0C, 0x17);
5441/* macchwsu - macchwsu. */
5442GEN_MAC_HANDLER(macchwsu, 0x0C, 0x06);
5443/* macchwsuo - macchwsuo. */
5444GEN_MAC_HANDLER(macchwsuo, 0x0C, 0x16);
5445/* macchwu - macchwu. */
5446GEN_MAC_HANDLER(macchwu, 0x0C, 0x04);
5447/* macchwuo - macchwuo. */
5448GEN_MAC_HANDLER(macchwuo, 0x0C, 0x14);
5449/* machhw - machhw. */
5450GEN_MAC_HANDLER(machhw, 0x0C, 0x01);
5451/* machhwo - machhwo. */
5452GEN_MAC_HANDLER(machhwo, 0x0C, 0x11);
5453/* machhws - machhws. */
5454GEN_MAC_HANDLER(machhws, 0x0C, 0x03);
5455/* machhwso - machhwso. */
5456GEN_MAC_HANDLER(machhwso, 0x0C, 0x13);
5457/* machhwsu - machhwsu. */
5458GEN_MAC_HANDLER(machhwsu, 0x0C, 0x02);
5459/* machhwsuo - machhwsuo. */
5460GEN_MAC_HANDLER(machhwsuo, 0x0C, 0x12);
5461/* machhwu - machhwu. */
5462GEN_MAC_HANDLER(machhwu, 0x0C, 0x00);
5463/* machhwuo - machhwuo. */
5464GEN_MAC_HANDLER(machhwuo, 0x0C, 0x10);
5465/* maclhw - maclhw. */
5466GEN_MAC_HANDLER(maclhw, 0x0C, 0x0D);
5467/* maclhwo - maclhwo. */
5468GEN_MAC_HANDLER(maclhwo, 0x0C, 0x1D);
5469/* maclhws - maclhws. */
5470GEN_MAC_HANDLER(maclhws, 0x0C, 0x0F);
5471/* maclhwso - maclhwso. */
5472GEN_MAC_HANDLER(maclhwso, 0x0C, 0x1F);
5473/* maclhwu - maclhwu. */
5474GEN_MAC_HANDLER(maclhwu, 0x0C, 0x0C);
5475/* maclhwuo - maclhwuo. */
5476GEN_MAC_HANDLER(maclhwuo, 0x0C, 0x1C);
5477/* maclhwsu - maclhwsu. */
5478GEN_MAC_HANDLER(maclhwsu, 0x0C, 0x0E);
5479/* maclhwsuo - maclhwsuo. */
5480GEN_MAC_HANDLER(maclhwsuo, 0x0C, 0x1E);
5481/* nmacchw - nmacchw. */
5482GEN_MAC_HANDLER(nmacchw, 0x0E, 0x05);
5483/* nmacchwo - nmacchwo. */
5484GEN_MAC_HANDLER(nmacchwo, 0x0E, 0x15);
5485/* nmacchws - nmacchws. */
5486GEN_MAC_HANDLER(nmacchws, 0x0E, 0x07);
5487/* nmacchwso - nmacchwso. */
5488GEN_MAC_HANDLER(nmacchwso, 0x0E, 0x17);
5489/* nmachhw - nmachhw. */
5490GEN_MAC_HANDLER(nmachhw, 0x0E, 0x01);
5491/* nmachhwo - nmachhwo. */
5492GEN_MAC_HANDLER(nmachhwo, 0x0E, 0x11);
5493/* nmachhws - nmachhws. */
5494GEN_MAC_HANDLER(nmachhws, 0x0E, 0x03);
5495/* nmachhwso - nmachhwso. */
5496GEN_MAC_HANDLER(nmachhwso, 0x0E, 0x13);
5497/* nmaclhw - nmaclhw. */
5498GEN_MAC_HANDLER(nmaclhw, 0x0E, 0x0D);
5499/* nmaclhwo - nmaclhwo. */
5500GEN_MAC_HANDLER(nmaclhwo, 0x0E, 0x1D);
5501/* nmaclhws - nmaclhws. */
5502GEN_MAC_HANDLER(nmaclhws, 0x0E, 0x0F);
5503/* nmaclhwso - nmaclhwso. */
5504GEN_MAC_HANDLER(nmaclhwso, 0x0E, 0x1F);
5505
5506/* mulchw - mulchw. */
5507GEN_MAC_HANDLER(mulchw, 0x08, 0x05);
5508/* mulchwu - mulchwu. */
5509GEN_MAC_HANDLER(mulchwu, 0x08, 0x04);
5510/* mulhhw - mulhhw. */
5511GEN_MAC_HANDLER(mulhhw, 0x08, 0x01);
5512/* mulhhwu - mulhhwu. */
5513GEN_MAC_HANDLER(mulhhwu, 0x08, 0x00);
5514/* mullhw - mullhw. */
5515GEN_MAC_HANDLER(mullhw, 0x08, 0x0D);
5516/* mullhwu - mullhwu. */
5517GEN_MAC_HANDLER(mullhwu, 0x08, 0x0C);
5518
5519/* mfdcr */
5520static void gen_mfdcr(DisasContext *ctx)
5521{
5522#if defined(CONFIG_USER_ONLY)
5523 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5524#else
5525 TCGv dcrn;
5526 if (unlikely(!ctx->mem_idx)) {
5527 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5528 return;
5529 }
5530 /* NIP cannot be restored if the memory exception comes from an helper */
5531 gen_update_nip(ctx, ctx->nip - 4);
5532 dcrn = tcg_const_tl(SPR(ctx->opcode));
5533 gen_helper_load_dcr(cpu_gpr[rD(ctx->opcode)], dcrn);
5534 tcg_temp_free(dcrn);
5535#endif
5536}
5537
5538/* mtdcr */
5539static void gen_mtdcr(DisasContext *ctx)
5540{
5541#if defined(CONFIG_USER_ONLY)
5542 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5543#else
5544 TCGv dcrn;
5545 if (unlikely(!ctx->mem_idx)) {
5546 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5547 return;
5548 }
5549 /* NIP cannot be restored if the memory exception comes from an helper */
5550 gen_update_nip(ctx, ctx->nip - 4);
5551 dcrn = tcg_const_tl(SPR(ctx->opcode));
5552 gen_helper_store_dcr(dcrn, cpu_gpr[rS(ctx->opcode)]);
5553 tcg_temp_free(dcrn);
5554#endif
5555}
5556
5557/* mfdcrx */
5558/* XXX: not implemented on 440 ? */
5559static void gen_mfdcrx(DisasContext *ctx)
5560{
5561#if defined(CONFIG_USER_ONLY)
5562 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5563#else
5564 if (unlikely(!ctx->mem_idx)) {
5565 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5566 return;
5567 }
5568 /* NIP cannot be restored if the memory exception comes from an helper */
5569 gen_update_nip(ctx, ctx->nip - 4);
5570 gen_helper_load_dcr(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
5571 /* Note: Rc update flag set leads to undefined state of Rc0 */
5572#endif
5573}
5574
5575/* mtdcrx */
5576/* XXX: not implemented on 440 ? */
5577static void gen_mtdcrx(DisasContext *ctx)
5578{
5579#if defined(CONFIG_USER_ONLY)
5580 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5581#else
5582 if (unlikely(!ctx->mem_idx)) {
5583 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
5584 return;
5585 }
5586 /* NIP cannot be restored if the memory exception comes from an helper */
5587 gen_update_nip(ctx, ctx->nip - 4);
5588 gen_helper_store_dcr(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
5589 /* Note: Rc update flag set leads to undefined state of Rc0 */
5590#endif
5591}
5592
5593/* mfdcrux (PPC 460) : user-mode access to DCR */
5594static void gen_mfdcrux(DisasContext *ctx)
5595{
5596 /* NIP cannot be restored if the memory exception comes from an helper */
5597 gen_update_nip(ctx, ctx->nip - 4);
5598 gen_helper_load_dcr(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
5599 /* Note: Rc update flag set leads to undefined state of Rc0 */
5600}
5601
5602/* mtdcrux (PPC 460) : user-mode access to DCR */
5603static void gen_mtdcrux(DisasContext *ctx)
5604{
5605 /* NIP cannot be restored if the memory exception comes from an helper */
5606 gen_update_nip(ctx, ctx->nip - 4);
5607 gen_helper_store_dcr(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
5608 /* Note: Rc update flag set leads to undefined state of Rc0 */
5609}
5610
5611/* dccci */
5612static void gen_dccci(DisasContext *ctx)
5613{
5614#if defined(CONFIG_USER_ONLY)
5615 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5616#else
5617 if (unlikely(!ctx->mem_idx)) {
5618 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5619 return;
5620 }
5621 /* interpreted as no-op */
5622#endif
5623}
5624
5625/* dcread */
5626static void gen_dcread(DisasContext *ctx)
5627{
5628#if defined(CONFIG_USER_ONLY)
5629 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5630#else
5631 TCGv EA, val;
5632 if (unlikely(!ctx->mem_idx)) {
5633 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5634 return;
5635 }
5636 gen_set_access_type(ctx, ACCESS_CACHE);
5637 EA = tcg_temp_new();
5638 gen_addr_reg_index(ctx, EA);
5639 val = tcg_temp_new();
5640 gen_qemu_ld32u(ctx, val, EA);
5641 tcg_temp_free(val);
5642 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], EA);
5643 tcg_temp_free(EA);
5644#endif
5645}
5646
5647/* icbt */
5648static void gen_icbt_40x(DisasContext *ctx)
5649{
5650 /* interpreted as no-op */
5651 /* XXX: specification say this is treated as a load by the MMU
5652 * but does not generate any exception
5653 */
5654}
5655
5656/* iccci */
5657static void gen_iccci(DisasContext *ctx)
5658{
5659#if defined(CONFIG_USER_ONLY)
5660 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5661#else
5662 if (unlikely(!ctx->mem_idx)) {
5663 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5664 return;
5665 }
5666 /* interpreted as no-op */
5667#endif
5668}
5669
5670/* icread */
5671static void gen_icread(DisasContext *ctx)
5672{
5673#if defined(CONFIG_USER_ONLY)
5674 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5675#else
5676 if (unlikely(!ctx->mem_idx)) {
5677 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5678 return;
5679 }
5680 /* interpreted as no-op */
5681#endif
5682}
5683
5684/* rfci (mem_idx only) */
5685static void gen_rfci_40x(DisasContext *ctx)
5686{
5687#if defined(CONFIG_USER_ONLY)
5688 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5689#else
5690 if (unlikely(!ctx->mem_idx)) {
5691 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5692 return;
5693 }
5694 /* Restore CPU state */
5695 gen_helper_40x_rfci();
5696 gen_sync_exception(ctx);
5697#endif
5698}
5699
5700static void gen_rfci(DisasContext *ctx)
5701{
5702#if defined(CONFIG_USER_ONLY)
5703 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5704#else
5705 if (unlikely(!ctx->mem_idx)) {
5706 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5707 return;
5708 }
5709 /* Restore CPU state */
5710 gen_helper_rfci();
5711 gen_sync_exception(ctx);
5712#endif
5713}
5714
5715/* BookE specific */
5716
5717/* XXX: not implemented on 440 ? */
5718static void gen_rfdi(DisasContext *ctx)
5719{
5720#if defined(CONFIG_USER_ONLY)
5721 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5722#else
5723 if (unlikely(!ctx->mem_idx)) {
5724 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5725 return;
5726 }
5727 /* Restore CPU state */
5728 gen_helper_rfdi();
5729 gen_sync_exception(ctx);
5730#endif
5731}
5732
5733/* XXX: not implemented on 440 ? */
5734static void gen_rfmci(DisasContext *ctx)
5735{
5736#if defined(CONFIG_USER_ONLY)
5737 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5738#else
5739 if (unlikely(!ctx->mem_idx)) {
5740 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5741 return;
5742 }
5743 /* Restore CPU state */
5744 gen_helper_rfmci();
5745 gen_sync_exception(ctx);
5746#endif
5747}
5748
5749/* TLB management - PowerPC 405 implementation */
5750
5751/* tlbre */
5752static void gen_tlbre_40x(DisasContext *ctx)
5753{
5754#if defined(CONFIG_USER_ONLY)
5755 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5756#else
5757 if (unlikely(!ctx->mem_idx)) {
5758 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5759 return;
5760 }
5761 switch (rB(ctx->opcode)) {
5762 case 0:
5763 gen_helper_4xx_tlbre_hi(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
5764 break;
5765 case 1:
5766 gen_helper_4xx_tlbre_lo(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
5767 break;
5768 default:
5769 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5770 break;
5771 }
5772#endif
5773}
5774
5775/* tlbsx - tlbsx. */
5776static void gen_tlbsx_40x(DisasContext *ctx)
5777{
5778#if defined(CONFIG_USER_ONLY)
5779 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5780#else
5781 TCGv t0;
5782 if (unlikely(!ctx->mem_idx)) {
5783 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5784 return;
5785 }
5786 t0 = tcg_temp_new();
5787 gen_addr_reg_index(ctx, t0);
5788 gen_helper_4xx_tlbsx(cpu_gpr[rD(ctx->opcode)], t0);
5789 tcg_temp_free(t0);
5790 if (Rc(ctx->opcode)) {
5791 int l1 = gen_new_label();
5792 tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);
5793 tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);
5794 tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);
5795 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rD(ctx->opcode)], -1, l1);
5796 tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 0x02);
5797 gen_set_label(l1);
5798 }
5799#endif
5800}
5801
5802/* tlbwe */
5803static void gen_tlbwe_40x(DisasContext *ctx)
5804{
5805#if defined(CONFIG_USER_ONLY)
5806 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5807#else
5808 if (unlikely(!ctx->mem_idx)) {
5809 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5810 return;
5811 }
5812 switch (rB(ctx->opcode)) {
5813 case 0:
5814 gen_helper_4xx_tlbwe_hi(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
5815 break;
5816 case 1:
5817 gen_helper_4xx_tlbwe_lo(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
5818 break;
5819 default:
5820 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5821 break;
5822 }
5823#endif
5824}
5825
5826/* TLB management - PowerPC 440 implementation */
5827
5828/* tlbre */
5829static void gen_tlbre_440(DisasContext *ctx)
5830{
5831#if defined(CONFIG_USER_ONLY)
5832 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5833#else
5834 if (unlikely(!ctx->mem_idx)) {
5835 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5836 return;
5837 }
5838 switch (rB(ctx->opcode)) {
5839 case 0:
5840 case 1:
5841 case 2:
5842 {
5843 TCGv_i32 t0 = tcg_const_i32(rB(ctx->opcode));
5844 gen_helper_440_tlbwe(t0, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
5845 tcg_temp_free_i32(t0);
5846 }
5847 break;
5848 default:
5849 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5850 break;
5851 }
5852#endif
5853}
5854
5855/* tlbsx - tlbsx. */
5856static void gen_tlbsx_440(DisasContext *ctx)
5857{
5858#if defined(CONFIG_USER_ONLY)
5859 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5860#else
5861 TCGv t0;
5862 if (unlikely(!ctx->mem_idx)) {
5863 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5864 return;
5865 }
5866 t0 = tcg_temp_new();
5867 gen_addr_reg_index(ctx, t0);
5868 gen_helper_440_tlbsx(cpu_gpr[rD(ctx->opcode)], t0);
5869 tcg_temp_free(t0);
5870 if (Rc(ctx->opcode)) {
5871 int l1 = gen_new_label();
5872 tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);
5873 tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);
5874 tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);
5875 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rD(ctx->opcode)], -1, l1);
5876 tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 0x02);
5877 gen_set_label(l1);
5878 }
5879#endif
5880}
5881
5882/* tlbwe */
5883static void gen_tlbwe_440(DisasContext *ctx)
5884{
5885#if defined(CONFIG_USER_ONLY)
5886 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5887#else
5888 if (unlikely(!ctx->mem_idx)) {
5889 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5890 return;
5891 }
5892 switch (rB(ctx->opcode)) {
5893 case 0:
5894 case 1:
5895 case 2:
5896 {
5897 TCGv_i32 t0 = tcg_const_i32(rB(ctx->opcode));
5898 gen_helper_440_tlbwe(t0, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
5899 tcg_temp_free_i32(t0);
5900 }
5901 break;
5902 default:
5903 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5904 break;
5905 }
5906#endif
5907}
5908
5909/* wrtee */
5910static void gen_wrtee(DisasContext *ctx)
5911{
5912#if defined(CONFIG_USER_ONLY)
5913 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5914#else
5915 TCGv t0;
5916 if (unlikely(!ctx->mem_idx)) {
5917 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5918 return;
5919 }
5920 t0 = tcg_temp_new();
5921 tcg_gen_andi_tl(t0, cpu_gpr[rD(ctx->opcode)], (1 << MSR_EE));
5922 tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(1 << MSR_EE));
5923 tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
5924 tcg_temp_free(t0);
5925 /* Stop translation to have a chance to raise an exception
5926 * if we just set msr_ee to 1
5927 */
5928 gen_stop_exception(ctx);
5929#endif
5930}
5931
5932/* wrteei */
5933static void gen_wrteei(DisasContext *ctx)
5934{
5935#if defined(CONFIG_USER_ONLY)
5936 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5937#else
5938 if (unlikely(!ctx->mem_idx)) {
5939 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
5940 return;
5941 }
5942 if (ctx->opcode & 0x00008000) {
5943 tcg_gen_ori_tl(cpu_msr, cpu_msr, (1 << MSR_EE));
5944 /* Stop translation to have a chance to raise an exception */
5945 gen_stop_exception(ctx);
5946 } else {
5947 tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(1 << MSR_EE));
5948 }
5949#endif
5950}
5951
5952/* PowerPC 440 specific instructions */
5953
5954/* dlmzb */
5955static void gen_dlmzb(DisasContext *ctx)
5956{
5957 TCGv_i32 t0 = tcg_const_i32(Rc(ctx->opcode));
5958 gen_helper_dlmzb(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
5959 cpu_gpr[rB(ctx->opcode)], t0);
5960 tcg_temp_free_i32(t0);
5961}
5962
5963/* mbar replaces eieio on 440 */
5964static void gen_mbar(DisasContext *ctx)
5965{
5966 /* interpreted as no-op */
5967}
5968
5969/* msync replaces sync on 440 */
5970static void gen_msync(DisasContext *ctx)
5971{
5972 /* interpreted as no-op */
5973}
5974
5975/* icbt */
5976static void gen_icbt_440(DisasContext *ctx)
5977{
5978 /* interpreted as no-op */
5979 /* XXX: specification say this is treated as a load by the MMU
5980 * but does not generate any exception
5981 */
5982}
5983
5984/*** Altivec vector extension ***/
5985/* Altivec registers moves */
5986
5987static always_inline TCGv_ptr gen_avr_ptr(int reg)
5988{
5989 TCGv_ptr r = tcg_temp_new_ptr();
5990 tcg_gen_addi_ptr(r, cpu_env, offsetof(CPUPPCState, avr[reg]));
5991 return r;
5992}
5993
5994#define GEN_VR_LDX(name, opc2, opc3) \
5995static void glue(gen_, name)(DisasContext *ctx) \
5996{ \
5997 TCGv EA; \
5998 if (unlikely(!ctx->altivec_enabled)) { \
5999 gen_exception(ctx, POWERPC_EXCP_VPU); \
6000 return; \
6001 } \
6002 gen_set_access_type(ctx, ACCESS_INT); \
6003 EA = tcg_temp_new(); \
6004 gen_addr_reg_index(ctx, EA); \
6005 tcg_gen_andi_tl(EA, EA, ~0xf); \
6006 if (ctx->le_mode) { \
6007 gen_qemu_ld64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
6008 tcg_gen_addi_tl(EA, EA, 8); \
6009 gen_qemu_ld64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
6010 } else { \
6011 gen_qemu_ld64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
6012 tcg_gen_addi_tl(EA, EA, 8); \
6013 gen_qemu_ld64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
6014 } \
6015 tcg_temp_free(EA); \
6016}
6017
6018#define GEN_VR_STX(name, opc2, opc3) \
6019static void gen_st##name(DisasContext *ctx) \
6020{ \
6021 TCGv EA; \
6022 if (unlikely(!ctx->altivec_enabled)) { \
6023 gen_exception(ctx, POWERPC_EXCP_VPU); \
6024 return; \
6025 } \
6026 gen_set_access_type(ctx, ACCESS_INT); \
6027 EA = tcg_temp_new(); \
6028 gen_addr_reg_index(ctx, EA); \
6029 tcg_gen_andi_tl(EA, EA, ~0xf); \
6030 if (ctx->le_mode) { \
6031 gen_qemu_st64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
6032 tcg_gen_addi_tl(EA, EA, 8); \
6033 gen_qemu_st64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
6034 } else { \
6035 gen_qemu_st64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
6036 tcg_gen_addi_tl(EA, EA, 8); \
6037 gen_qemu_st64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
6038 } \
6039 tcg_temp_free(EA); \
6040}
6041
6042#define GEN_VR_LVE(name, opc2, opc3) \
6043static void gen_lve##name(DisasContext *ctx) \
6044 { \
6045 TCGv EA; \
6046 TCGv_ptr rs; \
6047 if (unlikely(!ctx->altivec_enabled)) { \
6048 gen_exception(ctx, POWERPC_EXCP_VPU); \
6049 return; \
6050 } \
6051 gen_set_access_type(ctx, ACCESS_INT); \
6052 EA = tcg_temp_new(); \
6053 gen_addr_reg_index(ctx, EA); \
6054 rs = gen_avr_ptr(rS(ctx->opcode)); \
6055 gen_helper_lve##name (rs, EA); \
6056 tcg_temp_free(EA); \
6057 tcg_temp_free_ptr(rs); \
6058 }
6059
6060#define GEN_VR_STVE(name, opc2, opc3) \
6061static void gen_stve##name(DisasContext *ctx) \
6062 { \
6063 TCGv EA; \
6064 TCGv_ptr rs; \
6065 if (unlikely(!ctx->altivec_enabled)) { \
6066 gen_exception(ctx, POWERPC_EXCP_VPU); \
6067 return; \
6068 } \
6069 gen_set_access_type(ctx, ACCESS_INT); \
6070 EA = tcg_temp_new(); \
6071 gen_addr_reg_index(ctx, EA); \
6072 rs = gen_avr_ptr(rS(ctx->opcode)); \
6073 gen_helper_stve##name (rs, EA); \
6074 tcg_temp_free(EA); \
6075 tcg_temp_free_ptr(rs); \
6076 }
6077
6078GEN_VR_LDX(lvx, 0x07, 0x03);
6079/* As we don't emulate the cache, lvxl is stricly equivalent to lvx */
6080GEN_VR_LDX(lvxl, 0x07, 0x0B);
6081
6082GEN_VR_LVE(bx, 0x07, 0x00);
6083GEN_VR_LVE(hx, 0x07, 0x01);
6084GEN_VR_LVE(wx, 0x07, 0x02);
6085
6086GEN_VR_STX(svx, 0x07, 0x07);
6087/* As we don't emulate the cache, stvxl is stricly equivalent to stvx */
6088GEN_VR_STX(svxl, 0x07, 0x0F);
6089
6090GEN_VR_STVE(bx, 0x07, 0x04);
6091GEN_VR_STVE(hx, 0x07, 0x05);
6092GEN_VR_STVE(wx, 0x07, 0x06);
6093
6094static void gen_lvsl(DisasContext *ctx)
6095{
6096 TCGv_ptr rd;
6097 TCGv EA;
6098 if (unlikely(!ctx->altivec_enabled)) {
6099 gen_exception(ctx, POWERPC_EXCP_VPU);
6100 return;
6101 }
6102 EA = tcg_temp_new();
6103 gen_addr_reg_index(ctx, EA);
6104 rd = gen_avr_ptr(rD(ctx->opcode));
6105 gen_helper_lvsl(rd, EA);
6106 tcg_temp_free(EA);
6107 tcg_temp_free_ptr(rd);
6108}
6109
6110static void gen_lvsr(DisasContext *ctx)
6111{
6112 TCGv_ptr rd;
6113 TCGv EA;
6114 if (unlikely(!ctx->altivec_enabled)) {
6115 gen_exception(ctx, POWERPC_EXCP_VPU);
6116 return;
6117 }
6118 EA = tcg_temp_new();
6119 gen_addr_reg_index(ctx, EA);
6120 rd = gen_avr_ptr(rD(ctx->opcode));
6121 gen_helper_lvsr(rd, EA);
6122 tcg_temp_free(EA);
6123 tcg_temp_free_ptr(rd);
6124}
6125
6126static void gen_mfvscr(DisasContext *ctx)
6127{
6128 TCGv_i32 t;
6129 if (unlikely(!ctx->altivec_enabled)) {
6130 gen_exception(ctx, POWERPC_EXCP_VPU);
6131 return;
6132 }
6133 tcg_gen_movi_i64(cpu_avrh[rD(ctx->opcode)], 0);
6134 t = tcg_temp_new_i32();
6135 tcg_gen_ld_i32(t, cpu_env, offsetof(CPUState, vscr));
6136 tcg_gen_extu_i32_i64(cpu_avrl[rD(ctx->opcode)], t);
6137 tcg_temp_free_i32(t);
6138}
6139
6140static void gen_mtvscr(DisasContext *ctx)
6141{
6142 TCGv_ptr p;
6143 if (unlikely(!ctx->altivec_enabled)) {
6144 gen_exception(ctx, POWERPC_EXCP_VPU);
6145 return;
6146 }
6147 p = gen_avr_ptr(rD(ctx->opcode));
6148 gen_helper_mtvscr(p);
6149 tcg_temp_free_ptr(p);
6150}
6151
6152/* Logical operations */
6153#define GEN_VX_LOGICAL(name, tcg_op, opc2, opc3) \
6154static void glue(gen_, name)(DisasContext *ctx) \
6155{ \
6156 if (unlikely(!ctx->altivec_enabled)) { \
6157 gen_exception(ctx, POWERPC_EXCP_VPU); \
6158 return; \
6159 } \
6160 tcg_op(cpu_avrh[rD(ctx->opcode)], cpu_avrh[rA(ctx->opcode)], cpu_avrh[rB(ctx->opcode)]); \
6161 tcg_op(cpu_avrl[rD(ctx->opcode)], cpu_avrl[rA(ctx->opcode)], cpu_avrl[rB(ctx->opcode)]); \
6162}
6163
6164GEN_VX_LOGICAL(vand, tcg_gen_and_i64, 2, 16);
6165GEN_VX_LOGICAL(vandc, tcg_gen_andc_i64, 2, 17);
6166GEN_VX_LOGICAL(vor, tcg_gen_or_i64, 2, 18);
6167GEN_VX_LOGICAL(vxor, tcg_gen_xor_i64, 2, 19);
6168GEN_VX_LOGICAL(vnor, tcg_gen_nor_i64, 2, 20);
6169
6170#define GEN_VXFORM(name, opc2, opc3) \
6171static void glue(gen_, name)(DisasContext *ctx) \
6172{ \
6173 TCGv_ptr ra, rb, rd; \
6174 if (unlikely(!ctx->altivec_enabled)) { \
6175 gen_exception(ctx, POWERPC_EXCP_VPU); \
6176 return; \
6177 } \
6178 ra = gen_avr_ptr(rA(ctx->opcode)); \
6179 rb = gen_avr_ptr(rB(ctx->opcode)); \
6180 rd = gen_avr_ptr(rD(ctx->opcode)); \
6181 gen_helper_##name (rd, ra, rb); \
6182 tcg_temp_free_ptr(ra); \
6183 tcg_temp_free_ptr(rb); \
6184 tcg_temp_free_ptr(rd); \
6185}
6186
6187GEN_VXFORM(vaddubm, 0, 0);
6188GEN_VXFORM(vadduhm, 0, 1);
6189GEN_VXFORM(vadduwm, 0, 2);
6190GEN_VXFORM(vsububm, 0, 16);
6191GEN_VXFORM(vsubuhm, 0, 17);
6192GEN_VXFORM(vsubuwm, 0, 18);
6193GEN_VXFORM(vmaxub, 1, 0);
6194GEN_VXFORM(vmaxuh, 1, 1);
6195GEN_VXFORM(vmaxuw, 1, 2);
6196GEN_VXFORM(vmaxsb, 1, 4);
6197GEN_VXFORM(vmaxsh, 1, 5);
6198GEN_VXFORM(vmaxsw, 1, 6);
6199GEN_VXFORM(vminub, 1, 8);
6200GEN_VXFORM(vminuh, 1, 9);
6201GEN_VXFORM(vminuw, 1, 10);
6202GEN_VXFORM(vminsb, 1, 12);
6203GEN_VXFORM(vminsh, 1, 13);
6204GEN_VXFORM(vminsw, 1, 14);
6205GEN_VXFORM(vavgub, 1, 16);
6206GEN_VXFORM(vavguh, 1, 17);
6207GEN_VXFORM(vavguw, 1, 18);
6208GEN_VXFORM(vavgsb, 1, 20);
6209GEN_VXFORM(vavgsh, 1, 21);
6210GEN_VXFORM(vavgsw, 1, 22);
6211GEN_VXFORM(vmrghb, 6, 0);
6212GEN_VXFORM(vmrghh, 6, 1);
6213GEN_VXFORM(vmrghw, 6, 2);
6214GEN_VXFORM(vmrglb, 6, 4);
6215GEN_VXFORM(vmrglh, 6, 5);
6216GEN_VXFORM(vmrglw, 6, 6);
6217GEN_VXFORM(vmuloub, 4, 0);
6218GEN_VXFORM(vmulouh, 4, 1);
6219GEN_VXFORM(vmulosb, 4, 4);
6220GEN_VXFORM(vmulosh, 4, 5);
6221GEN_VXFORM(vmuleub, 4, 8);
6222GEN_VXFORM(vmuleuh, 4, 9);
6223GEN_VXFORM(vmulesb, 4, 12);
6224GEN_VXFORM(vmulesh, 4, 13);
6225GEN_VXFORM(vslb, 2, 4);
6226GEN_VXFORM(vslh, 2, 5);
6227GEN_VXFORM(vslw, 2, 6);
6228GEN_VXFORM(vsrb, 2, 8);
6229GEN_VXFORM(vsrh, 2, 9);
6230GEN_VXFORM(vsrw, 2, 10);
6231GEN_VXFORM(vsrab, 2, 12);
6232GEN_VXFORM(vsrah, 2, 13);
6233GEN_VXFORM(vsraw, 2, 14);
6234GEN_VXFORM(vslo, 6, 16);
6235GEN_VXFORM(vsro, 6, 17);
6236GEN_VXFORM(vaddcuw, 0, 6);
6237GEN_VXFORM(vsubcuw, 0, 22);
6238GEN_VXFORM(vaddubs, 0, 8);
6239GEN_VXFORM(vadduhs, 0, 9);
6240GEN_VXFORM(vadduws, 0, 10);
6241GEN_VXFORM(vaddsbs, 0, 12);
6242GEN_VXFORM(vaddshs, 0, 13);
6243GEN_VXFORM(vaddsws, 0, 14);
6244GEN_VXFORM(vsububs, 0, 24);
6245GEN_VXFORM(vsubuhs, 0, 25);
6246GEN_VXFORM(vsubuws, 0, 26);
6247GEN_VXFORM(vsubsbs, 0, 28);
6248GEN_VXFORM(vsubshs, 0, 29);
6249GEN_VXFORM(vsubsws, 0, 30);
6250GEN_VXFORM(vrlb, 2, 0);
6251GEN_VXFORM(vrlh, 2, 1);
6252GEN_VXFORM(vrlw, 2, 2);
6253GEN_VXFORM(vsl, 2, 7);
6254GEN_VXFORM(vsr, 2, 11);
6255GEN_VXFORM(vpkuhum, 7, 0);
6256GEN_VXFORM(vpkuwum, 7, 1);
6257GEN_VXFORM(vpkuhus, 7, 2);
6258GEN_VXFORM(vpkuwus, 7, 3);
6259GEN_VXFORM(vpkshus, 7, 4);
6260GEN_VXFORM(vpkswus, 7, 5);
6261GEN_VXFORM(vpkshss, 7, 6);
6262GEN_VXFORM(vpkswss, 7, 7);
6263GEN_VXFORM(vpkpx, 7, 12);
6264GEN_VXFORM(vsum4ubs, 4, 24);
6265GEN_VXFORM(vsum4sbs, 4, 28);
6266GEN_VXFORM(vsum4shs, 4, 25);
6267GEN_VXFORM(vsum2sws, 4, 26);
6268GEN_VXFORM(vsumsws, 4, 30);
6269GEN_VXFORM(vaddfp, 5, 0);
6270GEN_VXFORM(vsubfp, 5, 1);
6271GEN_VXFORM(vmaxfp, 5, 16);
6272GEN_VXFORM(vminfp, 5, 17);
6273
6274#define GEN_VXRFORM1(opname, name, str, opc2, opc3) \
6275static void glue(gen_, name)(DisasContext *ctx) \
6276 { \
6277 TCGv_ptr ra, rb, rd; \
6278 if (unlikely(!ctx->altivec_enabled)) { \
6279 gen_exception(ctx, POWERPC_EXCP_VPU); \
6280 return; \
6281 } \
6282 ra = gen_avr_ptr(rA(ctx->opcode)); \
6283 rb = gen_avr_ptr(rB(ctx->opcode)); \
6284 rd = gen_avr_ptr(rD(ctx->opcode)); \
6285 gen_helper_##opname (rd, ra, rb); \
6286 tcg_temp_free_ptr(ra); \
6287 tcg_temp_free_ptr(rb); \
6288 tcg_temp_free_ptr(rd); \
6289 }
6290
6291#define GEN_VXRFORM(name, opc2, opc3) \
6292 GEN_VXRFORM1(name, name, #name, opc2, opc3) \
6293 GEN_VXRFORM1(name##_dot, name##_, #name ".", opc2, (opc3 | (0x1 << 4)))
6294
6295GEN_VXRFORM(vcmpequb, 3, 0)
6296GEN_VXRFORM(vcmpequh, 3, 1)
6297GEN_VXRFORM(vcmpequw, 3, 2)
6298GEN_VXRFORM(vcmpgtsb, 3, 12)
6299GEN_VXRFORM(vcmpgtsh, 3, 13)
6300GEN_VXRFORM(vcmpgtsw, 3, 14)
6301GEN_VXRFORM(vcmpgtub, 3, 8)
6302GEN_VXRFORM(vcmpgtuh, 3, 9)
6303GEN_VXRFORM(vcmpgtuw, 3, 10)
6304GEN_VXRFORM(vcmpeqfp, 3, 3)
6305GEN_VXRFORM(vcmpgefp, 3, 7)
6306GEN_VXRFORM(vcmpgtfp, 3, 11)
6307GEN_VXRFORM(vcmpbfp, 3, 15)
6308
6309#define GEN_VXFORM_SIMM(name, opc2, opc3) \
6310static void glue(gen_, name)(DisasContext *ctx) \
6311 { \
6312 TCGv_ptr rd; \
6313 TCGv_i32 simm; \
6314 if (unlikely(!ctx->altivec_enabled)) { \
6315 gen_exception(ctx, POWERPC_EXCP_VPU); \
6316 return; \
6317 } \
6318 simm = tcg_const_i32(SIMM5(ctx->opcode)); \
6319 rd = gen_avr_ptr(rD(ctx->opcode)); \
6320 gen_helper_##name (rd, simm); \
6321 tcg_temp_free_i32(simm); \
6322 tcg_temp_free_ptr(rd); \
6323 }
6324
6325GEN_VXFORM_SIMM(vspltisb, 6, 12);
6326GEN_VXFORM_SIMM(vspltish, 6, 13);
6327GEN_VXFORM_SIMM(vspltisw, 6, 14);
6328
6329#define GEN_VXFORM_NOA(name, opc2, opc3) \
6330static void glue(gen_, name)(DisasContext *ctx) \
6331 { \
6332 TCGv_ptr rb, rd; \
6333 if (unlikely(!ctx->altivec_enabled)) { \
6334 gen_exception(ctx, POWERPC_EXCP_VPU); \
6335 return; \
6336 } \
6337 rb = gen_avr_ptr(rB(ctx->opcode)); \
6338 rd = gen_avr_ptr(rD(ctx->opcode)); \
6339 gen_helper_##name (rd, rb); \
6340 tcg_temp_free_ptr(rb); \
6341 tcg_temp_free_ptr(rd); \
6342 }
6343
6344GEN_VXFORM_NOA(vupkhsb, 7, 8);
6345GEN_VXFORM_NOA(vupkhsh, 7, 9);
6346GEN_VXFORM_NOA(vupklsb, 7, 10);
6347GEN_VXFORM_NOA(vupklsh, 7, 11);
6348GEN_VXFORM_NOA(vupkhpx, 7, 13);
6349GEN_VXFORM_NOA(vupklpx, 7, 15);
6350GEN_VXFORM_NOA(vrefp, 5, 4);
6351GEN_VXFORM_NOA(vrsqrtefp, 5, 5);
6352GEN_VXFORM_NOA(vlogefp, 5, 7);
6353GEN_VXFORM_NOA(vrfim, 5, 8);
6354GEN_VXFORM_NOA(vrfin, 5, 9);
6355GEN_VXFORM_NOA(vrfip, 5, 10);
6356GEN_VXFORM_NOA(vrfiz, 5, 11);
6357
6358#define GEN_VXFORM_SIMM(name, opc2, opc3) \
6359static void glue(gen_, name)(DisasContext *ctx) \
6360 { \
6361 TCGv_ptr rd; \
6362 TCGv_i32 simm; \
6363 if (unlikely(!ctx->altivec_enabled)) { \
6364 gen_exception(ctx, POWERPC_EXCP_VPU); \
6365 return; \
6366 } \
6367 simm = tcg_const_i32(SIMM5(ctx->opcode)); \
6368 rd = gen_avr_ptr(rD(ctx->opcode)); \
6369 gen_helper_##name (rd, simm); \
6370 tcg_temp_free_i32(simm); \
6371 tcg_temp_free_ptr(rd); \
6372 }
6373
6374#define GEN_VXFORM_UIMM(name, opc2, opc3) \
6375static void glue(gen_, name)(DisasContext *ctx) \
6376 { \
6377 TCGv_ptr rb, rd; \
6378 TCGv_i32 uimm; \
6379 if (unlikely(!ctx->altivec_enabled)) { \
6380 gen_exception(ctx, POWERPC_EXCP_VPU); \
6381 return; \
6382 } \
6383 uimm = tcg_const_i32(UIMM5(ctx->opcode)); \
6384 rb = gen_avr_ptr(rB(ctx->opcode)); \
6385 rd = gen_avr_ptr(rD(ctx->opcode)); \
6386 gen_helper_##name (rd, rb, uimm); \
6387 tcg_temp_free_i32(uimm); \
6388 tcg_temp_free_ptr(rb); \
6389 tcg_temp_free_ptr(rd); \
6390 }
6391
6392GEN_VXFORM_UIMM(vspltb, 6, 8);
6393GEN_VXFORM_UIMM(vsplth, 6, 9);
6394GEN_VXFORM_UIMM(vspltw, 6, 10);
6395GEN_VXFORM_UIMM(vcfux, 5, 12);
6396GEN_VXFORM_UIMM(vcfsx, 5, 13);
6397GEN_VXFORM_UIMM(vctuxs, 5, 14);
6398GEN_VXFORM_UIMM(vctsxs, 5, 15);
6399
6400static void gen_vsldoi(DisasContext *ctx)
6401{
6402 TCGv_ptr ra, rb, rd;
6403 TCGv_i32 sh;
6404 if (unlikely(!ctx->altivec_enabled)) {
6405 gen_exception(ctx, POWERPC_EXCP_VPU);
6406 return;
6407 }
6408 ra = gen_avr_ptr(rA(ctx->opcode));
6409 rb = gen_avr_ptr(rB(ctx->opcode));
6410 rd = gen_avr_ptr(rD(ctx->opcode));
6411 sh = tcg_const_i32(VSH(ctx->opcode));
6412 gen_helper_vsldoi (rd, ra, rb, sh);
6413 tcg_temp_free_ptr(ra);
6414 tcg_temp_free_ptr(rb);
6415 tcg_temp_free_ptr(rd);
6416 tcg_temp_free_i32(sh);
6417}
6418
6419#define GEN_VAFORM_PAIRED(name0, name1, opc2) \
6420static void glue(gen_, name0##_##name1)(DisasContext *ctx) \
6421 { \
6422 TCGv_ptr ra, rb, rc, rd; \
6423 if (unlikely(!ctx->altivec_enabled)) { \
6424 gen_exception(ctx, POWERPC_EXCP_VPU); \
6425 return; \
6426 } \
6427 ra = gen_avr_ptr(rA(ctx->opcode)); \
6428 rb = gen_avr_ptr(rB(ctx->opcode)); \
6429 rc = gen_avr_ptr(rC(ctx->opcode)); \
6430 rd = gen_avr_ptr(rD(ctx->opcode)); \
6431 if (Rc(ctx->opcode)) { \
6432 gen_helper_##name1 (rd, ra, rb, rc); \
6433 } else { \
6434 gen_helper_##name0 (rd, ra, rb, rc); \
6435 } \
6436 tcg_temp_free_ptr(ra); \
6437 tcg_temp_free_ptr(rb); \
6438 tcg_temp_free_ptr(rc); \
6439 tcg_temp_free_ptr(rd); \
6440 }
6441
6442GEN_VAFORM_PAIRED(vmhaddshs, vmhraddshs, 16)
6443
6444static void gen_vmladduhm(DisasContext *ctx)
6445{
6446 TCGv_ptr ra, rb, rc, rd;
6447 if (unlikely(!ctx->altivec_enabled)) {
6448 gen_exception(ctx, POWERPC_EXCP_VPU);
6449 return;
6450 }
6451 ra = gen_avr_ptr(rA(ctx->opcode));
6452 rb = gen_avr_ptr(rB(ctx->opcode));
6453 rc = gen_avr_ptr(rC(ctx->opcode));
6454 rd = gen_avr_ptr(rD(ctx->opcode));
6455 gen_helper_vmladduhm(rd, ra, rb, rc);
6456 tcg_temp_free_ptr(ra);
6457 tcg_temp_free_ptr(rb);
6458 tcg_temp_free_ptr(rc);
6459 tcg_temp_free_ptr(rd);
6460}
6461
6462GEN_VAFORM_PAIRED(vmsumubm, vmsummbm, 18)
6463GEN_VAFORM_PAIRED(vmsumuhm, vmsumuhs, 19)
6464GEN_VAFORM_PAIRED(vmsumshm, vmsumshs, 20)
6465GEN_VAFORM_PAIRED(vsel, vperm, 21)
6466GEN_VAFORM_PAIRED(vmaddfp, vnmsubfp, 23)
6467
6468/*** SPE extension ***/
6469/* Register moves */
6470
6471static always_inline void gen_load_gpr64(TCGv_i64 t, int reg) {
6472#if defined(TARGET_PPC64)
6473 tcg_gen_mov_i64(t, cpu_gpr[reg]);
6474#else
6475 tcg_gen_concat_i32_i64(t, cpu_gpr[reg], cpu_gprh[reg]);
6476#endif
6477}
6478
6479static always_inline void gen_store_gpr64(int reg, TCGv_i64 t) {
6480#if defined(TARGET_PPC64)
6481 tcg_gen_mov_i64(cpu_gpr[reg], t);
6482#else
6483 TCGv_i64 tmp = tcg_temp_new_i64();
6484 tcg_gen_trunc_i64_i32(cpu_gpr[reg], t);
6485 tcg_gen_shri_i64(tmp, t, 32);
6486 tcg_gen_trunc_i64_i32(cpu_gprh[reg], tmp);
6487 tcg_temp_free_i64(tmp);
6488#endif
6489}
6490
6491#define GEN_SPE(name0, name1, opc2, opc3, inval, type) \
6492static void glue(gen_, name0##_##name1)(DisasContext *ctx) \
6493{ \
6494 if (Rc(ctx->opcode)) \
6495 gen_##name1(ctx); \
6496 else \
6497 gen_##name0(ctx); \
6498}
6499
6500/* Handler for undefined SPE opcodes */
6501static always_inline void gen_speundef (DisasContext *ctx)
6502{
6503 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
6504}
6505
6506/* SPE logic */
6507#if defined(TARGET_PPC64)
6508#define GEN_SPEOP_LOGIC2(name, tcg_op) \
6509static always_inline void gen_##name (DisasContext *ctx) \
6510{ \
6511 if (unlikely(!ctx->spe_enabled)) { \
6512 gen_exception(ctx, POWERPC_EXCP_APU); \
6513 return; \
6514 } \
6515 tcg_op(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], \
6516 cpu_gpr[rB(ctx->opcode)]); \
6517}
6518#else
6519#define GEN_SPEOP_LOGIC2(name, tcg_op) \
6520static always_inline void gen_##name (DisasContext *ctx) \
6521{ \
6522 if (unlikely(!ctx->spe_enabled)) { \
6523 gen_exception(ctx, POWERPC_EXCP_APU); \
6524 return; \
6525 } \
6526 tcg_op(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], \
6527 cpu_gpr[rB(ctx->opcode)]); \
6528 tcg_op(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], \
6529 cpu_gprh[rB(ctx->opcode)]); \
6530}
6531#endif
6532
6533GEN_SPEOP_LOGIC2(evand, tcg_gen_and_tl);
6534GEN_SPEOP_LOGIC2(evandc, tcg_gen_andc_tl);
6535GEN_SPEOP_LOGIC2(evxor, tcg_gen_xor_tl);
6536GEN_SPEOP_LOGIC2(evor, tcg_gen_or_tl);
6537GEN_SPEOP_LOGIC2(evnor, tcg_gen_nor_tl);
6538GEN_SPEOP_LOGIC2(eveqv, tcg_gen_eqv_tl);
6539GEN_SPEOP_LOGIC2(evorc, tcg_gen_orc_tl);
6540GEN_SPEOP_LOGIC2(evnand, tcg_gen_nand_tl);
6541
6542/* SPE logic immediate */
6543#if defined(TARGET_PPC64)
6544#define GEN_SPEOP_TCG_LOGIC_IMM2(name, tcg_opi) \
6545static always_inline void gen_##name (DisasContext *ctx) \
6546{ \
6547 if (unlikely(!ctx->spe_enabled)) { \
6548 gen_exception(ctx, POWERPC_EXCP_APU); \
6549 return; \
6550 } \
6551 TCGv_i32 t0 = tcg_temp_local_new_i32(); \
6552 TCGv_i32 t1 = tcg_temp_local_new_i32(); \
6553 TCGv_i64 t2 = tcg_temp_local_new_i64(); \
6554 tcg_gen_trunc_i64_i32(t0, cpu_gpr[rA(ctx->opcode)]); \
6555 tcg_opi(t0, t0, rB(ctx->opcode)); \
6556 tcg_gen_shri_i64(t2, cpu_gpr[rA(ctx->opcode)], 32); \
6557 tcg_gen_trunc_i64_i32(t1, t2); \
6558 tcg_temp_free_i64(t2); \
6559 tcg_opi(t1, t1, rB(ctx->opcode)); \
6560 tcg_gen_concat_i32_i64(cpu_gpr[rD(ctx->opcode)], t0, t1); \
6561 tcg_temp_free_i32(t0); \
6562 tcg_temp_free_i32(t1); \
6563}
6564#else
6565#define GEN_SPEOP_TCG_LOGIC_IMM2(name, tcg_opi) \
6566static always_inline void gen_##name (DisasContext *ctx) \
6567{ \
6568 if (unlikely(!ctx->spe_enabled)) { \
6569 gen_exception(ctx, POWERPC_EXCP_APU); \
6570 return; \
6571 } \
6572 tcg_opi(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], \
6573 rB(ctx->opcode)); \
6574 tcg_opi(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], \
6575 rB(ctx->opcode)); \
6576}
6577#endif
6578GEN_SPEOP_TCG_LOGIC_IMM2(evslwi, tcg_gen_shli_i32);
6579GEN_SPEOP_TCG_LOGIC_IMM2(evsrwiu, tcg_gen_shri_i32);
6580GEN_SPEOP_TCG_LOGIC_IMM2(evsrwis, tcg_gen_sari_i32);
6581GEN_SPEOP_TCG_LOGIC_IMM2(evrlwi, tcg_gen_rotli_i32);
6582
6583/* SPE arithmetic */
6584#if defined(TARGET_PPC64)
6585#define GEN_SPEOP_ARITH1(name, tcg_op) \
6586static always_inline void gen_##name (DisasContext *ctx) \
6587{ \
6588 if (unlikely(!ctx->spe_enabled)) { \
6589 gen_exception(ctx, POWERPC_EXCP_APU); \
6590 return; \
6591 } \
6592 TCGv_i32 t0 = tcg_temp_local_new_i32(); \
6593 TCGv_i32 t1 = tcg_temp_local_new_i32(); \
6594 TCGv_i64 t2 = tcg_temp_local_new_i64(); \
6595 tcg_gen_trunc_i64_i32(t0, cpu_gpr[rA(ctx->opcode)]); \
6596 tcg_op(t0, t0); \
6597 tcg_gen_shri_i64(t2, cpu_gpr[rA(ctx->opcode)], 32); \
6598 tcg_gen_trunc_i64_i32(t1, t2); \
6599 tcg_temp_free_i64(t2); \
6600 tcg_op(t1, t1); \
6601 tcg_gen_concat_i32_i64(cpu_gpr[rD(ctx->opcode)], t0, t1); \
6602 tcg_temp_free_i32(t0); \
6603 tcg_temp_free_i32(t1); \
6604}
6605#else
6606#define GEN_SPEOP_ARITH1(name, tcg_op) \
6607static always_inline void gen_##name (DisasContext *ctx) \
6608{ \
6609 if (unlikely(!ctx->spe_enabled)) { \
6610 gen_exception(ctx, POWERPC_EXCP_APU); \
6611 return; \
6612 } \
6613 tcg_op(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]); \
6614 tcg_op(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)]); \
6615}
6616#endif
6617
6618static always_inline void gen_op_evabs (TCGv_i32 ret, TCGv_i32 arg1)
6619{
6620 int l1 = gen_new_label();
6621 int l2 = gen_new_label();
6622
6623 tcg_gen_brcondi_i32(TCG_COND_GE, arg1, 0, l1);
6624 tcg_gen_neg_i32(ret, arg1);
6625 tcg_gen_br(l2);
6626 gen_set_label(l1);
6627 tcg_gen_mov_i32(ret, arg1);
6628 gen_set_label(l2);
6629}
6630GEN_SPEOP_ARITH1(evabs, gen_op_evabs);
6631GEN_SPEOP_ARITH1(evneg, tcg_gen_neg_i32);
6632GEN_SPEOP_ARITH1(evextsb, tcg_gen_ext8s_i32);
6633GEN_SPEOP_ARITH1(evextsh, tcg_gen_ext16s_i32);
6634static always_inline void gen_op_evrndw (TCGv_i32 ret, TCGv_i32 arg1)
6635{
6636 tcg_gen_addi_i32(ret, arg1, 0x8000);
6637 tcg_gen_ext16u_i32(ret, ret);
6638}
6639GEN_SPEOP_ARITH1(evrndw, gen_op_evrndw);
6640GEN_SPEOP_ARITH1(evcntlsw, gen_helper_cntlsw32);
6641GEN_SPEOP_ARITH1(evcntlzw, gen_helper_cntlzw32);
6642
6643#if defined(TARGET_PPC64)
6644#define GEN_SPEOP_ARITH2(name, tcg_op) \
6645static always_inline void gen_##name (DisasContext *ctx) \
6646{ \
6647 if (unlikely(!ctx->spe_enabled)) { \
6648 gen_exception(ctx, POWERPC_EXCP_APU); \
6649 return; \
6650 } \
6651 TCGv_i32 t0 = tcg_temp_local_new_i32(); \
6652 TCGv_i32 t1 = tcg_temp_local_new_i32(); \
6653 TCGv_i32 t2 = tcg_temp_local_new_i32(); \
6654 TCGv_i64 t3 = tcg_temp_local_new_i64(); \
6655 tcg_gen_trunc_i64_i32(t0, cpu_gpr[rA(ctx->opcode)]); \
6656 tcg_gen_trunc_i64_i32(t2, cpu_gpr[rB(ctx->opcode)]); \
6657 tcg_op(t0, t0, t2); \
6658 tcg_gen_shri_i64(t3, cpu_gpr[rA(ctx->opcode)], 32); \
6659 tcg_gen_trunc_i64_i32(t1, t3); \
6660 tcg_gen_shri_i64(t3, cpu_gpr[rB(ctx->opcode)], 32); \
6661 tcg_gen_trunc_i64_i32(t2, t3); \
6662 tcg_temp_free_i64(t3); \
6663 tcg_op(t1, t1, t2); \
6664 tcg_temp_free_i32(t2); \
6665 tcg_gen_concat_i32_i64(cpu_gpr[rD(ctx->opcode)], t0, t1); \
6666 tcg_temp_free_i32(t0); \
6667 tcg_temp_free_i32(t1); \
6668}
6669#else
6670#define GEN_SPEOP_ARITH2(name, tcg_op) \
6671static always_inline void gen_##name (DisasContext *ctx) \
6672{ \
6673 if (unlikely(!ctx->spe_enabled)) { \
6674 gen_exception(ctx, POWERPC_EXCP_APU); \
6675 return; \
6676 } \
6677 tcg_op(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], \
6678 cpu_gpr[rB(ctx->opcode)]); \
6679 tcg_op(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], \
6680 cpu_gprh[rB(ctx->opcode)]); \
6681}
6682#endif
6683
6684static always_inline void gen_op_evsrwu (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
6685{
6686 TCGv_i32 t0;
6687 int l1, l2;
6688
6689 l1 = gen_new_label();
6690 l2 = gen_new_label();
6691 t0 = tcg_temp_local_new_i32();
6692 /* No error here: 6 bits are used */
6693 tcg_gen_andi_i32(t0, arg2, 0x3F);
6694 tcg_gen_brcondi_i32(TCG_COND_GE, t0, 32, l1);
6695 tcg_gen_shr_i32(ret, arg1, t0);
6696 tcg_gen_br(l2);
6697 gen_set_label(l1);
6698 tcg_gen_movi_i32(ret, 0);
6699 tcg_gen_br(l2);
6700 tcg_temp_free_i32(t0);
6701}
6702GEN_SPEOP_ARITH2(evsrwu, gen_op_evsrwu);
6703static always_inline void gen_op_evsrws (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
6704{
6705 TCGv_i32 t0;
6706 int l1, l2;
6707
6708 l1 = gen_new_label();
6709 l2 = gen_new_label();
6710 t0 = tcg_temp_local_new_i32();
6711 /* No error here: 6 bits are used */
6712 tcg_gen_andi_i32(t0, arg2, 0x3F);
6713 tcg_gen_brcondi_i32(TCG_COND_GE, t0, 32, l1);
6714 tcg_gen_sar_i32(ret, arg1, t0);
6715 tcg_gen_br(l2);
6716 gen_set_label(l1);
6717 tcg_gen_movi_i32(ret, 0);
6718 tcg_gen_br(l2);
6719 tcg_temp_free_i32(t0);
6720}
6721GEN_SPEOP_ARITH2(evsrws, gen_op_evsrws);
6722static always_inline void gen_op_evslw (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
6723{
6724 TCGv_i32 t0;
6725 int l1, l2;
6726
6727 l1 = gen_new_label();
6728 l2 = gen_new_label();
6729 t0 = tcg_temp_local_new_i32();
6730 /* No error here: 6 bits are used */
6731 tcg_gen_andi_i32(t0, arg2, 0x3F);
6732 tcg_gen_brcondi_i32(TCG_COND_GE, t0, 32, l1);
6733 tcg_gen_shl_i32(ret, arg1, t0);
6734 tcg_gen_br(l2);
6735 gen_set_label(l1);
6736 tcg_gen_movi_i32(ret, 0);
6737 tcg_gen_br(l2);
6738 tcg_temp_free_i32(t0);
6739}
6740GEN_SPEOP_ARITH2(evslw, gen_op_evslw);
6741static always_inline void gen_op_evrlw (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
6742{
6743 TCGv_i32 t0 = tcg_temp_new_i32();
6744 tcg_gen_andi_i32(t0, arg2, 0x1F);
6745 tcg_gen_rotl_i32(ret, arg1, t0);
6746 tcg_temp_free_i32(t0);
6747}
6748GEN_SPEOP_ARITH2(evrlw, gen_op_evrlw);
6749static always_inline void gen_evmergehi (DisasContext *ctx)
6750{
6751 if (unlikely(!ctx->spe_enabled)) {
6752 gen_exception(ctx, POWERPC_EXCP_APU);
6753 return;
6754 }
6755#if defined(TARGET_PPC64)
6756 TCGv t0 = tcg_temp_new();
6757 TCGv t1 = tcg_temp_new();
6758 tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 32);
6759 tcg_gen_andi_tl(t1, cpu_gpr[rA(ctx->opcode)], 0xFFFFFFFF0000000ULL);
6760 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], t0, t1);
6761 tcg_temp_free(t0);
6762 tcg_temp_free(t1);
6763#else
6764 tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gprh[rB(ctx->opcode)]);
6765 tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)]);
6766#endif
6767}
6768GEN_SPEOP_ARITH2(evaddw, tcg_gen_add_i32);
6769static always_inline void gen_op_evsubf (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
6770{
6771 tcg_gen_sub_i32(ret, arg2, arg1);
6772}
6773GEN_SPEOP_ARITH2(evsubfw, gen_op_evsubf);
6774
6775/* SPE arithmetic immediate */
6776#if defined(TARGET_PPC64)
6777#define GEN_SPEOP_ARITH_IMM2(name, tcg_op) \
6778static always_inline void gen_##name (DisasContext *ctx) \
6779{ \
6780 if (unlikely(!ctx->spe_enabled)) { \
6781 gen_exception(ctx, POWERPC_EXCP_APU); \
6782 return; \
6783 } \
6784 TCGv_i32 t0 = tcg_temp_local_new_i32(); \
6785 TCGv_i32 t1 = tcg_temp_local_new_i32(); \
6786 TCGv_i64 t2 = tcg_temp_local_new_i64(); \
6787 tcg_gen_trunc_i64_i32(t0, cpu_gpr[rB(ctx->opcode)]); \
6788 tcg_op(t0, t0, rA(ctx->opcode)); \
6789 tcg_gen_shri_i64(t2, cpu_gpr[rB(ctx->opcode)], 32); \
6790 tcg_gen_trunc_i64_i32(t1, t2); \
6791 tcg_temp_free_i64(t2); \
6792 tcg_op(t1, t1, rA(ctx->opcode)); \
6793 tcg_gen_concat_i32_i64(cpu_gpr[rD(ctx->opcode)], t0, t1); \
6794 tcg_temp_free_i32(t0); \
6795 tcg_temp_free_i32(t1); \
6796}
6797#else
6798#define GEN_SPEOP_ARITH_IMM2(name, tcg_op) \
6799static always_inline void gen_##name (DisasContext *ctx) \
6800{ \
6801 if (unlikely(!ctx->spe_enabled)) { \
6802 gen_exception(ctx, POWERPC_EXCP_APU); \
6803 return; \
6804 } \
6805 tcg_op(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], \
6806 rA(ctx->opcode)); \
6807 tcg_op(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rB(ctx->opcode)], \
6808 rA(ctx->opcode)); \
6809}
6810#endif
6811GEN_SPEOP_ARITH_IMM2(evaddiw, tcg_gen_addi_i32);
6812GEN_SPEOP_ARITH_IMM2(evsubifw, tcg_gen_subi_i32);
6813
6814/* SPE comparison */
6815#if defined(TARGET_PPC64)
6816#define GEN_SPEOP_COMP(name, tcg_cond) \
6817static always_inline void gen_##name (DisasContext *ctx) \
6818{ \
6819 if (unlikely(!ctx->spe_enabled)) { \
6820 gen_exception(ctx, POWERPC_EXCP_APU); \
6821 return; \
6822 } \
6823 int l1 = gen_new_label(); \
6824 int l2 = gen_new_label(); \
6825 int l3 = gen_new_label(); \
6826 int l4 = gen_new_label(); \
6827 TCGv_i32 t0 = tcg_temp_local_new_i32(); \
6828 TCGv_i32 t1 = tcg_temp_local_new_i32(); \
6829 TCGv_i64 t2 = tcg_temp_local_new_i64(); \
6830 tcg_gen_trunc_i64_i32(t0, cpu_gpr[rA(ctx->opcode)]); \
6831 tcg_gen_trunc_i64_i32(t1, cpu_gpr[rB(ctx->opcode)]); \
6832 tcg_gen_brcond_i32(tcg_cond, t0, t1, l1); \
6833 tcg_gen_movi_i32(cpu_crf[crfD(ctx->opcode)], 0); \
6834 tcg_gen_br(l2); \
6835 gen_set_label(l1); \
6836 tcg_gen_movi_i32(cpu_crf[crfD(ctx->opcode)], \
6837 CRF_CL | CRF_CH_OR_CL | CRF_CH_AND_CL); \
6838 gen_set_label(l2); \
6839 tcg_gen_shri_i64(t2, cpu_gpr[rA(ctx->opcode)], 32); \
6840 tcg_gen_trunc_i64_i32(t0, t2); \
6841 tcg_gen_shri_i64(t2, cpu_gpr[rB(ctx->opcode)], 32); \
6842 tcg_gen_trunc_i64_i32(t1, t2); \
6843 tcg_temp_free_i64(t2); \
6844 tcg_gen_brcond_i32(tcg_cond, t0, t1, l3); \
6845 tcg_gen_andi_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfD(ctx->opcode)], \
6846 ~(CRF_CH | CRF_CH_AND_CL)); \
6847 tcg_gen_br(l4); \
6848 gen_set_label(l3); \
6849 tcg_gen_ori_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfD(ctx->opcode)], \
6850 CRF_CH | CRF_CH_OR_CL); \
6851 gen_set_label(l4); \
6852 tcg_temp_free_i32(t0); \
6853 tcg_temp_free_i32(t1); \
6854}
6855#else
6856#define GEN_SPEOP_COMP(name, tcg_cond) \
6857static always_inline void gen_##name (DisasContext *ctx) \
6858{ \
6859 if (unlikely(!ctx->spe_enabled)) { \
6860 gen_exception(ctx, POWERPC_EXCP_APU); \
6861 return; \
6862 } \
6863 int l1 = gen_new_label(); \
6864 int l2 = gen_new_label(); \
6865 int l3 = gen_new_label(); \
6866 int l4 = gen_new_label(); \
6867 \
6868 tcg_gen_brcond_i32(tcg_cond, cpu_gpr[rA(ctx->opcode)], \
6869 cpu_gpr[rB(ctx->opcode)], l1); \
6870 tcg_gen_movi_tl(cpu_crf[crfD(ctx->opcode)], 0); \
6871 tcg_gen_br(l2); \
6872 gen_set_label(l1); \
6873 tcg_gen_movi_i32(cpu_crf[crfD(ctx->opcode)], \
6874 CRF_CL | CRF_CH_OR_CL | CRF_CH_AND_CL); \
6875 gen_set_label(l2); \
6876 tcg_gen_brcond_i32(tcg_cond, cpu_gprh[rA(ctx->opcode)], \
6877 cpu_gprh[rB(ctx->opcode)], l3); \
6878 tcg_gen_andi_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfD(ctx->opcode)], \
6879 ~(CRF_CH | CRF_CH_AND_CL)); \
6880 tcg_gen_br(l4); \
6881 gen_set_label(l3); \
6882 tcg_gen_ori_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfD(ctx->opcode)], \
6883 CRF_CH | CRF_CH_OR_CL); \
6884 gen_set_label(l4); \
6885}
6886#endif
6887GEN_SPEOP_COMP(evcmpgtu, TCG_COND_GTU);
6888GEN_SPEOP_COMP(evcmpgts, TCG_COND_GT);
6889GEN_SPEOP_COMP(evcmpltu, TCG_COND_LTU);
6890GEN_SPEOP_COMP(evcmplts, TCG_COND_LT);
6891GEN_SPEOP_COMP(evcmpeq, TCG_COND_EQ);
6892
6893/* SPE misc */
6894static always_inline void gen_brinc (DisasContext *ctx)
6895{
6896 /* Note: brinc is usable even if SPE is disabled */
6897 gen_helper_brinc(cpu_gpr[rD(ctx->opcode)],
6898 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
6899}
6900static always_inline void gen_evmergelo (DisasContext *ctx)
6901{
6902 if (unlikely(!ctx->spe_enabled)) {
6903 gen_exception(ctx, POWERPC_EXCP_APU);
6904 return;
6905 }
6906#if defined(TARGET_PPC64)
6907 TCGv t0 = tcg_temp_new();
6908 TCGv t1 = tcg_temp_new();
6909 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x00000000FFFFFFFFLL);
6910 tcg_gen_shli_tl(t1, cpu_gpr[rA(ctx->opcode)], 32);
6911 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], t0, t1);
6912 tcg_temp_free(t0);
6913 tcg_temp_free(t1);
6914#else
6915 tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
6916 tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
6917#endif
6918}
6919static always_inline void gen_evmergehilo (DisasContext *ctx)
6920{
6921 if (unlikely(!ctx->spe_enabled)) {
6922 gen_exception(ctx, POWERPC_EXCP_APU);
6923 return;
6924 }
6925#if defined(TARGET_PPC64)
6926 TCGv t0 = tcg_temp_new();
6927 TCGv t1 = tcg_temp_new();
6928 tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x00000000FFFFFFFFLL);
6929 tcg_gen_andi_tl(t1, cpu_gpr[rA(ctx->opcode)], 0xFFFFFFFF0000000ULL);
6930 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], t0, t1);
6931 tcg_temp_free(t0);
6932 tcg_temp_free(t1);
6933#else
6934 tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
6935 tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)]);
6936#endif
6937}
6938static always_inline void gen_evmergelohi (DisasContext *ctx)
6939{
6940 if (unlikely(!ctx->spe_enabled)) {
6941 gen_exception(ctx, POWERPC_EXCP_APU);
6942 return;
6943 }
6944#if defined(TARGET_PPC64)
6945 TCGv t0 = tcg_temp_new();
6946 TCGv t1 = tcg_temp_new();
6947 tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 32);
6948 tcg_gen_shli_tl(t1, cpu_gpr[rA(ctx->opcode)], 32);
6949 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], t0, t1);
6950 tcg_temp_free(t0);
6951 tcg_temp_free(t1);
6952#else
6953 if (rD(ctx->opcode) == rA(ctx->opcode)) {
6954 TCGv_i32 tmp = tcg_temp_new_i32();
6955 tcg_gen_mov_i32(tmp, cpu_gpr[rA(ctx->opcode)]);
6956 tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gprh[rB(ctx->opcode)]);
6957 tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], tmp);
6958 tcg_temp_free_i32(tmp);
6959 } else {
6960 tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gprh[rB(ctx->opcode)]);
6961 tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
6962 }
6963#endif
6964}
6965static always_inline void gen_evsplati (DisasContext *ctx)
6966{
6967 uint64_t imm = ((int32_t)(rA(ctx->opcode) << 11)) >> 27;
6968
6969#if defined(TARGET_PPC64)
6970 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], (imm << 32) | imm);
6971#else
6972 tcg_gen_movi_i32(cpu_gpr[rD(ctx->opcode)], imm);
6973 tcg_gen_movi_i32(cpu_gprh[rD(ctx->opcode)], imm);
6974#endif
6975}
6976static always_inline void gen_evsplatfi (DisasContext *ctx)
6977{
6978 uint64_t imm = rA(ctx->opcode) << 11;
6979
6980#if defined(TARGET_PPC64)
6981 tcg_gen_movi_tl(cpu_gpr[rD(ctx->opcode)], (imm << 32) | imm);
6982#else
6983 tcg_gen_movi_i32(cpu_gpr[rD(ctx->opcode)], imm);
6984 tcg_gen_movi_i32(cpu_gprh[rD(ctx->opcode)], imm);
6985#endif
6986}
6987
6988static always_inline void gen_evsel (DisasContext *ctx)
6989{
6990 int l1 = gen_new_label();
6991 int l2 = gen_new_label();
6992 int l3 = gen_new_label();
6993 int l4 = gen_new_label();
6994 TCGv_i32 t0 = tcg_temp_local_new_i32();
6995#if defined(TARGET_PPC64)
6996 TCGv t1 = tcg_temp_local_new();
6997 TCGv t2 = tcg_temp_local_new();
6998#endif
6999 tcg_gen_andi_i32(t0, cpu_crf[ctx->opcode & 0x07], 1 << 3);
7000 tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l1);
7001#if defined(TARGET_PPC64)
7002 tcg_gen_andi_tl(t1, cpu_gpr[rA(ctx->opcode)], 0xFFFFFFFF00000000ULL);
7003#else
7004 tcg_gen_mov_tl(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)]);
7005#endif
7006 tcg_gen_br(l2);
7007 gen_set_label(l1);
7008#if defined(TARGET_PPC64)
7009 tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0xFFFFFFFF00000000ULL);
7010#else
7011 tcg_gen_mov_tl(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rB(ctx->opcode)]);
7012#endif
7013 gen_set_label(l2);
7014 tcg_gen_andi_i32(t0, cpu_crf[ctx->opcode & 0x07], 1 << 2);
7015 tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l3);
7016#if defined(TARGET_PPC64)
7017 tcg_gen_andi_tl(t2, cpu_gpr[rA(ctx->opcode)], 0x00000000FFFFFFFFULL);
7018#else
7019 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
7020#endif
7021 tcg_gen_br(l4);
7022 gen_set_label(l3);
7023#if defined(TARGET_PPC64)
7024 tcg_gen_andi_tl(t2, cpu_gpr[rB(ctx->opcode)], 0x00000000FFFFFFFFULL);
7025#else
7026 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
7027#endif
7028 gen_set_label(l4);
7029 tcg_temp_free_i32(t0);
7030#if defined(TARGET_PPC64)
7031 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], t1, t2);
7032 tcg_temp_free(t1);
7033 tcg_temp_free(t2);
7034#endif
7035}
7036
7037static void gen_evsel0(DisasContext *ctx)
7038{
7039 gen_evsel(ctx);
7040}
7041
7042static void gen_evsel1(DisasContext *ctx)
7043{
7044 gen_evsel(ctx);
7045}
7046
7047static void gen_evsel2(DisasContext *ctx)
7048{
7049 gen_evsel(ctx);
7050}
7051
7052static void gen_evsel3(DisasContext *ctx)
7053{
7054 gen_evsel(ctx);
7055}
7056
7057GEN_SPE(evaddw, speundef, 0x00, 0x08, 0x00000000, PPC_SPE); ////
7058GEN_SPE(evaddiw, speundef, 0x01, 0x08, 0x00000000, PPC_SPE);
7059GEN_SPE(evsubfw, speundef, 0x02, 0x08, 0x00000000, PPC_SPE); ////
7060GEN_SPE(evsubifw, speundef, 0x03, 0x08, 0x00000000, PPC_SPE);
7061GEN_SPE(evabs, evneg, 0x04, 0x08, 0x0000F800, PPC_SPE); ////
7062GEN_SPE(evextsb, evextsh, 0x05, 0x08, 0x0000F800, PPC_SPE); ////
7063GEN_SPE(evrndw, evcntlzw, 0x06, 0x08, 0x0000F800, PPC_SPE); ////
7064GEN_SPE(evcntlsw, brinc, 0x07, 0x08, 0x00000000, PPC_SPE); //
7065GEN_SPE(speundef, evand, 0x08, 0x08, 0x00000000, PPC_SPE); ////
7066GEN_SPE(evandc, speundef, 0x09, 0x08, 0x00000000, PPC_SPE); ////
7067GEN_SPE(evxor, evor, 0x0B, 0x08, 0x00000000, PPC_SPE); ////
7068GEN_SPE(evnor, eveqv, 0x0C, 0x08, 0x00000000, PPC_SPE); ////
7069GEN_SPE(speundef, evorc, 0x0D, 0x08, 0x00000000, PPC_SPE); ////
7070GEN_SPE(evnand, speundef, 0x0F, 0x08, 0x00000000, PPC_SPE); ////
7071GEN_SPE(evsrwu, evsrws, 0x10, 0x08, 0x00000000, PPC_SPE); ////
7072GEN_SPE(evsrwiu, evsrwis, 0x11, 0x08, 0x00000000, PPC_SPE);
7073GEN_SPE(evslw, speundef, 0x12, 0x08, 0x00000000, PPC_SPE); ////
7074GEN_SPE(evslwi, speundef, 0x13, 0x08, 0x00000000, PPC_SPE);
7075GEN_SPE(evrlw, evsplati, 0x14, 0x08, 0x00000000, PPC_SPE); //
7076GEN_SPE(evrlwi, evsplatfi, 0x15, 0x08, 0x00000000, PPC_SPE);
7077GEN_SPE(evmergehi, evmergelo, 0x16, 0x08, 0x00000000, PPC_SPE); ////
7078GEN_SPE(evmergehilo, evmergelohi, 0x17, 0x08, 0x00000000, PPC_SPE); ////
7079GEN_SPE(evcmpgtu, evcmpgts, 0x18, 0x08, 0x00600000, PPC_SPE); ////
7080GEN_SPE(evcmpltu, evcmplts, 0x19, 0x08, 0x00600000, PPC_SPE); ////
7081GEN_SPE(evcmpeq, speundef, 0x1A, 0x08, 0x00600000, PPC_SPE); ////
7082
7083/* SPE load and stores */
7084static always_inline void gen_addr_spe_imm_index (DisasContext *ctx, TCGv EA, int sh)
7085{
7086 target_ulong uimm = rB(ctx->opcode);
7087
7088 if (rA(ctx->opcode) == 0) {
7089 tcg_gen_movi_tl(EA, uimm << sh);
7090 } else {
7091 tcg_gen_addi_tl(EA, cpu_gpr[rA(ctx->opcode)], uimm << sh);
7092#if defined(TARGET_PPC64)
7093 if (!ctx->sf_mode) {
7094 tcg_gen_ext32u_tl(EA, EA);
7095 }
7096#endif
7097 }
7098}
7099
7100static always_inline void gen_op_evldd(DisasContext *ctx, TCGv addr)
7101{
7102#if defined(TARGET_PPC64)
7103 gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], addr);
7104#else
7105 TCGv_i64 t0 = tcg_temp_new_i64();
7106 gen_qemu_ld64(ctx, t0, addr);
7107 tcg_gen_trunc_i64_i32(cpu_gpr[rD(ctx->opcode)], t0);
7108 tcg_gen_shri_i64(t0, t0, 32);
7109 tcg_gen_trunc_i64_i32(cpu_gprh[rD(ctx->opcode)], t0);
7110 tcg_temp_free_i64(t0);
7111#endif
7112}
7113
7114static always_inline void gen_op_evldw(DisasContext *ctx, TCGv addr)
7115{
7116#if defined(TARGET_PPC64)
7117 TCGv t0 = tcg_temp_new();
7118 gen_qemu_ld32u(ctx, t0, addr);
7119 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 32);
7120 gen_addr_add(ctx, addr, addr, 4);
7121 gen_qemu_ld32u(ctx, t0, addr);
7122 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7123 tcg_temp_free(t0);
7124#else
7125 gen_qemu_ld32u(ctx, cpu_gprh[rD(ctx->opcode)], addr);
7126 gen_addr_add(ctx, addr, addr, 4);
7127 gen_qemu_ld32u(ctx, cpu_gpr[rD(ctx->opcode)], addr);
7128#endif
7129}
7130
7131static always_inline void gen_op_evldh(DisasContext *ctx, TCGv addr)
7132{
7133 TCGv t0 = tcg_temp_new();
7134#if defined(TARGET_PPC64)
7135 gen_qemu_ld16u(ctx, t0, addr);
7136 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 48);
7137 gen_addr_add(ctx, addr, addr, 2);
7138 gen_qemu_ld16u(ctx, t0, addr);
7139 tcg_gen_shli_tl(t0, t0, 32);
7140 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7141 gen_addr_add(ctx, addr, addr, 2);
7142 gen_qemu_ld16u(ctx, t0, addr);
7143 tcg_gen_shli_tl(t0, t0, 16);
7144 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7145 gen_addr_add(ctx, addr, addr, 2);
7146 gen_qemu_ld16u(ctx, t0, addr);
7147 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7148#else
7149 gen_qemu_ld16u(ctx, t0, addr);
7150 tcg_gen_shli_tl(cpu_gprh[rD(ctx->opcode)], t0, 16);
7151 gen_addr_add(ctx, addr, addr, 2);
7152 gen_qemu_ld16u(ctx, t0, addr);
7153 tcg_gen_or_tl(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rD(ctx->opcode)], t0);
7154 gen_addr_add(ctx, addr, addr, 2);
7155 gen_qemu_ld16u(ctx, t0, addr);
7156 tcg_gen_shli_tl(cpu_gprh[rD(ctx->opcode)], t0, 16);
7157 gen_addr_add(ctx, addr, addr, 2);
7158 gen_qemu_ld16u(ctx, t0, addr);
7159 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7160#endif
7161 tcg_temp_free(t0);
7162}
7163
7164static always_inline void gen_op_evlhhesplat(DisasContext *ctx, TCGv addr)
7165{
7166 TCGv t0 = tcg_temp_new();
7167 gen_qemu_ld16u(ctx, t0, addr);
7168#if defined(TARGET_PPC64)
7169 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 48);
7170 tcg_gen_shli_tl(t0, t0, 16);
7171 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7172#else
7173 tcg_gen_shli_tl(t0, t0, 16);
7174 tcg_gen_mov_tl(cpu_gprh[rD(ctx->opcode)], t0);
7175 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], t0);
7176#endif
7177 tcg_temp_free(t0);
7178}
7179
7180static always_inline void gen_op_evlhhousplat(DisasContext *ctx, TCGv addr)
7181{
7182 TCGv t0 = tcg_temp_new();
7183 gen_qemu_ld16u(ctx, t0, addr);
7184#if defined(TARGET_PPC64)
7185 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 32);
7186 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7187#else
7188 tcg_gen_mov_tl(cpu_gprh[rD(ctx->opcode)], t0);
7189 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], t0);
7190#endif
7191 tcg_temp_free(t0);
7192}
7193
7194static always_inline void gen_op_evlhhossplat(DisasContext *ctx, TCGv addr)
7195{
7196 TCGv t0 = tcg_temp_new();
7197 gen_qemu_ld16s(ctx, t0, addr);
7198#if defined(TARGET_PPC64)
7199 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 32);
7200 tcg_gen_ext32u_tl(t0, t0);
7201 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7202#else
7203 tcg_gen_mov_tl(cpu_gprh[rD(ctx->opcode)], t0);
7204 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], t0);
7205#endif
7206 tcg_temp_free(t0);
7207}
7208
7209static always_inline void gen_op_evlwhe(DisasContext *ctx, TCGv addr)
7210{
7211 TCGv t0 = tcg_temp_new();
7212#if defined(TARGET_PPC64)
7213 gen_qemu_ld16u(ctx, t0, addr);
7214 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 48);
7215 gen_addr_add(ctx, addr, addr, 2);
7216 gen_qemu_ld16u(ctx, t0, addr);
7217 tcg_gen_shli_tl(t0, t0, 16);
7218 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7219#else
7220 gen_qemu_ld16u(ctx, t0, addr);
7221 tcg_gen_shli_tl(cpu_gprh[rD(ctx->opcode)], t0, 16);
7222 gen_addr_add(ctx, addr, addr, 2);
7223 gen_qemu_ld16u(ctx, t0, addr);
7224 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 16);
7225#endif
7226 tcg_temp_free(t0);
7227}
7228
7229static always_inline void gen_op_evlwhou(DisasContext *ctx, TCGv addr)
7230{
7231#if defined(TARGET_PPC64)
7232 TCGv t0 = tcg_temp_new();
7233 gen_qemu_ld16u(ctx, cpu_gpr[rD(ctx->opcode)], addr);
7234 gen_addr_add(ctx, addr, addr, 2);
7235 gen_qemu_ld16u(ctx, t0, addr);
7236 tcg_gen_shli_tl(t0, t0, 32);
7237 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7238 tcg_temp_free(t0);
7239#else
7240 gen_qemu_ld16u(ctx, cpu_gprh[rD(ctx->opcode)], addr);
7241 gen_addr_add(ctx, addr, addr, 2);
7242 gen_qemu_ld16u(ctx, cpu_gpr[rD(ctx->opcode)], addr);
7243#endif
7244}
7245
7246static always_inline void gen_op_evlwhos(DisasContext *ctx, TCGv addr)
7247{
7248#if defined(TARGET_PPC64)
7249 TCGv t0 = tcg_temp_new();
7250 gen_qemu_ld16s(ctx, t0, addr);
7251 tcg_gen_ext32u_tl(cpu_gpr[rD(ctx->opcode)], t0);
7252 gen_addr_add(ctx, addr, addr, 2);
7253 gen_qemu_ld16s(ctx, t0, addr);
7254 tcg_gen_shli_tl(t0, t0, 32);
7255 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7256 tcg_temp_free(t0);
7257#else
7258 gen_qemu_ld16s(ctx, cpu_gprh[rD(ctx->opcode)], addr);
7259 gen_addr_add(ctx, addr, addr, 2);
7260 gen_qemu_ld16s(ctx, cpu_gpr[rD(ctx->opcode)], addr);
7261#endif
7262}
7263
7264static always_inline void gen_op_evlwwsplat(DisasContext *ctx, TCGv addr)
7265{
7266 TCGv t0 = tcg_temp_new();
7267 gen_qemu_ld32u(ctx, t0, addr);
7268#if defined(TARGET_PPC64)
7269 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 32);
7270 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7271#else
7272 tcg_gen_mov_tl(cpu_gprh[rD(ctx->opcode)], t0);
7273 tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], t0);
7274#endif
7275 tcg_temp_free(t0);
7276}
7277
7278static always_inline void gen_op_evlwhsplat(DisasContext *ctx, TCGv addr)
7279{
7280 TCGv t0 = tcg_temp_new();
7281#if defined(TARGET_PPC64)
7282 gen_qemu_ld16u(ctx, t0, addr);
7283 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 48);
7284 tcg_gen_shli_tl(t0, t0, 32);
7285 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7286 gen_addr_add(ctx, addr, addr, 2);
7287 gen_qemu_ld16u(ctx, t0, addr);
7288 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7289 tcg_gen_shli_tl(t0, t0, 16);
7290 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t0);
7291#else
7292 gen_qemu_ld16u(ctx, t0, addr);
7293 tcg_gen_shli_tl(cpu_gprh[rD(ctx->opcode)], t0, 16);
7294 tcg_gen_or_tl(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rD(ctx->opcode)], t0);
7295 gen_addr_add(ctx, addr, addr, 2);
7296 gen_qemu_ld16u(ctx, t0, addr);
7297 tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)], t0, 16);
7298 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gprh[rD(ctx->opcode)], t0);
7299#endif
7300 tcg_temp_free(t0);
7301}
7302
7303static always_inline void gen_op_evstdd(DisasContext *ctx, TCGv addr)
7304{
7305#if defined(TARGET_PPC64)
7306 gen_qemu_st64(ctx, cpu_gpr[rS(ctx->opcode)], addr);
7307#else
7308 TCGv_i64 t0 = tcg_temp_new_i64();
7309 tcg_gen_concat_i32_i64(t0, cpu_gpr[rS(ctx->opcode)], cpu_gprh[rS(ctx->opcode)]);
7310 gen_qemu_st64(ctx, t0, addr);
7311 tcg_temp_free_i64(t0);
7312#endif
7313}
7314
7315static always_inline void gen_op_evstdw(DisasContext *ctx, TCGv addr)
7316{
7317#if defined(TARGET_PPC64)
7318 TCGv t0 = tcg_temp_new();
7319 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 32);
7320 gen_qemu_st32(ctx, t0, addr);
7321 tcg_temp_free(t0);
7322#else
7323 gen_qemu_st32(ctx, cpu_gprh[rS(ctx->opcode)], addr);
7324#endif
7325 gen_addr_add(ctx, addr, addr, 4);
7326 gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], addr);
7327}
7328
7329static always_inline void gen_op_evstdh(DisasContext *ctx, TCGv addr)
7330{
7331 TCGv t0 = tcg_temp_new();
7332#if defined(TARGET_PPC64)
7333 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 48);
7334#else
7335 tcg_gen_shri_tl(t0, cpu_gprh[rS(ctx->opcode)], 16);
7336#endif
7337 gen_qemu_st16(ctx, t0, addr);
7338 gen_addr_add(ctx, addr, addr, 2);
7339#if defined(TARGET_PPC64)
7340 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 32);
7341 gen_qemu_st16(ctx, t0, addr);
7342#else
7343 gen_qemu_st16(ctx, cpu_gprh[rS(ctx->opcode)], addr);
7344#endif
7345 gen_addr_add(ctx, addr, addr, 2);
7346 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 16);
7347 gen_qemu_st16(ctx, t0, addr);
7348 tcg_temp_free(t0);
7349 gen_addr_add(ctx, addr, addr, 2);
7350 gen_qemu_st16(ctx, cpu_gpr[rS(ctx->opcode)], addr);
7351}
7352
7353static always_inline void gen_op_evstwhe(DisasContext *ctx, TCGv addr)
7354{
7355 TCGv t0 = tcg_temp_new();
7356#if defined(TARGET_PPC64)
7357 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 48);
7358#else
7359 tcg_gen_shri_tl(t0, cpu_gprh[rS(ctx->opcode)], 16);
7360#endif
7361 gen_qemu_st16(ctx, t0, addr);
7362 gen_addr_add(ctx, addr, addr, 2);
7363 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 16);
7364 gen_qemu_st16(ctx, t0, addr);
7365 tcg_temp_free(t0);
7366}
7367
7368static always_inline void gen_op_evstwho(DisasContext *ctx, TCGv addr)
7369{
7370#if defined(TARGET_PPC64)
7371 TCGv t0 = tcg_temp_new();
7372 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 32);
7373 gen_qemu_st16(ctx, t0, addr);
7374 tcg_temp_free(t0);
7375#else
7376 gen_qemu_st16(ctx, cpu_gprh[rS(ctx->opcode)], addr);
7377#endif
7378 gen_addr_add(ctx, addr, addr, 2);
7379 gen_qemu_st16(ctx, cpu_gpr[rS(ctx->opcode)], addr);
7380}
7381
7382static always_inline void gen_op_evstwwe(DisasContext *ctx, TCGv addr)
7383{
7384#if defined(TARGET_PPC64)
7385 TCGv t0 = tcg_temp_new();
7386 tcg_gen_shri_tl(t0, cpu_gpr[rS(ctx->opcode)], 32);
7387 gen_qemu_st32(ctx, t0, addr);
7388 tcg_temp_free(t0);
7389#else
7390 gen_qemu_st32(ctx, cpu_gprh[rS(ctx->opcode)], addr);
7391#endif
7392}
7393
7394static always_inline void gen_op_evstwwo(DisasContext *ctx, TCGv addr)
7395{
7396 gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], addr);
7397}
7398
7399#define GEN_SPEOP_LDST(name, opc2, sh) \
7400static void glue(gen_, name)(DisasContext *ctx) \
7401{ \
7402 TCGv t0; \
7403 if (unlikely(!ctx->spe_enabled)) { \
7404 gen_exception(ctx, POWERPC_EXCP_APU); \
7405 return; \
7406 } \
7407 gen_set_access_type(ctx, ACCESS_INT); \
7408 t0 = tcg_temp_new(); \
7409 if (Rc(ctx->opcode)) { \
7410 gen_addr_spe_imm_index(ctx, t0, sh); \
7411 } else { \
7412 gen_addr_reg_index(ctx, t0); \
7413 } \
7414 gen_op_##name(ctx, t0); \
7415 tcg_temp_free(t0); \
7416}
7417
7418GEN_SPEOP_LDST(evldd, 0x00, 3);
7419GEN_SPEOP_LDST(evldw, 0x01, 3);
7420GEN_SPEOP_LDST(evldh, 0x02, 3);
7421GEN_SPEOP_LDST(evlhhesplat, 0x04, 1);
7422GEN_SPEOP_LDST(evlhhousplat, 0x06, 1);
7423GEN_SPEOP_LDST(evlhhossplat, 0x07, 1);
7424GEN_SPEOP_LDST(evlwhe, 0x08, 2);
7425GEN_SPEOP_LDST(evlwhou, 0x0A, 2);
7426GEN_SPEOP_LDST(evlwhos, 0x0B, 2);
7427GEN_SPEOP_LDST(evlwwsplat, 0x0C, 2);
7428GEN_SPEOP_LDST(evlwhsplat, 0x0E, 2);
7429
7430GEN_SPEOP_LDST(evstdd, 0x10, 3);
7431GEN_SPEOP_LDST(evstdw, 0x11, 3);
7432GEN_SPEOP_LDST(evstdh, 0x12, 3);
7433GEN_SPEOP_LDST(evstwhe, 0x18, 2);
7434GEN_SPEOP_LDST(evstwho, 0x1A, 2);
7435GEN_SPEOP_LDST(evstwwe, 0x1C, 2);
7436GEN_SPEOP_LDST(evstwwo, 0x1E, 2);
7437
7438/* Multiply and add - TODO */
7439#if 0
7440GEN_SPE(speundef, evmhessf, 0x01, 0x10, 0x00000000, PPC_SPE);
7441GEN_SPE(speundef, evmhossf, 0x03, 0x10, 0x00000000, PPC_SPE);
7442GEN_SPE(evmheumi, evmhesmi, 0x04, 0x10, 0x00000000, PPC_SPE);
7443GEN_SPE(speundef, evmhesmf, 0x05, 0x10, 0x00000000, PPC_SPE);
7444GEN_SPE(evmhoumi, evmhosmi, 0x06, 0x10, 0x00000000, PPC_SPE);
7445GEN_SPE(speundef, evmhosmf, 0x07, 0x10, 0x00000000, PPC_SPE);
7446GEN_SPE(speundef, evmhessfa, 0x11, 0x10, 0x00000000, PPC_SPE);
7447GEN_SPE(speundef, evmhossfa, 0x13, 0x10, 0x00000000, PPC_SPE);
7448GEN_SPE(evmheumia, evmhesmia, 0x14, 0x10, 0x00000000, PPC_SPE);
7449GEN_SPE(speundef, evmhesmfa, 0x15, 0x10, 0x00000000, PPC_SPE);
7450GEN_SPE(evmhoumia, evmhosmia, 0x16, 0x10, 0x00000000, PPC_SPE);
7451GEN_SPE(speundef, evmhosmfa, 0x17, 0x10, 0x00000000, PPC_SPE);
7452
7453GEN_SPE(speundef, evmwhssf, 0x03, 0x11, 0x00000000, PPC_SPE);
7454GEN_SPE(evmwlumi, speundef, 0x04, 0x11, 0x00000000, PPC_SPE);
7455GEN_SPE(evmwhumi, evmwhsmi, 0x06, 0x11, 0x00000000, PPC_SPE);
7456GEN_SPE(speundef, evmwhsmf, 0x07, 0x11, 0x00000000, PPC_SPE);
7457GEN_SPE(speundef, evmwssf, 0x09, 0x11, 0x00000000, PPC_SPE);
7458GEN_SPE(evmwumi, evmwsmi, 0x0C, 0x11, 0x00000000, PPC_SPE);
7459GEN_SPE(speundef, evmwsmf, 0x0D, 0x11, 0x00000000, PPC_SPE);
7460GEN_SPE(speundef, evmwhssfa, 0x13, 0x11, 0x00000000, PPC_SPE);
7461GEN_SPE(evmwlumia, speundef, 0x14, 0x11, 0x00000000, PPC_SPE);
7462GEN_SPE(evmwhumia, evmwhsmia, 0x16, 0x11, 0x00000000, PPC_SPE);
7463GEN_SPE(speundef, evmwhsmfa, 0x17, 0x11, 0x00000000, PPC_SPE);
7464GEN_SPE(speundef, evmwssfa, 0x19, 0x11, 0x00000000, PPC_SPE);
7465GEN_SPE(evmwumia, evmwsmia, 0x1C, 0x11, 0x00000000, PPC_SPE);
7466GEN_SPE(speundef, evmwsmfa, 0x1D, 0x11, 0x00000000, PPC_SPE);
7467
7468GEN_SPE(evadduiaaw, evaddsiaaw, 0x00, 0x13, 0x0000F800, PPC_SPE);
7469GEN_SPE(evsubfusiaaw, evsubfssiaaw, 0x01, 0x13, 0x0000F800, PPC_SPE);
7470GEN_SPE(evaddumiaaw, evaddsmiaaw, 0x04, 0x13, 0x0000F800, PPC_SPE);
7471GEN_SPE(evsubfumiaaw, evsubfsmiaaw, 0x05, 0x13, 0x0000F800, PPC_SPE);
7472GEN_SPE(evdivws, evdivwu, 0x06, 0x13, 0x00000000, PPC_SPE);
7473GEN_SPE(evmra, speundef, 0x07, 0x13, 0x0000F800, PPC_SPE);
7474
7475GEN_SPE(evmheusiaaw, evmhessiaaw, 0x00, 0x14, 0x00000000, PPC_SPE);
7476GEN_SPE(speundef, evmhessfaaw, 0x01, 0x14, 0x00000000, PPC_SPE);
7477GEN_SPE(evmhousiaaw, evmhossiaaw, 0x02, 0x14, 0x00000000, PPC_SPE);
7478GEN_SPE(speundef, evmhossfaaw, 0x03, 0x14, 0x00000000, PPC_SPE);
7479GEN_SPE(evmheumiaaw, evmhesmiaaw, 0x04, 0x14, 0x00000000, PPC_SPE);
7480GEN_SPE(speundef, evmhesmfaaw, 0x05, 0x14, 0x00000000, PPC_SPE);
7481GEN_SPE(evmhoumiaaw, evmhosmiaaw, 0x06, 0x14, 0x00000000, PPC_SPE);
7482GEN_SPE(speundef, evmhosmfaaw, 0x07, 0x14, 0x00000000, PPC_SPE);
7483GEN_SPE(evmhegumiaa, evmhegsmiaa, 0x14, 0x14, 0x00000000, PPC_SPE);
7484GEN_SPE(speundef, evmhegsmfaa, 0x15, 0x14, 0x00000000, PPC_SPE);
7485GEN_SPE(evmhogumiaa, evmhogsmiaa, 0x16, 0x14, 0x00000000, PPC_SPE);
7486GEN_SPE(speundef, evmhogsmfaa, 0x17, 0x14, 0x00000000, PPC_SPE);
7487
7488GEN_SPE(evmwlusiaaw, evmwlssiaaw, 0x00, 0x15, 0x00000000, PPC_SPE);
7489GEN_SPE(evmwlumiaaw, evmwlsmiaaw, 0x04, 0x15, 0x00000000, PPC_SPE);
7490GEN_SPE(speundef, evmwssfaa, 0x09, 0x15, 0x00000000, PPC_SPE);
7491GEN_SPE(evmwumiaa, evmwsmiaa, 0x0C, 0x15, 0x00000000, PPC_SPE);
7492GEN_SPE(speundef, evmwsmfaa, 0x0D, 0x15, 0x00000000, PPC_SPE);
7493
7494GEN_SPE(evmheusianw, evmhessianw, 0x00, 0x16, 0x00000000, PPC_SPE);
7495GEN_SPE(speundef, evmhessfanw, 0x01, 0x16, 0x00000000, PPC_SPE);
7496GEN_SPE(evmhousianw, evmhossianw, 0x02, 0x16, 0x00000000, PPC_SPE);
7497GEN_SPE(speundef, evmhossfanw, 0x03, 0x16, 0x00000000, PPC_SPE);
7498GEN_SPE(evmheumianw, evmhesmianw, 0x04, 0x16, 0x00000000, PPC_SPE);
7499GEN_SPE(speundef, evmhesmfanw, 0x05, 0x16, 0x00000000, PPC_SPE);
7500GEN_SPE(evmhoumianw, evmhosmianw, 0x06, 0x16, 0x00000000, PPC_SPE);
7501GEN_SPE(speundef, evmhosmfanw, 0x07, 0x16, 0x00000000, PPC_SPE);
7502GEN_SPE(evmhegumian, evmhegsmian, 0x14, 0x16, 0x00000000, PPC_SPE);
7503GEN_SPE(speundef, evmhegsmfan, 0x15, 0x16, 0x00000000, PPC_SPE);
7504GEN_SPE(evmhigumian, evmhigsmian, 0x16, 0x16, 0x00000000, PPC_SPE);
7505GEN_SPE(speundef, evmhogsmfan, 0x17, 0x16, 0x00000000, PPC_SPE);
7506
7507GEN_SPE(evmwlusianw, evmwlssianw, 0x00, 0x17, 0x00000000, PPC_SPE);
7508GEN_SPE(evmwlumianw, evmwlsmianw, 0x04, 0x17, 0x00000000, PPC_SPE);
7509GEN_SPE(speundef, evmwssfan, 0x09, 0x17, 0x00000000, PPC_SPE);
7510GEN_SPE(evmwumian, evmwsmian, 0x0C, 0x17, 0x00000000, PPC_SPE);
7511GEN_SPE(speundef, evmwsmfan, 0x0D, 0x17, 0x00000000, PPC_SPE);
7512#endif
7513
7514/*** SPE floating-point extension ***/
7515#if defined(TARGET_PPC64)
7516#define GEN_SPEFPUOP_CONV_32_32(name) \
7517static always_inline void gen_##name (DisasContext *ctx) \
7518{ \
7519 TCGv_i32 t0; \
7520 TCGv t1; \
7521 t0 = tcg_temp_new_i32(); \
7522 tcg_gen_trunc_tl_i32(t0, cpu_gpr[rB(ctx->opcode)]); \
7523 gen_helper_##name(t0, t0); \
7524 t1 = tcg_temp_new(); \
7525 tcg_gen_extu_i32_tl(t1, t0); \
7526 tcg_temp_free_i32(t0); \
7527 tcg_gen_andi_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], \
7528 0xFFFFFFFF00000000ULL); \
7529 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t1); \
7530 tcg_temp_free(t1); \
7531}
7532#define GEN_SPEFPUOP_CONV_32_64(name) \
7533static always_inline void gen_##name (DisasContext *ctx) \
7534{ \
7535 TCGv_i32 t0; \
7536 TCGv t1; \
7537 t0 = tcg_temp_new_i32(); \
7538 gen_helper_##name(t0, cpu_gpr[rB(ctx->opcode)]); \
7539 t1 = tcg_temp_new(); \
7540 tcg_gen_extu_i32_tl(t1, t0); \
7541 tcg_temp_free_i32(t0); \
7542 tcg_gen_andi_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], \
7543 0xFFFFFFFF00000000ULL); \
7544 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t1); \
7545 tcg_temp_free(t1); \
7546}
7547#define GEN_SPEFPUOP_CONV_64_32(name) \
7548static always_inline void gen_##name (DisasContext *ctx) \
7549{ \
7550 TCGv_i32 t0 = tcg_temp_new_i32(); \
7551 tcg_gen_trunc_tl_i32(t0, cpu_gpr[rB(ctx->opcode)]); \
7552 gen_helper_##name(cpu_gpr[rD(ctx->opcode)], t0); \
7553 tcg_temp_free_i32(t0); \
7554}
7555#define GEN_SPEFPUOP_CONV_64_64(name) \
7556static always_inline void gen_##name (DisasContext *ctx) \
7557{ \
7558 gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); \
7559}
7560#define GEN_SPEFPUOP_ARITH2_32_32(name) \
7561static always_inline void gen_##name (DisasContext *ctx) \
7562{ \
7563 TCGv_i32 t0, t1; \
7564 TCGv_i64 t2; \
7565 if (unlikely(!ctx->spe_enabled)) { \
7566 gen_exception(ctx, POWERPC_EXCP_APU); \
7567 return; \
7568 } \
7569 t0 = tcg_temp_new_i32(); \
7570 t1 = tcg_temp_new_i32(); \
7571 tcg_gen_trunc_tl_i32(t0, cpu_gpr[rA(ctx->opcode)]); \
7572 tcg_gen_trunc_tl_i32(t1, cpu_gpr[rB(ctx->opcode)]); \
7573 gen_helper_##name(t0, t0, t1); \
7574 tcg_temp_free_i32(t1); \
7575 t2 = tcg_temp_new(); \
7576 tcg_gen_extu_i32_tl(t2, t0); \
7577 tcg_temp_free_i32(t0); \
7578 tcg_gen_andi_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], \
7579 0xFFFFFFFF00000000ULL); \
7580 tcg_gen_or_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rD(ctx->opcode)], t2); \
7581 tcg_temp_free(t2); \
7582}
7583#define GEN_SPEFPUOP_ARITH2_64_64(name) \
7584static always_inline void gen_##name (DisasContext *ctx) \
7585{ \
7586 if (unlikely(!ctx->spe_enabled)) { \
7587 gen_exception(ctx, POWERPC_EXCP_APU); \
7588 return; \
7589 } \
7590 gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], \
7591 cpu_gpr[rB(ctx->opcode)]); \
7592}
7593#define GEN_SPEFPUOP_COMP_32(name) \
7594static always_inline void gen_##name (DisasContext *ctx) \
7595{ \
7596 TCGv_i32 t0, t1; \
7597 if (unlikely(!ctx->spe_enabled)) { \
7598 gen_exception(ctx, POWERPC_EXCP_APU); \
7599 return; \
7600 } \
7601 t0 = tcg_temp_new_i32(); \
7602 t1 = tcg_temp_new_i32(); \
7603 tcg_gen_trunc_tl_i32(t0, cpu_gpr[rA(ctx->opcode)]); \
7604 tcg_gen_trunc_tl_i32(t1, cpu_gpr[rB(ctx->opcode)]); \
7605 gen_helper_##name(cpu_crf[crfD(ctx->opcode)], t0, t1); \
7606 tcg_temp_free_i32(t0); \
7607 tcg_temp_free_i32(t1); \
7608}
7609#define GEN_SPEFPUOP_COMP_64(name) \
7610static always_inline void gen_##name (DisasContext *ctx) \
7611{ \
7612 if (unlikely(!ctx->spe_enabled)) { \
7613 gen_exception(ctx, POWERPC_EXCP_APU); \
7614 return; \
7615 } \
7616 gen_helper_##name(cpu_crf[crfD(ctx->opcode)], \
7617 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); \
7618}
7619#else
7620#define GEN_SPEFPUOP_CONV_32_32(name) \
7621static always_inline void gen_##name (DisasContext *ctx) \
7622{ \
7623 gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); \
7624}
7625#define GEN_SPEFPUOP_CONV_32_64(name) \
7626static always_inline void gen_##name (DisasContext *ctx) \
7627{ \
7628 TCGv_i64 t0 = tcg_temp_new_i64(); \
7629 gen_load_gpr64(t0, rB(ctx->opcode)); \
7630 gen_helper_##name(cpu_gpr[rD(ctx->opcode)], t0); \
7631 tcg_temp_free_i64(t0); \
7632}
7633#define GEN_SPEFPUOP_CONV_64_32(name) \
7634static always_inline void gen_##name (DisasContext *ctx) \
7635{ \
7636 TCGv_i64 t0 = tcg_temp_new_i64(); \
7637 gen_helper_##name(t0, cpu_gpr[rB(ctx->opcode)]); \
7638 gen_store_gpr64(rD(ctx->opcode), t0); \
7639 tcg_temp_free_i64(t0); \
7640}
7641#define GEN_SPEFPUOP_CONV_64_64(name) \
7642static always_inline void gen_##name (DisasContext *ctx) \
7643{ \
7644 TCGv_i64 t0 = tcg_temp_new_i64(); \
7645 gen_load_gpr64(t0, rB(ctx->opcode)); \
7646 gen_helper_##name(t0, t0); \
7647 gen_store_gpr64(rD(ctx->opcode), t0); \
7648 tcg_temp_free_i64(t0); \
7649}
7650#define GEN_SPEFPUOP_ARITH2_32_32(name) \
7651static always_inline void gen_##name (DisasContext *ctx) \
7652{ \
7653 if (unlikely(!ctx->spe_enabled)) { \
7654 gen_exception(ctx, POWERPC_EXCP_APU); \
7655 return; \
7656 } \
7657 gen_helper_##name(cpu_gpr[rD(ctx->opcode)], \
7658 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); \
7659}
7660#define GEN_SPEFPUOP_ARITH2_64_64(name) \
7661static always_inline void gen_##name (DisasContext *ctx) \
7662{ \
7663 TCGv_i64 t0, t1; \
7664 if (unlikely(!ctx->spe_enabled)) { \
7665 gen_exception(ctx, POWERPC_EXCP_APU); \
7666 return; \
7667 } \
7668 t0 = tcg_temp_new_i64(); \
7669 t1 = tcg_temp_new_i64(); \
7670 gen_load_gpr64(t0, rA(ctx->opcode)); \
7671 gen_load_gpr64(t1, rB(ctx->opcode)); \
7672 gen_helper_##name(t0, t0, t1); \
7673 gen_store_gpr64(rD(ctx->opcode), t0); \
7674 tcg_temp_free_i64(t0); \
7675 tcg_temp_free_i64(t1); \
7676}
7677#define GEN_SPEFPUOP_COMP_32(name) \
7678static always_inline void gen_##name (DisasContext *ctx) \
7679{ \
7680 if (unlikely(!ctx->spe_enabled)) { \
7681 gen_exception(ctx, POWERPC_EXCP_APU); \
7682 return; \
7683 } \
7684 gen_helper_##name(cpu_crf[crfD(ctx->opcode)], \
7685 cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); \
7686}
7687#define GEN_SPEFPUOP_COMP_64(name) \
7688static always_inline void gen_##name (DisasContext *ctx) \
7689{ \
7690 TCGv_i64 t0, t1; \
7691 if (unlikely(!ctx->spe_enabled)) { \
7692 gen_exception(ctx, POWERPC_EXCP_APU); \
7693 return; \
7694 } \
7695 t0 = tcg_temp_new_i64(); \
7696 t1 = tcg_temp_new_i64(); \
7697 gen_load_gpr64(t0, rA(ctx->opcode)); \
7698 gen_load_gpr64(t1, rB(ctx->opcode)); \
7699 gen_helper_##name(cpu_crf[crfD(ctx->opcode)], t0, t1); \
7700 tcg_temp_free_i64(t0); \
7701 tcg_temp_free_i64(t1); \
7702}
7703#endif
7704
7705/* Single precision floating-point vectors operations */
7706/* Arithmetic */
7707GEN_SPEFPUOP_ARITH2_64_64(evfsadd);
7708GEN_SPEFPUOP_ARITH2_64_64(evfssub);
7709GEN_SPEFPUOP_ARITH2_64_64(evfsmul);
7710GEN_SPEFPUOP_ARITH2_64_64(evfsdiv);
7711static always_inline void gen_evfsabs (DisasContext *ctx)
7712{
7713 if (unlikely(!ctx->spe_enabled)) {
7714 gen_exception(ctx, POWERPC_EXCP_APU);
7715 return;
7716 }
7717#if defined(TARGET_PPC64)
7718 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], ~0x8000000080000000LL);
7719#else
7720 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], ~0x80000000);
7721 tcg_gen_andi_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], ~0x80000000);
7722#endif
7723}
7724static always_inline void gen_evfsnabs (DisasContext *ctx)
7725{
7726 if (unlikely(!ctx->spe_enabled)) {
7727 gen_exception(ctx, POWERPC_EXCP_APU);
7728 return;
7729 }
7730#if defined(TARGET_PPC64)
7731 tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x8000000080000000LL);
7732#else
7733 tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);
7734 tcg_gen_ori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);
7735#endif
7736}
7737static always_inline void gen_evfsneg (DisasContext *ctx)
7738{
7739 if (unlikely(!ctx->spe_enabled)) {
7740 gen_exception(ctx, POWERPC_EXCP_APU);
7741 return;
7742 }
7743#if defined(TARGET_PPC64)
7744 tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x8000000080000000LL);
7745#else
7746 tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);
7747 tcg_gen_xori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);
7748#endif
7749}
7750
7751/* Conversion */
7752GEN_SPEFPUOP_CONV_64_64(evfscfui);
7753GEN_SPEFPUOP_CONV_64_64(evfscfsi);
7754GEN_SPEFPUOP_CONV_64_64(evfscfuf);
7755GEN_SPEFPUOP_CONV_64_64(evfscfsf);
7756GEN_SPEFPUOP_CONV_64_64(evfsctui);
7757GEN_SPEFPUOP_CONV_64_64(evfsctsi);
7758GEN_SPEFPUOP_CONV_64_64(evfsctuf);
7759GEN_SPEFPUOP_CONV_64_64(evfsctsf);
7760GEN_SPEFPUOP_CONV_64_64(evfsctuiz);
7761GEN_SPEFPUOP_CONV_64_64(evfsctsiz);
7762
7763/* Comparison */
7764GEN_SPEFPUOP_COMP_64(evfscmpgt);
7765GEN_SPEFPUOP_COMP_64(evfscmplt);
7766GEN_SPEFPUOP_COMP_64(evfscmpeq);
7767GEN_SPEFPUOP_COMP_64(evfststgt);
7768GEN_SPEFPUOP_COMP_64(evfststlt);
7769GEN_SPEFPUOP_COMP_64(evfststeq);
7770
7771/* Opcodes definitions */
7772GEN_SPE(evfsadd, evfssub, 0x00, 0x0A, 0x00000000, PPC_SPE_SINGLE); //
7773GEN_SPE(evfsabs, evfsnabs, 0x02, 0x0A, 0x0000F800, PPC_SPE_SINGLE); //
7774GEN_SPE(evfsneg, speundef, 0x03, 0x0A, 0x0000F800, PPC_SPE_SINGLE); //
7775GEN_SPE(evfsmul, evfsdiv, 0x04, 0x0A, 0x00000000, PPC_SPE_SINGLE); //
7776GEN_SPE(evfscmpgt, evfscmplt, 0x06, 0x0A, 0x00600000, PPC_SPE_SINGLE); //
7777GEN_SPE(evfscmpeq, speundef, 0x07, 0x0A, 0x00600000, PPC_SPE_SINGLE); //
7778GEN_SPE(evfscfui, evfscfsi, 0x08, 0x0A, 0x00180000, PPC_SPE_SINGLE); //
7779GEN_SPE(evfscfuf, evfscfsf, 0x09, 0x0A, 0x00180000, PPC_SPE_SINGLE); //
7780GEN_SPE(evfsctui, evfsctsi, 0x0A, 0x0A, 0x00180000, PPC_SPE_SINGLE); //
7781GEN_SPE(evfsctuf, evfsctsf, 0x0B, 0x0A, 0x00180000, PPC_SPE_SINGLE); //
7782GEN_SPE(evfsctuiz, speundef, 0x0C, 0x0A, 0x00180000, PPC_SPE_SINGLE); //
7783GEN_SPE(evfsctsiz, speundef, 0x0D, 0x0A, 0x00180000, PPC_SPE_SINGLE); //
7784GEN_SPE(evfststgt, evfststlt, 0x0E, 0x0A, 0x00600000, PPC_SPE_SINGLE); //
7785GEN_SPE(evfststeq, speundef, 0x0F, 0x0A, 0x00600000, PPC_SPE_SINGLE); //
7786
7787/* Single precision floating-point operations */
7788/* Arithmetic */
7789GEN_SPEFPUOP_ARITH2_32_32(efsadd);
7790GEN_SPEFPUOP_ARITH2_32_32(efssub);
7791GEN_SPEFPUOP_ARITH2_32_32(efsmul);
7792GEN_SPEFPUOP_ARITH2_32_32(efsdiv);
7793static always_inline void gen_efsabs (DisasContext *ctx)
7794{
7795 if (unlikely(!ctx->spe_enabled)) {
7796 gen_exception(ctx, POWERPC_EXCP_APU);
7797 return;
7798 }
7799 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], (target_long)~0x80000000LL);
7800}
7801static always_inline void gen_efsnabs (DisasContext *ctx)
7802{
7803 if (unlikely(!ctx->spe_enabled)) {
7804 gen_exception(ctx, POWERPC_EXCP_APU);
7805 return;
7806 }
7807 tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);
7808}
7809static always_inline void gen_efsneg (DisasContext *ctx)
7810{
7811 if (unlikely(!ctx->spe_enabled)) {
7812 gen_exception(ctx, POWERPC_EXCP_APU);
7813 return;
7814 }
7815 tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);
7816}
7817
7818/* Conversion */
7819GEN_SPEFPUOP_CONV_32_32(efscfui);
7820GEN_SPEFPUOP_CONV_32_32(efscfsi);
7821GEN_SPEFPUOP_CONV_32_32(efscfuf);
7822GEN_SPEFPUOP_CONV_32_32(efscfsf);
7823GEN_SPEFPUOP_CONV_32_32(efsctui);
7824GEN_SPEFPUOP_CONV_32_32(efsctsi);
7825GEN_SPEFPUOP_CONV_32_32(efsctuf);
7826GEN_SPEFPUOP_CONV_32_32(efsctsf);
7827GEN_SPEFPUOP_CONV_32_32(efsctuiz);
7828GEN_SPEFPUOP_CONV_32_32(efsctsiz);
7829GEN_SPEFPUOP_CONV_32_64(efscfd);
7830
7831/* Comparison */
7832GEN_SPEFPUOP_COMP_32(efscmpgt);
7833GEN_SPEFPUOP_COMP_32(efscmplt);
7834GEN_SPEFPUOP_COMP_32(efscmpeq);
7835GEN_SPEFPUOP_COMP_32(efststgt);
7836GEN_SPEFPUOP_COMP_32(efststlt);
7837GEN_SPEFPUOP_COMP_32(efststeq);
7838
7839/* Opcodes definitions */
7840GEN_SPE(efsadd, efssub, 0x00, 0x0B, 0x00000000, PPC_SPE_SINGLE); //
7841GEN_SPE(efsabs, efsnabs, 0x02, 0x0B, 0x0000F800, PPC_SPE_SINGLE); //
7842GEN_SPE(efsneg, speundef, 0x03, 0x0B, 0x0000F800, PPC_SPE_SINGLE); //
7843GEN_SPE(efsmul, efsdiv, 0x04, 0x0B, 0x00000000, PPC_SPE_SINGLE); //
7844GEN_SPE(efscmpgt, efscmplt, 0x06, 0x0B, 0x00600000, PPC_SPE_SINGLE); //
7845GEN_SPE(efscmpeq, efscfd, 0x07, 0x0B, 0x00600000, PPC_SPE_SINGLE); //
7846GEN_SPE(efscfui, efscfsi, 0x08, 0x0B, 0x00180000, PPC_SPE_SINGLE); //
7847GEN_SPE(efscfuf, efscfsf, 0x09, 0x0B, 0x00180000, PPC_SPE_SINGLE); //
7848GEN_SPE(efsctui, efsctsi, 0x0A, 0x0B, 0x00180000, PPC_SPE_SINGLE); //
7849GEN_SPE(efsctuf, efsctsf, 0x0B, 0x0B, 0x00180000, PPC_SPE_SINGLE); //
7850GEN_SPE(efsctuiz, speundef, 0x0C, 0x0B, 0x00180000, PPC_SPE_SINGLE); //
7851GEN_SPE(efsctsiz, speundef, 0x0D, 0x0B, 0x00180000, PPC_SPE_SINGLE); //
7852GEN_SPE(efststgt, efststlt, 0x0E, 0x0B, 0x00600000, PPC_SPE_SINGLE); //
7853GEN_SPE(efststeq, speundef, 0x0F, 0x0B, 0x00600000, PPC_SPE_SINGLE); //
7854
7855/* Double precision floating-point operations */
7856/* Arithmetic */
7857GEN_SPEFPUOP_ARITH2_64_64(efdadd);
7858GEN_SPEFPUOP_ARITH2_64_64(efdsub);
7859GEN_SPEFPUOP_ARITH2_64_64(efdmul);
7860GEN_SPEFPUOP_ARITH2_64_64(efddiv);
7861static always_inline void gen_efdabs (DisasContext *ctx)
7862{
7863 if (unlikely(!ctx->spe_enabled)) {
7864 gen_exception(ctx, POWERPC_EXCP_APU);
7865 return;
7866 }
7867#if defined(TARGET_PPC64)
7868 tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], ~0x8000000000000000LL);
7869#else
7870 tcg_gen_andi_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], ~0x80000000);
7871#endif
7872}
7873static always_inline void gen_efdnabs (DisasContext *ctx)
7874{
7875 if (unlikely(!ctx->spe_enabled)) {
7876 gen_exception(ctx, POWERPC_EXCP_APU);
7877 return;
7878 }
7879#if defined(TARGET_PPC64)
7880 tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x8000000000000000LL);
7881#else
7882 tcg_gen_ori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);
7883#endif
7884}
7885static always_inline void gen_efdneg (DisasContext *ctx)
7886{
7887 if (unlikely(!ctx->spe_enabled)) {
7888 gen_exception(ctx, POWERPC_EXCP_APU);
7889 return;
7890 }
7891#if defined(TARGET_PPC64)
7892 tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x8000000000000000LL);
7893#else
7894 tcg_gen_xori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);
7895#endif
7896}
7897
7898/* Conversion */
7899GEN_SPEFPUOP_CONV_64_32(efdcfui);
7900GEN_SPEFPUOP_CONV_64_32(efdcfsi);
7901GEN_SPEFPUOP_CONV_64_32(efdcfuf);
7902GEN_SPEFPUOP_CONV_64_32(efdcfsf);
7903GEN_SPEFPUOP_CONV_32_64(efdctui);
7904GEN_SPEFPUOP_CONV_32_64(efdctsi);
7905GEN_SPEFPUOP_CONV_32_64(efdctuf);
7906GEN_SPEFPUOP_CONV_32_64(efdctsf);
7907GEN_SPEFPUOP_CONV_32_64(efdctuiz);
7908GEN_SPEFPUOP_CONV_32_64(efdctsiz);
7909GEN_SPEFPUOP_CONV_64_32(efdcfs);
7910GEN_SPEFPUOP_CONV_64_64(efdcfuid);
7911GEN_SPEFPUOP_CONV_64_64(efdcfsid);
7912GEN_SPEFPUOP_CONV_64_64(efdctuidz);
7913GEN_SPEFPUOP_CONV_64_64(efdctsidz);
7914
7915/* Comparison */
7916GEN_SPEFPUOP_COMP_64(efdcmpgt);
7917GEN_SPEFPUOP_COMP_64(efdcmplt);
7918GEN_SPEFPUOP_COMP_64(efdcmpeq);
7919GEN_SPEFPUOP_COMP_64(efdtstgt);
7920GEN_SPEFPUOP_COMP_64(efdtstlt);
7921GEN_SPEFPUOP_COMP_64(efdtsteq);
7922
7923/* Opcodes definitions */
7924GEN_SPE(efdadd, efdsub, 0x10, 0x0B, 0x00000000, PPC_SPE_DOUBLE); //
7925GEN_SPE(efdcfuid, efdcfsid, 0x11, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7926GEN_SPE(efdabs, efdnabs, 0x12, 0x0B, 0x0000F800, PPC_SPE_DOUBLE); //
7927GEN_SPE(efdneg, speundef, 0x13, 0x0B, 0x0000F800, PPC_SPE_DOUBLE); //
7928GEN_SPE(efdmul, efddiv, 0x14, 0x0B, 0x00000000, PPC_SPE_DOUBLE); //
7929GEN_SPE(efdctuidz, efdctsidz, 0x15, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7930GEN_SPE(efdcmpgt, efdcmplt, 0x16, 0x0B, 0x00600000, PPC_SPE_DOUBLE); //
7931GEN_SPE(efdcmpeq, efdcfs, 0x17, 0x0B, 0x00600000, PPC_SPE_DOUBLE); //
7932GEN_SPE(efdcfui, efdcfsi, 0x18, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7933GEN_SPE(efdcfuf, efdcfsf, 0x19, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7934GEN_SPE(efdctui, efdctsi, 0x1A, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7935GEN_SPE(efdctuf, efdctsf, 0x1B, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7936GEN_SPE(efdctuiz, speundef, 0x1C, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7937GEN_SPE(efdctsiz, speundef, 0x1D, 0x0B, 0x00180000, PPC_SPE_DOUBLE); //
7938GEN_SPE(efdtstgt, efdtstlt, 0x1E, 0x0B, 0x00600000, PPC_SPE_DOUBLE); //
7939GEN_SPE(efdtsteq, speundef, 0x1F, 0x0B, 0x00600000, PPC_SPE_DOUBLE); //
7940
7941static opcode_t opcodes[] = {
7942GEN_HANDLER(invalid, 0x00, 0x00, 0x00, 0xFFFFFFFF, PPC_NONE),
7943GEN_HANDLER(cmp, 0x1F, 0x00, 0x00, 0x00400000, PPC_INTEGER),
7944GEN_HANDLER(cmpi, 0x0B, 0xFF, 0xFF, 0x00400000, PPC_INTEGER),
7945GEN_HANDLER(cmpl, 0x1F, 0x00, 0x01, 0x00400000, PPC_INTEGER),
7946GEN_HANDLER(cmpli, 0x0A, 0xFF, 0xFF, 0x00400000, PPC_INTEGER),
7947GEN_HANDLER(isel, 0x1F, 0x0F, 0xFF, 0x00000001, PPC_ISEL),
7948GEN_HANDLER(addi, 0x0E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7949GEN_HANDLER(addic, 0x0C, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7950GEN_HANDLER2(addic_, "addic.", 0x0D, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7951GEN_HANDLER(addis, 0x0F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7952GEN_HANDLER(mulhw, 0x1F, 0x0B, 0x02, 0x00000400, PPC_INTEGER),
7953GEN_HANDLER(mulhwu, 0x1F, 0x0B, 0x00, 0x00000400, PPC_INTEGER),
7954GEN_HANDLER(mullw, 0x1F, 0x0B, 0x07, 0x00000000, PPC_INTEGER),
7955GEN_HANDLER(mullwo, 0x1F, 0x0B, 0x17, 0x00000000, PPC_INTEGER),
7956GEN_HANDLER(mulli, 0x07, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7957#if defined(TARGET_PPC64)
7958GEN_HANDLER(mulld, 0x1F, 0x09, 0x07, 0x00000000, PPC_64B),
7959#endif
7960GEN_HANDLER(neg, 0x1F, 0x08, 0x03, 0x0000F800, PPC_INTEGER),
7961GEN_HANDLER(nego, 0x1F, 0x08, 0x13, 0x0000F800, PPC_INTEGER),
7962GEN_HANDLER(subfic, 0x08, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7963GEN_HANDLER2(andi_, "andi.", 0x1C, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7964GEN_HANDLER2(andis_, "andis.", 0x1D, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7965GEN_HANDLER(cntlzw, 0x1F, 0x1A, 0x00, 0x00000000, PPC_INTEGER),
7966GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER),
7967GEN_HANDLER(xor, 0x1F, 0x1C, 0x09, 0x00000000, PPC_INTEGER),
7968GEN_HANDLER(ori, 0x18, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7969GEN_HANDLER(oris, 0x19, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7970GEN_HANDLER(xori, 0x1A, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7971GEN_HANDLER(xoris, 0x1B, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7972GEN_HANDLER(popcntb, 0x1F, 0x03, 0x03, 0x0000F801, PPC_POPCNTB),
7973#if defined(TARGET_PPC64)
7974GEN_HANDLER(cntlzd, 0x1F, 0x1A, 0x01, 0x00000000, PPC_64B),
7975#endif
7976GEN_HANDLER(rlwimi, 0x14, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7977GEN_HANDLER(rlwinm, 0x15, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7978GEN_HANDLER(rlwnm, 0x17, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
7979GEN_HANDLER(slw, 0x1F, 0x18, 0x00, 0x00000000, PPC_INTEGER),
7980GEN_HANDLER(sraw, 0x1F, 0x18, 0x18, 0x00000000, PPC_INTEGER),
7981GEN_HANDLER(srawi, 0x1F, 0x18, 0x19, 0x00000000, PPC_INTEGER),
7982GEN_HANDLER(srw, 0x1F, 0x18, 0x10, 0x00000000, PPC_INTEGER),
7983#if defined(TARGET_PPC64)
7984GEN_HANDLER(sld, 0x1F, 0x1B, 0x00, 0x00000000, PPC_64B),
7985GEN_HANDLER(srad, 0x1F, 0x1A, 0x18, 0x00000000, PPC_64B),
7986GEN_HANDLER2(sradi0, "sradi", 0x1F, 0x1A, 0x19, 0x00000000, PPC_64B),
7987GEN_HANDLER2(sradi1, "sradi", 0x1F, 0x1B, 0x19, 0x00000000, PPC_64B),
7988GEN_HANDLER(srd, 0x1F, 0x1B, 0x10, 0x00000000, PPC_64B),
7989#endif
7990GEN_HANDLER(frsqrtes, 0x3B, 0x1A, 0xFF, 0x001F07C0, PPC_FLOAT_FRSQRTES),
7991GEN_HANDLER(fsqrt, 0x3F, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT),
7992GEN_HANDLER(fsqrts, 0x3B, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT),
7993GEN_HANDLER(fcmpo, 0x3F, 0x00, 0x01, 0x00600001, PPC_FLOAT),
7994GEN_HANDLER(fcmpu, 0x3F, 0x00, 0x00, 0x00600001, PPC_FLOAT),
7995GEN_HANDLER(fmr, 0x3F, 0x08, 0x02, 0x001F0000, PPC_FLOAT),
7996GEN_HANDLER(mcrfs, 0x3F, 0x00, 0x02, 0x0063F801, PPC_FLOAT),
7997GEN_HANDLER(mffs, 0x3F, 0x07, 0x12, 0x001FF800, PPC_FLOAT),
7998GEN_HANDLER(mtfsb0, 0x3F, 0x06, 0x02, 0x001FF800, PPC_FLOAT),
7999GEN_HANDLER(mtfsb1, 0x3F, 0x06, 0x01, 0x001FF800, PPC_FLOAT),
8000GEN_HANDLER(mtfsf, 0x3F, 0x07, 0x16, 0x00010000, PPC_FLOAT),
8001GEN_HANDLER(mtfsfi, 0x3F, 0x06, 0x04, 0x006f0800, PPC_FLOAT),
8002#if defined(TARGET_PPC64)
8003GEN_HANDLER(ld, 0x3A, 0xFF, 0xFF, 0x00000000, PPC_64B),
8004GEN_HANDLER(lq, 0x38, 0xFF, 0xFF, 0x00000000, PPC_64BX),
8005GEN_HANDLER(std, 0x3E, 0xFF, 0xFF, 0x00000000, PPC_64B),
8006#endif
8007GEN_HANDLER(lmw, 0x2E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
8008GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
8009GEN_HANDLER(lswi, 0x1F, 0x15, 0x12, 0x00000001, PPC_STRING),
8010GEN_HANDLER(lswx, 0x1F, 0x15, 0x10, 0x00000001, PPC_STRING),
8011GEN_HANDLER(stswi, 0x1F, 0x15, 0x16, 0x00000001, PPC_STRING),
8012GEN_HANDLER(stswx, 0x1F, 0x15, 0x14, 0x00000001, PPC_STRING),
8013GEN_HANDLER(eieio, 0x1F, 0x16, 0x1A, 0x03FFF801, PPC_MEM_EIEIO),
8014GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM),
8015GEN_HANDLER(lwarx, 0x1F, 0x14, 0x00, 0x00000001, PPC_RES),
8016GEN_HANDLER2(stwcx_, "stwcx.", 0x1F, 0x16, 0x04, 0x00000000, PPC_RES),
8017#if defined(TARGET_PPC64)
8018GEN_HANDLER(ldarx, 0x1F, 0x14, 0x02, 0x00000001, PPC_64B),
8019GEN_HANDLER2(stdcx_, "stdcx.", 0x1F, 0x16, 0x06, 0x00000000, PPC_64B),
8020#endif
8021GEN_HANDLER(sync, 0x1F, 0x16, 0x12, 0x039FF801, PPC_MEM_SYNC),
8022GEN_HANDLER(wait, 0x1F, 0x1E, 0x01, 0x03FFF801, PPC_WAIT),
8023GEN_HANDLER(b, 0x12, 0xFF, 0xFF, 0x00000000, PPC_FLOW),
8024GEN_HANDLER(bc, 0x10, 0xFF, 0xFF, 0x00000000, PPC_FLOW),
8025GEN_HANDLER(bcctr, 0x13, 0x10, 0x10, 0x00000000, PPC_FLOW),
8026GEN_HANDLER(bclr, 0x13, 0x10, 0x00, 0x00000000, PPC_FLOW),
8027GEN_HANDLER(mcrf, 0x13, 0x00, 0xFF, 0x00000001, PPC_INTEGER),
8028GEN_HANDLER(rfi, 0x13, 0x12, 0x01, 0x03FF8001, PPC_FLOW),
8029#if defined(TARGET_PPC64)
8030GEN_HANDLER(rfid, 0x13, 0x12, 0x00, 0x03FF8001, PPC_64B),
8031GEN_HANDLER(hrfid, 0x13, 0x12, 0x08, 0x03FF8001, PPC_64H),
8032#endif
8033GEN_HANDLER(sc, 0x11, 0xFF, 0xFF, 0x03FFF01D, PPC_FLOW),
8034GEN_HANDLER(tw, 0x1F, 0x04, 0x00, 0x00000001, PPC_FLOW),
8035GEN_HANDLER(twi, 0x03, 0xFF, 0xFF, 0x00000000, PPC_FLOW),
8036#if defined(TARGET_PPC64)
8037GEN_HANDLER(td, 0x1F, 0x04, 0x02, 0x00000001, PPC_64B),
8038GEN_HANDLER(tdi, 0x02, 0xFF, 0xFF, 0x00000000, PPC_64B),
8039#endif
8040GEN_HANDLER(mcrxr, 0x1F, 0x00, 0x10, 0x007FF801, PPC_MISC),
8041GEN_HANDLER(mfcr, 0x1F, 0x13, 0x00, 0x00000801, PPC_MISC),
8042GEN_HANDLER(mfmsr, 0x1F, 0x13, 0x02, 0x001FF801, PPC_MISC),
8043GEN_HANDLER(mfspr, 0x1F, 0x13, 0x0A, 0x00000001, PPC_MISC),
8044GEN_HANDLER(mftb, 0x1F, 0x13, 0x0B, 0x00000001, PPC_MFTB),
8045GEN_HANDLER(mtcrf, 0x1F, 0x10, 0x04, 0x00000801, PPC_MISC),
8046#if defined(TARGET_PPC64)
8047GEN_HANDLER(mtmsrd, 0x1F, 0x12, 0x05, 0x001EF801, PPC_64B),
8048#endif
8049GEN_HANDLER(mtmsr, 0x1F, 0x12, 0x04, 0x001FF801, PPC_MISC),
8050GEN_HANDLER(mtspr, 0x1F, 0x13, 0x0E, 0x00000001, PPC_MISC),
8051GEN_HANDLER(dcbf, 0x1F, 0x16, 0x02, 0x03C00001, PPC_CACHE),
8052GEN_HANDLER(dcbi, 0x1F, 0x16, 0x0E, 0x03E00001, PPC_CACHE),
8053GEN_HANDLER(dcbst, 0x1F, 0x16, 0x01, 0x03E00001, PPC_CACHE),
8054GEN_HANDLER(dcbt, 0x1F, 0x16, 0x08, 0x02000001, PPC_CACHE),
8055GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE),
8056GEN_HANDLER(dcbz, 0x1F, 0x16, 0x1F, 0x03E00001, PPC_CACHE_DCBZ),
8057GEN_HANDLER2(dcbz_970, "dcbz", 0x1F, 0x16, 0x1F, 0x03C00001, PPC_CACHE_DCBZT),
8058GEN_HANDLER(dst, 0x1F, 0x16, 0x0A, 0x01800001, PPC_ALTIVEC),
8059GEN_HANDLER(dstst, 0x1F, 0x16, 0x0B, 0x02000001, PPC_ALTIVEC),
8060GEN_HANDLER(dss, 0x1F, 0x16, 0x19, 0x019FF801, PPC_ALTIVEC),
8061GEN_HANDLER(icbi, 0x1F, 0x16, 0x1E, 0x03E00001, PPC_CACHE_ICBI),
8062GEN_HANDLER(dcba, 0x1F, 0x16, 0x17, 0x03E00001, PPC_CACHE_DCBA),
8063GEN_HANDLER(mfsr, 0x1F, 0x13, 0x12, 0x0010F801, PPC_SEGMENT),
8064GEN_HANDLER(mfsrin, 0x1F, 0x13, 0x14, 0x001F0001, PPC_SEGMENT),
8065GEN_HANDLER(mtsr, 0x1F, 0x12, 0x06, 0x0010F801, PPC_SEGMENT),
8066GEN_HANDLER(mtsrin, 0x1F, 0x12, 0x07, 0x001F0001, PPC_SEGMENT),
8067#if defined(TARGET_PPC64)
8068GEN_HANDLER2(mfsr_64b, "mfsr", 0x1F, 0x13, 0x12, 0x0010F801, PPC_SEGMENT_64B),
8069GEN_HANDLER2(mfsrin_64b, "mfsrin", 0x1F, 0x13, 0x14, 0x001F0001,
8070 PPC_SEGMENT_64B),
8071GEN_HANDLER2(mtsr_64b, "mtsr", 0x1F, 0x12, 0x06, 0x0010F801, PPC_SEGMENT_64B),
8072GEN_HANDLER2(mtsrin_64b, "mtsrin", 0x1F, 0x12, 0x07, 0x001F0001,
8073 PPC_SEGMENT_64B),
8074GEN_HANDLER2(slbmte, "slbmte", 0x1F, 0x12, 0x0C, 0x00000000, PPC_SEGMENT_64B),
8075#endif
8076GEN_HANDLER(tlbia, 0x1F, 0x12, 0x0B, 0x03FFFC01, PPC_MEM_TLBIA),
8077GEN_HANDLER(tlbiel, 0x1F, 0x12, 0x08, 0x03FF0001, PPC_MEM_TLBIE),
8078GEN_HANDLER(tlbie, 0x1F, 0x12, 0x09, 0x03FF0001, PPC_MEM_TLBIE),
8079GEN_HANDLER(tlbsync, 0x1F, 0x16, 0x11, 0x03FFF801, PPC_MEM_TLBSYNC),
8080#if defined(TARGET_PPC64)
8081GEN_HANDLER(slbia, 0x1F, 0x12, 0x0F, 0x03FFFC01, PPC_SLBI),
8082GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI),
8083#endif
8084GEN_HANDLER(eciwx, 0x1F, 0x16, 0x0D, 0x00000001, PPC_EXTERN),
8085GEN_HANDLER(ecowx, 0x1F, 0x16, 0x09, 0x00000001, PPC_EXTERN),
8086GEN_HANDLER(abs, 0x1F, 0x08, 0x0B, 0x0000F800, PPC_POWER_BR),
8087GEN_HANDLER(abso, 0x1F, 0x08, 0x1B, 0x0000F800, PPC_POWER_BR),
8088GEN_HANDLER(clcs, 0x1F, 0x10, 0x13, 0x0000F800, PPC_POWER_BR),
8089GEN_HANDLER(div, 0x1F, 0x0B, 0x0A, 0x00000000, PPC_POWER_BR),
8090GEN_HANDLER(divo, 0x1F, 0x0B, 0x1A, 0x00000000, PPC_POWER_BR),
8091GEN_HANDLER(divs, 0x1F, 0x0B, 0x0B, 0x00000000, PPC_POWER_BR),
8092GEN_HANDLER(divso, 0x1F, 0x0B, 0x1B, 0x00000000, PPC_POWER_BR),
8093GEN_HANDLER(doz, 0x1F, 0x08, 0x08, 0x00000000, PPC_POWER_BR),
8094GEN_HANDLER(dozo, 0x1F, 0x08, 0x18, 0x00000000, PPC_POWER_BR),
8095GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR),
8096GEN_HANDLER(lscbx, 0x1F, 0x15, 0x08, 0x00000000, PPC_POWER_BR),
8097GEN_HANDLER(maskg, 0x1F, 0x1D, 0x00, 0x00000000, PPC_POWER_BR),
8098GEN_HANDLER(maskir, 0x1F, 0x1D, 0x10, 0x00000000, PPC_POWER_BR),
8099GEN_HANDLER(mul, 0x1F, 0x0B, 0x03, 0x00000000, PPC_POWER_BR),
8100GEN_HANDLER(mulo, 0x1F, 0x0B, 0x13, 0x00000000, PPC_POWER_BR),
8101GEN_HANDLER(nabs, 0x1F, 0x08, 0x0F, 0x00000000, PPC_POWER_BR),
8102GEN_HANDLER(nabso, 0x1F, 0x08, 0x1F, 0x00000000, PPC_POWER_BR),
8103GEN_HANDLER(rlmi, 0x16, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR),
8104GEN_HANDLER(rrib, 0x1F, 0x19, 0x10, 0x00000000, PPC_POWER_BR),
8105GEN_HANDLER(sle, 0x1F, 0x19, 0x04, 0x00000000, PPC_POWER_BR),
8106GEN_HANDLER(sleq, 0x1F, 0x19, 0x06, 0x00000000, PPC_POWER_BR),
8107GEN_HANDLER(sliq, 0x1F, 0x18, 0x05, 0x00000000, PPC_POWER_BR),
8108GEN_HANDLER(slliq, 0x1F, 0x18, 0x07, 0x00000000, PPC_POWER_BR),
8109GEN_HANDLER(sllq, 0x1F, 0x18, 0x06, 0x00000000, PPC_POWER_BR),
8110GEN_HANDLER(slq, 0x1F, 0x18, 0x04, 0x00000000, PPC_POWER_BR),
8111GEN_HANDLER(sraiq, 0x1F, 0x18, 0x1D, 0x00000000, PPC_POWER_BR),
8112GEN_HANDLER(sraq, 0x1F, 0x18, 0x1C, 0x00000000, PPC_POWER_BR),
8113GEN_HANDLER(sre, 0x1F, 0x19, 0x14, 0x00000000, PPC_POWER_BR),
8114GEN_HANDLER(srea, 0x1F, 0x19, 0x1C, 0x00000000, PPC_POWER_BR),
8115GEN_HANDLER(sreq, 0x1F, 0x19, 0x16, 0x00000000, PPC_POWER_BR),
8116GEN_HANDLER(sriq, 0x1F, 0x18, 0x15, 0x00000000, PPC_POWER_BR),
8117GEN_HANDLER(srliq, 0x1F, 0x18, 0x17, 0x00000000, PPC_POWER_BR),
8118GEN_HANDLER(srlq, 0x1F, 0x18, 0x16, 0x00000000, PPC_POWER_BR),
8119GEN_HANDLER(srq, 0x1F, 0x18, 0x14, 0x00000000, PPC_POWER_BR),
8120GEN_HANDLER(dsa, 0x1F, 0x14, 0x13, 0x03FFF801, PPC_602_SPEC),
8121GEN_HANDLER(esa, 0x1F, 0x14, 0x12, 0x03FFF801, PPC_602_SPEC),
8122GEN_HANDLER(mfrom, 0x1F, 0x09, 0x08, 0x03E0F801, PPC_602_SPEC),
8123GEN_HANDLER2(tlbld_6xx, "tlbld", 0x1F, 0x12, 0x1E, 0x03FF0001, PPC_6xx_TLB),
8124GEN_HANDLER2(tlbli_6xx, "tlbli", 0x1F, 0x12, 0x1F, 0x03FF0001, PPC_6xx_TLB),
8125GEN_HANDLER2(tlbld_74xx, "tlbld", 0x1F, 0x12, 0x1E, 0x03FF0001, PPC_74xx_TLB),
8126GEN_HANDLER2(tlbli_74xx, "tlbli", 0x1F, 0x12, 0x1F, 0x03FF0001, PPC_74xx_TLB),
8127GEN_HANDLER(clf, 0x1F, 0x16, 0x03, 0x03E00000, PPC_POWER),
8128GEN_HANDLER(cli, 0x1F, 0x16, 0x0F, 0x03E00000, PPC_POWER),
8129GEN_HANDLER(dclst, 0x1F, 0x16, 0x13, 0x03E00000, PPC_POWER),
8130GEN_HANDLER(mfsri, 0x1F, 0x13, 0x13, 0x00000001, PPC_POWER),
8131GEN_HANDLER(rac, 0x1F, 0x12, 0x19, 0x00000001, PPC_POWER),
8132GEN_HANDLER(rfsvc, 0x13, 0x12, 0x02, 0x03FFF0001, PPC_POWER),
8133GEN_HANDLER(lfq, 0x38, 0xFF, 0xFF, 0x00000003, PPC_POWER2),
8134GEN_HANDLER(lfqu, 0x39, 0xFF, 0xFF, 0x00000003, PPC_POWER2),
8135GEN_HANDLER(lfqux, 0x1F, 0x17, 0x19, 0x00000001, PPC_POWER2),
8136GEN_HANDLER(lfqx, 0x1F, 0x17, 0x18, 0x00000001, PPC_POWER2),
8137GEN_HANDLER(stfq, 0x3C, 0xFF, 0xFF, 0x00000003, PPC_POWER2),
8138GEN_HANDLER(stfqu, 0x3D, 0xFF, 0xFF, 0x00000003, PPC_POWER2),
8139GEN_HANDLER(stfqux, 0x1F, 0x17, 0x1D, 0x00000001, PPC_POWER2),
8140GEN_HANDLER(stfqx, 0x1F, 0x17, 0x1C, 0x00000001, PPC_POWER2),
8141GEN_HANDLER(mfapidi, 0x1F, 0x13, 0x08, 0x0000F801, PPC_MFAPIDI),
8142GEN_HANDLER(tlbiva, 0x1F, 0x12, 0x18, 0x03FFF801, PPC_TLBIVA),
8143GEN_HANDLER(mfdcr, 0x1F, 0x03, 0x0A, 0x00000001, PPC_DCR),
8144GEN_HANDLER(mtdcr, 0x1F, 0x03, 0x0E, 0x00000001, PPC_DCR),
8145GEN_HANDLER(mfdcrx, 0x1F, 0x03, 0x08, 0x00000000, PPC_DCRX),
8146GEN_HANDLER(mtdcrx, 0x1F, 0x03, 0x0C, 0x00000000, PPC_DCRX),
8147GEN_HANDLER(mfdcrux, 0x1F, 0x03, 0x09, 0x00000000, PPC_DCRUX),
8148GEN_HANDLER(mtdcrux, 0x1F, 0x03, 0x0D, 0x00000000, PPC_DCRUX),
8149GEN_HANDLER(dccci, 0x1F, 0x06, 0x0E, 0x03E00001, PPC_4xx_COMMON),
8150GEN_HANDLER(dcread, 0x1F, 0x06, 0x0F, 0x00000001, PPC_4xx_COMMON),
8151GEN_HANDLER2(icbt_40x, "icbt", 0x1F, 0x06, 0x08, 0x03E00001, PPC_40x_ICBT),
8152GEN_HANDLER(iccci, 0x1F, 0x06, 0x1E, 0x00000001, PPC_4xx_COMMON),
8153GEN_HANDLER(icread, 0x1F, 0x06, 0x1F, 0x03E00001, PPC_4xx_COMMON),
8154GEN_HANDLER2(rfci_40x, "rfci", 0x13, 0x13, 0x01, 0x03FF8001, PPC_40x_EXCP),
8155GEN_HANDLER(rfci, 0x13, 0x13, 0x01, 0x03FF8001, PPC_BOOKE),
8156GEN_HANDLER(rfdi, 0x13, 0x07, 0x01, 0x03FF8001, PPC_RFDI),
8157GEN_HANDLER(rfmci, 0x13, 0x06, 0x01, 0x03FF8001, PPC_RFMCI),
8158GEN_HANDLER2(tlbre_40x, "tlbre", 0x1F, 0x12, 0x1D, 0x00000001, PPC_40x_TLB),
8159GEN_HANDLER2(tlbsx_40x, "tlbsx", 0x1F, 0x12, 0x1C, 0x00000000, PPC_40x_TLB),
8160GEN_HANDLER2(tlbwe_40x, "tlbwe", 0x1F, 0x12, 0x1E, 0x00000001, PPC_40x_TLB),
8161GEN_HANDLER2(tlbre_440, "tlbre", 0x1F, 0x12, 0x1D, 0x00000001, PPC_BOOKE),
8162GEN_HANDLER2(tlbsx_440, "tlbsx", 0x1F, 0x12, 0x1C, 0x00000000, PPC_BOOKE),
8163GEN_HANDLER2(tlbwe_440, "tlbwe", 0x1F, 0x12, 0x1E, 0x00000001, PPC_BOOKE),
8164GEN_HANDLER(wrtee, 0x1F, 0x03, 0x04, 0x000FFC01, PPC_WRTEE),
8165GEN_HANDLER(wrteei, 0x1F, 0x03, 0x05, 0x000E7C01, PPC_WRTEE),
8166GEN_HANDLER(dlmzb, 0x1F, 0x0E, 0x02, 0x00000000, PPC_440_SPEC),
8167GEN_HANDLER(mbar, 0x1F, 0x16, 0x1a, 0x001FF801, PPC_BOOKE),
8168GEN_HANDLER(msync, 0x1F, 0x16, 0x12, 0x03FFF801, PPC_BOOKE),
8169GEN_HANDLER2(icbt_440, "icbt", 0x1F, 0x16, 0x00, 0x03E00001, PPC_BOOKE),
8170GEN_HANDLER(lvsl, 0x1f, 0x06, 0x00, 0x00000001, PPC_ALTIVEC),
8171GEN_HANDLER(lvsr, 0x1f, 0x06, 0x01, 0x00000001, PPC_ALTIVEC),
8172GEN_HANDLER(mfvscr, 0x04, 0x2, 0x18, 0x001ff800, PPC_ALTIVEC),
8173GEN_HANDLER(mtvscr, 0x04, 0x2, 0x19, 0x03ff0000, PPC_ALTIVEC),
8174GEN_HANDLER(vsldoi, 0x04, 0x16, 0xFF, 0x00000400, PPC_ALTIVEC),
8175GEN_HANDLER(vmladduhm, 0x04, 0x11, 0xFF, 0x00000000, PPC_ALTIVEC),
8176GEN_HANDLER2(evsel0, "evsel", 0x04, 0x1c, 0x09, 0x00000000, PPC_SPE),
8177GEN_HANDLER2(evsel1, "evsel", 0x04, 0x1d, 0x09, 0x00000000, PPC_SPE),
8178GEN_HANDLER2(evsel2, "evsel", 0x04, 0x1e, 0x09, 0x00000000, PPC_SPE),
8179GEN_HANDLER2(evsel3, "evsel", 0x04, 0x1f, 0x09, 0x00000000, PPC_SPE),
8180
8181#undef GEN_INT_ARITH_ADD
8182#undef GEN_INT_ARITH_ADD_CONST
8183#define GEN_INT_ARITH_ADD(name, opc3, add_ca, compute_ca, compute_ov) \
8184GEN_HANDLER(name, 0x1F, 0x0A, opc3, 0x00000000, PPC_INTEGER),
8185#define GEN_INT_ARITH_ADD_CONST(name, opc3, const_val, \
8186 add_ca, compute_ca, compute_ov) \
8187GEN_HANDLER(name, 0x1F, 0x0A, opc3, 0x0000F800, PPC_INTEGER),
8188GEN_INT_ARITH_ADD(add, 0x08, 0, 0, 0)
8189GEN_INT_ARITH_ADD(addo, 0x18, 0, 0, 1)
8190GEN_INT_ARITH_ADD(addc, 0x00, 0, 1, 0)
8191GEN_INT_ARITH_ADD(addco, 0x10, 0, 1, 1)
8192GEN_INT_ARITH_ADD(adde, 0x04, 1, 1, 0)
8193GEN_INT_ARITH_ADD(addeo, 0x14, 1, 1, 1)
8194GEN_INT_ARITH_ADD_CONST(addme, 0x07, -1LL, 1, 1, 0)
8195GEN_INT_ARITH_ADD_CONST(addmeo, 0x17, -1LL, 1, 1, 1)
8196GEN_INT_ARITH_ADD_CONST(addze, 0x06, 0, 1, 1, 0)
8197GEN_INT_ARITH_ADD_CONST(addzeo, 0x16, 0, 1, 1, 1)
8198
8199#undef GEN_INT_ARITH_DIVW
8200#define GEN_INT_ARITH_DIVW(name, opc3, sign, compute_ov) \
8201GEN_HANDLER(name, 0x1F, 0x0B, opc3, 0x00000000, PPC_INTEGER)
8202GEN_INT_ARITH_DIVW(divwu, 0x0E, 0, 0),
8203GEN_INT_ARITH_DIVW(divwuo, 0x1E, 0, 1),
8204GEN_INT_ARITH_DIVW(divw, 0x0F, 1, 0),
8205GEN_INT_ARITH_DIVW(divwo, 0x1F, 1, 1),
8206
8207#if defined(TARGET_PPC64)
8208#undef GEN_INT_ARITH_DIVD
8209#define GEN_INT_ARITH_DIVD(name, opc3, sign, compute_ov) \
8210GEN_HANDLER(name, 0x1F, 0x09, opc3, 0x00000000, PPC_64B)
8211GEN_INT_ARITH_DIVD(divdu, 0x0E, 0, 0),
8212GEN_INT_ARITH_DIVD(divduo, 0x1E, 0, 1),
8213GEN_INT_ARITH_DIVD(divd, 0x0F, 1, 0),
8214GEN_INT_ARITH_DIVD(divdo, 0x1F, 1, 1),
8215
8216#undef GEN_INT_ARITH_MUL_HELPER
8217#define GEN_INT_ARITH_MUL_HELPER(name, opc3) \
8218GEN_HANDLER(name, 0x1F, 0x09, opc3, 0x00000000, PPC_64B)
8219GEN_INT_ARITH_MUL_HELPER(mulhdu, 0x00),
8220GEN_INT_ARITH_MUL_HELPER(mulhd, 0x02),
8221GEN_INT_ARITH_MUL_HELPER(mulldo, 0x17),
8222#endif
8223
8224#undef GEN_INT_ARITH_SUBF
8225#undef GEN_INT_ARITH_SUBF_CONST
8226#define GEN_INT_ARITH_SUBF(name, opc3, add_ca, compute_ca, compute_ov) \
8227GEN_HANDLER(name, 0x1F, 0x08, opc3, 0x00000000, PPC_INTEGER),
8228#define GEN_INT_ARITH_SUBF_CONST(name, opc3, const_val, \
8229 add_ca, compute_ca, compute_ov) \
8230GEN_HANDLER(name, 0x1F, 0x08, opc3, 0x0000F800, PPC_INTEGER),
8231GEN_INT_ARITH_SUBF(subf, 0x01, 0, 0, 0)
8232GEN_INT_ARITH_SUBF(subfo, 0x11, 0, 0, 1)
8233GEN_INT_ARITH_SUBF(subfc, 0x00, 0, 1, 0)
8234GEN_INT_ARITH_SUBF(subfco, 0x10, 0, 1, 1)
8235GEN_INT_ARITH_SUBF(subfe, 0x04, 1, 1, 0)
8236GEN_INT_ARITH_SUBF(subfeo, 0x14, 1, 1, 1)
8237GEN_INT_ARITH_SUBF_CONST(subfme, 0x07, -1LL, 1, 1, 0)
8238GEN_INT_ARITH_SUBF_CONST(subfmeo, 0x17, -1LL, 1, 1, 1)
8239GEN_INT_ARITH_SUBF_CONST(subfze, 0x06, 0, 1, 1, 0)
8240GEN_INT_ARITH_SUBF_CONST(subfzeo, 0x16, 0, 1, 1, 1)
8241
8242#undef GEN_LOGICAL1
8243#undef GEN_LOGICAL2
8244#define GEN_LOGICAL2(name, tcg_op, opc, type) \
8245GEN_HANDLER(name, 0x1F, 0x1C, opc, 0x00000000, type)
8246#define GEN_LOGICAL1(name, tcg_op, opc, type) \
8247GEN_HANDLER(name, 0x1F, 0x1A, opc, 0x00000000, type)
8248GEN_LOGICAL2(and, tcg_gen_and_tl, 0x00, PPC_INTEGER),
8249GEN_LOGICAL2(andc, tcg_gen_andc_tl, 0x01, PPC_INTEGER),
8250GEN_LOGICAL2(eqv, tcg_gen_eqv_tl, 0x08, PPC_INTEGER),
8251GEN_LOGICAL1(extsb, tcg_gen_ext8s_tl, 0x1D, PPC_INTEGER),
8252GEN_LOGICAL1(extsh, tcg_gen_ext16s_tl, 0x1C, PPC_INTEGER),
8253GEN_LOGICAL2(nand, tcg_gen_nand_tl, 0x0E, PPC_INTEGER),
8254GEN_LOGICAL2(nor, tcg_gen_nor_tl, 0x03, PPC_INTEGER),
8255GEN_LOGICAL2(orc, tcg_gen_orc_tl, 0x0C, PPC_INTEGER),
8256#if defined(TARGET_PPC64)
8257GEN_LOGICAL1(extsw, tcg_gen_ext32s_tl, 0x1E, PPC_64B),
8258#endif
8259
8260#if defined(TARGET_PPC64)
8261#undef GEN_PPC64_R2
8262#undef GEN_PPC64_R4
8263#define GEN_PPC64_R2(name, opc1, opc2) \
8264GEN_HANDLER2(name##0, stringify(name), opc1, opc2, 0xFF, 0x00000000, PPC_64B),\
8265GEN_HANDLER2(name##1, stringify(name), opc1, opc2 | 0x10, 0xFF, 0x00000000, \
8266 PPC_64B)
8267#define GEN_PPC64_R4(name, opc1, opc2) \
8268GEN_HANDLER2(name##0, stringify(name), opc1, opc2, 0xFF, 0x00000000, PPC_64B),\
8269GEN_HANDLER2(name##1, stringify(name), opc1, opc2 | 0x01, 0xFF, 0x00000000, \
8270 PPC_64B), \
8271GEN_HANDLER2(name##2, stringify(name), opc1, opc2 | 0x10, 0xFF, 0x00000000, \
8272 PPC_64B), \
8273GEN_HANDLER2(name##3, stringify(name), opc1, opc2 | 0x11, 0xFF, 0x00000000, \
8274 PPC_64B)
8275GEN_PPC64_R4(rldicl, 0x1E, 0x00),
8276GEN_PPC64_R4(rldicr, 0x1E, 0x02),
8277GEN_PPC64_R4(rldic, 0x1E, 0x04),
8278GEN_PPC64_R2(rldcl, 0x1E, 0x08),
8279GEN_PPC64_R2(rldcr, 0x1E, 0x09),
8280GEN_PPC64_R4(rldimi, 0x1E, 0x06),
8281#endif
8282
8283#undef _GEN_FLOAT_ACB
8284#undef GEN_FLOAT_ACB
8285#undef _GEN_FLOAT_AB
8286#undef GEN_FLOAT_AB
8287#undef _GEN_FLOAT_AC
8288#undef GEN_FLOAT_AC
8289#undef GEN_FLOAT_B
8290#undef GEN_FLOAT_BS
8291#define _GEN_FLOAT_ACB(name, op, op1, op2, isfloat, set_fprf, type) \
8292GEN_HANDLER(f##name, op1, op2, 0xFF, 0x00000000, type)
8293#define GEN_FLOAT_ACB(name, op2, set_fprf, type) \
8294_GEN_FLOAT_ACB(name, name, 0x3F, op2, 0, set_fprf, type), \
8295_GEN_FLOAT_ACB(name##s, name, 0x3B, op2, 1, set_fprf, type)
8296#define _GEN_FLOAT_AB(name, op, op1, op2, inval, isfloat, set_fprf, type) \
8297GEN_HANDLER(f##name, op1, op2, 0xFF, inval, type)
8298#define GEN_FLOAT_AB(name, op2, inval, set_fprf, type) \
8299_GEN_FLOAT_AB(name, name, 0x3F, op2, inval, 0, set_fprf, type), \
8300_GEN_FLOAT_AB(name##s, name, 0x3B, op2, inval, 1, set_fprf, type)
8301#define _GEN_FLOAT_AC(name, op, op1, op2, inval, isfloat, set_fprf, type) \
8302GEN_HANDLER(f##name, op1, op2, 0xFF, inval, type)
8303#define GEN_FLOAT_AC(name, op2, inval, set_fprf, type) \
8304_GEN_FLOAT_AC(name, name, 0x3F, op2, inval, 0, set_fprf, type), \
8305_GEN_FLOAT_AC(name##s, name, 0x3B, op2, inval, 1, set_fprf, type)
8306#define GEN_FLOAT_B(name, op2, op3, set_fprf, type) \
8307GEN_HANDLER(f##name, 0x3F, op2, op3, 0x001F0000, type)
8308#define GEN_FLOAT_BS(name, op1, op2, set_fprf, type) \
8309GEN_HANDLER(f##name, op1, op2, 0xFF, 0x001F07C0, type)
8310
8311GEN_FLOAT_AB(add, 0x15, 0x000007C0, 1, PPC_FLOAT),
8312GEN_FLOAT_AB(div, 0x12, 0x000007C0, 1, PPC_FLOAT),
8313GEN_FLOAT_AC(mul, 0x19, 0x0000F800, 1, PPC_FLOAT),
8314GEN_FLOAT_BS(re, 0x3F, 0x18, 1, PPC_FLOAT_EXT),
8315GEN_FLOAT_BS(res, 0x3B, 0x18, 1, PPC_FLOAT_FRES),
8316GEN_FLOAT_BS(rsqrte, 0x3F, 0x1A, 1, PPC_FLOAT_FRSQRTE),
8317_GEN_FLOAT_ACB(sel, sel, 0x3F, 0x17, 0, 0, PPC_FLOAT_FSEL),
8318GEN_FLOAT_AB(sub, 0x14, 0x000007C0, 1, PPC_FLOAT),
8319GEN_FLOAT_ACB(madd, 0x1D, 1, PPC_FLOAT),
8320GEN_FLOAT_ACB(msub, 0x1C, 1, PPC_FLOAT),
8321GEN_FLOAT_ACB(nmadd, 0x1F, 1, PPC_FLOAT),
8322GEN_FLOAT_ACB(nmsub, 0x1E, 1, PPC_FLOAT),
8323GEN_FLOAT_B(ctiw, 0x0E, 0x00, 0, PPC_FLOAT),
8324GEN_FLOAT_B(ctiwz, 0x0F, 0x00, 0, PPC_FLOAT),
8325GEN_FLOAT_B(rsp, 0x0C, 0x00, 1, PPC_FLOAT),
8326#if defined(TARGET_PPC64)
8327GEN_FLOAT_B(cfid, 0x0E, 0x1A, 1, PPC_64B),
8328GEN_FLOAT_B(ctid, 0x0E, 0x19, 0, PPC_64B),
8329GEN_FLOAT_B(ctidz, 0x0F, 0x19, 0, PPC_64B),
8330#endif
8331GEN_FLOAT_B(rin, 0x08, 0x0C, 1, PPC_FLOAT_EXT),
8332GEN_FLOAT_B(riz, 0x08, 0x0D, 1, PPC_FLOAT_EXT),
8333GEN_FLOAT_B(rip, 0x08, 0x0E, 1, PPC_FLOAT_EXT),
8334GEN_FLOAT_B(rim, 0x08, 0x0F, 1, PPC_FLOAT_EXT),
8335GEN_FLOAT_B(abs, 0x08, 0x08, 0, PPC_FLOAT),
8336GEN_FLOAT_B(nabs, 0x08, 0x04, 0, PPC_FLOAT),
8337GEN_FLOAT_B(neg, 0x08, 0x01, 0, PPC_FLOAT),
8338
8339#undef GEN_LD
8340#undef GEN_LDU
8341#undef GEN_LDUX
8342#undef GEN_LDX
8343#undef GEN_LDS
8344#define GEN_LD(name, ldop, opc, type) \
8345GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
8346#define GEN_LDU(name, ldop, opc, type) \
8347GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type),
8348#define GEN_LDUX(name, ldop, opc2, opc3, type) \
8349GEN_HANDLER(name##ux, 0x1F, opc2, opc3, 0x00000001, type),
8350#define GEN_LDX(name, ldop, opc2, opc3, type) \
8351GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type),
8352#define GEN_LDS(name, ldop, op, type) \
8353GEN_LD(name, ldop, op | 0x20, type) \
8354GEN_LDU(name, ldop, op | 0x21, type) \
8355GEN_LDUX(name, ldop, 0x17, op | 0x01, type) \
8356GEN_LDX(name, ldop, 0x17, op | 0x00, type)
8357
8358GEN_LDS(lbz, ld8u, 0x02, PPC_INTEGER)
8359GEN_LDS(lha, ld16s, 0x0A, PPC_INTEGER)
8360GEN_LDS(lhz, ld16u, 0x08, PPC_INTEGER)
8361GEN_LDS(lwz, ld32u, 0x00, PPC_INTEGER)
8362#if defined(TARGET_PPC64)
8363GEN_LDUX(lwa, ld32s, 0x15, 0x0B, PPC_64B)
8364GEN_LDX(lwa, ld32s, 0x15, 0x0A, PPC_64B)
8365GEN_LDUX(ld, ld64, 0x15, 0x01, PPC_64B)
8366GEN_LDX(ld, ld64, 0x15, 0x00, PPC_64B)
8367#endif
8368GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER)
8369GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER)
8370
8371#undef GEN_ST
8372#undef GEN_STU
8373#undef GEN_STUX
8374#undef GEN_STX
8375#undef GEN_STS
8376#define GEN_ST(name, stop, opc, type) \
8377GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
8378#define GEN_STU(name, stop, opc, type) \
8379GEN_HANDLER(stop##u, opc, 0xFF, 0xFF, 0x00000000, type),
8380#define GEN_STUX(name, stop, opc2, opc3, type) \
8381GEN_HANDLER(name##ux, 0x1F, opc2, opc3, 0x00000001, type),
8382#define GEN_STX(name, stop, opc2, opc3, type) \
8383GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type),
8384#define GEN_STS(name, stop, op, type) \
8385GEN_ST(name, stop, op | 0x20, type) \
8386GEN_STU(name, stop, op | 0x21, type) \
8387GEN_STUX(name, stop, 0x17, op | 0x01, type) \
8388GEN_STX(name, stop, 0x17, op | 0x00, type)
8389
8390GEN_STS(stb, st8, 0x06, PPC_INTEGER)
8391GEN_STS(sth, st16, 0x0C, PPC_INTEGER)
8392GEN_STS(stw, st32, 0x04, PPC_INTEGER)
8393#if defined(TARGET_PPC64)
8394GEN_STUX(std, st64, 0x15, 0x05, PPC_64B)
8395GEN_STX(std, st64, 0x15, 0x04, PPC_64B)
8396#endif
8397GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER)
8398GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER)
8399
8400#undef GEN_LDF
8401#undef GEN_LDUF
8402#undef GEN_LDUXF
8403#undef GEN_LDXF
8404#undef GEN_LDFS
8405#define GEN_LDF(name, ldop, opc, type) \
8406GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
8407#define GEN_LDUF(name, ldop, opc, type) \
8408GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type),
8409#define GEN_LDUXF(name, ldop, opc, type) \
8410GEN_HANDLER(name##ux, 0x1F, 0x17, opc, 0x00000001, type),
8411#define GEN_LDXF(name, ldop, opc2, opc3, type) \
8412GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type),
8413#define GEN_LDFS(name, ldop, op, type) \
8414GEN_LDF(name, ldop, op | 0x20, type) \
8415GEN_LDUF(name, ldop, op | 0x21, type) \
8416GEN_LDUXF(name, ldop, op | 0x01, type) \
8417GEN_LDXF(name, ldop, 0x17, op | 0x00, type)
8418
8419GEN_LDFS(lfd, ld64, 0x12, PPC_FLOAT)
8420GEN_LDFS(lfs, ld32fs, 0x10, PPC_FLOAT)
8421
8422#undef GEN_STF
8423#undef GEN_STUF
8424#undef GEN_STUXF
8425#undef GEN_STXF
8426#undef GEN_STFS
8427#define GEN_STF(name, stop, opc, type) \
8428GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
8429#define GEN_STUF(name, stop, opc, type) \
8430GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type),
8431#define GEN_STUXF(name, stop, opc, type) \
8432GEN_HANDLER(name##ux, 0x1F, 0x17, opc, 0x00000001, type),
8433#define GEN_STXF(name, stop, opc2, opc3, type) \
8434GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type),
8435#define GEN_STFS(name, stop, op, type) \
8436GEN_STF(name, stop, op | 0x20, type) \
8437GEN_STUF(name, stop, op | 0x21, type) \
8438GEN_STUXF(name, stop, op | 0x01, type) \
8439GEN_STXF(name, stop, 0x17, op | 0x00, type)
8440
8441GEN_STFS(stfd, st64, 0x16, PPC_FLOAT)
8442GEN_STFS(stfs, st32fs, 0x14, PPC_FLOAT)
8443GEN_STXF(stfiw, st32fiw, 0x17, 0x1E, PPC_FLOAT_STFIWX)
8444
8445#undef GEN_CRLOGIC
8446#define GEN_CRLOGIC(name, tcg_op, opc) \
8447GEN_HANDLER(name, 0x13, 0x01, opc, 0x00000001, PPC_INTEGER)
8448GEN_CRLOGIC(crand, tcg_gen_and_i32, 0x08),
8449GEN_CRLOGIC(crandc, tcg_gen_andc_i32, 0x04),
8450GEN_CRLOGIC(creqv, tcg_gen_eqv_i32, 0x09),
8451GEN_CRLOGIC(crnand, tcg_gen_nand_i32, 0x07),
8452GEN_CRLOGIC(crnor, tcg_gen_nor_i32, 0x01),
8453GEN_CRLOGIC(cror, tcg_gen_or_i32, 0x0E),
8454GEN_CRLOGIC(crorc, tcg_gen_orc_i32, 0x0D),
8455GEN_CRLOGIC(crxor, tcg_gen_xor_i32, 0x06),
8456
8457#undef GEN_MAC_HANDLER
8458#define GEN_MAC_HANDLER(name, opc2, opc3) \
8459GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_405_MAC)
8460GEN_MAC_HANDLER(macchw, 0x0C, 0x05),
8461GEN_MAC_HANDLER(macchwo, 0x0C, 0x15),
8462GEN_MAC_HANDLER(macchws, 0x0C, 0x07),
8463GEN_MAC_HANDLER(macchwso, 0x0C, 0x17),
8464GEN_MAC_HANDLER(macchwsu, 0x0C, 0x06),
8465GEN_MAC_HANDLER(macchwsuo, 0x0C, 0x16),
8466GEN_MAC_HANDLER(macchwu, 0x0C, 0x04),
8467GEN_MAC_HANDLER(macchwuo, 0x0C, 0x14),
8468GEN_MAC_HANDLER(machhw, 0x0C, 0x01),
8469GEN_MAC_HANDLER(machhwo, 0x0C, 0x11),
8470GEN_MAC_HANDLER(machhws, 0x0C, 0x03),
8471GEN_MAC_HANDLER(machhwso, 0x0C, 0x13),
8472GEN_MAC_HANDLER(machhwsu, 0x0C, 0x02),
8473GEN_MAC_HANDLER(machhwsuo, 0x0C, 0x12),
8474GEN_MAC_HANDLER(machhwu, 0x0C, 0x00),
8475GEN_MAC_HANDLER(machhwuo, 0x0C, 0x10),
8476GEN_MAC_HANDLER(maclhw, 0x0C, 0x0D),
8477GEN_MAC_HANDLER(maclhwo, 0x0C, 0x1D),
8478GEN_MAC_HANDLER(maclhws, 0x0C, 0x0F),
8479GEN_MAC_HANDLER(maclhwso, 0x0C, 0x1F),
8480GEN_MAC_HANDLER(maclhwu, 0x0C, 0x0C),
8481GEN_MAC_HANDLER(maclhwuo, 0x0C, 0x1C),
8482GEN_MAC_HANDLER(maclhwsu, 0x0C, 0x0E),
8483GEN_MAC_HANDLER(maclhwsuo, 0x0C, 0x1E),
8484GEN_MAC_HANDLER(nmacchw, 0x0E, 0x05),
8485GEN_MAC_HANDLER(nmacchwo, 0x0E, 0x15),
8486GEN_MAC_HANDLER(nmacchws, 0x0E, 0x07),
8487GEN_MAC_HANDLER(nmacchwso, 0x0E, 0x17),
8488GEN_MAC_HANDLER(nmachhw, 0x0E, 0x01),
8489GEN_MAC_HANDLER(nmachhwo, 0x0E, 0x11),
8490GEN_MAC_HANDLER(nmachhws, 0x0E, 0x03),
8491GEN_MAC_HANDLER(nmachhwso, 0x0E, 0x13),
8492GEN_MAC_HANDLER(nmaclhw, 0x0E, 0x0D),
8493GEN_MAC_HANDLER(nmaclhwo, 0x0E, 0x1D),
8494GEN_MAC_HANDLER(nmaclhws, 0x0E, 0x0F),
8495GEN_MAC_HANDLER(nmaclhwso, 0x0E, 0x1F),
8496GEN_MAC_HANDLER(mulchw, 0x08, 0x05),
8497GEN_MAC_HANDLER(mulchwu, 0x08, 0x04),
8498GEN_MAC_HANDLER(mulhhw, 0x08, 0x01),
8499GEN_MAC_HANDLER(mulhhwu, 0x08, 0x00),
8500GEN_MAC_HANDLER(mullhw, 0x08, 0x0D),
8501GEN_MAC_HANDLER(mullhwu, 0x08, 0x0C),
8502
8503#undef GEN_VR_LDX
8504#undef GEN_VR_STX
8505#undef GEN_VR_LVE
8506#undef GEN_VR_STVE
8507#define GEN_VR_LDX(name, opc2, opc3) \
8508GEN_HANDLER(name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
8509#define GEN_VR_STX(name, opc2, opc3) \
8510GEN_HANDLER(st##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
8511#define GEN_VR_LVE(name, opc2, opc3) \
8512 GEN_HANDLER(lve##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
8513#define GEN_VR_STVE(name, opc2, opc3) \
8514 GEN_HANDLER(stve##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
8515GEN_VR_LDX(lvx, 0x07, 0x03),
8516GEN_VR_LDX(lvxl, 0x07, 0x0B),
8517GEN_VR_LVE(bx, 0x07, 0x00),
8518GEN_VR_LVE(hx, 0x07, 0x01),
8519GEN_VR_LVE(wx, 0x07, 0x02),
8520GEN_VR_STX(svx, 0x07, 0x07),
8521GEN_VR_STX(svxl, 0x07, 0x0F),
8522GEN_VR_STVE(bx, 0x07, 0x04),
8523GEN_VR_STVE(hx, 0x07, 0x05),
8524GEN_VR_STVE(wx, 0x07, 0x06),
8525
8526#undef GEN_VX_LOGICAL
8527#define GEN_VX_LOGICAL(name, tcg_op, opc2, opc3) \
8528GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
8529GEN_VX_LOGICAL(vand, tcg_gen_and_i64, 2, 16),
8530GEN_VX_LOGICAL(vandc, tcg_gen_andc_i64, 2, 17),
8531GEN_VX_LOGICAL(vor, tcg_gen_or_i64, 2, 18),
8532GEN_VX_LOGICAL(vxor, tcg_gen_xor_i64, 2, 19),
8533GEN_VX_LOGICAL(vnor, tcg_gen_nor_i64, 2, 20),
8534
8535#undef GEN_VXFORM
8536#define GEN_VXFORM(name, opc2, opc3) \
8537GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
8538GEN_VXFORM(vaddubm, 0, 0),
8539GEN_VXFORM(vadduhm, 0, 1),
8540GEN_VXFORM(vadduwm, 0, 2),
8541GEN_VXFORM(vsububm, 0, 16),
8542GEN_VXFORM(vsubuhm, 0, 17),
8543GEN_VXFORM(vsubuwm, 0, 18),
8544GEN_VXFORM(vmaxub, 1, 0),
8545GEN_VXFORM(vmaxuh, 1, 1),
8546GEN_VXFORM(vmaxuw, 1, 2),
8547GEN_VXFORM(vmaxsb, 1, 4),
8548GEN_VXFORM(vmaxsh, 1, 5),
8549GEN_VXFORM(vmaxsw, 1, 6),
8550GEN_VXFORM(vminub, 1, 8),
8551GEN_VXFORM(vminuh, 1, 9),
8552GEN_VXFORM(vminuw, 1, 10),
8553GEN_VXFORM(vminsb, 1, 12),
8554GEN_VXFORM(vminsh, 1, 13),
8555GEN_VXFORM(vminsw, 1, 14),
8556GEN_VXFORM(vavgub, 1, 16),
8557GEN_VXFORM(vavguh, 1, 17),
8558GEN_VXFORM(vavguw, 1, 18),
8559GEN_VXFORM(vavgsb, 1, 20),
8560GEN_VXFORM(vavgsh, 1, 21),
8561GEN_VXFORM(vavgsw, 1, 22),
8562GEN_VXFORM(vmrghb, 6, 0),
8563GEN_VXFORM(vmrghh, 6, 1),
8564GEN_VXFORM(vmrghw, 6, 2),
8565GEN_VXFORM(vmrglb, 6, 4),
8566GEN_VXFORM(vmrglh, 6, 5),
8567GEN_VXFORM(vmrglw, 6, 6),
8568GEN_VXFORM(vmuloub, 4, 0),
8569GEN_VXFORM(vmulouh, 4, 1),
8570GEN_VXFORM(vmulosb, 4, 4),
8571GEN_VXFORM(vmulosh, 4, 5),
8572GEN_VXFORM(vmuleub, 4, 8),
8573GEN_VXFORM(vmuleuh, 4, 9),
8574GEN_VXFORM(vmulesb, 4, 12),
8575GEN_VXFORM(vmulesh, 4, 13),
8576GEN_VXFORM(vslb, 2, 4),
8577GEN_VXFORM(vslh, 2, 5),
8578GEN_VXFORM(vslw, 2, 6),
8579GEN_VXFORM(vsrb, 2, 8),
8580GEN_VXFORM(vsrh, 2, 9),
8581GEN_VXFORM(vsrw, 2, 10),
8582GEN_VXFORM(vsrab, 2, 12),
8583GEN_VXFORM(vsrah, 2, 13),
8584GEN_VXFORM(vsraw, 2, 14),
8585GEN_VXFORM(vslo, 6, 16),
8586GEN_VXFORM(vsro, 6, 17),
8587GEN_VXFORM(vaddcuw, 0, 6),
8588GEN_VXFORM(vsubcuw, 0, 22),
8589GEN_VXFORM(vaddubs, 0, 8),
8590GEN_VXFORM(vadduhs, 0, 9),
8591GEN_VXFORM(vadduws, 0, 10),
8592GEN_VXFORM(vaddsbs, 0, 12),
8593GEN_VXFORM(vaddshs, 0, 13),
8594GEN_VXFORM(vaddsws, 0, 14),
8595GEN_VXFORM(vsububs, 0, 24),
8596GEN_VXFORM(vsubuhs, 0, 25),
8597GEN_VXFORM(vsubuws, 0, 26),
8598GEN_VXFORM(vsubsbs, 0, 28),
8599GEN_VXFORM(vsubshs, 0, 29),
8600GEN_VXFORM(vsubsws, 0, 30),
8601GEN_VXFORM(vrlb, 2, 0),
8602GEN_VXFORM(vrlh, 2, 1),
8603GEN_VXFORM(vrlw, 2, 2),
8604GEN_VXFORM(vsl, 2, 7),
8605GEN_VXFORM(vsr, 2, 11),
8606GEN_VXFORM(vpkuhum, 7, 0),
8607GEN_VXFORM(vpkuwum, 7, 1),
8608GEN_VXFORM(vpkuhus, 7, 2),
8609GEN_VXFORM(vpkuwus, 7, 3),
8610GEN_VXFORM(vpkshus, 7, 4),
8611GEN_VXFORM(vpkswus, 7, 5),
8612GEN_VXFORM(vpkshss, 7, 6),
8613GEN_VXFORM(vpkswss, 7, 7),
8614GEN_VXFORM(vpkpx, 7, 12),
8615GEN_VXFORM(vsum4ubs, 4, 24),
8616GEN_VXFORM(vsum4sbs, 4, 28),
8617GEN_VXFORM(vsum4shs, 4, 25),
8618GEN_VXFORM(vsum2sws, 4, 26),
8619GEN_VXFORM(vsumsws, 4, 30),
8620GEN_VXFORM(vaddfp, 5, 0),
8621GEN_VXFORM(vsubfp, 5, 1),
8622GEN_VXFORM(vmaxfp, 5, 16),
8623GEN_VXFORM(vminfp, 5, 17),
8624
8625#undef GEN_VXRFORM1
8626#undef GEN_VXRFORM
8627#define GEN_VXRFORM1(opname, name, str, opc2, opc3) \
8628 GEN_HANDLER2(name, str, 0x4, opc2, opc3, 0x00000000, PPC_ALTIVEC),
8629#define GEN_VXRFORM(name, opc2, opc3) \
8630 GEN_VXRFORM1(name, name, #name, opc2, opc3) \
8631 GEN_VXRFORM1(name##_dot, name##_, #name ".", opc2, (opc3 | (0x1 << 4)))
8632GEN_VXRFORM(vcmpequb, 3, 0)
8633GEN_VXRFORM(vcmpequh, 3, 1)
8634GEN_VXRFORM(vcmpequw, 3, 2)
8635GEN_VXRFORM(vcmpgtsb, 3, 12)
8636GEN_VXRFORM(vcmpgtsh, 3, 13)
8637GEN_VXRFORM(vcmpgtsw, 3, 14)
8638GEN_VXRFORM(vcmpgtub, 3, 8)
8639GEN_VXRFORM(vcmpgtuh, 3, 9)
8640GEN_VXRFORM(vcmpgtuw, 3, 10)
8641GEN_VXRFORM(vcmpeqfp, 3, 3)
8642GEN_VXRFORM(vcmpgefp, 3, 7)
8643GEN_VXRFORM(vcmpgtfp, 3, 11)
8644GEN_VXRFORM(vcmpbfp, 3, 15)
8645
8646#undef GEN_VXFORM_SIMM
8647#define GEN_VXFORM_SIMM(name, opc2, opc3) \
8648 GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
8649GEN_VXFORM_SIMM(vspltisb, 6, 12),
8650GEN_VXFORM_SIMM(vspltish, 6, 13),
8651GEN_VXFORM_SIMM(vspltisw, 6, 14),
8652
8653#undef GEN_VXFORM_NOA
8654#define GEN_VXFORM_NOA(name, opc2, opc3) \
8655 GEN_HANDLER(name, 0x04, opc2, opc3, 0x001f0000, PPC_ALTIVEC)
8656GEN_VXFORM_NOA(vupkhsb, 7, 8),
8657GEN_VXFORM_NOA(vupkhsh, 7, 9),
8658GEN_VXFORM_NOA(vupklsb, 7, 10),
8659GEN_VXFORM_NOA(vupklsh, 7, 11),
8660GEN_VXFORM_NOA(vupkhpx, 7, 13),
8661GEN_VXFORM_NOA(vupklpx, 7, 15),
8662GEN_VXFORM_NOA(vrefp, 5, 4),
8663GEN_VXFORM_NOA(vrsqrtefp, 5, 5),
8664GEN_VXFORM_NOA(vlogefp, 5, 7),
8665GEN_VXFORM_NOA(vrfim, 5, 8),
8666GEN_VXFORM_NOA(vrfin, 5, 9),
8667GEN_VXFORM_NOA(vrfip, 5, 10),
8668GEN_VXFORM_NOA(vrfiz, 5, 11),
8669
8670#undef GEN_VXFORM_UIMM
8671#define GEN_VXFORM_UIMM(name, opc2, opc3) \
8672 GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
8673GEN_VXFORM_UIMM(vspltb, 6, 8),
8674GEN_VXFORM_UIMM(vsplth, 6, 9),
8675GEN_VXFORM_UIMM(vspltw, 6, 10),
8676GEN_VXFORM_UIMM(vcfux, 5, 12),
8677GEN_VXFORM_UIMM(vcfsx, 5, 13),
8678GEN_VXFORM_UIMM(vctuxs, 5, 14),
8679GEN_VXFORM_UIMM(vctsxs, 5, 15),
8680
8681#undef GEN_VAFORM_PAIRED
8682#define GEN_VAFORM_PAIRED(name0, name1, opc2) \
8683 GEN_HANDLER(name0##_##name1, 0x04, opc2, 0xFF, 0x00000000, PPC_ALTIVEC)
8684GEN_VAFORM_PAIRED(vmhaddshs, vmhraddshs, 16),
8685GEN_VAFORM_PAIRED(vmsumubm, vmsummbm, 18),
8686GEN_VAFORM_PAIRED(vmsumuhm, vmsumuhs, 19),
8687GEN_VAFORM_PAIRED(vmsumshm, vmsumshs, 20),
8688GEN_VAFORM_PAIRED(vsel, vperm, 21),
8689GEN_VAFORM_PAIRED(vmaddfp, vnmsubfp, 23),
8690
8691#undef GEN_SPE
8692#define GEN_SPE(name0, name1, opc2, opc3, inval, type) \
8693GEN_HANDLER(name0##_##name1, 0x04, opc2, opc3, inval, type)
8694GEN_SPE(evaddw, speundef, 0x00, 0x08, 0x00000000, PPC_SPE),
8695GEN_SPE(evaddiw, speundef, 0x01, 0x08, 0x00000000, PPC_SPE),
8696GEN_SPE(evsubfw, speundef, 0x02, 0x08, 0x00000000, PPC_SPE),
8697GEN_SPE(evsubifw, speundef, 0x03, 0x08, 0x00000000, PPC_SPE),
8698GEN_SPE(evabs, evneg, 0x04, 0x08, 0x0000F800, PPC_SPE),
8699GEN_SPE(evextsb, evextsh, 0x05, 0x08, 0x0000F800, PPC_SPE),
8700GEN_SPE(evrndw, evcntlzw, 0x06, 0x08, 0x0000F800, PPC_SPE),
8701GEN_SPE(evcntlsw, brinc, 0x07, 0x08, 0x00000000, PPC_SPE),
8702GEN_SPE(speundef, evand, 0x08, 0x08, 0x00000000, PPC_SPE),
8703GEN_SPE(evandc, speundef, 0x09, 0x08, 0x00000000, PPC_SPE),
8704GEN_SPE(evxor, evor, 0x0B, 0x08, 0x00000000, PPC_SPE),
8705GEN_SPE(evnor, eveqv, 0x0C, 0x08, 0x00000000, PPC_SPE),
8706GEN_SPE(speundef, evorc, 0x0D, 0x08, 0x00000000, PPC_SPE),
8707GEN_SPE(evnand, speundef, 0x0F, 0x08, 0x00000000, PPC_SPE),
8708GEN_SPE(evsrwu, evsrws, 0x10, 0x08, 0x00000000, PPC_SPE),
8709GEN_SPE(evsrwiu, evsrwis, 0x11, 0x08, 0x00000000, PPC_SPE),
8710GEN_SPE(evslw, speundef, 0x12, 0x08, 0x00000000, PPC_SPE),
8711GEN_SPE(evslwi, speundef, 0x13, 0x08, 0x00000000, PPC_SPE),
8712GEN_SPE(evrlw, evsplati, 0x14, 0x08, 0x00000000, PPC_SPE),
8713GEN_SPE(evrlwi, evsplatfi, 0x15, 0x08, 0x00000000, PPC_SPE),
8714GEN_SPE(evmergehi, evmergelo, 0x16, 0x08, 0x00000000, PPC_SPE),
8715GEN_SPE(evmergehilo, evmergelohi, 0x17, 0x08, 0x00000000, PPC_SPE),
8716GEN_SPE(evcmpgtu, evcmpgts, 0x18, 0x08, 0x00600000, PPC_SPE),
8717GEN_SPE(evcmpltu, evcmplts, 0x19, 0x08, 0x00600000, PPC_SPE),
8718GEN_SPE(evcmpeq, speundef, 0x1A, 0x08, 0x00600000, PPC_SPE),
8719
8720GEN_SPE(evfsadd, evfssub, 0x00, 0x0A, 0x00000000, PPC_SPE_SINGLE),
8721GEN_SPE(evfsabs, evfsnabs, 0x02, 0x0A, 0x0000F800, PPC_SPE_SINGLE),
8722GEN_SPE(evfsneg, speundef, 0x03, 0x0A, 0x0000F800, PPC_SPE_SINGLE),
8723GEN_SPE(evfsmul, evfsdiv, 0x04, 0x0A, 0x00000000, PPC_SPE_SINGLE),
8724GEN_SPE(evfscmpgt, evfscmplt, 0x06, 0x0A, 0x00600000, PPC_SPE_SINGLE),
8725GEN_SPE(evfscmpeq, speundef, 0x07, 0x0A, 0x00600000, PPC_SPE_SINGLE),
8726GEN_SPE(evfscfui, evfscfsi, 0x08, 0x0A, 0x00180000, PPC_SPE_SINGLE),
8727GEN_SPE(evfscfuf, evfscfsf, 0x09, 0x0A, 0x00180000, PPC_SPE_SINGLE),
8728GEN_SPE(evfsctui, evfsctsi, 0x0A, 0x0A, 0x00180000, PPC_SPE_SINGLE),
8729GEN_SPE(evfsctuf, evfsctsf, 0x0B, 0x0A, 0x00180000, PPC_SPE_SINGLE),
8730GEN_SPE(evfsctuiz, speundef, 0x0C, 0x0A, 0x00180000, PPC_SPE_SINGLE),
8731GEN_SPE(evfsctsiz, speundef, 0x0D, 0x0A, 0x00180000, PPC_SPE_SINGLE),
8732GEN_SPE(evfststgt, evfststlt, 0x0E, 0x0A, 0x00600000, PPC_SPE_SINGLE),
8733GEN_SPE(evfststeq, speundef, 0x0F, 0x0A, 0x00600000, PPC_SPE_SINGLE),
8734
8735GEN_SPE(efsadd, efssub, 0x00, 0x0B, 0x00000000, PPC_SPE_SINGLE),
8736GEN_SPE(efsabs, efsnabs, 0x02, 0x0B, 0x0000F800, PPC_SPE_SINGLE),
8737GEN_SPE(efsneg, speundef, 0x03, 0x0B, 0x0000F800, PPC_SPE_SINGLE),
8738GEN_SPE(efsmul, efsdiv, 0x04, 0x0B, 0x00000000, PPC_SPE_SINGLE),
8739GEN_SPE(efscmpgt, efscmplt, 0x06, 0x0B, 0x00600000, PPC_SPE_SINGLE),
8740GEN_SPE(efscmpeq, efscfd, 0x07, 0x0B, 0x00600000, PPC_SPE_SINGLE),
8741GEN_SPE(efscfui, efscfsi, 0x08, 0x0B, 0x00180000, PPC_SPE_SINGLE),
8742GEN_SPE(efscfuf, efscfsf, 0x09, 0x0B, 0x00180000, PPC_SPE_SINGLE),
8743GEN_SPE(efsctui, efsctsi, 0x0A, 0x0B, 0x00180000, PPC_SPE_SINGLE),
8744GEN_SPE(efsctuf, efsctsf, 0x0B, 0x0B, 0x00180000, PPC_SPE_SINGLE),
8745GEN_SPE(efsctuiz, speundef, 0x0C, 0x0B, 0x00180000, PPC_SPE_SINGLE),
8746GEN_SPE(efsctsiz, speundef, 0x0D, 0x0B, 0x00180000, PPC_SPE_SINGLE),
8747GEN_SPE(efststgt, efststlt, 0x0E, 0x0B, 0x00600000, PPC_SPE_SINGLE),
8748GEN_SPE(efststeq, speundef, 0x0F, 0x0B, 0x00600000, PPC_SPE_SINGLE),
8749
8750GEN_SPE(efdadd, efdsub, 0x10, 0x0B, 0x00000000, PPC_SPE_DOUBLE),
8751GEN_SPE(efdcfuid, efdcfsid, 0x11, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8752GEN_SPE(efdabs, efdnabs, 0x12, 0x0B, 0x0000F800, PPC_SPE_DOUBLE),
8753GEN_SPE(efdneg, speundef, 0x13, 0x0B, 0x0000F800, PPC_SPE_DOUBLE),
8754GEN_SPE(efdmul, efddiv, 0x14, 0x0B, 0x00000000, PPC_SPE_DOUBLE),
8755GEN_SPE(efdctuidz, efdctsidz, 0x15, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8756GEN_SPE(efdcmpgt, efdcmplt, 0x16, 0x0B, 0x00600000, PPC_SPE_DOUBLE),
8757GEN_SPE(efdcmpeq, efdcfs, 0x17, 0x0B, 0x00600000, PPC_SPE_DOUBLE),
8758GEN_SPE(efdcfui, efdcfsi, 0x18, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8759GEN_SPE(efdcfuf, efdcfsf, 0x19, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8760GEN_SPE(efdctui, efdctsi, 0x1A, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8761GEN_SPE(efdctuf, efdctsf, 0x1B, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8762GEN_SPE(efdctuiz, speundef, 0x1C, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8763GEN_SPE(efdctsiz, speundef, 0x1D, 0x0B, 0x00180000, PPC_SPE_DOUBLE),
8764GEN_SPE(efdtstgt, efdtstlt, 0x1E, 0x0B, 0x00600000, PPC_SPE_DOUBLE),
8765GEN_SPE(efdtsteq, speundef, 0x1F, 0x0B, 0x00600000, PPC_SPE_DOUBLE),
8766
8767#undef GEN_SPEOP_LDST
8768#define GEN_SPEOP_LDST(name, opc2, sh) \
8769GEN_HANDLER(name, 0x04, opc2, 0x0C, 0x00000000, PPC_SPE)
8770GEN_SPEOP_LDST(evldd, 0x00, 3),
8771GEN_SPEOP_LDST(evldw, 0x01, 3),
8772GEN_SPEOP_LDST(evldh, 0x02, 3),
8773GEN_SPEOP_LDST(evlhhesplat, 0x04, 1),
8774GEN_SPEOP_LDST(evlhhousplat, 0x06, 1),
8775GEN_SPEOP_LDST(evlhhossplat, 0x07, 1),
8776GEN_SPEOP_LDST(evlwhe, 0x08, 2),
8777GEN_SPEOP_LDST(evlwhou, 0x0A, 2),
8778GEN_SPEOP_LDST(evlwhos, 0x0B, 2),
8779GEN_SPEOP_LDST(evlwwsplat, 0x0C, 2),
8780GEN_SPEOP_LDST(evlwhsplat, 0x0E, 2),
8781
8782GEN_SPEOP_LDST(evstdd, 0x10, 3),
8783GEN_SPEOP_LDST(evstdw, 0x11, 3),
8784GEN_SPEOP_LDST(evstdh, 0x12, 3),
8785GEN_SPEOP_LDST(evstwhe, 0x18, 2),
8786GEN_SPEOP_LDST(evstwho, 0x1A, 2),
8787GEN_SPEOP_LDST(evstwwe, 0x1C, 2),
8788GEN_SPEOP_LDST(evstwwo, 0x1E, 2),
8789};
8790
8791#include "translate_init.c"
8792#include "helper_regs.h"
8793
8794/*****************************************************************************/
8795/* Misc PowerPC helpers */
8796void cpu_dump_state (CPUState *env, FILE *f,
8797 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
8798 int flags)
8799{
8800#define RGPL 4
8801#define RFPL 4
8802
8803 int i;
8804
8805 cpu_fprintf(f, "NIP " ADDRX " LR " ADDRX " CTR " ADDRX " XER %08x\n",
8806 env->nip, env->lr, env->ctr, env->xer);
8807 cpu_fprintf(f, "MSR " ADDRX " HID0 " ADDRX " HF " ADDRX " idx %d\n",
8808 env->msr, env->spr[SPR_HID0], env->hflags, env->mmu_idx);
8809#if !defined(NO_TIMER_DUMP)
8810 cpu_fprintf(f, "TB %08x %08x "
8811#if !defined(CONFIG_USER_ONLY)
8812 "DECR %08x"
8813#endif
8814 "\n",
8815 cpu_ppc_load_tbu(env), cpu_ppc_load_tbl(env)
8816#if !defined(CONFIG_USER_ONLY)
8817 , cpu_ppc_load_decr(env)
8818#endif
8819 );
8820#endif
8821 for (i = 0; i < 32; i++) {
8822 if ((i & (RGPL - 1)) == 0)
8823 cpu_fprintf(f, "GPR%02d", i);
8824 cpu_fprintf(f, " " REGX, ppc_dump_gpr(env, i));
8825 if ((i & (RGPL - 1)) == (RGPL - 1))
8826 cpu_fprintf(f, "\n");
8827 }
8828 cpu_fprintf(f, "CR ");
8829 for (i = 0; i < 8; i++)
8830 cpu_fprintf(f, "%01x", env->crf[i]);
8831 cpu_fprintf(f, " [");
8832 for (i = 0; i < 8; i++) {
8833 char a = '-';
8834 if (env->crf[i] & 0x08)
8835 a = 'L';
8836 else if (env->crf[i] & 0x04)
8837 a = 'G';
8838 else if (env->crf[i] & 0x02)
8839 a = 'E';
8840 cpu_fprintf(f, " %c%c", a, env->crf[i] & 0x01 ? 'O' : ' ');
8841 }
8842 cpu_fprintf(f, " ] RES " ADDRX "\n", env->reserve_addr);
8843 for (i = 0; i < 32; i++) {
8844 if ((i & (RFPL - 1)) == 0)
8845 cpu_fprintf(f, "FPR%02d", i);
8846 cpu_fprintf(f, " %016" PRIx64, *((uint64_t *)&env->fpr[i]));
8847 if ((i & (RFPL - 1)) == (RFPL - 1))
8848 cpu_fprintf(f, "\n");
8849 }
8850 cpu_fprintf(f, "FPSCR %08x\n", env->fpscr);
8851#if !defined(CONFIG_USER_ONLY)
8852 cpu_fprintf(f, "SRR0 " ADDRX " SRR1 " ADDRX " SDR1 " ADDRX "\n",
8853 env->spr[SPR_SRR0], env->spr[SPR_SRR1], env->sdr1);
8854#endif
8855
8856#undef RGPL
8857#undef RFPL
8858}
8859
8860void cpu_dump_statistics (CPUState *env, FILE*f,
8861 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
8862 int flags)
8863{
8864#if defined(DO_PPC_STATISTICS)
8865 opc_handler_t **t1, **t2, **t3, *handler;
8866 int op1, op2, op3;
8867
8868 t1 = env->opcodes;
8869 for (op1 = 0; op1 < 64; op1++) {
8870 handler = t1[op1];
8871 if (is_indirect_opcode(handler)) {
8872 t2 = ind_table(handler);
8873 for (op2 = 0; op2 < 32; op2++) {
8874 handler = t2[op2];
8875 if (is_indirect_opcode(handler)) {
8876 t3 = ind_table(handler);
8877 for (op3 = 0; op3 < 32; op3++) {
8878 handler = t3[op3];
8879 if (handler->count == 0)
8880 continue;
8881 cpu_fprintf(f, "%02x %02x %02x (%02x %04d) %16s: "
8882 "%016llx %lld\n",
8883 op1, op2, op3, op1, (op3 << 5) | op2,
8884 handler->oname,
8885 handler->count, handler->count);
8886 }
8887 } else {
8888 if (handler->count == 0)
8889 continue;
8890 cpu_fprintf(f, "%02x %02x (%02x %04d) %16s: "
8891 "%016llx %lld\n",
8892 op1, op2, op1, op2, handler->oname,
8893 handler->count, handler->count);
8894 }
8895 }
8896 } else {
8897 if (handler->count == 0)
8898 continue;
8899 cpu_fprintf(f, "%02x (%02x ) %16s: %016llx %lld\n",
8900 op1, op1, handler->oname,
8901 handler->count, handler->count);
8902 }
8903 }
8904#endif
8905}
8906
8907/*****************************************************************************/
8908static always_inline void gen_intermediate_code_internal (CPUState *env,
8909 TranslationBlock *tb,
8910 int search_pc)
8911{
8912 DisasContext ctx, *ctxp = &ctx;
8913 opc_handler_t **table, *handler;
8914 target_ulong pc_start;
8915 uint16_t *gen_opc_end;
8916 CPUBreakpoint *bp;
8917 int j, lj = -1;
8918 int num_insns;
8919 int max_insns;
8920
8921 pc_start = tb->pc;
8922 gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
8923 ctx.nip = pc_start;
8924 ctx.tb = tb;
8925 ctx.exception = POWERPC_EXCP_NONE;
8926 ctx.spr_cb = env->spr_cb;
8927 ctx.mem_idx = env->mmu_idx;
8928 ctx.access_type = -1;
8929 ctx.le_mode = env->hflags & (1 << MSR_LE) ? 1 : 0;
8930#if defined(TARGET_PPC64)
8931 ctx.sf_mode = msr_sf;
8932#endif
8933 ctx.fpu_enabled = msr_fp;
8934 if ((env->flags & POWERPC_FLAG_SPE) && msr_spe)
8935 ctx.spe_enabled = msr_spe;
8936 else
8937 ctx.spe_enabled = 0;
8938 if ((env->flags & POWERPC_FLAG_VRE) && msr_vr)
8939 ctx.altivec_enabled = msr_vr;
8940 else
8941 ctx.altivec_enabled = 0;
8942 if ((env->flags & POWERPC_FLAG_SE) && msr_se)
8943 ctx.singlestep_enabled = CPU_SINGLE_STEP;
8944 else
8945 ctx.singlestep_enabled = 0;
8946 if ((env->flags & POWERPC_FLAG_BE) && msr_be)
8947 ctx.singlestep_enabled |= CPU_BRANCH_STEP;
8948 if (unlikely(env->singlestep_enabled))
8949 ctx.singlestep_enabled |= GDBSTUB_SINGLE_STEP;
8950#if defined (DO_SINGLE_STEP) && 0
8951 /* Single step trace mode */
8952 msr_se = 1;
8953#endif
8954 num_insns = 0;
8955 max_insns = tb->cflags & CF_COUNT_MASK;
8956 if (max_insns == 0)
8957 max_insns = CF_COUNT_MASK;
8958
8959 gen_icount_start();
8960 /* Set env in case of segfault during code fetch */
8961 while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) {
8962 if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) {
8963 TAILQ_FOREACH(bp, &env->breakpoints, entry) {
8964 if (bp->pc == ctx.nip) {
8965 gen_debug_exception(ctxp);
8966 break;
8967 }
8968 }
8969 }
8970 if (unlikely(search_pc)) {
8971 j = gen_opc_ptr - gen_opc_buf;
8972 if (lj < j) {
8973 lj++;
8974 while (lj < j)
8975 gen_opc_instr_start[lj++] = 0;
8976 }
8977 gen_opc_pc[lj] = ctx.nip;
8978 gen_opc_instr_start[lj] = 1;
8979 gen_opc_icount[lj] = num_insns;
8980 }
8981 LOG_DISAS("----------------\n");
8982 LOG_DISAS("nip=" ADDRX " super=%d ir=%d\n",
8983 ctx.nip, ctx.mem_idx, (int)msr_ir);
8984 if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
8985 gen_io_start();
8986 if (unlikely(ctx.le_mode)) {
8987 ctx.opcode = bswap32(ldl_code(ctx.nip));
8988 } else {
8989 ctx.opcode = ldl_code(ctx.nip);
8990 }
8991 LOG_DISAS("translate opcode %08x (%02x %02x %02x) (%s)\n",
8992 ctx.opcode, opc1(ctx.opcode), opc2(ctx.opcode),
8993 opc3(ctx.opcode), little_endian ? "little" : "big");
8994 ctx.nip += 4;
8995 table = env->opcodes;
8996 num_insns++;
8997 handler = table[opc1(ctx.opcode)];
8998 if (is_indirect_opcode(handler)) {
8999 table = ind_table(handler);
9000 handler = table[opc2(ctx.opcode)];
9001 if (is_indirect_opcode(handler)) {
9002 table = ind_table(handler);
9003 handler = table[opc3(ctx.opcode)];
9004 }
9005 }
9006 /* Is opcode *REALLY* valid ? */
9007 if (unlikely(handler->handler == &gen_invalid)) {
9008 if (qemu_log_enabled()) {
9009 qemu_log("invalid/unsupported opcode: "
9010 "%02x - %02x - %02x (%08x) " ADDRX " %d\n",
9011 opc1(ctx.opcode), opc2(ctx.opcode),
9012 opc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);
9013 } else {
9014 printf("invalid/unsupported opcode: "
9015 "%02x - %02x - %02x (%08x) " ADDRX " %d\n",
9016 opc1(ctx.opcode), opc2(ctx.opcode),
9017 opc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);
9018 }
9019 } else {
9020 if (unlikely((ctx.opcode & handler->inval) != 0)) {
9021 if (qemu_log_enabled()) {
9022 qemu_log("invalid bits: %08x for opcode: "
9023 "%02x - %02x - %02x (%08x) " ADDRX "\n",
9024 ctx.opcode & handler->inval, opc1(ctx.opcode),
9025 opc2(ctx.opcode), opc3(ctx.opcode),
9026 ctx.opcode, ctx.nip - 4);
9027 } else {
9028 printf("invalid bits: %08x for opcode: "
9029 "%02x - %02x - %02x (%08x) " ADDRX "\n",
9030 ctx.opcode & handler->inval, opc1(ctx.opcode),
9031 opc2(ctx.opcode), opc3(ctx.opcode),
9032 ctx.opcode, ctx.nip - 4);
9033 }
9034 gen_inval_exception(ctxp, POWERPC_EXCP_INVAL_INVAL);
9035 break;
9036 }
9037 }
9038 (*(handler->handler))(&ctx);
9039#if defined(DO_PPC_STATISTICS)
9040 handler->count++;
9041#endif
9042 /* Check trace mode exceptions */
9043 if (unlikely(ctx.singlestep_enabled & CPU_SINGLE_STEP &&
9044 (ctx.nip <= 0x100 || ctx.nip > 0xF00) &&
9045 ctx.exception != POWERPC_SYSCALL &&
9046 ctx.exception != POWERPC_EXCP_TRAP &&
9047 ctx.exception != POWERPC_EXCP_BRANCH)) {
9048 gen_exception(ctxp, POWERPC_EXCP_TRACE);
9049 } else if (unlikely(((ctx.nip & (TARGET_PAGE_SIZE - 1)) == 0) ||
9050 (env->singlestep_enabled) ||
9051 singlestep ||
9052 num_insns >= max_insns)) {
9053 /* if we reach a page boundary or are single stepping, stop
9054 * generation
9055 */
9056 break;
9057 }
9058 }
9059 if (tb->cflags & CF_LAST_IO)
9060 gen_io_end();
9061 if (ctx.exception == POWERPC_EXCP_NONE) {
9062 gen_goto_tb(&ctx, 0, ctx.nip);
9063 } else if (ctx.exception != POWERPC_EXCP_BRANCH) {
9064 if (unlikely(env->singlestep_enabled)) {
9065 gen_debug_exception(ctxp);
9066 }
9067 /* Generate the return instruction */
9068 tcg_gen_exit_tb(0);
9069 }
9070 gen_icount_end(tb, num_insns);
9071 *gen_opc_ptr = INDEX_op_end;
9072 if (unlikely(search_pc)) {
9073 j = gen_opc_ptr - gen_opc_buf;
9074 lj++;
9075 while (lj <= j)
9076 gen_opc_instr_start[lj++] = 0;
9077 } else {
9078 tb->size = ctx.nip - pc_start;
9079 tb->icount = num_insns;
9080 }
9081#if defined(DEBUG_DISAS)
9082 qemu_log_mask(CPU_LOG_TB_CPU, "---------------- excp: %04x\n", ctx.exception);
9083 log_cpu_state_mask(CPU_LOG_TB_CPU, env, 0);
9084 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
9085 int flags;
9086 flags = env->bfd_mach;
9087 flags |= ctx.le_mode << 16;
9088 qemu_log("IN: %s\n", lookup_symbol(pc_start));
9089 log_target_disas(pc_start, ctx.nip - pc_start, flags);
9090 qemu_log("\n");
9091 }
9092#endif
9093}
9094
9095void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
9096{
9097 gen_intermediate_code_internal(env, tb, 0);
9098}
9099
9100void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
9101{
9102 gen_intermediate_code_internal(env, tb, 1);
9103}
9104
9105void gen_pc_load(CPUState *env, TranslationBlock *tb,
9106 unsigned long searched_pc, int pc_pos, void *puc)
9107{
9108 env->nip = gen_opc_pc[pc_pos];
9109}
Qemu copy for testing