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