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, 51 Franklin Street, Fifth Floor, 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 (const 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 const 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, *first; /* work */
87 const Unit *source; /* work */
88 uInt next = 0; /* work */
90 source = dn->lsu + D2U (digits) - 1; /* where msu comes from */
91 first = uar + D2U (digits + shift) - 1; /* where msu will end up */
92 target = uar + D2U (digits) - 1 + D2U (shift); /* where upper part of first cut goes */
94 cut = (DECDPUN - shift % DECDPUN) % DECDPUN;
95 for (; source >= dn->lsu; source--, target--)
97 /* split the source Unit and accumulate remainder for next */
98 uInt rem = *source % powers[cut];
99 next += *source / powers[cut];
101 *target = (Unit) next; /* write to target iff valid */
102 next = rem * powers[DECDPUN - cut]; /* save remainder for next Unit */
104 /* propagate remainder to one below and clear the rest */
105 for (; target >= uar; target--)
107 *target = (Unit) next;
110 digits += shift; /* add count (shift) of zeros added */
111 inu = uar; /* use units in working array */
114 /* densely pack the coefficient into the byte array, starting from
115 the right (optionally padded) */
116 bout = &bytes[len - 1]; /* rightmost result byte for phase */
118 #if DECDPUN!=3 /* not fast path */
119 in = *inu; /* prime */
120 cut = 0; /* at lowest digit */
121 bin = 0; /* [keep compiler quiet] */
124 for (n = 0; digits > 0; n++)
125 { /* each output bunch */
126 #if DECDPUN==3 /* fast path, 3-at-a-time */
127 bin = *inu; /* 3 ready for convert */
128 digits -= 3; /* [may go negative] */
129 inu++; /* may need another */
131 #else /* must collect digit-by-digit */
132 Unit dig; /* current digit */
133 Int j; /* digit-in-bunch count */
134 for (j = 0; j < 3; j++)
137 Unit temp = (Unit) ((uInt) (in * 6554) >> 16);
138 dig = (Unit) (in - X10 (temp));
154 break; /* [also protects *inu below] */
164 /* here we have 3 digits in bin, or have used all input digits */
168 /* write bunch (bcd) to byte array */
172 *bout = (uByte) dpd; /* [top 2 bits truncated] */
174 *bout = (uByte) (dpd >> 8);
177 *bout |= (uByte) (dpd << 2);
179 *bout = (uByte) (dpd >> 6);
182 *bout |= (uByte) (dpd << 4);
184 *bout = (uByte) (dpd >> 4);
187 *bout |= (uByte) (dpd << 6);
189 *bout = (uByte) (dpd >> 2);
197 /* ------------------------------------------------------------------ */
198 /* decDenseUnpackCoeff -- unpack a format's coefficient */
200 /* byte is the source's byte array */
201 /* len is length of the source's byte array */
202 /* dn is the target number, with 7, 16, or 34-digit space. */
203 /* bunches is the count of DPD groups in the decNumber (2, 5, or 11)*/
204 /* odd is 1 if there is a non-zero leading 10-bit group containing */
205 /* a single digit, 0 otherwise */
207 /* (This routine works on a copy of the number, if necessary, where */
208 /* an extra 10-bit group is prefixed to the coefficient continuation */
209 /* to hold the most significant digit if the latter is non-0.) */
211 /* dn->digits is set, but not the sign or exponent. */
212 /* No error is possible [the redundant 888 codes are allowed]. */
213 /* ------------------------------------------------------------------ */
215 decDenseUnpackCoeff (const uByte * bytes, Int len, decNumber * dn,
216 Int bunches, Int odd)
218 uInt dpd = 0; /* collector for 10 bits */
220 const uByte *bin; /* -> current input byte */
221 Unit *uout = dn->lsu; /* -> current output unit */
222 Unit out = 0; /* accumulator */
223 Int cut = 0; /* power of ten in current unit */
224 Unit *last = uout; /* will be unit containing msd */
226 uInt bcd; /* BCD result */
227 uInt nibble; /* work */
230 /* Expand the densely-packed integer, right to left */
231 bin = &bytes[len - 1]; /* next input byte to use */
232 for (n = 0; n < bunches + odd; n++)
233 { /* N bunches of 10 bits */
234 /* assemble the 10 bits */
240 dpd |= (*bin & 0x03) << 8;
243 dpd = (unsigned) *bin >> 2;
245 dpd |= (*bin & 0x0F) << 6;
248 dpd = (unsigned) *bin >> 4;
250 dpd |= (*bin & 0x3F) << 4;
253 dpd = (unsigned) *bin >> 6;
265 *uout = DPD2BIN[dpd]; /* convert 10 bits to binary 0-999 */
266 last = uout; /* record most significant unit */
270 #else /* DECDPUN!=3 */
272 { /* fastpath [e.g., leading zeros] */
274 for (; cut >= DECDPUN;)
283 bcd = DPD2BCD[dpd]; /* convert 10 bits to 12 bits BCD */
284 /* now split the 3 BCD nibbles into bytes, and accumulate into units */
285 /* If this is the last bunch and it is an odd one, we only have one */
286 /* nibble to handle [extras could overflow a Unit] */
287 nibble = bcd & 0x000f;
291 out = (Unit) (out + nibble * powers[cut]);
303 nibble = bcd & 0x00f0;
308 out = (Unit) (out + nibble * powers[cut]);
318 nibble = bcd & 0x0f00;
323 out = (Unit) (out + nibble * powers[cut]);
337 *uout = out; /* write out final unit */
339 /* here, last points to the most significant unit with digits */
340 /* we need to inspect it to get final digits count */
341 dn->digits = (last - dn->lsu) * DECDPUN; /* floor of digits */
342 for (cut = 0; cut < DECDPUN; cut++)
344 if (*last < powers[cut])
349 dn->digits++; /* zero has one digit */