1 /* Utility functions for decimal floating point support via decNumber.
2 Copyright (C) 2005 Free Software Foundation, Inc.
3 Contributed by IBM Corporation. Author Mike Cowlishaw.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #include "decNumber.h" /* base number library */
24 #include "decNumberLocal.h" /* decNumber local types, etc. */
25 #include "decUtility.h" /* utility routines */
27 /* ================================================================== */
28 /* Shared utility routines */
29 /* ================================================================== */
31 /* define and include the conversion tables to use */
32 #define DEC_BIN2DPD 1 /* used for all sizes */
38 #include "decDPD.h" /* lookup tables */
40 /* The maximum number of decNumberUnits we need for a working copy of */
41 /* the units array is the ceiling of digits/DECDPUN, where digits is */
42 /* the maximum number of digits in any of the formats for which this */
43 /* is used. We do not want to include decimal128.h, so, as a very */
44 /* special case, that number is defined here. */
46 #define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN)
48 /* ------------------------------------------------------------------ */
49 /* decDensePackCoeff -- densely pack coefficient into DPD form */
51 /* dn is the source number (assumed valid, max DECMAX754 digits) */
52 /* bytes is the target's byte array */
53 /* len is length of target format's byte array */
54 /* shift is the number of 0 digits to add on the right (normally 0) */
56 /* The coefficient must be known small enough to fit, and is filled */
57 /* in from the right (least significant first). Note that the full */
58 /* coefficient is copied, including the leading 'odd' digit. This */
59 /* digit is retrieved and packed into the combination field by the */
62 /* shift is used for 'fold-down' padding. */
64 /* No error is possible. */
65 /* ------------------------------------------------------------------ */
67 decDensePackCoeff (decNumber * dn, uByte * bytes, Int len, Int shift)
70 Int n; /* output bunch counter */
71 Int digits = dn->digits; /* digit countdown */
72 uInt dpd; /* densely packed decimal value */
73 uInt bin; /* binary value 0-999 */
74 uByte *bout; /* -> current output byte */
75 Unit *inu = dn->lsu; /* -> current input unit */
76 Unit uar[DECMAXUNITS]; /* working copy of units, iff shifted */
77 #if DECDPUN!=3 /* not fast path */
78 Unit in; /* current input unit */
82 { /* shift towards most significant required */
83 /* shift the units array to the left by pad digits and copy */
84 /* [this code is a special case of decShiftToMost, which could */
85 /* be used instead if exposed and the array were copied first] */
86 Unit *target, *source, *first; /* work */
87 uInt next = 0; /* work */
89 source = dn->lsu + D2U (digits) - 1; /* where msu comes from */
90 first = uar + D2U (digits + shift) - 1; /* where msu will end up */
91 target = uar + D2U (digits) - 1 + D2U (shift); /* where upper part of first cut goes */
93 cut = (DECDPUN - shift % DECDPUN) % DECDPUN;
94 for (; source >= dn->lsu; source--, target--)
96 /* split the source Unit and accumulate remainder for next */
97 uInt rem = *source % powers[cut];
98 next += *source / powers[cut];
100 *target = (Unit) next; /* write to target iff valid */
101 next = rem * powers[DECDPUN - cut]; /* save remainder for next Unit */
103 /* propagate remainder to one below and clear the rest */
104 for (; target >= uar; target--)
106 *target = (Unit) next;
109 digits += shift; /* add count (shift) of zeros added */
110 inu = uar; /* use units in working array */
113 /* densely pack the coefficient into the byte array, starting from
114 the right (optionally padded) */
115 bout = &bytes[len - 1]; /* rightmost result byte for phase */
117 #if DECDPUN!=3 /* not fast path */
118 in = *inu; /* prime */
119 cut = 0; /* at lowest digit */
120 bin = 0; /* [keep compiler quiet] */
123 for (n = 0; digits > 0; n++)
124 { /* each output bunch */
125 #if DECDPUN==3 /* fast path, 3-at-a-time */
126 bin = *inu; /* 3 ready for convert */
127 digits -= 3; /* [may go negative] */
128 inu++; /* may need another */
130 #else /* must collect digit-by-digit */
131 Unit dig; /* current digit */
132 Int j; /* digit-in-bunch count */
133 for (j = 0; j < 3; j++)
136 Unit temp = (Unit) ((uInt) (in * 6554) >> 16);
137 dig = (Unit) (in - X10 (temp));
153 break; /* [also protects *inu below] */
163 /* here we have 3 digits in bin, or have used all input digits */
167 /* write bunch (bcd) to byte array */
171 *bout = (uByte) dpd; /* [top 2 bits truncated] */
173 *bout = (uByte) (dpd >> 8);
176 *bout |= (uByte) (dpd << 2);
178 *bout = (uByte) (dpd >> 6);
181 *bout |= (uByte) (dpd << 4);
183 *bout = (uByte) (dpd >> 4);
186 *bout |= (uByte) (dpd << 6);
188 *bout = (uByte) (dpd >> 2);
196 /* ------------------------------------------------------------------ */
197 /* decDenseUnpackCoeff -- unpack a format's coefficient */
199 /* byte is the source's byte array */
200 /* len is length of the source's byte array */
201 /* dn is the target number, with 7, 16, or 34-digit space. */
202 /* bunches is the count of DPD groups in the decNumber (2, 5, or 11)*/
203 /* odd is 1 if there is a non-zero leading 10-bit group containing */
204 /* a single digit, 0 otherwise */
206 /* (This routine works on a copy of the number, if necessary, where */
207 /* an extra 10-bit group is prefixed to the coefficient continuation */
208 /* to hold the most significant digit if the latter is non-0.) */
210 /* dn->digits is set, but not the sign or exponent. */
211 /* No error is possible [the redundant 888 codes are allowed]. */
212 /* ------------------------------------------------------------------ */
214 decDenseUnpackCoeff (uByte * bytes, Int len, decNumber * dn,
215 Int bunches, Int odd)
217 uInt dpd = 0; /* collector for 10 bits */
219 uByte *bin; /* -> current input byte */
220 Unit *uout = dn->lsu; /* -> current output unit */
221 Unit out = 0; /* accumulator */
222 Int cut = 0; /* power of ten in current unit */
223 Unit *last = uout; /* will be unit containing msd */
225 uInt bcd; /* BCD result */
226 uInt nibble; /* work */
229 /* Expand the densely-packed integer, right to left */
230 bin = &bytes[len - 1]; /* next input byte to use */
231 for (n = 0; n < bunches + odd; n++)
232 { /* N bunches of 10 bits */
233 /* assemble the 10 bits */
239 dpd |= (*bin & 0x03) << 8;
242 dpd = (unsigned) *bin >> 2;
244 dpd |= (*bin & 0x0F) << 6;
247 dpd = (unsigned) *bin >> 4;
249 dpd |= (*bin & 0x3F) << 4;
252 dpd = (unsigned) *bin >> 6;
264 *uout = DPD2BIN[dpd]; /* convert 10 bits to binary 0-999 */
265 last = uout; /* record most significant unit */
269 #else /* DECDPUN!=3 */
271 { /* fastpath [e.g., leading zeros] */
273 for (; cut >= DECDPUN;)
282 bcd = DPD2BCD[dpd]; /* convert 10 bits to 12 bits BCD */
283 /* now split the 3 BCD nibbles into bytes, and accumulate into units */
284 /* If this is the last bunch and it is an odd one, we only have one */
285 /* nibble to handle [extras could overflow a Unit] */
286 nibble = bcd & 0x000f;
290 out = (Unit) (out + nibble * powers[cut]);
302 nibble = bcd & 0x00f0;
307 out = (Unit) (out + nibble * powers[cut]);
317 nibble = bcd & 0x0f00;
322 out = (Unit) (out + nibble * powers[cut]);
336 *uout = out; /* write out final unit */
338 /* here, last points to the most significant unit with digits */
339 /* we need to inspect it to get final digits count */
340 dn->digits = (last - dn->lsu) * DECDPUN; /* floor of digits */
341 for (cut = 0; cut < DECDPUN; cut++)
343 if (*last < powers[cut])
348 dn->digits++; /* zero has one digit */
353 __dec_byte_swap (unsigned long in)
356 unsigned char *p = (unsigned char *) &out;