← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to fpu/softfloat-specialize.h

  • Committer: Blue Swirl
  • Date: 2009-08-31 15:14:40 UTC
  • Revision ID: git-v1:528e93a9787ccfc59582a44035f5f342caf5b84f
Fix breakage due to __thread

Thread-local storage is not supported on all hosts.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
fpu/softfloat-specialize.h
37
37
#endif
38
38
 
39
39
/*----------------------------------------------------------------------------
40
 
| Underflow tininess-detection mode, statically initialized to default value.
41
 
| (The declaration in `softfloat.h' must match the `int8' type here.)
42
 
*----------------------------------------------------------------------------*/
43
 
int8 float_detect_tininess = float_tininess_after_rounding;
44
 
 
45
 
/*----------------------------------------------------------------------------
46
40
| Raises the exceptions specified by `flags'.  Floating-point traps can be
47
41
| defined here if desired.  It is currently not possible for such a trap
48
42
| to substitute a result value.  If traps are not implemented, this routine
67
61
*----------------------------------------------------------------------------*/
68
62
#if defined(TARGET_SPARC)
69
63
#define float32_default_nan make_float32(0x7FFFFFFF)
70
 
#elif defined(TARGET_POWERPC)
 
64
#elif defined(TARGET_POWERPC) || defined(TARGET_ARM)
71
65
#define float32_default_nan make_float32(0x7FC00000)
72
66
#elif defined(TARGET_HPPA)
73
67
#define float32_default_nan make_float32(0x7FA00000)
150
144
    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
151
145
    bits32 av, bv, res;
152
146
 
 
147
    if ( STATUS(default_nan_mode) )
 
148
        return float32_default_nan;
 
149
 
153
150
    aIsNaN = float32_is_nan( a );
154
151
    aIsSignalingNaN = float32_is_signaling_nan( a );
155
152
    bIsNaN = float32_is_nan( b );
169
166
        res = bIsNaN ? bv : av;
170
167
    }
171
168
    else if ( aIsNaN ) {
172
 
        if ( bIsSignalingNaN | ! bIsNaN )
 
169
        if ( bIsSignalingNaN || ! bIsNaN )
173
170
            res = av;
174
171
        else {
175
172
 returnLargerSignificand:
192
189
*----------------------------------------------------------------------------*/
193
190
#if defined(TARGET_SPARC)
194
191
#define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF ))
195
 
#elif defined(TARGET_POWERPC)
 
192
#elif defined(TARGET_POWERPC) || defined(TARGET_ARM)
196
193
#define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 ))
197
194
#elif defined(TARGET_HPPA)
198
195
#define float64_default_nan make_float64(LIT64( 0x7FF4000000000000 ))
282
279
    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
283
280
    bits64 av, bv, res;
284
281
 
 
282
    if ( STATUS(default_nan_mode) )
 
283
        return float64_default_nan;
 
284
 
285
285
    aIsNaN = float64_is_nan( a );
286
286
    aIsSignalingNaN = float64_is_signaling_nan( a );
287
287
    bIsNaN = float64_is_nan( b );
301
301
        res = bIsNaN ? bv : av;
302
302
    }
303
303
    else if ( aIsNaN ) {
304
 
        if ( bIsSignalingNaN | ! bIsNaN )
 
304
        if ( bIsSignalingNaN || ! bIsNaN )
305
305
            res = av;
306
306
        else {
307
307
 returnLargerSignificand:
418
418
{
419
419
    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
420
420
 
 
421
    if ( STATUS(default_nan_mode) ) {
 
422
        a.low = floatx80_default_nan_low;
 
423
        a.high = floatx80_default_nan_high;
 
424
        return a;
 
425
    }
 
426
 
421
427
    aIsNaN = floatx80_is_nan( a );
422
428
    aIsSignalingNaN = floatx80_is_signaling_nan( a );
423
429
    bIsNaN = floatx80_is_nan( b );
435
441
        return bIsNaN ? b : a;
436
442
    }
437
443
    else if ( aIsNaN ) {
438
 
        if ( bIsSignalingNaN | ! bIsNaN ) return a;
 
444
        if ( bIsSignalingNaN || ! bIsNaN ) return a;
439
445
 returnLargerSignificand:
440
446
        if ( a.low < b.low ) return b;
441
447
        if ( b.low < a.low ) return a;
538
544
{
539
545
    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
540
546
 
 
547
    if ( STATUS(default_nan_mode) ) {
 
548
        a.low = float128_default_nan_low;
 
549
        a.high = float128_default_nan_high;
 
550
        return a;
 
551
    }
 
552
 
541
553
    aIsNaN = float128_is_nan( a );
542
554
    aIsSignalingNaN = float128_is_signaling_nan( a );
543
555
    bIsNaN = float128_is_nan( b );
555
567
        return bIsNaN ? b : a;
556
568
    }
557
569
    else if ( aIsNaN ) {
558
 
        if ( bIsSignalingNaN | ! bIsNaN ) return a;
 
570
        if ( bIsSignalingNaN || ! bIsNaN ) return a;
559
571
 returnLargerSignificand:
560
572
        if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
561
573
        if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;