]> 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 Quantize
[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
a9d7ba03
TM		 379#define DFP_HELPER_TAB(op, dnop, postprocs, size) \
380void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
381{ \
382 struct PPC_DFP dfp; \
383 dfp_prepare_decimal##size(&dfp, a, b, env); \
384 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
385 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
386 postprocs(&dfp); \
387 if (size == 64) { \
388 t[0] = dfp.t64[0]; \
389 } else if (size == 128) { \
390 t[0] = dfp.t64[HI_IDX]; \
391 t[1] = dfp.t64[LO_IDX]; \
392 } \
393}
394
395static void ADD_PPs(struct PPC_DFP *dfp)
396{
397 dfp_set_FPRF_from_FRT(dfp);
398 dfp_check_for_OX(dfp);
399 dfp_check_for_UX(dfp);
400 dfp_check_for_XX(dfp);
401 dfp_check_for_VXSNAN(dfp);
402 dfp_check_for_VXISI_add(dfp);
403}
404
405DFP_HELPER_TAB(dadd, decNumberAdd, ADD_PPs, 64)
406DFP_HELPER_TAB(daddq, decNumberAdd, ADD_PPs, 128)
2128f8a5
TM		 407
408static void SUB_PPs(struct PPC_DFP *dfp)
409{
410 dfp_set_FPRF_from_FRT(dfp);
411 dfp_check_for_OX(dfp);
412 dfp_check_for_UX(dfp);
413 dfp_check_for_XX(dfp);
414 dfp_check_for_VXSNAN(dfp);
415 dfp_check_for_VXISI_subtract(dfp);
416}
417
418DFP_HELPER_TAB(dsub, decNumberSubtract, SUB_PPs, 64)
419DFP_HELPER_TAB(dsubq, decNumberSubtract, SUB_PPs, 128)
8de6a1cc
TM		 420
421static void MUL_PPs(struct PPC_DFP *dfp)
422{
423 dfp_set_FPRF_from_FRT(dfp);
424 dfp_check_for_OX(dfp);
425 dfp_check_for_UX(dfp);
426 dfp_check_for_XX(dfp);
427 dfp_check_for_VXSNAN(dfp);
428 dfp_check_for_VXIMZ(dfp);
429}
430
431DFP_HELPER_TAB(dmul, decNumberMultiply, MUL_PPs, 64)
432DFP_HELPER_TAB(dmulq, decNumberMultiply, MUL_PPs, 128)
9024ff40
TM		 433
434static void DIV_PPs(struct PPC_DFP *dfp)
435{
436 dfp_set_FPRF_from_FRT(dfp);
437 dfp_check_for_OX(dfp);
438 dfp_check_for_UX(dfp);
439 dfp_check_for_ZX(dfp);
440 dfp_check_for_XX(dfp);
441 dfp_check_for_VXSNAN(dfp);
442 dfp_check_for_VXZDZ(dfp);
443 dfp_check_for_VXIDI(dfp);
444}
445
446DFP_HELPER_TAB(ddiv, decNumberDivide, DIV_PPs, 64)
447DFP_HELPER_TAB(ddivq, decNumberDivide, DIV_PPs, 128)
5833505b
TM		 448
449#define DFP_HELPER_BF_AB(op, dnop, postprocs, size) \
450uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
451{ \
452 struct PPC_DFP dfp; \
453 dfp_prepare_decimal##size(&dfp, a, b, env); \
454 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
455 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
456 postprocs(&dfp); \
457 return dfp.crbf; \
458}
459
460static void CMPU_PPs(struct PPC_DFP *dfp)
461{
462 dfp_set_CRBF_from_T(dfp);
463 dfp_set_FPCC_from_CRBF(dfp);
464 dfp_check_for_VXSNAN(dfp);
465}
466
467DFP_HELPER_BF_AB(dcmpu, decNumberCompare, CMPU_PPs, 64)
468DFP_HELPER_BF_AB(dcmpuq, decNumberCompare, CMPU_PPs, 128)
469
470static void CMPO_PPs(struct PPC_DFP *dfp)
471{
472 dfp_set_CRBF_from_T(dfp);
473 dfp_set_FPCC_from_CRBF(dfp);
474 dfp_check_for_VXSNAN(dfp);
475 dfp_check_for_VXVC(dfp);
476}
477
478DFP_HELPER_BF_AB(dcmpo, decNumberCompare, CMPO_PPs, 64)
479DFP_HELPER_BF_AB(dcmpoq, decNumberCompare, CMPO_PPs, 128)
e601c1ee
TM		 480
481#define DFP_HELPER_TSTDC(op, size) \
482uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
483{ \
484 struct PPC_DFP dfp; \
485 int match = 0; \
486 \
487 dfp_prepare_decimal##size(&dfp, a, 0, env); \
488 \
489 match |= (dcm & 0x20) && decNumberIsZero(&dfp.a); \
490 match |= (dcm & 0x10) && decNumberIsSubnormal(&dfp.a, &dfp.context); \
491 match |= (dcm & 0x08) && decNumberIsNormal(&dfp.a, &dfp.context); \
492 match |= (dcm & 0x04) && decNumberIsInfinite(&dfp.a); \
493 match |= (dcm & 0x02) && decNumberIsQNaN(&dfp.a); \
494 match |= (dcm & 0x01) && decNumberIsSNaN(&dfp.a); \
495 \
496 if (decNumberIsNegative(&dfp.a)) { \
497 dfp.crbf = match ? 0xA : 0x8; \
498 } else { \
499 dfp.crbf = match ? 0x2 : 0x0; \
500 } \
501 \
502 dfp_set_FPCC_from_CRBF(&dfp); \
503 return dfp.crbf; \
504}
505
506DFP_HELPER_TSTDC(dtstdc, 64)
507DFP_HELPER_TSTDC(dtstdcq, 128)
1bf9c0e1
TM		 508
509#define DFP_HELPER_TSTDG(op, size) \
510uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
511{ \
512 struct PPC_DFP dfp; \
513 int minexp, maxexp, nzero_digits, nzero_idx, is_negative, is_zero, \
514 is_extreme_exp, is_subnormal, is_normal, leftmost_is_nonzero, \
515 match; \
516 \
517 dfp_prepare_decimal##size(&dfp, a, 0, env); \
518 \
519 if ((size) == 64) { \
520 minexp = -398; \
521 maxexp = 369; \
522 nzero_digits = 16; \
523 nzero_idx = 5; \
524 } else if ((size) == 128) { \
525 minexp = -6176; \
526 maxexp = 6111; \
527 nzero_digits = 34; \
528 nzero_idx = 11; \
529 } \
530 \
531 is_negative = decNumberIsNegative(&dfp.a); \
532 is_zero = decNumberIsZero(&dfp.a); \
533 is_extreme_exp = (dfp.a.exponent == maxexp) || \
534 (dfp.a.exponent == minexp); \
535 is_subnormal = decNumberIsSubnormal(&dfp.a, &dfp.context); \
536 is_normal = decNumberIsNormal(&dfp.a, &dfp.context); \
537 leftmost_is_nonzero = (dfp.a.digits == nzero_digits) && \
538 (dfp.a.lsu[nzero_idx] != 0); \
539 match = 0; \
540 \
541 match |= (dcm & 0x20) && is_zero && !is_extreme_exp; \
542 match |= (dcm & 0x10) && is_zero && is_extreme_exp; \
543 match |= (dcm & 0x08) && \
544 (is_subnormal || (is_normal && is_extreme_exp)); \
545 match |= (dcm & 0x04) && is_normal && !is_extreme_exp && \
546 !leftmost_is_nonzero; \
547 match |= (dcm & 0x02) && is_normal && !is_extreme_exp && \
548 leftmost_is_nonzero; \
549 match |= (dcm & 0x01) && decNumberIsSpecial(&dfp.a); \
550 \
551 if (is_negative) { \
552 dfp.crbf = match ? 0xA : 0x8; \
553 } else { \
554 dfp.crbf = match ? 0x2 : 0x0; \
555 } \
556 \
557 dfp_set_FPCC_from_CRBF(&dfp); \
558 return dfp.crbf; \
559}
560
561DFP_HELPER_TSTDG(dtstdg, 64)
562DFP_HELPER_TSTDG(dtstdgq, 128)
f3d2b0bc
TM		 563
564#define DFP_HELPER_TSTEX(op, size) \
565uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
566{ \
567 struct PPC_DFP dfp; \
568 int expa, expb, a_is_special, b_is_special; \
569 \
570 dfp_prepare_decimal##size(&dfp, a, b, env); \
571 \
572 expa = dfp.a.exponent; \
573 expb = dfp.b.exponent; \
574 a_is_special = decNumberIsSpecial(&dfp.a); \
575 b_is_special = decNumberIsSpecial(&dfp.b); \
576 \
577 if (a_is_special || b_is_special) { \
578 int atype = a_is_special ? (decNumberIsNaN(&dfp.a) ? 4 : 2) : 1; \
579 int btype = b_is_special ? (decNumberIsNaN(&dfp.b) ? 4 : 2) : 1; \
580 dfp.crbf = (atype ^ btype) ? 0x1 : 0x2; \
581 } else if (expa < expb) { \
582 dfp.crbf = 0x8; \
583 } else if (expa > expb) { \
584 dfp.crbf = 0x4; \
585 } else { \
586 dfp.crbf = 0x2; \
587 } \
588 \
589 dfp_set_FPCC_from_CRBF(&dfp); \
590 return dfp.crbf; \
591}
592
593DFP_HELPER_TSTEX(dtstex, 64)
594DFP_HELPER_TSTEX(dtstexq, 128)
f6022a76
TM		 595
596#define DFP_HELPER_TSTSF(op, size) \
597uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
598{ \
599 struct PPC_DFP dfp; \
600 unsigned k; \
601 \
602 dfp_prepare_decimal##size(&dfp, 0, b, env); \
603 \
604 k = *a & 0x3F; \
605 \
606 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
607 dfp.crbf = 1; \
608 } else if (k == 0) { \
609 dfp.crbf = 4; \
610 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
611 /* Zero has no sig digits */ \
612 dfp.crbf = 4; \
613 } else { \
614 unsigned nsd = dfp.b.digits; \
615 if (k < nsd) { \
616 dfp.crbf = 8; \
617 } else if (k > nsd) { \
618 dfp.crbf = 4; \
619 } else { \
620 dfp.crbf = 2; \
621 } \
622 } \
623 \
624 dfp_set_FPCC_from_CRBF(&dfp); \
625 return dfp.crbf; \
626}
627
628DFP_HELPER_TSTSF(dtstsf, 64)
629DFP_HELPER_TSTSF(dtstsfq, 128)
5826ebe2
TM		 630
631static void QUA_PPs(struct PPC_DFP *dfp)
632{
633 dfp_set_FPRF_from_FRT(dfp);
634 dfp_check_for_XX(dfp);
635 dfp_check_for_VXSNAN(dfp);
636 dfp_check_for_VXCVI(dfp);
637}
638
639static void dfp_quantize(uint8_t rmc, struct PPC_DFP *dfp)
640{
641 dfp_set_round_mode_from_immediate(0, rmc, dfp);
642 decNumberQuantize(&dfp->t, &dfp->b, &dfp->a, &dfp->context);
643 if (decNumberIsSNaN(&dfp->a)) {
644 dfp->t = dfp->a;
645 dfp_makeQNaN(&dfp->t);
646 } else if (decNumberIsSNaN(&dfp->b)) {
647 dfp->t = dfp->b;
648 dfp_makeQNaN(&dfp->t);
649 } else if (decNumberIsQNaN(&dfp->a)) {
650 dfp->t = dfp->a;
651 } else if (decNumberIsQNaN(&dfp->b)) {
652 dfp->t = dfp->b;
653 }
654}
655
656#define DFP_HELPER_QUAI(op, size) \
657void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
658 uint32_t te, uint32_t rmc) \
659{ \
660 struct PPC_DFP dfp; \
661 \
662 dfp_prepare_decimal##size(&dfp, 0, b, env); \
663 \
664 decNumberFromUInt32(&dfp.a, 1); \
665 dfp.a.exponent = (int32_t)((int8_t)(te << 3) >> 3); \
666 \
667 dfp_quantize(rmc, &dfp); \
668 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
669 &dfp.context); \
670 QUA_PPs(&dfp); \
671 \
672 if (size == 64) { \
673 t[0] = dfp.t64[0]; \
674 } else if (size == 128) { \
675 t[0] = dfp.t64[HI_IDX]; \
676 t[1] = dfp.t64[LO_IDX]; \
677 } \
678}
679
680DFP_HELPER_QUAI(dquai, 64)
681DFP_HELPER_QUAI(dquaiq, 128)
682
683#define DFP_HELPER_QUA(op, size) \
684void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
685 uint64_t *b, uint32_t rmc) \
686{ \
687 struct PPC_DFP dfp; \
688 \
689 dfp_prepare_decimal##size(&dfp, a, b, env); \
690 \
691 dfp_quantize(rmc, &dfp); \
692 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
693 &dfp.context); \
694 QUA_PPs(&dfp); \
695 \
696 if (size == 64) { \
697 t[0] = dfp.t64[0]; \
698 } else if (size == 128) { \
699 t[0] = dfp.t64[HI_IDX]; \
700 t[1] = dfp.t64[LO_IDX]; \
701 } \
702}
703
704DFP_HELPER_QUA(dqua, 64)
705DFP_HELPER_QUA(dquaq, 128)
Empty description
This page took 0.096577 seconds and 4 git commands to generate.