?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acpi:ich9: convert cpu hotplug to hotplug_handler API
[qemu.git] / target-s390x / translate.c
blob0cb036f667c2d1f9b7c52687c0ec531c159277b9
1 /*
2 * S/390 translation
3 *
4 * Copyright (c) 2009 Ulrich Hecht
5 * Copyright (c) 2010 Alexander Graf
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 /* #define DEBUG_INLINE_BRANCHES */
22 #define S390X_DEBUG_DISAS
23 /* #define S390X_DEBUG_DISAS_VERBOSE */
24
25 #ifdef S390X_DEBUG_DISAS_VERBOSE
26 # define LOG_DISAS(...) qemu_log(__VA_ARGS__)
27 #else
28 # define LOG_DISAS(...) do { } while (0)
29 #endif
30
31 #include "cpu.h"
32 #include "disas/disas.h"
33 #include "tcg-op.h"
34 #include "qemu/log.h"
35 #include "qemu/host-utils.h"
36 #include "exec/cpu_ldst.h"
37
38 /* global register indexes */
39 static TCGv_ptr cpu_env;
40
41 #include "exec/gen-icount.h"
42 #include "exec/helper-proto.h"
43 #include "exec/helper-gen.h"
44
45 #include "trace-tcg.h"
46
47
48 /* Information that (most) every instruction needs to manipulate. */
49 typedef struct DisasContext DisasContext;
50 typedef struct DisasInsn DisasInsn;
51 typedef struct DisasFields DisasFields;
52
53 struct DisasContext {
54 struct TranslationBlock *tb;
55 const DisasInsn *insn;
56 DisasFields *fields;
57 uint64_t pc, next_pc;
58 enum cc_op cc_op;
59 bool singlestep_enabled;
60 };
61
62 /* Information carried about a condition to be evaluated. */
63 typedef struct {
64 TCGCond cond:8;
65 bool is_64;
66 bool g1;
67 bool g2;
68 union {
69 struct { TCGv_i64 a, b; } s64;
70 struct { TCGv_i32 a, b; } s32;
71 } u;
72 } DisasCompare;
73
74 #define DISAS_EXCP 4
75
76 #ifdef DEBUG_INLINE_BRANCHES
77 static uint64_t inline_branch_hit[CC_OP_MAX];
78 static uint64_t inline_branch_miss[CC_OP_MAX];
79 #endif
80
81 static uint64_t pc_to_link_info(DisasContext *s, uint64_t pc)
82 {
83 if (!(s->tb->flags & FLAG_MASK_64)) {
84 if (s->tb->flags & FLAG_MASK_32) {
85 return pc | 0x80000000;
86 }
87 }
88 return pc;
89 }
90
91 void s390_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
92 int flags)
93 {
94 S390CPU *cpu = S390_CPU(cs);
95 CPUS390XState *env = &cpu->env;
96 int i;
97
98 if (env->cc_op > 3) {
99 cpu_fprintf(f, "PSW=mask %016" PRIx64 " addr %016" PRIx64 " cc %15s\n",
100 env->psw.mask, env->psw.addr, cc_name(env->cc_op));
101 } else {
102 cpu_fprintf(f, "PSW=mask %016" PRIx64 " addr %016" PRIx64 " cc %02x\n",
103 env->psw.mask, env->psw.addr, env->cc_op);
104 }
105
106 for (i = 0; i < 16; i++) {
107 cpu_fprintf(f, "R%02d=%016" PRIx64, i, env->regs[i]);
108 if ((i % 4) == 3) {
109 cpu_fprintf(f, "\n");
110 } else {
111 cpu_fprintf(f, " ");
112 }
113 }
114
115 for (i = 0; i < 16; i++) {
116 cpu_fprintf(f, "F%02d=%016" PRIx64, i, env->fregs[i].ll);
117 if ((i % 4) == 3) {
118 cpu_fprintf(f, "\n");
119 } else {
120 cpu_fprintf(f, " ");
121 }
122 }
123
124 #ifndef CONFIG_USER_ONLY
125 for (i = 0; i < 16; i++) {
126 cpu_fprintf(f, "C%02d=%016" PRIx64, i, env->cregs[i]);
127 if ((i % 4) == 3) {
128 cpu_fprintf(f, "\n");
129 } else {
130 cpu_fprintf(f, " ");
131 }
132 }
133 #endif
134
135 #ifdef DEBUG_INLINE_BRANCHES
136 for (i = 0; i < CC_OP_MAX; i++) {
137 cpu_fprintf(f, " %15s = %10ld\t%10ld\n", cc_name(i),
138 inline_branch_miss[i], inline_branch_hit[i]);
139 }
140 #endif
141
142 cpu_fprintf(f, "\n");
143 }
144
145 static TCGv_i64 psw_addr;
146 static TCGv_i64 psw_mask;
147
148 static TCGv_i32 cc_op;
149 static TCGv_i64 cc_src;
150 static TCGv_i64 cc_dst;
151 static TCGv_i64 cc_vr;
152
153 static char cpu_reg_names[32][4];
154 static TCGv_i64 regs[16];
155 static TCGv_i64 fregs[16];
156
157 static uint8_t gen_opc_cc_op[OPC_BUF_SIZE];
158
159 void s390x_translate_init(void)
160 {
161 int i;
162
163 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
164 psw_addr = tcg_global_mem_new_i64(TCG_AREG0,
165 offsetof(CPUS390XState, psw.addr),
166 "psw_addr");
167 psw_mask = tcg_global_mem_new_i64(TCG_AREG0,
168 offsetof(CPUS390XState, psw.mask),
169 "psw_mask");
170
171 cc_op = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUS390XState, cc_op),
172 "cc_op");
173 cc_src = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUS390XState, cc_src),
174 "cc_src");
175 cc_dst = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUS390XState, cc_dst),
176 "cc_dst");
177 cc_vr = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUS390XState, cc_vr),
178 "cc_vr");
179
180 for (i = 0; i < 16; i++) {
181 snprintf(cpu_reg_names[i], sizeof(cpu_reg_names[0]), "r%d", i);
182 regs[i] = tcg_global_mem_new(TCG_AREG0,
183 offsetof(CPUS390XState, regs[i]),
184 cpu_reg_names[i]);
185 }
186
187 for (i = 0; i < 16; i++) {
188 snprintf(cpu_reg_names[i + 16], sizeof(cpu_reg_names[0]), "f%d", i);
189 fregs[i] = tcg_global_mem_new(TCG_AREG0,
190 offsetof(CPUS390XState, fregs[i].d),
191 cpu_reg_names[i + 16]);
192 }
193 }
194
195 static TCGv_i64 load_reg(int reg)
196 {
197 TCGv_i64 r = tcg_temp_new_i64();
198 tcg_gen_mov_i64(r, regs[reg]);
199 return r;
200 }
201
202 static TCGv_i64 load_freg32_i64(int reg)
203 {
204 TCGv_i64 r = tcg_temp_new_i64();
205 tcg_gen_shri_i64(r, fregs[reg], 32);
206 return r;
207 }
208
209 static void store_reg(int reg, TCGv_i64 v)
210 {
211 tcg_gen_mov_i64(regs[reg], v);
212 }
213
214 static void store_freg(int reg, TCGv_i64 v)
215 {
216 tcg_gen_mov_i64(fregs[reg], v);
217 }
218
219 static void store_reg32_i64(int reg, TCGv_i64 v)
220 {
221 /* 32 bit register writes keep the upper half */
222 tcg_gen_deposit_i64(regs[reg], regs[reg], v, 0, 32);
223 }
224
225 static void store_reg32h_i64(int reg, TCGv_i64 v)
226 {
227 tcg_gen_deposit_i64(regs[reg], regs[reg], v, 32, 32);
228 }
229
230 static void store_freg32_i64(int reg, TCGv_i64 v)
231 {
232 tcg_gen_deposit_i64(fregs[reg], fregs[reg], v, 32, 32);
233 }
234
235 static void return_low128(TCGv_i64 dest)
236 {
237 tcg_gen_ld_i64(dest, cpu_env, offsetof(CPUS390XState, retxl));
238 }
239
240 static void update_psw_addr(DisasContext *s)
241 {
242 /* psw.addr */
243 tcg_gen_movi_i64(psw_addr, s->pc);
244 }
245
246 static void update_cc_op(DisasContext *s)
247 {
248 if (s->cc_op != CC_OP_DYNAMIC && s->cc_op != CC_OP_STATIC) {
249 tcg_gen_movi_i32(cc_op, s->cc_op);
250 }
251 }
252
253 static void potential_page_fault(DisasContext *s)
254 {
255 update_psw_addr(s);
256 update_cc_op(s);
257 }
258
259 static inline uint64_t ld_code2(CPUS390XState *env, uint64_t pc)
260 {
261 return (uint64_t)cpu_lduw_code(env, pc);
262 }
263
264 static inline uint64_t ld_code4(CPUS390XState *env, uint64_t pc)
265 {
266 return (uint64_t)(uint32_t)cpu_ldl_code(env, pc);
267 }
268
269 static int get_mem_index(DisasContext *s)
270 {
271 switch (s->tb->flags & FLAG_MASK_ASC) {
272 case PSW_ASC_PRIMARY >> 32:
273 return 0;
274 case PSW_ASC_SECONDARY >> 32:
275 return 1;
276 case PSW_ASC_HOME >> 32:
277 return 2;
278 default:
279 tcg_abort();
280 break;
281 }
282 }
283
284 static void gen_exception(int excp)
285 {
286 TCGv_i32 tmp = tcg_const_i32(excp);
287 gen_helper_exception(cpu_env, tmp);
288 tcg_temp_free_i32(tmp);
289 }
290
291 static void gen_program_exception(DisasContext *s, int code)
292 {
293 TCGv_i32 tmp;
294
295 /* Remember what pgm exeption this was. */
296 tmp = tcg_const_i32(code);
297 tcg_gen_st_i32(tmp, cpu_env, offsetof(CPUS390XState, int_pgm_code));
298 tcg_temp_free_i32(tmp);
299
300 tmp = tcg_const_i32(s->next_pc - s->pc);
301 tcg_gen_st_i32(tmp, cpu_env, offsetof(CPUS390XState, int_pgm_ilen));
302 tcg_temp_free_i32(tmp);
303
304 /* Advance past instruction. */
305 s->pc = s->next_pc;
306 update_psw_addr(s);
307
308 /* Save off cc. */
309 update_cc_op(s);
310
311 /* Trigger exception. */
312 gen_exception(EXCP_PGM);
313 }
314
315 static inline void gen_illegal_opcode(DisasContext *s)
316 {
317 gen_program_exception(s, PGM_SPECIFICATION);
318 }
319
320 static inline void check_privileged(DisasContext *s)
321 {
322 if (s->tb->flags & (PSW_MASK_PSTATE >> 32)) {
323 gen_program_exception(s, PGM_PRIVILEGED);
324 }
325 }
326
327 static TCGv_i64 get_address(DisasContext *s, int x2, int b2, int d2)
328 {
329 TCGv_i64 tmp = tcg_temp_new_i64();
330 bool need_31 = !(s->tb->flags & FLAG_MASK_64);
331
332 /* Note that d2 is limited to 20 bits, signed. If we crop negative
333 displacements early we create larger immedate addends. */
334
335 /* Note that addi optimizes the imm==0 case. */
336 if (b2 && x2) {
337 tcg_gen_add_i64(tmp, regs[b2], regs[x2]);
338 tcg_gen_addi_i64(tmp, tmp, d2);
339 } else if (b2) {
340 tcg_gen_addi_i64(tmp, regs[b2], d2);
341 } else if (x2) {
342 tcg_gen_addi_i64(tmp, regs[x2], d2);
343 } else {
344 if (need_31) {
345 d2 &= 0x7fffffff;
346 need_31 = false;
347 }
348 tcg_gen_movi_i64(tmp, d2);
349 }
350 if (need_31) {
351 tcg_gen_andi_i64(tmp, tmp, 0x7fffffff);
352 }
353
354 return tmp;
355 }
356
357 static inline bool live_cc_data(DisasContext *s)
358 {
359 return (s->cc_op != CC_OP_DYNAMIC
360 && s->cc_op != CC_OP_STATIC
361 && s->cc_op > 3);
362 }
363
364 static inline void gen_op_movi_cc(DisasContext *s, uint32_t val)
365 {
366 if (live_cc_data(s)) {
367 tcg_gen_discard_i64(cc_src);
368 tcg_gen_discard_i64(cc_dst);
369 tcg_gen_discard_i64(cc_vr);
370 }
371 s->cc_op = CC_OP_CONST0 + val;
372 }
373
374 static void gen_op_update1_cc_i64(DisasContext *s, enum cc_op op, TCGv_i64 dst)
375 {
376 if (live_cc_data(s)) {
377 tcg_gen_discard_i64(cc_src);
378 tcg_gen_discard_i64(cc_vr);
379 }
380 tcg_gen_mov_i64(cc_dst, dst);
381 s->cc_op = op;
382 }
383
384 static void gen_op_update2_cc_i64(DisasContext *s, enum cc_op op, TCGv_i64 src,
385 TCGv_i64 dst)
386 {
387 if (live_cc_data(s)) {
388 tcg_gen_discard_i64(cc_vr);
389 }
390 tcg_gen_mov_i64(cc_src, src);
391 tcg_gen_mov_i64(cc_dst, dst);
392 s->cc_op = op;
393 }
394
395 static void gen_op_update3_cc_i64(DisasContext *s, enum cc_op op, TCGv_i64 src,
396 TCGv_i64 dst, TCGv_i64 vr)
397 {
398 tcg_gen_mov_i64(cc_src, src);
399 tcg_gen_mov_i64(cc_dst, dst);
400 tcg_gen_mov_i64(cc_vr, vr);
401 s->cc_op = op;
402 }
403
404 static void set_cc_nz_u64(DisasContext *s, TCGv_i64 val)
405 {
406 gen_op_update1_cc_i64(s, CC_OP_NZ, val);
407 }
408
409 static void gen_set_cc_nz_f32(DisasContext *s, TCGv_i64 val)
410 {
411 gen_op_update1_cc_i64(s, CC_OP_NZ_F32, val);
412 }
413
414 static void gen_set_cc_nz_f64(DisasContext *s, TCGv_i64 val)
415 {
416 gen_op_update1_cc_i64(s, CC_OP_NZ_F64, val);
417 }
418
419 static void gen_set_cc_nz_f128(DisasContext *s, TCGv_i64 vh, TCGv_i64 vl)
420 {
421 gen_op_update2_cc_i64(s, CC_OP_NZ_F128, vh, vl);
422 }
423
424 /* CC value is in env->cc_op */
425 static void set_cc_static(DisasContext *s)
426 {
427 if (live_cc_data(s)) {
428 tcg_gen_discard_i64(cc_src);
429 tcg_gen_discard_i64(cc_dst);
430 tcg_gen_discard_i64(cc_vr);
431 }
432 s->cc_op = CC_OP_STATIC;
433 }
434
435 /* calculates cc into cc_op */
436 static void gen_op_calc_cc(DisasContext *s)
437 {
438 TCGv_i32 local_cc_op;
439 TCGv_i64 dummy;
440
441 TCGV_UNUSED_I32(local_cc_op);
442 TCGV_UNUSED_I64(dummy);
443 switch (s->cc_op) {
444 default:
445 dummy = tcg_const_i64(0);
446 /* FALLTHRU */
447 case CC_OP_ADD_64:
448 case CC_OP_ADDU_64:
449 case CC_OP_ADDC_64:
450 case CC_OP_SUB_64:
451 case CC_OP_SUBU_64:
452 case CC_OP_SUBB_64:
453 case CC_OP_ADD_32:
454 case CC_OP_ADDU_32:
455 case CC_OP_ADDC_32:
456 case CC_OP_SUB_32:
457 case CC_OP_SUBU_32:
458 case CC_OP_SUBB_32:
459 local_cc_op = tcg_const_i32(s->cc_op);
460 break;
461 case CC_OP_CONST0:
462 case CC_OP_CONST1:
463 case CC_OP_CONST2:
464 case CC_OP_CONST3:
465 case CC_OP_STATIC:
466 case CC_OP_DYNAMIC:
467 break;
468 }
469
470 switch (s->cc_op) {
471 case CC_OP_CONST0:
472 case CC_OP_CONST1:
473 case CC_OP_CONST2:
474 case CC_OP_CONST3:
475 /* s->cc_op is the cc value */
476 tcg_gen_movi_i32(cc_op, s->cc_op - CC_OP_CONST0);
477 break;
478 case CC_OP_STATIC:
479 /* env->cc_op already is the cc value */
480 break;
481 case CC_OP_NZ:
482 case CC_OP_ABS_64:
483 case CC_OP_NABS_64:
484 case CC_OP_ABS_32:
485 case CC_OP_NABS_32:
486 case CC_OP_LTGT0_32:
487 case CC_OP_LTGT0_64:
488 case CC_OP_COMP_32:
489 case CC_OP_COMP_64:
490 case CC_OP_NZ_F32:
491 case CC_OP_NZ_F64:
492 case CC_OP_FLOGR:
493 /* 1 argument */
494 gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, dummy, cc_dst, dummy);
495 break;
496 case CC_OP_ICM:
497 case CC_OP_LTGT_32:
498 case CC_OP_LTGT_64:
499 case CC_OP_LTUGTU_32:
500 case CC_OP_LTUGTU_64:
501 case CC_OP_TM_32:
502 case CC_OP_TM_64:
503 case CC_OP_SLA_32:
504 case CC_OP_SLA_64:
505 case CC_OP_NZ_F128:
506 /* 2 arguments */
507 gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, cc_src, cc_dst, dummy);
508 break;
509 case CC_OP_ADD_64:
510 case CC_OP_ADDU_64:
511 case CC_OP_ADDC_64:
512 case CC_OP_SUB_64:
513 case CC_OP_SUBU_64:
514 case CC_OP_SUBB_64:
515 case CC_OP_ADD_32:
516 case CC_OP_ADDU_32:
517 case CC_OP_ADDC_32:
518 case CC_OP_SUB_32:
519 case CC_OP_SUBU_32:
520 case CC_OP_SUBB_32:
521 /* 3 arguments */
522 gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, cc_src, cc_dst, cc_vr);
523 break;
524 case CC_OP_DYNAMIC:
525 /* unknown operation - assume 3 arguments and cc_op in env */
526 gen_helper_calc_cc(cc_op, cpu_env, cc_op, cc_src, cc_dst, cc_vr);
527 break;
528 default:
529 tcg_abort();
530 }
531
532 if (!TCGV_IS_UNUSED_I32(local_cc_op)) {
533 tcg_temp_free_i32(local_cc_op);
534 }
535 if (!TCGV_IS_UNUSED_I64(dummy)) {
536 tcg_temp_free_i64(dummy);
537 }
538
539 /* We now have cc in cc_op as constant */
540 set_cc_static(s);
541 }
542
543 static int use_goto_tb(DisasContext *s, uint64_t dest)
544 {
545 /* NOTE: we handle the case where the TB spans two pages here */
546 return (((dest & TARGET_PAGE_MASK) == (s->tb->pc & TARGET_PAGE_MASK)
547 || (dest & TARGET_PAGE_MASK) == ((s->pc - 1) & TARGET_PAGE_MASK))
548 && !s->singlestep_enabled
549 && !(s->tb->cflags & CF_LAST_IO));
550 }
551
552 static void account_noninline_branch(DisasContext *s, int cc_op)
553 {
554 #ifdef DEBUG_INLINE_BRANCHES
555 inline_branch_miss[cc_op]++;
556 #endif
557 }
558
559 static void account_inline_branch(DisasContext *s, int cc_op)
560 {
561 #ifdef DEBUG_INLINE_BRANCHES
562 inline_branch_hit[cc_op]++;
563 #endif
564 }
565
566 /* Table of mask values to comparison codes, given a comparison as input.
567 For such, CC=3 should not be possible. */
568 static const TCGCond ltgt_cond[16] = {
569 TCG_COND_NEVER, TCG_COND_NEVER, /* | | | x */
570 TCG_COND_GT, TCG_COND_GT, /* | | GT | x */
571 TCG_COND_LT, TCG_COND_LT, /* | LT | | x */
572 TCG_COND_NE, TCG_COND_NE, /* | LT | GT | x */
573 TCG_COND_EQ, TCG_COND_EQ, /* EQ | | | x */
574 TCG_COND_GE, TCG_COND_GE, /* EQ | | GT | x */
575 TCG_COND_LE, TCG_COND_LE, /* EQ | LT | | x */
576 TCG_COND_ALWAYS, TCG_COND_ALWAYS, /* EQ | LT | GT | x */
577 };
578
579 /* Table of mask values to comparison codes, given a logic op as input.
580 For such, only CC=0 and CC=1 should be possible. */
581 static const TCGCond nz_cond[16] = {
582 TCG_COND_NEVER, TCG_COND_NEVER, /* | | x | x */
583 TCG_COND_NEVER, TCG_COND_NEVER,
584 TCG_COND_NE, TCG_COND_NE, /* | NE | x | x */
585 TCG_COND_NE, TCG_COND_NE,
586 TCG_COND_EQ, TCG_COND_EQ, /* EQ | | x | x */
587 TCG_COND_EQ, TCG_COND_EQ,
588 TCG_COND_ALWAYS, TCG_COND_ALWAYS, /* EQ | NE | x | x */
589 TCG_COND_ALWAYS, TCG_COND_ALWAYS,
590 };
591
592 /* Interpret MASK in terms of S->CC_OP, and fill in C with all the
593 details required to generate a TCG comparison. */
594 static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
595 {
596 TCGCond cond;
597 enum cc_op old_cc_op = s->cc_op;
598
599 if (mask == 15 || mask == 0) {
600 c->cond = (mask ? TCG_COND_ALWAYS : TCG_COND_NEVER);
601 c->u.s32.a = cc_op;
602 c->u.s32.b = cc_op;
603 c->g1 = c->g2 = true;
604 c->is_64 = false;
605 return;
606 }
607
608 /* Find the TCG condition for the mask + cc op. */
609 switch (old_cc_op) {
610 case CC_OP_LTGT0_32:
611 case CC_OP_LTGT0_64:
612 case CC_OP_LTGT_32:
613 case CC_OP_LTGT_64:
614 cond = ltgt_cond[mask];
615 if (cond == TCG_COND_NEVER) {
616 goto do_dynamic;
617 }
618 account_inline_branch(s, old_cc_op);
619 break;
620
621 case CC_OP_LTUGTU_32:
622 case CC_OP_LTUGTU_64:
623 cond = tcg_unsigned_cond(ltgt_cond[mask]);
624 if (cond == TCG_COND_NEVER) {
625 goto do_dynamic;
626 }
627 account_inline_branch(s, old_cc_op);
628 break;
629
630 case CC_OP_NZ:
631 cond = nz_cond[mask];
632 if (cond == TCG_COND_NEVER) {
633 goto do_dynamic;
634 }
635 account_inline_branch(s, old_cc_op);
636 break;
637
638 case CC_OP_TM_32:
639 case CC_OP_TM_64:
640 switch (mask) {
641 case 8:
642 cond = TCG_COND_EQ;
643 break;
644 case 4 | 2 | 1:
645 cond = TCG_COND_NE;
646 break;
647 default:
648 goto do_dynamic;
649 }
650 account_inline_branch(s, old_cc_op);
651 break;
652
653 case CC_OP_ICM:
654 switch (mask) {
655 case 8:
656 cond = TCG_COND_EQ;
657 break;
658 case 4 | 2 | 1:
659 case 4 | 2:
660 cond = TCG_COND_NE;
661 break;
662 default:
663 goto do_dynamic;
664 }
665 account_inline_branch(s, old_cc_op);
666 break;
667
668 case CC_OP_FLOGR:
669 switch (mask & 0xa) {
670 case 8: /* src == 0 -> no one bit found */
671 cond = TCG_COND_EQ;
672 break;
673 case 2: /* src != 0 -> one bit found */
674 cond = TCG_COND_NE;
675 break;
676 default:
677 goto do_dynamic;
678 }
679 account_inline_branch(s, old_cc_op);
680 break;
681
682 case CC_OP_ADDU_32:
683 case CC_OP_ADDU_64:
684 switch (mask) {
685 case 8 | 2: /* vr == 0 */
686 cond = TCG_COND_EQ;
687 break;
688 case 4 | 1: /* vr != 0 */
689 cond = TCG_COND_NE;
690 break;
691 case 8 | 4: /* no carry -> vr >= src */
692 cond = TCG_COND_GEU;
693 break;
694 case 2 | 1: /* carry -> vr < src */
695 cond = TCG_COND_LTU;
696 break;
697 default:
698 goto do_dynamic;
699 }
700 account_inline_branch(s, old_cc_op);
701 break;
702
703 case CC_OP_SUBU_32:
704 case CC_OP_SUBU_64:
705 /* Note that CC=0 is impossible; treat it as dont-care. */
706 switch (mask & 7) {
707 case 2: /* zero -> op1 == op2 */
708 cond = TCG_COND_EQ;
709 break;
710 case 4 | 1: /* !zero -> op1 != op2 */
711 cond = TCG_COND_NE;
712 break;
713 case 4: /* borrow (!carry) -> op1 < op2 */
714 cond = TCG_COND_LTU;
715 break;
716 case 2 | 1: /* !borrow (carry) -> op1 >= op2 */
717 cond = TCG_COND_GEU;
718 break;
719 default:
720 goto do_dynamic;
721 }
722 account_inline_branch(s, old_cc_op);
723 break;
724
725 default:
726 do_dynamic:
727 /* Calculate cc value. */
728 gen_op_calc_cc(s);
729 /* FALLTHRU */
730
731 case CC_OP_STATIC:
732 /* Jump based on CC. We'll load up the real cond below;
733 the assignment here merely avoids a compiler warning. */
734 account_noninline_branch(s, old_cc_op);
735 old_cc_op = CC_OP_STATIC;
736 cond = TCG_COND_NEVER;
737 break;
738 }
739
740 /* Load up the arguments of the comparison. */
741 c->is_64 = true;
742 c->g1 = c->g2 = false;
743 switch (old_cc_op) {
744 case CC_OP_LTGT0_32:
745 c->is_64 = false;
746 c->u.s32.a = tcg_temp_new_i32();
747 tcg_gen_trunc_i64_i32(c->u.s32.a, cc_dst);
748 c->u.s32.b = tcg_const_i32(0);
749 break;
750 case CC_OP_LTGT_32:
751 case CC_OP_LTUGTU_32:
752 case CC_OP_SUBU_32:
753 c->is_64 = false;
754 c->u.s32.a = tcg_temp_new_i32();
755 tcg_gen_trunc_i64_i32(c->u.s32.a, cc_src);
756 c->u.s32.b = tcg_temp_new_i32();
757 tcg_gen_trunc_i64_i32(c->u.s32.b, cc_dst);
758 break;
759
760 case CC_OP_LTGT0_64:
761 case CC_OP_NZ:
762 case CC_OP_FLOGR:
763 c->u.s64.a = cc_dst;
764 c->u.s64.b = tcg_const_i64(0);
765 c->g1 = true;
766 break;
767 case CC_OP_LTGT_64:
768 case CC_OP_LTUGTU_64:
769 case CC_OP_SUBU_64:
770 c->u.s64.a = cc_src;
771 c->u.s64.b = cc_dst;
772 c->g1 = c->g2 = true;
773 break;
774
775 case CC_OP_TM_32:
776 case CC_OP_TM_64:
777 case CC_OP_ICM:
778 c->u.s64.a = tcg_temp_new_i64();
779 c->u.s64.b = tcg_const_i64(0);
780 tcg_gen_and_i64(c->u.s64.a, cc_src, cc_dst);
781 break;
782
783 case CC_OP_ADDU_32:
784 c->is_64 = false;
785 c->u.s32.a = tcg_temp_new_i32();
786 c->u.s32.b = tcg_temp_new_i32();
787 tcg_gen_trunc_i64_i32(c->u.s32.a, cc_vr);
788 if (cond == TCG_COND_EQ || cond == TCG_COND_NE) {
789 tcg_gen_movi_i32(c->u.s32.b, 0);
790 } else {
791 tcg_gen_trunc_i64_i32(c->u.s32.b, cc_src);
792 }
793 break;
794
795 case CC_OP_ADDU_64:
796 c->u.s64.a = cc_vr;
797 c->g1 = true;
798 if (cond == TCG_COND_EQ || cond == TCG_COND_NE) {
799 c->u.s64.b = tcg_const_i64(0);
800 } else {
801 c->u.s64.b = cc_src;
802 c->g2 = true;
803 }
804 break;
805
806 case CC_OP_STATIC:
807 c->is_64 = false;
808 c->u.s32.a = cc_op;
809 c->g1 = true;
810 switch (mask) {
811 case 0x8 | 0x4 | 0x2: /* cc != 3 */
812 cond = TCG_COND_NE;
813 c->u.s32.b = tcg_const_i32(3);
814 break;
815 case 0x8 | 0x4 | 0x1: /* cc != 2 */
816 cond = TCG_COND_NE;
817 c->u.s32.b = tcg_const_i32(2);
818 break;
819 case 0x8 | 0x2 | 0x1: /* cc != 1 */
820 cond = TCG_COND_NE;
821 c->u.s32.b = tcg_const_i32(1);
822 break;
823 case 0x8 | 0x2: /* cc == 0 || cc == 2 => (cc & 1) == 0 */
824 cond = TCG_COND_EQ;
825 c->g1 = false;
826 c->u.s32.a = tcg_temp_new_i32();
827 c->u.s32.b = tcg_const_i32(0);
828 tcg_gen_andi_i32(c->u.s32.a, cc_op, 1);
829 break;
830 case 0x8 | 0x4: /* cc < 2 */
831 cond = TCG_COND_LTU;
832 c->u.s32.b = tcg_const_i32(2);
833 break;
834 case 0x8: /* cc == 0 */
835 cond = TCG_COND_EQ;
836 c->u.s32.b = tcg_const_i32(0);
837 break;
838 case 0x4 | 0x2 | 0x1: /* cc != 0 */
839 cond = TCG_COND_NE;
840 c->u.s32.b = tcg_const_i32(0);
841 break;
842 case 0x4 | 0x1: /* cc == 1 || cc == 3 => (cc & 1) != 0 */
843 cond = TCG_COND_NE;
844 c->g1 = false;
845 c->u.s32.a = tcg_temp_new_i32();
846 c->u.s32.b = tcg_const_i32(0);
847 tcg_gen_andi_i32(c->u.s32.a, cc_op, 1);
848 break;
849 case 0x4: /* cc == 1 */
850 cond = TCG_COND_EQ;
851 c->u.s32.b = tcg_const_i32(1);
852 break;
853 case 0x2 | 0x1: /* cc > 1 */
854 cond = TCG_COND_GTU;
855 c->u.s32.b = tcg_const_i32(1);
856 break;
857 case 0x2: /* cc == 2 */
858 cond = TCG_COND_EQ;
859 c->u.s32.b = tcg_const_i32(2);
860 break;
861 case 0x1: /* cc == 3 */
862 cond = TCG_COND_EQ;
863 c->u.s32.b = tcg_const_i32(3);
864 break;
865 default:
866 /* CC is masked by something else: (8 >> cc) & mask. */
867 cond = TCG_COND_NE;
868 c->g1 = false;
869 c->u.s32.a = tcg_const_i32(8);
870 c->u.s32.b = tcg_const_i32(0);
871 tcg_gen_shr_i32(c->u.s32.a, c->u.s32.a, cc_op);
872 tcg_gen_andi_i32(c->u.s32.a, c->u.s32.a, mask);
873 break;
874 }
875 break;
876
877 default:
878 abort();
879 }
880 c->cond = cond;
881 }
882
883 static void free_compare(DisasCompare *c)
884 {
885 if (!c->g1) {
886 if (c->is_64) {
887 tcg_temp_free_i64(c->u.s64.a);
888 } else {
889 tcg_temp_free_i32(c->u.s32.a);
890 }
891 }
892 if (!c->g2) {
893 if (c->is_64) {
894 tcg_temp_free_i64(c->u.s64.b);
895 } else {
896 tcg_temp_free_i32(c->u.s32.b);
897 }
898 }
899 }
900
901 /* ====================================================================== */
902 /* Define the insn format enumeration. */
903 #define F0(N) FMT_##N,
904 #define F1(N, X1) F0(N)
905 #define F2(N, X1, X2) F0(N)
906 #define F3(N, X1, X2, X3) F0(N)
907 #define F4(N, X1, X2, X3, X4) F0(N)
908 #define F5(N, X1, X2, X3, X4, X5) F0(N)
909
910 typedef enum {
911 #include "insn-format.def"
912 } DisasFormat;
913
914 #undef F0
915 #undef F1
916 #undef F2
917 #undef F3
918 #undef F4
919 #undef F5
920
921 /* Define a structure to hold the decoded fields. We'll store each inside
922 an array indexed by an enum. In order to conserve memory, we'll arrange
923 for fields that do not exist at the same time to overlap, thus the "C"
924 for compact. For checking purposes there is an "O" for original index
925 as well that will be applied to availability bitmaps. */
926
927 enum DisasFieldIndexO {
928 FLD_O_r1,
929 FLD_O_r2,
930 FLD_O_r3,
931 FLD_O_m1,
932 FLD_O_m3,
933 FLD_O_m4,
934 FLD_O_b1,
935 FLD_O_b2,
936 FLD_O_b4,
937 FLD_O_d1,
938 FLD_O_d2,
939 FLD_O_d4,
940 FLD_O_x2,
941 FLD_O_l1,
942 FLD_O_l2,
943 FLD_O_i1,
944 FLD_O_i2,
945 FLD_O_i3,
946 FLD_O_i4,
947 FLD_O_i5
948 };
949
950 enum DisasFieldIndexC {
951 FLD_C_r1 = 0,
952 FLD_C_m1 = 0,
953 FLD_C_b1 = 0,
954 FLD_C_i1 = 0,
955
956 FLD_C_r2 = 1,
957 FLD_C_b2 = 1,
958 FLD_C_i2 = 1,
959
960 FLD_C_r3 = 2,
961 FLD_C_m3 = 2,
962 FLD_C_i3 = 2,
963
964 FLD_C_m4 = 3,
965 FLD_C_b4 = 3,
966 FLD_C_i4 = 3,
967 FLD_C_l1 = 3,
968
969 FLD_C_i5 = 4,
970 FLD_C_d1 = 4,
971
972 FLD_C_d2 = 5,
973
974 FLD_C_d4 = 6,
975 FLD_C_x2 = 6,
976 FLD_C_l2 = 6,
977
978 NUM_C_FIELD = 7
979 };
980
981 struct DisasFields {
982 unsigned op:8;
983 unsigned op2:8;
984 unsigned presentC:16;
985 unsigned int presentO;
986 int c[NUM_C_FIELD];
987 };
988
989 /* This is the way fields are to be accessed out of DisasFields. */
990 #define have_field(S, F) have_field1((S), FLD_O_##F)
991 #define get_field(S, F) get_field1((S), FLD_O_##F, FLD_C_##F)
992
993 static bool have_field1(const DisasFields *f, enum DisasFieldIndexO c)
994 {
995 return (f->presentO >> c) & 1;
996 }
997
998 static int get_field1(const DisasFields *f, enum DisasFieldIndexO o,
999 enum DisasFieldIndexC c)
1000 {
1001 assert(have_field1(f, o));
1002 return f->c[c];
1003 }
1004
1005 /* Describe the layout of each field in each format. */
1006 typedef struct DisasField {
1007 unsigned int beg:8;
1008 unsigned int size:8;
1009 unsigned int type:2;
1010 unsigned int indexC:6;
1011 enum DisasFieldIndexO indexO:8;
1012 } DisasField;
1013
1014 typedef struct DisasFormatInfo {
1015 DisasField op[NUM_C_FIELD];
1016 } DisasFormatInfo;
1017
1018 #define R(N, B) { B, 4, 0, FLD_C_r##N, FLD_O_r##N }
1019 #define M(N, B) { B, 4, 0, FLD_C_m##N, FLD_O_m##N }
1020 #define BD(N, BB, BD) { BB, 4, 0, FLD_C_b##N, FLD_O_b##N }, \
1021 { BD, 12, 0, FLD_C_d##N, FLD_O_d##N }
1022 #define BXD(N) { 16, 4, 0, FLD_C_b##N, FLD_O_b##N }, \
1023 { 12, 4, 0, FLD_C_x##N, FLD_O_x##N }, \
1024 { 20, 12, 0, FLD_C_d##N, FLD_O_d##N }
1025 #define BDL(N) { 16, 4, 0, FLD_C_b##N, FLD_O_b##N }, \
1026 { 20, 20, 2, FLD_C_d##N, FLD_O_d##N }
1027 #define BXDL(N) { 16, 4, 0, FLD_C_b##N, FLD_O_b##N }, \
1028 { 12, 4, 0, FLD_C_x##N, FLD_O_x##N }, \
1029 { 20, 20, 2, FLD_C_d##N, FLD_O_d##N }
1030 #define I(N, B, S) { B, S, 1, FLD_C_i##N, FLD_O_i##N }
1031 #define L(N, B, S) { B, S, 0, FLD_C_l##N, FLD_O_l##N }
1032
1033 #define F0(N) { { } },
1034 #define F1(N, X1) { { X1 } },
1035 #define F2(N, X1, X2) { { X1, X2 } },
1036 #define F3(N, X1, X2, X3) { { X1, X2, X3 } },
1037 #define F4(N, X1, X2, X3, X4) { { X1, X2, X3, X4 } },
1038 #define F5(N, X1, X2, X3, X4, X5) { { X1, X2, X3, X4, X5 } },
1039
1040 static const DisasFormatInfo format_info[] = {
1041 #include "insn-format.def"
1042 };
1043
1044 #undef F0
1045 #undef F1
1046 #undef F2
1047 #undef F3
1048 #undef F4
1049 #undef F5
1050 #undef R
1051 #undef M
1052 #undef BD
1053 #undef BXD
1054 #undef BDL
1055 #undef BXDL
1056 #undef I
1057 #undef L
1058
1059 /* Generally, we'll extract operands into this structures, operate upon
1060 them, and store them back. See the "in1", "in2", "prep", "wout" sets
1061 of routines below for more details. */
1062 typedef struct {
1063 bool g_out, g_out2, g_in1, g_in2;
1064 TCGv_i64 out, out2, in1, in2;
1065 TCGv_i64 addr1;
1066 } DisasOps;
1067
1068 /* Instructions can place constraints on their operands, raising specification
1069 exceptions if they are violated. To make this easy to automate, each "in1",
1070 "in2", "prep", "wout" helper will have a SPEC_<name> define that equals one
1071 of the following, or 0. To make this easy to document, we'll put the
1072 SPEC_<name> defines next to <name>. */
1073
1074 #define SPEC_r1_even 1
1075 #define SPEC_r2_even 2
1076 #define SPEC_r3_even 4
1077 #define SPEC_r1_f128 8
1078 #define SPEC_r2_f128 16
1079
1080 /* Return values from translate_one, indicating the state of the TB. */
1081 typedef enum {
1082 /* Continue the TB. */
1083 NO_EXIT,
1084 /* We have emitted one or more goto_tb. No fixup required. */
1085 EXIT_GOTO_TB,
1086 /* We are not using a goto_tb (for whatever reason), but have updated
1087 the PC (for whatever reason), so there's no need to do it again on
1088 exiting the TB. */
1089 EXIT_PC_UPDATED,
1090 /* We are exiting the TB, but have neither emitted a goto_tb, nor
1091 updated the PC for the next instruction to be executed. */
1092 EXIT_PC_STALE,
1093 /* We are ending the TB with a noreturn function call, e.g. longjmp.
1094 No following code will be executed. */
1095 EXIT_NORETURN,
1096 } ExitStatus;
1097
1098 typedef enum DisasFacility {
1099 FAC_Z, /* zarch (default) */
1100 FAC_CASS, /* compare and swap and store */
1101 FAC_CASS2, /* compare and swap and store 2*/
1102 FAC_DFP, /* decimal floating point */
1103 FAC_DFPR, /* decimal floating point rounding */
1104 FAC_DO, /* distinct operands */
1105 FAC_EE, /* execute extensions */
1106 FAC_EI, /* extended immediate */
1107 FAC_FPE, /* floating point extension */
1108 FAC_FPSSH, /* floating point support sign handling */
1109 FAC_FPRGR, /* FPR-GR transfer */
1110 FAC_GIE, /* general instructions extension */
1111 FAC_HFP_MA, /* HFP multiply-and-add/subtract */
1112 FAC_HW, /* high-word */
1113 FAC_IEEEE_SIM, /* IEEE exception sumilation */
1114 FAC_LOC, /* load/store on condition */
1115 FAC_LD, /* long displacement */
1116 FAC_PC, /* population count */
1117 FAC_SCF, /* store clock fast */
1118 FAC_SFLE, /* store facility list extended */
1119 } DisasFacility;
1120
1121 struct DisasInsn {
1122 unsigned opc:16;
1123 DisasFormat fmt:8;
1124 DisasFacility fac:8;
1125 unsigned spec:8;
1126
1127 const char *name;
1128
1129 void (*help_in1)(DisasContext *, DisasFields *, DisasOps *);
1130 void (*help_in2)(DisasContext *, DisasFields *, DisasOps *);
1131 void (*help_prep)(DisasContext *, DisasFields *, DisasOps *);
1132 void (*help_wout)(DisasContext *, DisasFields *, DisasOps *);
1133 void (*help_cout)(DisasContext *, DisasOps *);
1134 ExitStatus (*help_op)(DisasContext *, DisasOps *);
1135
1136 uint64_t data;
1137 };
1138
1139 /* ====================================================================== */
1140 /* Miscellaneous helpers, used by several operations. */
1141
1142 static void help_l2_shift(DisasContext *s, DisasFields *f,
1143 DisasOps *o, int mask)
1144 {
1145 int b2 = get_field(f, b2);
1146 int d2 = get_field(f, d2);
1147
1148 if (b2 == 0) {
1149 o->in2 = tcg_const_i64(d2 & mask);
1150 } else {
1151 o->in2 = get_address(s, 0, b2, d2);
1152 tcg_gen_andi_i64(o->in2, o->in2, mask);
1153 }
1154 }
1155
1156 static ExitStatus help_goto_direct(DisasContext *s, uint64_t dest)
1157 {
1158 if (dest == s->next_pc) {
1159 return NO_EXIT;
1160 }
1161 if (use_goto_tb(s, dest)) {
1162 update_cc_op(s);
1163 tcg_gen_goto_tb(0);
1164 tcg_gen_movi_i64(psw_addr, dest);
1165 tcg_gen_exit_tb((uintptr_t)s->tb);
1166 return EXIT_GOTO_TB;
1167 } else {
1168 tcg_gen_movi_i64(psw_addr, dest);
1169 return EXIT_PC_UPDATED;
1170 }
1171 }
1172
1173 static ExitStatus help_branch(DisasContext *s, DisasCompare *c,
1174 bool is_imm, int imm, TCGv_i64 cdest)
1175 {
1176 ExitStatus ret;
1177 uint64_t dest = s->pc + 2 * imm;
1178 int lab;
1179
1180 /* Take care of the special cases first. */
1181 if (c->cond == TCG_COND_NEVER) {
1182 ret = NO_EXIT;
1183 goto egress;
1184 }
1185 if (is_imm) {
1186 if (dest == s->next_pc) {
1187 /* Branch to next. */
1188 ret = NO_EXIT;
1189 goto egress;
1190 }
1191 if (c->cond == TCG_COND_ALWAYS) {
1192 ret = help_goto_direct(s, dest);
1193 goto egress;
1194 }
1195 } else {
1196 if (TCGV_IS_UNUSED_I64(cdest)) {
1197 /* E.g. bcr %r0 -> no branch. */
1198 ret = NO_EXIT;
1199 goto egress;
1200 }
1201 if (c->cond == TCG_COND_ALWAYS) {
1202 tcg_gen_mov_i64(psw_addr, cdest);
1203 ret = EXIT_PC_UPDATED;
1204 goto egress;
1205 }
1206 }
1207
1208 if (use_goto_tb(s, s->next_pc)) {
1209 if (is_imm && use_goto_tb(s, dest)) {
1210 /* Both exits can use goto_tb. */
1211 update_cc_op(s);
1212
1213 lab = gen_new_label();
1214 if (c->is_64) {
1215 tcg_gen_brcond_i64(c->cond, c->u.s64.a, c->u.s64.b, lab);
1216 } else {
1217 tcg_gen_brcond_i32(c->cond, c->u.s32.a, c->u.s32.b, lab);
1218 }
1219
1220 /* Branch not taken. */
1221 tcg_gen_goto_tb(0);
1222 tcg_gen_movi_i64(psw_addr, s->next_pc);
1223 tcg_gen_exit_tb((uintptr_t)s->tb + 0);
1224
1225 /* Branch taken. */
1226 gen_set_label(lab);
1227 tcg_gen_goto_tb(1);
1228 tcg_gen_movi_i64(psw_addr, dest);
1229 tcg_gen_exit_tb((uintptr_t)s->tb + 1);
1230
1231 ret = EXIT_GOTO_TB;
1232 } else {
1233 /* Fallthru can use goto_tb, but taken branch cannot. */
1234 /* Store taken branch destination before the brcond. This
1235 avoids having to allocate a new local temp to hold it.
1236 We'll overwrite this in the not taken case anyway. */
1237 if (!is_imm) {
1238 tcg_gen_mov_i64(psw_addr, cdest);
1239 }
1240
1241 lab = gen_new_label();
1242 if (c->is_64) {
1243 tcg_gen_brcond_i64(c->cond, c->u.s64.a, c->u.s64.b, lab);
1244 } else {
1245 tcg_gen_brcond_i32(c->cond, c->u.s32.a, c->u.s32.b, lab);
1246 }
1247
1248 /* Branch not taken. */
1249 update_cc_op(s);
1250 tcg_gen_goto_tb(0);
1251 tcg_gen_movi_i64(psw_addr, s->next_pc);
1252 tcg_gen_exit_tb((uintptr_t)s->tb + 0);
1253
1254 gen_set_label(lab);
1255 if (is_imm) {
1256 tcg_gen_movi_i64(psw_addr, dest);
1257 }
1258 ret = EXIT_PC_UPDATED;
1259 }
1260 } else {
1261 /* Fallthru cannot use goto_tb. This by itself is vanishingly rare.
1262 Most commonly we're single-stepping or some other condition that
1263 disables all use of goto_tb. Just update the PC and exit. */
1264
1265 TCGv_i64 next = tcg_const_i64(s->next_pc);
1266 if (is_imm) {
1267 cdest = tcg_const_i64(dest);
1268 }
1269
1270 if (c->is_64) {
1271 tcg_gen_movcond_i64(c->cond, psw_addr, c->u.s64.a, c->u.s64.b,
1272 cdest, next);
1273 } else {
1274 TCGv_i32 t0 = tcg_temp_new_i32();
1275 TCGv_i64 t1 = tcg_temp_new_i64();
1276 TCGv_i64 z = tcg_const_i64(0);
1277 tcg_gen_setcond_i32(c->cond, t0, c->u.s32.a, c->u.s32.b);
1278 tcg_gen_extu_i32_i64(t1, t0);
1279 tcg_temp_free_i32(t0);
1280 tcg_gen_movcond_i64(TCG_COND_NE, psw_addr, t1, z, cdest, next);
1281 tcg_temp_free_i64(t1);
1282 tcg_temp_free_i64(z);
1283 }
1284
1285 if (is_imm) {
1286 tcg_temp_free_i64(cdest);
1287 }
1288 tcg_temp_free_i64(next);
1289
1290 ret = EXIT_PC_UPDATED;
1291 }
1292
1293 egress:
1294 free_compare(c);
1295 return ret;
1296 }
1297
1298 /* ====================================================================== */
1299 /* The operations. These perform the bulk of the work for any insn,
1300 usually after the operands have been loaded and output initialized. */
1301
1302 static ExitStatus op_abs(DisasContext *s, DisasOps *o)
1303 {
1304 gen_helper_abs_i64(o->out, o->in2);
1305 return NO_EXIT;
1306 }
1307
1308 static ExitStatus op_absf32(DisasContext *s, DisasOps *o)
1309 {
1310 tcg_gen_andi_i64(o->out, o->in2, 0x7fffffffull);
1311 return NO_EXIT;
1312 }
1313
1314 static ExitStatus op_absf64(DisasContext *s, DisasOps *o)
1315 {
1316 tcg_gen_andi_i64(o->out, o->in2, 0x7fffffffffffffffull);
1317 return NO_EXIT;
1318 }
1319
1320 static ExitStatus op_absf128(DisasContext *s, DisasOps *o)
1321 {
1322 tcg_gen_andi_i64(o->out, o->in1, 0x7fffffffffffffffull);
1323 tcg_gen_mov_i64(o->out2, o->in2);
1324 return NO_EXIT;
1325 }
1326
1327 static ExitStatus op_add(DisasContext *s, DisasOps *o)
1328 {
1329 tcg_gen_add_i64(o->out, o->in1, o->in2);
1330 return NO_EXIT;
1331 }
1332
1333 static ExitStatus op_addc(DisasContext *s, DisasOps *o)
1334 {
1335 DisasCompare cmp;
1336 TCGv_i64 carry;
1337
1338 tcg_gen_add_i64(o->out, o->in1, o->in2);
1339
1340 /* The carry flag is the msb of CC, therefore the branch mask that would
1341 create that comparison is 3. Feeding the generated comparison to
1342 setcond produces the carry flag that we desire. */
1343 disas_jcc(s, &cmp, 3);
1344 carry = tcg_temp_new_i64();
1345 if (cmp.is_64) {
1346 tcg_gen_setcond_i64(cmp.cond, carry, cmp.u.s64.a, cmp.u.s64.b);
1347 } else {
1348 TCGv_i32 t = tcg_temp_new_i32();
1349 tcg_gen_setcond_i32(cmp.cond, t, cmp.u.s32.a, cmp.u.s32.b);
1350 tcg_gen_extu_i32_i64(carry, t);
1351 tcg_temp_free_i32(t);
1352 }
1353 free_compare(&cmp);
1354
1355 tcg_gen_add_i64(o->out, o->out, carry);
1356 tcg_temp_free_i64(carry);
1357 return NO_EXIT;
1358 }
1359
1360 static ExitStatus op_aeb(DisasContext *s, DisasOps *o)
1361 {
1362 gen_helper_aeb(o->out, cpu_env, o->in1, o->in2);
1363 return NO_EXIT;
1364 }
1365
1366 static ExitStatus op_adb(DisasContext *s, DisasOps *o)
1367 {
1368 gen_helper_adb(o->out, cpu_env, o->in1, o->in2);
1369 return NO_EXIT;
1370 }
1371
1372 static ExitStatus op_axb(DisasContext *s, DisasOps *o)
1373 {
1374 gen_helper_axb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
1375 return_low128(o->out2);
1376 return NO_EXIT;
1377 }
1378
1379 static ExitStatus op_and(DisasContext *s, DisasOps *o)
1380 {
1381 tcg_gen_and_i64(o->out, o->in1, o->in2);
1382 return NO_EXIT;
1383 }
1384
1385 static ExitStatus op_andi(DisasContext *s, DisasOps *o)
1386 {
1387 int shift = s->insn->data & 0xff;
1388 int size = s->insn->data >> 8;
1389 uint64_t mask = ((1ull << size) - 1) << shift;
1390
1391 assert(!o->g_in2);
1392 tcg_gen_shli_i64(o->in2, o->in2, shift);
1393 tcg_gen_ori_i64(o->in2, o->in2, ~mask);
1394 tcg_gen_and_i64(o->out, o->in1, o->in2);
1395
1396 /* Produce the CC from only the bits manipulated. */
1397 tcg_gen_andi_i64(cc_dst, o->out, mask);
1398 set_cc_nz_u64(s, cc_dst);
1399 return NO_EXIT;
1400 }
1401
1402 static ExitStatus op_bas(DisasContext *s, DisasOps *o)
1403 {
1404 tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->next_pc));
1405 if (!TCGV_IS_UNUSED_I64(o->in2)) {
1406 tcg_gen_mov_i64(psw_addr, o->in2);
1407 return EXIT_PC_UPDATED;
1408 } else {
1409 return NO_EXIT;
1410 }
1411 }
1412
1413 static ExitStatus op_basi(DisasContext *s, DisasOps *o)
1414 {
1415 tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->next_pc));
1416 return help_goto_direct(s, s->pc + 2 * get_field(s->fields, i2));
1417 }
1418
1419 static ExitStatus op_bc(DisasContext *s, DisasOps *o)
1420 {
1421 int m1 = get_field(s->fields, m1);
1422 bool is_imm = have_field(s->fields, i2);
1423 int imm = is_imm ? get_field(s->fields, i2) : 0;
1424 DisasCompare c;
1425
1426 disas_jcc(s, &c, m1);
1427 return help_branch(s, &c, is_imm, imm, o->in2);
1428 }
1429
1430 static ExitStatus op_bct32(DisasContext *s, DisasOps *o)
1431 {
1432 int r1 = get_field(s->fields, r1);
1433 bool is_imm = have_field(s->fields, i2);
1434 int imm = is_imm ? get_field(s->fields, i2) : 0;
1435 DisasCompare c;
1436 TCGv_i64 t;
1437
1438 c.cond = TCG_COND_NE;
1439 c.is_64 = false;
1440 c.g1 = false;
1441 c.g2 = false;
1442
1443 t = tcg_temp_new_i64();
1444 tcg_gen_subi_i64(t, regs[r1], 1);
1445 store_reg32_i64(r1, t);
1446 c.u.s32.a = tcg_temp_new_i32();
1447 c.u.s32.b = tcg_const_i32(0);
1448 tcg_gen_trunc_i64_i32(c.u.s32.a, t);
1449 tcg_temp_free_i64(t);
1450
1451 return help_branch(s, &c, is_imm, imm, o->in2);
1452 }
1453
1454 static ExitStatus op_bct64(DisasContext *s, DisasOps *o)
1455 {
1456 int r1 = get_field(s->fields, r1);
1457 bool is_imm = have_field(s->fields, i2);
1458 int imm = is_imm ? get_field(s->fields, i2) : 0;
1459 DisasCompare c;
1460
1461 c.cond = TCG_COND_NE;
1462 c.is_64 = true;
1463 c.g1 = true;
1464 c.g2 = false;
1465
1466 tcg_gen_subi_i64(regs[r1], regs[r1], 1);
1467 c.u.s64.a = regs[r1];
1468 c.u.s64.b = tcg_const_i64(0);
1469
1470 return help_branch(s, &c, is_imm, imm, o->in2);
1471 }
1472
1473 static ExitStatus op_bx32(DisasContext *s, DisasOps *o)
1474 {
1475 int r1 = get_field(s->fields, r1);
1476 int r3 = get_field(s->fields, r3);
1477 bool is_imm = have_field(s->fields, i2);
1478 int imm = is_imm ? get_field(s->fields, i2) : 0;
1479 DisasCompare c;
1480 TCGv_i64 t;
1481
1482 c.cond = (s->insn->data ? TCG_COND_LE : TCG_COND_GT);
1483 c.is_64 = false;
1484 c.g1 = false;
1485 c.g2 = false;
1486
1487 t = tcg_temp_new_i64();
1488 tcg_gen_add_i64(t, regs[r1], regs[r3]);
1489 c.u.s32.a = tcg_temp_new_i32();
1490 c.u.s32.b = tcg_temp_new_i32();
1491 tcg_gen_trunc_i64_i32(c.u.s32.a, t);
1492 tcg_gen_trunc_i64_i32(c.u.s32.b, regs[r3 | 1]);
1493 store_reg32_i64(r1, t);
1494 tcg_temp_free_i64(t);
1495
1496 return help_branch(s, &c, is_imm, imm, o->in2);
1497 }
1498
1499 static ExitStatus op_bx64(DisasContext *s, DisasOps *o)
1500 {
1501 int r1 = get_field(s->fields, r1);
1502 int r3 = get_field(s->fields, r3);
1503 bool is_imm = have_field(s->fields, i2);
1504 int imm = is_imm ? get_field(s->fields, i2) : 0;
1505 DisasCompare c;
1506
1507 c.cond = (s->insn->data ? TCG_COND_LE : TCG_COND_GT);
1508 c.is_64 = true;
1509
1510 if (r1 == (r3 | 1)) {
1511 c.u.s64.b = load_reg(r3 | 1);
1512 c.g2 = false;
1513 } else {
1514 c.u.s64.b = regs[r3 | 1];
1515 c.g2 = true;
1516 }
1517
1518 tcg_gen_add_i64(regs[r1], regs[r1], regs[r3]);
1519 c.u.s64.a = regs[r1];
1520 c.g1 = true;
1521
1522 return help_branch(s, &c, is_imm, imm, o->in2);
1523 }
1524
1525 static ExitStatus op_cj(DisasContext *s, DisasOps *o)
1526 {
1527 int imm, m3 = get_field(s->fields, m3);
1528 bool is_imm;
1529 DisasCompare c;
1530
1531 c.cond = ltgt_cond[m3];
1532 if (s->insn->data) {
1533 c.cond = tcg_unsigned_cond(c.cond);
1534 }
1535 c.is_64 = c.g1 = c.g2 = true;
1536 c.u.s64.a = o->in1;
1537 c.u.s64.b = o->in2;
1538
1539 is_imm = have_field(s->fields, i4);
1540 if (is_imm) {
1541 imm = get_field(s->fields, i4);
1542 } else {
1543 imm = 0;
1544 o->out = get_address(s, 0, get_field(s->fields, b4),
1545 get_field(s->fields, d4));
1546 }
1547
1548 return help_branch(s, &c, is_imm, imm, o->out);
1549 }
1550
1551 static ExitStatus op_ceb(DisasContext *s, DisasOps *o)
1552 {
1553 gen_helper_ceb(cc_op, cpu_env, o->in1, o->in2);
1554 set_cc_static(s);
1555 return NO_EXIT;
1556 }
1557
1558 static ExitStatus op_cdb(DisasContext *s, DisasOps *o)
1559 {
1560 gen_helper_cdb(cc_op, cpu_env, o->in1, o->in2);
1561 set_cc_static(s);
1562 return NO_EXIT;
1563 }
1564
1565 static ExitStatus op_cxb(DisasContext *s, DisasOps *o)
1566 {
1567 gen_helper_cxb(cc_op, cpu_env, o->out, o->out2, o->in1, o->in2);
1568 set_cc_static(s);
1569 return NO_EXIT;
1570 }
1571
1572 static ExitStatus op_cfeb(DisasContext *s, DisasOps *o)
1573 {
1574 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1575 gen_helper_cfeb(o->out, cpu_env, o->in2, m3);
1576 tcg_temp_free_i32(m3);
1577 gen_set_cc_nz_f32(s, o->in2);
1578 return NO_EXIT;
1579 }
1580
1581 static ExitStatus op_cfdb(DisasContext *s, DisasOps *o)
1582 {
1583 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1584 gen_helper_cfdb(o->out, cpu_env, o->in2, m3);
1585 tcg_temp_free_i32(m3);
1586 gen_set_cc_nz_f64(s, o->in2);
1587 return NO_EXIT;
1588 }
1589
1590 static ExitStatus op_cfxb(DisasContext *s, DisasOps *o)
1591 {
1592 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1593 gen_helper_cfxb(o->out, cpu_env, o->in1, o->in2, m3);
1594 tcg_temp_free_i32(m3);
1595 gen_set_cc_nz_f128(s, o->in1, o->in2);
1596 return NO_EXIT;
1597 }
1598
1599 static ExitStatus op_cgeb(DisasContext *s, DisasOps *o)
1600 {
1601 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1602 gen_helper_cgeb(o->out, cpu_env, o->in2, m3);
1603 tcg_temp_free_i32(m3);
1604 gen_set_cc_nz_f32(s, o->in2);
1605 return NO_EXIT;
1606 }
1607
1608 static ExitStatus op_cgdb(DisasContext *s, DisasOps *o)
1609 {
1610 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1611 gen_helper_cgdb(o->out, cpu_env, o->in2, m3);
1612 tcg_temp_free_i32(m3);
1613 gen_set_cc_nz_f64(s, o->in2);
1614 return NO_EXIT;
1615 }
1616
1617 static ExitStatus op_cgxb(DisasContext *s, DisasOps *o)
1618 {
1619 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1620 gen_helper_cgxb(o->out, cpu_env, o->in1, o->in2, m3);
1621 tcg_temp_free_i32(m3);
1622 gen_set_cc_nz_f128(s, o->in1, o->in2);
1623 return NO_EXIT;
1624 }
1625
1626 static ExitStatus op_clfeb(DisasContext *s, DisasOps *o)
1627 {
1628 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1629 gen_helper_clfeb(o->out, cpu_env, o->in2, m3);
1630 tcg_temp_free_i32(m3);
1631 gen_set_cc_nz_f32(s, o->in2);
1632 return NO_EXIT;
1633 }
1634
1635 static ExitStatus op_clfdb(DisasContext *s, DisasOps *o)
1636 {
1637 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1638 gen_helper_clfdb(o->out, cpu_env, o->in2, m3);
1639 tcg_temp_free_i32(m3);
1640 gen_set_cc_nz_f64(s, o->in2);
1641 return NO_EXIT;
1642 }
1643
1644 static ExitStatus op_clfxb(DisasContext *s, DisasOps *o)
1645 {
1646 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1647 gen_helper_clfxb(o->out, cpu_env, o->in1, o->in2, m3);
1648 tcg_temp_free_i32(m3);
1649 gen_set_cc_nz_f128(s, o->in1, o->in2);
1650 return NO_EXIT;
1651 }
1652
1653 static ExitStatus op_clgeb(DisasContext *s, DisasOps *o)
1654 {
1655 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1656 gen_helper_clgeb(o->out, cpu_env, o->in2, m3);
1657 tcg_temp_free_i32(m3);
1658 gen_set_cc_nz_f32(s, o->in2);
1659 return NO_EXIT;
1660 }
1661
1662 static ExitStatus op_clgdb(DisasContext *s, DisasOps *o)
1663 {
1664 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1665 gen_helper_clgdb(o->out, cpu_env, o->in2, m3);
1666 tcg_temp_free_i32(m3);
1667 gen_set_cc_nz_f64(s, o->in2);
1668 return NO_EXIT;
1669 }
1670
1671 static ExitStatus op_clgxb(DisasContext *s, DisasOps *o)
1672 {
1673 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1674 gen_helper_clgxb(o->out, cpu_env, o->in1, o->in2, m3);
1675 tcg_temp_free_i32(m3);
1676 gen_set_cc_nz_f128(s, o->in1, o->in2);
1677 return NO_EXIT;
1678 }
1679
1680 static ExitStatus op_cegb(DisasContext *s, DisasOps *o)
1681 {
1682 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1683 gen_helper_cegb(o->out, cpu_env, o->in2, m3);
1684 tcg_temp_free_i32(m3);
1685 return NO_EXIT;
1686 }
1687
1688 static ExitStatus op_cdgb(DisasContext *s, DisasOps *o)
1689 {
1690 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1691 gen_helper_cdgb(o->out, cpu_env, o->in2, m3);
1692 tcg_temp_free_i32(m3);
1693 return NO_EXIT;
1694 }
1695
1696 static ExitStatus op_cxgb(DisasContext *s, DisasOps *o)
1697 {
1698 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1699 gen_helper_cxgb(o->out, cpu_env, o->in2, m3);
1700 tcg_temp_free_i32(m3);
1701 return_low128(o->out2);
1702 return NO_EXIT;
1703 }
1704
1705 static ExitStatus op_celgb(DisasContext *s, DisasOps *o)
1706 {
1707 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1708 gen_helper_celgb(o->out, cpu_env, o->in2, m3);
1709 tcg_temp_free_i32(m3);
1710 return NO_EXIT;
1711 }
1712
1713 static ExitStatus op_cdlgb(DisasContext *s, DisasOps *o)
1714 {
1715 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1716 gen_helper_cdlgb(o->out, cpu_env, o->in2, m3);
1717 tcg_temp_free_i32(m3);
1718 return NO_EXIT;
1719 }
1720
1721 static ExitStatus op_cxlgb(DisasContext *s, DisasOps *o)
1722 {
1723 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1724 gen_helper_cxlgb(o->out, cpu_env, o->in2, m3);
1725 tcg_temp_free_i32(m3);
1726 return_low128(o->out2);
1727 return NO_EXIT;
1728 }
1729
1730 static ExitStatus op_cksm(DisasContext *s, DisasOps *o)
1731 {
1732 int r2 = get_field(s->fields, r2);
1733 TCGv_i64 len = tcg_temp_new_i64();
1734
1735 potential_page_fault(s);
1736 gen_helper_cksm(len, cpu_env, o->in1, o->in2, regs[r2 + 1]);
1737 set_cc_static(s);
1738 return_low128(o->out);
1739
1740 tcg_gen_add_i64(regs[r2], regs[r2], len);
1741 tcg_gen_sub_i64(regs[r2 + 1], regs[r2 + 1], len);
1742 tcg_temp_free_i64(len);
1743
1744 return NO_EXIT;
1745 }
1746
1747 static ExitStatus op_clc(DisasContext *s, DisasOps *o)
1748 {
1749 int l = get_field(s->fields, l1);
1750 TCGv_i32 vl;
1751
1752 switch (l + 1) {
1753 case 1:
1754 tcg_gen_qemu_ld8u(cc_src, o->addr1, get_mem_index(s));
1755 tcg_gen_qemu_ld8u(cc_dst, o->in2, get_mem_index(s));
1756 break;
1757 case 2:
1758 tcg_gen_qemu_ld16u(cc_src, o->addr1, get_mem_index(s));
1759 tcg_gen_qemu_ld16u(cc_dst, o->in2, get_mem_index(s));
1760 break;
1761 case 4:
1762 tcg_gen_qemu_ld32u(cc_src, o->addr1, get_mem_index(s));
1763 tcg_gen_qemu_ld32u(cc_dst, o->in2, get_mem_index(s));
1764 break;
1765 case 8:
1766 tcg_gen_qemu_ld64(cc_src, o->addr1, get_mem_index(s));
1767 tcg_gen_qemu_ld64(cc_dst, o->in2, get_mem_index(s));
1768 break;
1769 default:
1770 potential_page_fault(s);
1771 vl = tcg_const_i32(l);
1772 gen_helper_clc(cc_op, cpu_env, vl, o->addr1, o->in2);
1773 tcg_temp_free_i32(vl);
1774 set_cc_static(s);
1775 return NO_EXIT;
1776 }
1777 gen_op_update2_cc_i64(s, CC_OP_LTUGTU_64, cc_src, cc_dst);
1778 return NO_EXIT;
1779 }
1780
1781 static ExitStatus op_clcle(DisasContext *s, DisasOps *o)
1782 {
1783 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
1784 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
1785 potential_page_fault(s);
1786 gen_helper_clcle(cc_op, cpu_env, r1, o->in2, r3);
1787 tcg_temp_free_i32(r1);
1788 tcg_temp_free_i32(r3);
1789 set_cc_static(s);
1790 return NO_EXIT;
1791 }
1792
1793 static ExitStatus op_clm(DisasContext *s, DisasOps *o)
1794 {
1795 TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1796 TCGv_i32 t1 = tcg_temp_new_i32();
1797 tcg_gen_trunc_i64_i32(t1, o->in1);
1798 potential_page_fault(s);
1799 gen_helper_clm(cc_op, cpu_env, t1, m3, o->in2);
1800 set_cc_static(s);
1801 tcg_temp_free_i32(t1);
1802 tcg_temp_free_i32(m3);
1803 return NO_EXIT;
1804 }
1805
1806 static ExitStatus op_clst(DisasContext *s, DisasOps *o)
1807 {
1808 potential_page_fault(s);
1809 gen_helper_clst(o->in1, cpu_env, regs[0], o->in1, o->in2);
1810 set_cc_static(s);
1811 return_low128(o->in2);
1812 return NO_EXIT;
1813 }
1814
1815 static ExitStatus op_cps(DisasContext *s, DisasOps *o)
1816 {
1817 TCGv_i64 t = tcg_temp_new_i64();
1818 tcg_gen_andi_i64(t, o->in1, 0x8000000000000000ull);
1819 tcg_gen_andi_i64(o->out, o->in2, 0x7fffffffffffffffull);
1820 tcg_gen_or_i64(o->out, o->out, t);
1821 tcg_temp_free_i64(t);
1822 return NO_EXIT;
1823 }
1824
1825 static ExitStatus op_cs(DisasContext *s, DisasOps *o)
1826 {
1827 /* FIXME: needs an atomic solution for CONFIG_USER_ONLY. */
1828 int d2 = get_field(s->fields, d2);
1829 int b2 = get_field(s->fields, b2);
1830 int is_64 = s->insn->data;
1831 TCGv_i64 addr, mem, cc, z;
1832
1833 /* Note that in1 = R3 (new value) and
1834 in2 = (zero-extended) R1 (expected value). */
1835
1836 /* Load the memory into the (temporary) output. While the PoO only talks
1837 about moving the memory to R1 on inequality, if we include equality it
1838 means that R1 is equal to the memory in all conditions. */
1839 addr = get_address(s, 0, b2, d2);
1840 if (is_64) {
1841 tcg_gen_qemu_ld64(o->out, addr, get_mem_index(s));
1842 } else {
1843 tcg_gen_qemu_ld32u(o->out, addr, get_mem_index(s));
1844 }
1845
1846 /* Are the memory and expected values (un)equal? Note that this setcond
1847 produces the output CC value, thus the NE sense of the test. */
1848 cc = tcg_temp_new_i64();
1849 tcg_gen_setcond_i64(TCG_COND_NE, cc, o->in2, o->out);
1850
1851 /* If the memory and expected values are equal (CC==0), copy R3 to MEM.
1852 Recall that we are allowed to unconditionally issue the store (and
1853 thus any possible write trap), so (re-)store the original contents
1854 of MEM in case of inequality. */
1855 z = tcg_const_i64(0);
1856 mem = tcg_temp_new_i64();
1857 tcg_gen_movcond_i64(TCG_COND_EQ, mem, cc, z, o->in1, o->out);
1858 if (is_64) {
1859 tcg_gen_qemu_st64(mem, addr, get_mem_index(s));
1860 } else {
1861 tcg_gen_qemu_st32(mem, addr, get_mem_index(s));
1862 }
1863 tcg_temp_free_i64(z);
1864 tcg_temp_free_i64(mem);
1865 tcg_temp_free_i64(addr);
1866
1867 /* Store CC back to cc_op. Wait until after the store so that any
1868 exception gets the old cc_op value. */
1869 tcg_gen_trunc_i64_i32(cc_op, cc);
1870 tcg_temp_free_i64(cc);
1871 set_cc_static(s);
1872 return NO_EXIT;
1873 }
1874
1875 static ExitStatus op_cdsg(DisasContext *s, DisasOps *o)
1876 {
1877 /* FIXME: needs an atomic solution for CONFIG_USER_ONLY. */
1878 int r1 = get_field(s->fields, r1);
1879 int r3 = get_field(s->fields, r3);
1880 int d2 = get_field(s->fields, d2);
1881 int b2 = get_field(s->fields, b2);
1882 TCGv_i64 addrh, addrl, memh, meml, outh, outl, cc, z;
1883
1884 /* Note that R1:R1+1 = expected value and R3:R3+1 = new value. */
1885
1886 addrh = get_address(s, 0, b2, d2);
1887 addrl = get_address(s, 0, b2, d2 + 8);
1888 outh = tcg_temp_new_i64();
1889 outl = tcg_temp_new_i64();
1890
1891 tcg_gen_qemu_ld64(outh, addrh, get_mem_index(s));
1892 tcg_gen_qemu_ld64(outl, addrl, get_mem_index(s));
1893
1894 /* Fold the double-word compare with arithmetic. */
1895 cc = tcg_temp_new_i64();
1896 z = tcg_temp_new_i64();
1897 tcg_gen_xor_i64(cc, outh, regs[r1]);
1898 tcg_gen_xor_i64(z, outl, regs[r1 + 1]);
1899 tcg_gen_or_i64(cc, cc, z);
1900 tcg_gen_movi_i64(z, 0);
1901 tcg_gen_setcond_i64(TCG_COND_NE, cc, cc, z);
1902
1903 memh = tcg_temp_new_i64();
1904 meml = tcg_temp_new_i64();
1905 tcg_gen_movcond_i64(TCG_COND_EQ, memh, cc, z, regs[r3], outh);
1906 tcg_gen_movcond_i64(TCG_COND_EQ, meml, cc, z, regs[r3 + 1], outl);
1907 tcg_temp_free_i64(z);
1908
1909 tcg_gen_qemu_st64(memh, addrh, get_mem_index(s));
1910 tcg_gen_qemu_st64(meml, addrl, get_mem_index(s));
1911 tcg_temp_free_i64(memh);
1912 tcg_temp_free_i64(meml);
1913 tcg_temp_free_i64(addrh);
1914 tcg_temp_free_i64(addrl);
1915
1916 /* Save back state now that we've passed all exceptions. */
1917 tcg_gen_mov_i64(regs[r1], outh);
1918 tcg_gen_mov_i64(regs[r1 + 1], outl);
1919 tcg_gen_trunc_i64_i32(cc_op, cc);
1920 tcg_temp_free_i64(outh);
1921 tcg_temp_free_i64(outl);
1922 tcg_temp_free_i64(cc);
1923 set_cc_static(s);
1924 return NO_EXIT;
1925 }
1926
1927 #ifndef CONFIG_USER_ONLY
1928 static ExitStatus op_csp(DisasContext *s, DisasOps *o)
1929 {
1930 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
1931 check_privileged(s);
1932 gen_helper_csp(cc_op, cpu_env, r1, o->in2);
1933 tcg_temp_free_i32(r1);
1934 set_cc_static(s);
1935 return NO_EXIT;
1936 }
1937 #endif
1938
1939 static ExitStatus op_cvd(DisasContext *s, DisasOps *o)
1940 {
1941 TCGv_i64 t1 = tcg_temp_new_i64();
1942 TCGv_i32 t2 = tcg_temp_new_i32();
1943 tcg_gen_trunc_i64_i32(t2, o->in1);
1944 gen_helper_cvd(t1, t2);
1945 tcg_temp_free_i32(t2);
1946 tcg_gen_qemu_st64(t1, o->in2, get_mem_index(s));
1947 tcg_temp_free_i64(t1);
1948 return NO_EXIT;
1949 }
1950
1951 static ExitStatus op_ct(DisasContext *s, DisasOps *o)
1952 {
1953 int m3 = get_field(s->fields, m3);
1954 int lab = gen_new_label();
1955 TCGv_i32 t;
1956 TCGCond c;
1957
1958 c = tcg_invert_cond(ltgt_cond[m3]);
1959 if (s->insn->data) {
1960 c = tcg_unsigned_cond(c);
1961 }
1962 tcg_gen_brcond_i64(c, o->in1, o->in2, lab);
1963
1964 /* Set DXC to 0xff. */
1965 t = tcg_temp_new_i32();
1966 tcg_gen_ld_i32(t, cpu_env, offsetof(CPUS390XState, fpc));
1967 tcg_gen_ori_i32(t, t, 0xff00);
1968 tcg_gen_st_i32(t, cpu_env, offsetof(CPUS390XState, fpc));
1969 tcg_temp_free_i32(t);
1970
1971 /* Trap. */
1972 gen_program_exception(s, PGM_DATA);
1973
1974 gen_set_label(lab);
1975 return NO_EXIT;
1976 }
1977
1978 #ifndef CONFIG_USER_ONLY
1979 static ExitStatus op_diag(DisasContext *s, DisasOps *o)
1980 {
1981 TCGv_i32 tmp;
1982
1983 check_privileged(s);
1984 potential_page_fault(s);
1985
1986 /* We pretend the format is RX_a so that D2 is the field we want. */
1987 tmp = tcg_const_i32(get_field(s->fields, d2) & 0xfff);
1988 gen_helper_diag(regs[2], cpu_env, tmp, regs[2], regs[1]);
1989 tcg_temp_free_i32(tmp);
1990 return NO_EXIT;
1991 }
1992 #endif
1993
1994 static ExitStatus op_divs32(DisasContext *s, DisasOps *o)
1995 {
1996 gen_helper_divs32(o->out2, cpu_env, o->in1, o->in2);
1997 return_low128(o->out);
1998 return NO_EXIT;
1999 }
2000
2001 static ExitStatus op_divu32(DisasContext *s, DisasOps *o)
2002 {
2003 gen_helper_divu32(o->out2, cpu_env, o->in1, o->in2);
2004 return_low128(o->out);
2005 return NO_EXIT;
2006 }
2007
2008 static ExitStatus op_divs64(DisasContext *s, DisasOps *o)
2009 {
2010 gen_helper_divs64(o->out2, cpu_env, o->in1, o->in2);
2011 return_low128(o->out);
2012 return NO_EXIT;
2013 }
2014
2015 static ExitStatus op_divu64(DisasContext *s, DisasOps *o)
2016 {
2017 gen_helper_divu64(o->out2, cpu_env, o->out, o->out2, o->in2);
2018 return_low128(o->out);
2019 return NO_EXIT;
2020 }
2021
2022 static ExitStatus op_deb(DisasContext *s, DisasOps *o)
2023 {
2024 gen_helper_deb(o->out, cpu_env, o->in1, o->in2);
2025 return NO_EXIT;
2026 }
2027
2028 static ExitStatus op_ddb(DisasContext *s, DisasOps *o)
2029 {
2030 gen_helper_ddb(o->out, cpu_env, o->in1, o->in2);
2031 return NO_EXIT;
2032 }
2033
2034 static ExitStatus op_dxb(DisasContext *s, DisasOps *o)
2035 {
2036 gen_helper_dxb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
2037 return_low128(o->out2);
2038 return NO_EXIT;
2039 }
2040
2041 static ExitStatus op_ear(DisasContext *s, DisasOps *o)
2042 {
2043 int r2 = get_field(s->fields, r2);
2044 tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, aregs[r2]));
2045 return NO_EXIT;
2046 }
2047
2048 static ExitStatus op_efpc(DisasContext *s, DisasOps *o)
2049 {
2050 tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, fpc));
2051 return NO_EXIT;
2052 }
2053
2054 static ExitStatus op_ex(DisasContext *s, DisasOps *o)
2055 {
2056 /* ??? Perhaps a better way to implement EXECUTE is to set a bit in
2057 tb->flags, (ab)use the tb->cs_base field as the address of
2058 the template in memory, and grab 8 bits of tb->flags/cflags for
2059 the contents of the register. We would then recognize all this
2060 in gen_intermediate_code_internal, generating code for exactly
2061 one instruction. This new TB then gets executed normally.
2062
2063 On the other hand, this seems to be mostly used for modifying
2064 MVC inside of memcpy, which needs a helper call anyway. So
2065 perhaps this doesn't bear thinking about any further. */
2066
2067 TCGv_i64 tmp;
2068
2069 update_psw_addr(s);
2070 update_cc_op(s);
2071
2072 tmp = tcg_const_i64(s->next_pc);
2073 gen_helper_ex(cc_op, cpu_env, cc_op, o->in1, o->in2, tmp);
2074 tcg_temp_free_i64(tmp);
2075
2076 set_cc_static(s);
2077 return NO_EXIT;
2078 }
2079
2080 static ExitStatus op_flogr(DisasContext *s, DisasOps *o)
2081 {
2082 /* We'll use the original input for cc computation, since we get to
2083 compare that against 0, which ought to be better than comparing
2084 the real output against 64. It also lets cc_dst be a convenient
2085 temporary during our computation. */
2086 gen_op_update1_cc_i64(s, CC_OP_FLOGR, o->in2);
2087
2088 /* R1 = IN ? CLZ(IN) : 64. */
2089 gen_helper_clz(o->out, o->in2);
2090
2091 /* R1+1 = IN & ~(found bit). Note that we may attempt to shift this
2092 value by 64, which is undefined. But since the shift is 64 iff the
2093 input is zero, we still get the correct result after and'ing. */
2094 tcg_gen_movi_i64(o->out2, 0x8000000000000000ull);
2095 tcg_gen_shr_i64(o->out2, o->out2, o->out);
2096 tcg_gen_andc_i64(o->out2, cc_dst, o->out2);
2097 return NO_EXIT;
2098 }
2099
2100 static ExitStatus op_icm(DisasContext *s, DisasOps *o)
2101 {
2102 int m3 = get_field(s->fields, m3);
2103 int pos, len, base = s->insn->data;
2104 TCGv_i64 tmp = tcg_temp_new_i64();
2105 uint64_t ccm;
2106
2107 switch (m3) {
2108 case 0xf:
2109 /* Effectively a 32-bit load. */
2110 tcg_gen_qemu_ld32u(tmp, o->in2, get_mem_index(s));
2111 len = 32;
2112 goto one_insert;
2113
2114 case 0xc:
2115 case 0x6:
2116 case 0x3:
2117 /* Effectively a 16-bit load. */
2118 tcg_gen_qemu_ld16u(tmp, o->in2, get_mem_index(s));
2119 len = 16;
2120 goto one_insert;
2121
2122 case 0x8:
2123 case 0x4:
2124 case 0x2:
2125 case 0x1:
2126 /* Effectively an 8-bit load. */
2127 tcg_gen_qemu_ld8u(tmp, o->in2, get_mem_index(s));
2128 len = 8;
2129 goto one_insert;
2130
2131 one_insert:
2132 pos = base + ctz32(m3) * 8;
2133 tcg_gen_deposit_i64(o->out, o->out, tmp, pos, len);
2134 ccm = ((1ull << len) - 1) << pos;
2135 break;
2136
2137 default:
2138 /* This is going to be a sequence of loads and inserts. */
2139 pos = base + 32 - 8;
2140 ccm = 0;
2141 while (m3) {
2142 if (m3 & 0x8) {
2143 tcg_gen_qemu_ld8u(tmp, o->in2, get_mem_index(s));
2144 tcg_gen_addi_i64(o->in2, o->in2, 1);
2145 tcg_gen_deposit_i64(o->out, o->out, tmp, pos, 8);
2146 ccm |= 0xff << pos;
2147 }
2148 m3 = (m3 << 1) & 0xf;
2149 pos -= 8;
2150 }
2151 break;
2152 }
2153
2154 tcg_gen_movi_i64(tmp, ccm);
2155 gen_op_update2_cc_i64(s, CC_OP_ICM, tmp, o->out);
2156 tcg_temp_free_i64(tmp);
2157 return NO_EXIT;
2158 }
2159
2160 static ExitStatus op_insi(DisasContext *s, DisasOps *o)
2161 {
2162 int shift = s->insn->data & 0xff;
2163 int size = s->insn->data >> 8;
2164 tcg_gen_deposit_i64(o->out, o->in1, o->in2, shift, size);
2165 return NO_EXIT;
2166 }
2167
2168 static ExitStatus op_ipm(DisasContext *s, DisasOps *o)
2169 {
2170 TCGv_i64 t1;
2171
2172 gen_op_calc_cc(s);
2173 tcg_gen_andi_i64(o->out, o->out, ~0xff000000ull);
2174
2175 t1 = tcg_temp_new_i64();
2176 tcg_gen_shli_i64(t1, psw_mask, 20);
2177 tcg_gen_shri_i64(t1, t1, 36);
2178 tcg_gen_or_i64(o->out, o->out, t1);
2179
2180 tcg_gen_extu_i32_i64(t1, cc_op);
2181 tcg_gen_shli_i64(t1, t1, 28);
2182 tcg_gen_or_i64(o->out, o->out, t1);
2183 tcg_temp_free_i64(t1);
2184 return NO_EXIT;
2185 }
2186
2187 #ifndef CONFIG_USER_ONLY
2188 static ExitStatus op_ipte(DisasContext *s, DisasOps *o)
2189 {
2190 check_privileged(s);
2191 gen_helper_ipte(cpu_env, o->in1, o->in2);
2192 return NO_EXIT;
2193 }
2194
2195 static ExitStatus op_iske(DisasContext *s, DisasOps *o)
2196 {
2197 check_privileged(s);
2198 gen_helper_iske(o->out, cpu_env, o->in2);
2199 return NO_EXIT;
2200 }
2201 #endif
2202
2203 static ExitStatus op_ldeb(DisasContext *s, DisasOps *o)
2204 {
2205 gen_helper_ldeb(o->out, cpu_env, o->in2);
2206 return NO_EXIT;
2207 }
2208
2209 static ExitStatus op_ledb(DisasContext *s, DisasOps *o)
2210 {
2211 gen_helper_ledb(o->out, cpu_env, o->in2);
2212 return NO_EXIT;
2213 }
2214
2215 static ExitStatus op_ldxb(DisasContext *s, DisasOps *o)
2216 {
2217 gen_helper_ldxb(o->out, cpu_env, o->in1, o->in2);
2218 return NO_EXIT;
2219 }
2220
2221 static ExitStatus op_lexb(DisasContext *s, DisasOps *o)
2222 {
2223 gen_helper_lexb(o->out, cpu_env, o->in1, o->in2);
2224 return NO_EXIT;
2225 }
2226
2227 static ExitStatus op_lxdb(DisasContext *s, DisasOps *o)
2228 {
2229 gen_helper_lxdb(o->out, cpu_env, o->in2);
2230 return_low128(o->out2);
2231 return NO_EXIT;
2232 }
2233
2234 static ExitStatus op_lxeb(DisasContext *s, DisasOps *o)
2235 {
2236 gen_helper_lxeb(o->out, cpu_env, o->in2);
2237 return_low128(o->out2);
2238 return NO_EXIT;
2239 }
2240
2241 static ExitStatus op_llgt(DisasContext *s, DisasOps *o)
2242 {
2243 tcg_gen_andi_i64(o->out, o->in2, 0x7fffffff);
2244 return NO_EXIT;
2245 }
2246
2247 static ExitStatus op_ld8s(DisasContext *s, DisasOps *o)
2248 {
2249 tcg_gen_qemu_ld8s(o->out, o->in2, get_mem_index(s));
2250 return NO_EXIT;
2251 }
2252
2253 static ExitStatus op_ld8u(DisasContext *s, DisasOps *o)
2254 {
2255 tcg_gen_qemu_ld8u(o->out, o->in2, get_mem_index(s));
2256 return NO_EXIT;
2257 }
2258
2259 static ExitStatus op_ld16s(DisasContext *s, DisasOps *o)
2260 {
2261 tcg_gen_qemu_ld16s(o->out, o->in2, get_mem_index(s));
2262 return NO_EXIT;
2263 }
2264
2265 static ExitStatus op_ld16u(DisasContext *s, DisasOps *o)
2266 {
2267 tcg_gen_qemu_ld16u(o->out, o->in2, get_mem_index(s));
2268 return NO_EXIT;
2269 }
2270
2271 static ExitStatus op_ld32s(DisasContext *s, DisasOps *o)
2272 {
2273 tcg_gen_qemu_ld32s(o->out, o->in2, get_mem_index(s));
2274 return NO_EXIT;
2275 }
2276
2277 static ExitStatus op_ld32u(DisasContext *s, DisasOps *o)
2278 {
2279 tcg_gen_qemu_ld32u(o->out, o->in2, get_mem_index(s));
2280 return NO_EXIT;
2281 }
2282
2283 static ExitStatus op_ld64(DisasContext *s, DisasOps *o)
2284 {
2285 tcg_gen_qemu_ld64(o->out, o->in2, get_mem_index(s));
2286 return NO_EXIT;
2287 }
2288
2289 static ExitStatus op_loc(DisasContext *s, DisasOps *o)
2290 {
2291 DisasCompare c;
2292
2293 disas_jcc(s, &c, get_field(s->fields, m3));
2294
2295 if (c.is_64) {
2296 tcg_gen_movcond_i64(c.cond, o->out, c.u.s64.a, c.u.s64.b,
2297 o->in2, o->in1);
2298 free_compare(&c);
2299 } else {
2300 TCGv_i32 t32 = tcg_temp_new_i32();
2301 TCGv_i64 t, z;
2302
2303 tcg_gen_setcond_i32(c.cond, t32, c.u.s32.a, c.u.s32.b);
2304 free_compare(&c);
2305
2306 t = tcg_temp_new_i64();
2307 tcg_gen_extu_i32_i64(t, t32);
2308 tcg_temp_free_i32(t32);
2309
2310 z = tcg_const_i64(0);
2311 tcg_gen_movcond_i64(TCG_COND_NE, o->out, t, z, o->in2, o->in1);
2312 tcg_temp_free_i64(t);
2313 tcg_temp_free_i64(z);
2314 }
2315
2316 return NO_EXIT;
2317 }
2318
2319 #ifndef CONFIG_USER_ONLY
2320 static ExitStatus op_lctl(DisasContext *s, DisasOps *o)
2321 {
2322 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2323 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2324 check_privileged(s);
2325 potential_page_fault(s);
2326 gen_helper_lctl(cpu_env, r1, o->in2, r3);
2327 tcg_temp_free_i32(r1);
2328 tcg_temp_free_i32(r3);
2329 return NO_EXIT;
2330 }
2331
2332 static ExitStatus op_lctlg(DisasContext *s, DisasOps *o)
2333 {
2334 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2335 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2336 check_privileged(s);
2337 potential_page_fault(s);
2338 gen_helper_lctlg(cpu_env, r1, o->in2, r3);
2339 tcg_temp_free_i32(r1);
2340 tcg_temp_free_i32(r3);
2341 return NO_EXIT;
2342 }
2343 static ExitStatus op_lra(DisasContext *s, DisasOps *o)
2344 {
2345 check_privileged(s);
2346 potential_page_fault(s);
2347 gen_helper_lra(o->out, cpu_env, o->in2);
2348 set_cc_static(s);
2349 return NO_EXIT;
2350 }
2351
2352 static ExitStatus op_lpsw(DisasContext *s, DisasOps *o)
2353 {
2354 TCGv_i64 t1, t2;
2355
2356 check_privileged(s);
2357
2358 t1 = tcg_temp_new_i64();
2359 t2 = tcg_temp_new_i64();
2360 tcg_gen_qemu_ld32u(t1, o->in2, get_mem_index(s));
2361 tcg_gen_addi_i64(o->in2, o->in2, 4);
2362 tcg_gen_qemu_ld32u(t2, o->in2, get_mem_index(s));
2363 /* Convert the 32-bit PSW_MASK into the 64-bit PSW_MASK. */
2364 tcg_gen_shli_i64(t1, t1, 32);
2365 gen_helper_load_psw(cpu_env, t1, t2);
2366 tcg_temp_free_i64(t1);
2367 tcg_temp_free_i64(t2);
2368 return EXIT_NORETURN;
2369 }
2370
2371 static ExitStatus op_lpswe(DisasContext *s, DisasOps *o)
2372 {
2373 TCGv_i64 t1, t2;
2374
2375 check_privileged(s);
2376
2377 t1 = tcg_temp_new_i64();
2378 t2 = tcg_temp_new_i64();
2379 tcg_gen_qemu_ld64(t1, o->in2, get_mem_index(s));
2380 tcg_gen_addi_i64(o->in2, o->in2, 8);
2381 tcg_gen_qemu_ld64(t2, o->in2, get_mem_index(s));
2382 gen_helper_load_psw(cpu_env, t1, t2);
2383 tcg_temp_free_i64(t1);
2384 tcg_temp_free_i64(t2);
2385 return EXIT_NORETURN;
2386 }
2387 #endif
2388
2389 static ExitStatus op_lam(DisasContext *s, DisasOps *o)
2390 {
2391 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2392 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2393 potential_page_fault(s);
2394 gen_helper_lam(cpu_env, r1, o->in2, r3);
2395 tcg_temp_free_i32(r1);
2396 tcg_temp_free_i32(r3);
2397 return NO_EXIT;
2398 }
2399
2400 static ExitStatus op_lm32(DisasContext *s, DisasOps *o)
2401 {
2402 int r1 = get_field(s->fields, r1);
2403 int r3 = get_field(s->fields, r3);
2404 TCGv_i64 t = tcg_temp_new_i64();
2405 TCGv_i64 t4 = tcg_const_i64(4);
2406
2407 while (1) {
2408 tcg_gen_qemu_ld32u(t, o->in2, get_mem_index(s));
2409 store_reg32_i64(r1, t);
2410 if (r1 == r3) {
2411 break;
2412 }
2413 tcg_gen_add_i64(o->in2, o->in2, t4);
2414 r1 = (r1 + 1) & 15;
2415 }
2416
2417 tcg_temp_free_i64(t);
2418 tcg_temp_free_i64(t4);
2419 return NO_EXIT;
2420 }
2421
2422 static ExitStatus op_lmh(DisasContext *s, DisasOps *o)
2423 {
2424 int r1 = get_field(s->fields, r1);
2425 int r3 = get_field(s->fields, r3);
2426 TCGv_i64 t = tcg_temp_new_i64();
2427 TCGv_i64 t4 = tcg_const_i64(4);
2428
2429 while (1) {
2430 tcg_gen_qemu_ld32u(t, o->in2, get_mem_index(s));
2431 store_reg32h_i64(r1, t);
2432 if (r1 == r3) {
2433 break;
2434 }
2435 tcg_gen_add_i64(o->in2, o->in2, t4);
2436 r1 = (r1 + 1) & 15;
2437 }
2438
2439 tcg_temp_free_i64(t);
2440 tcg_temp_free_i64(t4);
2441 return NO_EXIT;
2442 }
2443
2444 static ExitStatus op_lm64(DisasContext *s, DisasOps *o)
2445 {
2446 int r1 = get_field(s->fields, r1);
2447 int r3 = get_field(s->fields, r3);
2448 TCGv_i64 t8 = tcg_const_i64(8);
2449
2450 while (1) {
2451 tcg_gen_qemu_ld64(regs[r1], o->in2, get_mem_index(s));
2452 if (r1 == r3) {
2453 break;
2454 }
2455 tcg_gen_add_i64(o->in2, o->in2, t8);
2456 r1 = (r1 + 1) & 15;
2457 }
2458
2459 tcg_temp_free_i64(t8);
2460 return NO_EXIT;
2461 }
2462
2463 static ExitStatus op_mov2(DisasContext *s, DisasOps *o)
2464 {
2465 o->out = o->in2;
2466 o->g_out = o->g_in2;
2467 TCGV_UNUSED_I64(o->in2);
2468 o->g_in2 = false;
2469 return NO_EXIT;
2470 }
2471
2472 static ExitStatus op_movx(DisasContext *s, DisasOps *o)
2473 {
2474 o->out = o->in1;
2475 o->out2 = o->in2;
2476 o->g_out = o->g_in1;
2477 o->g_out2 = o->g_in2;
2478 TCGV_UNUSED_I64(o->in1);
2479 TCGV_UNUSED_I64(o->in2);
2480 o->g_in1 = o->g_in2 = false;
2481 return NO_EXIT;
2482 }
2483
2484 static ExitStatus op_mvc(DisasContext *s, DisasOps *o)
2485 {
2486 TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
2487 potential_page_fault(s);
2488 gen_helper_mvc(cpu_env, l, o->addr1, o->in2);
2489 tcg_temp_free_i32(l);
2490 return NO_EXIT;
2491 }
2492
2493 static ExitStatus op_mvcl(DisasContext *s, DisasOps *o)
2494 {
2495 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2496 TCGv_i32 r2 = tcg_const_i32(get_field(s->fields, r2));
2497 potential_page_fault(s);
2498 gen_helper_mvcl(cc_op, cpu_env, r1, r2);
2499 tcg_temp_free_i32(r1);
2500 tcg_temp_free_i32(r2);
2501 set_cc_static(s);
2502 return NO_EXIT;
2503 }
2504
2505 static ExitStatus op_mvcle(DisasContext *s, DisasOps *o)
2506 {
2507 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2508 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2509 potential_page_fault(s);
2510 gen_helper_mvcle(cc_op, cpu_env, r1, o->in2, r3);
2511 tcg_temp_free_i32(r1);
2512 tcg_temp_free_i32(r3);
2513 set_cc_static(s);
2514 return NO_EXIT;
2515 }
2516
2517 #ifndef CONFIG_USER_ONLY
2518 static ExitStatus op_mvcp(DisasContext *s, DisasOps *o)
2519 {
2520 int r1 = get_field(s->fields, l1);
2521 check_privileged(s);
2522 potential_page_fault(s);
2523 gen_helper_mvcp(cc_op, cpu_env, regs[r1], o->addr1, o->in2);
2524 set_cc_static(s);
2525 return NO_EXIT;
2526 }
2527
2528 static ExitStatus op_mvcs(DisasContext *s, DisasOps *o)
2529 {
2530 int r1 = get_field(s->fields, l1);
2531 check_privileged(s);
2532 potential_page_fault(s);
2533 gen_helper_mvcs(cc_op, cpu_env, regs[r1], o->addr1, o->in2);
2534 set_cc_static(s);
2535 return NO_EXIT;
2536 }
2537 #endif
2538
2539 static ExitStatus op_mvpg(DisasContext *s, DisasOps *o)
2540 {
2541 potential_page_fault(s);
2542 gen_helper_mvpg(cpu_env, regs[0], o->in1, o->in2);
2543 set_cc_static(s);
2544 return NO_EXIT;
2545 }
2546
2547 static ExitStatus op_mvst(DisasContext *s, DisasOps *o)
2548 {
2549 potential_page_fault(s);
2550 gen_helper_mvst(o->in1, cpu_env, regs[0], o->in1, o->in2);
2551 set_cc_static(s);
2552 return_low128(o->in2);
2553 return NO_EXIT;
2554 }
2555
2556 static ExitStatus op_mul(DisasContext *s, DisasOps *o)
2557 {
2558 tcg_gen_mul_i64(o->out, o->in1, o->in2);
2559 return NO_EXIT;
2560 }
2561
2562 static ExitStatus op_mul128(DisasContext *s, DisasOps *o)
2563 {
2564 tcg_gen_mulu2_i64(o->out2, o->out, o->in1, o->in2);
2565 return NO_EXIT;
2566 }
2567
2568 static ExitStatus op_meeb(DisasContext *s, DisasOps *o)
2569 {
2570 gen_helper_meeb(o->out, cpu_env, o->in1, o->in2);
2571 return NO_EXIT;
2572 }
2573
2574 static ExitStatus op_mdeb(DisasContext *s, DisasOps *o)
2575 {
2576 gen_helper_mdeb(o->out, cpu_env, o->in1, o->in2);
2577 return NO_EXIT;
2578 }
2579
2580 static ExitStatus op_mdb(DisasContext *s, DisasOps *o)
2581 {
2582 gen_helper_mdb(o->out, cpu_env, o->in1, o->in2);
2583 return NO_EXIT;
2584 }
2585
2586 static ExitStatus op_mxb(DisasContext *s, DisasOps *o)
2587 {
2588 gen_helper_mxb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
2589 return_low128(o->out2);
2590 return NO_EXIT;
2591 }
2592
2593 static ExitStatus op_mxdb(DisasContext *s, DisasOps *o)
2594 {
2595 gen_helper_mxdb(o->out, cpu_env, o->out, o->out2, o->in2);
2596 return_low128(o->out2);
2597 return NO_EXIT;
2598 }
2599
2600 static ExitStatus op_maeb(DisasContext *s, DisasOps *o)
2601 {
2602 TCGv_i64 r3 = load_freg32_i64(get_field(s->fields, r3));
2603 gen_helper_maeb(o->out, cpu_env, o->in1, o->in2, r3);
2604 tcg_temp_free_i64(r3);
2605 return NO_EXIT;
2606 }
2607
2608 static ExitStatus op_madb(DisasContext *s, DisasOps *o)
2609 {
2610 int r3 = get_field(s->fields, r3);
2611 gen_helper_madb(o->out, cpu_env, o->in1, o->in2, fregs[r3]);
2612 return NO_EXIT;
2613 }
2614
2615 static ExitStatus op_mseb(DisasContext *s, DisasOps *o)
2616 {
2617 TCGv_i64 r3 = load_freg32_i64(get_field(s->fields, r3));
2618 gen_helper_mseb(o->out, cpu_env, o->in1, o->in2, r3);
2619 tcg_temp_free_i64(r3);
2620 return NO_EXIT;
2621 }
2622
2623 static ExitStatus op_msdb(DisasContext *s, DisasOps *o)
2624 {
2625 int r3 = get_field(s->fields, r3);
2626 gen_helper_msdb(o->out, cpu_env, o->in1, o->in2, fregs[r3]);
2627 return NO_EXIT;
2628 }
2629
2630 static ExitStatus op_nabs(DisasContext *s, DisasOps *o)
2631 {
2632 gen_helper_nabs_i64(o->out, o->in2);
2633 return NO_EXIT;
2634 }
2635
2636 static ExitStatus op_nabsf32(DisasContext *s, DisasOps *o)
2637 {
2638 tcg_gen_ori_i64(o->out, o->in2, 0x80000000ull);
2639 return NO_EXIT;
2640 }
2641
2642 static ExitStatus op_nabsf64(DisasContext *s, DisasOps *o)
2643 {
2644 tcg_gen_ori_i64(o->out, o->in2, 0x8000000000000000ull);
2645 return NO_EXIT;
2646 }
2647
2648 static ExitStatus op_nabsf128(DisasContext *s, DisasOps *o)
2649 {
2650 tcg_gen_ori_i64(o->out, o->in1, 0x8000000000000000ull);
2651 tcg_gen_mov_i64(o->out2, o->in2);
2652 return NO_EXIT;
2653 }
2654
2655 static ExitStatus op_nc(DisasContext *s, DisasOps *o)
2656 {
2657 TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
2658 potential_page_fault(s);
2659 gen_helper_nc(cc_op, cpu_env, l, o->addr1, o->in2);
2660 tcg_temp_free_i32(l);
2661 set_cc_static(s);
2662 return NO_EXIT;
2663 }
2664
2665 static ExitStatus op_neg(DisasContext *s, DisasOps *o)
2666 {
2667 tcg_gen_neg_i64(o->out, o->in2);
2668 return NO_EXIT;
2669 }
2670
2671 static ExitStatus op_negf32(DisasContext *s, DisasOps *o)
2672 {
2673 tcg_gen_xori_i64(o->out, o->in2, 0x80000000ull);
2674 return NO_EXIT;
2675 }
2676
2677 static ExitStatus op_negf64(DisasContext *s, DisasOps *o)
2678 {
2679 tcg_gen_xori_i64(o->out, o->in2, 0x8000000000000000ull);
2680 return NO_EXIT;
2681 }
2682
2683 static ExitStatus op_negf128(DisasContext *s, DisasOps *o)
2684 {
2685 tcg_gen_xori_i64(o->out, o->in1, 0x8000000000000000ull);
2686 tcg_gen_mov_i64(o->out2, o->in2);
2687 return NO_EXIT;
2688 }
2689
2690 static ExitStatus op_oc(DisasContext *s, DisasOps *o)
2691 {
2692 TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
2693 potential_page_fault(s);
2694 gen_helper_oc(cc_op, cpu_env, l, o->addr1, o->in2);
2695 tcg_temp_free_i32(l);
2696 set_cc_static(s);
2697 return NO_EXIT;
2698 }
2699
2700 static ExitStatus op_or(DisasContext *s, DisasOps *o)
2701 {
2702 tcg_gen_or_i64(o->out, o->in1, o->in2);
2703 return NO_EXIT;
2704 }
2705
2706 static ExitStatus op_ori(DisasContext *s, DisasOps *o)
2707 {
2708 int shift = s->insn->data & 0xff;
2709 int size = s->insn->data >> 8;
2710 uint64_t mask = ((1ull << size) - 1) << shift;
2711
2712 assert(!o->g_in2);
2713 tcg_gen_shli_i64(o->in2, o->in2, shift);
2714 tcg_gen_or_i64(o->out, o->in1, o->in2);
2715
2716 /* Produce the CC from only the bits manipulated. */
2717 tcg_gen_andi_i64(cc_dst, o->out, mask);
2718 set_cc_nz_u64(s, cc_dst);
2719 return NO_EXIT;
2720 }
2721
2722 static ExitStatus op_popcnt(DisasContext *s, DisasOps *o)
2723 {
2724 gen_helper_popcnt(o->out, o->in2);
2725 return NO_EXIT;
2726 }
2727
2728 #ifndef CONFIG_USER_ONLY
2729 static ExitStatus op_ptlb(DisasContext *s, DisasOps *o)
2730 {
2731 check_privileged(s);
2732 gen_helper_ptlb(cpu_env);
2733 return NO_EXIT;
2734 }
2735 #endif
2736
2737 static ExitStatus op_risbg(DisasContext *s, DisasOps *o)
2738 {
2739 int i3 = get_field(s->fields, i3);
2740 int i4 = get_field(s->fields, i4);
2741 int i5 = get_field(s->fields, i5);
2742 int do_zero = i4 & 0x80;
2743 uint64_t mask, imask, pmask;
2744 int pos, len, rot;
2745
2746 /* Adjust the arguments for the specific insn. */
2747 switch (s->fields->op2) {
2748 case 0x55: /* risbg */
2749 i3 &= 63;
2750 i4 &= 63;
2751 pmask = ~0;
2752 break;
2753 case 0x5d: /* risbhg */
2754 i3 &= 31;
2755 i4 &= 31;
2756 pmask = 0xffffffff00000000ull;
2757 break;
2758 case 0x51: /* risblg */
2759 i3 &= 31;
2760 i4 &= 31;
2761 pmask = 0x00000000ffffffffull;
2762 break;
2763 default:
2764 abort();
2765 }
2766
2767 /* MASK is the set of bits to be inserted from R2.
2768 Take care for I3/I4 wraparound. */
2769 mask = pmask >> i3;
2770 if (i3 <= i4) {
2771 mask ^= pmask >> i4 >> 1;
2772 } else {
2773 mask |= ~(pmask >> i4 >> 1);
2774 }
2775 mask &= pmask;
2776
2777 /* IMASK is the set of bits to be kept from R1. In the case of the high/low
2778 insns, we need to keep the other half of the register. */
2779 imask = ~mask | ~pmask;
2780 if (do_zero) {
2781 if (s->fields->op2 == 0x55) {
2782 imask = 0;
2783 } else {
2784 imask = ~pmask;
2785 }
2786 }
2787
2788 /* In some cases we can implement this with deposit, which can be more
2789 efficient on some hosts. */
2790 if (~mask == imask && i3 <= i4) {
2791 if (s->fields->op2 == 0x5d) {
2792 i3 += 32, i4 += 32;
2793 }
2794 /* Note that we rotate the bits to be inserted to the lsb, not to
2795 the position as described in the PoO. */
2796 len = i4 - i3 + 1;
2797 pos = 63 - i4;
2798 rot = (i5 - pos) & 63;
2799 } else {
2800 pos = len = -1;
2801 rot = i5 & 63;
2802 }
2803
2804 /* Rotate the input as necessary. */
2805 tcg_gen_rotli_i64(o->in2, o->in2, rot);
2806
2807 /* Insert the selected bits into the output. */
2808 if (pos >= 0) {
2809 tcg_gen_deposit_i64(o->out, o->out, o->in2, pos, len);
2810 } else if (imask == 0) {
2811 tcg_gen_andi_i64(o->out, o->in2, mask);
2812 } else {
2813 tcg_gen_andi_i64(o->in2, o->in2, mask);
2814 tcg_gen_andi_i64(o->out, o->out, imask);
2815 tcg_gen_or_i64(o->out, o->out, o->in2);
2816 }
2817 return NO_EXIT;
2818 }
2819
2820 static ExitStatus op_rosbg(DisasContext *s, DisasOps *o)
2821 {
2822 int i3 = get_field(s->fields, i3);
2823 int i4 = get_field(s->fields, i4);
2824 int i5 = get_field(s->fields, i5);
2825 uint64_t mask;
2826
2827 /* If this is a test-only form, arrange to discard the result. */
2828 if (i3 & 0x80) {
2829 o->out = tcg_temp_new_i64();
2830 o->g_out = false;
2831 }
2832
2833 i3 &= 63;
2834 i4 &= 63;
2835 i5 &= 63;
2836
2837 /* MASK is the set of bits to be operated on from R2.
2838 Take care for I3/I4 wraparound. */
2839 mask = ~0ull >> i3;
2840 if (i3 <= i4) {
2841 mask ^= ~0ull >> i4 >> 1;
2842 } else {
2843 mask |= ~(~0ull >> i4 >> 1);
2844 }
2845
2846 /* Rotate the input as necessary. */
2847 tcg_gen_rotli_i64(o->in2, o->in2, i5);
2848
2849 /* Operate. */
2850 switch (s->fields->op2) {
2851 case 0x55: /* AND */
2852 tcg_gen_ori_i64(o->in2, o->in2, ~mask);
2853 tcg_gen_and_i64(o->out, o->out, o->in2);
2854 break;
2855 case 0x56: /* OR */
2856 tcg_gen_andi_i64(o->in2, o->in2, mask);
2857 tcg_gen_or_i64(o->out, o->out, o->in2);
2858 break;
2859 case 0x57: /* XOR */
2860 tcg_gen_andi_i64(o->in2, o->in2, mask);
2861 tcg_gen_xor_i64(o->out, o->out, o->in2);
2862 break;
2863 default:
2864 abort();
2865 }
2866
2867 /* Set the CC. */
2868 tcg_gen_andi_i64(cc_dst, o->out, mask);
2869 set_cc_nz_u64(s, cc_dst);
2870 return NO_EXIT;
2871 }
2872
2873 static ExitStatus op_rev16(DisasContext *s, DisasOps *o)
2874 {
2875 tcg_gen_bswap16_i64(o->out, o->in2);
2876 return NO_EXIT;
2877 }
2878
2879 static ExitStatus op_rev32(DisasContext *s, DisasOps *o)
2880 {
2881 tcg_gen_bswap32_i64(o->out, o->in2);
2882 return NO_EXIT;
2883 }
2884
2885 static ExitStatus op_rev64(DisasContext *s, DisasOps *o)
2886 {
2887 tcg_gen_bswap64_i64(o->out, o->in2);
2888 return NO_EXIT;
2889 }
2890
2891 static ExitStatus op_rll32(DisasContext *s, DisasOps *o)
2892 {
2893 TCGv_i32 t1 = tcg_temp_new_i32();
2894 TCGv_i32 t2 = tcg_temp_new_i32();
2895 TCGv_i32 to = tcg_temp_new_i32();
2896 tcg_gen_trunc_i64_i32(t1, o->in1);
2897 tcg_gen_trunc_i64_i32(t2, o->in2);
2898 tcg_gen_rotl_i32(to, t1, t2);
2899 tcg_gen_extu_i32_i64(o->out, to);
2900 tcg_temp_free_i32(t1);
2901 tcg_temp_free_i32(t2);
2902 tcg_temp_free_i32(to);
2903 return NO_EXIT;
2904 }
2905
2906 static ExitStatus op_rll64(DisasContext *s, DisasOps *o)
2907 {
2908 tcg_gen_rotl_i64(o->out, o->in1, o->in2);
2909 return NO_EXIT;
2910 }
2911
2912 #ifndef CONFIG_USER_ONLY
2913 static ExitStatus op_rrbe(DisasContext *s, DisasOps *o)
2914 {
2915 check_privileged(s);
2916 gen_helper_rrbe(cc_op, cpu_env, o->in2);
2917 set_cc_static(s);
2918 return NO_EXIT;
2919 }
2920
2921 static ExitStatus op_sacf(DisasContext *s, DisasOps *o)
2922 {
2923 check_privileged(s);
2924 gen_helper_sacf(cpu_env, o->in2);
2925 /* Addressing mode has changed, so end the block. */
2926 return EXIT_PC_STALE;
2927 }
2928 #endif
2929
2930 static ExitStatus op_sar(DisasContext *s, DisasOps *o)
2931 {
2932 int r1 = get_field(s->fields, r1);
2933 tcg_gen_st32_i64(o->in2, cpu_env, offsetof(CPUS390XState, aregs[r1]));
2934 return NO_EXIT;
2935 }
2936
2937 static ExitStatus op_seb(DisasContext *s, DisasOps *o)
2938 {
2939 gen_helper_seb(o->out, cpu_env, o->in1, o->in2);
2940 return NO_EXIT;
2941 }
2942
2943 static ExitStatus op_sdb(DisasContext *s, DisasOps *o)
2944 {
2945 gen_helper_sdb(o->out, cpu_env, o->in1, o->in2);
2946 return NO_EXIT;
2947 }
2948
2949 static ExitStatus op_sxb(DisasContext *s, DisasOps *o)
2950 {
2951 gen_helper_sxb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
2952 return_low128(o->out2);
2953 return NO_EXIT;
2954 }
2955
2956 static ExitStatus op_sqeb(DisasContext *s, DisasOps *o)
2957 {
2958 gen_helper_sqeb(o->out, cpu_env, o->in2);
2959 return NO_EXIT;
2960 }
2961
2962 static ExitStatus op_sqdb(DisasContext *s, DisasOps *o)
2963 {
2964 gen_helper_sqdb(o->out, cpu_env, o->in2);
2965 return NO_EXIT;
2966 }
2967
2968 static ExitStatus op_sqxb(DisasContext *s, DisasOps *o)
2969 {
2970 gen_helper_sqxb(o->out, cpu_env, o->in1, o->in2);
2971 return_low128(o->out2);
2972 return NO_EXIT;
2973 }
2974
2975 #ifndef CONFIG_USER_ONLY
2976 static ExitStatus op_servc(DisasContext *s, DisasOps *o)
2977 {
2978 check_privileged(s);
2979 potential_page_fault(s);
2980 gen_helper_servc(cc_op, cpu_env, o->in2, o->in1);
2981 set_cc_static(s);
2982 return NO_EXIT;
2983 }
2984
2985 static ExitStatus op_sigp(DisasContext *s, DisasOps *o)
2986 {
2987 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2988 check_privileged(s);
2989 potential_page_fault(s);
2990 gen_helper_sigp(cc_op, cpu_env, o->in2, r1, o->in1);
2991 tcg_temp_free_i32(r1);
2992 return NO_EXIT;
2993 }
2994 #endif
2995
2996 static ExitStatus op_soc(DisasContext *s, DisasOps *o)
2997 {
2998 DisasCompare c;
2999 TCGv_i64 a;
3000 int lab, r1;
3001
3002 disas_jcc(s, &c, get_field(s->fields, m3));
3003
3004 lab = gen_new_label();
3005 if (c.is_64) {
3006 tcg_gen_brcond_i64(c.cond, c.u.s64.a, c.u.s64.b, lab);
3007 } else {
3008 tcg_gen_brcond_i32(c.cond, c.u.s32.a, c.u.s32.b, lab);
3009 }
3010 free_compare(&c);
3011
3012 r1 = get_field(s->fields, r1);
3013 a = get_address(s, 0, get_field(s->fields, b2), get_field(s->fields, d2));
3014 if (s->insn->data) {
3015 tcg_gen_qemu_st64(regs[r1], a, get_mem_index(s));
3016 } else {
3017 tcg_gen_qemu_st32(regs[r1], a, get_mem_index(s));
3018 }
3019 tcg_temp_free_i64(a);
3020
3021 gen_set_label(lab);
3022 return NO_EXIT;
3023 }
3024
3025 static ExitStatus op_sla(DisasContext *s, DisasOps *o)
3026 {
3027 uint64_t sign = 1ull << s->insn->data;
3028 enum cc_op cco = s->insn->data == 31 ? CC_OP_SLA_32 : CC_OP_SLA_64;
3029 gen_op_update2_cc_i64(s, cco, o->in1, o->in2);
3030 tcg_gen_shl_i64(o->out, o->in1, o->in2);
3031 /* The arithmetic left shift is curious in that it does not affect
3032 the sign bit. Copy that over from the source unchanged. */
3033 tcg_gen_andi_i64(o->out, o->out, ~sign);
3034 tcg_gen_andi_i64(o->in1, o->in1, sign);
3035 tcg_gen_or_i64(o->out, o->out, o->in1);
3036 return NO_EXIT;
3037 }
3038
3039 static ExitStatus op_sll(DisasContext *s, DisasOps *o)
3040 {
3041 tcg_gen_shl_i64(o->out, o->in1, o->in2);
3042 return NO_EXIT;
3043 }
3044
3045 static ExitStatus op_sra(DisasContext *s, DisasOps *o)
3046 {
3047 tcg_gen_sar_i64(o->out, o->in1, o->in2);
3048 return NO_EXIT;
3049 }
3050
3051 static ExitStatus op_srl(DisasContext *s, DisasOps *o)
3052 {
3053 tcg_gen_shr_i64(o->out, o->in1, o->in2);
3054 return NO_EXIT;
3055 }
3056
3057 static ExitStatus op_sfpc(DisasContext *s, DisasOps *o)
3058 {
3059 gen_helper_sfpc(cpu_env, o->in2);
3060 return NO_EXIT;
3061 }
3062
3063 static ExitStatus op_sfas(DisasContext *s, DisasOps *o)
3064 {
3065 gen_helper_sfas(cpu_env, o->in2);
3066 return NO_EXIT;
3067 }
3068
3069 static ExitStatus op_srnm(DisasContext *s, DisasOps *o)
3070 {
3071 int b2 = get_field(s->fields, b2);
3072 int d2 = get_field(s->fields, d2);
3073 TCGv_i64 t1 = tcg_temp_new_i64();
3074 TCGv_i64 t2 = tcg_temp_new_i64();
3075 int mask, pos, len;
3076
3077 switch (s->fields->op2) {
3078 case 0x99: /* SRNM */
3079 pos = 0, len = 2;
3080 break;
3081 case 0xb8: /* SRNMB */
3082 pos = 0, len = 3;
3083 break;
3084 case 0xb9: /* SRNMT */
3085 pos = 4, len = 3;
3086 break;
3087 default:
3088 tcg_abort();
3089 }
3090 mask = (1 << len) - 1;
3091
3092 /* Insert the value into the appropriate field of the FPC. */
3093 if (b2 == 0) {
3094 tcg_gen_movi_i64(t1, d2 & mask);
3095 } else {
3096 tcg_gen_addi_i64(t1, regs[b2], d2);
3097 tcg_gen_andi_i64(t1, t1, mask);
3098 }
3099 tcg_gen_ld32u_i64(t2, cpu_env, offsetof(CPUS390XState, fpc));
3100 tcg_gen_deposit_i64(t2, t2, t1, pos, len);
3101 tcg_temp_free_i64(t1);
3102
3103 /* Then install the new FPC to set the rounding mode in fpu_status. */
3104 gen_helper_sfpc(cpu_env, t2);
3105 tcg_temp_free_i64(t2);
3106 return NO_EXIT;
3107 }
3108
3109 #ifndef CONFIG_USER_ONLY
3110 static ExitStatus op_spka(DisasContext *s, DisasOps *o)
3111 {
3112 check_privileged(s);
3113 tcg_gen_shri_i64(o->in2, o->in2, 4);
3114 tcg_gen_deposit_i64(psw_mask, psw_mask, o->in2, PSW_SHIFT_KEY - 4, 4);
3115 return NO_EXIT;
3116 }
3117
3118 static ExitStatus op_sske(DisasContext *s, DisasOps *o)
3119 {
3120 check_privileged(s);
3121 gen_helper_sske(cpu_env, o->in1, o->in2);
3122 return NO_EXIT;
3123 }
3124
3125 static ExitStatus op_ssm(DisasContext *s, DisasOps *o)
3126 {
3127 check_privileged(s);
3128 tcg_gen_deposit_i64(psw_mask, psw_mask, o->in2, 56, 8);
3129 return NO_EXIT;
3130 }
3131
3132 static ExitStatus op_stap(DisasContext *s, DisasOps *o)
3133 {
3134 check_privileged(s);
3135 /* ??? Surely cpu address != cpu number. In any case the previous
3136 version of this stored more than the required half-word, so it
3137 is unlikely this has ever been tested. */
3138 tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, cpu_num));
3139 return NO_EXIT;
3140 }
3141
3142 static ExitStatus op_stck(DisasContext *s, DisasOps *o)
3143 {
3144 gen_helper_stck(o->out, cpu_env);
3145 /* ??? We don't implement clock states. */
3146 gen_op_movi_cc(s, 0);
3147 return NO_EXIT;
3148 }
3149
3150 static ExitStatus op_stcke(DisasContext *s, DisasOps *o)
3151 {
3152 TCGv_i64 c1 = tcg_temp_new_i64();
3153 TCGv_i64 c2 = tcg_temp_new_i64();
3154 gen_helper_stck(c1, cpu_env);
3155 /* Shift the 64-bit value into its place as a zero-extended
3156 104-bit value. Note that "bit positions 64-103 are always
3157 non-zero so that they compare differently to STCK"; we set
3158 the least significant bit to 1. */
3159 tcg_gen_shli_i64(c2, c1, 56);
3160 tcg_gen_shri_i64(c1, c1, 8);
3161 tcg_gen_ori_i64(c2, c2, 0x10000);
3162 tcg_gen_qemu_st64(c1, o->in2, get_mem_index(s));
3163 tcg_gen_addi_i64(o->in2, o->in2, 8);
3164 tcg_gen_qemu_st64(c2, o->in2, get_mem_index(s));
3165 tcg_temp_free_i64(c1);
3166 tcg_temp_free_i64(c2);
3167 /* ??? We don't implement clock states. */
3168 gen_op_movi_cc(s, 0);
3169 return NO_EXIT;
3170 }
3171
3172 static ExitStatus op_sckc(DisasContext *s, DisasOps *o)
3173 {
3174 check_privileged(s);
3175 gen_helper_sckc(cpu_env, o->in2);
3176 return NO_EXIT;
3177 }
3178
3179 static ExitStatus op_stckc(DisasContext *s, DisasOps *o)
3180 {
3181 check_privileged(s);
3182 gen_helper_stckc(o->out, cpu_env);
3183 return NO_EXIT;
3184 }
3185
3186 static ExitStatus op_stctg(DisasContext *s, DisasOps *o)
3187 {
3188 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
3189 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
3190 check_privileged(s);
3191 potential_page_fault(s);
3192 gen_helper_stctg(cpu_env, r1, o->in2, r3);
3193 tcg_temp_free_i32(r1);
3194 tcg_temp_free_i32(r3);
3195 return NO_EXIT;
3196 }
3197
3198 static ExitStatus op_stctl(DisasContext *s, DisasOps *o)
3199 {
3200 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
3201 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
3202 check_privileged(s);
3203 potential_page_fault(s);
3204 gen_helper_stctl(cpu_env, r1, o->in2, r3);
3205 tcg_temp_free_i32(r1);
3206 tcg_temp_free_i32(r3);
3207 return NO_EXIT;
3208 }
3209
3210 static ExitStatus op_stidp(DisasContext *s, DisasOps *o)
3211 {
3212 check_privileged(s);
3213 tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, cpu_num));
3214 return NO_EXIT;
3215 }
3216
3217 static ExitStatus op_spt(DisasContext *s, DisasOps *o)
3218 {
3219 check_privileged(s);
3220 gen_helper_spt(cpu_env, o->in2);
3221 return NO_EXIT;
3222 }
3223
3224 static ExitStatus op_stfl(DisasContext *s, DisasOps *o)
3225 {
3226 TCGv_i64 f, a;
3227 /* We really ought to have more complete indication of facilities
3228 that we implement. Address this when STFLE is implemented. */
3229 check_privileged(s);
3230 f = tcg_const_i64(0xc0000000);
3231 a = tcg_const_i64(200);
3232 tcg_gen_qemu_st32(f, a, get_mem_index(s));
3233 tcg_temp_free_i64(f);
3234 tcg_temp_free_i64(a);
3235 return NO_EXIT;
3236 }
3237
3238 static ExitStatus op_stpt(DisasContext *s, DisasOps *o)
3239 {
3240 check_privileged(s);
3241 gen_helper_stpt(o->out, cpu_env);
3242 return NO_EXIT;
3243 }
3244
3245 static ExitStatus op_stsi(DisasContext *s, DisasOps *o)
3246 {
3247 check_privileged(s);
3248 potential_page_fault(s);
3249 gen_helper_stsi(cc_op, cpu_env, o->in2, regs[0], regs[1]);
3250 set_cc_static(s);
3251 return NO_EXIT;
3252 }
3253
3254 static ExitStatus op_spx(DisasContext *s, DisasOps *o)
3255 {
3256 check_privileged(s);
3257 gen_helper_spx(cpu_env, o->in2);
3258 return NO_EXIT;
3259 }
3260
3261 static ExitStatus op_subchannel(DisasContext *s, DisasOps *o)
3262 {
3263 check_privileged(s);
3264 /* Not operational. */
3265 gen_op_movi_cc(s, 3);
3266 return NO_EXIT;
3267 }
3268
3269 static ExitStatus op_stpx(DisasContext *s, DisasOps *o)
3270 {
3271 check_privileged(s);
3272 tcg_gen_ld_i64(o->out, cpu_env, offsetof(CPUS390XState, psa));
3273 tcg_gen_andi_i64(o->out, o->out, 0x7fffe000);
3274 return NO_EXIT;
3275 }
3276
3277 static ExitStatus op_stnosm(DisasContext *s, DisasOps *o)
3278 {
3279 uint64_t i2 = get_field(s->fields, i2);
3280 TCGv_i64 t;
3281
3282 check_privileged(s);
3283
3284 /* It is important to do what the instruction name says: STORE THEN.
3285 If we let the output hook perform the store then if we fault and
3286 restart, we'll have the wrong SYSTEM MASK in place. */
3287 t = tcg_temp_new_i64();
3288 tcg_gen_shri_i64(t, psw_mask, 56);
3289 tcg_gen_qemu_st8(t, o->addr1, get_mem_index(s));
3290 tcg_temp_free_i64(t);
3291
3292 if (s->fields->op == 0xac) {
3293 tcg_gen_andi_i64(psw_mask, psw_mask,
3294 (i2 << 56) | 0x00ffffffffffffffull);
3295 } else {
3296 tcg_gen_ori_i64(psw_mask, psw_mask, i2 << 56);
3297 }
3298 return NO_EXIT;
3299 }
3300
3301 static ExitStatus op_stura(DisasContext *s, DisasOps *o)
3302 {
3303 check_privileged(s);
3304 potential_page_fault(s);
3305 gen_helper_stura(cpu_env, o->in2, o->in1);
3306 return NO_EXIT;
3307 }
3308 #endif
3309
3310 static ExitStatus op_st8(DisasContext *s, DisasOps *o)
3311 {
3312 tcg_gen_qemu_st8(o->in1, o->in2, get_mem_index(s));
3313 return NO_EXIT;
3314 }
3315
3316 static ExitStatus op_st16(DisasContext *s, DisasOps *o)
3317 {
3318 tcg_gen_qemu_st16(o->in1, o->in2, get_mem_index(s));
3319 return NO_EXIT;
3320 }
3321
3322 static ExitStatus op_st32(DisasContext *s, DisasOps *o)
3323 {
3324 tcg_gen_qemu_st32(o->in1, o->in2, get_mem_index(s));
3325 return NO_EXIT;
3326 }
3327
3328 static ExitStatus op_st64(DisasContext *s, DisasOps *o)
3329 {
3330 tcg_gen_qemu_st64(o->in1, o->in2, get_mem_index(s));
3331 return NO_EXIT;
3332 }
3333
3334 static ExitStatus op_stam(DisasContext *s, DisasOps *o)
3335 {
3336 TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
3337 TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
3338 potential_page_fault(s);
3339 gen_helper_stam(cpu_env, r1, o->in2, r3);
3340 tcg_temp_free_i32(r1);
3341 tcg_temp_free_i32(r3);
3342 return NO_EXIT;
3343 }
3344
3345 static ExitStatus op_stcm(DisasContext *s, DisasOps *o)
3346 {
3347 int m3 = get_field(s->fields, m3);
3348 int pos, base = s->insn->data;
3349 TCGv_i64 tmp = tcg_temp_new_i64();
3350
3351 pos = base + ctz32(m3) * 8;
3352 switch (m3) {
3353 case 0xf:
3354 /* Effectively a 32-bit store. */
3355 tcg_gen_shri_i64(tmp, o->in1, pos);
3356 tcg_gen_qemu_st32(tmp, o->in2, get_mem_index(s));
3357 break;
3358
3359 case 0xc:
3360 case 0x6:
3361 case 0x3:
3362 /* Effectively a 16-bit store. */
3363 tcg_gen_shri_i64(tmp, o->in1, pos);
3364 tcg_gen_qemu_st16(tmp, o->in2, get_mem_index(s));
3365 break;
3366
3367 case 0x8:
3368 case 0x4:
3369 case 0x2:
3370 case 0x1:
3371 /* Effectively an 8-bit store. */
3372 tcg_gen_shri_i64(tmp, o->in1, pos);
3373 tcg_gen_qemu_st8(tmp, o->in2, get_mem_index(s));
3374 break;
3375
3376 default:
3377 /* This is going to be a sequence of shifts and stores. */
3378 pos = base + 32 - 8;
3379 while (m3) {
3380 if (m3 & 0x8) {
3381 tcg_gen_shri_i64(tmp, o->in1, pos);
3382 tcg_gen_qemu_st8(tmp, o->in2, get_mem_index(s));
3383 tcg_gen_addi_i64(o->in2, o->in2, 1);
3384 }
3385 m3 = (m3 << 1) & 0xf;
3386 pos -= 8;
3387 }
3388 break;
3389 }
3390 tcg_temp_free_i64(tmp);
3391 return NO_EXIT;
3392 }
3393
3394 static ExitStatus op_stm(DisasContext *s, DisasOps *o)
3395 {
3396 int r1 = get_field(s->fields, r1);
3397 int r3 = get_field(s->fields, r3);
3398 int size = s->insn->data;
3399 TCGv_i64 tsize = tcg_const_i64(size);
3400
3401 while (1) {
3402 if (size == 8) {
3403 tcg_gen_qemu_st64(regs[r1], o->in2, get_mem_index(s));
3404 } else {
3405 tcg_gen_qemu_st32(regs[r1], o->in2, get_mem_index(s));
3406 }
3407 if (r1 == r3) {
3408 break;
3409 }
3410 tcg_gen_add_i64(o->in2, o->in2, tsize);
3411 r1 = (r1 + 1) & 15;
3412 }
3413
3414 tcg_temp_free_i64(tsize);
3415 return NO_EXIT;
3416 }
3417
3418 static ExitStatus op_stmh(DisasContext *s, DisasOps *o)
3419 {
3420 int r1 = get_field(s->fields, r1);
3421 int r3 = get_field(s->fields, r3);
3422 TCGv_i64 t = tcg_temp_new_i64();
3423 TCGv_i64 t4 = tcg_const_i64(4);
3424 TCGv_i64 t32 = tcg_const_i64(32);
3425
3426 while (1) {
3427 tcg_gen_shl_i64(t, regs[r1], t32);
3428 tcg_gen_qemu_st32(t, o->in2, get_mem_index(s));
3429 if (r1 == r3) {
3430 break;
3431 }
3432 tcg_gen_add_i64(o->in2, o->in2, t4);
3433 r1 = (r1 + 1) & 15;
3434 }
3435
3436 tcg_temp_free_i64(t);
3437 tcg_temp_free_i64(t4);
3438 tcg_temp_free_i64(t32);
3439 return NO_EXIT;
3440 }
3441
3442 static ExitStatus op_srst(DisasContext *s, DisasOps *o)
3443 {
3444 potential_page_fault(s);
3445 gen_helper_srst(o->in1, cpu_env, regs[0], o->in1, o->in2);
3446 set_cc_static(s);
3447 return_low128(o->in2);
3448 return NO_EXIT;
3449 }
3450
3451 static ExitStatus op_sub(DisasContext *s, DisasOps *o)
3452 {
3453 tcg_gen_sub_i64(o->out, o->in1, o->in2);
3454 return NO_EXIT;
3455 }
3456
3457 static ExitStatus op_subb(DisasContext *s, DisasOps *o)
3458 {
3459 DisasCompare cmp;
3460 TCGv_i64 borrow;
3461
3462 tcg_gen_sub_i64(o->out, o->in1, o->in2);
3463
3464 /* The !borrow flag is the msb of CC. Since we want the inverse of
3465 that, we ask for a comparison of CC=0 | CC=1 -> mask of 8 | 4. */
3466 disas_jcc(s, &cmp, 8 | 4);
3467 borrow = tcg_temp_new_i64();
3468 if (cmp.is_64) {
3469 tcg_gen_setcond_i64(cmp.cond, borrow, cmp.u.s64.a, cmp.u.s64.b);
3470 } else {
3471 TCGv_i32 t = tcg_temp_new_i32();
3472 tcg_gen_setcond_i32(cmp.cond, t, cmp.u.s32.a, cmp.u.s32.b);
3473 tcg_gen_extu_i32_i64(borrow, t);
3474 tcg_temp_free_i32(t);
3475 }
3476 free_compare(&cmp);
3477
3478 tcg_gen_sub_i64(o->out, o->out, borrow);
3479 tcg_temp_free_i64(borrow);
3480 return NO_EXIT;
3481 }
3482
3483 static ExitStatus op_svc(DisasContext *s, DisasOps *o)
3484 {
3485 TCGv_i32 t;
3486
3487 update_psw_addr(s);
3488 update_cc_op(s);
3489
3490 t = tcg_const_i32(get_field(s->fields, i1) & 0xff);
3491 tcg_gen_st_i32(t, cpu_env, offsetof(CPUS390XState, int_svc_code));
3492 tcg_temp_free_i32(t);
3493
3494 t = tcg_const_i32(s->next_pc - s->pc);
3495 tcg_gen_st_i32(t, cpu_env, offsetof(CPUS390XState, int_svc_ilen));
3496 tcg_temp_free_i32(t);
3497
3498 gen_exception(EXCP_SVC);
3499 return EXIT_NORETURN;
3500 }
3501
3502 static ExitStatus op_tceb(DisasContext *s, DisasOps *o)
3503 {
3504 gen_helper_tceb(cc_op, o->in1, o->in2);
3505 set_cc_static(s);
3506 return NO_EXIT;
3507 }
3508
3509 static ExitStatus op_tcdb(DisasContext *s, DisasOps *o)
3510 {
3511 gen_helper_tcdb(cc_op, o->in1, o->in2);
3512 set_cc_static(s);
3513 return NO_EXIT;
3514 }
3515
3516 static ExitStatus op_tcxb(DisasContext *s, DisasOps *o)
3517 {
3518 gen_helper_tcxb(cc_op, o->out, o->out2, o->in2);
3519 set_cc_static(s);
3520 return NO_EXIT;
3521 }
3522
3523 #ifndef CONFIG_USER_ONLY
3524 static ExitStatus op_tprot(DisasContext *s, DisasOps *o)
3525 {
3526 potential_page_fault(s);
3527 gen_helper_tprot(cc_op, o->addr1, o->in2);
3528 set_cc_static(s);
3529 return NO_EXIT;
3530 }
3531 #endif
3532
3533 static ExitStatus op_tr(DisasContext *s, DisasOps *o)
3534 {
3535 TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
3536 potential_page_fault(s);
3537 gen_helper_tr(cpu_env, l, o->addr1, o->in2);
3538 tcg_temp_free_i32(l);
3539 set_cc_static(s);
3540 return NO_EXIT;
3541 }
3542
3543 static ExitStatus op_unpk(DisasContext *s, DisasOps *o)
3544 {
3545 TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
3546 potential_page_fault(s);
3547 gen_helper_unpk(cpu_env, l, o->addr1, o->in2);
3548 tcg_temp_free_i32(l);
3549 return NO_EXIT;
3550 }
3551
3552 static ExitStatus op_xc(DisasContext *s, DisasOps *o)
3553 {
3554 int d1 = get_field(s->fields, d1);
3555 int d2 = get_field(s->fields, d2);
3556 int b1 = get_field(s->fields, b1);
3557 int b2 = get_field(s->fields, b2);
3558 int l = get_field(s->fields, l1);
3559 TCGv_i32 t32;
3560
3561 o->addr1 = get_address(s, 0, b1, d1);
3562
3563 /* If the addresses are identical, this is a store/memset of zero. */
3564 if (b1 == b2 && d1 == d2 && (l + 1) <= 32) {
3565 o->in2 = tcg_const_i64(0);
3566
3567 l++;
3568 while (l >= 8) {
3569 tcg_gen_qemu_st64(o->in2, o->addr1, get_mem_index(s));
3570 l -= 8;
3571 if (l > 0) {
3572 tcg_gen_addi_i64(o->addr1, o->addr1, 8);
3573 }
3574 }
3575 if (l >= 4) {
3576 tcg_gen_qemu_st32(o->in2, o->addr1, get_mem_index(s));
3577 l -= 4;
3578 if (l > 0) {
3579 tcg_gen_addi_i64(o->addr1, o->addr1, 4);
3580 }
3581 }
3582 if (l >= 2) {
3583 tcg_gen_qemu_st16(o->in2, o->addr1, get_mem_index(s));
3584 l -= 2;
3585 if (l > 0) {
3586 tcg_gen_addi_i64(o->addr1, o->addr1, 2);
3587 }
3588 }
3589 if (l) {
3590 tcg_gen_qemu_st8(o->in2, o->addr1, get_mem_index(s));
3591 }
3592 gen_op_movi_cc(s, 0);
3593 return NO_EXIT;
3594 }
3595
3596 /* But in general we'll defer to a helper. */
3597 o->in2 = get_address(s, 0, b2, d2);
3598 t32 = tcg_const_i32(l);
3599 potential_page_fault(s);
3600 gen_helper_xc(cc_op, cpu_env, t32, o->addr1, o->in2);
3601 tcg_temp_free_i32(t32);
3602 set_cc_static(s);
3603 return NO_EXIT;
3604 }
3605
3606 static ExitStatus op_xor(DisasContext *s, DisasOps *o)
3607 {
3608 tcg_gen_xor_i64(o->out, o->in1, o->in2);
3609 return NO_EXIT;
3610 }
3611
3612 static ExitStatus op_xori(DisasContext *s, DisasOps *o)
3613 {
3614 int shift = s->insn->data & 0xff;
3615 int size = s->insn->data >> 8;
3616 uint64_t mask = ((1ull << size) - 1) << shift;
3617
3618 assert(!o->g_in2);
3619 tcg_gen_shli_i64(o->in2, o->in2, shift);
3620 tcg_gen_xor_i64(o->out, o->in1, o->in2);
3621
3622 /* Produce the CC from only the bits manipulated. */
3623 tcg_gen_andi_i64(cc_dst, o->out, mask);
3624 set_cc_nz_u64(s, cc_dst);
3625 return NO_EXIT;
3626 }
3627
3628 static ExitStatus op_zero(DisasContext *s, DisasOps *o)
3629 {
3630 o->out = tcg_const_i64(0);
3631 return NO_EXIT;
3632 }
3633
3634 static ExitStatus op_zero2(DisasContext *s, DisasOps *o)
3635 {
3636 o->out = tcg_const_i64(0);
3637 o->out2 = o->out;
3638 o->g_out2 = true;
3639 return NO_EXIT;
3640 }
3641
3642 /* ====================================================================== */
3643 /* The "Cc OUTput" generators. Given the generated output (and in some cases
3644 the original inputs), update the various cc data structures in order to
3645 be able to compute the new condition code. */
3646
3647 static void cout_abs32(DisasContext *s, DisasOps *o)
3648 {
3649 gen_op_update1_cc_i64(s, CC_OP_ABS_32, o->out);
3650 }
3651
3652 static void cout_abs64(DisasContext *s, DisasOps *o)
3653 {
3654 gen_op_update1_cc_i64(s, CC_OP_ABS_64, o->out);
3655 }
3656
3657 static void cout_adds32(DisasContext *s, DisasOps *o)
3658 {
3659 gen_op_update3_cc_i64(s, CC_OP_ADD_32, o->in1, o->in2, o->out);
3660 }
3661
3662 static void cout_adds64(DisasContext *s, DisasOps *o)
3663 {
3664 gen_op_update3_cc_i64(s, CC_OP_ADD_64, o->in1, o->in2, o->out);
3665 }
3666
3667 static void cout_addu32(DisasContext *s, DisasOps *o)
3668 {
3669 gen_op_update3_cc_i64(s, CC_OP_ADDU_32, o->in1, o->in2, o->out);
3670 }
3671
3672 static void cout_addu64(DisasContext *s, DisasOps *o)
3673 {
3674 gen_op_update3_cc_i64(s, CC_OP_ADDU_64, o->in1, o->in2, o->out);
3675 }
3676
3677 static void cout_addc32(DisasContext *s, DisasOps *o)
3678 {
3679 gen_op_update3_cc_i64(s, CC_OP_ADDC_32, o->in1, o->in2, o->out);
3680 }
3681
3682 static void cout_addc64(DisasContext *s, DisasOps *o)
3683 {
3684 gen_op_update3_cc_i64(s, CC_OP_ADDC_64, o->in1, o->in2, o->out);
3685 }
3686
3687 static void cout_cmps32(DisasContext *s, DisasOps *o)
3688 {
3689 gen_op_update2_cc_i64(s, CC_OP_LTGT_32, o->in1, o->in2);
3690 }
3691
3692 static void cout_cmps64(DisasContext *s, DisasOps *o)
3693 {
3694 gen_op_update2_cc_i64(s, CC_OP_LTGT_64, o->in1, o->in2);
3695 }
3696
3697 static void cout_cmpu32(DisasContext *s, DisasOps *o)
3698 {
3699 gen_op_update2_cc_i64(s, CC_OP_LTUGTU_32, o->in1, o->in2);
3700 }
3701
3702 static void cout_cmpu64(DisasContext *s, DisasOps *o)
3703 {
3704 gen_op_update2_cc_i64(s, CC_OP_LTUGTU_64, o->in1, o->in2);
3705 }
3706
3707 static void cout_f32(DisasContext *s, DisasOps *o)
3708 {
3709 gen_op_update1_cc_i64(s, CC_OP_NZ_F32, o->out);
3710 }
3711
3712 static void cout_f64(DisasContext *s, DisasOps *o)
3713 {
3714 gen_op_update1_cc_i64(s, CC_OP_NZ_F64, o->out);
3715 }
3716
3717 static void cout_f128(DisasContext *s, DisasOps *o)
3718 {
3719 gen_op_update2_cc_i64(s, CC_OP_NZ_F128, o->out, o->out2);
3720 }
3721
3722 static void cout_nabs32(DisasContext *s, DisasOps *o)
3723 {
3724 gen_op_update1_cc_i64(s, CC_OP_NABS_32, o->out);
3725 }
3726
3727 static void cout_nabs64(DisasContext *s, DisasOps *o)
3728 {
3729 gen_op_update1_cc_i64(s, CC_OP_NABS_64, o->out);
3730 }
3731
3732 static void cout_neg32(DisasContext *s, DisasOps *o)
3733 {
3734 gen_op_update1_cc_i64(s, CC_OP_COMP_32, o->out);
3735 }
3736
3737 static void cout_neg64(DisasContext *s, DisasOps *o)
3738 {
3739 gen_op_update1_cc_i64(s, CC_OP_COMP_64, o->out);
3740 }
3741
3742 static void cout_nz32(DisasContext *s, DisasOps *o)
3743 {
3744 tcg_gen_ext32u_i64(cc_dst, o->out);
3745 gen_op_update1_cc_i64(s, CC_OP_NZ, cc_dst);
3746 }
3747
3748 static void cout_nz64(DisasContext *s, DisasOps *o)
3749 {
3750 gen_op_update1_cc_i64(s, CC_OP_NZ, o->out);
3751 }
3752
3753 static void cout_s32(DisasContext *s, DisasOps *o)
3754 {
3755 gen_op_update1_cc_i64(s, CC_OP_LTGT0_32, o->out);
3756 }
3757
3758 static void cout_s64(DisasContext *s, DisasOps *o)
3759 {
3760 gen_op_update1_cc_i64(s, CC_OP_LTGT0_64, o->out);
3761 }
3762
3763 static void cout_subs32(DisasContext *s, DisasOps *o)
3764 {
3765 gen_op_update3_cc_i64(s, CC_OP_SUB_32, o->in1, o->in2, o->out);
3766 }
3767
3768 static void cout_subs64(DisasContext *s, DisasOps *o)
3769 {
3770 gen_op_update3_cc_i64(s, CC_OP_SUB_64, o->in1, o->in2, o->out);
3771 }
3772
3773 static void cout_subu32(DisasContext *s, DisasOps *o)
3774 {
3775 gen_op_update3_cc_i64(s, CC_OP_SUBU_32, o->in1, o->in2, o->out);
3776 }
3777
3778 static void cout_subu64(DisasContext *s, DisasOps *o)
3779 {
3780 gen_op_update3_cc_i64(s, CC_OP_SUBU_64, o->in1, o->in2, o->out);
3781 }
3782
3783 static void cout_subb32(DisasContext *s, DisasOps *o)
3784 {
3785 gen_op_update3_cc_i64(s, CC_OP_SUBB_32, o->in1, o->in2, o->out);
3786 }
3787
3788 static void cout_subb64(DisasContext *s, DisasOps *o)
3789 {
3790 gen_op_update3_cc_i64(s, CC_OP_SUBB_64, o->in1, o->in2, o->out);
3791 }
3792
3793 static void cout_tm32(DisasContext *s, DisasOps *o)
3794 {
3795 gen_op_update2_cc_i64(s, CC_OP_TM_32, o->in1, o->in2);
3796 }
3797
3798 static void cout_tm64(DisasContext *s, DisasOps *o)
3799 {
3800 gen_op_update2_cc_i64(s, CC_OP_TM_64, o->in1, o->in2);
3801 }
3802
3803 /* ====================================================================== */
3804 /* The "PREParation" generators. These initialize the DisasOps.OUT fields
3805 with the TCG register to which we will write. Used in combination with
3806 the "wout" generators, in some cases we need a new temporary, and in
3807 some cases we can write to a TCG global. */
3808
3809 static void prep_new(DisasContext *s, DisasFields *f, DisasOps *o)
3810 {
3811 o->out = tcg_temp_new_i64();
3812 }
3813 #define SPEC_prep_new 0
3814
3815 static void prep_new_P(DisasContext *s, DisasFields *f, DisasOps *o)
3816 {
3817 o->out = tcg_temp_new_i64();
3818 o->out2 = tcg_temp_new_i64();
3819 }
3820 #define SPEC_prep_new_P 0
3821
3822 static void prep_r1(DisasContext *s, DisasFields *f, DisasOps *o)
3823 {
3824 o->out = regs[get_field(f, r1)];
3825 o->g_out = true;
3826 }
3827 #define SPEC_prep_r1 0
3828
3829 static void prep_r1_P(DisasContext *s, DisasFields *f, DisasOps *o)
3830 {
3831 int r1 = get_field(f, r1);
3832 o->out = regs[r1];
3833 o->out2 = regs[r1 + 1];
3834 o->g_out = o->g_out2 = true;
3835 }
3836 #define SPEC_prep_r1_P SPEC_r1_even
3837
3838 static void prep_f1(DisasContext *s, DisasFields *f, DisasOps *o)
3839 {
3840 o->out = fregs[get_field(f, r1)];
3841 o->g_out = true;
3842 }
3843 #define SPEC_prep_f1 0
3844
3845 static void prep_x1(DisasContext *s, DisasFields *f, DisasOps *o)
3846 {
3847 int r1 = get_field(f, r1);
3848 o->out = fregs[r1];
3849 o->out2 = fregs[r1 + 2];
3850 o->g_out = o->g_out2 = true;
3851 }
3852 #define SPEC_prep_x1 SPEC_r1_f128
3853
3854 /* ====================================================================== */
3855 /* The "Write OUTput" generators. These generally perform some non-trivial
3856 copy of data to TCG globals, or to main memory. The trivial cases are
3857 generally handled by having a "prep" generator install the TCG global
3858 as the destination of the operation. */
3859
3860 static void wout_r1(DisasContext *s, DisasFields *f, DisasOps *o)
3861 {
3862 store_reg(get_field(f, r1), o->out);
3863 }
3864 #define SPEC_wout_r1 0
3865
3866 static void wout_r1_8(DisasContext *s, DisasFields *f, DisasOps *o)
3867 {
3868 int r1 = get_field(f, r1);
3869 tcg_gen_deposit_i64(regs[r1], regs[r1], o->out, 0, 8);
3870 }
3871 #define SPEC_wout_r1_8 0
3872
3873 static void wout_r1_16(DisasContext *s, DisasFields *f, DisasOps *o)
3874 {
3875 int r1 = get_field(f, r1);
3876 tcg_gen_deposit_i64(regs[r1], regs[r1], o->out, 0, 16);
3877 }
3878 #define SPEC_wout_r1_16 0
3879
3880 static void wout_r1_32(DisasContext *s, DisasFields *f, DisasOps *o)
3881 {
3882 store_reg32_i64(get_field(f, r1), o->out);
3883 }
3884 #define SPEC_wout_r1_32 0
3885
3886 static void wout_r1_P32(DisasContext *s, DisasFields *f, DisasOps *o)
3887 {
3888 int r1 = get_field(f, r1);
3889 store_reg32_i64(r1, o->out);
3890 store_reg32_i64(r1 + 1, o->out2);
3891 }
3892 #define SPEC_wout_r1_P32 SPEC_r1_even
3893
3894 static void wout_r1_D32(DisasContext *s, DisasFields *f, DisasOps *o)
3895 {
3896 int r1 = get_field(f, r1);
3897 store_reg32_i64(r1 + 1, o->out);
3898 tcg_gen_shri_i64(o->out, o->out, 32);
3899 store_reg32_i64(r1, o->out);
3900 }
3901 #define SPEC_wout_r1_D32 SPEC_r1_even
3902
3903 static void wout_e1(DisasContext *s, DisasFields *f, DisasOps *o)
3904 {
3905 store_freg32_i64(get_field(f, r1), o->out);
3906 }
3907 #define SPEC_wout_e1 0
3908
3909 static void wout_f1(DisasContext *s, DisasFields *f, DisasOps *o)
3910 {
3911 store_freg(get_field(f, r1), o->out);
3912 }
3913 #define SPEC_wout_f1 0
3914
3915 static void wout_x1(DisasContext *s, DisasFields *f, DisasOps *o)
3916 {
3917 int f1 = get_field(s->fields, r1);
3918 store_freg(f1, o->out);
3919 store_freg(f1 + 2, o->out2);
3920 }
3921 #define SPEC_wout_x1 SPEC_r1_f128
3922
3923 static void wout_cond_r1r2_32(DisasContext *s, DisasFields *f, DisasOps *o)
3924 {
3925 if (get_field(f, r1) != get_field(f, r2)) {
3926 store_reg32_i64(get_field(f, r1), o->out);
3927 }
3928 }
3929 #define SPEC_wout_cond_r1r2_32 0
3930
3931 static void wout_cond_e1e2(DisasContext *s, DisasFields *f, DisasOps *o)
3932 {
3933 if (get_field(f, r1) != get_field(f, r2)) {
3934 store_freg32_i64(get_field(f, r1), o->out);
3935 }
3936 }
3937 #define SPEC_wout_cond_e1e2 0
3938
3939 static void wout_m1_8(DisasContext *s, DisasFields *f, DisasOps *o)
3940 {
3941 tcg_gen_qemu_st8(o->out, o->addr1, get_mem_index(s));
3942 }
3943 #define SPEC_wout_m1_8 0
3944
3945 static void wout_m1_16(DisasContext *s, DisasFields *f, DisasOps *o)
3946 {
3947 tcg_gen_qemu_st16(o->out, o->addr1, get_mem_index(s));
3948 }
3949 #define SPEC_wout_m1_16 0
3950
3951 static void wout_m1_32(DisasContext *s, DisasFields *f, DisasOps *o)
3952 {
3953 tcg_gen_qemu_st32(o->out, o->addr1, get_mem_index(s));
3954 }
3955 #define SPEC_wout_m1_32 0
3956
3957 static void wout_m1_64(DisasContext *s, DisasFields *f, DisasOps *o)
3958 {
3959 tcg_gen_qemu_st64(o->out, o->addr1, get_mem_index(s));
3960 }
3961 #define SPEC_wout_m1_64 0
3962
3963 static void wout_m2_32(DisasContext *s, DisasFields *f, DisasOps *o)
3964 {
3965 tcg_gen_qemu_st32(o->out, o->in2, get_mem_index(s));
3966 }
3967 #define SPEC_wout_m2_32 0
3968
3969 /* ====================================================================== */
3970 /* The "INput 1" generators. These load the first operand to an insn. */
3971
3972 static void in1_r1(DisasContext *s, DisasFields *f, DisasOps *o)
3973 {
3974 o->in1 = load_reg(get_field(f, r1));
3975 }
3976 #define SPEC_in1_r1 0
3977
3978 static void in1_r1_o(DisasContext *s, DisasFields *f, DisasOps *o)
3979 {
3980 o->in1 = regs[get_field(f, r1)];
3981 o->g_in1 = true;
3982 }
3983 #define SPEC_in1_r1_o 0
3984
3985 static void in1_r1_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3986 {
3987 o->in1 = tcg_temp_new_i64();
3988 tcg_gen_ext32s_i64(o->in1, regs[get_field(f, r1)]);
3989 }
3990 #define SPEC_in1_r1_32s 0
3991
3992 static void in1_r1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3993 {
3994 o->in1 = tcg_temp_new_i64();
3995 tcg_gen_ext32u_i64(o->in1, regs[get_field(f, r1)]);
3996 }
3997 #define SPEC_in1_r1_32u 0
3998
3999 static void in1_r1_sr32(DisasContext *s, DisasFields *f, DisasOps *o)
4000 {
4001 o->in1 = tcg_temp_new_i64();
4002 tcg_gen_shri_i64(o->in1, regs[get_field(f, r1)], 32);
4003 }
4004 #define SPEC_in1_r1_sr32 0
4005
4006 static void in1_r1p1(DisasContext *s, DisasFields *f, DisasOps *o)
4007 {
4008 o->in1 = load_reg(get_field(f, r1) + 1);
4009 }
4010 #define SPEC_in1_r1p1 SPEC_r1_even
4011
4012 static void in1_r1p1_32s(DisasContext *s, DisasFields *f, DisasOps *o)
4013 {
4014 o->in1 = tcg_temp_new_i64();
4015 tcg_gen_ext32s_i64(o->in1, regs[get_field(f, r1) + 1]);
4016 }
4017 #define SPEC_in1_r1p1_32s SPEC_r1_even
4018
4019 static void in1_r1p1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4020 {
4021 o->in1 = tcg_temp_new_i64();
4022 tcg_gen_ext32u_i64(o->in1, regs[get_field(f, r1) + 1]);
4023 }
4024 #define SPEC_in1_r1p1_32u SPEC_r1_even
4025
4026 static void in1_r1_D32(DisasContext *s, DisasFields *f, DisasOps *o)
4027 {
4028 int r1 = get_field(f, r1);
4029 o->in1 = tcg_temp_new_i64();
4030 tcg_gen_concat32_i64(o->in1, regs[r1 + 1], regs[r1]);
4031 }
4032 #define SPEC_in1_r1_D32 SPEC_r1_even
4033
4034 static void in1_r2(DisasContext *s, DisasFields *f, DisasOps *o)
4035 {
4036 o->in1 = load_reg(get_field(f, r2));
4037 }
4038 #define SPEC_in1_r2 0
4039
4040 static void in1_r3(DisasContext *s, DisasFields *f, DisasOps *o)
4041 {
4042 o->in1 = load_reg(get_field(f, r3));
4043 }
4044 #define SPEC_in1_r3 0
4045
4046 static void in1_r3_o(DisasContext *s, DisasFields *f, DisasOps *o)
4047 {
4048 o->in1 = regs[get_field(f, r3)];
4049 o->g_in1 = true;
4050 }
4051 #define SPEC_in1_r3_o 0
4052
4053 static void in1_r3_32s(DisasContext *s, DisasFields *f, DisasOps *o)
4054 {
4055 o->in1 = tcg_temp_new_i64();
4056 tcg_gen_ext32s_i64(o->in1, regs[get_field(f, r3)]);
4057 }
4058 #define SPEC_in1_r3_32s 0
4059
4060 static void in1_r3_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4061 {
4062 o->in1 = tcg_temp_new_i64();
4063 tcg_gen_ext32u_i64(o->in1, regs[get_field(f, r3)]);
4064 }
4065 #define SPEC_in1_r3_32u 0
4066
4067 static void in1_r3_D32(DisasContext *s, DisasFields *f, DisasOps *o)
4068 {
4069 int r3 = get_field(f, r3);
4070 o->in1 = tcg_temp_new_i64();
4071 tcg_gen_concat32_i64(o->in1, regs[r3 + 1], regs[r3]);
4072 }
4073 #define SPEC_in1_r3_D32 SPEC_r3_even
4074
4075 static void in1_e1(DisasContext *s, DisasFields *f, DisasOps *o)
4076 {
4077 o->in1 = load_freg32_i64(get_field(f, r1));
4078 }
4079 #define SPEC_in1_e1 0
4080
4081 static void in1_f1_o(DisasContext *s, DisasFields *f, DisasOps *o)
4082 {
4083 o->in1 = fregs[get_field(f, r1)];
4084 o->g_in1 = true;
4085 }
4086 #define SPEC_in1_f1_o 0
4087
4088 static void in1_x1_o(DisasContext *s, DisasFields *f, DisasOps *o)
4089 {
4090 int r1 = get_field(f, r1);
4091 o->out = fregs[r1];
4092 o->out2 = fregs[r1 + 2];
4093 o->g_out = o->g_out2 = true;
4094 }
4095 #define SPEC_in1_x1_o SPEC_r1_f128
4096
4097 static void in1_f3_o(DisasContext *s, DisasFields *f, DisasOps *o)
4098 {
4099 o->in1 = fregs[get_field(f, r3)];
4100 o->g_in1 = true;
4101 }
4102 #define SPEC_in1_f3_o 0
4103
4104 static void in1_la1(DisasContext *s, DisasFields *f, DisasOps *o)
4105 {
4106 o->addr1 = get_address(s, 0, get_field(f, b1), get_field(f, d1));
4107 }
4108 #define SPEC_in1_la1 0
4109
4110 static void in1_la2(DisasContext *s, DisasFields *f, DisasOps *o)
4111 {
4112 int x2 = have_field(f, x2) ? get_field(f, x2) : 0;
4113 o->addr1 = get_address(s, x2, get_field(f, b2), get_field(f, d2));
4114 }
4115 #define SPEC_in1_la2 0
4116
4117 static void in1_m1_8u(DisasContext *s, DisasFields *f, DisasOps *o)
4118 {
4119 in1_la1(s, f, o);
4120 o->in1 = tcg_temp_new_i64();
4121 tcg_gen_qemu_ld8u(o->in1, o->addr1, get_mem_index(s));
4122 }
4123 #define SPEC_in1_m1_8u 0
4124
4125 static void in1_m1_16s(DisasContext *s, DisasFields *f, DisasOps *o)
4126 {
4127 in1_la1(s, f, o);
4128 o->in1 = tcg_temp_new_i64();
4129 tcg_gen_qemu_ld16s(o->in1, o->addr1, get_mem_index(s));
4130 }
4131 #define SPEC_in1_m1_16s 0
4132
4133 static void in1_m1_16u(DisasContext *s, DisasFields *f, DisasOps *o)
4134 {
4135 in1_la1(s, f, o);
4136 o->in1 = tcg_temp_new_i64();
4137 tcg_gen_qemu_ld16u(o->in1, o->addr1, get_mem_index(s));
4138 }
4139 #define SPEC_in1_m1_16u 0
4140
4141 static void in1_m1_32s(DisasContext *s, DisasFields *f, DisasOps *o)
4142 {
4143 in1_la1(s, f, o);
4144 o->in1 = tcg_temp_new_i64();
4145 tcg_gen_qemu_ld32s(o->in1, o->addr1, get_mem_index(s));
4146 }
4147 #define SPEC_in1_m1_32s 0
4148
4149 static void in1_m1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4150 {
4151 in1_la1(s, f, o);
4152 o->in1 = tcg_temp_new_i64();
4153 tcg_gen_qemu_ld32u(o->in1, o->addr1, get_mem_index(s));
4154 }
4155 #define SPEC_in1_m1_32u 0
4156
4157 static void in1_m1_64(DisasContext *s, DisasFields *f, DisasOps *o)
4158 {
4159 in1_la1(s, f, o);
4160 o->in1 = tcg_temp_new_i64();
4161 tcg_gen_qemu_ld64(o->in1, o->addr1, get_mem_index(s));
4162 }
4163 #define SPEC_in1_m1_64 0
4164
4165 /* ====================================================================== */
4166 /* The "INput 2" generators. These load the second operand to an insn. */
4167
4168 static void in2_r1_o(DisasContext *s, DisasFields *f, DisasOps *o)
4169 {
4170 o->in2 = regs[get_field(f, r1)];
4171 o->g_in2 = true;
4172 }
4173 #define SPEC_in2_r1_o 0
4174
4175 static void in2_r1_16u(DisasContext *s, DisasFields *f, DisasOps *o)
4176 {
4177 o->in2 = tcg_temp_new_i64();
4178 tcg_gen_ext16u_i64(o->in2, regs[get_field(f, r1)]);
4179 }
4180 #define SPEC_in2_r1_16u 0
4181
4182 static void in2_r1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4183 {
4184 o->in2 = tcg_temp_new_i64();
4185 tcg_gen_ext32u_i64(o->in2, regs[get_field(f, r1)]);
4186 }
4187 #define SPEC_in2_r1_32u 0
4188
4189 static void in2_r1_D32(DisasContext *s, DisasFields *f, DisasOps *o)
4190 {
4191 int r1 = get_field(f, r1);
4192 o->in2 = tcg_temp_new_i64();
4193 tcg_gen_concat32_i64(o->in2, regs[r1 + 1], regs[r1]);
4194 }
4195 #define SPEC_in2_r1_D32 SPEC_r1_even
4196
4197 static void in2_r2(DisasContext *s, DisasFields *f, DisasOps *o)
4198 {
4199 o->in2 = load_reg(get_field(f, r2));
4200 }
4201 #define SPEC_in2_r2 0
4202
4203 static void in2_r2_o(DisasContext *s, DisasFields *f, DisasOps *o)
4204 {
4205 o->in2 = regs[get_field(f, r2)];
4206 o->g_in2 = true;
4207 }
4208 #define SPEC_in2_r2_o 0
4209
4210 static void in2_r2_nz(DisasContext *s, DisasFields *f, DisasOps *o)
4211 {
4212 int r2 = get_field(f, r2);
4213 if (r2 != 0) {
4214 o->in2 = load_reg(r2);
4215 }
4216 }
4217 #define SPEC_in2_r2_nz 0
4218
4219 static void in2_r2_8s(DisasContext *s, DisasFields *f, DisasOps *o)
4220 {
4221 o->in2 = tcg_temp_new_i64();
4222 tcg_gen_ext8s_i64(o->in2, regs[get_field(f, r2)]);
4223 }
4224 #define SPEC_in2_r2_8s 0
4225
4226 static void in2_r2_8u(DisasContext *s, DisasFields *f, DisasOps *o)
4227 {
4228 o->in2 = tcg_temp_new_i64();
4229 tcg_gen_ext8u_i64(o->in2, regs[get_field(f, r2)]);
4230 }
4231 #define SPEC_in2_r2_8u 0
4232
4233 static void in2_r2_16s(DisasContext *s, DisasFields *f, DisasOps *o)
4234 {
4235 o->in2 = tcg_temp_new_i64();
4236 tcg_gen_ext16s_i64(o->in2, regs[get_field(f, r2)]);
4237 }
4238 #define SPEC_in2_r2_16s 0
4239
4240 static void in2_r2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
4241 {
4242 o->in2 = tcg_temp_new_i64();
4243 tcg_gen_ext16u_i64(o->in2, regs[get_field(f, r2)]);
4244 }
4245 #define SPEC_in2_r2_16u 0
4246
4247 static void in2_r3(DisasContext *s, DisasFields *f, DisasOps *o)
4248 {
4249 o->in2 = load_reg(get_field(f, r3));
4250 }
4251 #define SPEC_in2_r3 0
4252
4253 static void in2_r2_32s(DisasContext *s, DisasFields *f, DisasOps *o)
4254 {
4255 o->in2 = tcg_temp_new_i64();
4256 tcg_gen_ext32s_i64(o->in2, regs[get_field(f, r2)]);
4257 }
4258 #define SPEC_in2_r2_32s 0
4259
4260 static void in2_r2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4261 {
4262 o->in2 = tcg_temp_new_i64();
4263 tcg_gen_ext32u_i64(o->in2, regs[get_field(f, r2)]);
4264 }
4265 #define SPEC_in2_r2_32u 0
4266
4267 static void in2_e2(DisasContext *s, DisasFields *f, DisasOps *o)
4268 {
4269 o->in2 = load_freg32_i64(get_field(f, r2));
4270 }
4271 #define SPEC_in2_e2 0
4272
4273 static void in2_f2_o(DisasContext *s, DisasFields *f, DisasOps *o)
4274 {
4275 o->in2 = fregs[get_field(f, r2)];
4276 o->g_in2 = true;
4277 }
4278 #define SPEC_in2_f2_o 0
4279
4280 static void in2_x2_o(DisasContext *s, DisasFields *f, DisasOps *o)
4281 {
4282 int r2 = get_field(f, r2);
4283 o->in1 = fregs[r2];
4284 o->in2 = fregs[r2 + 2];
4285 o->g_in1 = o->g_in2 = true;
4286 }
4287 #define SPEC_in2_x2_o SPEC_r2_f128
4288
4289 static void in2_ra2(DisasContext *s, DisasFields *f, DisasOps *o)
4290 {
4291 o->in2 = get_address(s, 0, get_field(f, r2), 0);
4292 }
4293 #define SPEC_in2_ra2 0
4294
4295 static void in2_a2(DisasContext *s, DisasFields *f, DisasOps *o)
4296 {
4297 int x2 = have_field(f, x2) ? get_field(f, x2) : 0;
4298 o->in2 = get_address(s, x2, get_field(f, b2), get_field(f, d2));
4299 }
4300 #define SPEC_in2_a2 0
4301
4302 static void in2_ri2(DisasContext *s, DisasFields *f, DisasOps *o)
4303 {
4304 o->in2 = tcg_const_i64(s->pc + (int64_t)get_field(f, i2) * 2);
4305 }
4306 #define SPEC_in2_ri2 0
4307
4308 static void in2_sh32(DisasContext *s, DisasFields *f, DisasOps *o)
4309 {
4310 help_l2_shift(s, f, o, 31);
4311 }
4312 #define SPEC_in2_sh32 0
4313
4314 static void in2_sh64(DisasContext *s, DisasFields *f, DisasOps *o)
4315 {
4316 help_l2_shift(s, f, o, 63);
4317 }
4318 #define SPEC_in2_sh64 0
4319
4320 static void in2_m2_8u(DisasContext *s, DisasFields *f, DisasOps *o)
4321 {
4322 in2_a2(s, f, o);
4323 tcg_gen_qemu_ld8u(o->in2, o->in2, get_mem_index(s));
4324 }
4325 #define SPEC_in2_m2_8u 0
4326
4327 static void in2_m2_16s(DisasContext *s, DisasFields *f, DisasOps *o)
4328 {
4329 in2_a2(s, f, o);
4330 tcg_gen_qemu_ld16s(o->in2, o->in2, get_mem_index(s));
4331 }
4332 #define SPEC_in2_m2_16s 0
4333
4334 static void in2_m2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
4335 {
4336 in2_a2(s, f, o);
4337 tcg_gen_qemu_ld16u(o->in2, o->in2, get_mem_index(s));
4338 }
4339 #define SPEC_in2_m2_16u 0
4340
4341 static void in2_m2_32s(DisasContext *s, DisasFields *f, DisasOps *o)
4342 {
4343 in2_a2(s, f, o);
4344 tcg_gen_qemu_ld32s(o->in2, o->in2, get_mem_index(s));
4345 }
4346 #define SPEC_in2_m2_32s 0
4347
4348 static void in2_m2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4349 {
4350 in2_a2(s, f, o);
4351 tcg_gen_qemu_ld32u(o->in2, o->in2, get_mem_index(s));
4352 }
4353 #define SPEC_in2_m2_32u 0
4354
4355 static void in2_m2_64(DisasContext *s, DisasFields *f, DisasOps *o)
4356 {
4357 in2_a2(s, f, o);
4358 tcg_gen_qemu_ld64(o->in2, o->in2, get_mem_index(s));
4359 }
4360 #define SPEC_in2_m2_64 0
4361
4362 static void in2_mri2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
4363 {
4364 in2_ri2(s, f, o);
4365 tcg_gen_qemu_ld16u(o->in2, o->in2, get_mem_index(s));
4366 }
4367 #define SPEC_in2_mri2_16u 0
4368
4369 static void in2_mri2_32s(DisasContext *s, DisasFields *f, DisasOps *o)
4370 {
4371 in2_ri2(s, f, o);
4372 tcg_gen_qemu_ld32s(o->in2, o->in2, get_mem_index(s));
4373 }
4374 #define SPEC_in2_mri2_32s 0
4375
4376 static void in2_mri2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4377 {
4378 in2_ri2(s, f, o);
4379 tcg_gen_qemu_ld32u(o->in2, o->in2, get_mem_index(s));
4380 }
4381 #define SPEC_in2_mri2_32u 0
4382
4383 static void in2_mri2_64(DisasContext *s, DisasFields *f, DisasOps *o)
4384 {
4385 in2_ri2(s, f, o);
4386 tcg_gen_qemu_ld64(o->in2, o->in2, get_mem_index(s));
4387 }
4388 #define SPEC_in2_mri2_64 0
4389
4390 static void in2_i2(DisasContext *s, DisasFields *f, DisasOps *o)
4391 {
4392 o->in2 = tcg_const_i64(get_field(f, i2));
4393 }
4394 #define SPEC_in2_i2 0
4395
4396 static void in2_i2_8u(DisasContext *s, DisasFields *f, DisasOps *o)
4397 {
4398 o->in2 = tcg_const_i64((uint8_t)get_field(f, i2));
4399 }
4400 #define SPEC_in2_i2_8u 0
4401
4402 static void in2_i2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
4403 {
4404 o->in2 = tcg_const_i64((uint16_t)get_field(f, i2));
4405 }
4406 #define SPEC_in2_i2_16u 0
4407
4408 static void in2_i2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
4409 {
4410 o->in2 = tcg_const_i64((uint32_t)get_field(f, i2));
4411 }
4412 #define SPEC_in2_i2_32u 0
4413
4414 static void in2_i2_16u_shl(DisasContext *s, DisasFields *f, DisasOps *o)
4415 {
4416 uint64_t i2 = (uint16_t)get_field(f, i2);
4417 o->in2 = tcg_const_i64(i2 << s->insn->data);
4418 }
4419 #define SPEC_in2_i2_16u_shl 0
4420
4421 static void in2_i2_32u_shl(DisasContext *s, DisasFields *f, DisasOps *o)
4422 {
4423 uint64_t i2 = (uint32_t)get_field(f, i2);
4424 o->in2 = tcg_const_i64(i2 << s->insn->data);
4425 }
4426 #define SPEC_in2_i2_32u_shl 0
4427
4428 /* ====================================================================== */
4429
4430 /* Find opc within the table of insns. This is formulated as a switch
4431 statement so that (1) we get compile-time notice of cut-paste errors
4432 for duplicated opcodes, and (2) the compiler generates the binary
4433 search tree, rather than us having to post-process the table. */
4434
4435 #define C(OPC, NM, FT, FC, I1, I2, P, W, OP, CC) \
4436 D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, 0)
4437
4438 #define D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, D) insn_ ## NM,
4439
4440 enum DisasInsnEnum {
4441 #include "insn-data.def"
4442 };
4443
4444 #undef D
4445 #define D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, D) { \
4446 .opc = OPC, \
4447 .fmt = FMT_##FT, \
4448 .fac = FAC_##FC, \
4449 .spec = SPEC_in1_##I1 | SPEC_in2_##I2 | SPEC_prep_##P | SPEC_wout_##W, \
4450 .name = #NM, \
4451 .help_in1 = in1_##I1, \
4452 .help_in2 = in2_##I2, \
4453 .help_prep = prep_##P, \
4454 .help_wout = wout_##W, \
4455 .help_cout = cout_##CC, \
4456 .help_op = op_##OP, \
4457 .data = D \
4458 },
4459
4460 /* Allow 0 to be used for NULL in the table below. */
4461 #define in1_0 NULL
4462 #define in2_0 NULL
4463 #define prep_0 NULL
4464 #define wout_0 NULL
4465 #define cout_0 NULL
4466 #define op_0 NULL
4467
4468 #define SPEC_in1_0 0
4469 #define SPEC_in2_0 0
4470 #define SPEC_prep_0 0
4471 #define SPEC_wout_0 0
4472
4473 static const DisasInsn insn_info[] = {
4474 #include "insn-data.def"
4475 };
4476
4477 #undef D
4478 #define D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, D) \
4479 case OPC: return &insn_info[insn_ ## NM];
4480
4481 static const DisasInsn *lookup_opc(uint16_t opc)
4482 {
4483 switch (opc) {
4484 #include "insn-data.def"
4485 default:
4486 return NULL;
4487 }
4488 }
4489
4490 #undef D
4491 #undef C
4492
4493 /* Extract a field from the insn. The INSN should be left-aligned in
4494 the uint64_t so that we can more easily utilize the big-bit-endian
4495 definitions we extract from the Principals of Operation. */
4496
4497 static void extract_field(DisasFields *o, const DisasField *f, uint64_t insn)
4498 {
4499 uint32_t r, m;
4500
4501 if (f->size == 0) {
4502 return;
4503 }
4504
4505 /* Zero extract the field from the insn. */
4506 r = (insn << f->beg) >> (64 - f->size);
4507
4508 /* Sign-extend, or un-swap the field as necessary. */
4509 switch (f->type) {
4510 case 0: /* unsigned */
4511 break;
4512 case 1: /* signed */
4513 assert(f->size <= 32);
4514 m = 1u << (f->size - 1);
4515 r = (r ^ m) - m;
4516 break;
4517 case 2: /* dl+dh split, signed 20 bit. */
4518 r = ((int8_t)r << 12) | (r >> 8);
4519 break;
4520 default:
4521 abort();
4522 }
4523
4524 /* Validate that the "compressed" encoding we selected above is valid.
4525 I.e. we havn't make two different original fields overlap. */
4526 assert(((o->presentC >> f->indexC) & 1) == 0);
4527 o->presentC |= 1 << f->indexC;
4528 o->presentO |= 1 << f->indexO;
4529
4530 o->c[f->indexC] = r;
4531 }
4532
4533 /* Lookup the insn at the current PC, extracting the operands into O and
4534 returning the info struct for the insn. Returns NULL for invalid insn. */
4535
4536 static const DisasInsn *extract_insn(CPUS390XState *env, DisasContext *s,
4537 DisasFields *f)
4538 {
4539 uint64_t insn, pc = s->pc;
4540 int op, op2, ilen;
4541 const DisasInsn *info;
4542
4543 insn = ld_code2(env, pc);
4544 op = (insn >> 8) & 0xff;
4545 ilen = get_ilen(op);
4546 s->next_pc = s->pc + ilen;
4547
4548 switch (ilen) {
4549 case 2:
4550 insn = insn << 48;
4551 break;
4552 case 4:
4553 insn = ld_code4(env, pc) << 32;
4554 break;
4555 case 6:
4556 insn = (insn << 48) | (ld_code4(env, pc + 2) << 16);
4557 break;
4558 default:
4559 abort();
4560 }
4561
4562 /* We can't actually determine the insn format until we've looked up
4563 the full insn opcode. Which we can't do without locating the
4564 secondary opcode. Assume by default that OP2 is at bit 40; for
4565 those smaller insns that don't actually have a secondary opcode
4566 this will correctly result in OP2 = 0. */
4567 switch (op) {
4568 case 0x01: /* E */
4569 case 0x80: /* S */
4570 case 0x82: /* S */
4571 case 0x93: /* S */
4572 case 0xb2: /* S, RRF, RRE */
4573 case 0xb3: /* RRE, RRD, RRF */
4574 case 0xb9: /* RRE, RRF */
4575 case 0xe5: /* SSE, SIL */
4576 op2 = (insn << 8) >> 56;
4577 break;
4578 case 0xa5: /* RI */
4579 case 0xa7: /* RI */
4580 case 0xc0: /* RIL */
4581 case 0xc2: /* RIL */
4582 case 0xc4: /* RIL */
4583 case 0xc6: /* RIL */
4584 case 0xc8: /* SSF */
4585 case 0xcc: /* RIL */
4586 op2 = (insn << 12) >> 60;
4587 break;
4588 case 0xd0 ... 0xdf: /* SS */
4589 case 0xe1: /* SS */
4590 case 0xe2: /* SS */
4591 case 0xe8: /* SS */
4592 case 0xe9: /* SS */
4593 case 0xea: /* SS */
4594 case 0xee ... 0xf3: /* SS */
4595 case 0xf8 ... 0xfd: /* SS */
4596 op2 = 0;
4597 break;
4598 default:
4599 op2 = (insn << 40) >> 56;
4600 break;
4601 }
4602
4603 memset(f, 0, sizeof(*f));
4604 f->op = op;
4605 f->op2 = op2;
4606
4607 /* Lookup the instruction. */
4608 info = lookup_opc(op << 8 | op2);
4609
4610 /* If we found it, extract the operands. */
4611 if (info != NULL) {
4612 DisasFormat fmt = info->fmt;
4613 int i;
4614
4615 for (i = 0; i < NUM_C_FIELD; ++i) {
4616 extract_field(f, &format_info[fmt].op[i], insn);
4617 }
4618 }
4619 return info;
4620 }
4621
4622 static ExitStatus translate_one(CPUS390XState *env, DisasContext *s)
4623 {
4624 const DisasInsn *insn;
4625 ExitStatus ret = NO_EXIT;
4626 DisasFields f;
4627 DisasOps o;
4628
4629 /* Search for the insn in the table. */
4630 insn = extract_insn(env, s, &f);
4631
4632 /* Not found means unimplemented/illegal opcode. */
4633 if (insn == NULL) {
4634 qemu_log_mask(LOG_UNIMP, "unimplemented opcode 0x%02x%02x\n",
4635 f.op, f.op2);
4636 gen_illegal_opcode(s);
4637 return EXIT_NORETURN;
4638 }
4639
4640 /* Check for insn specification exceptions. */
4641 if (insn->spec) {
4642 int spec = insn->spec, excp = 0, r;
4643
4644 if (spec & SPEC_r1_even) {
4645 r = get_field(&f, r1);
4646 if (r & 1) {
4647 excp = PGM_SPECIFICATION;
4648 }
4649 }
4650 if (spec & SPEC_r2_even) {
4651 r = get_field(&f, r2);
4652 if (r & 1) {
4653 excp = PGM_SPECIFICATION;
4654 }
4655 }
4656 if (spec & SPEC_r3_even) {
4657 r = get_field(&f, r3);
4658 if (r & 1) {
4659 excp = PGM_SPECIFICATION;
4660 }
4661 }
4662 if (spec & SPEC_r1_f128) {
4663 r = get_field(&f, r1);
4664 if (r > 13) {
4665 excp = PGM_SPECIFICATION;
4666 }
4667 }
4668 if (spec & SPEC_r2_f128) {
4669 r = get_field(&f, r2);
4670 if (r > 13) {
4671 excp = PGM_SPECIFICATION;
4672 }
4673 }
4674 if (excp) {
4675 gen_program_exception(s, excp);
4676 return EXIT_NORETURN;
4677 }
4678 }
4679
4680 /* Set up the strutures we use to communicate with the helpers. */
4681 s->insn = insn;
4682 s->fields = &f;
4683 o.g_out = o.g_out2 = o.g_in1 = o.g_in2 = false;
4684 TCGV_UNUSED_I64(o.out);
4685 TCGV_UNUSED_I64(o.out2);
4686 TCGV_UNUSED_I64(o.in1);
4687 TCGV_UNUSED_I64(o.in2);
4688 TCGV_UNUSED_I64(o.addr1);
4689
4690 /* Implement the instruction. */
4691 if (insn->help_in1) {
4692 insn->help_in1(s, &f, &o);
4693 }
4694 if (insn->help_in2) {
4695 insn->help_in2(s, &f, &o);
4696 }
4697 if (insn->help_prep) {
4698 insn->help_prep(s, &f, &o);
4699 }
4700 if (insn->help_op) {
4701 ret = insn->help_op(s, &o);
4702 }
4703 if (insn->help_wout) {
4704 insn->help_wout(s, &f, &o);
4705 }
4706 if (insn->help_cout) {
4707 insn->help_cout(s, &o);
4708 }
4709
4710 /* Free any temporaries created by the helpers. */
4711 if (!TCGV_IS_UNUSED_I64(o.out) && !o.g_out) {
4712 tcg_temp_free_i64(o.out);
4713 }
4714 if (!TCGV_IS_UNUSED_I64(o.out2) && !o.g_out2) {
4715 tcg_temp_free_i64(o.out2);
4716 }
4717 if (!TCGV_IS_UNUSED_I64(o.in1) && !o.g_in1) {
4718 tcg_temp_free_i64(o.in1);
4719 }
4720 if (!TCGV_IS_UNUSED_I64(o.in2) && !o.g_in2) {
4721 tcg_temp_free_i64(o.in2);
4722 }
4723 if (!TCGV_IS_UNUSED_I64(o.addr1)) {
4724 tcg_temp_free_i64(o.addr1);
4725 }
4726
4727 /* Advance to the next instruction. */
4728 s->pc = s->next_pc;
4729 return ret;
4730 }
4731
4732 static inline void gen_intermediate_code_internal(S390CPU *cpu,
4733 TranslationBlock *tb,
4734 bool search_pc)
4735 {
4736 CPUState *cs = CPU(cpu);
4737 CPUS390XState *env = &cpu->env;
4738 DisasContext dc;
4739 target_ulong pc_start;
4740 uint64_t next_page_start;
4741 uint16_t *gen_opc_end;
4742 int j, lj = -1;
4743 int num_insns, max_insns;
4744 CPUBreakpoint *bp;
4745 ExitStatus status;
4746 bool do_debug;
4747
4748 pc_start = tb->pc;
4749
4750 /* 31-bit mode */
4751 if (!(tb->flags & FLAG_MASK_64)) {
4752 pc_start &= 0x7fffffff;
4753 }
4754
4755 dc.tb = tb;
4756 dc.pc = pc_start;
4757 dc.cc_op = CC_OP_DYNAMIC;
4758 do_debug = dc.singlestep_enabled = cs->singlestep_enabled;
4759
4760 gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
4761
4762 next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
4763
4764 num_insns = 0;
4765 max_insns = tb->cflags & CF_COUNT_MASK;
4766 if (max_insns == 0) {
4767 max_insns = CF_COUNT_MASK;
4768 }
4769
4770 gen_tb_start();
4771
4772 do {
4773 if (search_pc) {
4774 j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
4775 if (lj < j) {
4776 lj++;
4777 while (lj < j) {
4778 tcg_ctx.gen_opc_instr_start[lj++] = 0;
4779 }
4780 }
4781 tcg_ctx.gen_opc_pc[lj] = dc.pc;
4782 gen_opc_cc_op[lj] = dc.cc_op;
4783 tcg_ctx.gen_opc_instr_start[lj] = 1;
4784 tcg_ctx.gen_opc_icount[lj] = num_insns;
4785 }
4786 if (++num_insns == max_insns && (tb->cflags & CF_LAST_IO)) {
4787 gen_io_start();
4788 }
4789
4790 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
4791 tcg_gen_debug_insn_start(dc.pc);
4792 }
4793
4794 status = NO_EXIT;
4795 if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) {
4796 QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {
4797 if (bp->pc == dc.pc) {
4798 status = EXIT_PC_STALE;
4799 do_debug = true;
4800 break;
4801 }
4802 }
4803 }
4804 if (status == NO_EXIT) {
4805 status = translate_one(env, &dc);
4806 }
4807
4808 /* If we reach a page boundary, are single stepping,
4809 or exhaust instruction count, stop generation. */
4810 if (status == NO_EXIT
4811 && (dc.pc >= next_page_start
4812 || tcg_ctx.gen_opc_ptr >= gen_opc_end
4813 || num_insns >= max_insns
4814 || singlestep
4815 || cs->singlestep_enabled)) {
4816 status = EXIT_PC_STALE;
4817 }
4818 } while (status == NO_EXIT);
4819
4820 if (tb->cflags & CF_LAST_IO) {
4821 gen_io_end();
4822 }
4823
4824 switch (status) {
4825 case EXIT_GOTO_TB:
4826 case EXIT_NORETURN:
4827 break;
4828 case EXIT_PC_STALE:
4829 update_psw_addr(&dc);
4830 /* FALLTHRU */
4831 case EXIT_PC_UPDATED:
4832 /* Next TB starts off with CC_OP_DYNAMIC, so make sure the
4833 cc op type is in env */
4834 update_cc_op(&dc);
4835 /* Exit the TB, either by raising a debug exception or by return. */
4836 if (do_debug) {
4837 gen_exception(EXCP_DEBUG);
4838 } else {
4839 tcg_gen_exit_tb(0);
4840 }
4841 break;
4842 default:
4843 abort();
4844 }
4845
4846 gen_tb_end(tb, num_insns);
4847 *tcg_ctx.gen_opc_ptr = INDEX_op_end;
4848 if (search_pc) {
4849 j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
4850 lj++;
4851 while (lj <= j) {
4852 tcg_ctx.gen_opc_instr_start[lj++] = 0;
4853 }
4854 } else {
4855 tb->size = dc.pc - pc_start;
4856 tb->icount = num_insns;
4857 }
4858
4859 #if defined(S390X_DEBUG_DISAS)
4860 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
4861 qemu_log("IN: %s\n", lookup_symbol(pc_start));
4862 log_target_disas(env, pc_start, dc.pc - pc_start, 1);
4863 qemu_log("\n");
4864 }
4865 #endif
4866 }
4867
4868 void gen_intermediate_code (CPUS390XState *env, struct TranslationBlock *tb)
4869 {
4870 gen_intermediate_code_internal(s390_env_get_cpu(env), tb, false);
4871 }
4872
4873 void gen_intermediate_code_pc (CPUS390XState *env, struct TranslationBlock *tb)
4874 {
4875 gen_intermediate_code_internal(s390_env_get_cpu(env), tb, true);
4876 }
4877
4878 void restore_state_to_opc(CPUS390XState *env, TranslationBlock *tb, int pc_pos)
4879 {
4880 int cc_op;
4881 env->psw.addr = tcg_ctx.gen_opc_pc[pc_pos];
4882 cc_op = gen_opc_cc_op[pc_pos];
4883 if ((cc_op != CC_OP_DYNAMIC) && (cc_op != CC_OP_STATIC)) {
4884 env->cc_op = cc_op;
4885 }
4886 }
QEmu