Mercurial > hg > CbC > CbC_gcc
comparison libgcc/config/libbid/bid32_to_bid128.c @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 04ced10e8804 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* Copyright (C) 2007, 2009 Free Software Foundation, Inc. | |
2 | |
3 This file is part of GCC. | |
4 | |
5 GCC is free software; you can redistribute it and/or modify it under | |
6 the terms of the GNU General Public License as published by the Free | |
7 Software Foundation; either version 3, or (at your option) any later | |
8 version. | |
9 | |
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
13 for more details. | |
14 | |
15 Under Section 7 of GPL version 3, you are granted additional | |
16 permissions described in the GCC Runtime Library Exception, version | |
17 3.1, as published by the Free Software Foundation. | |
18 | |
19 You should have received a copy of the GNU General Public License and | |
20 a copy of the GCC Runtime Library Exception along with this program; | |
21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
22 <http://www.gnu.org/licenses/>. */ | |
23 | |
24 #define BID_128RES | |
25 #include "bid_internal.h" | |
26 | |
27 /* | |
28 * Takes a BID32 as input and converts it to a BID128 and returns it. | |
29 */ | |
30 TYPE0_FUNCTION_ARGTYPE1_NORND (UINT128, bid32_to_bid128, UINT32, x) | |
31 | |
32 UINT128 new_coeff, res; | |
33 UINT32 sign_x; | |
34 int exponent_x; | |
35 UINT32 coefficient_x; | |
36 | |
37 if (!unpack_BID32 (&sign_x, &exponent_x, &coefficient_x, x)) { | |
38 if (((x) & 0x78000000) == 0x78000000) { | |
39 #ifdef SET_STATUS_FLAGS | |
40 if (((x) & 0x7e000000) == 0x7e000000) // sNaN | |
41 __set_status_flags (pfpsf, INVALID_EXCEPTION); | |
42 #endif | |
43 res.w[0] = (coefficient_x & 0x000fffff); | |
44 __mul_64x128_low (res, res.w[0], power10_table_128[27]); | |
45 res.w[1] |= | |
46 ((((UINT64) coefficient_x) << 32) & 0xfc00000000000000ull); | |
47 | |
48 BID_RETURN (res); | |
49 } | |
50 } | |
51 | |
52 new_coeff.w[0] = coefficient_x; | |
53 new_coeff.w[1] = 0; | |
54 get_BID128_very_fast (&res, ((UINT64) sign_x) << 32, | |
55 exponent_x + DECIMAL_EXPONENT_BIAS_128 - | |
56 DECIMAL_EXPONENT_BIAS_32, new_coeff); | |
57 BID_RETURN (res); | |
58 } // convert_bid32_to_bid128 | |
59 | |
60 | |
61 /* | |
62 * Takes a BID128 as input and converts it to a BID32 and returns it. | |
63 */ | |
64 #if DECIMAL_CALL_BY_REFERENCE | |
65 | |
66 void | |
67 bid128_to_bid32 (UINT32 * pres, | |
68 UINT128 * | |
69 px _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM | |
70 _EXC_INFO_PARAM) { | |
71 UINT128 x = *px; | |
72 #else | |
73 | |
74 UINT32 | |
75 bid128_to_bid32 (UINT128 x _RND_MODE_PARAM _EXC_FLAGS_PARAM | |
76 _EXC_MASKS_PARAM _EXC_INFO_PARAM) { | |
77 #endif | |
78 UINT128 CX, T128, TP128, Qh, Ql, Qh1, Stemp, Tmp, Tmp1, CX1; | |
79 UINT64 sign_x, carry, cy; | |
80 SINT64 D; | |
81 UINT32 res; | |
82 int_float f64, fx; | |
83 int exponent_x, extra_digits, amount, bin_expon_cx, uf_check = 0; | |
84 unsigned rmode, status; | |
85 | |
86 #if DECIMAL_CALL_BY_REFERENCE | |
87 #if !DECIMAL_GLOBAL_ROUNDING | |
88 _IDEC_round rnd_mode = *prnd_mode; | |
89 #endif | |
90 #endif | |
91 | |
92 BID_SWAP128 (x); | |
93 // unpack arguments, check for NaN or Infinity or 0 | |
94 if (!unpack_BID128_value (&sign_x, &exponent_x, &CX, x)) { | |
95 if (((x.w[1]) & 0x7800000000000000ull) == 0x7800000000000000ull) { | |
96 Tmp.w[1] = (CX.w[1] & 0x00003fffffffffffull); | |
97 Tmp.w[0] = CX.w[0]; | |
98 TP128 = reciprocals10_128[27]; | |
99 __mul_128x128_full (Qh, Ql, Tmp, TP128); | |
100 amount = recip_scale[27] - 64; | |
101 res = ((CX.w[1] >> 32) & 0xfc000000) | (Qh.w[1] >> amount); | |
102 #ifdef SET_STATUS_FLAGS | |
103 if ((x.w[1] & SNAN_MASK64) == SNAN_MASK64) // sNaN | |
104 __set_status_flags (pfpsf, INVALID_EXCEPTION); | |
105 #endif | |
106 BID_RETURN_VAL (res); | |
107 } | |
108 // x is 0 | |
109 exponent_x = | |
110 exponent_x - DECIMAL_EXPONENT_BIAS_128 + DECIMAL_EXPONENT_BIAS_32; | |
111 if (exponent_x < 0) | |
112 exponent_x = 0; | |
113 if (exponent_x > DECIMAL_MAX_EXPON_32) | |
114 exponent_x = DECIMAL_MAX_EXPON_32; | |
115 res = (sign_x >> 32) | (exponent_x << 23); | |
116 BID_RETURN_VAL (res); | |
117 | |
118 } | |
119 | |
120 if (CX.w[1] || (CX.w[0] >= 10000000)) { | |
121 // find number of digits in coefficient | |
122 // 2^64 | |
123 f64.i = 0x5f800000; | |
124 // fx ~ CX | |
125 fx.d = (float) CX.w[1] * f64.d + (float) CX.w[0]; | |
126 bin_expon_cx = ((fx.i >> 23) & 0xff) - 0x7f; | |
127 extra_digits = estimate_decimal_digits[bin_expon_cx] - 7; | |
128 // scale = 38-estimate_decimal_digits[bin_expon_cx]; | |
129 D = CX.w[1] - power10_index_binexp_128[bin_expon_cx].w[1]; | |
130 if (D > 0 | |
131 || (!D | |
132 && CX.w[0] >= power10_index_binexp_128[bin_expon_cx].w[0])) | |
133 extra_digits++; | |
134 | |
135 exponent_x += extra_digits; | |
136 | |
137 #ifndef IEEE_ROUND_NEAREST_TIES_AWAY | |
138 #ifndef IEEE_ROUND_NEAREST | |
139 rmode = rnd_mode; | |
140 if (sign_x && (unsigned) (rmode - 1) < 2) | |
141 rmode = 3 - rmode; | |
142 #else | |
143 rmode = 0; | |
144 #endif | |
145 #else | |
146 rmode = 0; | |
147 #endif | |
148 if (exponent_x < | |
149 DECIMAL_EXPONENT_BIAS_128 - DECIMAL_EXPONENT_BIAS_32) { | |
150 uf_check = 1; | |
151 if (-extra_digits + exponent_x - DECIMAL_EXPONENT_BIAS_128 + | |
152 DECIMAL_EXPONENT_BIAS_32 + 35 >= 0) { | |
153 if (exponent_x == | |
154 DECIMAL_EXPONENT_BIAS_128 - DECIMAL_EXPONENT_BIAS_32 - 1) { | |
155 T128 = round_const_table_128[rmode][extra_digits]; | |
156 __add_carry_out (CX1.w[0], carry, T128.w[0], CX.w[0]); | |
157 CX1.w[1] = CX.w[1] + T128.w[1] + carry; | |
158 if (__unsigned_compare_ge_128 | |
159 (CX1, power10_table_128[extra_digits + 7])) | |
160 uf_check = 0; | |
161 } | |
162 extra_digits = | |
163 extra_digits + DECIMAL_EXPONENT_BIAS_128 - | |
164 DECIMAL_EXPONENT_BIAS_32 - exponent_x; | |
165 exponent_x = | |
166 DECIMAL_EXPONENT_BIAS_128 - DECIMAL_EXPONENT_BIAS_32; | |
167 } else | |
168 rmode = ROUNDING_TO_ZERO; | |
169 } | |
170 | |
171 T128 = round_const_table_128[rmode][extra_digits]; | |
172 __add_carry_out (CX.w[0], carry, T128.w[0], CX.w[0]); | |
173 CX.w[1] = CX.w[1] + T128.w[1] + carry; | |
174 | |
175 TP128 = reciprocals10_128[extra_digits]; | |
176 __mul_128x128_full (Qh, Ql, CX, TP128); | |
177 amount = recip_scale[extra_digits]; | |
178 | |
179 if (amount >= 64) { | |
180 CX.w[0] = Qh.w[1] >> (amount - 64); | |
181 CX.w[1] = 0; | |
182 } else { | |
183 __shr_128 (CX, Qh, amount); | |
184 } | |
185 | |
186 #ifndef IEEE_ROUND_NEAREST_TIES_AWAY | |
187 #ifndef IEEE_ROUND_NEAREST | |
188 if (!(rnd_mode)) | |
189 #endif | |
190 if (CX.w[0] & 1) { | |
191 // check whether fractional part of initial_P/10^ed1 is exactly .5 | |
192 | |
193 // get remainder | |
194 __shl_128_long (Qh1, Qh, (128 - amount)); | |
195 | |
196 if (!Qh1.w[1] && !Qh1.w[0] | |
197 && (Ql.w[1] < reciprocals10_128[extra_digits].w[1] | |
198 || (Ql.w[1] == reciprocals10_128[extra_digits].w[1] | |
199 && Ql.w[0] < reciprocals10_128[extra_digits].w[0]))) { | |
200 CX.w[0]--; | |
201 } | |
202 } | |
203 #endif | |
204 | |
205 | |
206 { | |
207 status = INEXACT_EXCEPTION; | |
208 // get remainder | |
209 __shl_128_long (Qh1, Qh, (128 - amount)); | |
210 | |
211 switch (rmode) { | |
212 case ROUNDING_TO_NEAREST: | |
213 case ROUNDING_TIES_AWAY: | |
214 // test whether fractional part is 0 | |
215 if (Qh1.w[1] == 0x8000000000000000ull && (!Qh1.w[0]) | |
216 && (Ql.w[1] < reciprocals10_128[extra_digits].w[1] | |
217 || (Ql.w[1] == reciprocals10_128[extra_digits].w[1] | |
218 && Ql.w[0] < reciprocals10_128[extra_digits].w[0]))) | |
219 status = EXACT_STATUS; | |
220 break; | |
221 case ROUNDING_DOWN: | |
222 case ROUNDING_TO_ZERO: | |
223 if ((!Qh1.w[1]) && (!Qh1.w[0]) | |
224 && (Ql.w[1] < reciprocals10_128[extra_digits].w[1] | |
225 || (Ql.w[1] == reciprocals10_128[extra_digits].w[1] | |
226 && Ql.w[0] < reciprocals10_128[extra_digits].w[0]))) | |
227 status = EXACT_STATUS; | |
228 break; | |
229 default: | |
230 // round up | |
231 __add_carry_out (Stemp.w[0], cy, Ql.w[0], | |
232 reciprocals10_128[extra_digits].w[0]); | |
233 __add_carry_in_out (Stemp.w[1], carry, Ql.w[1], | |
234 reciprocals10_128[extra_digits].w[1], cy); | |
235 __shr_128_long (Qh, Qh1, (128 - amount)); | |
236 Tmp.w[0] = 1; | |
237 Tmp.w[1] = 0; | |
238 __shl_128_long (Tmp1, Tmp, amount); | |
239 Qh.w[0] += carry; | |
240 if (Qh.w[0] < carry) | |
241 Qh.w[1]++; | |
242 if (__unsigned_compare_ge_128 (Qh, Tmp1)) | |
243 status = EXACT_STATUS; | |
244 } | |
245 | |
246 if (status != EXACT_STATUS) { | |
247 if (uf_check) { | |
248 status |= UNDERFLOW_EXCEPTION; | |
249 } | |
250 #ifdef SET_STATUS_FLAGS | |
251 __set_status_flags (pfpsf, status); | |
252 #endif | |
253 } | |
254 } | |
255 | |
256 } | |
257 | |
258 res = | |
259 get_BID32 ((UINT32) (sign_x >> 32), | |
260 exponent_x - DECIMAL_EXPONENT_BIAS_128 + | |
261 DECIMAL_EXPONENT_BIAS_32, CX.w[0], rnd_mode, pfpsf); | |
262 BID_RETURN_VAL (res); | |
263 | |
264 } |