Subversion Repositories HelenOS-historic

Rev

Rev 1035 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
647 cejka 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
 
1657 cejka 29
 /** @addtogroup softfloat 
30
 * @{
31
 */
32
/** @file
33
 */
34
 
697 cejka 35
#include "sftypes.h"
36
#include "conversion.h"
857 cejka 37
#include "comparison.h"
874 cejka 38
#include "common.h"
697 cejka 39
 
40
float64 convertFloat32ToFloat64(float32 a)
41
{
42
    float64 result;
1031 cejka 43
    uint64_t frac;
697 cejka 44
 
45
    result.parts.sign = a.parts.sign;
804 cejka 46
    result.parts.fraction = a.parts.fraction;
47
    result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
697 cejka 48
 
49
    if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
50
        result.parts.exp = 0x7FF;
51
        /* TODO; check if its correct for SigNaNs*/
52
        return result;
53
    };
54
 
55
    result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
56
    if (a.parts.exp == 0) {
57
        /* normalize denormalized numbers */
58
 
804 cejka 59
        if (result.parts.fraction == 0ll) { /* fix zero */
697 cejka 60
            result.parts.exp = 0ll;
61
            return result;
62
        }
63
 
804 cejka 64
        frac = result.parts.fraction;
697 cejka 65
 
804 cejka 66
        while (!(frac & (0x10000000000000ll))) {
67
            frac <<= 1;
697 cejka 68
            --result.parts.exp;
69
        };
698 cejka 70
 
71
        ++result.parts.exp;
804 cejka 72
        result.parts.fraction = frac;
697 cejka 73
    };
74
 
75
    return result;
76
 
857 cejka 77
}
697 cejka 78
 
79
float32 convertFloat64ToFloat32(float64 a)
80
{
81
    float32 result;
1031 cejka 82
    int32_t exp;
83
    uint64_t frac;
697 cejka 84
 
85
    result.parts.sign = a.parts.sign;
86
 
87
    if (isFloat64NaN(a)) {
88
 
89
        result.parts.exp = 0xFF;
90
 
91
        if (isFloat64SigNaN(a)) {
1031 cejka 92
            result.parts.fraction = 0x400000; /* set first bit of fraction nonzero */
697 cejka 93
            return result;
94
        }
95
 
804 cejka 96
        result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
697 cejka 97
        return result;
98
    };
99
 
100
    if (isFloat64Infinity(a)) {
804 cejka 101
        result.parts.fraction = 0;
697 cejka 102
        result.parts.exp = 0xFF;
103
        return result;
104
    };
105
 
106
    exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
107
 
108
    if (exp >= 0xFF) {
109
        /*FIXME: overflow*/
804 cejka 110
        result.parts.fraction = 0;
697 cejka 111
        result.parts.exp = 0xFF;
112
        return result;
113
 
114
    } else if (exp <= 0 ) {
115
 
116
        /* underflow or denormalized */
117
 
118
        result.parts.exp = 0;
119
 
120
        exp *= -1; 
804 cejka 121
        if (exp > FLOAT32_FRACTION_SIZE ) {
697 cejka 122
            /* FIXME: underflow */
804 cejka 123
            result.parts.fraction = 0;
697 cejka 124
            return result;
125
        };
126
 
127
        /* denormalized */
128
 
804 cejka 129
        frac = a.parts.fraction;
130
        frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
697 cejka 131
 
804 cejka 132
        frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
698 cejka 133
 
697 cejka 134
        while (exp > 0) {
135
            --exp;
804 cejka 136
            frac >>= 1;
697 cejka 137
        };
804 cejka 138
        result.parts.fraction = frac;
697 cejka 139
 
140
        return result;
141
    };
142
 
143
    result.parts.exp = exp;
804 cejka 144
    result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
697 cejka 145
    return result;
857 cejka 146
}
697 cejka 147
 
857 cejka 148
 
149
/** Helping procedure for converting float32 to uint32
150
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
151
 * @return unsigned integer
152
 */
1031 cejka 153
static uint32_t _float32_to_uint32_helper(float32 a)
857 cejka 154
{
1031 cejka 155
    uint32_t frac;
857 cejka 156
 
157
    if (a.parts.exp < FLOAT32_BIAS) {
158
        /*TODO: rounding*/
159
        return 0;
160
    }
161
 
162
    frac = a.parts.fraction;
163
 
164
    frac |= FLOAT32_HIDDEN_BIT_MASK;
165
    /* shift fraction to left so hidden bit will be the most significant bit */
166
    frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
167
 
168
    frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
169
    if ((a.parts.sign == 1) && (frac != 0)) {
170
        frac = ~frac;
171
        ++frac;
172
    }
173
 
174
    return frac;
175
}
176
 
177
/* Convert float to unsigned int32
178
 * FIXME: Im not sure what to return if overflow/underflow happens
179
 *  - now its the biggest or the smallest int
180
 */
1031 cejka 181
uint32_t float32_to_uint32(float32 a)
857 cejka 182
{
183
    if (isFloat32NaN(a)) {
184
        return MAX_UINT32;
185
    }
186
 
187
    if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
188
        if (a.parts.sign) {
189
            return MIN_UINT32;
190
        }
191
        return MAX_UINT32;
192
    }
193
 
194
    return _float32_to_uint32_helper(a);   
195
}
196
 
197
/* Convert float to signed int32
198
 * FIXME: Im not sure what to return if overflow/underflow happens
199
 *  - now its the biggest or the smallest int
200
 */
1031 cejka 201
int32_t float32_to_int32(float32 a)
857 cejka 202
{
203
    if (isFloat32NaN(a)) {
204
        return MAX_INT32;
205
    }
206
 
207
    if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
208
        if (a.parts.sign) {
209
            return MIN_INT32;
210
        }
211
        return MAX_INT32;
212
    }
213
    return _float32_to_uint32_helper(a);
214
}  
215
 
216
 
865 cejka 217
/** Helping procedure for converting float64 to uint64
218
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
219
 * @return unsigned integer
220
 */
1031 cejka 221
static uint64_t _float64_to_uint64_helper(float64 a)
865 cejka 222
{
1031 cejka 223
    uint64_t frac;
865 cejka 224
 
225
    if (a.parts.exp < FLOAT64_BIAS) {
226
        /*TODO: rounding*/
227
        return 0;
228
    }
229
 
230
    frac = a.parts.fraction;
231
 
232
    frac |= FLOAT64_HIDDEN_BIT_MASK;
233
    /* shift fraction to left so hidden bit will be the most significant bit */
234
    frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
857 cejka 235
 
865 cejka 236
    frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
237
    if ((a.parts.sign == 1) && (frac != 0)) {
238
        frac = ~frac;
239
        ++frac;
240
    }
241
 
242
    return frac;
243
}
244
 
245
/* Convert float to unsigned int64
246
 * FIXME: Im not sure what to return if overflow/underflow happens
247
 *  - now its the biggest or the smallest int
248
 */
1031 cejka 249
uint64_t float64_to_uint64(float64 a)
865 cejka 250
{
251
    if (isFloat64NaN(a)) {
252
        return MAX_UINT64;
253
    }
254
 
255
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
256
        if (a.parts.sign) {
257
            return MIN_UINT64;
258
        }
259
        return MAX_UINT64;
260
    }
261
 
262
    return _float64_to_uint64_helper(a);   
263
}
264
 
265
/* Convert float to signed int64
266
 * FIXME: Im not sure what to return if overflow/underflow happens
267
 *  - now its the biggest or the smallest int
268
 */
1031 cejka 269
int64_t float64_to_int64(float64 a)
865 cejka 270
{
271
    if (isFloat64NaN(a)) {
272
        return MAX_INT64;
273
    }
274
 
275
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
276
        if (a.parts.sign) {
277
            return MIN_INT64;
278
        }
279
        return MAX_INT64;
280
    }
281
    return _float64_to_uint64_helper(a);
282
}  
283
 
284
 
285
 
286
 
287
 
288
/** Helping procedure for converting float32 to uint64
289
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
290
 * @return unsigned integer
291
 */
1031 cejka 292
static uint64_t _float32_to_uint64_helper(float32 a)
865 cejka 293
{
1031 cejka 294
    uint64_t frac;
865 cejka 295
 
296
    if (a.parts.exp < FLOAT32_BIAS) {
297
        /*TODO: rounding*/
298
        return 0;
299
    }
300
 
301
    frac = a.parts.fraction;
302
 
303
    frac |= FLOAT32_HIDDEN_BIT_MASK;
304
    /* shift fraction to left so hidden bit will be the most significant bit */
305
    frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
306
 
307
    frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
308
    if ((a.parts.sign == 1) && (frac != 0)) {
309
        frac = ~frac;
310
        ++frac;
311
    }
312
 
313
    return frac;
314
}
315
 
316
/* Convert float to unsigned int64
317
 * FIXME: Im not sure what to return if overflow/underflow happens
318
 *  - now its the biggest or the smallest int
319
 */
1031 cejka 320
uint64_t float32_to_uint64(float32 a)
865 cejka 321
{
322
    if (isFloat32NaN(a)) {
323
        return MAX_UINT64;
324
    }
325
 
326
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
327
        if (a.parts.sign) {
328
            return MIN_UINT64;
329
        }
330
        return MAX_UINT64;
331
    }
332
 
333
    return _float32_to_uint64_helper(a);   
334
}
335
 
336
/* Convert float to signed int64
337
 * FIXME: Im not sure what to return if overflow/underflow happens
338
 *  - now its the biggest or the smallest int
339
 */
1031 cejka 340
int64_t float32_to_int64(float32 a)
865 cejka 341
{
342
    if (isFloat32NaN(a)) {
343
        return MAX_INT64;
344
    }
345
 
346
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
347
        if (a.parts.sign) {
348
            return (MIN_INT64);
349
        }
350
        return MAX_INT64;
351
    }
352
    return _float32_to_uint64_helper(a);
353
}  
354
 
355
 
356
/* Convert float64 to unsigned int32
357
 * FIXME: Im not sure what to return if overflow/underflow happens
358
 *  - now its the biggest or the smallest int
359
 */
1031 cejka 360
uint32_t float64_to_uint32(float64 a)
865 cejka 361
{
362
    if (isFloat64NaN(a)) {
363
        return MAX_UINT32;
364
    }
365
 
366
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
367
        if (a.parts.sign) {
368
            return MIN_UINT32;
369
        }
370
        return MAX_UINT32;
371
    }
372
 
1031 cejka 373
    return (uint32_t)_float64_to_uint64_helper(a); 
865 cejka 374
}
375
 
376
/* Convert float64 to signed int32
377
 * FIXME: Im not sure what to return if overflow/underflow happens
378
 *  - now its the biggest or the smallest int
379
 */
1031 cejka 380
int32_t float64_to_int32(float64 a)
865 cejka 381
{
382
    if (isFloat64NaN(a)) {
383
        return MAX_INT32;
384
    }
385
 
386
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
387
        if (a.parts.sign) {
388
            return MIN_INT32;
389
        }
390
        return MAX_INT32;
391
    }
1031 cejka 392
    return (int32_t)_float64_to_uint64_helper(a);
865 cejka 393
}  
394
 
874 cejka 395
/** Convert unsigned integer to float32
396
 *
397
 *
398
 */
1031 cejka 399
float32 uint32_to_float32(uint32_t i)
874 cejka 400
{
401
    int counter;
1031 cejka 402
    int32_t exp;
874 cejka 403
    float32 result;
404
 
405
    result.parts.sign = 0;
406
    result.parts.fraction = 0;
865 cejka 407
 
874 cejka 408
    counter = countZeroes32(i);
409
 
410
    exp = FLOAT32_BIAS + 32 - counter - 1;
411
 
412
    if (counter == 32) {
413
        result.binary = 0;
414
        return result;
415
    }
416
 
417
    if (counter > 0) {
418
        i <<= counter - 1;
419
    } else {
420
        i >>= 1;
421
    }
422
 
423
    roundFloat32(&exp, &i);
424
 
425
    result.parts.fraction = i >> 7;
426
    result.parts.exp = exp;
427
 
428
    return result;
429
}
430
 
1031 cejka 431
float32 int32_to_float32(int32_t i)
874 cejka 432
{
433
    float32 result;
434
 
435
    if (i < 0) {
1031 cejka 436
        result = uint32_to_float32((uint32_t)(-i));
874 cejka 437
    } else {
1031 cejka 438
        result = uint32_to_float32((uint32_t)i);
874 cejka 439
    }
440
 
441
    result.parts.sign = i < 0;
442
 
443
    return result;
444
}
445
 
446
 
1031 cejka 447
float32 uint64_to_float32(uint64_t i)
874 cejka 448
{
875 cejka 449
    int counter;
1031 cejka 450
    int32_t exp;
1035 cejka 451
    uint32_t j;
875 cejka 452
    float32 result;
453
 
454
    result.parts.sign = 0;
455
    result.parts.fraction = 0;
456
 
457
    counter = countZeroes64(i);
458
 
459
    exp = FLOAT32_BIAS + 64 - counter - 1;
460
 
461
    if (counter == 64) {
462
        result.binary = 0;
463
        return result;
464
    }
465
 
466
    /* Shift all to the first 31 bits (31. will be hidden 1)*/
467
    if (counter > 33) {
468
        i <<= counter - 1 - 32;
469
    } else {
470
        i >>= 1 + 32 - counter;
471
    }
1031 cejka 472
 
473
    j = (uint32_t)i;
474
    roundFloat32(&exp, &j);
875 cejka 475
 
1031 cejka 476
    result.parts.fraction = j >> 7;
875 cejka 477
    result.parts.exp = exp;
478
    return result;
874 cejka 479
}
480
 
1031 cejka 481
float32 int64_to_float32(int64_t i)
874 cejka 482
{
483
    float32 result;
484
 
485
    if (i < 0) {
1031 cejka 486
        result = uint64_to_float32((uint64_t)(-i));
874 cejka 487
    } else {
1031 cejka 488
        result = uint64_to_float32((uint64_t)i);
874 cejka 489
    }
490
 
491
    result.parts.sign = i < 0;
492
 
493
    return result;
494
}
876 cejka 495
 
496
/** Convert unsigned integer to float64
497
 *
498
 *
499
 */
1031 cejka 500
float64 uint32_to_float64(uint32_t i)
876 cejka 501
{
502
    int counter;
1031 cejka 503
    int32_t exp;
876 cejka 504
    float64 result;
1031 cejka 505
    uint64_t frac;
876 cejka 506
 
507
    result.parts.sign = 0;
508
    result.parts.fraction = 0;
509
 
510
    counter = countZeroes32(i);
511
 
512
    exp = FLOAT64_BIAS + 32 - counter - 1;
513
 
514
    if (counter == 32) {
515
        result.binary = 0;
516
        return result;
517
    }
518
 
519
    frac = i;
520
    frac <<= counter + 32 - 1;
521
 
522
    roundFloat64(&exp, &frac);
523
 
524
    result.parts.fraction = frac >> 10;
525
    result.parts.exp = exp;
526
 
527
    return result;
528
}
529
 
1031 cejka 530
float64 int32_to_float64(int32_t i)
876 cejka 531
{
532
    float64 result;
533
 
534
    if (i < 0) {
1031 cejka 535
        result = uint32_to_float64((uint32_t)(-i));
876 cejka 536
    } else {
1031 cejka 537
        result = uint32_to_float64((uint32_t)i);
876 cejka 538
    }
539
 
540
    result.parts.sign = i < 0;
541
 
542
    return result;
543
}
544
 
545
 
1031 cejka 546
float64 uint64_to_float64(uint64_t i)
876 cejka 547
{
548
    int counter;
1031 cejka 549
    int32_t exp;
876 cejka 550
    float64 result;
551
 
552
    result.parts.sign = 0;
553
    result.parts.fraction = 0;
554
 
555
    counter = countZeroes64(i);
556
 
557
    exp = FLOAT64_BIAS + 64 - counter - 1;
558
 
559
    if (counter == 64) {
560
        result.binary = 0;
561
        return result;
562
    }
563
 
564
    if (counter > 0) {
565
        i <<= counter - 1;
566
    } else {
567
        i >>= 1;
568
    }
569
 
570
    roundFloat64(&exp, &i);
571
 
572
    result.parts.fraction = i >> 10;
573
    result.parts.exp = exp;
574
    return result;
575
}
576
 
1031 cejka 577
float64 int64_to_float64(int64_t i)
876 cejka 578
{
579
    float64 result;
580
 
581
    if (i < 0) {
1031 cejka 582
        result = uint64_to_float64((uint64_t)(-i));
876 cejka 583
    } else {
1031 cejka 584
        result = uint64_to_float64((uint64_t)i);
876 cejka 585
    }
586
 
587
    result.parts.sign = i < 0;
588
 
589
    return result;
590
}
591
 
592
 
1657 cejka 593
 
594
 /** @}
595
 */
596