]> Git Repo - qemu.git/blame - target-ppc/dfp_helper.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
target-ppc: Introduce DFP Round to Integer
[qemu.git] / target-ppc / dfp_helper.c
CommitLineData
7b0c0d66
TM		 1/*
2 * PowerPC Decimal Floating Point (DPF) emulation helpers for QEMU.
3 *
4 * Copyright (c) 2014 IBM Corporation.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include "cpu.h"
21#include "exec/helper-proto.h"
22
23#define DECNUMDIGITS 34
24#include "libdecnumber/decContext.h"
25#include "libdecnumber/decNumber.h"
26#include "libdecnumber/dpd/decimal32.h"
27#include "libdecnumber/dpd/decimal64.h"
28#include "libdecnumber/dpd/decimal128.h"
29
30#if defined(HOST_WORDS_BIGENDIAN)
31#define HI_IDX 0
32#define LO_IDX 1
33#else
34#define HI_IDX 1
35#define LO_IDX 0
36#endif
37
38struct PPC_DFP {
39 CPUPPCState *env;
40 uint64_t t64[2], a64[2], b64[2];
41 decNumber t, a, b;
42 decContext context;
43 uint8_t crbf;
44};
45
46static void dfp_prepare_rounding_mode(decContext *context, uint64_t fpscr)
47{
48 enum rounding rnd;
49
50 switch ((fpscr >> 32) & 0x7) {
51 case 0:
52 rnd = DEC_ROUND_HALF_EVEN;
53 break;
54 case 1:
55 rnd = DEC_ROUND_DOWN;
56 break;
57 case 2:
58 rnd = DEC_ROUND_CEILING;
59 break;
60 case 3:
61 rnd = DEC_ROUND_FLOOR;
62 break;
63 case 4:
64 rnd = DEC_ROUND_HALF_UP;
65 break;
66 case 5:
67 rnd = DEC_ROUND_HALF_DOWN;
68 break;
69 case 6:
70 rnd = DEC_ROUND_UP;
71 break;
72 case 7:
73 rnd = DEC_ROUND_05UP;
74 break;
75 default:
76 g_assert_not_reached();
77 }
78
79 decContextSetRounding(context, rnd);
80}
81
5826ebe2
TM		 82static void dfp_set_round_mode_from_immediate(uint8_t r, uint8_t rmc,
83 struct PPC_DFP *dfp)
84{
85 enum rounding rnd;
86 if (r == 0) {
87 switch (rmc & 3) {
88 case 0:
89 rnd = DEC_ROUND_HALF_EVEN;
90 break;
91 case 1:
92 rnd = DEC_ROUND_DOWN;
93 break;
94 case 2:
95 rnd = DEC_ROUND_HALF_UP;
96 break;
97 case 3: /* use FPSCR rounding mode */
98 return;
99 default:
100 assert(0); /* cannot get here */
101 }
102 } else { /* r == 1 */
103 switch (rmc & 3) {
104 case 0:
105 rnd = DEC_ROUND_CEILING;
106 break;
107 case 1:
108 rnd = DEC_ROUND_FLOOR;
109 break;
110 case 2:
111 rnd = DEC_ROUND_UP;
112 break;
113 case 3:
114 rnd = DEC_ROUND_HALF_DOWN;
115 break;
116 default:
117 assert(0); /* cannot get here */
118 }
119 }
120 decContextSetRounding(&dfp->context, rnd);
121}
122
7b0c0d66
TM		 123static void dfp_prepare_decimal64(struct PPC_DFP *dfp, uint64_t *a,
124 uint64_t *b, CPUPPCState *env)
125{
126 decContextDefault(&dfp->context, DEC_INIT_DECIMAL64);
127 dfp_prepare_rounding_mode(&dfp->context, env->fpscr);
128 dfp->env = env;
129
130 if (a) {
131 dfp->a64[0] = *a;
132 decimal64ToNumber((decimal64 *)dfp->a64, &dfp->a);
133 } else {
134 dfp->a64[0] = 0;
135 decNumberZero(&dfp->a);
136 }
137
138 if (b) {
139 dfp->b64[0] = *b;
140 decimal64ToNumber((decimal64 *)dfp->b64, &dfp->b);
141 } else {
142 dfp->b64[0] = 0;
143 decNumberZero(&dfp->b);
144 }
145}
146
7b0c0d66
TM		 147static void dfp_prepare_decimal128(struct PPC_DFP *dfp, uint64_t *a,
148 uint64_t *b, CPUPPCState *env)
149{
150 decContextDefault(&dfp->context, DEC_INIT_DECIMAL128);
151 dfp_prepare_rounding_mode(&dfp->context, env->fpscr);
152 dfp->env = env;
153
154 if (a) {
155 dfp->a64[0] = a[HI_IDX];
156 dfp->a64[1] = a[LO_IDX];
157 decimal128ToNumber((decimal128 *)dfp->a64, &dfp->a);
158 } else {
159 dfp->a64[0] = dfp->a64[1] = 0;
160 decNumberZero(&dfp->a);
161 }
162
163 if (b) {
164 dfp->b64[0] = b[HI_IDX];
165 dfp->b64[1] = b[LO_IDX];
166 decimal128ToNumber((decimal128 *)dfp->b64, &dfp->b);
167 } else {
168 dfp->b64[0] = dfp->b64[1] = 0;
169 decNumberZero(&dfp->b);
170 }
171}
27722744
TM		 172
173#define FP_FX (1ull << FPSCR_FX)
174#define FP_FEX (1ull << FPSCR_FEX)
175#define FP_OX (1ull << FPSCR_OX)
176#define FP_OE (1ull << FPSCR_OE)
177#define FP_UX (1ull << FPSCR_UX)
178#define FP_UE (1ull << FPSCR_UE)
179#define FP_XX (1ull << FPSCR_XX)
180#define FP_XE (1ull << FPSCR_XE)
181#define FP_ZX (1ull << FPSCR_ZX)
182#define FP_ZE (1ull << FPSCR_ZE)
183#define FP_VX (1ull << FPSCR_VX)
184#define FP_VXSNAN (1ull << FPSCR_VXSNAN)
185#define FP_VXISI (1ull << FPSCR_VXISI)
186#define FP_VXIMZ (1ull << FPSCR_VXIMZ)
187#define FP_VXZDZ (1ull << FPSCR_VXZDZ)
188#define FP_VXIDI (1ull << FPSCR_VXIDI)
189#define FP_VXVC (1ull << FPSCR_VXVC)
190#define FP_VXCVI (1ull << FPSCR_VXCVI)
191#define FP_VE (1ull << FPSCR_VE)
192#define FP_FI (1ull << FPSCR_FI)
193
27722744
TM		 194static void dfp_set_FPSCR_flag(struct PPC_DFP *dfp, uint64_t flag,
195 uint64_t enabled)
196{
197 dfp->env->fpscr |= (flag | FP_FX);
198 if (dfp->env->fpscr & enabled) {
199 dfp->env->fpscr |= FP_FEX;
200 }
201}
a9d7ba03
TM		 202
203static void dfp_set_FPRF_from_FRT_with_context(struct PPC_DFP *dfp,
204 decContext *context)
205{
206 uint64_t fprf = 0;
207
208 /* construct FPRF */
209 switch (decNumberClass(&dfp->t, context)) {
210 case DEC_CLASS_SNAN:
211 fprf = 0x01;
212 break;
213 case DEC_CLASS_QNAN:
214 fprf = 0x11;
215 break;
216 case DEC_CLASS_NEG_INF:
217 fprf = 0x09;
218 break;
219 case DEC_CLASS_NEG_NORMAL:
220 fprf = 0x08;
221 break;
222 case DEC_CLASS_NEG_SUBNORMAL:
223 fprf = 0x18;
224 break;
225 case DEC_CLASS_NEG_ZERO:
226 fprf = 0x12;
227 break;
228 case DEC_CLASS_POS_ZERO:
229 fprf = 0x02;
230 break;
231 case DEC_CLASS_POS_SUBNORMAL:
232 fprf = 0x14;
233 break;
234 case DEC_CLASS_POS_NORMAL:
235 fprf = 0x04;
236 break;
237 case DEC_CLASS_POS_INF:
238 fprf = 0x05;
239 break;
240 default:
241 assert(0); /* should never get here */
242 }
243 dfp->env->fpscr &= ~(0x1F << 12);
244 dfp->env->fpscr |= (fprf << 12);
245}
246
247static void dfp_set_FPRF_from_FRT(struct PPC_DFP *dfp)
248{
249 dfp_set_FPRF_from_FRT_with_context(dfp, &dfp->context);
250}
251
252static void dfp_check_for_OX(struct PPC_DFP *dfp)
253{
254 if (dfp->context.status & DEC_Overflow) {
255 dfp_set_FPSCR_flag(dfp, FP_OX, FP_OE);
256 }
257}
258
259static void dfp_check_for_UX(struct PPC_DFP *dfp)
260{
261 if (dfp->context.status & DEC_Underflow) {
262 dfp_set_FPSCR_flag(dfp, FP_UX, FP_UE);
263 }
264}
265
266static void dfp_check_for_XX(struct PPC_DFP *dfp)
267{
268 if (dfp->context.status & DEC_Inexact) {
269 dfp_set_FPSCR_flag(dfp, FP_XX | FP_FI, FP_XE);
270 }
271}
272
9024ff40
TM		 273static void dfp_check_for_ZX(struct PPC_DFP *dfp)
274{
275 if (dfp->context.status & DEC_Division_by_zero) {
276 dfp_set_FPSCR_flag(dfp, FP_ZX, FP_ZE);
277 }
278}
279
a9d7ba03
TM		 280static void dfp_check_for_VXSNAN(struct PPC_DFP *dfp)
281{
282 if (dfp->context.status & DEC_Invalid_operation) {
283 if (decNumberIsSNaN(&dfp->a) || decNumberIsSNaN(&dfp->b)) {
284 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FP_VE);
285 }
286 }
287}
288
289static void dfp_check_for_VXISI(struct PPC_DFP *dfp, int testForSameSign)
290{
291 if (dfp->context.status & DEC_Invalid_operation) {
292 if (decNumberIsInfinite(&dfp->a) && decNumberIsInfinite(&dfp->b)) {
293 int same = decNumberClass(&dfp->a, &dfp->context) ==
294 decNumberClass(&dfp->b, &dfp->context);
295 if ((same && testForSameSign) || (!same && !testForSameSign)) {
296 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXISI, FP_VE);
297 }
298 }
299 }
300}
301
302static void dfp_check_for_VXISI_add(struct PPC_DFP *dfp)
303{
304 dfp_check_for_VXISI(dfp, 0);
305}
306
2128f8a5
TM		 307static void dfp_check_for_VXISI_subtract(struct PPC_DFP *dfp)
308{
309 dfp_check_for_VXISI(dfp, 1);
310}
311
8de6a1cc
TM		 312static void dfp_check_for_VXIMZ(struct PPC_DFP *dfp)
313{
314 if (dfp->context.status & DEC_Invalid_operation) {
315 if ((decNumberIsInfinite(&dfp->a) && decNumberIsZero(&dfp->b)) ||
316 (decNumberIsInfinite(&dfp->b) && decNumberIsZero(&dfp->a))) {
317 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXIMZ, FP_VE);
318 }
319 }
320}
321
9024ff40
TM		 322static void dfp_check_for_VXZDZ(struct PPC_DFP *dfp)
323{
324 if (dfp->context.status & DEC_Division_undefined) {
325 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXZDZ, FP_VE);
326 }
327}
328
329static void dfp_check_for_VXIDI(struct PPC_DFP *dfp)
330{
331 if (dfp->context.status & DEC_Invalid_operation) {
332 if (decNumberIsInfinite(&dfp->a) && decNumberIsInfinite(&dfp->b)) {
333 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXIDI, FP_VE);
334 }
335 }
336}
337
5833505b
TM		 338static void dfp_check_for_VXVC(struct PPC_DFP *dfp)
339{
340 if (decNumberIsNaN(&dfp->a) || decNumberIsNaN(&dfp->b)) {
341 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXVC, FP_VE);
342 }
343}
344
5826ebe2
TM		 345static void dfp_check_for_VXCVI(struct PPC_DFP *dfp)
346{
347 if ((dfp->context.status & DEC_Invalid_operation) &&
348 (!decNumberIsSNaN(&dfp->a)) &&
349 (!decNumberIsSNaN(&dfp->b))) {
350 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
351 }
352}
353
5833505b
TM		 354static void dfp_set_CRBF_from_T(struct PPC_DFP *dfp)
355{
356 if (decNumberIsNaN(&dfp->t)) {
357 dfp->crbf = 1;
358 } else if (decNumberIsZero(&dfp->t)) {
359 dfp->crbf = 2;
360 } else if (decNumberIsNegative(&dfp->t)) {
361 dfp->crbf = 8;
362 } else {
363 dfp->crbf = 4;
364 }
365}
366
367static void dfp_set_FPCC_from_CRBF(struct PPC_DFP *dfp)
368{
369 dfp->env->fpscr &= ~(0xF << 12);
370 dfp->env->fpscr |= (dfp->crbf << 12);
371}
372
5826ebe2
TM		 373static inline void dfp_makeQNaN(decNumber *dn)
374{
375 dn->bits &= ~DECSPECIAL;
376 dn->bits |= DECNAN;
377}
378
512918aa
TM		 379static inline int dfp_get_digit(decNumber *dn, int n)
380{
381 assert(DECDPUN == 3);
382 int unit = n / DECDPUN;
383 int dig = n % DECDPUN;
384 switch (dig) {
385 case 0:
386 return dn->lsu[unit] % 10;
387 case 1:
388 return (dn->lsu[unit] / 10) % 10;
389 case 2:
390 return dn->lsu[unit] / 100;
391 default:
392 assert(0);
393 }
394}
395
a9d7ba03
TM		 396#define DFP_HELPER_TAB(op, dnop, postprocs, size) \
397void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
398{ \
399 struct PPC_DFP dfp; \
400 dfp_prepare_decimal##size(&dfp, a, b, env); \
401 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
402 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
403 postprocs(&dfp); \
404 if (size == 64) { \
405 t[0] = dfp.t64[0]; \
406 } else if (size == 128) { \
407 t[0] = dfp.t64[HI_IDX]; \
408 t[1] = dfp.t64[LO_IDX]; \
409 } \
410}
411
412static void ADD_PPs(struct PPC_DFP *dfp)
413{
414 dfp_set_FPRF_from_FRT(dfp);
415 dfp_check_for_OX(dfp);
416 dfp_check_for_UX(dfp);
417 dfp_check_for_XX(dfp);
418 dfp_check_for_VXSNAN(dfp);
419 dfp_check_for_VXISI_add(dfp);
420}
421
422DFP_HELPER_TAB(dadd, decNumberAdd, ADD_PPs, 64)
423DFP_HELPER_TAB(daddq, decNumberAdd, ADD_PPs, 128)
2128f8a5
TM		 424
425static void SUB_PPs(struct PPC_DFP *dfp)
426{
427 dfp_set_FPRF_from_FRT(dfp);
428 dfp_check_for_OX(dfp);
429 dfp_check_for_UX(dfp);
430 dfp_check_for_XX(dfp);
431 dfp_check_for_VXSNAN(dfp);
432 dfp_check_for_VXISI_subtract(dfp);
433}
434
435DFP_HELPER_TAB(dsub, decNumberSubtract, SUB_PPs, 64)
436DFP_HELPER_TAB(dsubq, decNumberSubtract, SUB_PPs, 128)
8de6a1cc
TM		 437
438static void MUL_PPs(struct PPC_DFP *dfp)
439{
440 dfp_set_FPRF_from_FRT(dfp);
441 dfp_check_for_OX(dfp);
442 dfp_check_for_UX(dfp);
443 dfp_check_for_XX(dfp);
444 dfp_check_for_VXSNAN(dfp);
445 dfp_check_for_VXIMZ(dfp);
446}
447
448DFP_HELPER_TAB(dmul, decNumberMultiply, MUL_PPs, 64)
449DFP_HELPER_TAB(dmulq, decNumberMultiply, MUL_PPs, 128)
9024ff40
TM		 450
451static void DIV_PPs(struct PPC_DFP *dfp)
452{
453 dfp_set_FPRF_from_FRT(dfp);
454 dfp_check_for_OX(dfp);
455 dfp_check_for_UX(dfp);
456 dfp_check_for_ZX(dfp);
457 dfp_check_for_XX(dfp);
458 dfp_check_for_VXSNAN(dfp);
459 dfp_check_for_VXZDZ(dfp);
460 dfp_check_for_VXIDI(dfp);
461}
462
463DFP_HELPER_TAB(ddiv, decNumberDivide, DIV_PPs, 64)
464DFP_HELPER_TAB(ddivq, decNumberDivide, DIV_PPs, 128)
5833505b
TM		 465
466#define DFP_HELPER_BF_AB(op, dnop, postprocs, size) \
467uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
468{ \
469 struct PPC_DFP dfp; \
470 dfp_prepare_decimal##size(&dfp, a, b, env); \
471 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
472 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
473 postprocs(&dfp); \
474 return dfp.crbf; \
475}
476
477static void CMPU_PPs(struct PPC_DFP *dfp)
478{
479 dfp_set_CRBF_from_T(dfp);
480 dfp_set_FPCC_from_CRBF(dfp);
481 dfp_check_for_VXSNAN(dfp);
482}
483
484DFP_HELPER_BF_AB(dcmpu, decNumberCompare, CMPU_PPs, 64)
485DFP_HELPER_BF_AB(dcmpuq, decNumberCompare, CMPU_PPs, 128)
486
487static void CMPO_PPs(struct PPC_DFP *dfp)
488{
489 dfp_set_CRBF_from_T(dfp);
490 dfp_set_FPCC_from_CRBF(dfp);
491 dfp_check_for_VXSNAN(dfp);
492 dfp_check_for_VXVC(dfp);
493}
494
495DFP_HELPER_BF_AB(dcmpo, decNumberCompare, CMPO_PPs, 64)
496DFP_HELPER_BF_AB(dcmpoq, decNumberCompare, CMPO_PPs, 128)
e601c1ee
TM		 497
498#define DFP_HELPER_TSTDC(op, size) \
499uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
500{ \
501 struct PPC_DFP dfp; \
502 int match = 0; \
503 \
504 dfp_prepare_decimal##size(&dfp, a, 0, env); \
505 \
506 match |= (dcm & 0x20) && decNumberIsZero(&dfp.a); \
507 match |= (dcm & 0x10) && decNumberIsSubnormal(&dfp.a, &dfp.context); \
508 match |= (dcm & 0x08) && decNumberIsNormal(&dfp.a, &dfp.context); \
509 match |= (dcm & 0x04) && decNumberIsInfinite(&dfp.a); \
510 match |= (dcm & 0x02) && decNumberIsQNaN(&dfp.a); \
511 match |= (dcm & 0x01) && decNumberIsSNaN(&dfp.a); \
512 \
513 if (decNumberIsNegative(&dfp.a)) { \
514 dfp.crbf = match ? 0xA : 0x8; \
515 } else { \
516 dfp.crbf = match ? 0x2 : 0x0; \
517 } \
518 \
519 dfp_set_FPCC_from_CRBF(&dfp); \
520 return dfp.crbf; \
521}
522
523DFP_HELPER_TSTDC(dtstdc, 64)
524DFP_HELPER_TSTDC(dtstdcq, 128)
1bf9c0e1
TM		 525
526#define DFP_HELPER_TSTDG(op, size) \
527uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
528{ \
529 struct PPC_DFP dfp; \
530 int minexp, maxexp, nzero_digits, nzero_idx, is_negative, is_zero, \
531 is_extreme_exp, is_subnormal, is_normal, leftmost_is_nonzero, \
532 match; \
533 \
534 dfp_prepare_decimal##size(&dfp, a, 0, env); \
535 \
536 if ((size) == 64) { \
537 minexp = -398; \
538 maxexp = 369; \
539 nzero_digits = 16; \
540 nzero_idx = 5; \
541 } else if ((size) == 128) { \
542 minexp = -6176; \
543 maxexp = 6111; \
544 nzero_digits = 34; \
545 nzero_idx = 11; \
546 } \
547 \
548 is_negative = decNumberIsNegative(&dfp.a); \
549 is_zero = decNumberIsZero(&dfp.a); \
550 is_extreme_exp = (dfp.a.exponent == maxexp) || \
551 (dfp.a.exponent == minexp); \
552 is_subnormal = decNumberIsSubnormal(&dfp.a, &dfp.context); \
553 is_normal = decNumberIsNormal(&dfp.a, &dfp.context); \
554 leftmost_is_nonzero = (dfp.a.digits == nzero_digits) && \
555 (dfp.a.lsu[nzero_idx] != 0); \
556 match = 0; \
557 \
558 match |= (dcm & 0x20) && is_zero && !is_extreme_exp; \
559 match |= (dcm & 0x10) && is_zero && is_extreme_exp; \
560 match |= (dcm & 0x08) && \
561 (is_subnormal || (is_normal && is_extreme_exp)); \
562 match |= (dcm & 0x04) && is_normal && !is_extreme_exp && \
563 !leftmost_is_nonzero; \
564 match |= (dcm & 0x02) && is_normal && !is_extreme_exp && \
565 leftmost_is_nonzero; \
566 match |= (dcm & 0x01) && decNumberIsSpecial(&dfp.a); \
567 \
568 if (is_negative) { \
569 dfp.crbf = match ? 0xA : 0x8; \
570 } else { \
571 dfp.crbf = match ? 0x2 : 0x0; \
572 } \
573 \
574 dfp_set_FPCC_from_CRBF(&dfp); \
575 return dfp.crbf; \
576}
577
578DFP_HELPER_TSTDG(dtstdg, 64)
579DFP_HELPER_TSTDG(dtstdgq, 128)
f3d2b0bc
TM		 580
581#define DFP_HELPER_TSTEX(op, size) \
582uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
583{ \
584 struct PPC_DFP dfp; \
585 int expa, expb, a_is_special, b_is_special; \
586 \
587 dfp_prepare_decimal##size(&dfp, a, b, env); \
588 \
589 expa = dfp.a.exponent; \
590 expb = dfp.b.exponent; \
591 a_is_special = decNumberIsSpecial(&dfp.a); \
592 b_is_special = decNumberIsSpecial(&dfp.b); \
593 \
594 if (a_is_special || b_is_special) { \
595 int atype = a_is_special ? (decNumberIsNaN(&dfp.a) ? 4 : 2) : 1; \
596 int btype = b_is_special ? (decNumberIsNaN(&dfp.b) ? 4 : 2) : 1; \
597 dfp.crbf = (atype ^ btype) ? 0x1 : 0x2; \
598 } else if (expa < expb) { \
599 dfp.crbf = 0x8; \
600 } else if (expa > expb) { \
601 dfp.crbf = 0x4; \
602 } else { \
603 dfp.crbf = 0x2; \
604 } \
605 \
606 dfp_set_FPCC_from_CRBF(&dfp); \
607 return dfp.crbf; \
608}
609
610DFP_HELPER_TSTEX(dtstex, 64)
611DFP_HELPER_TSTEX(dtstexq, 128)
f6022a76
TM		 612
613#define DFP_HELPER_TSTSF(op, size) \
614uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
615{ \
616 struct PPC_DFP dfp; \
617 unsigned k; \
618 \
619 dfp_prepare_decimal##size(&dfp, 0, b, env); \
620 \
621 k = *a & 0x3F; \
622 \
623 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
624 dfp.crbf = 1; \
625 } else if (k == 0) { \
626 dfp.crbf = 4; \
627 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
628 /* Zero has no sig digits */ \
629 dfp.crbf = 4; \
630 } else { \
631 unsigned nsd = dfp.b.digits; \
632 if (k < nsd) { \
633 dfp.crbf = 8; \
634 } else if (k > nsd) { \
635 dfp.crbf = 4; \
636 } else { \
637 dfp.crbf = 2; \
638 } \
639 } \
640 \
641 dfp_set_FPCC_from_CRBF(&dfp); \
642 return dfp.crbf; \
643}
644
645DFP_HELPER_TSTSF(dtstsf, 64)
646DFP_HELPER_TSTSF(dtstsfq, 128)
5826ebe2
TM		 647
648static void QUA_PPs(struct PPC_DFP *dfp)
649{
650 dfp_set_FPRF_from_FRT(dfp);
651 dfp_check_for_XX(dfp);
652 dfp_check_for_VXSNAN(dfp);
653 dfp_check_for_VXCVI(dfp);
654}
655
656static void dfp_quantize(uint8_t rmc, struct PPC_DFP *dfp)
657{
658 dfp_set_round_mode_from_immediate(0, rmc, dfp);
659 decNumberQuantize(&dfp->t, &dfp->b, &dfp->a, &dfp->context);
660 if (decNumberIsSNaN(&dfp->a)) {
661 dfp->t = dfp->a;
662 dfp_makeQNaN(&dfp->t);
663 } else if (decNumberIsSNaN(&dfp->b)) {
664 dfp->t = dfp->b;
665 dfp_makeQNaN(&dfp->t);
666 } else if (decNumberIsQNaN(&dfp->a)) {
667 dfp->t = dfp->a;
668 } else if (decNumberIsQNaN(&dfp->b)) {
669 dfp->t = dfp->b;
670 }
671}
672
673#define DFP_HELPER_QUAI(op, size) \
674void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
675 uint32_t te, uint32_t rmc) \
676{ \
677 struct PPC_DFP dfp; \
678 \
679 dfp_prepare_decimal##size(&dfp, 0, b, env); \
680 \
681 decNumberFromUInt32(&dfp.a, 1); \
682 dfp.a.exponent = (int32_t)((int8_t)(te << 3) >> 3); \
683 \
684 dfp_quantize(rmc, &dfp); \
685 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
686 &dfp.context); \
687 QUA_PPs(&dfp); \
688 \
689 if (size == 64) { \
690 t[0] = dfp.t64[0]; \
691 } else if (size == 128) { \
692 t[0] = dfp.t64[HI_IDX]; \
693 t[1] = dfp.t64[LO_IDX]; \
694 } \
695}
696
697DFP_HELPER_QUAI(dquai, 64)
698DFP_HELPER_QUAI(dquaiq, 128)
699
700#define DFP_HELPER_QUA(op, size) \
701void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
702 uint64_t *b, uint32_t rmc) \
703{ \
704 struct PPC_DFP dfp; \
705 \
706 dfp_prepare_decimal##size(&dfp, a, b, env); \
707 \
708 dfp_quantize(rmc, &dfp); \
709 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
710 &dfp.context); \
711 QUA_PPs(&dfp); \
712 \
713 if (size == 64) { \
714 t[0] = dfp.t64[0]; \
715 } else if (size == 128) { \
716 t[0] = dfp.t64[HI_IDX]; \
717 t[1] = dfp.t64[LO_IDX]; \
718 } \
719}
720
721DFP_HELPER_QUA(dqua, 64)
722DFP_HELPER_QUA(dquaq, 128)
512918aa
TM		 723
724static void _dfp_reround(uint8_t rmc, int32_t ref_sig, int32_t xmax,
725 struct PPC_DFP *dfp)
726{
727 int msd_orig, msd_rslt;
728
729 if (unlikely((ref_sig == 0) || (dfp->b.digits <= ref_sig))) {
730 dfp->t = dfp->b;
731 if (decNumberIsSNaN(&dfp->b)) {
732 dfp_makeQNaN(&dfp->t);
733 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FPSCR_VE);
734 }
735 return;
736 }
737
738 /* Reround is equivalent to quantizing b with 1**E(n) where */
739 /* n = exp(b) + numDigits(b) - reference_significance. */
740
741 decNumberFromUInt32(&dfp->a, 1);
742 dfp->a.exponent = dfp->b.exponent + dfp->b.digits - ref_sig;
743
744 if (unlikely(dfp->a.exponent > xmax)) {
745 dfp->t.digits = 0;
746 dfp->t.bits &= ~DECNEG;
747 dfp_makeQNaN(&dfp->t);
748 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FPSCR_VE);
749 return;
750 }
751
752 dfp_quantize(rmc, dfp);
753
754 msd_orig = dfp_get_digit(&dfp->b, dfp->b.digits-1);
755 msd_rslt = dfp_get_digit(&dfp->t, dfp->t.digits-1);
756
757 /* If the quantization resulted in rounding up to the next magnitude, */
758 /* then we need to shift the significand and adjust the exponent. */
759
760 if (unlikely((msd_orig == 9) && (msd_rslt == 1))) {
761
762 decNumber negone;
763
764 decNumberFromInt32(&negone, -1);
765 decNumberShift(&dfp->t, &dfp->t, &negone, &dfp->context);
766 dfp->t.exponent++;
767
768 if (unlikely(dfp->t.exponent > xmax)) {
769 dfp_makeQNaN(&dfp->t);
770 dfp->t.digits = 0;
771 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
772 /* Inhibit XX in this case */
773 decContextClearStatus(&dfp->context, DEC_Inexact);
774 }
775 }
776}
777
778#define DFP_HELPER_RRND(op, size) \
779void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
780 uint64_t *b, uint32_t rmc) \
781{ \
782 struct PPC_DFP dfp; \
783 int32_t ref_sig = *a & 0x3F; \
784 int32_t xmax = ((size) == 64) ? 369 : 6111; \
785 \
786 dfp_prepare_decimal##size(&dfp, 0, b, env); \
787 \
788 _dfp_reround(rmc, ref_sig, xmax, &dfp); \
789 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
790 &dfp.context); \
791 QUA_PPs(&dfp); \
792 \
793 if (size == 64) { \
794 t[0] = dfp.t64[0]; \
795 } else if (size == 128) { \
796 t[0] = dfp.t64[HI_IDX]; \
797 t[1] = dfp.t64[LO_IDX]; \
798 } \
799}
800
801DFP_HELPER_RRND(drrnd, 64)
802DFP_HELPER_RRND(drrndq, 128)
97c0d930
TM		 803
804#define DFP_HELPER_RINT(op, postprocs, size) \
805void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
806 uint32_t r, uint32_t rmc) \
807{ \
808 struct PPC_DFP dfp; \
809 \
810 dfp_prepare_decimal##size(&dfp, 0, b, env); \
811 \
812 dfp_set_round_mode_from_immediate(r, rmc, &dfp); \
813 decNumberToIntegralExact(&dfp.t, &dfp.b, &dfp.context); \
814 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
815 postprocs(&dfp); \
816 \
817 if (size == 64) { \
818 t[0] = dfp.t64[0]; \
819 } else if (size == 128) { \
820 t[0] = dfp.t64[HI_IDX]; \
821 t[1] = dfp.t64[LO_IDX]; \
822 } \
823}
824
825static void RINTX_PPs(struct PPC_DFP *dfp)
826{
827 dfp_set_FPRF_from_FRT(dfp);
828 dfp_check_for_XX(dfp);
829 dfp_check_for_VXSNAN(dfp);
830}
831
832DFP_HELPER_RINT(drintx, RINTX_PPs, 64)
833DFP_HELPER_RINT(drintxq, RINTX_PPs, 128)
834
835static void RINTN_PPs(struct PPC_DFP *dfp)
836{
837 dfp_set_FPRF_from_FRT(dfp);
838 dfp_check_for_VXSNAN(dfp);
839}
840
841DFP_HELPER_RINT(drintn, RINTN_PPs, 64)
842DFP_HELPER_RINT(drintnq, RINTN_PPs, 128)
Empty description
This page took 0.108636 seconds and 4 git commands to generate.