?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ppc: Add support for 'mffscrn','mffscrni' instructions
[qemu/ar7.git] / target / ppc / dfp_helper.c
blobda8e08a35c5bccc274a722dd2a7cd6d210c72b79
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 "qemu/osdep.h"
21 #include "cpu.h"
22 #include "exec/helper-proto.h"
23
24 #define DECNUMDIGITS 34
25 #include "libdecnumber/decContext.h"
26 #include "libdecnumber/decNumber.h"
27 #include "libdecnumber/dpd/decimal32.h"
28 #include "libdecnumber/dpd/decimal64.h"
29 #include "libdecnumber/dpd/decimal128.h"
30
31 #if defined(HOST_WORDS_BIGENDIAN)
32 #define HI_IDX 0
33 #define LO_IDX 1
34 #else
35 #define HI_IDX 1
36 #define LO_IDX 0
37 #endif
38
39 struct PPC_DFP {
40 CPUPPCState *env;
41 uint64_t t64[2], a64[2], b64[2];
42 decNumber t, a, b;
43 decContext context;
44 uint8_t crbf;
45 };
46
47 static void dfp_prepare_rounding_mode(decContext *context, uint64_t fpscr)
48 {
49 enum rounding rnd;
50
51 switch ((fpscr & FP_DRN) >> FPSCR_DRN0) {
52 case 0:
53 rnd = DEC_ROUND_HALF_EVEN;
54 break;
55 case 1:
56 rnd = DEC_ROUND_DOWN;
57 break;
58 case 2:
59 rnd = DEC_ROUND_CEILING;
60 break;
61 case 3:
62 rnd = DEC_ROUND_FLOOR;
63 break;
64 case 4:
65 rnd = DEC_ROUND_HALF_UP;
66 break;
67 case 5:
68 rnd = DEC_ROUND_HALF_DOWN;
69 break;
70 case 6:
71 rnd = DEC_ROUND_UP;
72 break;
73 case 7:
74 rnd = DEC_ROUND_05UP;
75 break;
76 default:
77 g_assert_not_reached();
78 }
79
80 decContextSetRounding(context, rnd);
81 }
82
83 static void dfp_set_round_mode_from_immediate(uint8_t r, uint8_t rmc,
84 struct PPC_DFP *dfp)
85 {
86 enum rounding rnd;
87 if (r == 0) {
88 switch (rmc & 3) {
89 case 0:
90 rnd = DEC_ROUND_HALF_EVEN;
91 break;
92 case 1:
93 rnd = DEC_ROUND_DOWN;
94 break;
95 case 2:
96 rnd = DEC_ROUND_HALF_UP;
97 break;
98 case 3: /* use FPSCR rounding mode */
99 return;
100 default:
101 assert(0); /* cannot get here */
102 }
103 } else { /* r == 1 */
104 switch (rmc & 3) {
105 case 0:
106 rnd = DEC_ROUND_CEILING;
107 break;
108 case 1:
109 rnd = DEC_ROUND_FLOOR;
110 break;
111 case 2:
112 rnd = DEC_ROUND_UP;
113 break;
114 case 3:
115 rnd = DEC_ROUND_HALF_DOWN;
116 break;
117 default:
118 assert(0); /* cannot get here */
119 }
120 }
121 decContextSetRounding(&dfp->context, rnd);
122 }
123
124 static void dfp_prepare_decimal64(struct PPC_DFP *dfp, uint64_t *a,
125 uint64_t *b, CPUPPCState *env)
126 {
127 decContextDefault(&dfp->context, DEC_INIT_DECIMAL64);
128 dfp_prepare_rounding_mode(&dfp->context, env->fpscr);
129 dfp->env = env;
130
131 if (a) {
132 dfp->a64[0] = *a;
133 decimal64ToNumber((decimal64 *)dfp->a64, &dfp->a);
134 } else {
135 dfp->a64[0] = 0;
136 decNumberZero(&dfp->a);
137 }
138
139 if (b) {
140 dfp->b64[0] = *b;
141 decimal64ToNumber((decimal64 *)dfp->b64, &dfp->b);
142 } else {
143 dfp->b64[0] = 0;
144 decNumberZero(&dfp->b);
145 }
146 }
147
148 static void dfp_prepare_decimal128(struct PPC_DFP *dfp, uint64_t *a,
149 uint64_t *b, CPUPPCState *env)
150 {
151 decContextDefault(&dfp->context, DEC_INIT_DECIMAL128);
152 dfp_prepare_rounding_mode(&dfp->context, env->fpscr);
153 dfp->env = env;
154
155 if (a) {
156 dfp->a64[0] = a[HI_IDX];
157 dfp->a64[1] = a[LO_IDX];
158 decimal128ToNumber((decimal128 *)dfp->a64, &dfp->a);
159 } else {
160 dfp->a64[0] = dfp->a64[1] = 0;
161 decNumberZero(&dfp->a);
162 }
163
164 if (b) {
165 dfp->b64[0] = b[HI_IDX];
166 dfp->b64[1] = b[LO_IDX];
167 decimal128ToNumber((decimal128 *)dfp->b64, &dfp->b);
168 } else {
169 dfp->b64[0] = dfp->b64[1] = 0;
170 decNumberZero(&dfp->b);
171 }
172 }
173
174 static void dfp_set_FPSCR_flag(struct PPC_DFP *dfp, uint64_t flag,
175 uint64_t enabled)
176 {
177 dfp->env->fpscr |= (flag | FP_FX);
178 if (dfp->env->fpscr & enabled) {
179 dfp->env->fpscr |= FP_FEX;
180 }
181 }
182
183 static void dfp_set_FPRF_from_FRT_with_context(struct PPC_DFP *dfp,
184 decContext *context)
185 {
186 uint64_t fprf = 0;
187
188 /* construct FPRF */
189 switch (decNumberClass(&dfp->t, context)) {
190 case DEC_CLASS_SNAN:
191 fprf = 0x01;
192 break;
193 case DEC_CLASS_QNAN:
194 fprf = 0x11;
195 break;
196 case DEC_CLASS_NEG_INF:
197 fprf = 0x09;
198 break;
199 case DEC_CLASS_NEG_NORMAL:
200 fprf = 0x08;
201 break;
202 case DEC_CLASS_NEG_SUBNORMAL:
203 fprf = 0x18;
204 break;
205 case DEC_CLASS_NEG_ZERO:
206 fprf = 0x12;
207 break;
208 case DEC_CLASS_POS_ZERO:
209 fprf = 0x02;
210 break;
211 case DEC_CLASS_POS_SUBNORMAL:
212 fprf = 0x14;
213 break;
214 case DEC_CLASS_POS_NORMAL:
215 fprf = 0x04;
216 break;
217 case DEC_CLASS_POS_INF:
218 fprf = 0x05;
219 break;
220 default:
221 assert(0); /* should never get here */
222 }
223 dfp->env->fpscr &= ~(0x1F << 12);
224 dfp->env->fpscr |= (fprf << 12);
225 }
226
227 static void dfp_set_FPRF_from_FRT(struct PPC_DFP *dfp)
228 {
229 dfp_set_FPRF_from_FRT_with_context(dfp, &dfp->context);
230 }
231
232 static void dfp_set_FPRF_from_FRT_short(struct PPC_DFP *dfp)
233 {
234 decContext shortContext;
235 decContextDefault(&shortContext, DEC_INIT_DECIMAL32);
236 dfp_set_FPRF_from_FRT_with_context(dfp, &shortContext);
237 }
238
239 static void dfp_set_FPRF_from_FRT_long(struct PPC_DFP *dfp)
240 {
241 decContext longContext;
242 decContextDefault(&longContext, DEC_INIT_DECIMAL64);
243 dfp_set_FPRF_from_FRT_with_context(dfp, &longContext);
244 }
245
246 static void dfp_check_for_OX(struct PPC_DFP *dfp)
247 {
248 if (dfp->context.status & DEC_Overflow) {
249 dfp_set_FPSCR_flag(dfp, FP_OX, FP_OE);
250 }
251 }
252
253 static void dfp_check_for_UX(struct PPC_DFP *dfp)
254 {
255 if (dfp->context.status & DEC_Underflow) {
256 dfp_set_FPSCR_flag(dfp, FP_UX, FP_UE);
257 }
258 }
259
260 static void dfp_check_for_XX(struct PPC_DFP *dfp)
261 {
262 if (dfp->context.status & DEC_Inexact) {
263 dfp_set_FPSCR_flag(dfp, FP_XX | FP_FI, FP_XE);
264 }
265 }
266
267 static void dfp_check_for_ZX(struct PPC_DFP *dfp)
268 {
269 if (dfp->context.status & DEC_Division_by_zero) {
270 dfp_set_FPSCR_flag(dfp, FP_ZX, FP_ZE);
271 }
272 }
273
274 static void dfp_check_for_VXSNAN(struct PPC_DFP *dfp)
275 {
276 if (dfp->context.status & DEC_Invalid_operation) {
277 if (decNumberIsSNaN(&dfp->a) || decNumberIsSNaN(&dfp->b)) {
278 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FP_VE);
279 }
280 }
281 }
282
283 static void dfp_check_for_VXSNAN_and_convert_to_QNaN(struct PPC_DFP *dfp)
284 {
285 if (decNumberIsSNaN(&dfp->t)) {
286 dfp->t.bits &= ~DECSNAN;
287 dfp->t.bits |= DECNAN;
288 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FP_VE);
289 }
290 }
291
292 static void dfp_check_for_VXISI(struct PPC_DFP *dfp, int testForSameSign)
293 {
294 if (dfp->context.status & DEC_Invalid_operation) {
295 if (decNumberIsInfinite(&dfp->a) && decNumberIsInfinite(&dfp->b)) {
296 int same = decNumberClass(&dfp->a, &dfp->context) ==
297 decNumberClass(&dfp->b, &dfp->context);
298 if ((same && testForSameSign) || (!same && !testForSameSign)) {
299 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXISI, FP_VE);
300 }
301 }
302 }
303 }
304
305 static void dfp_check_for_VXISI_add(struct PPC_DFP *dfp)
306 {
307 dfp_check_for_VXISI(dfp, 0);
308 }
309
310 static void dfp_check_for_VXISI_subtract(struct PPC_DFP *dfp)
311 {
312 dfp_check_for_VXISI(dfp, 1);
313 }
314
315 static void dfp_check_for_VXIMZ(struct PPC_DFP *dfp)
316 {
317 if (dfp->context.status & DEC_Invalid_operation) {
318 if ((decNumberIsInfinite(&dfp->a) && decNumberIsZero(&dfp->b)) ||
319 (decNumberIsInfinite(&dfp->b) && decNumberIsZero(&dfp->a))) {
320 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXIMZ, FP_VE);
321 }
322 }
323 }
324
325 static void dfp_check_for_VXZDZ(struct PPC_DFP *dfp)
326 {
327 if (dfp->context.status & DEC_Division_undefined) {
328 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXZDZ, FP_VE);
329 }
330 }
331
332 static void dfp_check_for_VXIDI(struct PPC_DFP *dfp)
333 {
334 if (dfp->context.status & DEC_Invalid_operation) {
335 if (decNumberIsInfinite(&dfp->a) && decNumberIsInfinite(&dfp->b)) {
336 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXIDI, FP_VE);
337 }
338 }
339 }
340
341 static void dfp_check_for_VXVC(struct PPC_DFP *dfp)
342 {
343 if (decNumberIsNaN(&dfp->a) || decNumberIsNaN(&dfp->b)) {
344 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXVC, FP_VE);
345 }
346 }
347
348 static void dfp_check_for_VXCVI(struct PPC_DFP *dfp)
349 {
350 if ((dfp->context.status & DEC_Invalid_operation) &&
351 (!decNumberIsSNaN(&dfp->a)) &&
352 (!decNumberIsSNaN(&dfp->b))) {
353 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
354 }
355 }
356
357 static void dfp_set_CRBF_from_T(struct PPC_DFP *dfp)
358 {
359 if (decNumberIsNaN(&dfp->t)) {
360 dfp->crbf = 1;
361 } else if (decNumberIsZero(&dfp->t)) {
362 dfp->crbf = 2;
363 } else if (decNumberIsNegative(&dfp->t)) {
364 dfp->crbf = 8;
365 } else {
366 dfp->crbf = 4;
367 }
368 }
369
370 static void dfp_set_FPCC_from_CRBF(struct PPC_DFP *dfp)
371 {
372 dfp->env->fpscr &= ~(0xF << 12);
373 dfp->env->fpscr |= (dfp->crbf << 12);
374 }
375
376 static inline void dfp_makeQNaN(decNumber *dn)
377 {
378 dn->bits &= ~DECSPECIAL;
379 dn->bits |= DECNAN;
380 }
381
382 static inline int dfp_get_digit(decNumber *dn, int n)
383 {
384 assert(DECDPUN == 3);
385 int unit = n / DECDPUN;
386 int dig = n % DECDPUN;
387 switch (dig) {
388 case 0:
389 return dn->lsu[unit] % 10;
390 case 1:
391 return (dn->lsu[unit] / 10) % 10;
392 case 2:
393 return dn->lsu[unit] / 100;
394 }
395 g_assert_not_reached();
396 }
397
398 #define DFP_HELPER_TAB(op, dnop, postprocs, size) \
399 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
400 { \
401 struct PPC_DFP dfp; \
402 dfp_prepare_decimal##size(&dfp, a, b, env); \
403 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
404 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
405 postprocs(&dfp); \
406 if (size == 64) { \
407 t[0] = dfp.t64[0]; \
408 } else if (size == 128) { \
409 t[0] = dfp.t64[HI_IDX]; \
410 t[1] = dfp.t64[LO_IDX]; \
411 } \
412 }
413
414 static void ADD_PPs(struct PPC_DFP *dfp)
415 {
416 dfp_set_FPRF_from_FRT(dfp);
417 dfp_check_for_OX(dfp);
418 dfp_check_for_UX(dfp);
419 dfp_check_for_XX(dfp);
420 dfp_check_for_VXSNAN(dfp);
421 dfp_check_for_VXISI_add(dfp);
422 }
423
424 DFP_HELPER_TAB(dadd, decNumberAdd, ADD_PPs, 64)
425 DFP_HELPER_TAB(daddq, decNumberAdd, ADD_PPs, 128)
426
427 static void SUB_PPs(struct PPC_DFP *dfp)
428 {
429 dfp_set_FPRF_from_FRT(dfp);
430 dfp_check_for_OX(dfp);
431 dfp_check_for_UX(dfp);
432 dfp_check_for_XX(dfp);
433 dfp_check_for_VXSNAN(dfp);
434 dfp_check_for_VXISI_subtract(dfp);
435 }
436
437 DFP_HELPER_TAB(dsub, decNumberSubtract, SUB_PPs, 64)
438 DFP_HELPER_TAB(dsubq, decNumberSubtract, SUB_PPs, 128)
439
440 static void MUL_PPs(struct PPC_DFP *dfp)
441 {
442 dfp_set_FPRF_from_FRT(dfp);
443 dfp_check_for_OX(dfp);
444 dfp_check_for_UX(dfp);
445 dfp_check_for_XX(dfp);
446 dfp_check_for_VXSNAN(dfp);
447 dfp_check_for_VXIMZ(dfp);
448 }
449
450 DFP_HELPER_TAB(dmul, decNumberMultiply, MUL_PPs, 64)
451 DFP_HELPER_TAB(dmulq, decNumberMultiply, MUL_PPs, 128)
452
453 static void DIV_PPs(struct PPC_DFP *dfp)
454 {
455 dfp_set_FPRF_from_FRT(dfp);
456 dfp_check_for_OX(dfp);
457 dfp_check_for_UX(dfp);
458 dfp_check_for_ZX(dfp);
459 dfp_check_for_XX(dfp);
460 dfp_check_for_VXSNAN(dfp);
461 dfp_check_for_VXZDZ(dfp);
462 dfp_check_for_VXIDI(dfp);
463 }
464
465 DFP_HELPER_TAB(ddiv, decNumberDivide, DIV_PPs, 64)
466 DFP_HELPER_TAB(ddivq, decNumberDivide, DIV_PPs, 128)
467
468 #define DFP_HELPER_BF_AB(op, dnop, postprocs, size) \
469 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
470 { \
471 struct PPC_DFP dfp; \
472 dfp_prepare_decimal##size(&dfp, a, b, env); \
473 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
474 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
475 postprocs(&dfp); \
476 return dfp.crbf; \
477 }
478
479 static void CMPU_PPs(struct PPC_DFP *dfp)
480 {
481 dfp_set_CRBF_from_T(dfp);
482 dfp_set_FPCC_from_CRBF(dfp);
483 dfp_check_for_VXSNAN(dfp);
484 }
485
486 DFP_HELPER_BF_AB(dcmpu, decNumberCompare, CMPU_PPs, 64)
487 DFP_HELPER_BF_AB(dcmpuq, decNumberCompare, CMPU_PPs, 128)
488
489 static void CMPO_PPs(struct PPC_DFP *dfp)
490 {
491 dfp_set_CRBF_from_T(dfp);
492 dfp_set_FPCC_from_CRBF(dfp);
493 dfp_check_for_VXSNAN(dfp);
494 dfp_check_for_VXVC(dfp);
495 }
496
497 DFP_HELPER_BF_AB(dcmpo, decNumberCompare, CMPO_PPs, 64)
498 DFP_HELPER_BF_AB(dcmpoq, decNumberCompare, CMPO_PPs, 128)
499
500 #define DFP_HELPER_TSTDC(op, size) \
501 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
502 { \
503 struct PPC_DFP dfp; \
504 int match = 0; \
505 \
506 dfp_prepare_decimal##size(&dfp, a, 0, env); \
507 \
508 match |= (dcm & 0x20) && decNumberIsZero(&dfp.a); \
509 match |= (dcm & 0x10) && decNumberIsSubnormal(&dfp.a, &dfp.context); \
510 match |= (dcm & 0x08) && decNumberIsNormal(&dfp.a, &dfp.context); \
511 match |= (dcm & 0x04) && decNumberIsInfinite(&dfp.a); \
512 match |= (dcm & 0x02) && decNumberIsQNaN(&dfp.a); \
513 match |= (dcm & 0x01) && decNumberIsSNaN(&dfp.a); \
514 \
515 if (decNumberIsNegative(&dfp.a)) { \
516 dfp.crbf = match ? 0xA : 0x8; \
517 } else { \
518 dfp.crbf = match ? 0x2 : 0x0; \
519 } \
520 \
521 dfp_set_FPCC_from_CRBF(&dfp); \
522 return dfp.crbf; \
523 }
524
525 DFP_HELPER_TSTDC(dtstdc, 64)
526 DFP_HELPER_TSTDC(dtstdcq, 128)
527
528 #define DFP_HELPER_TSTDG(op, size) \
529 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
530 { \
531 struct PPC_DFP dfp; \
532 int minexp, maxexp, nzero_digits, nzero_idx, is_negative, is_zero, \
533 is_extreme_exp, is_subnormal, is_normal, leftmost_is_nonzero, \
534 match; \
535 \
536 dfp_prepare_decimal##size(&dfp, a, 0, env); \
537 \
538 if ((size) == 64) { \
539 minexp = -398; \
540 maxexp = 369; \
541 nzero_digits = 16; \
542 nzero_idx = 5; \
543 } else if ((size) == 128) { \
544 minexp = -6176; \
545 maxexp = 6111; \
546 nzero_digits = 34; \
547 nzero_idx = 11; \
548 } \
549 \
550 is_negative = decNumberIsNegative(&dfp.a); \
551 is_zero = decNumberIsZero(&dfp.a); \
552 is_extreme_exp = (dfp.a.exponent == maxexp) || \
553 (dfp.a.exponent == minexp); \
554 is_subnormal = decNumberIsSubnormal(&dfp.a, &dfp.context); \
555 is_normal = decNumberIsNormal(&dfp.a, &dfp.context); \
556 leftmost_is_nonzero = (dfp.a.digits == nzero_digits) && \
557 (dfp.a.lsu[nzero_idx] != 0); \
558 match = 0; \
559 \
560 match |= (dcm & 0x20) && is_zero && !is_extreme_exp; \
561 match |= (dcm & 0x10) && is_zero && is_extreme_exp; \
562 match |= (dcm & 0x08) && \
563 (is_subnormal || (is_normal && is_extreme_exp)); \
564 match |= (dcm & 0x04) && is_normal && !is_extreme_exp && \
565 !leftmost_is_nonzero; \
566 match |= (dcm & 0x02) && is_normal && !is_extreme_exp && \
567 leftmost_is_nonzero; \
568 match |= (dcm & 0x01) && decNumberIsSpecial(&dfp.a); \
569 \
570 if (is_negative) { \
571 dfp.crbf = match ? 0xA : 0x8; \
572 } else { \
573 dfp.crbf = match ? 0x2 : 0x0; \
574 } \
575 \
576 dfp_set_FPCC_from_CRBF(&dfp); \
577 return dfp.crbf; \
578 }
579
580 DFP_HELPER_TSTDG(dtstdg, 64)
581 DFP_HELPER_TSTDG(dtstdgq, 128)
582
583 #define DFP_HELPER_TSTEX(op, size) \
584 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
585 { \
586 struct PPC_DFP dfp; \
587 int expa, expb, a_is_special, b_is_special; \
588 \
589 dfp_prepare_decimal##size(&dfp, a, b, env); \
590 \
591 expa = dfp.a.exponent; \
592 expb = dfp.b.exponent; \
593 a_is_special = decNumberIsSpecial(&dfp.a); \
594 b_is_special = decNumberIsSpecial(&dfp.b); \
595 \
596 if (a_is_special || b_is_special) { \
597 int atype = a_is_special ? (decNumberIsNaN(&dfp.a) ? 4 : 2) : 1; \
598 int btype = b_is_special ? (decNumberIsNaN(&dfp.b) ? 4 : 2) : 1; \
599 dfp.crbf = (atype ^ btype) ? 0x1 : 0x2; \
600 } else if (expa < expb) { \
601 dfp.crbf = 0x8; \
602 } else if (expa > expb) { \
603 dfp.crbf = 0x4; \
604 } else { \
605 dfp.crbf = 0x2; \
606 } \
607 \
608 dfp_set_FPCC_from_CRBF(&dfp); \
609 return dfp.crbf; \
610 }
611
612 DFP_HELPER_TSTEX(dtstex, 64)
613 DFP_HELPER_TSTEX(dtstexq, 128)
614
615 #define DFP_HELPER_TSTSF(op, size) \
616 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
617 { \
618 struct PPC_DFP dfp; \
619 unsigned k; \
620 \
621 dfp_prepare_decimal##size(&dfp, 0, b, env); \
622 \
623 k = *a & 0x3F; \
624 \
625 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
626 dfp.crbf = 1; \
627 } else if (k == 0) { \
628 dfp.crbf = 4; \
629 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
630 /* Zero has no sig digits */ \
631 dfp.crbf = 4; \
632 } else { \
633 unsigned nsd = dfp.b.digits; \
634 if (k < nsd) { \
635 dfp.crbf = 8; \
636 } else if (k > nsd) { \
637 dfp.crbf = 4; \
638 } else { \
639 dfp.crbf = 2; \
640 } \
641 } \
642 \
643 dfp_set_FPCC_from_CRBF(&dfp); \
644 return dfp.crbf; \
645 }
646
647 DFP_HELPER_TSTSF(dtstsf, 64)
648 DFP_HELPER_TSTSF(dtstsfq, 128)
649
650 #define DFP_HELPER_TSTSFI(op, size) \
651 uint32_t helper_##op(CPUPPCState *env, uint32_t a, uint64_t *b) \
652 { \
653 struct PPC_DFP dfp; \
654 unsigned uim; \
655 \
656 dfp_prepare_decimal##size(&dfp, 0, b, env); \
657 \
658 uim = a & 0x3F; \
659 \
660 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
661 dfp.crbf = 1; \
662 } else if (uim == 0) { \
663 dfp.crbf = 4; \
664 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
665 /* Zero has no sig digits */ \
666 dfp.crbf = 4; \
667 } else { \
668 unsigned nsd = dfp.b.digits; \
669 if (uim < nsd) { \
670 dfp.crbf = 8; \
671 } else if (uim > nsd) { \
672 dfp.crbf = 4; \
673 } else { \
674 dfp.crbf = 2; \
675 } \
676 } \
677 \
678 dfp_set_FPCC_from_CRBF(&dfp); \
679 return dfp.crbf; \
680 }
681
682 DFP_HELPER_TSTSFI(dtstsfi, 64)
683 DFP_HELPER_TSTSFI(dtstsfiq, 128)
684
685 static void QUA_PPs(struct PPC_DFP *dfp)
686 {
687 dfp_set_FPRF_from_FRT(dfp);
688 dfp_check_for_XX(dfp);
689 dfp_check_for_VXSNAN(dfp);
690 dfp_check_for_VXCVI(dfp);
691 }
692
693 static void dfp_quantize(uint8_t rmc, struct PPC_DFP *dfp)
694 {
695 dfp_set_round_mode_from_immediate(0, rmc, dfp);
696 decNumberQuantize(&dfp->t, &dfp->b, &dfp->a, &dfp->context);
697 if (decNumberIsSNaN(&dfp->a)) {
698 dfp->t = dfp->a;
699 dfp_makeQNaN(&dfp->t);
700 } else if (decNumberIsSNaN(&dfp->b)) {
701 dfp->t = dfp->b;
702 dfp_makeQNaN(&dfp->t);
703 } else if (decNumberIsQNaN(&dfp->a)) {
704 dfp->t = dfp->a;
705 } else if (decNumberIsQNaN(&dfp->b)) {
706 dfp->t = dfp->b;
707 }
708 }
709
710 #define DFP_HELPER_QUAI(op, size) \
711 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
712 uint32_t te, uint32_t rmc) \
713 { \
714 struct PPC_DFP dfp; \
715 \
716 dfp_prepare_decimal##size(&dfp, 0, b, env); \
717 \
718 decNumberFromUInt32(&dfp.a, 1); \
719 dfp.a.exponent = (int32_t)((int8_t)(te << 3) >> 3); \
720 \
721 dfp_quantize(rmc, &dfp); \
722 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
723 &dfp.context); \
724 QUA_PPs(&dfp); \
725 \
726 if (size == 64) { \
727 t[0] = dfp.t64[0]; \
728 } else if (size == 128) { \
729 t[0] = dfp.t64[HI_IDX]; \
730 t[1] = dfp.t64[LO_IDX]; \
731 } \
732 }
733
734 DFP_HELPER_QUAI(dquai, 64)
735 DFP_HELPER_QUAI(dquaiq, 128)
736
737 #define DFP_HELPER_QUA(op, size) \
738 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
739 uint64_t *b, uint32_t rmc) \
740 { \
741 struct PPC_DFP dfp; \
742 \
743 dfp_prepare_decimal##size(&dfp, a, b, env); \
744 \
745 dfp_quantize(rmc, &dfp); \
746 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
747 &dfp.context); \
748 QUA_PPs(&dfp); \
749 \
750 if (size == 64) { \
751 t[0] = dfp.t64[0]; \
752 } else if (size == 128) { \
753 t[0] = dfp.t64[HI_IDX]; \
754 t[1] = dfp.t64[LO_IDX]; \
755 } \
756 }
757
758 DFP_HELPER_QUA(dqua, 64)
759 DFP_HELPER_QUA(dquaq, 128)
760
761 static void _dfp_reround(uint8_t rmc, int32_t ref_sig, int32_t xmax,
762 struct PPC_DFP *dfp)
763 {
764 int msd_orig, msd_rslt;
765
766 if (unlikely((ref_sig == 0) || (dfp->b.digits <= ref_sig))) {
767 dfp->t = dfp->b;
768 if (decNumberIsSNaN(&dfp->b)) {
769 dfp_makeQNaN(&dfp->t);
770 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FPSCR_VE);
771 }
772 return;
773 }
774
775 /* Reround is equivalent to quantizing b with 1**E(n) where */
776 /* n = exp(b) + numDigits(b) - reference_significance. */
777
778 decNumberFromUInt32(&dfp->a, 1);
779 dfp->a.exponent = dfp->b.exponent + dfp->b.digits - ref_sig;
780
781 if (unlikely(dfp->a.exponent > xmax)) {
782 dfp->t.digits = 0;
783 dfp->t.bits &= ~DECNEG;
784 dfp_makeQNaN(&dfp->t);
785 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FPSCR_VE);
786 return;
787 }
788
789 dfp_quantize(rmc, dfp);
790
791 msd_orig = dfp_get_digit(&dfp->b, dfp->b.digits-1);
792 msd_rslt = dfp_get_digit(&dfp->t, dfp->t.digits-1);
793
794 /* If the quantization resulted in rounding up to the next magnitude, */
795 /* then we need to shift the significand and adjust the exponent. */
796
797 if (unlikely((msd_orig == 9) && (msd_rslt == 1))) {
798
799 decNumber negone;
800
801 decNumberFromInt32(&negone, -1);
802 decNumberShift(&dfp->t, &dfp->t, &negone, &dfp->context);
803 dfp->t.exponent++;
804
805 if (unlikely(dfp->t.exponent > xmax)) {
806 dfp_makeQNaN(&dfp->t);
807 dfp->t.digits = 0;
808 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
809 /* Inhibit XX in this case */
810 decContextClearStatus(&dfp->context, DEC_Inexact);
811 }
812 }
813 }
814
815 #define DFP_HELPER_RRND(op, size) \
816 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
817 uint64_t *b, uint32_t rmc) \
818 { \
819 struct PPC_DFP dfp; \
820 int32_t ref_sig = *a & 0x3F; \
821 int32_t xmax = ((size) == 64) ? 369 : 6111; \
822 \
823 dfp_prepare_decimal##size(&dfp, 0, b, env); \
824 \
825 _dfp_reround(rmc, ref_sig, xmax, &dfp); \
826 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
827 &dfp.context); \
828 QUA_PPs(&dfp); \
829 \
830 if (size == 64) { \
831 t[0] = dfp.t64[0]; \
832 } else if (size == 128) { \
833 t[0] = dfp.t64[HI_IDX]; \
834 t[1] = dfp.t64[LO_IDX]; \
835 } \
836 }
837
838 DFP_HELPER_RRND(drrnd, 64)
839 DFP_HELPER_RRND(drrndq, 128)
840
841 #define DFP_HELPER_RINT(op, postprocs, size) \
842 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
843 uint32_t r, uint32_t rmc) \
844 { \
845 struct PPC_DFP dfp; \
846 \
847 dfp_prepare_decimal##size(&dfp, 0, b, env); \
848 \
849 dfp_set_round_mode_from_immediate(r, rmc, &dfp); \
850 decNumberToIntegralExact(&dfp.t, &dfp.b, &dfp.context); \
851 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
852 postprocs(&dfp); \
853 \
854 if (size == 64) { \
855 t[0] = dfp.t64[0]; \
856 } else if (size == 128) { \
857 t[0] = dfp.t64[HI_IDX]; \
858 t[1] = dfp.t64[LO_IDX]; \
859 } \
860 }
861
862 static void RINTX_PPs(struct PPC_DFP *dfp)
863 {
864 dfp_set_FPRF_from_FRT(dfp);
865 dfp_check_for_XX(dfp);
866 dfp_check_for_VXSNAN(dfp);
867 }
868
869 DFP_HELPER_RINT(drintx, RINTX_PPs, 64)
870 DFP_HELPER_RINT(drintxq, RINTX_PPs, 128)
871
872 static void RINTN_PPs(struct PPC_DFP *dfp)
873 {
874 dfp_set_FPRF_from_FRT(dfp);
875 dfp_check_for_VXSNAN(dfp);
876 }
877
878 DFP_HELPER_RINT(drintn, RINTN_PPs, 64)
879 DFP_HELPER_RINT(drintnq, RINTN_PPs, 128)
880
881 void helper_dctdp(CPUPPCState *env, uint64_t *t, uint64_t *b)
882 {
883 struct PPC_DFP dfp;
884 uint32_t b_short = *b;
885 dfp_prepare_decimal64(&dfp, 0, 0, env);
886 decimal32ToNumber((decimal32 *)&b_short, &dfp.t);
887 decimal64FromNumber((decimal64 *)t, &dfp.t, &dfp.context);
888 dfp_set_FPRF_from_FRT(&dfp);
889 }
890
891 void helper_dctqpq(CPUPPCState *env, uint64_t *t, uint64_t *b)
892 {
893 struct PPC_DFP dfp;
894 dfp_prepare_decimal128(&dfp, 0, 0, env);
895 decimal64ToNumber((decimal64 *)b, &dfp.t);
896
897 dfp_check_for_VXSNAN_and_convert_to_QNaN(&dfp);
898 dfp_set_FPRF_from_FRT(&dfp);
899
900 decimal128FromNumber((decimal128 *)&dfp.t64, &dfp.t, &dfp.context);
901 t[0] = dfp.t64[HI_IDX];
902 t[1] = dfp.t64[LO_IDX];
903 }
904
905 void helper_drsp(CPUPPCState *env, uint64_t *t, uint64_t *b)
906 {
907 struct PPC_DFP dfp;
908 uint32_t t_short = 0;
909 dfp_prepare_decimal64(&dfp, 0, b, env);
910 decimal32FromNumber((decimal32 *)&t_short, &dfp.b, &dfp.context);
911 decimal32ToNumber((decimal32 *)&t_short, &dfp.t);
912
913 dfp_set_FPRF_from_FRT_short(&dfp);
914 dfp_check_for_OX(&dfp);
915 dfp_check_for_UX(&dfp);
916 dfp_check_for_XX(&dfp);
917
918 *t = t_short;
919 }
920
921 void helper_drdpq(CPUPPCState *env, uint64_t *t, uint64_t *b)
922 {
923 struct PPC_DFP dfp;
924 dfp_prepare_decimal128(&dfp, 0, b, env);
925 decimal64FromNumber((decimal64 *)&dfp.t64, &dfp.b, &dfp.context);
926 decimal64ToNumber((decimal64 *)&dfp.t64, &dfp.t);
927
928 dfp_check_for_VXSNAN_and_convert_to_QNaN(&dfp);
929 dfp_set_FPRF_from_FRT_long(&dfp);
930 dfp_check_for_OX(&dfp);
931 dfp_check_for_UX(&dfp);
932 dfp_check_for_XX(&dfp);
933
934 decimal64FromNumber((decimal64 *)dfp.t64, &dfp.t, &dfp.context);
935 t[0] = dfp.t64[0];
936 t[1] = 0;
937 }
938
939 #define DFP_HELPER_CFFIX(op, size) \
940 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
941 { \
942 struct PPC_DFP dfp; \
943 dfp_prepare_decimal##size(&dfp, 0, b, env); \
944 decNumberFromInt64(&dfp.t, (int64_t)(*b)); \
945 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
946 CFFIX_PPs(&dfp); \
947 \
948 if (size == 64) { \
949 t[0] = dfp.t64[0]; \
950 } else if (size == 128) { \
951 t[0] = dfp.t64[HI_IDX]; \
952 t[1] = dfp.t64[LO_IDX]; \
953 } \
954 }
955
956 static void CFFIX_PPs(struct PPC_DFP *dfp)
957 {
958 dfp_set_FPRF_from_FRT(dfp);
959 dfp_check_for_XX(dfp);
960 }
961
962 DFP_HELPER_CFFIX(dcffix, 64)
963 DFP_HELPER_CFFIX(dcffixq, 128)
964
965 #define DFP_HELPER_CTFIX(op, size) \
966 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
967 { \
968 struct PPC_DFP dfp; \
969 dfp_prepare_decimal##size(&dfp, 0, b, env); \
970 \
971 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
972 uint64_t invalid_flags = FP_VX | FP_VXCVI; \
973 if (decNumberIsInfinite(&dfp.b)) { \
974 dfp.t64[0] = decNumberIsNegative(&dfp.b) ? INT64_MIN : INT64_MAX; \
975 } else { /* NaN */ \
976 dfp.t64[0] = INT64_MIN; \
977 if (decNumberIsSNaN(&dfp.b)) { \
978 invalid_flags |= FP_VXSNAN; \
979 } \
980 } \
981 dfp_set_FPSCR_flag(&dfp, invalid_flags, FP_VE); \
982 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
983 dfp.t64[0] = 0; \
984 } else { \
985 decNumberToIntegralExact(&dfp.b, &dfp.b, &dfp.context); \
986 dfp.t64[0] = decNumberIntegralToInt64(&dfp.b, &dfp.context); \
987 if (decContextTestStatus(&dfp.context, DEC_Invalid_operation)) { \
988 dfp.t64[0] = decNumberIsNegative(&dfp.b) ? INT64_MIN : INT64_MAX; \
989 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FP_VE); \
990 } else { \
991 dfp_check_for_XX(&dfp); \
992 } \
993 } \
994 \
995 *t = dfp.t64[0]; \
996 }
997
998 DFP_HELPER_CTFIX(dctfix, 64)
999 DFP_HELPER_CTFIX(dctfixq, 128)
1000
1001 static inline void dfp_set_bcd_digit_64(uint64_t *t, uint8_t digit,
1002 unsigned n)
1003 {
1004 *t |= ((uint64_t)(digit & 0xF) << (n << 2));
1005 }
1006
1007 static inline void dfp_set_bcd_digit_128(uint64_t *t, uint8_t digit,
1008 unsigned n)
1009 {
1010 t[(n & 0x10) ? HI_IDX : LO_IDX] |=
1011 ((uint64_t)(digit & 0xF) << ((n & 15) << 2));
1012 }
1013
1014 static inline void dfp_set_sign_64(uint64_t *t, uint8_t sgn)
1015 {
1016 *t <<= 4;
1017 *t |= (sgn & 0xF);
1018 }
1019
1020 static inline void dfp_set_sign_128(uint64_t *t, uint8_t sgn)
1021 {
1022 t[HI_IDX] <<= 4;
1023 t[HI_IDX] |= (t[LO_IDX] >> 60);
1024 t[LO_IDX] <<= 4;
1025 t[LO_IDX] |= (sgn & 0xF);
1026 }
1027
1028 #define DFP_HELPER_DEDPD(op, size) \
1029 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, uint32_t sp) \
1030 { \
1031 struct PPC_DFP dfp; \
1032 uint8_t digits[34]; \
1033 int i, N; \
1034 \
1035 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1036 \
1037 decNumberGetBCD(&dfp.b, digits); \
1038 dfp.t64[0] = dfp.t64[1] = 0; \
1039 N = dfp.b.digits; \
1040 \
1041 for (i = 0; (i < N) && (i < (size)/4); i++) { \
1042 dfp_set_bcd_digit_##size(dfp.t64, digits[N-i-1], i); \
1043 } \
1044 \
1045 if (sp & 2) { \
1046 uint8_t sgn; \
1047 \
1048 if (decNumberIsNegative(&dfp.b)) { \
1049 sgn = 0xD; \
1050 } else { \
1051 sgn = ((sp & 1) ? 0xF : 0xC); \
1052 } \
1053 dfp_set_sign_##size(dfp.t64, sgn); \
1054 } \
1055 \
1056 if (size == 64) { \
1057 t[0] = dfp.t64[0]; \
1058 } else if (size == 128) { \
1059 t[0] = dfp.t64[HI_IDX]; \
1060 t[1] = dfp.t64[LO_IDX]; \
1061 } \
1062 }
1063
1064 DFP_HELPER_DEDPD(ddedpd, 64)
1065 DFP_HELPER_DEDPD(ddedpdq, 128)
1066
1067 static inline uint8_t dfp_get_bcd_digit_64(uint64_t *t, unsigned n)
1068 {
1069 return *t >> ((n << 2) & 63) & 15;
1070 }
1071
1072 static inline uint8_t dfp_get_bcd_digit_128(uint64_t *t, unsigned n)
1073 {
1074 return t[(n & 0x10) ? HI_IDX : LO_IDX] >> ((n << 2) & 63) & 15;
1075 }
1076
1077 #define DFP_HELPER_ENBCD(op, size) \
1078 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, uint32_t s) \
1079 { \
1080 struct PPC_DFP dfp; \
1081 uint8_t digits[32]; \
1082 int n = 0, offset = 0, sgn = 0, nonzero = 0; \
1083 \
1084 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1085 \
1086 decNumberZero(&dfp.t); \
1087 \
1088 if (s) { \
1089 uint8_t sgnNibble = dfp_get_bcd_digit_##size(dfp.b64, offset++); \
1090 switch (sgnNibble) { \
1091 case 0xD: \
1092 case 0xB: \
1093 sgn = 1; \
1094 break; \
1095 case 0xC: \
1096 case 0xF: \
1097 case 0xA: \
1098 case 0xE: \
1099 sgn = 0; \
1100 break; \
1101 default: \
1102 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FPSCR_VE); \
1103 return; \
1104 } \
1105 } \
1106 \
1107 while (offset < (size) / 4) { \
1108 n++; \
1109 digits[(size) / 4 - n] = dfp_get_bcd_digit_##size(dfp.b64, offset++); \
1110 if (digits[(size) / 4 - n] > 10) { \
1111 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FPSCR_VE); \
1112 return; \
1113 } else { \
1114 nonzero |= (digits[(size) / 4 - n] > 0); \
1115 } \
1116 } \
1117 \
1118 if (nonzero) { \
1119 decNumberSetBCD(&dfp.t, digits + ((size) / 4) - n, n); \
1120 } \
1121 \
1122 if (s && sgn) { \
1123 dfp.t.bits |= DECNEG; \
1124 } \
1125 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
1126 &dfp.context); \
1127 dfp_set_FPRF_from_FRT(&dfp); \
1128 if ((size) == 64) { \
1129 t[0] = dfp.t64[0]; \
1130 } else if ((size) == 128) { \
1131 t[0] = dfp.t64[HI_IDX]; \
1132 t[1] = dfp.t64[LO_IDX]; \
1133 } \
1134 }
1135
1136 DFP_HELPER_ENBCD(denbcd, 64)
1137 DFP_HELPER_ENBCD(denbcdq, 128)
1138
1139 #define DFP_HELPER_XEX(op, size) \
1140 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
1141 { \
1142 struct PPC_DFP dfp; \
1143 \
1144 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1145 \
1146 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
1147 if (decNumberIsInfinite(&dfp.b)) { \
1148 *t = -1; \
1149 } else if (decNumberIsSNaN(&dfp.b)) { \
1150 *t = -3; \
1151 } else if (decNumberIsQNaN(&dfp.b)) { \
1152 *t = -2; \
1153 } else { \
1154 assert(0); \
1155 } \
1156 } else { \
1157 if ((size) == 64) { \
1158 *t = dfp.b.exponent + 398; \
1159 } else if ((size) == 128) { \
1160 *t = dfp.b.exponent + 6176; \
1161 } else { \
1162 assert(0); \
1163 } \
1164 } \
1165 }
1166
1167 DFP_HELPER_XEX(dxex, 64)
1168 DFP_HELPER_XEX(dxexq, 128)
1169
1170 static void dfp_set_raw_exp_64(uint64_t *t, uint64_t raw)
1171 {
1172 *t &= 0x8003ffffffffffffULL;
1173 *t |= (raw << (63 - 13));
1174 }
1175
1176 static void dfp_set_raw_exp_128(uint64_t *t, uint64_t raw)
1177 {
1178 t[HI_IDX] &= 0x80003fffffffffffULL;
1179 t[HI_IDX] |= (raw << (63 - 17));
1180 }
1181
1182 #define DFP_HELPER_IEX(op, size) \
1183 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
1184 { \
1185 struct PPC_DFP dfp; \
1186 uint64_t raw_qnan, raw_snan, raw_inf, max_exp; \
1187 int bias; \
1188 int64_t exp = *((int64_t *)a); \
1189 \
1190 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1191 \
1192 if ((size) == 64) { \
1193 max_exp = 767; \
1194 raw_qnan = 0x1F00; \
1195 raw_snan = 0x1F80; \
1196 raw_inf = 0x1E00; \
1197 bias = 398; \
1198 } else if ((size) == 128) { \
1199 max_exp = 12287; \
1200 raw_qnan = 0x1f000; \
1201 raw_snan = 0x1f800; \
1202 raw_inf = 0x1e000; \
1203 bias = 6176; \
1204 } else { \
1205 assert(0); \
1206 } \
1207 \
1208 if (unlikely((exp < 0) || (exp > max_exp))) { \
1209 dfp.t64[0] = dfp.b64[0]; \
1210 dfp.t64[1] = dfp.b64[1]; \
1211 if (exp == -1) { \
1212 dfp_set_raw_exp_##size(dfp.t64, raw_inf); \
1213 } else if (exp == -3) { \
1214 dfp_set_raw_exp_##size(dfp.t64, raw_snan); \
1215 } else { \
1216 dfp_set_raw_exp_##size(dfp.t64, raw_qnan); \
1217 } \
1218 } else { \
1219 dfp.t = dfp.b; \
1220 if (unlikely(decNumberIsSpecial(&dfp.t))) { \
1221 dfp.t.bits &= ~DECSPECIAL; \
1222 } \
1223 dfp.t.exponent = exp - bias; \
1224 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
1225 &dfp.context); \
1226 } \
1227 if (size == 64) { \
1228 t[0] = dfp.t64[0]; \
1229 } else if (size == 128) { \
1230 t[0] = dfp.t64[HI_IDX]; \
1231 t[1] = dfp.t64[LO_IDX]; \
1232 } \
1233 }
1234
1235 DFP_HELPER_IEX(diex, 64)
1236 DFP_HELPER_IEX(diexq, 128)
1237
1238 static void dfp_clear_lmd_from_g5msb(uint64_t *t)
1239 {
1240
1241 /* The most significant 5 bits of the PowerPC DFP format combine bits */
1242 /* from the left-most decimal digit (LMD) and the biased exponent. */
1243 /* This routine clears the LMD bits while preserving the exponent */
1244 /* bits. See "Figure 80: Encoding of bits 0:4 of the G field for */
1245 /* Finite Numbers" in the Power ISA for additional details. */
1246
1247 uint64_t g5msb = (*t >> 58) & 0x1F;
1248
1249 if ((g5msb >> 3) < 3) { /* LMD in [0-7] ? */
1250 *t &= ~(7ULL << 58);
1251 } else {
1252 switch (g5msb & 7) {
1253 case 0:
1254 case 1:
1255 g5msb = 0;
1256 break;
1257 case 2:
1258 case 3:
1259 g5msb = 0x8;
1260 break;
1261 case 4:
1262 case 5:
1263 g5msb = 0x10;
1264 break;
1265 case 6:
1266 g5msb = 0x1E;
1267 break;
1268 case 7:
1269 g5msb = 0x1F;
1270 break;
1271 }
1272
1273 *t &= ~(0x1fULL << 58);
1274 *t |= (g5msb << 58);
1275 }
1276 }
1277
1278 #define DFP_HELPER_SHIFT(op, size, shift_left) \
1279 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
1280 uint32_t sh) \
1281 { \
1282 struct PPC_DFP dfp; \
1283 unsigned max_digits = ((size) == 64) ? 16 : 34; \
1284 \
1285 dfp_prepare_decimal##size(&dfp, a, 0, env); \
1286 \
1287 if (sh <= max_digits) { \
1288 \
1289 decNumber shd; \
1290 unsigned special = dfp.a.bits & DECSPECIAL; \
1291 \
1292 if (shift_left) { \
1293 decNumberFromUInt32(&shd, sh); \
1294 } else { \
1295 decNumberFromInt32(&shd, -((int32_t)sh)); \
1296 } \
1297 \
1298 dfp.a.bits &= ~DECSPECIAL; \
1299 decNumberShift(&dfp.t, &dfp.a, &shd, &dfp.context); \
1300 \
1301 dfp.t.bits |= special; \
1302 if (special && (dfp.t.digits >= max_digits)) { \
1303 dfp.t.digits = max_digits - 1; \
1304 } \
1305 \
1306 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
1307 &dfp.context); \
1308 } else { \
1309 if ((size) == 64) { \
1310 dfp.t64[0] = dfp.a64[0] & 0xFFFC000000000000ULL; \
1311 dfp_clear_lmd_from_g5msb(dfp.t64); \
1312 } else { \
1313 dfp.t64[HI_IDX] = dfp.a64[HI_IDX] & \
1314 0xFFFFC00000000000ULL; \
1315 dfp_clear_lmd_from_g5msb(dfp.t64 + HI_IDX); \
1316 dfp.t64[LO_IDX] = 0; \
1317 } \
1318 } \
1319 \
1320 if ((size) == 64) { \
1321 t[0] = dfp.t64[0]; \
1322 } else { \
1323 t[0] = dfp.t64[HI_IDX]; \
1324 t[1] = dfp.t64[LO_IDX]; \
1325 } \
1326 }
1327
1328 DFP_HELPER_SHIFT(dscli, 64, 1)
1329 DFP_HELPER_SHIFT(dscliq, 128, 1)
1330 DFP_HELPER_SHIFT(dscri, 64, 0)
1331 DFP_HELPER_SHIFT(dscriq, 128, 0)
AR7 emulation for QEMU