]>
git.proxmox.com Git - qemu.git/blob - target-s390x/fpu_helper.c
9805026c6a8f71d1092d40bf11fec2a8ba93cd1d
2 * S/390 FPU helper routines
4 * Copyright (c) 2009 Ulrich Hecht
5 * Copyright (c) 2009 Alexander Graf
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.
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.
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/>.
24 #if !defined(CONFIG_USER_ONLY)
25 #include "exec/softmmu_exec.h"
28 /* #define DEBUG_HELPER */
30 #define HELPER_LOG(x...) qemu_log(x)
32 #define HELPER_LOG(x...)
35 #define RET128(F) (env->retxl = F.low, F.high)
37 #define convert_bit(mask, from, to) \
39 ? (mask / (from / to)) & to \
40 : (mask & from) * (to / from))
42 static void ieee_exception(CPUS390XState
*env
, uint32_t dxc
, uintptr_t retaddr
)
44 /* Install the DXC code. */
45 env
->fpc
= (env
->fpc
& ~0xff00) | (dxc
<< 8);
47 runtime_exception(env
, PGM_DATA
, retaddr
);
50 /* Should be called after any operation that may raise IEEE exceptions. */
51 static void handle_exceptions(CPUS390XState
*env
, uintptr_t retaddr
)
53 unsigned s390_exc
, qemu_exc
;
55 /* Get the exceptions raised by the current operation. Reset the
56 fpu_status contents so that the next operation has a clean slate. */
57 qemu_exc
= env
->fpu_status
.float_exception_flags
;
61 env
->fpu_status
.float_exception_flags
= 0;
63 /* Convert softfloat exception bits to s390 exception bits. */
65 s390_exc
|= convert_bit(qemu_exc
, float_flag_invalid
, 0x80);
66 s390_exc
|= convert_bit(qemu_exc
, float_flag_divbyzero
, 0x40);
67 s390_exc
|= convert_bit(qemu_exc
, float_flag_overflow
, 0x20);
68 s390_exc
|= convert_bit(qemu_exc
, float_flag_underflow
, 0x10);
69 s390_exc
|= convert_bit(qemu_exc
, float_flag_inexact
, 0x08);
71 /* Install the exceptions that we raised. */
72 env
->fpc
|= s390_exc
<< 16;
74 /* Send signals for enabled exceptions. */
75 s390_exc
&= env
->fpc
>> 24;
77 ieee_exception(env
, s390_exc
, retaddr
);
81 static inline int float_comp_to_cc(CPUS390XState
*env
, int float_compare
)
83 switch (float_compare
) {
84 case float_relation_equal
:
86 case float_relation_less
:
88 case float_relation_greater
:
90 case float_relation_unordered
:
93 cpu_abort(env
, "unknown return value for float compare\n");
97 /* condition codes for unary FP ops */
98 uint32_t set_cc_nz_f32(float32 v
)
100 if (float32_is_any_nan(v
)) {
102 } else if (float32_is_zero(v
)) {
104 } else if (float32_is_neg(v
)) {
111 uint32_t set_cc_nz_f64(float64 v
)
113 if (float64_is_any_nan(v
)) {
115 } else if (float64_is_zero(v
)) {
117 } else if (float64_is_neg(v
)) {
124 uint32_t set_cc_nz_f128(float128 v
)
126 if (float128_is_any_nan(v
)) {
128 } else if (float128_is_zero(v
)) {
130 } else if (float128_is_neg(v
)) {
137 /* convert 32-bit int to 64-bit float */
138 void HELPER(cdfbr
)(CPUS390XState
*env
, uint32_t f1
, int32_t v2
)
140 HELPER_LOG("%s: converting %d to f%d\n", __func__
, v2
, f1
);
141 env
->fregs
[f1
].d
= int32_to_float64(v2
, &env
->fpu_status
);
144 /* convert 32-bit int to 128-bit float */
145 void HELPER(cxfbr
)(CPUS390XState
*env
, uint32_t f1
, int32_t v2
)
149 v1
.q
= int32_to_float128(v2
, &env
->fpu_status
);
150 env
->fregs
[f1
].ll
= v1
.ll
.upper
;
151 env
->fregs
[f1
+ 2].ll
= v1
.ll
.lower
;
154 /* convert 64-bit int to 32-bit float */
155 void HELPER(cegbr
)(CPUS390XState
*env
, uint32_t f1
, int64_t v2
)
157 HELPER_LOG("%s: converting %ld to f%d\n", __func__
, v2
, f1
);
158 env
->fregs
[f1
].l
.upper
= int64_to_float32(v2
, &env
->fpu_status
);
161 /* convert 64-bit int to 64-bit float */
162 void HELPER(cdgbr
)(CPUS390XState
*env
, uint32_t f1
, int64_t v2
)
164 HELPER_LOG("%s: converting %ld to f%d\n", __func__
, v2
, f1
);
165 env
->fregs
[f1
].d
= int64_to_float64(v2
, &env
->fpu_status
);
168 /* convert 64-bit int to 128-bit float */
169 void HELPER(cxgbr
)(CPUS390XState
*env
, uint32_t f1
, int64_t v2
)
173 x1
.q
= int64_to_float128(v2
, &env
->fpu_status
);
174 HELPER_LOG("%s: converted %ld to 0x%lx and 0x%lx\n", __func__
, v2
,
175 x1
.ll
.upper
, x1
.ll
.lower
);
176 env
->fregs
[f1
].ll
= x1
.ll
.upper
;
177 env
->fregs
[f1
+ 2].ll
= x1
.ll
.lower
;
180 /* convert 32-bit int to 32-bit float */
181 void HELPER(cefbr
)(CPUS390XState
*env
, uint32_t f1
, int32_t v2
)
183 env
->fregs
[f1
].l
.upper
= int32_to_float32(v2
, &env
->fpu_status
);
184 HELPER_LOG("%s: converting %d to 0x%d in f%d\n", __func__
, v2
,
185 env
->fregs
[f1
].l
.upper
, f1
);
188 /* 32-bit FP addition */
189 uint64_t HELPER(aeb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
191 float32 ret
= float32_add(f1
, f2
, &env
->fpu_status
);
192 handle_exceptions(env
, GETPC());
196 /* 64-bit FP addition */
197 uint64_t HELPER(adb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
199 float64 ret
= float64_add(f1
, f2
, &env
->fpu_status
);
200 handle_exceptions(env
, GETPC());
204 /* 128-bit FP addition */
205 uint64_t HELPER(axb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
,
206 uint64_t bh
, uint64_t bl
)
208 float128 ret
= float128_add(make_float128(ah
, al
),
209 make_float128(bh
, bl
),
211 handle_exceptions(env
, GETPC());
215 /* 32-bit FP subtraction */
216 uint64_t HELPER(seb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
218 float32 ret
= float32_sub(f1
, f2
, &env
->fpu_status
);
219 handle_exceptions(env
, GETPC());
223 /* 64-bit FP subtraction */
224 uint64_t HELPER(sdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
226 float64 ret
= float64_sub(f1
, f2
, &env
->fpu_status
);
227 handle_exceptions(env
, GETPC());
231 /* 128-bit FP subtraction */
232 uint64_t HELPER(sxb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
,
233 uint64_t bh
, uint64_t bl
)
235 float128 ret
= float128_sub(make_float128(ah
, al
),
236 make_float128(bh
, bl
),
238 handle_exceptions(env
, GETPC());
242 /* 32-bit FP division */
243 uint64_t HELPER(deb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
245 float32 ret
= float32_div(f1
, f2
, &env
->fpu_status
);
246 handle_exceptions(env
, GETPC());
250 /* 64-bit FP division */
251 uint64_t HELPER(ddb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
253 float64 ret
= float64_div(f1
, f2
, &env
->fpu_status
);
254 handle_exceptions(env
, GETPC());
258 /* 128-bit FP division */
259 uint64_t HELPER(dxb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
,
260 uint64_t bh
, uint64_t bl
)
262 float128 ret
= float128_div(make_float128(ah
, al
),
263 make_float128(bh
, bl
),
265 handle_exceptions(env
, GETPC());
269 /* 32-bit FP multiplication */
270 uint64_t HELPER(meeb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
272 float32 ret
= float32_mul(f1
, f2
, &env
->fpu_status
);
273 handle_exceptions(env
, GETPC());
277 /* 64-bit FP multiplication */
278 uint64_t HELPER(mdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
280 float64 ret
= float64_mul(f1
, f2
, &env
->fpu_status
);
281 handle_exceptions(env
, GETPC());
285 /* 64/32-bit FP multiplication */
286 uint64_t HELPER(mdeb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
288 float64 ret
= float32_to_float64(f2
, &env
->fpu_status
);
289 ret
= float64_mul(f1
, ret
, &env
->fpu_status
);
290 handle_exceptions(env
, GETPC());
294 /* 128-bit FP multiplication */
295 uint64_t HELPER(mxb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
,
296 uint64_t bh
, uint64_t bl
)
298 float128 ret
= float128_mul(make_float128(ah
, al
),
299 make_float128(bh
, bl
),
301 handle_exceptions(env
, GETPC());
305 /* 128/64-bit FP multiplication */
306 uint64_t HELPER(mxdb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
,
309 float128 ret
= float64_to_float128(f2
, &env
->fpu_status
);
310 ret
= float128_mul(make_float128(ah
, al
), ret
, &env
->fpu_status
);
311 handle_exceptions(env
, GETPC());
315 /* convert 32-bit float to 64-bit float */
316 uint64_t HELPER(ldeb
)(CPUS390XState
*env
, uint64_t f2
)
318 float64 ret
= float32_to_float64(f2
, &env
->fpu_status
);
319 handle_exceptions(env
, GETPC());
323 /* convert 128-bit float to 64-bit float */
324 uint64_t HELPER(ldxb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
)
326 float64 ret
= float128_to_float64(make_float128(ah
, al
), &env
->fpu_status
);
327 handle_exceptions(env
, GETPC());
331 /* convert 64-bit float to 128-bit float */
332 uint64_t HELPER(lxdb
)(CPUS390XState
*env
, uint64_t f2
)
334 float128 ret
= float64_to_float128(f2
, &env
->fpu_status
);
335 handle_exceptions(env
, GETPC());
339 /* convert 32-bit float to 128-bit float */
340 uint64_t HELPER(lxeb
)(CPUS390XState
*env
, uint64_t f2
)
342 float128 ret
= float32_to_float128(f2
, &env
->fpu_status
);
343 handle_exceptions(env
, GETPC());
347 /* convert 64-bit float to 32-bit float */
348 uint64_t HELPER(ledb
)(CPUS390XState
*env
, uint64_t f2
)
350 float32 ret
= float64_to_float32(f2
, &env
->fpu_status
);
351 handle_exceptions(env
, GETPC());
355 /* convert 128-bit float to 32-bit float */
356 uint64_t HELPER(lexb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
)
358 float32 ret
= float128_to_float32(make_float128(ah
, al
), &env
->fpu_status
);
359 handle_exceptions(env
, GETPC());
363 /* absolute value of 32-bit float */
364 uint32_t HELPER(lpebr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
367 float32 v2
= env
->fregs
[f2
].d
;
369 v1
= float32_abs(v2
);
370 env
->fregs
[f1
].d
= v1
;
371 return set_cc_nz_f32(v1
);
374 /* absolute value of 64-bit float */
375 uint32_t HELPER(lpdbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
378 float64 v2
= env
->fregs
[f2
].d
;
380 v1
= float64_abs(v2
);
381 env
->fregs
[f1
].d
= v1
;
382 return set_cc_nz_f64(v1
);
385 /* absolute value of 128-bit float */
386 uint32_t HELPER(lpxbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
391 v2
.ll
.upper
= env
->fregs
[f2
].ll
;
392 v2
.ll
.lower
= env
->fregs
[f2
+ 2].ll
;
393 v1
.q
= float128_abs(v2
.q
);
394 env
->fregs
[f1
].ll
= v1
.ll
.upper
;
395 env
->fregs
[f1
+ 2].ll
= v1
.ll
.lower
;
396 return set_cc_nz_f128(v1
.q
);
399 /* load complement of 32-bit float */
400 uint32_t HELPER(lcebr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
402 env
->fregs
[f1
].l
.upper
= float32_chs(env
->fregs
[f2
].l
.upper
);
404 return set_cc_nz_f32(env
->fregs
[f1
].l
.upper
);
407 /* load complement of 64-bit float */
408 uint32_t HELPER(lcdbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
410 env
->fregs
[f1
].d
= float64_chs(env
->fregs
[f2
].d
);
412 return set_cc_nz_f64(env
->fregs
[f1
].d
);
415 /* load complement of 128-bit float */
416 uint32_t HELPER(lcxbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
420 x2
.ll
.upper
= env
->fregs
[f2
].ll
;
421 x2
.ll
.lower
= env
->fregs
[f2
+ 2].ll
;
422 x1
.q
= float128_chs(x2
.q
);
423 env
->fregs
[f1
].ll
= x1
.ll
.upper
;
424 env
->fregs
[f1
+ 2].ll
= x1
.ll
.lower
;
425 return set_cc_nz_f128(x1
.q
);
428 /* 32-bit FP compare */
429 uint32_t HELPER(ceb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
431 int cmp
= float32_compare_quiet(f1
, f2
, &env
->fpu_status
);
432 handle_exceptions(env
, GETPC());
433 return float_comp_to_cc(env
, cmp
);
436 /* 64-bit FP compare */
437 uint32_t HELPER(cdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
439 int cmp
= float64_compare_quiet(f1
, f2
, &env
->fpu_status
);
440 handle_exceptions(env
, GETPC());
441 return float_comp_to_cc(env
, cmp
);
444 /* 128-bit FP compare */
445 uint32_t HELPER(cxb
)(CPUS390XState
*env
, uint64_t ah
, uint64_t al
,
446 uint64_t bh
, uint64_t bl
)
448 int cmp
= float128_compare_quiet(make_float128(ah
, al
),
449 make_float128(bh
, bl
),
451 handle_exceptions(env
, GETPC());
452 return float_comp_to_cc(env
, cmp
);
455 static void set_round_mode(CPUS390XState
*env
, int m3
)
462 /* biased round no nearest */
464 /* round to nearest */
465 set_float_rounding_mode(float_round_nearest_even
, &env
->fpu_status
);
469 set_float_rounding_mode(float_round_to_zero
, &env
->fpu_status
);
473 set_float_rounding_mode(float_round_up
, &env
->fpu_status
);
477 set_float_rounding_mode(float_round_down
, &env
->fpu_status
);
482 /* convert 32-bit float to 64-bit int */
483 uint32_t HELPER(cgebr
)(CPUS390XState
*env
, uint32_t r1
, uint32_t f2
,
486 float32 v2
= env
->fregs
[f2
].l
.upper
;
488 set_round_mode(env
, m3
);
489 env
->regs
[r1
] = float32_to_int64(v2
, &env
->fpu_status
);
490 return set_cc_nz_f32(v2
);
493 /* convert 64-bit float to 64-bit int */
494 uint32_t HELPER(cgdbr
)(CPUS390XState
*env
, uint32_t r1
, uint32_t f2
,
497 float64 v2
= env
->fregs
[f2
].d
;
499 set_round_mode(env
, m3
);
500 env
->regs
[r1
] = float64_to_int64(v2
, &env
->fpu_status
);
501 return set_cc_nz_f64(v2
);
504 /* convert 128-bit float to 64-bit int */
505 uint32_t HELPER(cgxbr
)(CPUS390XState
*env
, uint32_t r1
, uint32_t f2
,
510 v2
.ll
.upper
= env
->fregs
[f2
].ll
;
511 v2
.ll
.lower
= env
->fregs
[f2
+ 2].ll
;
512 set_round_mode(env
, m3
);
513 env
->regs
[r1
] = float128_to_int64(v2
.q
, &env
->fpu_status
);
514 if (float128_is_any_nan(v2
.q
)) {
516 } else if (float128_is_zero(v2
.q
)) {
518 } else if (float128_is_neg(v2
.q
)) {
525 /* convert 32-bit float to 32-bit int */
526 uint32_t HELPER(cfebr
)(CPUS390XState
*env
, uint32_t r1
, uint32_t f2
,
529 float32 v2
= env
->fregs
[f2
].l
.upper
;
531 set_round_mode(env
, m3
);
532 env
->regs
[r1
] = (env
->regs
[r1
] & 0xffffffff00000000ULL
) |
533 float32_to_int32(v2
, &env
->fpu_status
);
534 return set_cc_nz_f32(v2
);
537 /* convert 64-bit float to 32-bit int */
538 uint32_t HELPER(cfdbr
)(CPUS390XState
*env
, uint32_t r1
, uint32_t f2
,
541 float64 v2
= env
->fregs
[f2
].d
;
543 set_round_mode(env
, m3
);
544 env
->regs
[r1
] = (env
->regs
[r1
] & 0xffffffff00000000ULL
) |
545 float64_to_int32(v2
, &env
->fpu_status
);
546 return set_cc_nz_f64(v2
);
549 /* convert 128-bit float to 32-bit int */
550 uint32_t HELPER(cfxbr
)(CPUS390XState
*env
, uint32_t r1
, uint32_t f2
,
555 v2
.ll
.upper
= env
->fregs
[f2
].ll
;
556 v2
.ll
.lower
= env
->fregs
[f2
+ 2].ll
;
557 env
->regs
[r1
] = (env
->regs
[r1
] & 0xffffffff00000000ULL
) |
558 float128_to_int32(v2
.q
, &env
->fpu_status
);
559 return set_cc_nz_f128(v2
.q
);
562 /* load 32-bit FP zero */
563 void HELPER(lzer
)(CPUS390XState
*env
, uint32_t f1
)
565 env
->fregs
[f1
].l
.upper
= float32_zero
;
568 /* load 64-bit FP zero */
569 void HELPER(lzdr
)(CPUS390XState
*env
, uint32_t f1
)
571 env
->fregs
[f1
].d
= float64_zero
;
574 /* load 128-bit FP zero */
575 void HELPER(lzxr
)(CPUS390XState
*env
, uint32_t f1
)
579 x
.q
= float64_to_float128(float64_zero
, &env
->fpu_status
);
580 env
->fregs
[f1
].ll
= x
.ll
.upper
;
581 env
->fregs
[f1
+ 1].ll
= x
.ll
.lower
;
584 /* 64-bit FP multiply and add RM */
585 void HELPER(madb
)(CPUS390XState
*env
, uint32_t f1
, uint64_t a2
, uint32_t f3
)
589 HELPER_LOG("%s: f1 %d a2 0x%lx f3 %d\n", __func__
, f1
, a2
, f3
);
590 v2
.ll
= cpu_ldq_data(env
, a2
);
591 env
->fregs
[f1
].d
= float64_add(env
->fregs
[f1
].d
,
592 float64_mul(v2
.d
, env
->fregs
[f3
].d
,
597 /* 64-bit FP multiply and add RR */
598 void HELPER(madbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f3
, uint32_t f2
)
600 HELPER_LOG("%s: f1 %d f2 %d f3 %d\n", __func__
, f1
, f2
, f3
);
601 env
->fregs
[f1
].d
= float64_add(float64_mul(env
->fregs
[f2
].d
,
604 env
->fregs
[f1
].d
, &env
->fpu_status
);
607 /* 64-bit FP multiply and subtract RR */
608 void HELPER(msdbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f3
, uint32_t f2
)
610 HELPER_LOG("%s: f1 %d f2 %d f3 %d\n", __func__
, f1
, f2
, f3
);
611 env
->fregs
[f1
].d
= float64_sub(float64_mul(env
->fregs
[f2
].d
,
614 env
->fregs
[f1
].d
, &env
->fpu_status
);
617 /* 32-bit FP multiply and add RR */
618 void HELPER(maebr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f3
, uint32_t f2
)
620 env
->fregs
[f1
].l
.upper
= float32_add(env
->fregs
[f1
].l
.upper
,
621 float32_mul(env
->fregs
[f2
].l
.upper
,
622 env
->fregs
[f3
].l
.upper
,
627 /* test data class 32-bit */
628 uint32_t HELPER(tceb
)(CPUS390XState
*env
, uint32_t f1
, uint64_t m2
)
630 float32 v1
= env
->fregs
[f1
].l
.upper
;
631 int neg
= float32_is_neg(v1
);
634 HELPER_LOG("%s: v1 0x%lx m2 0x%lx neg %d\n", __func__
, (long)v1
, m2
, neg
);
635 if ((float32_is_zero(v1
) && (m2
& (1 << (11-neg
)))) ||
636 (float32_is_infinity(v1
) && (m2
& (1 << (5-neg
)))) ||
637 (float32_is_any_nan(v1
) && (m2
& (1 << (3-neg
)))) ||
638 (float32_is_signaling_nan(v1
) && (m2
& (1 << (1-neg
))))) {
640 } else if (m2
& (1 << (9-neg
))) {
641 /* assume normalized number */
645 /* FIXME: denormalized? */
649 /* test data class 64-bit */
650 uint32_t HELPER(tcdb
)(CPUS390XState
*env
, uint32_t f1
, uint64_t m2
)
652 float64 v1
= env
->fregs
[f1
].d
;
653 int neg
= float64_is_neg(v1
);
656 HELPER_LOG("%s: v1 0x%lx m2 0x%lx neg %d\n", __func__
, v1
, m2
, neg
);
657 if ((float64_is_zero(v1
) && (m2
& (1 << (11-neg
)))) ||
658 (float64_is_infinity(v1
) && (m2
& (1 << (5-neg
)))) ||
659 (float64_is_any_nan(v1
) && (m2
& (1 << (3-neg
)))) ||
660 (float64_is_signaling_nan(v1
) && (m2
& (1 << (1-neg
))))) {
662 } else if (m2
& (1 << (9-neg
))) {
663 /* assume normalized number */
666 /* FIXME: denormalized? */
670 /* test data class 128-bit */
671 uint32_t HELPER(tcxb
)(CPUS390XState
*env
, uint32_t f1
, uint64_t m2
)
677 v1
.ll
.upper
= env
->fregs
[f1
].ll
;
678 v1
.ll
.lower
= env
->fregs
[f1
+ 2].ll
;
680 neg
= float128_is_neg(v1
.q
);
681 if ((float128_is_zero(v1
.q
) && (m2
& (1 << (11-neg
)))) ||
682 (float128_is_infinity(v1
.q
) && (m2
& (1 << (5-neg
)))) ||
683 (float128_is_any_nan(v1
.q
) && (m2
& (1 << (3-neg
)))) ||
684 (float128_is_signaling_nan(v1
.q
) && (m2
& (1 << (1-neg
))))) {
686 } else if (m2
& (1 << (9-neg
))) {
687 /* assume normalized number */
690 /* FIXME: denormalized? */
694 /* square root 64-bit RR */
695 void HELPER(sqdbr
)(CPUS390XState
*env
, uint32_t f1
, uint32_t f2
)
697 env
->fregs
[f1
].d
= float64_sqrt(env
->fregs
[f2
].d
, &env
->fpu_status
);