xref: /openbmc/qemu/target/s390x/tcg/cc_helper.c (revision 197a1372) 
1 /*
2  *  S/390 condition code helper routines
3  *
4  *  Copyright (c) 2009 Ulrich Hecht
5  *  Copyright (c) 2009 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.1 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 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "s390x-internal.h"
24 #include "tcg_s390x.h"
25 #include "exec/exec-all.h"
26 #include "exec/helper-proto.h"
27 #include "qemu/host-utils.h"
28 
29 /* #define DEBUG_HELPER */
30 #ifdef DEBUG_HELPER
31 #define HELPER_LOG(x...) qemu_log(x)
32 #else
33 #define HELPER_LOG(x...)
34 #endif
35 
36 static uint32_t cc_calc_ltgt_32(int32_t src, int32_t dst)
37 {
38     if (src == dst) {
39         return 0;
40     } else if (src < dst) {
41         return 1;
42     } else {
43         return 2;
44     }
45 }
46 
47 static uint32_t cc_calc_ltgt0_32(int32_t dst)
48 {
49     return cc_calc_ltgt_32(dst, 0);
50 }
51 
52 static uint32_t cc_calc_ltgt_64(int64_t src, int64_t dst)
53 {
54     if (src == dst) {
55         return 0;
56     } else if (src < dst) {
57         return 1;
58     } else {
59         return 2;
60     }
61 }
62 
63 static uint32_t cc_calc_ltgt0_64(int64_t dst)
64 {
65     return cc_calc_ltgt_64(dst, 0);
66 }
67 
68 static uint32_t cc_calc_ltugtu_32(uint32_t src, uint32_t dst)
69 {
70     if (src == dst) {
71         return 0;
72     } else if (src < dst) {
73         return 1;
74     } else {
75         return 2;
76     }
77 }
78 
79 static uint32_t cc_calc_ltugtu_64(uint64_t src, uint64_t dst)
80 {
81     if (src == dst) {
82         return 0;
83     } else if (src < dst) {
84         return 1;
85     } else {
86         return 2;
87     }
88 }
89 
90 static uint32_t cc_calc_tm_32(uint32_t val, uint32_t mask)
91 {
92     uint32_t r = val & mask;
93 
94     if (r == 0) {
95         return 0;
96     } else if (r == mask) {
97         return 3;
98     } else {
99         return 1;
100     }
101 }
102 
103 static uint32_t cc_calc_tm_64(uint64_t val, uint64_t mask)
104 {
105     uint64_t r = val & mask;
106 
107     if (r == 0) {
108         return 0;
109     } else if (r == mask) {
110         return 3;
111     } else {
112         int top = clz64(mask);
113         if ((int64_t)(val << top) < 0) {
114             return 2;
115         } else {
116             return 1;
117         }
118     }
119 }
120 
121 static uint32_t cc_calc_nz(uint64_t dst)
122 {
123     return !!dst;
124 }
125 
126 static uint32_t cc_calc_addu(uint64_t carry_out, uint64_t result)
127 {
128     g_assert(carry_out <= 1);
129     return (result != 0) + 2 * carry_out;
130 }
131 
132 static uint32_t cc_calc_subu(uint64_t borrow_out, uint64_t result)
133 {
134     return cc_calc_addu(borrow_out + 1, result);
135 }
136 
137 static uint32_t cc_calc_add_64(int64_t a1, int64_t a2, int64_t ar)
138 {
139     if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar >= 0)) {
140         return 3; /* overflow */
141     } else {
142         if (ar < 0) {
143             return 1;
144         } else if (ar > 0) {
145             return 2;
146         } else {
147             return 0;
148         }
149     }
150 }
151 
152 static 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; /* overflow */
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 
167 static uint32_t cc_calc_abs_64(int64_t dst)
168 {
169     if ((uint64_t)dst == 0x8000000000000000ULL) {
170         return 3;
171     } else if (dst) {
172         return 2;
173     } else {
174         return 0;
175     }
176 }
177 
178 static uint32_t cc_calc_nabs_64(int64_t dst)
179 {
180     return !!dst;
181 }
182 
183 static uint32_t cc_calc_comp_64(int64_t dst)
184 {
185     if ((uint64_t)dst == 0x8000000000000000ULL) {
186         return 3;
187     } else if (dst < 0) {
188         return 1;
189     } else if (dst > 0) {
190         return 2;
191     } else {
192         return 0;
193     }
194 }
195 
196 
197 static uint32_t cc_calc_add_32(int32_t a1, int32_t a2, int32_t ar)
198 {
199     if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar >= 0)) {
200         return 3; /* overflow */
201     } else {
202         if (ar < 0) {
203             return 1;
204         } else if (ar > 0) {
205             return 2;
206         } else {
207             return 0;
208         }
209     }
210 }
211 
212 static uint32_t cc_calc_sub_32(int32_t a1, int32_t a2, int32_t ar)
213 {
214     if ((a1 >= 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
215         return 3; /* overflow */
216     } else {
217         if (ar < 0) {
218             return 1;
219         } else if (ar > 0) {
220             return 2;
221         } else {
222             return 0;
223         }
224     }
225 }
226 
227 static uint32_t cc_calc_abs_32(int32_t dst)
228 {
229     if ((uint32_t)dst == 0x80000000UL) {
230         return 3;
231     } else if (dst) {
232         return 2;
233     } else {
234         return 0;
235     }
236 }
237 
238 static uint32_t cc_calc_nabs_32(int32_t dst)
239 {
240     return !!dst;
241 }
242 
243 static uint32_t cc_calc_comp_32(int32_t dst)
244 {
245     if ((uint32_t)dst == 0x80000000UL) {
246         return 3;
247     } else if (dst < 0) {
248         return 1;
249     } else if (dst > 0) {
250         return 2;
251     } else {
252         return 0;
253     }
254 }
255 
256 /* calculate condition code for insert character under mask insn */
257 static uint32_t cc_calc_icm(uint64_t mask, uint64_t val)
258 {
259     if ((val & mask) == 0) {
260         return 0;
261     } else {
262         int top = clz64(mask);
263         if ((int64_t)(val << top) < 0) {
264             return 1;
265         } else {
266             return 2;
267         }
268     }
269 }
270 
271 static uint32_t cc_calc_sla(uint64_t src, int shift)
272 {
273     uint64_t mask = -1ULL << (63 - shift);
274     uint64_t sign = 1ULL << 63;
275     uint64_t match;
276     int64_t r;
277 
278     /* Check if the sign bit stays the same.  */
279     if (src & sign) {
280         match = mask;
281     } else {
282         match = 0;
283     }
284     if ((src & mask) != match) {
285         /* Overflow.  */
286         return 3;
287     }
288 
289     r = ((src << shift) & ~sign) | (src & sign);
290     if (r == 0) {
291         return 0;
292     } else if (r < 0) {
293         return 1;
294     }
295     return 2;
296 }
297 
298 static uint32_t cc_calc_flogr(uint64_t dst)
299 {
300     return dst ? 2 : 0;
301 }
302 
303 static uint32_t cc_calc_lcbb(uint64_t dst)
304 {
305     return dst == 16 ? 0 : 3;
306 }
307 
308 static uint32_t cc_calc_vc(uint64_t low, uint64_t high)
309 {
310     if (high == -1ull && low == -1ull) {
311         /* all elements match */
312         return 0;
313     } else if (high == 0 && low == 0) {
314         /* no elements match */
315         return 3;
316     } else {
317         /* some elements but not all match */
318         return 1;
319     }
320 }
321 
322 static uint32_t cc_calc_muls_32(int64_t res)
323 {
324     const int64_t tmp = res >> 31;
325 
326     if (!res) {
327         return 0;
328     } else if (tmp && tmp != -1) {
329         return 3;
330     } else if (res < 0) {
331         return 1;
332     }
333     return 2;
334 }
335 
336 static uint64_t cc_calc_muls_64(int64_t res_high, uint64_t res_low)
337 {
338     if (!res_high && !res_low) {
339         return 0;
340     } else if (res_high + (res_low >> 63) != 0) {
341         return 3;
342     } else if (res_high < 0) {
343         return 1;
344     }
345     return 2;
346 }
347 
348 static uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
349                                   uint64_t src, uint64_t dst, uint64_t vr)
350 {
351     uint32_t r = 0;
352 
353     switch (cc_op) {
354     case CC_OP_CONST0:
355     case CC_OP_CONST1:
356     case CC_OP_CONST2:
357     case CC_OP_CONST3:
358         /* cc_op value _is_ cc */
359         r = cc_op;
360         break;
361     case CC_OP_LTGT0_32:
362         r = cc_calc_ltgt0_32(dst);
363         break;
364     case CC_OP_LTGT0_64:
365         r =  cc_calc_ltgt0_64(dst);
366         break;
367     case CC_OP_LTGT_32:
368         r =  cc_calc_ltgt_32(src, dst);
369         break;
370     case CC_OP_LTGT_64:
371         r =  cc_calc_ltgt_64(src, dst);
372         break;
373     case CC_OP_LTUGTU_32:
374         r =  cc_calc_ltugtu_32(src, dst);
375         break;
376     case CC_OP_LTUGTU_64:
377         r =  cc_calc_ltugtu_64(src, dst);
378         break;
379     case CC_OP_TM_32:
380         r =  cc_calc_tm_32(src, dst);
381         break;
382     case CC_OP_TM_64:
383         r =  cc_calc_tm_64(src, dst);
384         break;
385     case CC_OP_NZ:
386         r =  cc_calc_nz(dst);
387         break;
388     case CC_OP_ADDU:
389         r = cc_calc_addu(src, dst);
390         break;
391     case CC_OP_SUBU:
392         r = cc_calc_subu(src, dst);
393         break;
394     case CC_OP_ADD_64:
395         r =  cc_calc_add_64(src, dst, vr);
396         break;
397     case CC_OP_SUB_64:
398         r =  cc_calc_sub_64(src, dst, vr);
399         break;
400     case CC_OP_ABS_64:
401         r =  cc_calc_abs_64(dst);
402         break;
403     case CC_OP_NABS_64:
404         r =  cc_calc_nabs_64(dst);
405         break;
406     case CC_OP_COMP_64:
407         r =  cc_calc_comp_64(dst);
408         break;
409     case CC_OP_MULS_64:
410         r = cc_calc_muls_64(src, dst);
411         break;
412 
413     case CC_OP_ADD_32:
414         r =  cc_calc_add_32(src, dst, vr);
415         break;
416     case CC_OP_SUB_32:
417         r =  cc_calc_sub_32(src, dst, vr);
418         break;
419     case CC_OP_ABS_32:
420         r =  cc_calc_abs_32(dst);
421         break;
422     case CC_OP_NABS_32:
423         r =  cc_calc_nabs_32(dst);
424         break;
425     case CC_OP_COMP_32:
426         r =  cc_calc_comp_32(dst);
427         break;
428     case CC_OP_MULS_32:
429         r = cc_calc_muls_32(dst);
430         break;
431 
432     case CC_OP_ICM:
433         r =  cc_calc_icm(src, dst);
434         break;
435     case CC_OP_SLA:
436         r =  cc_calc_sla(src, dst);
437         break;
438     case CC_OP_FLOGR:
439         r = cc_calc_flogr(dst);
440         break;
441     case CC_OP_LCBB:
442         r = cc_calc_lcbb(dst);
443         break;
444     case CC_OP_VC:
445         r = cc_calc_vc(src, dst);
446         break;
447 
448     case CC_OP_NZ_F32:
449         r = set_cc_nz_f32(dst);
450         break;
451     case CC_OP_NZ_F64:
452         r = set_cc_nz_f64(dst);
453         break;
454     case CC_OP_NZ_F128:
455         r = set_cc_nz_f128(make_float128(src, dst));
456         break;
457 
458     default:
459         cpu_abort(env_cpu(env), "Unknown CC operation: %s\n", cc_name(cc_op));
460     }
461 
462     HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
463                cc_name(cc_op), src, dst, vr, r);
464     return r;
465 }
466 
467 uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
468                  uint64_t vr)
469 {
470     return do_calc_cc(env, cc_op, src, dst, vr);
471 }
472 
473 uint32_t HELPER(calc_cc)(CPUS390XState *env, uint32_t cc_op, uint64_t src,
474                          uint64_t dst, uint64_t vr)
475 {
476     return do_calc_cc(env, cc_op, src, dst, vr);
477 }
478 
479 #ifndef CONFIG_USER_ONLY
480 void HELPER(load_psw)(CPUS390XState *env, uint64_t mask, uint64_t addr)
481 {
482     s390_cpu_set_psw(env, mask, addr);
483     cpu_loop_exit(env_cpu(env));
484 }
485 
486 void HELPER(sacf)(CPUS390XState *env, uint64_t a1)
487 {
488     HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
489 
490     if (!(env->psw.mask & PSW_MASK_DAT)) {
491         tcg_s390_program_interrupt(env, PGM_SPECIAL_OP, GETPC());
492     }
493 
494     switch (a1 & 0xf00) {
495     case 0x000:
496         env->psw.mask &= ~PSW_MASK_ASC;
497         env->psw.mask |= PSW_ASC_PRIMARY;
498         break;
499     case 0x100:
500         env->psw.mask &= ~PSW_MASK_ASC;
501         env->psw.mask |= PSW_ASC_SECONDARY;
502         break;
503     case 0x300:
504         if ((env->psw.mask & PSW_MASK_PSTATE) != 0) {
505             tcg_s390_program_interrupt(env, PGM_PRIVILEGED, GETPC());
506         }
507         env->psw.mask &= ~PSW_MASK_ASC;
508         env->psw.mask |= PSW_ASC_HOME;
509         break;
510     default:
511         HELPER_LOG("unknown sacf mode: %" PRIx64 "\n", a1);
512         tcg_s390_program_interrupt(env, PGM_SPECIFICATION, GETPC());
513     }
514 }
515 #endif
516