]> 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 Convert to Fixed
[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
ca603eb4
TM		 252static void dfp_set_FPRF_from_FRT_short(struct PPC_DFP *dfp)
253{
254 decContext shortContext;
255 decContextDefault(&shortContext, DEC_INIT_DECIMAL32);
256 dfp_set_FPRF_from_FRT_with_context(dfp, &shortContext);
257}
258
259static void dfp_set_FPRF_from_FRT_long(struct PPC_DFP *dfp)
260{
261 decContext longContext;
262 decContextDefault(&longContext, DEC_INIT_DECIMAL64);
263 dfp_set_FPRF_from_FRT_with_context(dfp, &longContext);
264}
265
a9d7ba03
TM		 266static void dfp_check_for_OX(struct PPC_DFP *dfp)
267{
268 if (dfp->context.status & DEC_Overflow) {
269 dfp_set_FPSCR_flag(dfp, FP_OX, FP_OE);
270 }
271}
272
273static void dfp_check_for_UX(struct PPC_DFP *dfp)
274{
275 if (dfp->context.status & DEC_Underflow) {
276 dfp_set_FPSCR_flag(dfp, FP_UX, FP_UE);
277 }
278}
279
280static void dfp_check_for_XX(struct PPC_DFP *dfp)
281{
282 if (dfp->context.status & DEC_Inexact) {
283 dfp_set_FPSCR_flag(dfp, FP_XX | FP_FI, FP_XE);
284 }
285}
286
9024ff40
TM		 287static void dfp_check_for_ZX(struct PPC_DFP *dfp)
288{
289 if (dfp->context.status & DEC_Division_by_zero) {
290 dfp_set_FPSCR_flag(dfp, FP_ZX, FP_ZE);
291 }
292}
293
a9d7ba03
TM		 294static void dfp_check_for_VXSNAN(struct PPC_DFP *dfp)
295{
296 if (dfp->context.status & DEC_Invalid_operation) {
297 if (decNumberIsSNaN(&dfp->a) || decNumberIsSNaN(&dfp->b)) {
298 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FP_VE);
299 }
300 }
301}
302
290d9ee5
TM		 303static void dfp_check_for_VXSNAN_and_convert_to_QNaN(struct PPC_DFP *dfp)
304{
305 if (decNumberIsSNaN(&dfp->t)) {
306 dfp->t.bits &= ~DECSNAN;
307 dfp->t.bits |= DECNAN;
308 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FP_VE);
309 }
310}
311
a9d7ba03
TM		 312static void dfp_check_for_VXISI(struct PPC_DFP *dfp, int testForSameSign)
313{
314 if (dfp->context.status & DEC_Invalid_operation) {
315 if (decNumberIsInfinite(&dfp->a) && decNumberIsInfinite(&dfp->b)) {
316 int same = decNumberClass(&dfp->a, &dfp->context) ==
317 decNumberClass(&dfp->b, &dfp->context);
318 if ((same && testForSameSign) || (!same && !testForSameSign)) {
319 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXISI, FP_VE);
320 }
321 }
322 }
323}
324
325static void dfp_check_for_VXISI_add(struct PPC_DFP *dfp)
326{
327 dfp_check_for_VXISI(dfp, 0);
328}
329
2128f8a5
TM		 330static void dfp_check_for_VXISI_subtract(struct PPC_DFP *dfp)
331{
332 dfp_check_for_VXISI(dfp, 1);
333}
334
8de6a1cc
TM		 335static void dfp_check_for_VXIMZ(struct PPC_DFP *dfp)
336{
337 if (dfp->context.status & DEC_Invalid_operation) {
338 if ((decNumberIsInfinite(&dfp->a) && decNumberIsZero(&dfp->b)) ||
339 (decNumberIsInfinite(&dfp->b) && decNumberIsZero(&dfp->a))) {
340 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXIMZ, FP_VE);
341 }
342 }
343}
344
9024ff40
TM		 345static void dfp_check_for_VXZDZ(struct PPC_DFP *dfp)
346{
347 if (dfp->context.status & DEC_Division_undefined) {
348 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXZDZ, FP_VE);
349 }
350}
351
352static void dfp_check_for_VXIDI(struct PPC_DFP *dfp)
353{
354 if (dfp->context.status & DEC_Invalid_operation) {
355 if (decNumberIsInfinite(&dfp->a) && decNumberIsInfinite(&dfp->b)) {
356 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXIDI, FP_VE);
357 }
358 }
359}
360
5833505b
TM		 361static void dfp_check_for_VXVC(struct PPC_DFP *dfp)
362{
363 if (decNumberIsNaN(&dfp->a) || decNumberIsNaN(&dfp->b)) {
364 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXVC, FP_VE);
365 }
366}
367
5826ebe2
TM		 368static void dfp_check_for_VXCVI(struct PPC_DFP *dfp)
369{
370 if ((dfp->context.status & DEC_Invalid_operation) &&
371 (!decNumberIsSNaN(&dfp->a)) &&
372 (!decNumberIsSNaN(&dfp->b))) {
373 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
374 }
375}
376
5833505b
TM		 377static void dfp_set_CRBF_from_T(struct PPC_DFP *dfp)
378{
379 if (decNumberIsNaN(&dfp->t)) {
380 dfp->crbf = 1;
381 } else if (decNumberIsZero(&dfp->t)) {
382 dfp->crbf = 2;
383 } else if (decNumberIsNegative(&dfp->t)) {
384 dfp->crbf = 8;
385 } else {
386 dfp->crbf = 4;
387 }
388}
389
390static void dfp_set_FPCC_from_CRBF(struct PPC_DFP *dfp)
391{
392 dfp->env->fpscr &= ~(0xF << 12);
393 dfp->env->fpscr |= (dfp->crbf << 12);
394}
395
5826ebe2
TM		 396static inline void dfp_makeQNaN(decNumber *dn)
397{
398 dn->bits &= ~DECSPECIAL;
399 dn->bits |= DECNAN;
400}
401
512918aa
TM		 402static inline int dfp_get_digit(decNumber *dn, int n)
403{
404 assert(DECDPUN == 3);
405 int unit = n / DECDPUN;
406 int dig = n % DECDPUN;
407 switch (dig) {
408 case 0:
409 return dn->lsu[unit] % 10;
410 case 1:
411 return (dn->lsu[unit] / 10) % 10;
412 case 2:
413 return dn->lsu[unit] / 100;
414 default:
415 assert(0);
416 }
417}
418
a9d7ba03
TM		 419#define DFP_HELPER_TAB(op, dnop, postprocs, size) \
420void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
421{ \
422 struct PPC_DFP dfp; \
423 dfp_prepare_decimal##size(&dfp, a, b, env); \
424 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
425 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
426 postprocs(&dfp); \
427 if (size == 64) { \
428 t[0] = dfp.t64[0]; \
429 } else if (size == 128) { \
430 t[0] = dfp.t64[HI_IDX]; \
431 t[1] = dfp.t64[LO_IDX]; \
432 } \
433}
434
435static void ADD_PPs(struct PPC_DFP *dfp)
436{
437 dfp_set_FPRF_from_FRT(dfp);
438 dfp_check_for_OX(dfp);
439 dfp_check_for_UX(dfp);
440 dfp_check_for_XX(dfp);
441 dfp_check_for_VXSNAN(dfp);
442 dfp_check_for_VXISI_add(dfp);
443}
444
445DFP_HELPER_TAB(dadd, decNumberAdd, ADD_PPs, 64)
446DFP_HELPER_TAB(daddq, decNumberAdd, ADD_PPs, 128)
2128f8a5
TM		 447
448static void SUB_PPs(struct PPC_DFP *dfp)
449{
450 dfp_set_FPRF_from_FRT(dfp);
451 dfp_check_for_OX(dfp);
452 dfp_check_for_UX(dfp);
453 dfp_check_for_XX(dfp);
454 dfp_check_for_VXSNAN(dfp);
455 dfp_check_for_VXISI_subtract(dfp);
456}
457
458DFP_HELPER_TAB(dsub, decNumberSubtract, SUB_PPs, 64)
459DFP_HELPER_TAB(dsubq, decNumberSubtract, SUB_PPs, 128)
8de6a1cc
TM		 460
461static void MUL_PPs(struct PPC_DFP *dfp)
462{
463 dfp_set_FPRF_from_FRT(dfp);
464 dfp_check_for_OX(dfp);
465 dfp_check_for_UX(dfp);
466 dfp_check_for_XX(dfp);
467 dfp_check_for_VXSNAN(dfp);
468 dfp_check_for_VXIMZ(dfp);
469}
470
471DFP_HELPER_TAB(dmul, decNumberMultiply, MUL_PPs, 64)
472DFP_HELPER_TAB(dmulq, decNumberMultiply, MUL_PPs, 128)
9024ff40
TM		 473
474static void DIV_PPs(struct PPC_DFP *dfp)
475{
476 dfp_set_FPRF_from_FRT(dfp);
477 dfp_check_for_OX(dfp);
478 dfp_check_for_UX(dfp);
479 dfp_check_for_ZX(dfp);
480 dfp_check_for_XX(dfp);
481 dfp_check_for_VXSNAN(dfp);
482 dfp_check_for_VXZDZ(dfp);
483 dfp_check_for_VXIDI(dfp);
484}
485
486DFP_HELPER_TAB(ddiv, decNumberDivide, DIV_PPs, 64)
487DFP_HELPER_TAB(ddivq, decNumberDivide, DIV_PPs, 128)
5833505b
TM		 488
489#define DFP_HELPER_BF_AB(op, dnop, postprocs, size) \
490uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
491{ \
492 struct PPC_DFP dfp; \
493 dfp_prepare_decimal##size(&dfp, a, b, env); \
494 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
495 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
496 postprocs(&dfp); \
497 return dfp.crbf; \
498}
499
500static void CMPU_PPs(struct PPC_DFP *dfp)
501{
502 dfp_set_CRBF_from_T(dfp);
503 dfp_set_FPCC_from_CRBF(dfp);
504 dfp_check_for_VXSNAN(dfp);
505}
506
507DFP_HELPER_BF_AB(dcmpu, decNumberCompare, CMPU_PPs, 64)
508DFP_HELPER_BF_AB(dcmpuq, decNumberCompare, CMPU_PPs, 128)
509
510static void CMPO_PPs(struct PPC_DFP *dfp)
511{
512 dfp_set_CRBF_from_T(dfp);
513 dfp_set_FPCC_from_CRBF(dfp);
514 dfp_check_for_VXSNAN(dfp);
515 dfp_check_for_VXVC(dfp);
516}
517
518DFP_HELPER_BF_AB(dcmpo, decNumberCompare, CMPO_PPs, 64)
519DFP_HELPER_BF_AB(dcmpoq, decNumberCompare, CMPO_PPs, 128)
e601c1ee
TM		 520
521#define DFP_HELPER_TSTDC(op, size) \
522uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
523{ \
524 struct PPC_DFP dfp; \
525 int match = 0; \
526 \
527 dfp_prepare_decimal##size(&dfp, a, 0, env); \
528 \
529 match |= (dcm & 0x20) && decNumberIsZero(&dfp.a); \
530 match |= (dcm & 0x10) && decNumberIsSubnormal(&dfp.a, &dfp.context); \
531 match |= (dcm & 0x08) && decNumberIsNormal(&dfp.a, &dfp.context); \
532 match |= (dcm & 0x04) && decNumberIsInfinite(&dfp.a); \
533 match |= (dcm & 0x02) && decNumberIsQNaN(&dfp.a); \
534 match |= (dcm & 0x01) && decNumberIsSNaN(&dfp.a); \
535 \
536 if (decNumberIsNegative(&dfp.a)) { \
537 dfp.crbf = match ? 0xA : 0x8; \
538 } else { \
539 dfp.crbf = match ? 0x2 : 0x0; \
540 } \
541 \
542 dfp_set_FPCC_from_CRBF(&dfp); \
543 return dfp.crbf; \
544}
545
546DFP_HELPER_TSTDC(dtstdc, 64)
547DFP_HELPER_TSTDC(dtstdcq, 128)
1bf9c0e1
TM		 548
549#define DFP_HELPER_TSTDG(op, size) \
550uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
551{ \
552 struct PPC_DFP dfp; \
553 int minexp, maxexp, nzero_digits, nzero_idx, is_negative, is_zero, \
554 is_extreme_exp, is_subnormal, is_normal, leftmost_is_nonzero, \
555 match; \
556 \
557 dfp_prepare_decimal##size(&dfp, a, 0, env); \
558 \
559 if ((size) == 64) { \
560 minexp = -398; \
561 maxexp = 369; \
562 nzero_digits = 16; \
563 nzero_idx = 5; \
564 } else if ((size) == 128) { \
565 minexp = -6176; \
566 maxexp = 6111; \
567 nzero_digits = 34; \
568 nzero_idx = 11; \
569 } \
570 \
571 is_negative = decNumberIsNegative(&dfp.a); \
572 is_zero = decNumberIsZero(&dfp.a); \
573 is_extreme_exp = (dfp.a.exponent == maxexp) || \
574 (dfp.a.exponent == minexp); \
575 is_subnormal = decNumberIsSubnormal(&dfp.a, &dfp.context); \
576 is_normal = decNumberIsNormal(&dfp.a, &dfp.context); \
577 leftmost_is_nonzero = (dfp.a.digits == nzero_digits) && \
578 (dfp.a.lsu[nzero_idx] != 0); \
579 match = 0; \
580 \
581 match |= (dcm & 0x20) && is_zero && !is_extreme_exp; \
582 match |= (dcm & 0x10) && is_zero && is_extreme_exp; \
583 match |= (dcm & 0x08) && \
584 (is_subnormal || (is_normal && is_extreme_exp)); \
585 match |= (dcm & 0x04) && is_normal && !is_extreme_exp && \
586 !leftmost_is_nonzero; \
587 match |= (dcm & 0x02) && is_normal && !is_extreme_exp && \
588 leftmost_is_nonzero; \
589 match |= (dcm & 0x01) && decNumberIsSpecial(&dfp.a); \
590 \
591 if (is_negative) { \
592 dfp.crbf = match ? 0xA : 0x8; \
593 } else { \
594 dfp.crbf = match ? 0x2 : 0x0; \
595 } \
596 \
597 dfp_set_FPCC_from_CRBF(&dfp); \
598 return dfp.crbf; \
599}
600
601DFP_HELPER_TSTDG(dtstdg, 64)
602DFP_HELPER_TSTDG(dtstdgq, 128)
f3d2b0bc
TM		 603
604#define DFP_HELPER_TSTEX(op, size) \
605uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
606{ \
607 struct PPC_DFP dfp; \
608 int expa, expb, a_is_special, b_is_special; \
609 \
610 dfp_prepare_decimal##size(&dfp, a, b, env); \
611 \
612 expa = dfp.a.exponent; \
613 expb = dfp.b.exponent; \
614 a_is_special = decNumberIsSpecial(&dfp.a); \
615 b_is_special = decNumberIsSpecial(&dfp.b); \
616 \
617 if (a_is_special || b_is_special) { \
618 int atype = a_is_special ? (decNumberIsNaN(&dfp.a) ? 4 : 2) : 1; \
619 int btype = b_is_special ? (decNumberIsNaN(&dfp.b) ? 4 : 2) : 1; \
620 dfp.crbf = (atype ^ btype) ? 0x1 : 0x2; \
621 } else if (expa < expb) { \
622 dfp.crbf = 0x8; \
623 } else if (expa > expb) { \
624 dfp.crbf = 0x4; \
625 } else { \
626 dfp.crbf = 0x2; \
627 } \
628 \
629 dfp_set_FPCC_from_CRBF(&dfp); \
630 return dfp.crbf; \
631}
632
633DFP_HELPER_TSTEX(dtstex, 64)
634DFP_HELPER_TSTEX(dtstexq, 128)
f6022a76
TM		 635
636#define DFP_HELPER_TSTSF(op, size) \
637uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
638{ \
639 struct PPC_DFP dfp; \
640 unsigned k; \
641 \
642 dfp_prepare_decimal##size(&dfp, 0, b, env); \
643 \
644 k = *a & 0x3F; \
645 \
646 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
647 dfp.crbf = 1; \
648 } else if (k == 0) { \
649 dfp.crbf = 4; \
650 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
651 /* Zero has no sig digits */ \
652 dfp.crbf = 4; \
653 } else { \
654 unsigned nsd = dfp.b.digits; \
655 if (k < nsd) { \
656 dfp.crbf = 8; \
657 } else if (k > nsd) { \
658 dfp.crbf = 4; \
659 } else { \
660 dfp.crbf = 2; \
661 } \
662 } \
663 \
664 dfp_set_FPCC_from_CRBF(&dfp); \
665 return dfp.crbf; \
666}
667
668DFP_HELPER_TSTSF(dtstsf, 64)
669DFP_HELPER_TSTSF(dtstsfq, 128)
5826ebe2
TM		 670
671static void QUA_PPs(struct PPC_DFP *dfp)
672{
673 dfp_set_FPRF_from_FRT(dfp);
674 dfp_check_for_XX(dfp);
675 dfp_check_for_VXSNAN(dfp);
676 dfp_check_for_VXCVI(dfp);
677}
678
679static void dfp_quantize(uint8_t rmc, struct PPC_DFP *dfp)
680{
681 dfp_set_round_mode_from_immediate(0, rmc, dfp);
682 decNumberQuantize(&dfp->t, &dfp->b, &dfp->a, &dfp->context);
683 if (decNumberIsSNaN(&dfp->a)) {
684 dfp->t = dfp->a;
685 dfp_makeQNaN(&dfp->t);
686 } else if (decNumberIsSNaN(&dfp->b)) {
687 dfp->t = dfp->b;
688 dfp_makeQNaN(&dfp->t);
689 } else if (decNumberIsQNaN(&dfp->a)) {
690 dfp->t = dfp->a;
691 } else if (decNumberIsQNaN(&dfp->b)) {
692 dfp->t = dfp->b;
693 }
694}
695
696#define DFP_HELPER_QUAI(op, size) \
697void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
698 uint32_t te, uint32_t rmc) \
699{ \
700 struct PPC_DFP dfp; \
701 \
702 dfp_prepare_decimal##size(&dfp, 0, b, env); \
703 \
704 decNumberFromUInt32(&dfp.a, 1); \
705 dfp.a.exponent = (int32_t)((int8_t)(te << 3) >> 3); \
706 \
707 dfp_quantize(rmc, &dfp); \
708 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
709 &dfp.context); \
710 QUA_PPs(&dfp); \
711 \
712 if (size == 64) { \
713 t[0] = dfp.t64[0]; \
714 } else if (size == 128) { \
715 t[0] = dfp.t64[HI_IDX]; \
716 t[1] = dfp.t64[LO_IDX]; \
717 } \
718}
719
720DFP_HELPER_QUAI(dquai, 64)
721DFP_HELPER_QUAI(dquaiq, 128)
722
723#define DFP_HELPER_QUA(op, size) \
724void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
725 uint64_t *b, uint32_t rmc) \
726{ \
727 struct PPC_DFP dfp; \
728 \
729 dfp_prepare_decimal##size(&dfp, a, b, env); \
730 \
731 dfp_quantize(rmc, &dfp); \
732 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
733 &dfp.context); \
734 QUA_PPs(&dfp); \
735 \
736 if (size == 64) { \
737 t[0] = dfp.t64[0]; \
738 } else if (size == 128) { \
739 t[0] = dfp.t64[HI_IDX]; \
740 t[1] = dfp.t64[LO_IDX]; \
741 } \
742}
743
744DFP_HELPER_QUA(dqua, 64)
745DFP_HELPER_QUA(dquaq, 128)
512918aa
TM		 746
747static void _dfp_reround(uint8_t rmc, int32_t ref_sig, int32_t xmax,
748 struct PPC_DFP *dfp)
749{
750 int msd_orig, msd_rslt;
751
752 if (unlikely((ref_sig == 0) || (dfp->b.digits <= ref_sig))) {
753 dfp->t = dfp->b;
754 if (decNumberIsSNaN(&dfp->b)) {
755 dfp_makeQNaN(&dfp->t);
756 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FPSCR_VE);
757 }
758 return;
759 }
760
761 /* Reround is equivalent to quantizing b with 1**E(n) where */
762 /* n = exp(b) + numDigits(b) - reference_significance. */
763
764 decNumberFromUInt32(&dfp->a, 1);
765 dfp->a.exponent = dfp->b.exponent + dfp->b.digits - ref_sig;
766
767 if (unlikely(dfp->a.exponent > xmax)) {
768 dfp->t.digits = 0;
769 dfp->t.bits &= ~DECNEG;
770 dfp_makeQNaN(&dfp->t);
771 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FPSCR_VE);
772 return;
773 }
774
775 dfp_quantize(rmc, dfp);
776
777 msd_orig = dfp_get_digit(&dfp->b, dfp->b.digits-1);
778 msd_rslt = dfp_get_digit(&dfp->t, dfp->t.digits-1);
779
780 /* If the quantization resulted in rounding up to the next magnitude, */
781 /* then we need to shift the significand and adjust the exponent. */
782
783 if (unlikely((msd_orig == 9) && (msd_rslt == 1))) {
784
785 decNumber negone;
786
787 decNumberFromInt32(&negone, -1);
788 decNumberShift(&dfp->t, &dfp->t, &negone, &dfp->context);
789 dfp->t.exponent++;
790
791 if (unlikely(dfp->t.exponent > xmax)) {
792 dfp_makeQNaN(&dfp->t);
793 dfp->t.digits = 0;
794 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
795 /* Inhibit XX in this case */
796 decContextClearStatus(&dfp->context, DEC_Inexact);
797 }
798 }
799}
800
801#define DFP_HELPER_RRND(op, size) \
802void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
803 uint64_t *b, uint32_t rmc) \
804{ \
805 struct PPC_DFP dfp; \
806 int32_t ref_sig = *a & 0x3F; \
807 int32_t xmax = ((size) == 64) ? 369 : 6111; \
808 \
809 dfp_prepare_decimal##size(&dfp, 0, b, env); \
810 \
811 _dfp_reround(rmc, ref_sig, xmax, &dfp); \
812 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
813 &dfp.context); \
814 QUA_PPs(&dfp); \
815 \
816 if (size == 64) { \
817 t[0] = dfp.t64[0]; \
818 } else if (size == 128) { \
819 t[0] = dfp.t64[HI_IDX]; \
820 t[1] = dfp.t64[LO_IDX]; \
821 } \
822}
823
824DFP_HELPER_RRND(drrnd, 64)
825DFP_HELPER_RRND(drrndq, 128)
97c0d930
TM		 826
827#define DFP_HELPER_RINT(op, postprocs, size) \
828void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
829 uint32_t r, uint32_t rmc) \
830{ \
831 struct PPC_DFP dfp; \
832 \
833 dfp_prepare_decimal##size(&dfp, 0, b, env); \
834 \
835 dfp_set_round_mode_from_immediate(r, rmc, &dfp); \
836 decNumberToIntegralExact(&dfp.t, &dfp.b, &dfp.context); \
837 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
838 postprocs(&dfp); \
839 \
840 if (size == 64) { \
841 t[0] = dfp.t64[0]; \
842 } else if (size == 128) { \
843 t[0] = dfp.t64[HI_IDX]; \
844 t[1] = dfp.t64[LO_IDX]; \
845 } \
846}
847
848static void RINTX_PPs(struct PPC_DFP *dfp)
849{
850 dfp_set_FPRF_from_FRT(dfp);
851 dfp_check_for_XX(dfp);
852 dfp_check_for_VXSNAN(dfp);
853}
854
855DFP_HELPER_RINT(drintx, RINTX_PPs, 64)
856DFP_HELPER_RINT(drintxq, RINTX_PPs, 128)
857
858static void RINTN_PPs(struct PPC_DFP *dfp)
859{
860 dfp_set_FPRF_from_FRT(dfp);
861 dfp_check_for_VXSNAN(dfp);
862}
863
864DFP_HELPER_RINT(drintn, RINTN_PPs, 64)
865DFP_HELPER_RINT(drintnq, RINTN_PPs, 128)
290d9ee5
TM		 866
867void helper_dctdp(CPUPPCState *env, uint64_t *t, uint64_t *b)
868{
869 struct PPC_DFP dfp;
870 uint32_t b_short = *b;
871 dfp_prepare_decimal64(&dfp, 0, 0, env);
872 decimal32ToNumber((decimal32 *)&b_short, &dfp.t);
873 decimal64FromNumber((decimal64 *)t, &dfp.t, &dfp.context);
874 dfp_set_FPRF_from_FRT(&dfp);
875}
876
877void helper_dctqpq(CPUPPCState *env, uint64_t *t, uint64_t *b)
878{
879 struct PPC_DFP dfp;
880 dfp_prepare_decimal128(&dfp, 0, 0, env);
881 decimal64ToNumber((decimal64 *)b, &dfp.t);
882
883 dfp_check_for_VXSNAN_and_convert_to_QNaN(&dfp);
884 dfp_set_FPRF_from_FRT(&dfp);
885
886 decimal128FromNumber((decimal128 *)&dfp.t64, &dfp.t, &dfp.context);
887 t[0] = dfp.t64[HI_IDX];
888 t[1] = dfp.t64[LO_IDX];
889}
ca603eb4
TM		 890
891void helper_drsp(CPUPPCState *env, uint64_t *t, uint64_t *b)
892{
893 struct PPC_DFP dfp;
894 uint32_t t_short = 0;
895 dfp_prepare_decimal64(&dfp, 0, b, env);
896 decimal32FromNumber((decimal32 *)&t_short, &dfp.b, &dfp.context);
897 decimal32ToNumber((decimal32 *)&t_short, &dfp.t);
898
899 dfp_set_FPRF_from_FRT_short(&dfp);
900 dfp_check_for_OX(&dfp);
901 dfp_check_for_UX(&dfp);
902 dfp_check_for_XX(&dfp);
903
904 *t = t_short;
905}
906
907void helper_drdpq(CPUPPCState *env, uint64_t *t, uint64_t *b)
908{
909 struct PPC_DFP dfp;
910 dfp_prepare_decimal128(&dfp, 0, b, env);
911 decimal64FromNumber((decimal64 *)&dfp.t64, &dfp.b, &dfp.context);
912 decimal64ToNumber((decimal64 *)&dfp.t64, &dfp.t);
913
914 dfp_check_for_VXSNAN_and_convert_to_QNaN(&dfp);
915 dfp_set_FPRF_from_FRT_long(&dfp);
916 dfp_check_for_OX(&dfp);
917 dfp_check_for_UX(&dfp);
918 dfp_check_for_XX(&dfp);
919
920 decimal64FromNumber((decimal64 *)dfp.t64, &dfp.t, &dfp.context);
921 t[0] = dfp.t64[0];
922 t[1] = 0;
923}
f1214193
TM		 924
925#define DFP_HELPER_CFFIX(op, size) \
926void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
927{ \
928 struct PPC_DFP dfp; \
929 dfp_prepare_decimal##size(&dfp, 0, b, env); \
930 decNumberFromInt64(&dfp.t, (int64_t)(*b)); \
931 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
932 CFFIX_PPs(&dfp); \
933 \
934 if (size == 64) { \
935 t[0] = dfp.t64[0]; \
936 } else if (size == 128) { \
937 t[0] = dfp.t64[HI_IDX]; \
938 t[1] = dfp.t64[LO_IDX]; \
939 } \
940}
941
942static void CFFIX_PPs(struct PPC_DFP *dfp)
943{
944 dfp_set_FPRF_from_FRT(dfp);
945 dfp_check_for_XX(dfp);
946}
947
948DFP_HELPER_CFFIX(dcffix, 64)
949DFP_HELPER_CFFIX(dcffixq, 128)
bea0dd79
TM		 950
951#define DFP_HELPER_CTFIX(op, size) \
952void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
953{ \
954 struct PPC_DFP dfp; \
955 dfp_prepare_decimal##size(&dfp, 0, b, env); \
956 \
957 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
958 uint64_t invalid_flags = FP_VX | FP_VXCVI; \
959 if (decNumberIsInfinite(&dfp.b)) { \
960 dfp.t64[0] = decNumberIsNegative(&dfp.b) ? INT64_MIN : INT64_MAX; \
961 } else { /* NaN */ \
962 dfp.t64[0] = INT64_MIN; \
963 if (decNumberIsSNaN(&dfp.b)) { \
964 invalid_flags |= FP_VXSNAN; \
965 } \
966 } \
967 dfp_set_FPSCR_flag(&dfp, invalid_flags, FP_VE); \
968 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
969 dfp.t64[0] = 0; \
970 } else { \
971 decNumberToIntegralExact(&dfp.b, &dfp.b, &dfp.context); \
972 dfp.t64[0] = decNumberIntegralToInt64(&dfp.b, &dfp.context); \
973 if (decContextTestStatus(&dfp.context, DEC_Invalid_operation)) { \
974 dfp.t64[0] = decNumberIsNegative(&dfp.b) ? INT64_MIN : INT64_MAX; \
975 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FP_VE); \
976 } else { \
977 dfp_check_for_XX(&dfp); \
978 } \
979 } \
980 \
981 *t = dfp.t64[0]; \
982}
983
984DFP_HELPER_CTFIX(dctfix, 64)
985DFP_HELPER_CTFIX(dctfixq, 128)
Empty description
This page took 0.12511 seconds and 4 git commands to generate.