source: mainline/softfloat/generic/conversion.c@ a82695c

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a82695c was a82695c, checked in by Josef Cejka <malyzelenyhnus@…>, 19 years ago

Completed conversions from float/double to integer types.
  • Property mode set to 100644
File size: 8.8 KB
RevLine 
[b5440cf]1/*
2 * Copyright (C) 2005 Josef Cejka
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
[feef1cd]29#include "sftypes.h"
30#include "conversion.h"
[afffa1e]31#include "comparison.h"
[feef1cd]32
33float64 convertFloat32ToFloat64(float32 a)
34{
35 float64 result;
[1266543]36 __u64 frac;
[feef1cd]37
38 result.parts.sign = a.parts.sign;
[1266543]39 result.parts.fraction = a.parts.fraction;
40 result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
[feef1cd]41
42 if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
43 result.parts.exp = 0x7FF;
44 /* TODO; check if its correct for SigNaNs*/
45 return result;
46 };
47
48 result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
49 if (a.parts.exp == 0) {
50 /* normalize denormalized numbers */
51
[1266543]52 if (result.parts.fraction == 0ll) { /* fix zero */
[feef1cd]53 result.parts.exp = 0ll;
54 return result;
55 }
56
[1266543]57 frac = result.parts.fraction;
[feef1cd]58
[1266543]59 while (!(frac & (0x10000000000000ll))) {
60 frac <<= 1;
[feef1cd]61 --result.parts.exp;
62 };
[56a39dde]63
64 ++result.parts.exp;
[1266543]65 result.parts.fraction = frac;
[feef1cd]66 };
67
68 return result;
69
[afffa1e]70}
[feef1cd]71
72float32 convertFloat64ToFloat32(float64 a)
73{
74 float32 result;
75 __s32 exp;
[1266543]76 __u64 frac;
[feef1cd]77
78 result.parts.sign = a.parts.sign;
79
80 if (isFloat64NaN(a)) {
81
82 result.parts.exp = 0xFF;
83
84 if (isFloat64SigNaN(a)) {
[1266543]85 result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
[feef1cd]86 return result;
87 }
88
[1266543]89 result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
[feef1cd]90 return result;
91 };
92
93 if (isFloat64Infinity(a)) {
[1266543]94 result.parts.fraction = 0;
[feef1cd]95 result.parts.exp = 0xFF;
96 return result;
97 };
98
99 exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
100
101 if (exp >= 0xFF) {
102 /*FIXME: overflow*/
[1266543]103 result.parts.fraction = 0;
[feef1cd]104 result.parts.exp = 0xFF;
105 return result;
106
107 } else if (exp <= 0 ) {
108
109 /* underflow or denormalized */
110
111 result.parts.exp = 0;
112
113 exp *= -1;
[1266543]114 if (exp > FLOAT32_FRACTION_SIZE ) {
[feef1cd]115 /* FIXME: underflow */
[1266543]116 result.parts.fraction = 0;
[feef1cd]117 return result;
118 };
119
120 /* denormalized */
121
[1266543]122 frac = a.parts.fraction;
123 frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
[feef1cd]124
[1266543]125 frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
[56a39dde]126
[feef1cd]127 while (exp > 0) {
128 --exp;
[1266543]129 frac >>= 1;
[feef1cd]130 };
[1266543]131 result.parts.fraction = frac;
[feef1cd]132
133 return result;
134 };
135
136 result.parts.exp = exp;
[1266543]137 result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
[feef1cd]138 return result;
[afffa1e]139}
140
141
142/** Helping procedure for converting float32 to uint32
143 * @param a floating point number in normalized form (no NaNs or Inf are checked )
144 * @return unsigned integer
145 */
146static __u32 _float32_to_uint32_helper(float32 a)
147{
148 __u32 frac;
149
150 if (a.parts.exp < FLOAT32_BIAS) {
151 /*TODO: rounding*/
152 return 0;
153 }
154
155 frac = a.parts.fraction;
156
157 frac |= FLOAT32_HIDDEN_BIT_MASK;
158 /* shift fraction to left so hidden bit will be the most significant bit */
159 frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
160
161 frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
162 if ((a.parts.sign == 1) && (frac != 0)) {
163 frac = ~frac;
164 ++frac;
165 }
166
167 return frac;
168}
169
170/* Convert float to unsigned int32
171 * FIXME: Im not sure what to return if overflow/underflow happens
172 * - now its the biggest or the smallest int
173 */
174__u32 float32_to_uint32(float32 a)
175{
176 if (isFloat32NaN(a)) {
177 return MAX_UINT32;
178 }
179
180 if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
181 if (a.parts.sign) {
182 return MIN_UINT32;
183 }
184 return MAX_UINT32;
185 }
186
187 return _float32_to_uint32_helper(a);
188}
189
190/* Convert float to signed int32
191 * FIXME: Im not sure what to return if overflow/underflow happens
192 * - now its the biggest or the smallest int
193 */
194__s32 float32_to_int32(float32 a)
195{
196 if (isFloat32NaN(a)) {
197 return MAX_INT32;
198 }
199
200 if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
201 if (a.parts.sign) {
202 return MIN_INT32;
203 }
204 return MAX_INT32;
205 }
206 return _float32_to_uint32_helper(a);
207}
208
209
[a82695c]210/** Helping procedure for converting float64 to uint64
211 * @param a floating point number in normalized form (no NaNs or Inf are checked )
212 * @return unsigned integer
213 */
214static __u64 _float64_to_uint64_helper(float64 a)
215{
216 __u64 frac;
217
218 if (a.parts.exp < FLOAT64_BIAS) {
219 /*TODO: rounding*/
220 return 0;
221 }
222
223 frac = a.parts.fraction;
224
225 frac |= FLOAT64_HIDDEN_BIT_MASK;
226 /* shift fraction to left so hidden bit will be the most significant bit */
227 frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
228
229 frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
230 if ((a.parts.sign == 1) && (frac != 0)) {
231 frac = ~frac;
232 ++frac;
233 }
234
235 return frac;
236}
237
238/* Convert float to unsigned int64
239 * FIXME: Im not sure what to return if overflow/underflow happens
240 * - now its the biggest or the smallest int
241 */
242__u64 float64_to_uint64(float64 a)
243{
244 if (isFloat64NaN(a)) {
245 return MAX_UINT64;
246 }
247
248 if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
249 if (a.parts.sign) {
250 return MIN_UINT64;
251 }
252 return MAX_UINT64;
253 }
254
255 return _float64_to_uint64_helper(a);
256}
257
258/* Convert float to signed int64
259 * FIXME: Im not sure what to return if overflow/underflow happens
260 * - now its the biggest or the smallest int
261 */
262__s64 float64_to_int64(float64 a)
263{
264 if (isFloat64NaN(a)) {
265 return MAX_INT64;
266 }
267
268 if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
269 if (a.parts.sign) {
270 return MIN_INT64;
271 }
272 return MAX_INT64;
273 }
274 return _float64_to_uint64_helper(a);
275}
276
277
278
279
280
281/** Helping procedure for converting float32 to uint64
282 * @param a floating point number in normalized form (no NaNs or Inf are checked )
283 * @return unsigned integer
284 */
285static __u64 _float32_to_uint64_helper(float32 a)
286{
287 __u64 frac;
288
289 if (a.parts.exp < FLOAT32_BIAS) {
290 /*TODO: rounding*/
291 return 0;
292 }
293
294 frac = a.parts.fraction;
295
296 frac |= FLOAT32_HIDDEN_BIT_MASK;
297 /* shift fraction to left so hidden bit will be the most significant bit */
298 frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
299
300 frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
301 if ((a.parts.sign == 1) && (frac != 0)) {
302 frac = ~frac;
303 ++frac;
304 }
305
306 return frac;
307}
308
309/* Convert float to unsigned int64
310 * FIXME: Im not sure what to return if overflow/underflow happens
311 * - now its the biggest or the smallest int
312 */
313__u64 float32_to_uint64(float32 a)
314{
315 if (isFloat32NaN(a)) {
316 return MAX_UINT64;
317 }
318
319 if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
320 if (a.parts.sign) {
321 return MIN_UINT64;
322 }
323 return MAX_UINT64;
324 }
325
326 return _float32_to_uint64_helper(a);
327}
328
329/* Convert float to signed int64
330 * FIXME: Im not sure what to return if overflow/underflow happens
331 * - now its the biggest or the smallest int
332 */
333__s64 float32_to_int64(float32 a)
334{
335 if (isFloat32NaN(a)) {
336 return MAX_INT64;
337 }
338
339 if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
340 if (a.parts.sign) {
341 return (MIN_INT64);
342 }
343 return MAX_INT64;
344 }
345 return _float32_to_uint64_helper(a);
346}
347
348
349/* Convert float64 to unsigned int32
350 * FIXME: Im not sure what to return if overflow/underflow happens
351 * - now its the biggest or the smallest int
352 */
353__u32 float64_to_uint32(float64 a)
354{
355 if (isFloat64NaN(a)) {
356 return MAX_UINT32;
357 }
358
359 if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
360 if (a.parts.sign) {
361 return MIN_UINT32;
362 }
363 return MAX_UINT32;
364 }
365
366 return (__u32)_float64_to_uint64_helper(a);
367}
368
369/* Convert float64 to signed int32
370 * FIXME: Im not sure what to return if overflow/underflow happens
371 * - now its the biggest or the smallest int
372 */
373__s32 float64_to_int32(float64 a)
374{
375 if (isFloat64NaN(a)) {
376 return MAX_INT32;
377 }
378
379 if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
380 if (a.parts.sign) {
381 return MIN_INT32;
382 }
383 return MAX_INT32;
384 }
385 return (__s32)_float64_to_uint64_helper(a);
386}
387
[feef1cd]388
Note: See TracBrowser for help on using the repository browser.