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