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