s390x/kvm: Fix opcode decoding for eb instruction handler
[sdk/emulator/qemu.git] / target-s390x / fpu_helper.c
1 /*
2  *  S/390 FPU 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 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 "cpu.h"
22 #include "exec/cpu_ldst.h"
23 #include "exec/helper-proto.h"
24
25 /* #define DEBUG_HELPER */
26 #ifdef DEBUG_HELPER
27 #define HELPER_LOG(x...) qemu_log(x)
28 #else
29 #define HELPER_LOG(x...)
30 #endif
31
32 #define RET128(F) (env->retxl = F.low, F.high)
33
34 #define convert_bit(mask, from, to) \
35     (to < from                      \
36      ? (mask / (from / to)) & to    \
37      : (mask & from) * (to / from))
38
39 static void ieee_exception(CPUS390XState *env, uint32_t dxc, uintptr_t retaddr)
40 {
41     /* Install the DXC code.  */
42     env->fpc = (env->fpc & ~0xff00) | (dxc << 8);
43     /* Trap.  */
44     runtime_exception(env, PGM_DATA, retaddr);
45 }
46
47 /* Should be called after any operation that may raise IEEE exceptions.  */
48 static void handle_exceptions(CPUS390XState *env, uintptr_t retaddr)
49 {
50     unsigned s390_exc, qemu_exc;
51
52     /* Get the exceptions raised by the current operation.  Reset the
53        fpu_status contents so that the next operation has a clean slate.  */
54     qemu_exc = env->fpu_status.float_exception_flags;
55     if (qemu_exc == 0) {
56         return;
57     }
58     env->fpu_status.float_exception_flags = 0;
59
60     /* Convert softfloat exception bits to s390 exception bits.  */
61     s390_exc = 0;
62     s390_exc |= convert_bit(qemu_exc, float_flag_invalid, 0x80);
63     s390_exc |= convert_bit(qemu_exc, float_flag_divbyzero, 0x40);
64     s390_exc |= convert_bit(qemu_exc, float_flag_overflow, 0x20);
65     s390_exc |= convert_bit(qemu_exc, float_flag_underflow, 0x10);
66     s390_exc |= convert_bit(qemu_exc, float_flag_inexact, 0x08);
67
68     /* Install the exceptions that we raised.  */
69     env->fpc |= s390_exc << 16;
70
71     /* Send signals for enabled exceptions.  */
72     s390_exc &= env->fpc >> 24;
73     if (s390_exc) {
74         ieee_exception(env, s390_exc, retaddr);
75     }
76 }
77
78 static inline int float_comp_to_cc(CPUS390XState *env, int float_compare)
79 {
80     S390CPU *cpu = s390_env_get_cpu(env);
81
82     switch (float_compare) {
83     case float_relation_equal:
84         return 0;
85     case float_relation_less:
86         return 1;
87     case float_relation_greater:
88         return 2;
89     case float_relation_unordered:
90         return 3;
91     default:
92         cpu_abort(CPU(cpu), "unknown return value for float compare\n");
93     }
94 }
95
96 /* condition codes for unary FP ops */
97 uint32_t set_cc_nz_f32(float32 v)
98 {
99     if (float32_is_any_nan(v)) {
100         return 3;
101     } else if (float32_is_zero(v)) {
102         return 0;
103     } else if (float32_is_neg(v)) {
104         return 1;
105     } else {
106         return 2;
107     }
108 }
109
110 uint32_t set_cc_nz_f64(float64 v)
111 {
112     if (float64_is_any_nan(v)) {
113         return 3;
114     } else if (float64_is_zero(v)) {
115         return 0;
116     } else if (float64_is_neg(v)) {
117         return 1;
118     } else {
119         return 2;
120     }
121 }
122
123 uint32_t set_cc_nz_f128(float128 v)
124 {
125     if (float128_is_any_nan(v)) {
126         return 3;
127     } else if (float128_is_zero(v)) {
128         return 0;
129     } else if (float128_is_neg(v)) {
130         return 1;
131     } else {
132         return 2;
133     }
134 }
135
136 /* 32-bit FP addition */
137 uint64_t HELPER(aeb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
138 {
139     float32 ret = float32_add(f1, f2, &env->fpu_status);
140     handle_exceptions(env, GETPC());
141     return ret;
142 }
143
144 /* 64-bit FP addition */
145 uint64_t HELPER(adb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
146 {
147     float64 ret = float64_add(f1, f2, &env->fpu_status);
148     handle_exceptions(env, GETPC());
149     return ret;
150 }
151
152 /* 128-bit FP addition */
153 uint64_t HELPER(axb)(CPUS390XState *env, uint64_t ah, uint64_t al,
154                      uint64_t bh, uint64_t bl)
155 {
156     float128 ret = float128_add(make_float128(ah, al),
157                                 make_float128(bh, bl),
158                                 &env->fpu_status);
159     handle_exceptions(env, GETPC());
160     return RET128(ret);
161 }
162
163 /* 32-bit FP subtraction */
164 uint64_t HELPER(seb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
165 {
166     float32 ret = float32_sub(f1, f2, &env->fpu_status);
167     handle_exceptions(env, GETPC());
168     return ret;
169 }
170
171 /* 64-bit FP subtraction */
172 uint64_t HELPER(sdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
173 {
174     float64 ret = float64_sub(f1, f2, &env->fpu_status);
175     handle_exceptions(env, GETPC());
176     return ret;
177 }
178
179 /* 128-bit FP subtraction */
180 uint64_t HELPER(sxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
181                      uint64_t bh, uint64_t bl)
182 {
183     float128 ret = float128_sub(make_float128(ah, al),
184                                 make_float128(bh, bl),
185                                 &env->fpu_status);
186     handle_exceptions(env, GETPC());
187     return RET128(ret);
188 }
189
190 /* 32-bit FP division */
191 uint64_t HELPER(deb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
192 {
193     float32 ret = float32_div(f1, f2, &env->fpu_status);
194     handle_exceptions(env, GETPC());
195     return ret;
196 }
197
198 /* 64-bit FP division */
199 uint64_t HELPER(ddb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
200 {
201     float64 ret = float64_div(f1, f2, &env->fpu_status);
202     handle_exceptions(env, GETPC());
203     return ret;
204 }
205
206 /* 128-bit FP division */
207 uint64_t HELPER(dxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
208                      uint64_t bh, uint64_t bl)
209 {
210     float128 ret = float128_div(make_float128(ah, al),
211                                 make_float128(bh, bl),
212                                 &env->fpu_status);
213     handle_exceptions(env, GETPC());
214     return RET128(ret);
215 }
216
217 /* 32-bit FP multiplication */
218 uint64_t HELPER(meeb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
219 {
220     float32 ret = float32_mul(f1, f2, &env->fpu_status);
221     handle_exceptions(env, GETPC());
222     return ret;
223 }
224
225 /* 64-bit FP multiplication */
226 uint64_t HELPER(mdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
227 {
228     float64 ret = float64_mul(f1, f2, &env->fpu_status);
229     handle_exceptions(env, GETPC());
230     return ret;
231 }
232
233 /* 64/32-bit FP multiplication */
234 uint64_t HELPER(mdeb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
235 {
236     float64 ret = float32_to_float64(f2, &env->fpu_status);
237     ret = float64_mul(f1, ret, &env->fpu_status);
238     handle_exceptions(env, GETPC());
239     return ret;
240 }
241
242 /* 128-bit FP multiplication */
243 uint64_t HELPER(mxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
244                      uint64_t bh, uint64_t bl)
245 {
246     float128 ret = float128_mul(make_float128(ah, al),
247                                 make_float128(bh, bl),
248                                 &env->fpu_status);
249     handle_exceptions(env, GETPC());
250     return RET128(ret);
251 }
252
253 /* 128/64-bit FP multiplication */
254 uint64_t HELPER(mxdb)(CPUS390XState *env, uint64_t ah, uint64_t al,
255                       uint64_t f2)
256 {
257     float128 ret = float64_to_float128(f2, &env->fpu_status);
258     ret = float128_mul(make_float128(ah, al), ret, &env->fpu_status);
259     handle_exceptions(env, GETPC());
260     return RET128(ret);
261 }
262
263 /* convert 32-bit float to 64-bit float */
264 uint64_t HELPER(ldeb)(CPUS390XState *env, uint64_t f2)
265 {
266     float64 ret = float32_to_float64(f2, &env->fpu_status);
267     handle_exceptions(env, GETPC());
268     return ret;
269 }
270
271 /* convert 128-bit float to 64-bit float */
272 uint64_t HELPER(ldxb)(CPUS390XState *env, uint64_t ah, uint64_t al)
273 {
274     float64 ret = float128_to_float64(make_float128(ah, al), &env->fpu_status);
275     handle_exceptions(env, GETPC());
276     return ret;
277 }
278
279 /* convert 64-bit float to 128-bit float */
280 uint64_t HELPER(lxdb)(CPUS390XState *env, uint64_t f2)
281 {
282     float128 ret = float64_to_float128(f2, &env->fpu_status);
283     handle_exceptions(env, GETPC());
284     return RET128(ret);
285 }
286
287 /* convert 32-bit float to 128-bit float */
288 uint64_t HELPER(lxeb)(CPUS390XState *env, uint64_t f2)
289 {
290     float128 ret = float32_to_float128(f2, &env->fpu_status);
291     handle_exceptions(env, GETPC());
292     return RET128(ret);
293 }
294
295 /* convert 64-bit float to 32-bit float */
296 uint64_t HELPER(ledb)(CPUS390XState *env, uint64_t f2)
297 {
298     float32 ret = float64_to_float32(f2, &env->fpu_status);
299     handle_exceptions(env, GETPC());
300     return ret;
301 }
302
303 /* convert 128-bit float to 32-bit float */
304 uint64_t HELPER(lexb)(CPUS390XState *env, uint64_t ah, uint64_t al)
305 {
306     float32 ret = float128_to_float32(make_float128(ah, al), &env->fpu_status);
307     handle_exceptions(env, GETPC());
308     return ret;
309 }
310
311 /* 32-bit FP compare */
312 uint32_t HELPER(ceb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
313 {
314     int cmp = float32_compare_quiet(f1, f2, &env->fpu_status);
315     handle_exceptions(env, GETPC());
316     return float_comp_to_cc(env, cmp);
317 }
318
319 /* 64-bit FP compare */
320 uint32_t HELPER(cdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
321 {
322     int cmp = float64_compare_quiet(f1, f2, &env->fpu_status);
323     handle_exceptions(env, GETPC());
324     return float_comp_to_cc(env, cmp);
325 }
326
327 /* 128-bit FP compare */
328 uint32_t HELPER(cxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
329                      uint64_t bh, uint64_t bl)
330 {
331     int cmp = float128_compare_quiet(make_float128(ah, al),
332                                      make_float128(bh, bl),
333                                      &env->fpu_status);
334     handle_exceptions(env, GETPC());
335     return float_comp_to_cc(env, cmp);
336 }
337
338 static int swap_round_mode(CPUS390XState *env, int m3)
339 {
340     int ret = env->fpu_status.float_rounding_mode;
341     switch (m3) {
342     case 0:
343         /* current mode */
344         break;
345     case 1:
346         /* biased round no nearest */
347     case 4:
348         /* round to nearest */
349         set_float_rounding_mode(float_round_nearest_even, &env->fpu_status);
350         break;
351     case 5:
352         /* round to zero */
353         set_float_rounding_mode(float_round_to_zero, &env->fpu_status);
354         break;
355     case 6:
356         /* round to +inf */
357         set_float_rounding_mode(float_round_up, &env->fpu_status);
358         break;
359     case 7:
360         /* round to -inf */
361         set_float_rounding_mode(float_round_down, &env->fpu_status);
362         break;
363     }
364     return ret;
365 }
366
367 /* convert 64-bit int to 32-bit float */
368 uint64_t HELPER(cegb)(CPUS390XState *env, int64_t v2, uint32_t m3)
369 {
370     int hold = swap_round_mode(env, m3);
371     float32 ret = int64_to_float32(v2, &env->fpu_status);
372     set_float_rounding_mode(hold, &env->fpu_status);
373     handle_exceptions(env, GETPC());
374     return ret;
375 }
376
377 /* convert 64-bit int to 64-bit float */
378 uint64_t HELPER(cdgb)(CPUS390XState *env, int64_t v2, uint32_t m3)
379 {
380     int hold = swap_round_mode(env, m3);
381     float64 ret = int64_to_float64(v2, &env->fpu_status);
382     set_float_rounding_mode(hold, &env->fpu_status);
383     handle_exceptions(env, GETPC());
384     return ret;
385 }
386
387 /* convert 64-bit int to 128-bit float */
388 uint64_t HELPER(cxgb)(CPUS390XState *env, int64_t v2, uint32_t m3)
389 {
390     int hold = swap_round_mode(env, m3);
391     float128 ret = int64_to_float128(v2, &env->fpu_status);
392     set_float_rounding_mode(hold, &env->fpu_status);
393     handle_exceptions(env, GETPC());
394     return RET128(ret);
395 }
396
397 /* convert 64-bit uint to 32-bit float */
398 uint64_t HELPER(celgb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
399 {
400     int hold = swap_round_mode(env, m3);
401     float32 ret = uint64_to_float32(v2, &env->fpu_status);
402     set_float_rounding_mode(hold, &env->fpu_status);
403     handle_exceptions(env, GETPC());
404     return ret;
405 }
406
407 /* convert 64-bit uint to 64-bit float */
408 uint64_t HELPER(cdlgb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
409 {
410     int hold = swap_round_mode(env, m3);
411     float64 ret = uint64_to_float64(v2, &env->fpu_status);
412     set_float_rounding_mode(hold, &env->fpu_status);
413     handle_exceptions(env, GETPC());
414     return ret;
415 }
416
417 /* convert 64-bit uint to 128-bit float */
418 uint64_t HELPER(cxlgb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
419 {
420     int hold = swap_round_mode(env, m3);
421     float128 ret = uint64_to_float128(v2, &env->fpu_status);
422     set_float_rounding_mode(hold, &env->fpu_status);
423     handle_exceptions(env, GETPC());
424     return RET128(ret);
425 }
426
427 /* convert 32-bit float to 64-bit int */
428 uint64_t HELPER(cgeb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
429 {
430     int hold = swap_round_mode(env, m3);
431     int64_t ret = float32_to_int64(v2, &env->fpu_status);
432     set_float_rounding_mode(hold, &env->fpu_status);
433     handle_exceptions(env, GETPC());
434     return ret;
435 }
436
437 /* convert 64-bit float to 64-bit int */
438 uint64_t HELPER(cgdb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
439 {
440     int hold = swap_round_mode(env, m3);
441     int64_t ret = float64_to_int64(v2, &env->fpu_status);
442     set_float_rounding_mode(hold, &env->fpu_status);
443     handle_exceptions(env, GETPC());
444     return ret;
445 }
446
447 /* convert 128-bit float to 64-bit int */
448 uint64_t HELPER(cgxb)(CPUS390XState *env, uint64_t h, uint64_t l, uint32_t m3)
449 {
450     int hold = swap_round_mode(env, m3);
451     float128 v2 = make_float128(h, l);
452     int64_t ret = float128_to_int64(v2, &env->fpu_status);
453     set_float_rounding_mode(hold, &env->fpu_status);
454     handle_exceptions(env, GETPC());
455     return ret;
456 }
457
458 /* convert 32-bit float to 32-bit int */
459 uint64_t HELPER(cfeb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
460 {
461     int hold = swap_round_mode(env, m3);
462     int32_t ret = float32_to_int32(v2, &env->fpu_status);
463     set_float_rounding_mode(hold, &env->fpu_status);
464     handle_exceptions(env, GETPC());
465     return ret;
466 }
467
468 /* convert 64-bit float to 32-bit int */
469 uint64_t HELPER(cfdb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
470 {
471     int hold = swap_round_mode(env, m3);
472     int32_t ret = float64_to_int32(v2, &env->fpu_status);
473     set_float_rounding_mode(hold, &env->fpu_status);
474     handle_exceptions(env, GETPC());
475     return ret;
476 }
477
478 /* convert 128-bit float to 32-bit int */
479 uint64_t HELPER(cfxb)(CPUS390XState *env, uint64_t h, uint64_t l, uint32_t m3)
480 {
481     int hold = swap_round_mode(env, m3);
482     float128 v2 = make_float128(h, l);
483     int32_t ret = float128_to_int32(v2, &env->fpu_status);
484     set_float_rounding_mode(hold, &env->fpu_status);
485     handle_exceptions(env, GETPC());
486     return ret;
487 }
488
489 /* convert 32-bit float to 64-bit uint */
490 uint64_t HELPER(clgeb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
491 {
492     int hold = swap_round_mode(env, m3);
493     uint64_t ret;
494     v2 = float32_to_float64(v2, &env->fpu_status);
495     ret = float64_to_uint64(v2, &env->fpu_status);
496     set_float_rounding_mode(hold, &env->fpu_status);
497     handle_exceptions(env, GETPC());
498     return ret;
499 }
500
501 /* convert 64-bit float to 64-bit uint */
502 uint64_t HELPER(clgdb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
503 {
504     int hold = swap_round_mode(env, m3);
505     uint64_t ret = float64_to_uint64(v2, &env->fpu_status);
506     set_float_rounding_mode(hold, &env->fpu_status);
507     handle_exceptions(env, GETPC());
508     return ret;
509 }
510
511 /* convert 128-bit float to 64-bit uint */
512 uint64_t HELPER(clgxb)(CPUS390XState *env, uint64_t h, uint64_t l, uint32_t m3)
513 {
514     int hold = swap_round_mode(env, m3);
515     float128 v2 = make_float128(h, l);
516     /* ??? Not 100% correct.  */
517     uint64_t ret = float128_to_int64(v2, &env->fpu_status);
518     set_float_rounding_mode(hold, &env->fpu_status);
519     handle_exceptions(env, GETPC());
520     return ret;
521 }
522
523 /* convert 32-bit float to 32-bit uint */
524 uint64_t HELPER(clfeb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
525 {
526     int hold = swap_round_mode(env, m3);
527     uint32_t ret = float32_to_uint32(v2, &env->fpu_status);
528     set_float_rounding_mode(hold, &env->fpu_status);
529     handle_exceptions(env, GETPC());
530     return ret;
531 }
532
533 /* convert 64-bit float to 32-bit uint */
534 uint64_t HELPER(clfdb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
535 {
536     int hold = swap_round_mode(env, m3);
537     uint32_t ret = float64_to_uint32(v2, &env->fpu_status);
538     set_float_rounding_mode(hold, &env->fpu_status);
539     handle_exceptions(env, GETPC());
540     return ret;
541 }
542
543 /* convert 128-bit float to 32-bit uint */
544 uint64_t HELPER(clfxb)(CPUS390XState *env, uint64_t h, uint64_t l, uint32_t m3)
545 {
546     int hold = swap_round_mode(env, m3);
547     float128 v2 = make_float128(h, l);
548     /* Not 100% correct.  */
549     uint32_t ret = float128_to_int64(v2, &env->fpu_status);
550     set_float_rounding_mode(hold, &env->fpu_status);
551     handle_exceptions(env, GETPC());
552     return ret;
553 }
554
555 /* 32-bit FP multiply and add */
556 uint64_t HELPER(maeb)(CPUS390XState *env, uint64_t f1,
557                       uint64_t f2, uint64_t f3)
558 {
559     float32 ret = float32_muladd(f2, f3, f1, 0, &env->fpu_status);
560     handle_exceptions(env, GETPC());
561     return ret;
562 }
563
564 /* 64-bit FP multiply and add */
565 uint64_t HELPER(madb)(CPUS390XState *env, uint64_t f1,
566                       uint64_t f2, uint64_t f3)
567 {
568     float64 ret = float64_muladd(f2, f3, f1, 0, &env->fpu_status);
569     handle_exceptions(env, GETPC());
570     return ret;
571 }
572
573 /* 32-bit FP multiply and subtract */
574 uint64_t HELPER(mseb)(CPUS390XState *env, uint64_t f1,
575                       uint64_t f2, uint64_t f3)
576 {
577     float32 ret = float32_muladd(f2, f3, f1, float_muladd_negate_c,
578                                  &env->fpu_status);
579     handle_exceptions(env, GETPC());
580     return ret;
581 }
582
583 /* 64-bit FP multiply and subtract */
584 uint64_t HELPER(msdb)(CPUS390XState *env, uint64_t f1,
585                       uint64_t f2, uint64_t f3)
586 {
587     float64 ret = float64_muladd(f2, f3, f1, float_muladd_negate_c,
588                                  &env->fpu_status);
589     handle_exceptions(env, GETPC());
590     return ret;
591 }
592
593 /* test data class 32-bit */
594 uint32_t HELPER(tceb)(uint64_t f1, uint64_t m2)
595 {
596     float32 v1 = f1;
597     int neg = float32_is_neg(v1);
598     uint32_t cc = 0;
599
600     if ((float32_is_zero(v1) && (m2 & (1 << (11-neg)))) ||
601         (float32_is_infinity(v1) && (m2 & (1 << (5-neg)))) ||
602         (float32_is_any_nan(v1) && (m2 & (1 << (3-neg)))) ||
603         (float32_is_signaling_nan(v1) && (m2 & (1 << (1-neg))))) {
604         cc = 1;
605     } else if (m2 & (1 << (9-neg))) {
606         /* assume normalized number */
607         cc = 1;
608     }
609     /* FIXME: denormalized? */
610     return cc;
611 }
612
613 /* test data class 64-bit */
614 uint32_t HELPER(tcdb)(uint64_t v1, uint64_t m2)
615 {
616     int neg = float64_is_neg(v1);
617     uint32_t cc = 0;
618
619     if ((float64_is_zero(v1) && (m2 & (1 << (11-neg)))) ||
620         (float64_is_infinity(v1) && (m2 & (1 << (5-neg)))) ||
621         (float64_is_any_nan(v1) && (m2 & (1 << (3-neg)))) ||
622         (float64_is_signaling_nan(v1) && (m2 & (1 << (1-neg))))) {
623         cc = 1;
624     } else if (m2 & (1 << (9-neg))) {
625         /* assume normalized number */
626         cc = 1;
627     }
628     /* FIXME: denormalized? */
629     return cc;
630 }
631
632 /* test data class 128-bit */
633 uint32_t HELPER(tcxb)(uint64_t ah, uint64_t al, uint64_t m2)
634 {
635     float128 v1 = make_float128(ah, al);
636     int neg = float128_is_neg(v1);
637     uint32_t cc = 0;
638
639     if ((float128_is_zero(v1) && (m2 & (1 << (11-neg)))) ||
640         (float128_is_infinity(v1) && (m2 & (1 << (5-neg)))) ||
641         (float128_is_any_nan(v1) && (m2 & (1 << (3-neg)))) ||
642         (float128_is_signaling_nan(v1) && (m2 & (1 << (1-neg))))) {
643         cc = 1;
644     } else if (m2 & (1 << (9-neg))) {
645         /* assume normalized number */
646         cc = 1;
647     }
648     /* FIXME: denormalized? */
649     return cc;
650 }
651
652 /* square root 32-bit */
653 uint64_t HELPER(sqeb)(CPUS390XState *env, uint64_t f2)
654 {
655     float32 ret = float32_sqrt(f2, &env->fpu_status);
656     handle_exceptions(env, GETPC());
657     return ret;
658 }
659
660 /* square root 64-bit */
661 uint64_t HELPER(sqdb)(CPUS390XState *env, uint64_t f2)
662 {
663     float64 ret = float64_sqrt(f2, &env->fpu_status);
664     handle_exceptions(env, GETPC());
665     return ret;
666 }
667
668 /* square root 128-bit */
669 uint64_t HELPER(sqxb)(CPUS390XState *env, uint64_t ah, uint64_t al)
670 {
671     float128 ret = float128_sqrt(make_float128(ah, al), &env->fpu_status);
672     handle_exceptions(env, GETPC());
673     return RET128(ret);
674 }
675
676 static const int fpc_to_rnd[4] = {
677     float_round_nearest_even,
678     float_round_to_zero,
679     float_round_up,
680     float_round_down
681 };
682
683 /* set fpc */
684 void HELPER(sfpc)(CPUS390XState *env, uint64_t fpc)
685 {
686     /* Install everything in the main FPC.  */
687     env->fpc = fpc;
688
689     /* Install the rounding mode in the shadow fpu_status.  */
690     set_float_rounding_mode(fpc_to_rnd[fpc & 3], &env->fpu_status);
691 }
692
693 /* set fpc and signal */
694 void HELPER(sfas)(CPUS390XState *env, uint64_t val)
695 {
696     uint32_t signalling = env->fpc;
697     uint32_t source = val;
698     uint32_t s390_exc;
699
700     /* The contents of the source operand are placed in the FPC register;
701        then the flags in the FPC register are set to the logical OR of the
702        signalling flags and the source flags.  */
703     env->fpc = source | (signalling & 0x00ff0000);
704     set_float_rounding_mode(fpc_to_rnd[source & 3], &env->fpu_status);
705
706     /* If any signalling flag is 1 and the corresponding source mask
707        is also 1, a simulated-iee-exception trap occurs.  */
708     s390_exc = (signalling >> 16) & (source >> 24);
709     if (s390_exc) {
710         ieee_exception(env, s390_exc | 3, GETPC());
711     }
712 }