1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "cpu.h"
22#include "exec/helper-proto.h"
23#include "qemu/host-utils.h"
24
25
26#ifdef DEBUG_HELPER
27#define HELPER_LOG(x...) qemu_log(x)
28#else
29#define HELPER_LOG(x...)
30#endif
31
32static uint32_t cc_calc_ltgt_32(int32_t src, int32_t dst)
33{
34 if (src == dst) {
35 return 0;
36 } else if (src < dst) {
37 return 1;
38 } else {
39 return 2;
40 }
41}
42
43static uint32_t cc_calc_ltgt0_32(int32_t dst)
44{
45 return cc_calc_ltgt_32(dst, 0);
46}
47
48static uint32_t cc_calc_ltgt_64(int64_t src, int64_t dst)
49{
50 if (src == dst) {
51 return 0;
52 } else if (src < dst) {
53 return 1;
54 } else {
55 return 2;
56 }
57}
58
59static uint32_t cc_calc_ltgt0_64(int64_t dst)
60{
61 return cc_calc_ltgt_64(dst, 0);
62}
63
64static uint32_t cc_calc_ltugtu_32(uint32_t src, uint32_t dst)
65{
66 if (src == dst) {
67 return 0;
68 } else if (src < dst) {
69 return 1;
70 } else {
71 return 2;
72 }
73}
74
75static uint32_t cc_calc_ltugtu_64(uint64_t src, uint64_t dst)
76{
77 if (src == dst) {
78 return 0;
79 } else if (src < dst) {
80 return 1;
81 } else {
82 return 2;
83 }
84}
85
86static uint32_t cc_calc_tm_32(uint32_t val, uint32_t mask)
87{
88 uint32_t r = val & mask;
89
90 if (r == 0) {
91 return 0;
92 } else if (r == mask) {
93 return 3;
94 } else {
95 return 1;
96 }
97}
98
99static uint32_t cc_calc_tm_64(uint64_t val, uint64_t mask)
100{
101 uint64_t r = val & mask;
102
103 if (r == 0) {
104 return 0;
105 } else if (r == mask) {
106 return 3;
107 } else {
108 int top = clz64(mask);
109 if ((int64_t)(val << top) < 0) {
110 return 2;
111 } else {
112 return 1;
113 }
114 }
115}
116
117static uint32_t cc_calc_nz(uint64_t dst)
118{
119 return !!dst;
120}
121
122static uint32_t cc_calc_add_64(int64_t a1, int64_t a2, int64_t ar)
123{
124 if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
125 return 3;
126 } else {
127 if (ar < 0) {
128 return 1;
129 } else if (ar > 0) {
130 return 2;
131 } else {
132 return 0;
133 }
134 }
135}
136
137static uint32_t cc_calc_addu_64(uint64_t a1, uint64_t a2, uint64_t ar)
138{
139 return (ar != 0) + 2 * (ar < a1);
140}
141
142static uint32_t cc_calc_addc_64(uint64_t a1, uint64_t a2, uint64_t ar)
143{
144
145 uint64_t a2c = ar - a1;
146
147 int carry_out = (a2c < a2) || (ar < a1);
148
149 return (ar != 0) + 2 * carry_out;
150}
151
152static uint32_t cc_calc_sub_64(int64_t a1, int64_t a2, int64_t ar)
153{
154 if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
155 return 3;
156 } else {
157 if (ar < 0) {
158 return 1;
159 } else if (ar > 0) {
160 return 2;
161 } else {
162 return 0;
163 }
164 }
165}
166
167static uint32_t cc_calc_subu_64(uint64_t a1, uint64_t a2, uint64_t ar)
168{
169 if (ar == 0) {
170 return 2;
171 } else {
172 if (a2 > a1) {
173 return 1;
174 } else {
175 return 3;
176 }
177 }
178}
179
180static uint32_t cc_calc_subb_64(uint64_t a1, uint64_t a2, uint64_t ar)
181{
182 int borrow_out;
183
184 if (ar != a1 - a2) {
185 borrow_out = (a2 >= a1);
186 } else {
187 borrow_out = (a2 > a1);
188 }
189
190 return (ar != 0) + 2 * !borrow_out;
191}
192
193static uint32_t cc_calc_abs_64(int64_t dst)
194{
195 if ((uint64_t)dst == 0x8000000000000000ULL) {
196 return 3;
197 } else if (dst) {
198 return 1;
199 } else {
200 return 0;
201 }
202}
203
204static uint32_t cc_calc_nabs_64(int64_t dst)
205{
206 return !!dst;
207}
208
209static uint32_t cc_calc_comp_64(int64_t dst)
210{
211 if ((uint64_t)dst == 0x8000000000000000ULL) {
212 return 3;
213 } else if (dst < 0) {
214 return 1;
215 } else if (dst > 0) {
216 return 2;
217 } else {
218 return 0;
219 }
220}
221
222
223static uint32_t cc_calc_add_32(int32_t a1, int32_t a2, int32_t ar)
224{
225 if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
226 return 3;
227 } else {
228 if (ar < 0) {
229 return 1;
230 } else if (ar > 0) {
231 return 2;
232 } else {
233 return 0;
234 }
235 }
236}
237
238static uint32_t cc_calc_addu_32(uint32_t a1, uint32_t a2, uint32_t ar)
239{
240 return (ar != 0) + 2 * (ar < a1);
241}
242
243static uint32_t cc_calc_addc_32(uint32_t a1, uint32_t a2, uint32_t ar)
244{
245
246 uint32_t a2c = ar - a1;
247
248 int carry_out = (a2c < a2) || (ar < a1);
249
250 return (ar != 0) + 2 * carry_out;
251}
252
253static uint32_t cc_calc_sub_32(int32_t a1, int32_t a2, int32_t ar)
254{
255 if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
256 return 3;
257 } else {
258 if (ar < 0) {
259 return 1;
260 } else if (ar > 0) {
261 return 2;
262 } else {
263 return 0;
264 }
265 }
266}
267
268static uint32_t cc_calc_subu_32(uint32_t a1, uint32_t a2, uint32_t ar)
269{
270 if (ar == 0) {
271 return 2;
272 } else {
273 if (a2 > a1) {
274 return 1;
275 } else {
276 return 3;
277 }
278 }
279}
280
281static uint32_t cc_calc_subb_32(uint32_t a1, uint32_t a2, uint32_t ar)
282{
283 int borrow_out;
284
285 if (ar != a1 - a2) {
286 borrow_out = (a2 >= a1);
287 } else {
288 borrow_out = (a2 > a1);
289 }
290
291 return (ar != 0) + 2 * !borrow_out;
292}
293
294static uint32_t cc_calc_abs_32(int32_t dst)
295{
296 if ((uint32_t)dst == 0x80000000UL) {
297 return 3;
298 } else if (dst) {
299 return 1;
300 } else {
301 return 0;
302 }
303}
304
305static uint32_t cc_calc_nabs_32(int32_t dst)
306{
307 return !!dst;
308}
309
310static uint32_t cc_calc_comp_32(int32_t dst)
311{
312 if ((uint32_t)dst == 0x80000000UL) {
313 return 3;
314 } else if (dst < 0) {
315 return 1;
316 } else if (dst > 0) {
317 return 2;
318 } else {
319 return 0;
320 }
321}
322
323
324static uint32_t cc_calc_icm(uint64_t mask, uint64_t val)
325{
326 if ((val & mask) == 0) {
327 return 0;
328 } else {
329 int top = clz64(mask);
330 if ((int64_t)(val << top) < 0) {
331 return 1;
332 } else {
333 return 2;
334 }
335 }
336}
337
338static uint32_t cc_calc_sla_32(uint32_t src, int shift)
339{
340 uint32_t mask = ((1U << shift) - 1U) << (32 - shift);
341 uint32_t sign = 1U << 31;
342 uint32_t match;
343 int32_t r;
344
345
346 if (src & sign) {
347 match = mask;
348 } else {
349 match = 0;
350 }
351 if ((src & mask) != match) {
352
353 return 3;
354 }
355
356 r = ((src << shift) & ~sign) | (src & sign);
357 if (r == 0) {
358 return 0;
359 } else if (r < 0) {
360 return 1;
361 }
362 return 2;
363}
364
365static uint32_t cc_calc_sla_64(uint64_t src, int shift)
366{
367 uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
368 uint64_t sign = 1ULL << 63;
369 uint64_t match;
370 int64_t r;
371
372
373 if (src & sign) {
374 match = mask;
375 } else {
376 match = 0;
377 }
378 if ((src & mask) != match) {
379
380 return 3;
381 }
382
383 r = ((src << shift) & ~sign) | (src & sign);
384 if (r == 0) {
385 return 0;
386 } else if (r < 0) {
387 return 1;
388 }
389 return 2;
390}
391
392static uint32_t cc_calc_flogr(uint64_t dst)
393{
394 return dst ? 2 : 0;
395}
396
397static uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
398 uint64_t src, uint64_t dst, uint64_t vr)
399{
400 S390CPU *cpu = s390_env_get_cpu(env);
401 uint32_t r = 0;
402
403 switch (cc_op) {
404 case CC_OP_CONST0:
405 case CC_OP_CONST1:
406 case CC_OP_CONST2:
407 case CC_OP_CONST3:
408
409 r = cc_op;
410 break;
411 case CC_OP_LTGT0_32:
412 r = cc_calc_ltgt0_32(dst);
413 break;
414 case CC_OP_LTGT0_64:
415 r = cc_calc_ltgt0_64(dst);
416 break;
417 case CC_OP_LTGT_32:
418 r = cc_calc_ltgt_32(src, dst);
419 break;
420 case CC_OP_LTGT_64:
421 r = cc_calc_ltgt_64(src, dst);
422 break;
423 case CC_OP_LTUGTU_32:
424 r = cc_calc_ltugtu_32(src, dst);
425 break;
426 case CC_OP_LTUGTU_64:
427 r = cc_calc_ltugtu_64(src, dst);
428 break;
429 case CC_OP_TM_32:
430 r = cc_calc_tm_32(src, dst);
431 break;
432 case CC_OP_TM_64:
433 r = cc_calc_tm_64(src, dst);
434 break;
435 case CC_OP_NZ:
436 r = cc_calc_nz(dst);
437 break;
438 case CC_OP_ADD_64:
439 r = cc_calc_add_64(src, dst, vr);
440 break;
441 case CC_OP_ADDU_64:
442 r = cc_calc_addu_64(src, dst, vr);
443 break;
444 case CC_OP_ADDC_64:
445 r = cc_calc_addc_64(src, dst, vr);
446 break;
447 case CC_OP_SUB_64:
448 r = cc_calc_sub_64(src, dst, vr);
449 break;
450 case CC_OP_SUBU_64:
451 r = cc_calc_subu_64(src, dst, vr);
452 break;
453 case CC_OP_SUBB_64:
454 r = cc_calc_subb_64(src, dst, vr);
455 break;
456 case CC_OP_ABS_64:
457 r = cc_calc_abs_64(dst);
458 break;
459 case CC_OP_NABS_64:
460 r = cc_calc_nabs_64(dst);
461 break;
462 case CC_OP_COMP_64:
463 r = cc_calc_comp_64(dst);
464 break;
465
466 case CC_OP_ADD_32:
467 r = cc_calc_add_32(src, dst, vr);
468 break;
469 case CC_OP_ADDU_32:
470 r = cc_calc_addu_32(src, dst, vr);
471 break;
472 case CC_OP_ADDC_32:
473 r = cc_calc_addc_32(src, dst, vr);
474 break;
475 case CC_OP_SUB_32:
476 r = cc_calc_sub_32(src, dst, vr);
477 break;
478 case CC_OP_SUBU_32:
479 r = cc_calc_subu_32(src, dst, vr);
480 break;
481 case CC_OP_SUBB_32:
482 r = cc_calc_subb_32(src, dst, vr);
483 break;
484 case CC_OP_ABS_32:
485 r = cc_calc_abs_32(dst);
486 break;
487 case CC_OP_NABS_32:
488 r = cc_calc_nabs_32(dst);
489 break;
490 case CC_OP_COMP_32:
491 r = cc_calc_comp_32(dst);
492 break;
493
494 case CC_OP_ICM:
495 r = cc_calc_icm(src, dst);
496 break;
497 case CC_OP_SLA_32:
498 r = cc_calc_sla_32(src, dst);
499 break;
500 case CC_OP_SLA_64:
501 r = cc_calc_sla_64(src, dst);
502 break;
503 case CC_OP_FLOGR:
504 r = cc_calc_flogr(dst);
505 break;
506
507 case CC_OP_NZ_F32:
508 r = set_cc_nz_f32(dst);
509 break;
510 case CC_OP_NZ_F64:
511 r = set_cc_nz_f64(dst);
512 break;
513 case CC_OP_NZ_F128:
514 r = set_cc_nz_f128(make_float128(src, dst));
515 break;
516
517 default:
518 cpu_abort(CPU(cpu), "Unknown CC operation: %s\n", cc_name(cc_op));
519 }
520
521 HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
522 cc_name(cc_op), src, dst, vr, r);
523 return r;
524}
525
526uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
527 uint64_t vr)
528{
529 return do_calc_cc(env, cc_op, src, dst, vr);
530}
531
532uint32_t HELPER(calc_cc)(CPUS390XState *env, uint32_t cc_op, uint64_t src,
533 uint64_t dst, uint64_t vr)
534{
535 return do_calc_cc(env, cc_op, src, dst, vr);
536}
537
538#ifndef CONFIG_USER_ONLY
539void HELPER(load_psw)(CPUS390XState *env, uint64_t mask, uint64_t addr)
540{
541 load_psw(env, mask, addr);
542 cpu_loop_exit(CPU(s390_env_get_cpu(env)));
543}
544
545void HELPER(sacf)(CPUS390XState *env, uint64_t a1)
546{
547 HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
548
549 switch (a1 & 0xf00) {
550 case 0x000:
551 env->psw.mask &= ~PSW_MASK_ASC;
552 env->psw.mask |= PSW_ASC_PRIMARY;
553 break;
554 case 0x100:
555 env->psw.mask &= ~PSW_MASK_ASC;
556 env->psw.mask |= PSW_ASC_SECONDARY;
557 break;
558 case 0x300:
559 env->psw.mask &= ~PSW_MASK_ASC;
560 env->psw.mask |= PSW_ASC_HOME;
561 break;
562 default:
563 qemu_log("unknown sacf mode: %" PRIx64 "\n", a1);
564 program_interrupt(env, PGM_SPECIFICATION, 2);
565 break;
566 }
567}
568#endif
569