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