target-ppc: Fix compiler warning
[qemu.git] / target-ppc / dfp_helper.c
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
38 struct 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
46 static 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
82 static 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
123 static 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
147 static 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 }
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
194 static 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 }
202
203 static 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
247 static void dfp_set_FPRF_from_FRT(struct PPC_DFP *dfp)
248 {
249 dfp_set_FPRF_from_FRT_with_context(dfp, &dfp->context);
250 }
251
252 static 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
259 static 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
266 static 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
273 static 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
280 static 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
287 static 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
294 static 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
303 static 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
312 static 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
325 static void dfp_check_for_VXISI_add(struct PPC_DFP *dfp)
326 {
327 dfp_check_for_VXISI(dfp, 0);
328 }
329
330 static void dfp_check_for_VXISI_subtract(struct PPC_DFP *dfp)
331 {
332 dfp_check_for_VXISI(dfp, 1);
333 }
334
335 static 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
345 static 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
352 static 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
361 static 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
368 static 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
377 static 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
390 static 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
396 static inline void dfp_makeQNaN(decNumber *dn)
397 {
398 dn->bits &= ~DECSPECIAL;
399 dn->bits |= DECNAN;
400 }
401
402 static 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 }
415 g_assert_not_reached();
416 }
417
418 #define DFP_HELPER_TAB(op, dnop, postprocs, size) \
419 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
420 { \
421 struct PPC_DFP dfp; \
422 dfp_prepare_decimal##size(&dfp, a, b, env); \
423 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
424 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
425 postprocs(&dfp); \
426 if (size == 64) { \
427 t[0] = dfp.t64[0]; \
428 } else if (size == 128) { \
429 t[0] = dfp.t64[HI_IDX]; \
430 t[1] = dfp.t64[LO_IDX]; \
431 } \
432 }
433
434 static void ADD_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_XX(dfp);
440 dfp_check_for_VXSNAN(dfp);
441 dfp_check_for_VXISI_add(dfp);
442 }
443
444 DFP_HELPER_TAB(dadd, decNumberAdd, ADD_PPs, 64)
445 DFP_HELPER_TAB(daddq, decNumberAdd, ADD_PPs, 128)
446
447 static void SUB_PPs(struct PPC_DFP *dfp)
448 {
449 dfp_set_FPRF_from_FRT(dfp);
450 dfp_check_for_OX(dfp);
451 dfp_check_for_UX(dfp);
452 dfp_check_for_XX(dfp);
453 dfp_check_for_VXSNAN(dfp);
454 dfp_check_for_VXISI_subtract(dfp);
455 }
456
457 DFP_HELPER_TAB(dsub, decNumberSubtract, SUB_PPs, 64)
458 DFP_HELPER_TAB(dsubq, decNumberSubtract, SUB_PPs, 128)
459
460 static void MUL_PPs(struct PPC_DFP *dfp)
461 {
462 dfp_set_FPRF_from_FRT(dfp);
463 dfp_check_for_OX(dfp);
464 dfp_check_for_UX(dfp);
465 dfp_check_for_XX(dfp);
466 dfp_check_for_VXSNAN(dfp);
467 dfp_check_for_VXIMZ(dfp);
468 }
469
470 DFP_HELPER_TAB(dmul, decNumberMultiply, MUL_PPs, 64)
471 DFP_HELPER_TAB(dmulq, decNumberMultiply, MUL_PPs, 128)
472
473 static void DIV_PPs(struct PPC_DFP *dfp)
474 {
475 dfp_set_FPRF_from_FRT(dfp);
476 dfp_check_for_OX(dfp);
477 dfp_check_for_UX(dfp);
478 dfp_check_for_ZX(dfp);
479 dfp_check_for_XX(dfp);
480 dfp_check_for_VXSNAN(dfp);
481 dfp_check_for_VXZDZ(dfp);
482 dfp_check_for_VXIDI(dfp);
483 }
484
485 DFP_HELPER_TAB(ddiv, decNumberDivide, DIV_PPs, 64)
486 DFP_HELPER_TAB(ddivq, decNumberDivide, DIV_PPs, 128)
487
488 #define DFP_HELPER_BF_AB(op, dnop, postprocs, size) \
489 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
490 { \
491 struct PPC_DFP dfp; \
492 dfp_prepare_decimal##size(&dfp, a, b, env); \
493 dnop(&dfp.t, &dfp.a, &dfp.b, &dfp.context); \
494 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
495 postprocs(&dfp); \
496 return dfp.crbf; \
497 }
498
499 static void CMPU_PPs(struct PPC_DFP *dfp)
500 {
501 dfp_set_CRBF_from_T(dfp);
502 dfp_set_FPCC_from_CRBF(dfp);
503 dfp_check_for_VXSNAN(dfp);
504 }
505
506 DFP_HELPER_BF_AB(dcmpu, decNumberCompare, CMPU_PPs, 64)
507 DFP_HELPER_BF_AB(dcmpuq, decNumberCompare, CMPU_PPs, 128)
508
509 static void CMPO_PPs(struct PPC_DFP *dfp)
510 {
511 dfp_set_CRBF_from_T(dfp);
512 dfp_set_FPCC_from_CRBF(dfp);
513 dfp_check_for_VXSNAN(dfp);
514 dfp_check_for_VXVC(dfp);
515 }
516
517 DFP_HELPER_BF_AB(dcmpo, decNumberCompare, CMPO_PPs, 64)
518 DFP_HELPER_BF_AB(dcmpoq, decNumberCompare, CMPO_PPs, 128)
519
520 #define DFP_HELPER_TSTDC(op, size) \
521 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
522 { \
523 struct PPC_DFP dfp; \
524 int match = 0; \
525 \
526 dfp_prepare_decimal##size(&dfp, a, 0, env); \
527 \
528 match |= (dcm & 0x20) && decNumberIsZero(&dfp.a); \
529 match |= (dcm & 0x10) && decNumberIsSubnormal(&dfp.a, &dfp.context); \
530 match |= (dcm & 0x08) && decNumberIsNormal(&dfp.a, &dfp.context); \
531 match |= (dcm & 0x04) && decNumberIsInfinite(&dfp.a); \
532 match |= (dcm & 0x02) && decNumberIsQNaN(&dfp.a); \
533 match |= (dcm & 0x01) && decNumberIsSNaN(&dfp.a); \
534 \
535 if (decNumberIsNegative(&dfp.a)) { \
536 dfp.crbf = match ? 0xA : 0x8; \
537 } else { \
538 dfp.crbf = match ? 0x2 : 0x0; \
539 } \
540 \
541 dfp_set_FPCC_from_CRBF(&dfp); \
542 return dfp.crbf; \
543 }
544
545 DFP_HELPER_TSTDC(dtstdc, 64)
546 DFP_HELPER_TSTDC(dtstdcq, 128)
547
548 #define DFP_HELPER_TSTDG(op, size) \
549 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint32_t dcm) \
550 { \
551 struct PPC_DFP dfp; \
552 int minexp, maxexp, nzero_digits, nzero_idx, is_negative, is_zero, \
553 is_extreme_exp, is_subnormal, is_normal, leftmost_is_nonzero, \
554 match; \
555 \
556 dfp_prepare_decimal##size(&dfp, a, 0, env); \
557 \
558 if ((size) == 64) { \
559 minexp = -398; \
560 maxexp = 369; \
561 nzero_digits = 16; \
562 nzero_idx = 5; \
563 } else if ((size) == 128) { \
564 minexp = -6176; \
565 maxexp = 6111; \
566 nzero_digits = 34; \
567 nzero_idx = 11; \
568 } \
569 \
570 is_negative = decNumberIsNegative(&dfp.a); \
571 is_zero = decNumberIsZero(&dfp.a); \
572 is_extreme_exp = (dfp.a.exponent == maxexp) || \
573 (dfp.a.exponent == minexp); \
574 is_subnormal = decNumberIsSubnormal(&dfp.a, &dfp.context); \
575 is_normal = decNumberIsNormal(&dfp.a, &dfp.context); \
576 leftmost_is_nonzero = (dfp.a.digits == nzero_digits) && \
577 (dfp.a.lsu[nzero_idx] != 0); \
578 match = 0; \
579 \
580 match |= (dcm & 0x20) && is_zero && !is_extreme_exp; \
581 match |= (dcm & 0x10) && is_zero && is_extreme_exp; \
582 match |= (dcm & 0x08) && \
583 (is_subnormal || (is_normal && is_extreme_exp)); \
584 match |= (dcm & 0x04) && is_normal && !is_extreme_exp && \
585 !leftmost_is_nonzero; \
586 match |= (dcm & 0x02) && is_normal && !is_extreme_exp && \
587 leftmost_is_nonzero; \
588 match |= (dcm & 0x01) && decNumberIsSpecial(&dfp.a); \
589 \
590 if (is_negative) { \
591 dfp.crbf = match ? 0xA : 0x8; \
592 } else { \
593 dfp.crbf = match ? 0x2 : 0x0; \
594 } \
595 \
596 dfp_set_FPCC_from_CRBF(&dfp); \
597 return dfp.crbf; \
598 }
599
600 DFP_HELPER_TSTDG(dtstdg, 64)
601 DFP_HELPER_TSTDG(dtstdgq, 128)
602
603 #define DFP_HELPER_TSTEX(op, size) \
604 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
605 { \
606 struct PPC_DFP dfp; \
607 int expa, expb, a_is_special, b_is_special; \
608 \
609 dfp_prepare_decimal##size(&dfp, a, b, env); \
610 \
611 expa = dfp.a.exponent; \
612 expb = dfp.b.exponent; \
613 a_is_special = decNumberIsSpecial(&dfp.a); \
614 b_is_special = decNumberIsSpecial(&dfp.b); \
615 \
616 if (a_is_special || b_is_special) { \
617 int atype = a_is_special ? (decNumberIsNaN(&dfp.a) ? 4 : 2) : 1; \
618 int btype = b_is_special ? (decNumberIsNaN(&dfp.b) ? 4 : 2) : 1; \
619 dfp.crbf = (atype ^ btype) ? 0x1 : 0x2; \
620 } else if (expa < expb) { \
621 dfp.crbf = 0x8; \
622 } else if (expa > expb) { \
623 dfp.crbf = 0x4; \
624 } else { \
625 dfp.crbf = 0x2; \
626 } \
627 \
628 dfp_set_FPCC_from_CRBF(&dfp); \
629 return dfp.crbf; \
630 }
631
632 DFP_HELPER_TSTEX(dtstex, 64)
633 DFP_HELPER_TSTEX(dtstexq, 128)
634
635 #define DFP_HELPER_TSTSF(op, size) \
636 uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
637 { \
638 struct PPC_DFP dfp; \
639 unsigned k; \
640 \
641 dfp_prepare_decimal##size(&dfp, 0, b, env); \
642 \
643 k = *a & 0x3F; \
644 \
645 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
646 dfp.crbf = 1; \
647 } else if (k == 0) { \
648 dfp.crbf = 4; \
649 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
650 /* Zero has no sig digits */ \
651 dfp.crbf = 4; \
652 } else { \
653 unsigned nsd = dfp.b.digits; \
654 if (k < nsd) { \
655 dfp.crbf = 8; \
656 } else if (k > nsd) { \
657 dfp.crbf = 4; \
658 } else { \
659 dfp.crbf = 2; \
660 } \
661 } \
662 \
663 dfp_set_FPCC_from_CRBF(&dfp); \
664 return dfp.crbf; \
665 }
666
667 DFP_HELPER_TSTSF(dtstsf, 64)
668 DFP_HELPER_TSTSF(dtstsfq, 128)
669
670 static void QUA_PPs(struct PPC_DFP *dfp)
671 {
672 dfp_set_FPRF_from_FRT(dfp);
673 dfp_check_for_XX(dfp);
674 dfp_check_for_VXSNAN(dfp);
675 dfp_check_for_VXCVI(dfp);
676 }
677
678 static void dfp_quantize(uint8_t rmc, struct PPC_DFP *dfp)
679 {
680 dfp_set_round_mode_from_immediate(0, rmc, dfp);
681 decNumberQuantize(&dfp->t, &dfp->b, &dfp->a, &dfp->context);
682 if (decNumberIsSNaN(&dfp->a)) {
683 dfp->t = dfp->a;
684 dfp_makeQNaN(&dfp->t);
685 } else if (decNumberIsSNaN(&dfp->b)) {
686 dfp->t = dfp->b;
687 dfp_makeQNaN(&dfp->t);
688 } else if (decNumberIsQNaN(&dfp->a)) {
689 dfp->t = dfp->a;
690 } else if (decNumberIsQNaN(&dfp->b)) {
691 dfp->t = dfp->b;
692 }
693 }
694
695 #define DFP_HELPER_QUAI(op, size) \
696 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
697 uint32_t te, uint32_t rmc) \
698 { \
699 struct PPC_DFP dfp; \
700 \
701 dfp_prepare_decimal##size(&dfp, 0, b, env); \
702 \
703 decNumberFromUInt32(&dfp.a, 1); \
704 dfp.a.exponent = (int32_t)((int8_t)(te << 3) >> 3); \
705 \
706 dfp_quantize(rmc, &dfp); \
707 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
708 &dfp.context); \
709 QUA_PPs(&dfp); \
710 \
711 if (size == 64) { \
712 t[0] = dfp.t64[0]; \
713 } else if (size == 128) { \
714 t[0] = dfp.t64[HI_IDX]; \
715 t[1] = dfp.t64[LO_IDX]; \
716 } \
717 }
718
719 DFP_HELPER_QUAI(dquai, 64)
720 DFP_HELPER_QUAI(dquaiq, 128)
721
722 #define DFP_HELPER_QUA(op, size) \
723 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
724 uint64_t *b, uint32_t rmc) \
725 { \
726 struct PPC_DFP dfp; \
727 \
728 dfp_prepare_decimal##size(&dfp, a, b, env); \
729 \
730 dfp_quantize(rmc, &dfp); \
731 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
732 &dfp.context); \
733 QUA_PPs(&dfp); \
734 \
735 if (size == 64) { \
736 t[0] = dfp.t64[0]; \
737 } else if (size == 128) { \
738 t[0] = dfp.t64[HI_IDX]; \
739 t[1] = dfp.t64[LO_IDX]; \
740 } \
741 }
742
743 DFP_HELPER_QUA(dqua, 64)
744 DFP_HELPER_QUA(dquaq, 128)
745
746 static void _dfp_reround(uint8_t rmc, int32_t ref_sig, int32_t xmax,
747 struct PPC_DFP *dfp)
748 {
749 int msd_orig, msd_rslt;
750
751 if (unlikely((ref_sig == 0) || (dfp->b.digits <= ref_sig))) {
752 dfp->t = dfp->b;
753 if (decNumberIsSNaN(&dfp->b)) {
754 dfp_makeQNaN(&dfp->t);
755 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXSNAN, FPSCR_VE);
756 }
757 return;
758 }
759
760 /* Reround is equivalent to quantizing b with 1**E(n) where */
761 /* n = exp(b) + numDigits(b) - reference_significance. */
762
763 decNumberFromUInt32(&dfp->a, 1);
764 dfp->a.exponent = dfp->b.exponent + dfp->b.digits - ref_sig;
765
766 if (unlikely(dfp->a.exponent > xmax)) {
767 dfp->t.digits = 0;
768 dfp->t.bits &= ~DECNEG;
769 dfp_makeQNaN(&dfp->t);
770 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FPSCR_VE);
771 return;
772 }
773
774 dfp_quantize(rmc, dfp);
775
776 msd_orig = dfp_get_digit(&dfp->b, dfp->b.digits-1);
777 msd_rslt = dfp_get_digit(&dfp->t, dfp->t.digits-1);
778
779 /* If the quantization resulted in rounding up to the next magnitude, */
780 /* then we need to shift the significand and adjust the exponent. */
781
782 if (unlikely((msd_orig == 9) && (msd_rslt == 1))) {
783
784 decNumber negone;
785
786 decNumberFromInt32(&negone, -1);
787 decNumberShift(&dfp->t, &dfp->t, &negone, &dfp->context);
788 dfp->t.exponent++;
789
790 if (unlikely(dfp->t.exponent > xmax)) {
791 dfp_makeQNaN(&dfp->t);
792 dfp->t.digits = 0;
793 dfp_set_FPSCR_flag(dfp, FP_VX | FP_VXCVI, FP_VE);
794 /* Inhibit XX in this case */
795 decContextClearStatus(&dfp->context, DEC_Inexact);
796 }
797 }
798 }
799
800 #define DFP_HELPER_RRND(op, size) \
801 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
802 uint64_t *b, uint32_t rmc) \
803 { \
804 struct PPC_DFP dfp; \
805 int32_t ref_sig = *a & 0x3F; \
806 int32_t xmax = ((size) == 64) ? 369 : 6111; \
807 \
808 dfp_prepare_decimal##size(&dfp, 0, b, env); \
809 \
810 _dfp_reround(rmc, ref_sig, xmax, &dfp); \
811 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
812 &dfp.context); \
813 QUA_PPs(&dfp); \
814 \
815 if (size == 64) { \
816 t[0] = dfp.t64[0]; \
817 } else if (size == 128) { \
818 t[0] = dfp.t64[HI_IDX]; \
819 t[1] = dfp.t64[LO_IDX]; \
820 } \
821 }
822
823 DFP_HELPER_RRND(drrnd, 64)
824 DFP_HELPER_RRND(drrndq, 128)
825
826 #define DFP_HELPER_RINT(op, postprocs, size) \
827 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, \
828 uint32_t r, uint32_t rmc) \
829 { \
830 struct PPC_DFP dfp; \
831 \
832 dfp_prepare_decimal##size(&dfp, 0, b, env); \
833 \
834 dfp_set_round_mode_from_immediate(r, rmc, &dfp); \
835 decNumberToIntegralExact(&dfp.t, &dfp.b, &dfp.context); \
836 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
837 postprocs(&dfp); \
838 \
839 if (size == 64) { \
840 t[0] = dfp.t64[0]; \
841 } else if (size == 128) { \
842 t[0] = dfp.t64[HI_IDX]; \
843 t[1] = dfp.t64[LO_IDX]; \
844 } \
845 }
846
847 static void RINTX_PPs(struct PPC_DFP *dfp)
848 {
849 dfp_set_FPRF_from_FRT(dfp);
850 dfp_check_for_XX(dfp);
851 dfp_check_for_VXSNAN(dfp);
852 }
853
854 DFP_HELPER_RINT(drintx, RINTX_PPs, 64)
855 DFP_HELPER_RINT(drintxq, RINTX_PPs, 128)
856
857 static void RINTN_PPs(struct PPC_DFP *dfp)
858 {
859 dfp_set_FPRF_from_FRT(dfp);
860 dfp_check_for_VXSNAN(dfp);
861 }
862
863 DFP_HELPER_RINT(drintn, RINTN_PPs, 64)
864 DFP_HELPER_RINT(drintnq, RINTN_PPs, 128)
865
866 void helper_dctdp(CPUPPCState *env, uint64_t *t, uint64_t *b)
867 {
868 struct PPC_DFP dfp;
869 uint32_t b_short = *b;
870 dfp_prepare_decimal64(&dfp, 0, 0, env);
871 decimal32ToNumber((decimal32 *)&b_short, &dfp.t);
872 decimal64FromNumber((decimal64 *)t, &dfp.t, &dfp.context);
873 dfp_set_FPRF_from_FRT(&dfp);
874 }
875
876 void helper_dctqpq(CPUPPCState *env, uint64_t *t, uint64_t *b)
877 {
878 struct PPC_DFP dfp;
879 dfp_prepare_decimal128(&dfp, 0, 0, env);
880 decimal64ToNumber((decimal64 *)b, &dfp.t);
881
882 dfp_check_for_VXSNAN_and_convert_to_QNaN(&dfp);
883 dfp_set_FPRF_from_FRT(&dfp);
884
885 decimal128FromNumber((decimal128 *)&dfp.t64, &dfp.t, &dfp.context);
886 t[0] = dfp.t64[HI_IDX];
887 t[1] = dfp.t64[LO_IDX];
888 }
889
890 void helper_drsp(CPUPPCState *env, uint64_t *t, uint64_t *b)
891 {
892 struct PPC_DFP dfp;
893 uint32_t t_short = 0;
894 dfp_prepare_decimal64(&dfp, 0, b, env);
895 decimal32FromNumber((decimal32 *)&t_short, &dfp.b, &dfp.context);
896 decimal32ToNumber((decimal32 *)&t_short, &dfp.t);
897
898 dfp_set_FPRF_from_FRT_short(&dfp);
899 dfp_check_for_OX(&dfp);
900 dfp_check_for_UX(&dfp);
901 dfp_check_for_XX(&dfp);
902
903 *t = t_short;
904 }
905
906 void helper_drdpq(CPUPPCState *env, uint64_t *t, uint64_t *b)
907 {
908 struct PPC_DFP dfp;
909 dfp_prepare_decimal128(&dfp, 0, b, env);
910 decimal64FromNumber((decimal64 *)&dfp.t64, &dfp.b, &dfp.context);
911 decimal64ToNumber((decimal64 *)&dfp.t64, &dfp.t);
912
913 dfp_check_for_VXSNAN_and_convert_to_QNaN(&dfp);
914 dfp_set_FPRF_from_FRT_long(&dfp);
915 dfp_check_for_OX(&dfp);
916 dfp_check_for_UX(&dfp);
917 dfp_check_for_XX(&dfp);
918
919 decimal64FromNumber((decimal64 *)dfp.t64, &dfp.t, &dfp.context);
920 t[0] = dfp.t64[0];
921 t[1] = 0;
922 }
923
924 #define DFP_HELPER_CFFIX(op, size) \
925 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
926 { \
927 struct PPC_DFP dfp; \
928 dfp_prepare_decimal##size(&dfp, 0, b, env); \
929 decNumberFromInt64(&dfp.t, (int64_t)(*b)); \
930 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, &dfp.context); \
931 CFFIX_PPs(&dfp); \
932 \
933 if (size == 64) { \
934 t[0] = dfp.t64[0]; \
935 } else if (size == 128) { \
936 t[0] = dfp.t64[HI_IDX]; \
937 t[1] = dfp.t64[LO_IDX]; \
938 } \
939 }
940
941 static void CFFIX_PPs(struct PPC_DFP *dfp)
942 {
943 dfp_set_FPRF_from_FRT(dfp);
944 dfp_check_for_XX(dfp);
945 }
946
947 DFP_HELPER_CFFIX(dcffix, 64)
948 DFP_HELPER_CFFIX(dcffixq, 128)
949
950 #define DFP_HELPER_CTFIX(op, size) \
951 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
952 { \
953 struct PPC_DFP dfp; \
954 dfp_prepare_decimal##size(&dfp, 0, b, env); \
955 \
956 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
957 uint64_t invalid_flags = FP_VX | FP_VXCVI; \
958 if (decNumberIsInfinite(&dfp.b)) { \
959 dfp.t64[0] = decNumberIsNegative(&dfp.b) ? INT64_MIN : INT64_MAX; \
960 } else { /* NaN */ \
961 dfp.t64[0] = INT64_MIN; \
962 if (decNumberIsSNaN(&dfp.b)) { \
963 invalid_flags |= FP_VXSNAN; \
964 } \
965 } \
966 dfp_set_FPSCR_flag(&dfp, invalid_flags, FP_VE); \
967 } else if (unlikely(decNumberIsZero(&dfp.b))) { \
968 dfp.t64[0] = 0; \
969 } else { \
970 decNumberToIntegralExact(&dfp.b, &dfp.b, &dfp.context); \
971 dfp.t64[0] = decNumberIntegralToInt64(&dfp.b, &dfp.context); \
972 if (decContextTestStatus(&dfp.context, DEC_Invalid_operation)) { \
973 dfp.t64[0] = decNumberIsNegative(&dfp.b) ? INT64_MIN : INT64_MAX; \
974 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FP_VE); \
975 } else { \
976 dfp_check_for_XX(&dfp); \
977 } \
978 } \
979 \
980 *t = dfp.t64[0]; \
981 }
982
983 DFP_HELPER_CTFIX(dctfix, 64)
984 DFP_HELPER_CTFIX(dctfixq, 128)
985
986 static inline void dfp_set_bcd_digit_64(uint64_t *t, uint8_t digit,
987 unsigned n)
988 {
989 *t |= ((uint64_t)(digit & 0xF) << (n << 2));
990 }
991
992 static inline void dfp_set_bcd_digit_128(uint64_t *t, uint8_t digit,
993 unsigned n)
994 {
995 t[(n & 0x10) ? HI_IDX : LO_IDX] |=
996 ((uint64_t)(digit & 0xF) << ((n & 15) << 2));
997 }
998
999 static inline void dfp_set_sign_64(uint64_t *t, uint8_t sgn)
1000 {
1001 *t <<= 4;
1002 *t |= (sgn & 0xF);
1003 }
1004
1005 static inline void dfp_set_sign_128(uint64_t *t, uint8_t sgn)
1006 {
1007 t[HI_IDX] <<= 4;
1008 t[HI_IDX] |= (t[LO_IDX] >> 60);
1009 t[LO_IDX] <<= 4;
1010 t[LO_IDX] |= (sgn & 0xF);
1011 }
1012
1013 #define DFP_HELPER_DEDPD(op, size) \
1014 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, uint32_t sp) \
1015 { \
1016 struct PPC_DFP dfp; \
1017 uint8_t digits[34]; \
1018 int i, N; \
1019 \
1020 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1021 \
1022 decNumberGetBCD(&dfp.b, digits); \
1023 dfp.t64[0] = dfp.t64[1] = 0; \
1024 N = dfp.b.digits; \
1025 \
1026 for (i = 0; (i < N) && (i < (size)/4); i++) { \
1027 dfp_set_bcd_digit_##size(dfp.t64, digits[N-i-1], i); \
1028 } \
1029 \
1030 if (sp & 2) { \
1031 uint8_t sgn; \
1032 \
1033 if (decNumberIsNegative(&dfp.b)) { \
1034 sgn = 0xD; \
1035 } else { \
1036 sgn = ((sp & 1) ? 0xF : 0xC); \
1037 } \
1038 dfp_set_sign_##size(dfp.t64, sgn); \
1039 } \
1040 \
1041 if (size == 64) { \
1042 t[0] = dfp.t64[0]; \
1043 } else if (size == 128) { \
1044 t[0] = dfp.t64[HI_IDX]; \
1045 t[1] = dfp.t64[LO_IDX]; \
1046 } \
1047 }
1048
1049 DFP_HELPER_DEDPD(ddedpd, 64)
1050 DFP_HELPER_DEDPD(ddedpdq, 128)
1051
1052 static inline uint8_t dfp_get_bcd_digit_64(uint64_t *t, unsigned n)
1053 {
1054 return *t >> ((n << 2) & 63) & 15;
1055 }
1056
1057 static inline uint8_t dfp_get_bcd_digit_128(uint64_t *t, unsigned n)
1058 {
1059 return t[(n & 0x10) ? HI_IDX : LO_IDX] >> ((n << 2) & 63) & 15;
1060 }
1061
1062 #define DFP_HELPER_ENBCD(op, size) \
1063 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b, uint32_t s) \
1064 { \
1065 struct PPC_DFP dfp; \
1066 uint8_t digits[32]; \
1067 int n = 0, offset = 0, sgn = 0, nonzero = 0; \
1068 \
1069 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1070 \
1071 decNumberZero(&dfp.t); \
1072 \
1073 if (s) { \
1074 uint8_t sgnNibble = dfp_get_bcd_digit_##size(dfp.b64, offset++); \
1075 switch (sgnNibble) { \
1076 case 0xD: \
1077 case 0xB: \
1078 sgn = 1; \
1079 break; \
1080 case 0xC: \
1081 case 0xF: \
1082 case 0xA: \
1083 case 0xE: \
1084 sgn = 0; \
1085 break; \
1086 default: \
1087 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FPSCR_VE); \
1088 return; \
1089 } \
1090 } \
1091 \
1092 while (offset < (size)/4) { \
1093 n++; \
1094 digits[(size)/4-n] = dfp_get_bcd_digit_##size(dfp.b64, offset++); \
1095 if (digits[(size)/4-n] > 10) { \
1096 dfp_set_FPSCR_flag(&dfp, FP_VX | FP_VXCVI, FPSCR_VE); \
1097 return; \
1098 } else { \
1099 nonzero |= (digits[(size)/4-n] > 0); \
1100 } \
1101 } \
1102 \
1103 if (nonzero) { \
1104 decNumberSetBCD(&dfp.t, digits+((size)/4)-n, n); \
1105 } \
1106 \
1107 if (s && sgn) { \
1108 dfp.t.bits |= DECNEG; \
1109 } \
1110 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
1111 &dfp.context); \
1112 dfp_set_FPRF_from_FRT(&dfp); \
1113 if ((size) == 64) { \
1114 t[0] = dfp.t64[0]; \
1115 } else if ((size) == 128) { \
1116 t[0] = dfp.t64[HI_IDX]; \
1117 t[1] = dfp.t64[LO_IDX]; \
1118 } \
1119 }
1120
1121 DFP_HELPER_ENBCD(denbcd, 64)
1122 DFP_HELPER_ENBCD(denbcdq, 128)
1123
1124 #define DFP_HELPER_XEX(op, size) \
1125 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *b) \
1126 { \
1127 struct PPC_DFP dfp; \
1128 \
1129 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1130 \
1131 if (unlikely(decNumberIsSpecial(&dfp.b))) { \
1132 if (decNumberIsInfinite(&dfp.b)) { \
1133 *t = -1; \
1134 } else if (decNumberIsSNaN(&dfp.b)) { \
1135 *t = -3; \
1136 } else if (decNumberIsQNaN(&dfp.b)) { \
1137 *t = -2; \
1138 } else { \
1139 assert(0); \
1140 } \
1141 } else { \
1142 if ((size) == 64) { \
1143 *t = dfp.b.exponent + 398; \
1144 } else if ((size) == 128) { \
1145 *t = dfp.b.exponent + 6176; \
1146 } else { \
1147 assert(0); \
1148 } \
1149 } \
1150 }
1151
1152 DFP_HELPER_XEX(dxex, 64)
1153 DFP_HELPER_XEX(dxexq, 128)
1154
1155 static void dfp_set_raw_exp_64(uint64_t *t, uint64_t raw)
1156 {
1157 *t &= 0x8003ffffffffffffULL;
1158 *t |= (raw << (63-13));
1159 }
1160
1161 static void dfp_set_raw_exp_128(uint64_t *t, uint64_t raw)
1162 {
1163 t[HI_IDX] &= 0x80003fffffffffffULL;
1164 t[HI_IDX] |= (raw << (63-17));
1165 }
1166
1167 #define DFP_HELPER_IEX(op, size) \
1168 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, uint64_t *b) \
1169 { \
1170 struct PPC_DFP dfp; \
1171 uint64_t raw_qnan, raw_snan, raw_inf, max_exp; \
1172 int bias; \
1173 int64_t exp = *((int64_t *)a); \
1174 \
1175 dfp_prepare_decimal##size(&dfp, 0, b, env); \
1176 \
1177 if ((size) == 64) { \
1178 max_exp = 767; \
1179 raw_qnan = 0x1F00; \
1180 raw_snan = 0x1F80; \
1181 raw_inf = 0x1E00; \
1182 bias = 398; \
1183 } else if ((size) == 128) { \
1184 max_exp = 12287; \
1185 raw_qnan = 0x1f000; \
1186 raw_snan = 0x1f800; \
1187 raw_inf = 0x1e000; \
1188 bias = 6176; \
1189 } else { \
1190 assert(0); \
1191 } \
1192 \
1193 if (unlikely((exp < 0) || (exp > max_exp))) { \
1194 dfp.t64[0] = dfp.b64[0]; \
1195 dfp.t64[1] = dfp.b64[1]; \
1196 if (exp == -1) { \
1197 dfp_set_raw_exp_##size(dfp.t64, raw_inf); \
1198 } else if (exp == -3) { \
1199 dfp_set_raw_exp_##size(dfp.t64, raw_snan); \
1200 } else { \
1201 dfp_set_raw_exp_##size(dfp.t64, raw_qnan); \
1202 } \
1203 } else { \
1204 dfp.t = dfp.b; \
1205 if (unlikely(decNumberIsSpecial(&dfp.t))) { \
1206 dfp.t.bits &= ~DECSPECIAL; \
1207 } \
1208 dfp.t.exponent = exp - bias; \
1209 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
1210 &dfp.context); \
1211 } \
1212 if (size == 64) { \
1213 t[0] = dfp.t64[0]; \
1214 } else if (size == 128) { \
1215 t[0] = dfp.t64[HI_IDX]; \
1216 t[1] = dfp.t64[LO_IDX]; \
1217 } \
1218 }
1219
1220 DFP_HELPER_IEX(diex, 64)
1221 DFP_HELPER_IEX(diexq, 128)
1222
1223 static void dfp_clear_lmd_from_g5msb(uint64_t *t)
1224 {
1225
1226 /* The most significant 5 bits of the PowerPC DFP format combine bits */
1227 /* from the left-most decimal digit (LMD) and the biased exponent. */
1228 /* This routine clears the LMD bits while preserving the exponent */
1229 /* bits. See "Figure 80: Encoding of bits 0:4 of the G field for */
1230 /* Finite Numbers" in the Power ISA for additional details. */
1231
1232 uint64_t g5msb = (*t >> 58) & 0x1F;
1233
1234 if ((g5msb >> 3) < 3) { /* LMD in [0-7] ? */
1235 *t &= ~(7ULL << 58);
1236 } else {
1237 switch (g5msb & 7) {
1238 case 0:
1239 case 1:
1240 g5msb = 0;
1241 break;
1242 case 2:
1243 case 3:
1244 g5msb = 0x8;
1245 break;
1246 case 4:
1247 case 5:
1248 g5msb = 0x10;
1249 break;
1250 case 6:
1251 g5msb = 0x1E;
1252 break;
1253 case 7:
1254 g5msb = 0x1F;
1255 break;
1256 }
1257
1258 *t &= ~(0x1fULL << 58);
1259 *t |= (g5msb << 58);
1260 }
1261 }
1262
1263 #define DFP_HELPER_SHIFT(op, size, shift_left) \
1264 void helper_##op(CPUPPCState *env, uint64_t *t, uint64_t *a, \
1265 uint32_t sh) \
1266 { \
1267 struct PPC_DFP dfp; \
1268 unsigned max_digits = ((size) == 64) ? 16 : 34; \
1269 \
1270 dfp_prepare_decimal##size(&dfp, a, 0, env); \
1271 \
1272 if (sh <= max_digits) { \
1273 \
1274 decNumber shd; \
1275 unsigned special = dfp.a.bits & DECSPECIAL; \
1276 \
1277 if (shift_left) { \
1278 decNumberFromUInt32(&shd, sh); \
1279 } else { \
1280 decNumberFromInt32(&shd, -((int32_t)sh)); \
1281 } \
1282 \
1283 dfp.a.bits &= ~DECSPECIAL; \
1284 decNumberShift(&dfp.t, &dfp.a, &shd, &dfp.context); \
1285 \
1286 dfp.t.bits |= special; \
1287 if (special && (dfp.t.digits >= max_digits)) { \
1288 dfp.t.digits = max_digits - 1; \
1289 } \
1290 \
1291 decimal##size##FromNumber((decimal##size *)dfp.t64, &dfp.t, \
1292 &dfp.context); \
1293 } else { \
1294 if ((size) == 64) { \
1295 dfp.t64[0] = dfp.a64[0] & 0xFFFC000000000000ULL; \
1296 dfp_clear_lmd_from_g5msb(dfp.t64); \
1297 } else { \
1298 dfp.t64[HI_IDX] = dfp.a64[HI_IDX] & \
1299 0xFFFFC00000000000ULL; \
1300 dfp_clear_lmd_from_g5msb(dfp.t64 + HI_IDX); \
1301 dfp.t64[LO_IDX] = 0; \
1302 } \
1303 } \
1304 \
1305 if ((size) == 64) { \
1306 t[0] = dfp.t64[0]; \
1307 } else { \
1308 t[0] = dfp.t64[HI_IDX]; \
1309 t[1] = dfp.t64[LO_IDX]; \
1310 } \
1311 }
1312
1313 DFP_HELPER_SHIFT(dscli, 64, 1)
1314 DFP_HELPER_SHIFT(dscliq, 128, 1)
1315 DFP_HELPER_SHIFT(dscri, 64, 0)
1316 DFP_HELPER_SHIFT(dscriq, 128, 0)