Loading...
Searching...
No Matches
softfloat.h File Reference
Include dependency graph for softfloat.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Macros | |
| #define | THREAD_LOCAL |
Enumerations | |
| enum | { softfloat_tininess_beforeRounding = 0 , softfloat_tininess_afterRounding = 1 } |
| enum | { softfloat_round_near_even = 0 , softfloat_round_minMag = 1 , softfloat_round_min = 2 , softfloat_round_max = 3 , softfloat_round_near_maxMag = 4 , softfloat_round_odd = 6 } |
| enum | { softfloat_flag_inexact = 1 , softfloat_flag_underflow = 2 , softfloat_flag_overflow = 4 , softfloat_flag_infinite = 8 , softfloat_flag_invalid = 16 } |
Macro Definition Documentation
◆ THREAD_LOCAL
| #define THREAD_LOCAL |
Definition at line 54 of file softfloat.h.
Enumeration Type Documentation
◆ anonymous enum
| anonymous enum |
| Enumerator | |
|---|---|
| softfloat_tininess_beforeRounding | |
| softfloat_tininess_afterRounding | |
Definition at line 61 of file softfloat.h.
61 {
64};
◆ anonymous enum
| anonymous enum |
| Enumerator | |
|---|---|
| softfloat_round_near_even | |
| softfloat_round_minMag | |
| softfloat_round_min | |
| softfloat_round_max | |
| softfloat_round_near_maxMag | |
| softfloat_round_odd | |
Definition at line 71 of file softfloat.h.
71 {
72 softfloat_round_near_even = 0,
73 softfloat_round_minMag = 1,
74 softfloat_round_min = 2,
75 softfloat_round_max = 3,
76 softfloat_round_near_maxMag = 4,
77 softfloat_round_odd = 6
78};
◆ anonymous enum
| anonymous enum |
| Enumerator | |
|---|---|
| softfloat_flag_inexact | |
| softfloat_flag_underflow | |
| softfloat_flag_overflow | |
| softfloat_flag_infinite | |
| softfloat_flag_invalid | |
Definition at line 84 of file softfloat.h.
84 {
85 softfloat_flag_inexact = 1,
86 softfloat_flag_underflow = 2,
87 softfloat_flag_overflow = 4,
88 softfloat_flag_infinite = 8,
89 softfloat_flag_invalid = 16
90};
Function Documentation
◆ extF80M_add()
| void extF80M_add | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr, | ||
| extFloat80_t * | zPtr ) |
Definition at line 86 of file extF80M_add.c.
88{
89
94 false
95 );
96
97}
void softfloat_addExtF80M(const struct extFloat80M *, const struct extFloat80M *, struct extFloat80M *, bool)
Definition s_addExtF80M.c:45
Definition softfloat_types.h:63
◆ extF80M_div()
| void extF80M_div | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr, | ||
| extFloat80_t * | zPtr ) |
Definition at line 58 of file extF80M_div.c.
60{
63 uint_fast16_t uiA64;
64 int32_t expA;
65 uint_fast16_t uiB64;
66 int32_t expB;
67 bool signZ;
68 uint64_t sigA, x64;
69 int32_t expZ;
70 int shiftDist;
72 int ix;
73 uint32_t q, qs[2];
74 uint_fast16_t uiZ64;
75 uint64_t uiZ0;
76
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
82 /*------------------------------------------------------------------------
83 *------------------------------------------------------------------------*/
84 uiA64 = aSPtr->signExp;
85 expA = expExtF80UI64( uiA64 );
86 uiB64 = bSPtr->signExp;
87 expB = expExtF80UI64( uiB64 );
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
91 if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
93 if ( expA == 0x7FFF ) {
94 if ( expB == 0x7FFF ) goto invalid;
95 goto infinity;
96 }
97 goto zero;
98 }
99 /*------------------------------------------------------------------------
100 *------------------------------------------------------------------------*/
101 sigA = aSPtr->signif;
102 x64 = bSPtr->signif;
103 if ( ! expB ) expB = 1;
105 if ( ! x64 ) {
106 if ( ! sigA ) goto invalid;
108 goto infinity;
109 }
110 expB += softfloat_normExtF80SigM( &x64 );
111 }
112 if ( ! expA ) expA = 1;
114 if ( ! sigA ) goto zero;
115 expA += softfloat_normExtF80SigM( &sigA );
116 }
117 /*------------------------------------------------------------------------
118 *------------------------------------------------------------------------*/
119 expZ = expA - expB + 0x3FFF;
120 shiftDist = 29;
121 if ( sigA < x64 ) {
122 --expZ;
123 shiftDist = 30;
124 }
125 softfloat_shortShiftLeft64To96M( sigA, shiftDist, y );
126 recip32 = softfloat_approxRecip32_1( x64>>32 );
128 x64 >>= 2;
129 sigB[indexWord( 3, 2 )] = x64>>32;
130 sigB[indexWord( 3, 1 )] = x64;
131 ix = 2;
132 for (;;) {
134 q = (x64 + 0x80000000)>>32;
135 --ix;
136 if ( ix < 0 ) break;
137 softfloat_remStep96MBy32( y, 29, sigB, q, y );
139 --q;
140 softfloat_add96M( y, sigB, y );
141 }
142 qs[ix] = q;
143 }
144 /*------------------------------------------------------------------------
145 *------------------------------------------------------------------------*/
146 if ( ((q + 1) & 0x3FFFFF) < 2 ) {
147 softfloat_remStep96MBy32( y, 29, sigB, q, y );
149 --q;
150 softfloat_add96M( y, sigB, y );
152 ++q;
153 softfloat_sub96M( y, sigB, y );
154 }
155 if (
157 ) {
158 q |= 1;
159 }
160 }
161 /*------------------------------------------------------------------------
162 *------------------------------------------------------------------------*/
163 x64 = (uint64_t) q<<9;
165 x64 = ((uint64_t) qs[0]<<6) + (x64>>32);
169 signZ, expZ, y, extF80_roundingPrecision, zSPtr );
170 return;
171 /*------------------------------------------------------------------------
172 *------------------------------------------------------------------------*/
173 invalid:
174 softfloat_invalidExtF80M( zSPtr );
175 return;
176 /*------------------------------------------------------------------------
177 *------------------------------------------------------------------------*/
178 infinity:
179 uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
180 uiZ0 = UINT64_C( 0x8000000000000000 );
181 goto uiZ;
182 /*------------------------------------------------------------------------
183 *------------------------------------------------------------------------*/
184 zero:
185 uiZ64 = packToExtF80UI64( signZ, 0 );
186 uiZ0 = 0;
187 uiZ:
188 zSPtr->signExp = uiZ64;
189 zSPtr->signif = uiZ0;
190
191}
void softfloat_raiseFlags(uint_fast8_t flags)
Definition softfloat_raiseFlags.c:46
void softfloat_invalidExtF80M(struct extFloat80M *)
Definition s_invalidExtF80M.c:41
void softfloat_roundPackMToExtF80M(bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M *)
Definition s_roundPackMToExtF80M.c:44
bool softfloat_tryPropagateNaNExtF80M(const struct extFloat80M *, const struct extFloat80M *, struct extFloat80M *)
Definition s_tryPropagateNaNExtF80M.c:43
int_fast8_t softfloat_compare96M(const uint32_t *aPtr, const uint32_t *bPtr)
Definition s_compare96M.c:43
#define softfloat_remStep96MBy32(remPtr, dist, bPtr, q, zPtr)
Definition primitives.h:1138
void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t *zPtr)
Definition s_shortShiftLeft64To96M.c:44
uint32_t softfloat_approxRecip32_1(uint32_t a)
Definition s_approxRecip32_1.c:45
THREAD_LOCAL uint_fast8_t extF80_roundingPrecision
Definition softfloat_state.c:51
◆ extF80M_eq()
| bool extF80M_eq | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr ) |
Definition at line 55 of file extF80M_eq.c.
56{
58 uint_fast16_t uiA64;
59 uint64_t uiA0;
60 uint_fast16_t uiB64;
61 uint64_t uiB0;
62
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
69 uiA64 = aSPtr->signExp;
70 uiA0 = aSPtr->signif;
71 uiB64 = bSPtr->signExp;
72 uiB0 = bSPtr->signif;
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
76 if (
77 softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
78 || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
79 ) {
81 }
82 return false;
83 }
84 /*------------------------------------------------------------------------
85 *------------------------------------------------------------------------*/
86 if ( uiA0 == uiB0 ) {
87 return (uiA64 == uiB64) || ! uiA0;
88 } else {
91 }
92 return false;
93 }
94
95}
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)
Definition specialize.h:202
int softfloat_compareNonnormExtF80M(const struct extFloat80M *, const struct extFloat80M *)
Definition s_compareNonnormExtF80M.c:43
◆ extF80M_eq_signaling()
| bool extF80M_eq_signaling | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr ) |
Definition at line 54 of file extF80M_eq_signaling.c.
55{
57 uint_fast16_t uiA64;
58 uint64_t uiA0;
59 uint_fast16_t uiB64;
60 uint64_t uiB0;
61
62 /*------------------------------------------------------------------------
63 *------------------------------------------------------------------------*/
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
68 uiA64 = aSPtr->signExp;
69 uiA0 = aSPtr->signif;
70 uiB64 = bSPtr->signExp;
71 uiB0 = bSPtr->signif;
72 /*------------------------------------------------------------------------
73 *------------------------------------------------------------------------*/
76 return false;
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 if ( uiA0 == uiB0 ) {
81 return (uiA64 == uiB64) || ! uiA0;
82 } else {
85 }
86 return false;
87 }
88
89}
◆ extF80M_isSignalingNaN()
| bool extF80M_isSignalingNaN | ( | const extFloat80_t * | aPtr | ) |
◆ extF80M_le()
| bool extF80M_le | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr ) |
Definition at line 54 of file extF80M_le.c.
55{
57 uint_fast16_t uiA64;
58 uint64_t uiA0;
59 uint_fast16_t uiB64;
60 uint64_t uiB0;
61 bool signA, ltMags;
62
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
69 uiA64 = aSPtr->signExp;
70 uiA0 = aSPtr->signif;
71 uiB64 = bSPtr->signExp;
72 uiB0 = bSPtr->signif;
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
77 return false;
78 }
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 signA = signExtF80UI64( uiA64 );
82 if ( (uiA64 ^ uiB64) & 0x8000 ) {
83 /*--------------------------------------------------------------------
84 | Signs are different.
85 *--------------------------------------------------------------------*/
86 return signA || ! (uiA0 | uiB0);
87 } else {
88 /*--------------------------------------------------------------------
89 | Signs are the same.
90 *--------------------------------------------------------------------*/
93 }
94 if ( uiA64 == uiB64 ) {
95 if ( uiA0 == uiB0 ) return true;
96 ltMags = (uiA0 < uiB0);
97 } else {
98 ltMags = (uiA64 < uiB64);
99 }
100 return signA ^ ltMags;
101 }
102
103}
◆ extF80M_le_quiet()
| bool extF80M_le_quiet | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr ) |
Definition at line 55 of file extF80M_le_quiet.c.
56{
58 uint_fast16_t uiA64;
59 uint64_t uiA0;
60 uint_fast16_t uiB64;
61 uint64_t uiB0;
62 bool signA, ltMags;
63
64 /*------------------------------------------------------------------------
65 *------------------------------------------------------------------------*/
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
70 uiA64 = aSPtr->signExp;
71 uiA0 = aSPtr->signif;
72 uiB64 = bSPtr->signExp;
73 uiB0 = bSPtr->signif;
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
77 if (
78 softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
79 || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
80 ) {
82 }
83 return false;
84 }
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
87 signA = signExtF80UI64( uiA64 );
88 if ( (uiA64 ^ uiB64) & 0x8000 ) {
89 /*--------------------------------------------------------------------
90 | Signs are different.
91 *--------------------------------------------------------------------*/
92 return signA || ! (uiA0 | uiB0);
93 } else {
94 /*--------------------------------------------------------------------
95 | Signs are the same.
96 *--------------------------------------------------------------------*/
99 }
100 if ( uiA64 == uiB64 ) {
101 if ( uiA0 == uiB0 ) return true;
102 ltMags = (uiA0 < uiB0);
103 } else {
104 ltMags = (uiA64 < uiB64);
105 }
106 return signA ^ ltMags;
107 }
108
109}
◆ extF80M_lt()
| bool extF80M_lt | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr ) |
Definition at line 54 of file extF80M_lt.c.
55{
57 uint_fast16_t uiA64;
58 uint64_t uiA0;
59 uint_fast16_t uiB64;
60 uint64_t uiB0;
61 bool signA, ltMags;
62
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
69 uiA64 = aSPtr->signExp;
70 uiA0 = aSPtr->signif;
71 uiB64 = bSPtr->signExp;
72 uiB0 = bSPtr->signif;
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
77 return false;
78 }
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 signA = signExtF80UI64( uiA64 );
82 if ( (uiA64 ^ uiB64) & 0x8000 ) {
83 /*--------------------------------------------------------------------
84 | Signs are different.
85 *--------------------------------------------------------------------*/
86 return signA && ((uiA0 | uiB0) != 0);
87 } else {
88 /*--------------------------------------------------------------------
89 | Signs are the same.
90 *--------------------------------------------------------------------*/
93 }
94 if ( uiA64 == uiB64 ) {
95 if ( uiA0 == uiB0 ) return false;
96 ltMags = (uiA0 < uiB0);
97 } else {
98 ltMags = (uiA64 < uiB64);
99 }
100 return signA ^ ltMags;
101 }
102
103}
◆ extF80M_lt_quiet()
| bool extF80M_lt_quiet | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr ) |
Definition at line 55 of file extF80M_lt_quiet.c.
56{
58 uint_fast16_t uiA64;
59 uint64_t uiA0;
60 uint_fast16_t uiB64;
61 uint64_t uiB0;
62 bool signA, ltMags;
63
64 /*------------------------------------------------------------------------
65 *------------------------------------------------------------------------*/
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
70 uiA64 = aSPtr->signExp;
71 uiA0 = aSPtr->signif;
72 uiB64 = bSPtr->signExp;
73 uiB0 = bSPtr->signif;
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
77 if (
78 softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
79 || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
80 ) {
82 }
83 return false;
84 }
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
87 signA = signExtF80UI64( uiA64 );
88 if ( (uiA64 ^ uiB64) & 0x8000 ) {
89 /*--------------------------------------------------------------------
90 | Signs are different.
91 *--------------------------------------------------------------------*/
92 return signA && ((uiA0 | uiB0) != 0);
93 } else {
94 /*--------------------------------------------------------------------
95 | Signs are the same.
96 *--------------------------------------------------------------------*/
99 }
100 if ( uiA64 == uiB64 ) {
101 if ( uiA0 == uiB0 ) return false;
102 ltMags = (uiA0 < uiB0);
103 } else {
104 ltMags = (uiA64 < uiB64);
105 }
106 return signA ^ ltMags;
107 }
108
109}
◆ extF80M_mul()
| void extF80M_mul | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr, | ||
| extFloat80_t * | zPtr ) |
Definition at line 58 of file extF80M_mul.c.
60{
63 uint_fast16_t uiA64;
64 int32_t expA;
65 uint_fast16_t uiB64;
66 int32_t expB;
67 bool signZ;
68 uint_fast16_t exp, uiZ64;
69 uint64_t uiZ0, sigA, sigB;
70 int32_t expZ;
71 uint32_t sigProd[4], *extSigZPtr;
72
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 uiA64 = aSPtr->signExp;
81 expA = expExtF80UI64( uiA64 );
82 uiB64 = bSPtr->signExp;
83 expB = expExtF80UI64( uiB64 );
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
87 if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
89 if (
90 (! aSPtr->signif && (expA != 0x7FFF))
91 || (! bSPtr->signif && (expB != 0x7FFF))
92 ) {
93 softfloat_invalidExtF80M( zSPtr );
94 return;
95 }
96 uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
97 uiZ0 = UINT64_C( 0x8000000000000000 );
98 goto uiZ;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 if ( ! expA ) expA = 1;
103 sigA = aSPtr->signif;
105 if ( ! sigA ) goto zero;
106 expA += softfloat_normExtF80SigM( &sigA );
107 }
108 if ( ! expB ) expB = 1;
109 sigB = bSPtr->signif;
111 if ( ! sigB ) goto zero;
112 expB += softfloat_normExtF80SigM( &sigB );
113 }
114 /*------------------------------------------------------------------------
115 *------------------------------------------------------------------------*/
116 expZ = expA + expB - 0x3FFE;
117 softfloat_mul64To128M( sigA, sigB, sigProd );
119 extSigZPtr = &sigProd[indexMultiwordHi( 4, 3 )];
121 --expZ;
122 softfloat_add96M( extSigZPtr, extSigZPtr, extSigZPtr );
123 }
125 signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
126 return;
127 /*------------------------------------------------------------------------
128 *------------------------------------------------------------------------*/
129 zero:
130 uiZ64 = packToExtF80UI64( signZ, 0 );
131 uiZ0 = 0;
132 uiZ:
133 zSPtr->signExp = uiZ64;
134 zSPtr->signif = uiZ0;
135
136}
void softfloat_mul64To128M(uint64_t a, uint64_t b, uint32_t *zPtr)
Definition s_mul64To128M.c:43
◆ extF80M_rem()
| void extF80M_rem | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr, | ||
| extFloat80_t * | zPtr ) |
Definition at line 58 of file extF80M_rem.c.
60{
63 uint_fast16_t uiA64;
64 int32_t expA, expB;
65 uint64_t x64;
66 bool signRem;
67 uint64_t sigA;
68 int32_t expDiff;
69 uint32_t rem[3], x[3], sig32B, q, recip32, rem2[3], *remPtr, *altRemPtr;
70 uint32_t *newRemPtr, wordMeanRem;
71
72 /*------------------------------------------------------------------------
73 *------------------------------------------------------------------------*/
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
79 uiA64 = aSPtr->signExp;
80 expA = expExtF80UI64( uiA64 );
82 /*------------------------------------------------------------------------
83 *------------------------------------------------------------------------*/
84 if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
86 if ( expA == 0x7FFF ) goto invalid;
87 /*--------------------------------------------------------------------
88 | If we get here, then argument b is an infinity and `expB' is 0x7FFF;
89 | Doubling `expB' is an easy way to ensure that `expDiff' later is
90 | less than -1, which will result in returning a canonicalized version
91 | of argument a.
92 *--------------------------------------------------------------------*/
93 expB += expB;
94 }
95 /*------------------------------------------------------------------------
96 *------------------------------------------------------------------------*/
97 if ( ! expB ) expB = 1;
98 x64 = bSPtr->signif;
100 if ( ! x64 ) goto invalid;
101 expB += softfloat_normExtF80SigM( &x64 );
102 }
103 signRem = signExtF80UI64( uiA64 );
104 if ( ! expA ) expA = 1;
105 sigA = aSPtr->signif;
107 if ( ! sigA ) {
108 expA = 0;
109 goto copyA;
110 }
111 expA += softfloat_normExtF80SigM( &sigA );
112 }
113 /*------------------------------------------------------------------------
114 *------------------------------------------------------------------------*/
115 expDiff = expA - expB;
116 if ( expDiff < -1 ) goto copyA;
117 rem[indexWord( 3, 2 )] = sigA>>34;
118 rem[indexWord( 3, 1 )] = sigA>>2;
121 sig32B = x64>>32;
122 x64 >>= 2;
123 x[indexWord( 3, 2 )] = x64>>32;
124 x[indexWord( 3, 1 )] = x64;
125 if ( expDiff < 1 ) {
126 if ( expDiff ) {
127 --expB;
128 softfloat_add96M( x, x, x );
129 q = 0;
130 } else {
131 q = (softfloat_compare96M( x, rem ) <= 0);
133 }
134 } else {
135 recip32 = softfloat_approxRecip32_1( sig32B );
136 expDiff -= 30;
137 for (;;) {
139 if ( expDiff < 0 ) break;
140 q = (x64 + 0x80000000)>>32;
141 softfloat_remStep96MBy32( rem, 29, x, q, rem );
143 softfloat_add96M( rem, x, rem );
144 }
145 expDiff -= 29;
146 }
147 /*--------------------------------------------------------------------
148 | (`expDiff' cannot be less than -29 here.)
149 *--------------------------------------------------------------------*/
150 q = (uint32_t) (x64>>32)>>(~expDiff & 31);
151 softfloat_remStep96MBy32( rem, expDiff + 30, x, q, rem );
153 remPtr = rem;
154 altRemPtr = rem2;
155 softfloat_add96M( remPtr, x, altRemPtr );
156 goto selectRem;
157 }
158 }
159 /*------------------------------------------------------------------------
160 *------------------------------------------------------------------------*/
161 remPtr = rem;
162 altRemPtr = rem2;
163 do {
164 ++q;
165 newRemPtr = altRemPtr;
166 softfloat_sub96M( remPtr, x, newRemPtr );
167 altRemPtr = remPtr;
168 remPtr = newRemPtr;
170 selectRem:
171 softfloat_add96M( remPtr, altRemPtr, x );
172 wordMeanRem = x[indexWordHi( 3 )];
173 if (
174 (wordMeanRem & 0x80000000)
175 || (! wordMeanRem && (q & 1) && ! x[indexWord( 3, 0 )]
176 && ! x[indexWord( 3, 1 )])
177 ) {
178 remPtr = altRemPtr;
179 }
181 signRem = ! signRem;
182 softfloat_negX96M( remPtr );
183 }
184 softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr );
185 return;
186 /*------------------------------------------------------------------------
187 *------------------------------------------------------------------------*/
188 invalid:
189 softfloat_invalidExtF80M( zSPtr );
190 return;
191 /*------------------------------------------------------------------------
192 *------------------------------------------------------------------------*/
193 copyA:
194 if ( expA < 1 ) {
195 sigA >>= 1 - expA;
196 expA = 0;
197 }
199 zSPtr->signif = sigA;
200
201}
void softfloat_normRoundPackMToExtF80M(bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M *)
Definition s_normRoundPackMToExtF80M.c:43
◆ extF80M_roundToInt()
| void extF80M_roundToInt | ( | const extFloat80_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact, | ||
| extFloat80_t * | zPtr ) |
Definition at line 62 of file extF80M_roundToInt.c.
68{
71 uint_fast16_t uiA64, signUI64;
72 int32_t exp;
73 uint64_t sigA;
74 uint_fast16_t uiZ64;
75 uint64_t sigZ, lastBitMask, roundBitsMask;
76
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
81 /*------------------------------------------------------------------------
82 *------------------------------------------------------------------------*/
83 uiA64 = aSPtr->signExp;
84 signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
85 exp = expExtF80UI64( uiA64 );
86 sigA = aSPtr->signif;
87 /*------------------------------------------------------------------------
88 *------------------------------------------------------------------------*/
90 if ( !sigA ) {
91 uiZ64 = signUI64;
92 sigZ = 0;
93 goto uiZ;
94 }
95 exp += softfloat_normExtF80SigM( &sigA );
96 }
97 /*------------------------------------------------------------------------
98 *------------------------------------------------------------------------*/
99 if ( exp <= 0x3FFE ) {
101 switch ( roundingMode ) {
105 if ( exp == 0x3FFE ) goto mag1;
106 break;
108 if ( signUI64 ) goto mag1;
109 break;
111 if ( !signUI64 ) goto mag1;
112 break;
113#ifdef SOFTFLOAT_ROUND_ODD
115 goto mag1;
116#endif
117 }
118 uiZ64 = signUI64;
119 sigZ = 0;
120 goto uiZ;
121 mag1:
122 uiZ64 = signUI64 | 0x3FFF;
123 sigZ = UINT64_C( 0x8000000000000000 );
124 goto uiZ;
125 }
126 /*------------------------------------------------------------------------
127 *------------------------------------------------------------------------*/
128 if ( 0x403E <= exp ) {
129 if ( exp == 0x7FFF ) {
131 softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
132 return;
133 }
134 sigZ = UINT64_C( 0x8000000000000000 );
135 } else {
136 sigZ = sigA;
137 }
138 uiZ64 = signUI64 | exp;
139 goto uiZ;
140 }
141 /*------------------------------------------------------------------------
142 *------------------------------------------------------------------------*/
143 uiZ64 = signUI64 | exp;
144 lastBitMask = (uint64_t) 1<<(0x403E - exp);
145 roundBitsMask = lastBitMask - 1;
146 sigZ = sigA;
148 sigZ += lastBitMask>>1;
150 sigZ += lastBitMask>>1;
151 if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
152 } else if (
154 ) {
155 sigZ += roundBitsMask;
156 }
157 sigZ &= ~roundBitsMask;
158 if ( !sigZ ) {
159 ++uiZ64;
160 sigZ = UINT64_C( 0x8000000000000000 );
161 }
162 if ( sigZ != sigA ) {
163#ifdef SOFTFLOAT_ROUND_ODD
165#endif
167 }
168 uiZ:
169 zSPtr->signExp = uiZ64;
170 zSPtr->signif = sigZ;
171 return;
172
173}
void softfloat_propagateNaNExtF80M(const struct extFloat80M *aSPtr, const struct extFloat80M *bSPtr, struct extFloat80M *zSPtr)
Definition s_propagateNaNExtF80M.c:51
THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags
Definition softfloat_state.c:49
◆ extF80M_sqrt()
| void extF80M_sqrt | ( | const extFloat80_t * | aPtr, |
| extFloat80_t * | zPtr ) |
Definition at line 55 of file extF80M_sqrt.c.
56{
59 uint_fast16_t uiA64, signUI64;
60 int32_t expA;
61 uint64_t rem64;
62 int32_t expZ;
63 uint32_t rem96[3], sig32A, recipSqrt32, sig32Z, q;
64 uint64_t sig64Z, x64;
65 uint32_t rem32, term[4], rem[4], extSigZ[3];
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
71 /*------------------------------------------------------------------------
72 *------------------------------------------------------------------------*/
73 uiA64 = aSPtr->signExp;
74 signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
75 expA = expExtF80UI64( uiA64 );
76 rem64 = aSPtr->signif;
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
79 if ( expA == 0x7FFF ) {
81 softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
82 return;
83 }
84 if ( signUI64 ) goto invalid;
85 rem64 = UINT64_C( 0x8000000000000000 );
86 goto copyA;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( ! expA ) expA = 1;
92 if ( ! rem64 ) {
93 uiA64 = signUI64;
94 goto copyA;
95 }
96 expA += softfloat_normExtF80SigM( &rem64 );
97 }
98 if ( signUI64 ) goto invalid;
99 /*------------------------------------------------------------------------
100 *------------------------------------------------------------------------*/
101 expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
102 expA &= 1;
103 softfloat_shortShiftLeft64To96M( rem64, 30 - expA, rem96 );
104 sig32A = rem64>>32;
105 recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
106 sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
107 if ( expA ) sig32Z >>= 1;
108 rem64 =
110 - (uint64_t) sig32Z * sig32Z;
111 rem96[indexWord( 3, 2 )] = rem64>>32;
112 rem96[indexWord( 3, 1 )] = rem64;
113 /*------------------------------------------------------------------------
114 *------------------------------------------------------------------------*/
117 term[indexWord( 3, 2 )] = 0;
118 /*------------------------------------------------------------------------
119 | (Repeating this loop is a rare occurrence.)
120 *------------------------------------------------------------------------*/
121 for (;;) {
122 x64 = ((uint64_t) sig32Z<<32) + sig64Z;
123 term[indexWord( 3, 1 )] = x64>>32;
124 term[indexWord( 3, 0 )] = x64;
126 rem96, 29, term, q, &rem[indexMultiwordHi( 4, 3 )] );
127 rem32 = rem[indexWord( 4, 3 )];
128 if ( ! (rem32 & 0x80000000) ) break;
129 --q;
130 sig64Z -= 1<<3;
131 }
133 /*------------------------------------------------------------------------
134 *------------------------------------------------------------------------*/
136 if ( rem64>>34 ) q += recipSqrt32;
137 x64 = (uint64_t) q<<7;
138 extSigZ[indexWord( 3, 0 )] = x64;
139 x64 = (sig64Z<<1) + (x64>>32);
140 extSigZ[indexWord( 3, 2 )] = x64>>32;
141 extSigZ[indexWord( 3, 1 )] = x64;
142 /*------------------------------------------------------------------------
143 *------------------------------------------------------------------------*/
144 if ( (q & 0xFFFFFF) <= 2 ) {
145 q &= ~(uint32_t) 0xFFFF;
146 extSigZ[indexWordLo( 3 )] = q<<7;
147 x64 = sig64Z + (q>>27);
148 term[indexWord( 4, 3 )] = 0;
149 term[indexWord( 4, 2 )] = x64>>32;
150 term[indexWord( 4, 1 )] = x64;
151 term[indexWord( 4, 0 )] = q<<5;
152 rem[indexWord( 4, 0 )] = 0;
153 softfloat_remStep128MBy32( rem, 28, term, q, rem );
154 q = rem[indexWordHi( 4 )];
155 if ( q & 0x80000000 ) {
156 softfloat_sub1X96M( extSigZ );
157 } else {
159 extSigZ[indexWordLo( 3 )] |= 1;
160 }
161 }
162 }
164 0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
165 return;
166 /*------------------------------------------------------------------------
167 *------------------------------------------------------------------------*/
168 invalid:
169 softfloat_invalidExtF80M( zSPtr );
170 return;
171 /*------------------------------------------------------------------------
172 *------------------------------------------------------------------------*/
173 copyA:
174 zSPtr->signExp = uiA64;
175 zSPtr->signif = rem64;
176
177}
#define softfloat_remStep128MBy32(remPtr, dist, bPtr, q, zPtr)
Definition primitives.h:1146
uint32_t softfloat_approxRecipSqrt32_1(unsigned int oddExpA, uint32_t a)
Definition s_approxRecipSqrt32_1.c:45
◆ extF80M_sub()
| void extF80M_sub | ( | const extFloat80_t * | aPtr, |
| const extFloat80_t * | bPtr, | ||
| extFloat80_t * | zPtr ) |
Definition at line 86 of file extF80M_sub.c.
88{
89
94 true
95 );
96
97}
◆ extF80M_to_f128M()
| void extF80M_to_f128M | ( | const extFloat80_t * | aPtr, |
| float128_t * | zPtr ) |
Definition at line 55 of file extF80M_to_f128M.c.
56{
58 uint32_t *zWPtr;
59 uint_fast16_t uiA64;
60 bool sign;
61 int32_t exp;
62 uint64_t sig;
64 uint32_t uiZ96;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 zWPtr = (uint32_t *) zPtr;
70 /*------------------------------------------------------------------------
71 *------------------------------------------------------------------------*/
72 uiA64 = aSPtr->signExp;
73 sign = signExtF80UI64( uiA64 );
74 exp = expExtF80UI64( uiA64 );
75 sig = aSPtr->signif;
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 zWPtr[indexWord( 4, 0 )] = 0;
79 if ( exp == 0x7FFF ) {
83 return;
84 }
85 uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
86 goto uiZ;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( exp ) --exp;
92 if ( ! sig ) {
93 uiZ96 = packToF128UI96( sign, 0, 0 );
94 goto uiZ;
95 }
96 exp += softfloat_normExtF80SigM( &sig );
97 }
98 /*------------------------------------------------------------------------
99 *------------------------------------------------------------------------*/
101 sig >>= 15;
102 zWPtr[indexWord( 4, 2 )] = sig;
103 if ( exp < 0 ) {
104 zWPtr[indexWordHi( 4 )] = sig>>32;
106 &zWPtr[indexMultiwordHi( 4, 3 )],
107 -exp,
108 &zWPtr[indexMultiwordHi( 4, 3 )]
109 );
110 exp = 0;
112 }
114 return;
115 /*------------------------------------------------------------------------
116 *------------------------------------------------------------------------*/
117 uiZ:
118 zWPtr[indexWord( 4, 3 )] = uiZ96;
119 zWPtr[indexWord( 4, 2 )] = 0;
120 zWPtr[indexWord( 4, 1 )] = 0;
121
122}
#define softfloat_extF80MToCommonNaN(aSPtr, zPtr)
Definition specialize.h:318
Definition specialize.h:76
◆ extF80M_to_f16()
| float16_t extF80M_to_f16 | ( | const extFloat80_t * | aPtr | ) |
Definition at line 55 of file extF80M_to_f16.c.
56{
58 uint_fast16_t uiA64;
59 bool sign;
60 int32_t exp;
61 uint64_t sig;
63 uint16_t uiZ, sig16;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 uiA64 = aSPtr->signExp;
72 sign = signExtF80UI64( uiA64 );
73 exp = expExtF80UI64( uiA64 );
74 sig = aSPtr->signif;
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp == 0x7FFF ) {
81 } else {
82 uiZ = packToF16UI( sign, 0x1F, 0 );
83 }
84 goto uiZ;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
89 if ( ! sig ) {
90 uiZ = packToF16UI( sign, 0, 0 );
91 goto uiZ;
92 }
93 exp += softfloat_normExtF80SigM( &sig );
94 }
95 /*------------------------------------------------------------------------
96 *------------------------------------------------------------------------*/
97 sig16 = softfloat_shortShiftRightJam64( sig, 49 );
98 exp -= 0x3FF1;
100 if ( exp < -0x40 ) exp = -0x40;
101 }
103 /*------------------------------------------------------------------------
104 *------------------------------------------------------------------------*/
105 uiZ:
106 uZ.ui = uiZ;
107 return uZ.f;
108
109}
float16_t softfloat_roundPackToF16(bool, int_fast16_t, uint_fast16_t)
Definition s_roundPackToF16.c:44
uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist)
Definition s_shortShiftRightJam64.c:42
Definition internals.h:45
◆ extF80M_to_f32()
| float32_t extF80M_to_f32 | ( | const extFloat80_t * | aPtr | ) |
Definition at line 55 of file extF80M_to_f32.c.
56{
58 uint_fast16_t uiA64;
59 bool sign;
60 int32_t exp;
61 uint64_t sig;
63 uint32_t uiZ, sig32;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 uiA64 = aSPtr->signExp;
72 sign = signExtF80UI64( uiA64 );
73 exp = expExtF80UI64( uiA64 );
74 sig = aSPtr->signif;
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp == 0x7FFF ) {
81 } else {
82 uiZ = packToF32UI( sign, 0xFF, 0 );
83 }
84 goto uiZ;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
89 if ( ! sig ) {
90 uiZ = packToF32UI( sign, 0, 0 );
91 goto uiZ;
92 }
93 exp += softfloat_normExtF80SigM( &sig );
94 }
95 /*------------------------------------------------------------------------
96 *------------------------------------------------------------------------*/
97 sig32 = softfloat_shortShiftRightJam64( sig, 33 );
98 exp -= 0x3F81;
100 if ( exp < -0x1000 ) exp = -0x1000;
101 }
103 /*------------------------------------------------------------------------
104 *------------------------------------------------------------------------*/
105 uiZ:
106 uZ.ui = uiZ;
107 return uZ.f;
108
109}
float32_t softfloat_roundPackToF32(bool, int_fast16_t, uint_fast32_t)
Definition s_roundPackToF32.c:44
Definition internals.h:46
◆ extF80M_to_f64()
| float64_t extF80M_to_f64 | ( | const extFloat80_t * | aPtr | ) |
Definition at line 55 of file extF80M_to_f64.c.
56{
58 uint_fast16_t uiA64;
59 bool sign;
60 int32_t exp;
61 uint64_t sig;
63 uint64_t uiZ;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 uiA64 = aSPtr->signExp;
72 sign = signExtF80UI64( uiA64 );
73 exp = expExtF80UI64( uiA64 );
74 sig = aSPtr->signif;
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp == 0x7FFF ) {
81 } else {
82 uiZ = packToF64UI( sign, 0x7FF, 0 );
83 }
84 goto uiZ;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
89 if ( ! sig ) {
90 uiZ = packToF64UI( sign, 0, 0 );
91 goto uiZ;
92 }
93 exp += softfloat_normExtF80SigM( &sig );
94 }
95 /*------------------------------------------------------------------------
96 *------------------------------------------------------------------------*/
97 sig = softfloat_shortShiftRightJam64( sig, 1 );
98 exp -= 0x3C01;
100 if ( exp < -0x1000 ) exp = -0x1000;
101 }
103 /*------------------------------------------------------------------------
104 *------------------------------------------------------------------------*/
105 uiZ:
106 uZ.ui = uiZ;
107 return uZ.f;
108
109}
float64_t softfloat_roundPackToF64(bool, int_fast16_t, uint_fast64_t)
Definition s_roundPackToF64.c:44
Definition internals.h:47
◆ extF80M_to_i32()
| int_fast32_t extF80M_to_i32 | ( | const extFloat80_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 58 of file extF80M_to_i32.c.
60{
62 uint_fast16_t uiA64;
63 bool sign;
64 int32_t exp;
65 uint64_t sig;
66 int32_t shiftDist;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uiA64 = aSPtr->signExp;
72 sign = signExtF80UI64( uiA64 );
73 exp = expExtF80UI64( uiA64 );
74 sig = aSPtr->signif;
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 shiftDist = 0x4032 - exp;
78 if ( shiftDist <= 0 ) {
79 if ( sig>>32 ) goto invalid;
80 if ( -32 < shiftDist ) {
81 sig <<= -shiftDist;
82 } else {
84 }
85 } else {
86 sig = softfloat_shiftRightJam64( sig, shiftDist );
87 }
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
91 invalid:
93 return
96
97}
int_fast32_t softfloat_roundToI32(bool, uint_fast64_t, uint_fast8_t, bool)
Definition s_roundToI32.c:45
uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist)
Definition s_shiftRightJam64.c:42
◆ extF80M_to_i32_r_minMag()
| int_fast32_t extF80M_to_i32_r_minMag | ( | const extFloat80_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file extF80M_to_i32_r_minMag.c.
56{
58 uint_fast16_t uiA64;
59 int32_t exp;
60 uint64_t sig;
61 int32_t shiftDist;
62 bool sign, raiseInexact;
63 int32_t z;
64 uint64_t shiftedSig;
65 uint32_t absZ;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uiA64 = aSPtr->signExp;
72 exp = expExtF80UI64( uiA64 );
73 sig = aSPtr->signif;
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( ! sig && (exp != 0x7FFF) ) return 0;
77 shiftDist = 0x403E - exp;
78 if ( 64 <= shiftDist ) {
79 raiseInexact = exact;
80 z = 0;
81 } else {
82 sign = signExtF80UI64( uiA64 );
83 raiseInexact = false;
84 if ( shiftDist < 0 ) {
85 if ( sig>>32 || (shiftDist <= -31) ) goto invalid;
87 if ( shiftedSig>>32 ) goto invalid;
88 absZ = shiftedSig;
89 } else {
90 shiftedSig = sig;
91 if ( shiftDist ) shiftedSig >>= shiftDist;
92 if ( shiftedSig>>32 ) goto invalid;
93 absZ = shiftedSig;
94 if ( exact && shiftDist ) {
95 raiseInexact = ((uint64_t) absZ<<shiftDist != sig);
96 }
97 }
98 if ( sign ) {
99 if ( 0x80000000 < absZ ) goto invalid;
100 u.ui = -absZ;
101 z = u.i;
102 } else {
103 if ( 0x80000000 <= absZ ) goto invalid;
104 z = absZ;
105 }
106 }
108 return z;
109 /*------------------------------------------------------------------------
110 *------------------------------------------------------------------------*/
111 invalid:
113 return
116
117}
◆ extF80M_to_i64()
| int_fast64_t extF80M_to_i64 | ( | const extFloat80_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 58 of file extF80M_to_i64.c.
60{
62 uint_fast16_t uiA64;
63 bool sign;
64 int32_t exp;
65 uint64_t sig;
66 int32_t shiftDist;
67 uint32_t extSig[3];
68
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
72 uiA64 = aSPtr->signExp;
73 sign = signExtF80UI64( uiA64 );
74 exp = expExtF80UI64( uiA64 );
75 sig = aSPtr->signif;
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 shiftDist = 0x403E - exp;
79 if ( shiftDist < 0 ) {
81 return
82 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
83 ? i64_fromNaN
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 extSig[indexWord( 3, 2 )] = sig>>32;
89 extSig[indexWord( 3, 1 )] = sig;
90 extSig[indexWord( 3, 0 )] = 0;
93
94}
int_fast64_t softfloat_roundMToI64(bool, uint32_t *, uint_fast8_t, bool)
Definition s_roundMToI64.c:45
#define softfloat_shiftRightJam96M(aPtr, dist, zPtr)
Definition primitives.h:873
◆ extF80M_to_i64_r_minMag()
| int_fast64_t extF80M_to_i64_r_minMag | ( | const extFloat80_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file extF80M_to_i64_r_minMag.c.
56{
58 uint_fast16_t uiA64;
59 int32_t exp;
60 uint64_t sig;
61 int32_t shiftDist;
62 bool sign, raiseInexact;
63 int64_t z;
64 uint64_t absZ;
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
70 uiA64 = aSPtr->signExp;
71 exp = expExtF80UI64( uiA64 );
72 sig = aSPtr->signif;
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
75 if ( ! sig && (exp != 0x7FFF) ) return 0;
76 shiftDist = 0x403E - exp;
77 if ( 64 <= shiftDist ) {
78 raiseInexact = exact;
79 z = 0;
80 } else {
81 sign = signExtF80UI64( uiA64 );
82 raiseInexact = false;
83 if ( shiftDist < 0 ) {
84 if ( shiftDist <= -63 ) goto invalid;
85 shiftDist = -shiftDist;
86 absZ = sig<<shiftDist;
87 if ( absZ>>shiftDist != sig ) goto invalid;
88 } else {
89 absZ = sig;
90 if ( shiftDist ) absZ >>= shiftDist;
91 if ( exact && shiftDist ) raiseInexact = (absZ<<shiftDist != sig);
92 }
93 if ( sign ) {
95 u.ui = -absZ;
96 z = u.i;
97 } else {
99 z = absZ;
100 }
101 }
103 return z;
104 /*------------------------------------------------------------------------
105 *------------------------------------------------------------------------*/
106 invalid:
108 return
111
112}
◆ extF80M_to_ui32()
| uint_fast32_t extF80M_to_ui32 | ( | const extFloat80_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 58 of file extF80M_to_ui32.c.
60{
62 uint_fast16_t uiA64;
63 bool sign;
64 int32_t exp;
65 uint64_t sig;
66 int32_t shiftDist;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uiA64 = aSPtr->signExp;
72 sign = signExtF80UI64( uiA64 );
73 exp = expExtF80UI64( uiA64 );
74 sig = aSPtr->signif;
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 shiftDist = 0x4032 - exp;
78 if ( shiftDist <= 0 ) {
79 if ( sig>>32 ) goto invalid;
80 if ( -32 < shiftDist ) {
81 sig <<= -shiftDist;
82 } else {
84 }
85 } else {
86 sig = softfloat_shiftRightJam64( sig, shiftDist );
87 }
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
91 invalid:
93 return
94 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
95 ? ui32_fromNaN
97
98}
uint_fast32_t softfloat_roundToUI32(bool, uint_fast64_t, uint_fast8_t, bool)
Definition s_roundToUI32.c:45
◆ extF80M_to_ui32_r_minMag()
| uint_fast32_t extF80M_to_ui32_r_minMag | ( | const extFloat80_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file extF80M_to_ui32_r_minMag.c.
56{
58 uint_fast16_t uiA64;
59 int32_t exp;
60 uint64_t sig;
61 int32_t shiftDist;
62 bool sign;
63 uint64_t shiftedSig;
64 uint32_t z;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA64 = aSPtr->signExp;
70 exp = expExtF80UI64( uiA64 );
71 sig = aSPtr->signif;
72 /*------------------------------------------------------------------------
73 *------------------------------------------------------------------------*/
74 if ( ! sig && (exp != 0x7FFF) ) return 0;
75 shiftDist = 0x403E - exp;
76 if ( 64 <= shiftDist ) {
78 return 0;
79 }
80 /*------------------------------------------------------------------------
81 *------------------------------------------------------------------------*/
82 sign = signExtF80UI64( uiA64 );
83 if ( shiftDist < 0 ) {
84 if ( sign || sig>>32 || (shiftDist <= -31) ) goto invalid;
86 if ( shiftedSig>>32 ) goto invalid;
87 z = shiftedSig;
88 } else {
89 shiftedSig = sig;
90 if ( shiftDist ) shiftedSig >>= shiftDist;
91 if ( shiftedSig>>32 ) goto invalid;
92 z = shiftedSig;
93 if ( sign && z ) goto invalid;
96 }
97 }
98 return z;
99 /*------------------------------------------------------------------------
100 *------------------------------------------------------------------------*/
101 invalid:
103 return
104 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
105 ? ui32_fromNaN
107
108}
◆ extF80M_to_ui64()
| uint_fast64_t extF80M_to_ui64 | ( | const extFloat80_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 58 of file extF80M_to_ui64.c.
60{
62 uint_fast16_t uiA64;
63 bool sign;
64 int32_t exp;
65 uint64_t sig;
66 int32_t shiftDist;
67 uint32_t extSig[3];
68
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
72 uiA64 = aSPtr->signExp;
73 sign = signExtF80UI64( uiA64 );
74 exp = expExtF80UI64( uiA64 );
75 sig = aSPtr->signif;
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 shiftDist = 0x403E - exp;
79 if ( shiftDist < 0 ) {
81 return
82 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
83 ? ui64_fromNaN
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 extSig[indexWord( 3, 2 )] = sig>>32;
89 extSig[indexWord( 3, 1 )] = sig;
90 extSig[indexWord( 3, 0 )] = 0;
93
94}
uint_fast64_t softfloat_roundMToUI64(bool, uint32_t *, uint_fast8_t, bool)
Definition s_roundMToUI64.c:45
◆ extF80M_to_ui64_r_minMag()
| uint_fast64_t extF80M_to_ui64_r_minMag | ( | const extFloat80_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file extF80M_to_ui64_r_minMag.c.
56{
58 uint_fast16_t uiA64;
59 int32_t exp;
60 uint64_t sig;
61 int32_t shiftDist;
62 bool sign;
63 uint64_t z;
64
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
68 uiA64 = aSPtr->signExp;
69 exp = expExtF80UI64( uiA64 );
70 sig = aSPtr->signif;
71 /*------------------------------------------------------------------------
72 *------------------------------------------------------------------------*/
73 if ( ! sig && (exp != 0x7FFF) ) return 0;
74 shiftDist = 0x403E - exp;
75 if ( 64 <= shiftDist ) {
77 return 0;
78 }
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 sign = signExtF80UI64( uiA64 );
82 if ( shiftDist < 0 ) {
83 if ( sign || (shiftDist <= -63) ) goto invalid;
84 shiftDist = -shiftDist;
85 z = sig<<shiftDist;
86 if ( z>>shiftDist != sig ) goto invalid;
87 } else {
88 z = sig;
89 if ( shiftDist ) z >>= shiftDist;
90 if ( sign && z ) goto invalid;
91 if ( exact && shiftDist && (z<<shiftDist != sig) ) {
93 }
94 }
95 return z;
96 /*------------------------------------------------------------------------
97 *------------------------------------------------------------------------*/
98 invalid:
100 return
101 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
102 ? ui64_fromNaN
104
105}
◆ f128M_add()
| void f128M_add | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr, | ||
| float128_t * | zPtr ) |
Definition at line 84 of file f128M_add.c.
85{
86
90 (uint32_t *) zPtr,
91 false
92 );
93
94}
void softfloat_addF128M(const uint32_t *, const uint32_t *, uint32_t *, bool)
Definition s_addF128M.c:45
◆ f128M_div()
| void f128M_div | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr, | ||
| float128_t * | zPtr ) |
Definition at line 57 of file f128M_div.c.
58{
60 uint32_t *zWPtr, uiA96;
61 bool signA;
62 int32_t expA;
63 uint32_t uiB96;
64 bool signB;
65 int32_t expB;
66 bool signZ;
68 int32_t expZ;
69 uint32_t recip32;
70 int ix;
71 uint64_t q64;
72 uint32_t q, qs[3], uiZ96;
73
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
78 zWPtr = (uint32_t *) zPtr;
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 uiA96 = aWPtr[indexWordHi( 4 )];
82 signA = signF128UI96( uiA96 );
83 expA = expF128UI96( uiA96 );
84 uiB96 = bWPtr[indexWordHi( 4 )];
85 signB = signF128UI96( uiB96 );
86 expB = expF128UI96( uiB96 );
87 signZ = signA ^ signB;
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
92 if ( expA == 0x7FFF ) {
93 if ( expB == 0x7FFF ) goto invalid;
94 goto infinity;
95 }
96 goto zero;
97 }
98 /*------------------------------------------------------------------------
99 *------------------------------------------------------------------------*/
100 expA = softfloat_shiftNormSigF128M( aWPtr, 13, y );
101 expB = softfloat_shiftNormSigF128M( bWPtr, 13, sigB );
102 if ( expA == -128 ) {
103 if ( expB == -128 ) goto invalid;
104 goto zero;
105 }
106 if ( expB == -128 ) {
108 goto infinity;
109 }
110 /*------------------------------------------------------------------------
111 *------------------------------------------------------------------------*/
112 expZ = expA - expB + 0x3FFE;
114 --expZ;
115 softfloat_add128M( y, y, y );
116 }
117 recip32 =
120 >>30
121 );
122 ix = 3;
123 for (;;) {
125 q = (q64 + 0x80000000)>>32;
126 --ix;
127 if ( ix < 0 ) break;
128 softfloat_remStep128MBy32( y, 29, sigB, q, y );
130 --q;
131 softfloat_add128M( y, sigB, y );
132 }
133 qs[ix] = q;
134 }
135 /*------------------------------------------------------------------------
136 *------------------------------------------------------------------------*/
137 if ( ((q + 1) & 7) < 2 ) {
138 softfloat_remStep128MBy32( y, 29, sigB, q, y );
140 --q;
141 softfloat_add128M( y, sigB, y );
143 ++q;
144 softfloat_sub128M( y, sigB, y );
145 }
146 if (
149 ) {
150 q |= 1;
151 }
152 }
153 /*------------------------------------------------------------------------
154 *------------------------------------------------------------------------*/
155 q64 = (uint64_t) q<<28;
157 q64 = ((uint64_t) qs[0]<<25) + (q64>>32);
159 q64 = ((uint64_t) qs[1]<<22) + (q64>>32);
161 q64 = ((uint64_t) qs[2]<<19) + (q64>>32);
164 softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
165 return;
166 /*------------------------------------------------------------------------
167 *------------------------------------------------------------------------*/
168 invalid:
169 softfloat_invalidF128M( zWPtr );
170 return;
171 /*------------------------------------------------------------------------
172 *------------------------------------------------------------------------*/
173 infinity:
174 uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
175 goto uiZ96;
176 zero:
177 uiZ96 = packToF128UI96( signZ, 0, 0 );
178 uiZ96:
179 zWPtr[indexWordHi( 4 )] = uiZ96;
180 zWPtr[indexWord( 4, 2 )] = 0;
181 zWPtr[indexWord( 4, 1 )] = 0;
182 zWPtr[indexWord( 4, 0 )] = 0;
183
184}
void softfloat_roundPackMToF128M(bool, int32_t, uint32_t *, uint32_t *)
Definition s_roundPackMToF128M.c:44
int softfloat_shiftNormSigF128M(const uint32_t *, uint_fast8_t, uint32_t *)
Definition s_shiftNormSigF128M.c:42
bool softfloat_tryPropagateNaNF128M(const uint32_t *, const uint32_t *, uint32_t *)
Definition s_tryPropagateNaNF128M.c:44
int_fast8_t softfloat_compare128M(const uint32_t *aPtr, const uint32_t *bPtr)
Definition s_compare128M.c:43
◆ f128M_eq()
| bool f128M_eq | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr ) |
Definition at line 55 of file f128M_eq.c.
56{
58 uint32_t wordA, wordB, uiA96, uiB96;
59 bool possibleOppositeZeros;
60 uint32_t mashWord;
61
64 wordA = aWPtr[indexWord( 4, 2 )];
65 wordB = bWPtr[indexWord( 4, 2 )];
66 if ( wordA != wordB ) goto false_checkSigNaNs;
67 uiA96 = aWPtr[indexWordHi( 4 )];
68 uiB96 = bWPtr[indexWordHi( 4 )];
69 possibleOppositeZeros = false;
70 if ( uiA96 != uiB96 ) {
71 possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
72 if ( ! possibleOppositeZeros ) goto false_checkSigNaNs;
73 }
74 mashWord = wordA | wordB;
75 wordA = aWPtr[indexWord( 4, 1 )];
76 wordB = bWPtr[indexWord( 4, 1 )];
77 if ( wordA != wordB ) goto false_checkSigNaNs;
78 mashWord |= wordA | wordB;
79 wordA = aWPtr[indexWord( 4, 0 )];
80 wordB = bWPtr[indexWord( 4, 0 )];
81 if ( wordA != wordB ) goto false_checkSigNaNs;
82 if ( possibleOppositeZeros && ((mashWord | wordA | wordB) != 0) ) {
83 goto false_checkSigNaNs;
84 }
86 return true;
87 }
88 false_checkSigNaNs:
89 if (
92 ) {
94 }
95 return false;
96
97}
bool f128M_isSignalingNaN(const float128_t *aPtr)
Definition f128M_isSignalingNaN.c:45
Definition softfloat_types.h:53
◆ f128M_eq_signaling()
| bool f128M_eq_signaling | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr ) |
Definition at line 55 of file f128M_eq_signaling.c.
56{
58 uint32_t wordA, wordB, uiA96, uiB96;
59 bool possibleOppositeZeros;
60 uint32_t mashWord;
61
66 return false;
67 }
68 wordA = aWPtr[indexWord( 4, 2 )];
69 wordB = bWPtr[indexWord( 4, 2 )];
70 if ( wordA != wordB ) return false;
71 uiA96 = aWPtr[indexWordHi( 4 )];
72 uiB96 = bWPtr[indexWordHi( 4 )];
73 possibleOppositeZeros = false;
74 if ( uiA96 != uiB96 ) {
75 possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
76 if ( ! possibleOppositeZeros ) return false;
77 }
78 mashWord = wordA | wordB;
79 wordA = aWPtr[indexWord( 4, 1 )];
80 wordB = bWPtr[indexWord( 4, 1 )];
81 if ( wordA != wordB ) return false;
82 mashWord |= wordA | wordB;
83 wordA = aWPtr[indexWord( 4, 0 )];
84 wordB = bWPtr[indexWord( 4, 0 )];
85 return
86 (wordA == wordB)
87 && (! possibleOppositeZeros || ((mashWord | wordA | wordB) == 0));
88
89}
◆ f128M_isSignalingNaN()
| bool f128M_isSignalingNaN | ( | const float128_t * | aPtr | ) |
Definition at line 45 of file f128M_isSignalingNaN.c.
46{
48 uint32_t uiA96;
49
51 uiA96 = aWPtr[indexWordHi( 4 )];
52 if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
53 return
54 ((uiA96 & 0x00007FFF) != 0)
56 | aWPtr[indexWord( 4, 0 )])
57 != 0);
58
59}
◆ f128M_le()
| bool f128M_le | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr ) |
Definition at line 54 of file f128M_le.c.
55{
57 uint32_t uiA96, uiB96;
58 bool signA, signB;
59 uint32_t wordA, wordB;
60
65 return false;
66 }
67 uiA96 = aWPtr[indexWordHi( 4 )];
68 uiB96 = bWPtr[indexWordHi( 4 )];
69 signA = signF128UI96( uiA96 );
70 signB = signF128UI96( uiB96 );
71 if ( signA != signB ) {
72 if ( signA ) return true;
73 if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
74 wordA = aWPtr[indexWord( 4, 2 )];
75 wordB = bWPtr[indexWord( 4, 2 )];
76 if ( wordA | wordB ) return false;
77 wordA = aWPtr[indexWord( 4, 1 )];
78 wordB = bWPtr[indexWord( 4, 1 )];
79 if ( wordA | wordB ) return false;
80 wordA = aWPtr[indexWord( 4, 0 )];
81 wordB = bWPtr[indexWord( 4, 0 )];
82 return ((wordA | wordB) == 0);
83 }
84 if ( signA ) {
87 }
89
90}
◆ f128M_le_quiet()
| bool f128M_le_quiet | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr ) |
Definition at line 55 of file f128M_le_quiet.c.
56{
58 uint32_t uiA96, uiB96;
59 bool signA, signB;
60 uint32_t wordA, wordB;
61
67 }
68 return false;
69 }
70 uiA96 = aWPtr[indexWordHi( 4 )];
71 uiB96 = bWPtr[indexWordHi( 4 )];
72 signA = signF128UI96( uiA96 );
73 signB = signF128UI96( uiB96 );
74 if ( signA != signB ) {
75 if ( signA ) return true;
76 if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
77 wordA = aWPtr[indexWord( 4, 2 )];
78 wordB = bWPtr[indexWord( 4, 2 )];
79 if ( wordA | wordB ) return false;
80 wordA = aWPtr[indexWord( 4, 1 )];
81 wordB = bWPtr[indexWord( 4, 1 )];
82 if ( wordA | wordB ) return false;
83 wordA = aWPtr[indexWord( 4, 0 )];
84 wordB = bWPtr[indexWord( 4, 0 )];
85 return ((wordA | wordB) == 0);
86 }
87 if ( signA ) {
90 }
92
93}
◆ f128M_lt()
| bool f128M_lt | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr ) |
Definition at line 54 of file f128M_lt.c.
55{
57 uint32_t uiA96, uiB96;
58 bool signA, signB;
59 uint32_t wordA, wordB;
60
65 return false;
66 }
67 uiA96 = aWPtr[indexWordHi( 4 )];
68 uiB96 = bWPtr[indexWordHi( 4 )];
69 signA = signF128UI96( uiA96 );
70 signB = signF128UI96( uiB96 );
71 if ( signA != signB ) {
72 if ( signB ) return false;
73 if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
74 wordA = aWPtr[indexWord( 4, 2 )];
75 wordB = bWPtr[indexWord( 4, 2 )];
76 if ( wordA | wordB ) return true;
77 wordA = aWPtr[indexWord( 4, 1 )];
78 wordB = bWPtr[indexWord( 4, 1 )];
79 if ( wordA | wordB ) return true;
80 wordA = aWPtr[indexWord( 4, 0 )];
81 wordB = bWPtr[indexWord( 4, 0 )];
82 return ((wordA | wordB) != 0);
83 }
84 if ( signA ) {
87 }
89
90}
◆ f128M_lt_quiet()
| bool f128M_lt_quiet | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr ) |
Definition at line 55 of file f128M_lt_quiet.c.
56{
58 uint32_t uiA96, uiB96;
59 bool signA, signB;
60 uint32_t wordA, wordB;
61
67 }
68 return false;
69 }
70 uiA96 = aWPtr[indexWordHi( 4 )];
71 uiB96 = bWPtr[indexWordHi( 4 )];
72 signA = signF128UI96( uiA96 );
73 signB = signF128UI96( uiB96 );
74 if ( signA != signB ) {
75 if ( signB ) return false;
76 if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
77 wordA = aWPtr[indexWord( 4, 2 )];
78 wordB = bWPtr[indexWord( 4, 2 )];
79 if ( wordA | wordB ) return true;
80 wordA = aWPtr[indexWord( 4, 1 )];
81 wordB = bWPtr[indexWord( 4, 1 )];
82 if ( wordA | wordB ) return true;
83 wordA = aWPtr[indexWord( 4, 0 )];
84 wordB = bWPtr[indexWord( 4, 0 )];
85 return ((wordA | wordB) != 0);
86 }
87 if ( signA ) {
90 }
92
93}
◆ f128M_mul()
| void f128M_mul | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr, | ||
| float128_t * | zPtr ) |
Definition at line 57 of file f128M_mul.c.
58{
60 uint32_t *zWPtr;
61 uint32_t uiA96;
62 int32_t expA;
63 uint32_t uiB96;
64 int32_t expB;
65 bool signZ;
67 uint32_t uiZ96, sigA[4];
68 uint_fast8_t shiftDist;
69 uint32_t sigB[4];
70 int32_t expZ;
71 uint32_t sigProd[8], *extSigZPtr;
72
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
77 zWPtr = (uint32_t *) zPtr;
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 uiA96 = aWPtr[indexWordHi( 4 )];
81 expA = expF128UI96( uiA96 );
82 uiB96 = bWPtr[indexWordHi( 4 )];
83 expB = expF128UI96( uiB96 );
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
87 if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
89 ptr = aWPtr;
90 if ( ! expA ) goto possiblyInvalid;
91 if ( ! expB ) {
92 ptr = bWPtr;
93 possiblyInvalid:
94 if (
97 | ptr[indexWord( 4, 0 )])
98 ) {
99 softfloat_invalidF128M( zWPtr );
100 return;
101 }
102 }
103 uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
104 goto uiZ96;
105 }
106 /*------------------------------------------------------------------------
107 *------------------------------------------------------------------------*/
108 if ( expA ) {
113 } else {
114 expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA );
115 if ( expA == -128 ) goto zero;
116 }
117 if ( expB ) {
122 } else {
123 expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigB );
124 if ( expB == -128 ) goto zero;
125 }
126 /*------------------------------------------------------------------------
127 *------------------------------------------------------------------------*/
128 expZ = expA + expB - 0x4000;
129 softfloat_mul128MTo256M( sigA, sigB, sigProd );
130 if (
131 sigProd[indexWord( 8, 2 )]
133 ) {
134 sigProd[indexWord( 8, 3 )] |= 1;
135 }
136 extSigZPtr = &sigProd[indexMultiwordHi( 8, 5 )];
137 shiftDist = 16;
139 ++expZ;
140 shiftDist = 15;
141 }
142 softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
143 softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
144 return;
145 /*------------------------------------------------------------------------
146 *------------------------------------------------------------------------*/
147 zero:
148 uiZ96 = packToF128UI96( signZ, 0, 0 );
149 uiZ96:
150 zWPtr[indexWordHi( 4 )] = uiZ96;
151 zWPtr[indexWord( 4, 2 )] = 0;
152 zWPtr[indexWord( 4, 1 )] = 0;
153 zWPtr[indexWord( 4, 0 )] = 0;
154
155}
void softfloat_mul128MTo256M(const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr)
Definition s_mul128MTo256M.c:44
#define softfloat_shortShiftLeft160M(aPtr, dist, zPtr)
Definition primitives.h:711
◆ f128M_mulAdd()
| void f128M_mulAdd | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr, | ||
| const float128_t * | cPtr, | ||
| float128_t * | zPtr ) |
Definition at line 73 of file f128M_mulAdd.c.
79{
80
85 (uint32_t *) zPtr,
86 0
87 );
88
89}
void softfloat_mulAddF128M(const uint32_t *, const uint32_t *, const uint32_t *, uint32_t *, uint_fast8_t)
Definition s_mulAddF128M.c:45
◆ f128M_rem()
| void f128M_rem | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr, | ||
| float128_t * | zPtr ) |
Definition at line 57 of file f128M_rem.c.
58{
60 uint32_t *zWPtr, uiA96;
61 int32_t expA, expB;
62 uint32_t x[4], rem1[5], *remPtr;
63 bool signRem;
64 int32_t expDiff;
65 uint32_t q, recip32;
66 uint64_t q64;
67 uint32_t rem2[5], *altRemPtr, *newRemPtr, wordMeanRem;
68
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
73 zWPtr = (uint32_t *) zPtr;
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 uiA96 = aWPtr[indexWordHi( 4 )];
77 expA = expF128UI96( uiA96 );
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
83 if ( expA == 0x7FFF ) goto invalid;
84 goto copyA;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 if ( expA < expB - 1 ) goto copyA;
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
91 expB = softfloat_shiftNormSigF128M( bWPtr, 13, x );
92 if ( expB == -128 ) goto invalid;
93 remPtr = &rem1[indexMultiwordLo( 5, 4 )];
94 expA = softfloat_shiftNormSigF128M( aWPtr, 13, remPtr );
95 if ( expA == -128 ) goto copyA;
96 signRem = signF128UI96( uiA96 );
97 /*------------------------------------------------------------------------
98 *------------------------------------------------------------------------*/
99 expDiff = expA - expB;
100 if ( expDiff < 1 ) {
101 if ( expDiff < -1 ) goto copyA;
102 if ( expDiff ) {
103 --expB;
104 softfloat_add128M( x, x, x );
105 q = 0;
106 } else {
107 q = (softfloat_compare128M( x, remPtr ) <= 0);
109 }
110 } else {
111 recip32 =
114 >>30
115 );
116 expDiff -= 30;
117 for (;;) {
119 if ( expDiff < 0 ) break;
120 q = (q64 + 0x80000000)>>32;
121 softfloat_remStep128MBy32( remPtr, 29, x, q, remPtr );
123 softfloat_add128M( remPtr, x, remPtr );
124 }
125 expDiff -= 29;
126 }
127 /*--------------------------------------------------------------------
128 | (`expDiff' cannot be less than -29 here.)
129 *--------------------------------------------------------------------*/
130 q = (uint32_t) (q64>>32)>>(~expDiff & 31);
131 softfloat_remStep128MBy32( remPtr, expDiff + 30, x, q, remPtr );
133 altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
134 softfloat_add128M( remPtr, x, altRemPtr );
135 goto selectRem;
136 }
137 }
138 /*------------------------------------------------------------------------
139 *------------------------------------------------------------------------*/
140 altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
141 do {
142 ++q;
143 newRemPtr = altRemPtr;
144 softfloat_sub128M( remPtr, x, newRemPtr );
145 altRemPtr = remPtr;
146 remPtr = newRemPtr;
148 selectRem:
149 softfloat_add128M( remPtr, altRemPtr, x );
150 wordMeanRem = x[indexWordHi( 4 )];
151 if (
152 (wordMeanRem & 0x80000000)
153 || (! wordMeanRem && (q & 1) && ! x[indexWord( 4, 0 )]
155 ) {
156 remPtr = altRemPtr;
157 }
159 signRem = ! signRem;
160 softfloat_negX128M( remPtr );
161 }
162 remPtr -= indexMultiwordLo( 5, 4 );
163 remPtr[indexWordHi( 5 )] = 0;
164 softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr );
165 return;
166 /*------------------------------------------------------------------------
167 *------------------------------------------------------------------------*/
168 invalid:
169 softfloat_invalidF128M( zWPtr );
170 return;
171 /*------------------------------------------------------------------------
172 *------------------------------------------------------------------------*/
173 copyA:
174 zWPtr[indexWordHi( 4 )] = uiA96;
178
179}
void softfloat_normRoundPackMToF128M(bool, int32_t, uint32_t *, uint32_t *)
Definition s_normRoundPackMToF128M.c:43
◆ f128M_roundToInt()
| void f128M_roundToInt | ( | const float128_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact, | ||
| float128_t * | zPtr ) |
Definition at line 62 of file f128M_roundToInt.c.
68{
70 uint32_t *zWPtr;
71 uint32_t ui96;
72 int32_t exp;
73 uint32_t sigExtra;
74 bool sign;
75 uint_fast8_t bitPos;
76 bool roundNear;
77 unsigned int index, lastIndex;
78 bool extra;
80 uint_fast8_t carry;
81 uint32_t extrasMask;
82
83 /*------------------------------------------------------------------------
84 *------------------------------------------------------------------------*/
86 zWPtr = (uint32_t *) zPtr;
87 /*------------------------------------------------------------------------
88 *------------------------------------------------------------------------*/
89 ui96 = aWPtr[indexWordHi( 4 )];
90 exp = expF128UI96( ui96 );
91 /*------------------------------------------------------------------------
92 *------------------------------------------------------------------------*/
93 if ( exp < 0x3FFF ) {
94 zWPtr[indexWord( 4, 2 )] = 0;
95 zWPtr[indexWord( 4, 1 )] = 0;
96 zWPtr[indexWord( 4, 0 )] = 0;
97 sigExtra = aWPtr[indexWord( 4, 2 )];
98 if ( !sigExtra ) {
100 }
101 if ( !sigExtra && !(ui96 & 0x7FFFFFFF) ) goto ui96;
103 sign = signF128UI96( ui96 );
104 switch ( roundingMode ) {
108 if ( exp == 0x3FFE ) goto mag1;
109 break;
111 if ( sign ) goto mag1;
112 break;
114 if ( !sign ) goto mag1;
115 break;
116#ifdef SOFTFLOAT_ROUND_ODD
118 goto mag1;
119#endif
120 }
121 ui96 = packToF128UI96( sign, 0, 0 );
122 goto ui96;
123 mag1:
124 ui96 = packToF128UI96( sign, 0x3FFF, 0 );
125 goto ui96;
126 }
127 /*------------------------------------------------------------------------
128 *------------------------------------------------------------------------*/
129 if ( 0x406F <= exp ) {
130 if (
131 (exp == 0x7FFF)
132 && (fracF128UI96( ui96 )
134 | aWPtr[indexWord( 4, 0 )]))
135 ) {
136 softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
137 return;
138 }
142 goto ui96;
143 }
144 /*------------------------------------------------------------------------
145 *------------------------------------------------------------------------*/
146 bitPos = 0x406F - exp;
147 roundNear =
148 (roundingMode == softfloat_round_near_maxMag)
149 || (roundingMode == softfloat_round_near_even);
150 bitPos -= roundNear;
151 index = indexWordLo( 4 );
152 lastIndex = indexWordHi( 4 );
153 extra = 0;
154 for (;;) {
155 wordA = aWPtr[index];
156 if ( bitPos < 32 ) break;
157 if ( wordA ) extra = 1;
158 zWPtr[index] = 0;
159 index += wordIncr;
160 bitPos -= 32;
161 }
163 if ( roundNear ) {
164 wordZ = wordA + bit;
165 carry = (wordZ < wordA);
166 bit <<= 1;
167 extrasMask = bit - 1;
168 if ( exact && (extra || (wordA & extrasMask)) ) {
170 }
171 if (
172 (roundingMode == softfloat_round_near_even)
173 && !extra && !(wordZ & extrasMask)
174 ) {
176 zWPtr[index] = wordZ;
177 index += wordIncr;
178 wordZ = aWPtr[index] + carry;
179 carry &= !wordZ;
180 zWPtr[index] = wordZ & ~1;
181 goto propagateCarry;
182 }
183 wordZ &= ~bit;
184 }
185 } else {
186 wordZ = wordA;
187 carry = 0;
188 extrasMask = bit - 1;
189 if ( extra || (wordA & extrasMask) ) {
191 if (
192 roundingMode
194 : softfloat_round_max)
195 ) {
196 wordZ += bit;
197 carry = (wordZ < wordA);
198#ifdef SOFTFLOAT_ROUND_ODD
200 wordZ |= bit;
201#endif
202 }
203 }
204 }
205 wordZ &= ~extrasMask;
206 zWPtr[index] = wordZ;
207 propagateCarry:
208 while ( index != lastIndex ) {
209 index += wordIncr;
210 wordZ = aWPtr[index] + carry;
211 zWPtr[index] = wordZ;
212 carry &= !wordZ;
213 }
214 return;
215 /*------------------------------------------------------------------------
216 *------------------------------------------------------------------------*/
217 ui96:
218 zWPtr[indexWordHi( 4 )] = ui96;
219
220}
void softfloat_propagateNaNF128M(const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr)
Definition s_propagateNaNF128M.c:53
◆ f128M_sqrt()
| void f128M_sqrt | ( | const float128_t * | aPtr, |
| float128_t * | zPtr ) |
Definition at line 55 of file f128M_sqrt.c.
56{
58 uint32_t *zWPtr;
59 uint32_t uiA96;
60 bool signA;
61 int32_t rawExpA;
62 uint32_t rem[6];
63 int32_t expA, expZ;
64 uint64_t rem64;
65 uint32_t sig32A, recipSqrt32, sig32Z, qs[3], q;
66 uint64_t sig64Z;
67 uint32_t term[5];
68 uint64_t x64;
70
71 /*------------------------------------------------------------------------
72 *------------------------------------------------------------------------*/
74 zWPtr = (uint32_t *) zPtr;
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 uiA96 = aWPtr[indexWordHi( 4 )];
78 signA = signF128UI96( uiA96 );
79 rawExpA = expF128UI96( uiA96 );
80 /*------------------------------------------------------------------------
81 *------------------------------------------------------------------------*/
82 if ( rawExpA == 0x7FFF ) {
83 if (
84 fracF128UI96( uiA96 )
86 | aWPtr[indexWord( 4, 0 )])
87 ) {
88 softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
89 return;
90 }
91 if ( ! signA ) goto copyA;
92 goto invalid;
93 }
94 /*------------------------------------------------------------------------
95 *------------------------------------------------------------------------*/
96 expA = softfloat_shiftNormSigF128M( aWPtr, 13 - (rawExpA & 1), rem );
97 if ( expA == -128 ) goto copyA;
98 if ( signA ) goto invalid;
99 /*------------------------------------------------------------------------
100 | (`sig32Z' is guaranteed to be a lower bound on the square root of
101 | `sig32A', which makes `sig32Z' also a lower bound on the square root of
102 | `sigA'.)
103 *------------------------------------------------------------------------*/
104 expZ = ((expA - 0x3FFF)>>1) + 0x3FFE;
105 expA &= 1;
107 if ( expA ) {
108 if ( ! rawExpA ) {
109 softfloat_shortShiftRight128M( rem, 1, rem );
110 rem64 >>= 1;
111 }
112 sig32A = rem64>>29;
113 } else {
114 sig32A = rem64>>30;
115 }
116 recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
117 sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
118 if ( expA ) sig32Z >>= 1;
119 qs[2] = sig32Z;
120 rem64 -= (uint64_t) sig32Z * sig32Z;
121 rem[indexWord( 4, 3 )] = rem64>>32;
122 rem[indexWord( 4, 2 )] = rem64;
123 /*------------------------------------------------------------------------
124 *------------------------------------------------------------------------*/
127 term[indexWord( 4, 3 )] = 0;
128 term[indexWord( 4, 0 )] = 0;
129 /*------------------------------------------------------------------------
130 | (Repeating this loop is a rare occurrence.)
131 *------------------------------------------------------------------------*/
132 for (;;) {
133 x64 = ((uint64_t) sig32Z<<32) + sig64Z;
134 term[indexWord( 4, 2 )] = x64>>32;
135 term[indexWord( 4, 1 )] = x64;
136 softfloat_remStep128MBy32( rem, 29, term, q, y );
138 if ( ! (rem32 & 0x80000000) ) break;
139 --q;
140 sig64Z -= 1<<3;
141 }
142 qs[1] = q;
144 /*------------------------------------------------------------------------
145 *------------------------------------------------------------------------*/
147 if ( rem64>>34 ) q += recipSqrt32;
148 sig64Z <<= 1;
149 /*------------------------------------------------------------------------
150 | (Repeating this loop is a rare occurrence.)
151 *------------------------------------------------------------------------*/
152 for (;;) {
153 x64 = sig64Z + (q>>26);
154 term[indexWord( 4, 2 )] = x64>>32;
155 term[indexWord( 4, 1 )] = x64;
156 term[indexWord( 4, 0 )] = q<<6;
158 y, 29, term, q, &rem[indexMultiwordHi( 6, 4 )] );
159 rem32 = rem[indexWordHi( 6 )];
160 if ( ! (rem32 & 0x80000000) ) break;
161 --q;
162 }
163 qs[0] = q;
165 /*------------------------------------------------------------------------
166 *------------------------------------------------------------------------*/
168 if ( rem64>>34 ) q += recipSqrt32;
169 x64 = (uint64_t) q<<27;
171 x64 = ((uint64_t) qs[0]<<24) + (x64>>32);
173 x64 = ((uint64_t) qs[1]<<21) + (x64>>32);
175 x64 = ((uint64_t) qs[2]<<18) + (x64>>32);
178 /*------------------------------------------------------------------------
179 *------------------------------------------------------------------------*/
180 if ( (q & 0xF) <= 2 ) {
181 q &= ~3;
183 term[indexWord( 5, 4 )] = 0;
184 term[indexWord( 5, 3 )] = 0;
185 term[indexWord( 5, 2 )] = 0;
186 term[indexWord( 5, 1 )] = q>>6;
187 term[indexWord( 5, 0 )] = q<<26;
188 softfloat_sub160M( y, term, term );
189 rem[indexWord( 6, 1 )] = 0;
190 rem[indexWord( 6, 0 )] = 0;
192 &rem[indexMultiwordLo( 6, 5 )],
193 14,
194 term,
195 q,
196 &rem[indexMultiwordLo( 6, 5 )]
197 );
198 rem32 = rem[indexWord( 6, 4 )];
199 if ( rem32 & 0x80000000 ) {
200 softfloat_sub1X160M( y );
201 } else {
202 if (
205 ) {
207 }
208 }
209 }
210 softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
211 return;
212 /*------------------------------------------------------------------------
213 *------------------------------------------------------------------------*/
214 invalid:
215 softfloat_invalidF128M( zWPtr );
216 return;
217 /*------------------------------------------------------------------------
218 *------------------------------------------------------------------------*/
219 copyA:
220 zWPtr[indexWordHi( 4 )] = uiA96;
224
225}
#define softfloat_remStep160MBy32(remPtr, dist, bPtr, q, zPtr)
Definition primitives.h:1154
#define softfloat_shortShiftRight128M(aPtr, dist, zPtr)
Definition primitives.h:782
◆ f128M_sub()
| void f128M_sub | ( | const float128_t * | aPtr, |
| const float128_t * | bPtr, | ||
| float128_t * | zPtr ) |
Definition at line 84 of file f128M_sub.c.
◆ f128M_to_extF80M()
| void f128M_to_extF80M | ( | const float128_t * | aPtr, |
| extFloat80_t * | zPtr ) |
Definition at line 55 of file f128M_to_extF80M.c.
56{
59 uint32_t uiA96;
60 bool sign;
61 int32_t exp;
63 uint32_t sig[4];
64
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 uiA96 = aWPtr[indexWordHi( 4 )];
72 sign = signF128UI96( uiA96 );
73 exp = expF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( exp == 0x7FFF ) {
80 return;
81 }
84 return;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 exp = softfloat_shiftNormSigF128M( aWPtr, 15, sig );
89 if ( exp == -128 ) {
91 zSPtr->signif = 0;
92 return;
93 }
96 sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
97
98}
#define softfloat_commonNaNToExtF80M
Definition s_commonNaNToExtF80M.c:40
#define softfloat_f128MToCommonNaN(aWPtr, zPtr)
Definition specialize.h:369
◆ f128M_to_f16()
| float16_t f128M_to_f16 | ( | const float128_t * | aPtr | ) |
Definition at line 55 of file f128M_to_f16.c.
56{
58 uint32_t uiA96;
59 bool sign;
60 int32_t exp;
61 uint32_t frac32;
63 uint16_t uiZ, frac16;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 uiA96 = aWPtr[indexWordHi( 4 )];
72 sign = signF128UI96( uiA96 );
73 exp = expF128UI96( uiA96 );
74 frac32 =
75 fracF128UI96( uiA96 )
77 | aWPtr[indexWord( 4, 0 )])
78 != 0);
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 if ( exp == 0x7FFF ) {
82 if ( frac32 ) {
85 } else {
86 uiZ = packToF16UI( sign, 0x1F, 0 );
87 }
88 goto uiZ;
89 }
90 /*------------------------------------------------------------------------
91 *------------------------------------------------------------------------*/
92 frac16 = frac32>>2 | (frac32 & 3);
93 if ( ! (exp | frac16) ) {
94 uiZ = packToF16UI( sign, 0, 0 );
95 goto uiZ;
96 }
97 /*------------------------------------------------------------------------
98 *------------------------------------------------------------------------*/
99 exp -= 0x3FF1;
101 if ( exp < -0x40 ) exp = -0x40;
102 }
104 /*------------------------------------------------------------------------
105 *------------------------------------------------------------------------*/
106 uiZ:
107 uZ.ui = uiZ;
108 return uZ.f;
109
110}
◆ f128M_to_f32()
| float32_t f128M_to_f32 | ( | const float128_t * | aPtr | ) |
Definition at line 55 of file f128M_to_f32.c.
56{
58 uint32_t uiA96;
59 bool sign;
60 int32_t exp;
61 uint64_t frac64;
63 uint32_t uiZ, frac32;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA96 = aWPtr[indexWordHi( 4 )];
70 sign = signF128UI96( uiA96 );
71 exp = expF128UI96( uiA96 );
72 frac64 =
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp == 0x7FFF ) {
78 if ( frac64 ) {
81 } else {
82 uiZ = packToF32UI( sign, 0xFF, 0 );
83 }
84 goto uiZ;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 frac32 = softfloat_shortShiftRightJam64( frac64, 18 );
89 if ( ! (exp | frac32) ) {
90 uiZ = packToF32UI( sign, 0, 0 );
91 goto uiZ;
92 }
93 /*------------------------------------------------------------------------
94 *------------------------------------------------------------------------*/
95 exp -= 0x3F81;
97 if ( exp < -0x1000 ) exp = -0x1000;
98 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 uiZ:
103 uZ.ui = uiZ;
104 return uZ.f;
105
106}
◆ f128M_to_f64()
| float64_t f128M_to_f64 | ( | const float128_t * | aPtr | ) |
Definition at line 55 of file f128M_to_f64.c.
56{
58 uint32_t uiA96;
59 bool sign;
60 int32_t exp;
61 uint64_t frac64;
63 uint64_t uiZ;
64 uint32_t frac32;
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
70 uiA96 = aWPtr[indexWordHi( 4 )];
71 sign = signF128UI96( uiA96 );
72 exp = expF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( exp == 0x7FFF ) {
80 } else {
81 uiZ = packToF64UI( sign, 0x7FF, 0 );
82 }
83 goto uiZ;
84 }
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
87 frac32 = aWPtr[indexWord( 4, 1 )];
88 frac64 = frac64<<14 | frac32>>18;
90 if ( ! (exp | frac64) ) {
91 uiZ = packToF64UI( sign, 0, 0 );
92 goto uiZ;
93 }
94 /*------------------------------------------------------------------------
95 *------------------------------------------------------------------------*/
96 exp -= 0x3C01;
98 if ( exp < -0x1000 ) exp = -0x1000;
99 }
100 return
102 sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
103 /*------------------------------------------------------------------------
104 *------------------------------------------------------------------------*/
105 uiZ:
106 uZ.ui = uiZ;
107 return uZ.f;
108
109}
◆ f128M_to_i32()
| int_fast32_t f128M_to_i32 | ( | const float128_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 57 of file f128M_to_i32.c.
58{
60 uint32_t uiA96;
61 bool sign;
62 int32_t exp;
63 uint64_t sig64;
64 int32_t shiftDist;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA96 = aWPtr[indexWordHi( 4 )];
70 sign = signF128UI96( uiA96 );
71 exp = expF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
77 if ( (exp == 0x7FFF) && sig64 ) {
78#if (i32_fromNaN == i32_fromPosOverflow)
79 sign = 0;
80#elif (i32_fromNaN == i32_fromNegOverflow)
81 sign = 1;
82#else
85#endif
86 }
87#endif
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
91 shiftDist = 0x4023 - exp;
94
95}
◆ f128M_to_i32_r_minMag()
| int_fast32_t f128M_to_i32_r_minMag | ( | const float128_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file f128M_to_i32_r_minMag.c.
56{
58 uint32_t uiA96;
59 bool sign;
60 int32_t exp;
61 uint64_t sig64;
62 int32_t shiftDist;
63 uint32_t absZ, uiZ;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA96 = aWPtr[indexWordHi( 4 )];
70 sign = signF128UI96( uiA96 );
71 exp = expF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( exp < 0x3FFF ) {
77 if ( exact && (exp | sig64) ) {
79 }
80 return 0;
81 }
82 /*------------------------------------------------------------------------
83 *------------------------------------------------------------------------*/
84 if ( 0x401F <= exp ) goto invalid;
85 shiftDist = 0x402F - exp;
86 sig64 |= UINT64_C( 0x0001000000000000 );
87 absZ = sig64>>shiftDist;
88 uiZ = sign ? -absZ : absZ;
89 if ( uiZ>>31 != sign ) goto invalid;
92 }
93 uZ.ui = uiZ;
94 return uZ.i;
95 /*------------------------------------------------------------------------
96 *------------------------------------------------------------------------*/
97 invalid:
99 return
100 (exp == 0x7FFF) && sig64 ? i32_fromNaN
102
103}
◆ f128M_to_i64()
| int_fast64_t f128M_to_i64 | ( | const float128_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 57 of file f128M_to_i64.c.
58{
60 uint32_t uiA96;
61 bool sign;
62 int32_t exp;
63 uint32_t sig96;
64 int32_t shiftDist;
65 uint32_t sig[4];
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
70 uiA96 = aWPtr[indexWordHi( 4 )];
71 sign = signF128UI96( uiA96 );
72 exp = expF128UI96( uiA96 );
73 sig96 = fracF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 shiftDist = 0x404F - exp;
77 if ( shiftDist < 17 ) {
79 return
80 (exp == 0x7FFF)
81 && (sig96
83 | aWPtr[indexWord( 4, 0 )]))
84 ? i64_fromNaN
86 }
87 /*------------------------------------------------------------------------
88 *------------------------------------------------------------------------*/
89 if ( exp ) sig96 |= 0x00010000;
90 sig[indexWord( 4, 3 )] = sig96;
94 softfloat_shiftRightJam128M( sig, shiftDist, sig );
95 return
97 sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
98
99}
#define softfloat_shiftRightJam128M(aPtr, dist, zPtr)
Definition primitives.h:881
◆ f128M_to_i64_r_minMag()
| int_fast64_t f128M_to_i64_r_minMag | ( | const float128_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file f128M_to_i64_r_minMag.c.
56{
58 uint32_t uiA96;
59 bool sign;
60 int32_t exp;
61 uint32_t sig96;
62 int32_t shiftDist;
63 uint32_t sig[4];
64 uint64_t uiZ;
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
70 uiA96 = aWPtr[indexWordHi( 4 )];
71 sign = signF128UI96( uiA96 );
72 exp = expF128UI96( uiA96 );
73 sig96 = fracF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 shiftDist = 0x403E - exp;
77 if ( shiftDist < 0 ) goto invalid;
78 if ( exact ) {
79 if ( exp ) sig96 |= 0x00010000;
80 sig[indexWord( 4, 3 )] = sig96;
84 softfloat_shiftRightJam128M( sig, shiftDist + 17, sig );
87 goto invalid;
88 }
91 }
92 } else {
93 if ( 64 <= shiftDist ) return 0;
94 uiZ =
95 (uint64_t) sig96<<47
97 | aWPtr[indexWord( 4, 1 )]>>17;
98 if ( shiftDist ) {
99 uiZ |= UINT64_C( 0x8000000000000000 );
100 uiZ >>= shiftDist;
101 } else {
102 if ( uiZ || ! sign ) goto invalid;
103 uiZ |= UINT64_C( 0x8000000000000000 );
104 }
105 }
106 if ( sign ) uiZ = -uiZ;
107 uZ.ui = uiZ;
108 return uZ.i;
109 /*------------------------------------------------------------------------
110 *------------------------------------------------------------------------*/
111 invalid:
113 return
114 (exp == 0x7FFF)
115 && (sig96
117 | aWPtr[indexWord( 4, 0 )]))
118 ? i64_fromNaN
120
121}
◆ f128M_to_ui32()
| uint_fast32_t f128M_to_ui32 | ( | const float128_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 57 of file f128M_to_ui32.c.
58{
60 uint32_t uiA96;
61 bool sign;
62 int32_t exp;
63 uint64_t sig64;
64 int32_t shiftDist;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA96 = aWPtr[indexWordHi( 4 )];
70 sign = signF128UI96( uiA96 );
71 exp = expF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
77 if ( (exp == 0x7FFF) && sig64 ) {
78#if (ui32_fromNaN == ui32_fromPosOverflow)
79 sign = 0;
80#elif (ui32_fromNaN == ui32_fromNegOverflow)
81 sign = 1;
82#else
85#endif
86 }
87#endif
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
91 shiftDist = 0x4023 - exp;
94
95}
◆ f128M_to_ui32_r_minMag()
| uint_fast32_t f128M_to_ui32_r_minMag | ( | const float128_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file f128M_to_ui32_r_minMag.c.
56{
58 uint32_t uiA96;
59 int32_t exp;
60 uint64_t sig64;
61 int32_t shiftDist;
62 bool sign;
63 uint32_t z;
64
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
68 uiA96 = aWPtr[indexWordHi( 4 )];
69 exp = expF128UI96( uiA96 );
72 /*------------------------------------------------------------------------
73 *------------------------------------------------------------------------*/
74 shiftDist = 0x402F - exp;
75 if ( 49 <= shiftDist ) {
76 if ( exact && (exp | sig64) ) {
78 }
79 return 0;
80 }
81 /*------------------------------------------------------------------------
82 *------------------------------------------------------------------------*/
83 sign = signF128UI96( uiA96 );
84 if ( sign || (shiftDist < 17) ) {
86 return
87 (exp == 0x7FFF) && sig64 ? ui32_fromNaN
89 }
90 /*------------------------------------------------------------------------
91 *------------------------------------------------------------------------*/
92 sig64 |= UINT64_C( 0x0001000000000000 );
93 z = sig64>>shiftDist;
96 }
97 return z;
98
99}
◆ f128M_to_ui64()
| uint_fast64_t f128M_to_ui64 | ( | const float128_t * | aPtr, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 57 of file f128M_to_ui64.c.
58{
60 uint32_t uiA96;
61 bool sign;
62 int32_t exp;
63 uint32_t sig96;
64 int32_t shiftDist;
65 uint32_t sig[4];
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
70 uiA96 = aWPtr[indexWordHi( 4 )];
71 sign = signF128UI96( uiA96 );
72 exp = expF128UI96( uiA96 );
73 sig96 = fracF128UI96( uiA96 );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 shiftDist = 0x404F - exp;
77 if ( shiftDist < 17 ) {
79 return
80 (exp == 0x7FFF)
81 && (sig96
83 | aWPtr[indexWord( 4, 0 )]))
84 ? ui64_fromNaN
86 }
87 /*------------------------------------------------------------------------
88 *------------------------------------------------------------------------*/
89 if ( exp ) sig96 |= 0x00010000;
90 sig[indexWord( 4, 3 )] = sig96;
94 softfloat_shiftRightJam128M( sig, shiftDist, sig );
95 return
97 sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
98
99}
◆ f128M_to_ui64_r_minMag()
| uint_fast64_t f128M_to_ui64_r_minMag | ( | const float128_t * | aPtr, |
| bool | exact ) |
Definition at line 55 of file f128M_to_ui64_r_minMag.c.
56{
58 uint32_t uiA96;
59 bool sign;
60 int32_t exp;
61 uint32_t sig96;
62 int32_t shiftDist;
63 uint32_t sig[4];
64 uint64_t z;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA96 = aWPtr[indexWordHi( 4 )];
70 sign = signF128UI96( uiA96 );
71 exp = expF128UI96( uiA96 );
72 sig96 = fracF128UI96( uiA96 );
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
75 shiftDist = 0x403E - exp;
76 if ( shiftDist < 0 ) goto invalid;
77 if ( exact ) {
78 if ( exp ) sig96 |= 0x00010000;
79 sig[indexWord( 4, 3 )] = sig96;
83 softfloat_shiftRightJam128M( sig, shiftDist + 17, sig );
85 if ( sign && z ) goto invalid;
88 }
89 } else {
90 if ( 64 <= shiftDist ) return 0;
91 if ( sign ) goto invalid;
92 z = UINT64_C( 0x8000000000000000 )
93 | (uint64_t) sig96<<47
95 | aWPtr[indexWord( 4, 1 )]>>17;
96 z >>= shiftDist;
97 }
98 return z;
99 /*------------------------------------------------------------------------
100 *------------------------------------------------------------------------*/
101 invalid:
103 return
104 (exp == 0x7FFF)
105 && (sig96
107 | aWPtr[indexWord( 4, 0 )]))
108 ? ui64_fromNaN
110
111}
◆ f16_add()
Definition at line 43 of file f16_add.c.
44{
46 uint_fast16_t uiA;
48 uint_fast16_t uiB;
49#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
51#endif
52
53 uA.f = a;
54 uiA = uA.ui;
55 uB.f = b;
56 uiB = uB.ui;
57#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
60 } else {
62 }
63#else
64 magsFuncPtr =
66 return (*magsFuncPtr)( uiA, uiB );
67#endif
68
69}
float16_t softfloat_subMagsF16(uint_fast16_t, uint_fast16_t)
Definition s_subMagsF16.c:44
float16_t softfloat_addMagsF16(uint_fast16_t, uint_fast16_t)
Definition s_addMagsF16.c:44
Definition softfloat_types.h:50
◆ f16_div()
Definition at line 47 of file f16_div.c.
48{
50 uint_fast16_t uiA;
51 bool signA;
52 int_fast8_t expA;
53 uint_fast16_t sigA;
55 uint_fast16_t uiB;
56 bool signB;
57 int_fast8_t expB;
58 uint_fast16_t sigB;
59 bool signZ;
61 int_fast8_t expZ;
62#ifdef SOFTFLOAT_FAST_DIV32TO16
63 uint_fast32_t sig32A;
64 uint_fast16_t sigZ;
65#else
66 int index;
67 uint16_t r0;
68 uint_fast16_t sigZ, rem;
69#endif
70 uint_fast16_t uiZ;
72
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
76 uiA = uA.ui;
77 signA = signF16UI( uiA );
78 expA = expF16UI( uiA );
79 sigA = fracF16UI( uiA );
80 uB.f = b;
81 uiB = uB.ui;
82 signB = signF16UI( uiB );
83 expB = expF16UI( uiB );
84 sigB = fracF16UI( uiB );
85 signZ = signA ^ signB;
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 if ( expA == 0x1F ) {
89 if ( sigA ) goto propagateNaN;
90 if ( expB == 0x1F ) {
91 if ( sigB ) goto propagateNaN;
92 goto invalid;
93 }
94 goto infinity;
95 }
96 if ( expB == 0x1F ) {
97 if ( sigB ) goto propagateNaN;
98 goto zero;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 if ( ! expB ) {
103 if ( ! sigB ) {
104 if ( ! (expA | sigA) ) goto invalid;
106 goto infinity;
107 }
108 normExpSig = softfloat_normSubnormalF16Sig( sigB );
109 expB = normExpSig.exp;
110 sigB = normExpSig.sig;
111 }
112 if ( ! expA ) {
113 if ( ! sigA ) goto zero;
114 normExpSig = softfloat_normSubnormalF16Sig( sigA );
115 expA = normExpSig.exp;
116 sigA = normExpSig.sig;
117 }
118 /*------------------------------------------------------------------------
119 *------------------------------------------------------------------------*/
120 expZ = expA - expB + 0xE;
121 sigA |= 0x0400;
122 sigB |= 0x0400;
123#ifdef SOFTFLOAT_FAST_DIV32TO16
124 if ( sigA < sigB ) {
125 --expZ;
126 sig32A = (uint_fast32_t) sigA<<15;
127 } else {
128 sig32A = (uint_fast32_t) sigA<<14;
129 }
130 sigZ = sig32A / sigB;
132#else
133 if ( sigA < sigB ) {
134 --expZ;
135 sigA <<= 5;
136 } else {
137 sigA <<= 4;
138 }
139 index = sigB>>6 & 0xF;
140 r0 = softfloat_approxRecip_1k0s[index]
142 * (sigB & 0x3F))
143 >>10);
144 sigZ = ((uint_fast32_t) sigA * r0)>>16;
145 rem = (sigA<<10) - sigZ * sigB;
146 sigZ += (rem * (uint_fast32_t) r0)>>26;
147 /*------------------------------------------------------------------------
148 *------------------------------------------------------------------------*/
149 ++sigZ;
150 if ( ! (sigZ & 7) ) {
151 sigZ &= ~1;
152 rem = (sigA<<10) - sigZ * sigB;
153 if ( rem & 0x8000 ) {
154 sigZ -= 2;
155 } else {
156 if ( rem ) sigZ |= 1;
157 }
158 }
159#endif
161 /*------------------------------------------------------------------------
162 *------------------------------------------------------------------------*/
163 propagateNaN:
164 uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
165 goto uiZ;
166 /*------------------------------------------------------------------------
167 *------------------------------------------------------------------------*/
168 invalid:
170 uiZ = defaultNaNF16UI;
171 goto uiZ;
172 /*------------------------------------------------------------------------
173 *------------------------------------------------------------------------*/
174 infinity:
175 uiZ = packToF16UI( signZ, 0x1F, 0 );
176 goto uiZ;
177 /*------------------------------------------------------------------------
178 *------------------------------------------------------------------------*/
179 zero:
180 uiZ = packToF16UI( signZ, 0, 0 );
181 uiZ:
182 uZ.ui = uiZ;
183 return uZ.f;
184
185}
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB)
Definition s_propagateNaNF16UI.c:51
const uint16_t softfloat_approxRecip_1k0s[]
Definition s_approxRecip_1Ks.c:41
const uint16_t softfloat_approxRecip_1k1s[]
Definition s_approxRecip_1Ks.c:45
struct exp8_sig16 softfloat_normSubnormalF16Sig(uint_fast16_t)
Definition s_normSubnormalF16Sig.c:41
Definition internals.h:90
◆ f16_eq()
Definition at line 44 of file f16_eq.c.
45{
47 uint_fast16_t uiA;
49 uint_fast16_t uiB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
56 if (
58 ) {
60 }
61 return false;
62 }
64
65}
◆ f16_eq_signaling()
Definition at line 43 of file f16_eq_signaling.c.
44{
46 uint_fast16_t uiA;
48 uint_fast16_t uiB;
49
51 uiA = uA.ui;
52 uB.f = b;
53 uiB = uB.ui;
56 return false;
57 }
59
60}
◆ f16_isSignalingNaN()
| bool f16_isSignalingNaN | ( | float16_t | a | ) |
Definition at line 43 of file f16_isSignalingNaN.c.
◆ f16_le()
Definition at line 43 of file f16_le.c.
44{
46 uint_fast16_t uiA;
48 uint_fast16_t uiB;
49 bool signA, signB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
57 return false;
58 }
59 signA = signF16UI( uiA );
60 signB = signF16UI( uiB );
61 return
62 (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1)
63 : (uiA == uiB) || (signA ^ (uiA < uiB));
64
65}
◆ f16_le_quiet()
Definition at line 44 of file f16_le_quiet.c.
45{
47 uint_fast16_t uiA;
49 uint_fast16_t uiB;
50 bool signA, signB;
51
53 uiA = uA.ui;
54 uB.f = b;
55 uiB = uB.ui;
57 if (
59 ) {
61 }
62 return false;
63 }
64 signA = signF16UI( uiA );
65 signB = signF16UI( uiB );
66 return
67 (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1)
68 : (uiA == uiB) || (signA ^ (uiA < uiB));
69
70}
◆ f16_lt()
Definition at line 43 of file f16_lt.c.
44{
46 uint_fast16_t uiA;
48 uint_fast16_t uiB;
49 bool signA, signB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
57 return false;
58 }
59 signA = signF16UI( uiA );
60 signB = signF16UI( uiB );
61 return
62 (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0)
63 : (uiA != uiB) && (signA ^ (uiA < uiB));
64
65}
◆ f16_lt_quiet()
Definition at line 44 of file f16_lt_quiet.c.
45{
47 uint_fast16_t uiA;
49 uint_fast16_t uiB;
50 bool signA, signB;
51
53 uiA = uA.ui;
54 uB.f = b;
55 uiB = uB.ui;
57 if (
59 ) {
61 }
62 return false;
63 }
64 signA = signF16UI( uiA );
65 signB = signF16UI( uiB );
66 return
67 (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0)
68 : (uiA != uiB) && (signA ^ (uiA < uiB));
69
70}
◆ f16_mul()
Definition at line 44 of file f16_mul.c.
45{
47 uint_fast16_t uiA;
48 bool signA;
49 int_fast8_t expA;
50 uint_fast16_t sigA;
52 uint_fast16_t uiB;
53 bool signB;
54 int_fast8_t expB;
55 uint_fast16_t sigB;
56 bool signZ;
57 uint_fast16_t magBits;
59 int_fast8_t expZ;
60 uint_fast32_t sig32Z;
61 uint_fast16_t sigZ, uiZ;
63
64 /*------------------------------------------------------------------------
65 *------------------------------------------------------------------------*/
67 uiA = uA.ui;
68 signA = signF16UI( uiA );
69 expA = expF16UI( uiA );
70 sigA = fracF16UI( uiA );
71 uB.f = b;
72 uiB = uB.ui;
73 signB = signF16UI( uiB );
74 expB = expF16UI( uiB );
75 sigB = fracF16UI( uiB );
76 signZ = signA ^ signB;
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
79 if ( expA == 0x1F ) {
80 if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;
81 magBits = expB | sigB;
82 goto infArg;
83 }
84 if ( expB == 0x1F ) {
85 if ( sigB ) goto propagateNaN;
86 magBits = expA | sigA;
87 goto infArg;
88 }
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
91 if ( ! expA ) {
92 if ( ! sigA ) goto zero;
93 normExpSig = softfloat_normSubnormalF16Sig( sigA );
94 expA = normExpSig.exp;
95 sigA = normExpSig.sig;
96 }
97 if ( ! expB ) {
98 if ( ! sigB ) goto zero;
99 normExpSig = softfloat_normSubnormalF16Sig( sigB );
100 expB = normExpSig.exp;
101 sigB = normExpSig.sig;
102 }
103 /*------------------------------------------------------------------------
104 *------------------------------------------------------------------------*/
105 expZ = expA + expB - 0xF;
106 sigA = (sigA | 0x0400)<<4;
107 sigB = (sigB | 0x0400)<<5;
108 sig32Z = (uint_fast32_t) sigA * sigB;
109 sigZ = sig32Z>>16;
110 if ( sig32Z & 0xFFFF ) sigZ |= 1;
111 if ( sigZ < 0x4000 ) {
112 --expZ;
113 sigZ <<= 1;
114 }
116 /*------------------------------------------------------------------------
117 *------------------------------------------------------------------------*/
118 propagateNaN:
119 uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
120 goto uiZ;
121 /*------------------------------------------------------------------------
122 *------------------------------------------------------------------------*/
123 infArg:
124 if ( ! magBits ) {
126 uiZ = defaultNaNF16UI;
127 } else {
128 uiZ = packToF16UI( signZ, 0x1F, 0 );
129 }
130 goto uiZ;
131 /*------------------------------------------------------------------------
132 *------------------------------------------------------------------------*/
133 zero:
134 uiZ = packToF16UI( signZ, 0, 0 );
135 uiZ:
136 uZ.ui = uiZ;
137 return uZ.f;
138
139}
◆ f16_mulAdd()
Definition at line 42 of file f16_mulAdd.c.
43{
45 uint_fast16_t uiA;
47 uint_fast16_t uiB;
49 uint_fast16_t uiC;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
55 uC.f = c;
56 uiC = uC.ui;
58
59}
float16_t softfloat_mulAddF16(uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t)
Definition s_mulAddF16.c:45
◆ f16_rem()
Definition at line 44 of file f16_rem.c.
45{
47 uint_fast16_t uiA;
48 bool signA;
49 int_fast8_t expA;
50 uint_fast16_t sigA;
52 uint_fast16_t uiB;
53 int_fast8_t expB;
54 uint_fast16_t sigB;
56 uint16_t rem;
57 int_fast8_t expDiff;
58 uint_fast16_t q;
59 uint32_t recip32, q32;
60 uint16_t altRem, meanRem;
61 bool signRem;
62 uint_fast16_t uiZ;
64
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
68 uiA = uA.ui;
69 signA = signF16UI( uiA );
70 expA = expF16UI( uiA );
71 sigA = fracF16UI( uiA );
72 uB.f = b;
73 uiB = uB.ui;
74 expB = expF16UI( uiB );
75 sigB = fracF16UI( uiB );
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( expA == 0x1F ) {
79 if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;
80 goto invalid;
81 }
82 if ( expB == 0x1F ) {
83 if ( sigB ) goto propagateNaN;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 if ( ! expB ) {
89 if ( ! sigB ) goto invalid;
90 normExpSig = softfloat_normSubnormalF16Sig( sigB );
91 expB = normExpSig.exp;
92 sigB = normExpSig.sig;
93 }
94 if ( ! expA ) {
96 normExpSig = softfloat_normSubnormalF16Sig( sigA );
97 expA = normExpSig.exp;
98 sigA = normExpSig.sig;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 rem = sigA | 0x0400;
103 sigB |= 0x0400;
104 expDiff = expA - expB;
105 if ( expDiff < 1 ) {
107 sigB <<= 3;
108 if ( expDiff ) {
109 rem <<= 2;
110 q = 0;
111 } else {
112 rem <<= 3;
113 q = (sigB <= rem);
114 if ( q ) rem -= sigB;
115 }
116 } else {
118 /*--------------------------------------------------------------------
119 | Changing the shift of `rem' here requires also changing the initial
120 | subtraction from `expDiff'.
121 *--------------------------------------------------------------------*/
122 rem <<= 4;
123 expDiff -= 31;
124 /*--------------------------------------------------------------------
125 | The scale of `sigB' affects how many bits are obtained during each
126 | cycle of the loop. Currently this is 29 bits per loop iteration,
127 | which is believed to be the maximum possible.
128 *--------------------------------------------------------------------*/
129 sigB <<= 3;
130 for (;;) {
131 q32 = (rem * (uint_fast64_t) recip32)>>16;
132 if ( expDiff < 0 ) break;
133 rem = -((uint_fast16_t) q32 * sigB);
134 expDiff -= 29;
135 }
136 /*--------------------------------------------------------------------
137 | (`expDiff' cannot be less than -30 here.)
138 *--------------------------------------------------------------------*/
139 q32 >>= ~expDiff & 31;
140 q = q32;
141 rem = (rem<<(expDiff + 30)) - q * sigB;
142 }
143 /*------------------------------------------------------------------------
144 *------------------------------------------------------------------------*/
145 do {
146 altRem = rem;
147 ++q;
148 rem -= sigB;
149 } while ( ! (rem & 0x8000) );
150 meanRem = rem + altRem;
151 if ( (meanRem & 0x8000) || (! meanRem && (q & 1)) ) rem = altRem;
152 signRem = signA;
153 if ( 0x8000 <= rem ) {
154 signRem = ! signRem;
155 rem = -rem;
156 }
158 /*------------------------------------------------------------------------
159 *------------------------------------------------------------------------*/
160 propagateNaN:
161 uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
162 goto uiZ;
163 invalid:
165 uiZ = defaultNaNF16UI;
166 uiZ:
167 uZ.ui = uiZ;
168 return uZ.f;
169
170}
float16_t softfloat_normRoundPackToF16(bool, int_fast16_t, uint_fast16_t)
Definition s_normRoundPackToF16.c:43
◆ f16_roundToInt()
| float16_t f16_roundToInt | ( | float16_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f16_roundToInt.c.
45{
47 uint_fast16_t uiA;
48 int_fast8_t exp;
49 uint_fast16_t uiZ, lastBitMask, roundBitsMask;
51
52 /*------------------------------------------------------------------------
53 *------------------------------------------------------------------------*/
55 uiA = uA.ui;
56 exp = expF16UI( uiA );
57 /*------------------------------------------------------------------------
58 *------------------------------------------------------------------------*/
59 if ( exp <= 0xE ) {
62 uiZ = uiA & packToF16UI( 1, 0, 0 );
63 switch ( roundingMode ) {
68 break;
71 break;
74 break;
75#ifdef SOFTFLOAT_ROUND_ODD
77 uiZ |= packToF16UI( 0, 0xF, 0 );
78 break;
79#endif
80 }
81 goto uiZ;
82 }
83 /*------------------------------------------------------------------------
84 *------------------------------------------------------------------------*/
85 if ( 0x19 <= exp ) {
87 uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
88 goto uiZ;
89 }
91 }
92 /*------------------------------------------------------------------------
93 *------------------------------------------------------------------------*/
94 uiZ = uiA;
95 lastBitMask = (uint_fast16_t) 1<<(0x19 - exp);
96 roundBitsMask = lastBitMask - 1;
98 uiZ += lastBitMask>>1;
100 uiZ += lastBitMask>>1;
101 if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
102 } else if (
103 roundingMode
105 ) {
106 uiZ += roundBitsMask;
107 }
108 uiZ &= ~roundBitsMask;
109 if ( uiZ != uiA ) {
110#ifdef SOFTFLOAT_ROUND_ODD
112#endif
114 }
115 uiZ:
116 uZ.ui = uiZ;
117 return uZ.f;
118
119}
◆ f16_sqrt()
Definition at line 47 of file f16_sqrt.c.
48{
50 uint_fast16_t uiA;
51 bool signA;
52 int_fast8_t expA;
53 uint_fast16_t sigA, uiZ;
55 int_fast8_t expZ;
56 int index;
57 uint_fast16_t r0;
58 uint_fast32_t ESqrR0;
60 uint_fast16_t recipSqrt16, sigZ, shiftedSigZ;
61 uint16_t negRem;
63
64 /*------------------------------------------------------------------------
65 *------------------------------------------------------------------------*/
67 uiA = uA.ui;
68 signA = signF16UI( uiA );
69 expA = expF16UI( uiA );
70 sigA = fracF16UI( uiA );
71 /*------------------------------------------------------------------------
72 *------------------------------------------------------------------------*/
73 if ( expA == 0x1F ) {
74 if ( sigA ) {
75 uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
76 goto uiZ;
77 }
79 goto invalid;
80 }
81 /*------------------------------------------------------------------------
82 *------------------------------------------------------------------------*/
83 if ( signA ) {
85 goto invalid;
86 }
87 /*------------------------------------------------------------------------
88 *------------------------------------------------------------------------*/
89 if ( ! expA ) {
91 normExpSig = softfloat_normSubnormalF16Sig( sigA );
92 expA = normExpSig.exp;
93 sigA = normExpSig.sig;
94 }
95 /*------------------------------------------------------------------------
96 *------------------------------------------------------------------------*/
97 expZ = ((expA - 0xF)>>1) + 0xE;
98 expA &= 1;
99 sigA |= 0x0400;
100 index = (sigA>>6 & 0xE) + expA;
101 r0 = softfloat_approxRecipSqrt_1k0s[index]
103 * (sigA & 0x7F))
104 >>11);
105 ESqrR0 = ((uint_fast32_t) r0 * r0)>>1;
106 if ( expA ) ESqrR0 >>= 1;
109 if ( ! (recipSqrt16 & 0x8000) ) recipSqrt16 = 0x8000;
110 sigZ = ((uint_fast32_t) (sigA<<5) * recipSqrt16)>>16;
111 if ( expA ) sigZ >>= 1;
112 /*------------------------------------------------------------------------
113 *------------------------------------------------------------------------*/
114 ++sigZ;
115 if ( ! (sigZ & 7) ) {
116 shiftedSigZ = sigZ>>1;
117 negRem = shiftedSigZ * shiftedSigZ;
118 sigZ &= ~1;
119 if ( negRem & 0x8000 ) {
120 sigZ |= 1;
121 } else {
122 if ( negRem ) --sigZ;
123 }
124 }
126 /*------------------------------------------------------------------------
127 *------------------------------------------------------------------------*/
128 invalid:
130 uiZ = defaultNaNF16UI;
131 uiZ:
132 uZ.ui = uiZ;
133 return uZ.f;
134
135}
const uint16_t softfloat_approxRecipSqrt_1k0s[]
Definition s_approxRecipSqrt_1Ks.c:41
const uint16_t softfloat_approxRecipSqrt_1k1s[]
Definition s_approxRecipSqrt_1Ks.c:45
◆ f16_sub()
Definition at line 43 of file f16_sub.c.
44{
46 uint_fast16_t uiA;
48 uint_fast16_t uiB;
49#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
51#endif
52
53 uA.f = a;
54 uiA = uA.ui;
55 uB.f = b;
56 uiB = uB.ui;
57#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
60 } else {
62 }
63#else
64 magsFuncPtr =
66 return (*magsFuncPtr)( uiA, uiB );
67#endif
68
69}
◆ f16_to_extF80M()
| void f16_to_extF80M | ( | float16_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 55 of file f16_to_extF80M.c.
56{
59 uint16_t uiA;
60 bool sign;
61 int_fast8_t exp;
62 uint16_t frac;
64 uint_fast16_t uiZ64;
65 uint32_t uiZ32;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uA.f = a;
72 uiA = uA.ui;
73 sign = signF16UI( uiA );
74 exp = expF16UI( uiA );
75 frac = fracF16UI( uiA );
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( exp == 0x1F ) {
79 if ( frac ) {
82 return;
83 }
84 uiZ64 = packToExtF80UI64( sign, 0x7FFF );
85 uiZ32 = 0x80000000;
86 goto uiZ;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( ! exp ) {
91 if ( ! frac ) {
92 uiZ64 = packToExtF80UI64( sign, 0 );
93 uiZ32 = 0;
94 goto uiZ;
95 }
96 normExpSig = softfloat_normSubnormalF16Sig( frac );
97 exp = normExpSig.exp;
98 frac = normExpSig.sig;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );
103 uiZ32 = 0x80000000 | (uint32_t) frac<<21;
104 uiZ:
105 zSPtr->signExp = uiZ64;
107
108}
◆ f16_to_f128M()
| void f16_to_f128M | ( | float16_t | a, |
| float128_t * | zPtr ) |
Definition at line 55 of file f16_to_f128M.c.
56{
57 uint32_t *zWPtr;
59 uint16_t uiA;
60 bool sign;
61 int_fast8_t exp;
62 uint16_t frac;
64 uint32_t uiZ96;
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
69 zWPtr = (uint32_t *) zPtr;
70 /*------------------------------------------------------------------------
71 *------------------------------------------------------------------------*/
72 uA.f = a;
73 uiA = uA.ui;
74 sign = signF16UI( uiA );
76 frac = fracF16UI( uiA );
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
80 if ( frac ) {
83 return;
84 }
85 uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
86 goto uiZ;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
91 if ( ! frac ) {
92 uiZ96 = packToF128UI96( sign, 0, 0 );
93 goto uiZ;
94 }
95 normExpSig = softfloat_normSubnormalF16Sig( frac );
96 exp = normExpSig.exp - 1;
97 frac = normExpSig.sig;
98 }
99 /*------------------------------------------------------------------------
100 *------------------------------------------------------------------------*/
102 uiZ:
103 zWPtr[indexWord( 4, 3 )] = uiZ96;
104 zWPtr[indexWord( 4, 2 )] = 0;
105 zWPtr[indexWord( 4, 1 )] = 0;
106 zWPtr[indexWord( 4, 0 )] = 0;
107
108}
◆ f16_to_f32()
Definition at line 44 of file f16_to_f32.c.
45{
47 uint_fast16_t uiA;
48 bool sign;
49 int_fast8_t exp;
50 uint_fast16_t frac;
52 uint_fast32_t uiZ;
55
56 /*------------------------------------------------------------------------
57 *------------------------------------------------------------------------*/
59 uiA = uA.ui;
60 sign = signF16UI( uiA );
61 exp = expF16UI( uiA );
62 frac = fracF16UI( uiA );
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
65 if ( exp == 0x1F ) {
66 if ( frac ) {
69 } else {
70 uiZ = packToF32UI( sign, 0xFF, 0 );
71 }
72 goto uiZ;
73 }
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( ! exp ) {
77 if ( ! frac ) {
78 uiZ = packToF32UI( sign, 0, 0 );
79 goto uiZ;
80 }
81 normExpSig = softfloat_normSubnormalF16Sig( frac );
82 exp = normExpSig.exp - 1;
83 frac = normExpSig.sig;
84 }
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
88 uiZ:
89 uZ.ui = uiZ;
90 return uZ.f;
91
92}
◆ f16_to_f64()
Definition at line 44 of file f16_to_f64.c.
45{
47 uint_fast16_t uiA;
48 bool sign;
49 int_fast8_t exp;
50 uint_fast16_t frac;
52 uint_fast64_t uiZ;
55
56 /*------------------------------------------------------------------------
57 *------------------------------------------------------------------------*/
59 uiA = uA.ui;
60 sign = signF16UI( uiA );
61 exp = expF16UI( uiA );
62 frac = fracF16UI( uiA );
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
65 if ( exp == 0x1F ) {
66 if ( frac ) {
69 } else {
70 uiZ = packToF64UI( sign, 0x7FF, 0 );
71 }
72 goto uiZ;
73 }
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( ! exp ) {
77 if ( ! frac ) {
78 uiZ = packToF64UI( sign, 0, 0 );
79 goto uiZ;
80 }
81 normExpSig = softfloat_normSubnormalF16Sig( frac );
82 exp = normExpSig.exp - 1;
83 frac = normExpSig.sig;
84 }
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
88 uiZ:
89 uZ.ui = uiZ;
90 return uZ.f;
91
92}
◆ f16_to_i32()
| int_fast32_t f16_to_i32 | ( | float16_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f16_to_i32.c.
45{
47 uint_fast16_t uiA;
48 bool sign;
49 int_fast8_t exp;
50 uint_fast16_t frac;
51 int_fast32_t sig32;
52 int_fast8_t shiftDist;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 sign = signF16UI( uiA );
59 exp = expF16UI( uiA );
60 frac = fracF16UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63 if ( exp == 0x1F ) {
65 return
66 frac ? i32_fromNaN
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sig32 = frac;
72 if ( exp ) {
73 sig32 |= 0x0400;
74 shiftDist = exp - 0x19;
75 if ( 0 <= shiftDist ) {
76 sig32 <<= shiftDist;
77 return sign ? -sig32 : sig32;
78 }
79 shiftDist = exp - 0x0D;
80 if ( 0 < shiftDist ) sig32 <<= shiftDist;
81 }
82 return
84 sign, (uint_fast32_t) sig32, roundingMode, exact );
85
86}
◆ f16_to_i32_r_minMag()
| int_fast32_t f16_to_i32_r_minMag | ( | float16_t | a, |
| bool | exact ) |
Definition at line 44 of file f16_to_i32_r_minMag.c.
45{
47 uint_fast16_t uiA;
48 int_fast8_t exp;
49 uint_fast16_t frac;
50 int_fast8_t shiftDist;
51 bool sign;
52 int_fast32_t alignedSig;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF16UI( uiA );
59 frac = fracF16UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = exp - 0x0F;
63 if ( shiftDist < 0 ) {
64 if ( exact && (exp | frac) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF16UI( uiA );
72 if ( exp == 0x1F ) {
74 return
75 (exp == 0x1F) && frac ? i32_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
81 if ( exact && (alignedSig & 0x3FF) ) {
83 }
84 alignedSig >>= 10;
85 return sign ? -alignedSig : alignedSig;
86
87}
◆ f16_to_i64()
| int_fast64_t f16_to_i64 | ( | float16_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f16_to_i64.c.
45{
47 uint_fast16_t uiA;
48 bool sign;
49 int_fast8_t exp;
50 uint_fast16_t frac;
51 int_fast32_t sig32;
52 int_fast8_t shiftDist;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 sign = signF16UI( uiA );
59 exp = expF16UI( uiA );
60 frac = fracF16UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63 if ( exp == 0x1F ) {
65 return
66 frac ? i64_fromNaN
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sig32 = frac;
72 if ( exp ) {
73 sig32 |= 0x0400;
74 shiftDist = exp - 0x19;
75 if ( 0 <= shiftDist ) {
76 sig32 <<= shiftDist;
77 return sign ? -sig32 : sig32;
78 }
79 shiftDist = exp - 0x0D;
80 if ( 0 < shiftDist ) sig32 <<= shiftDist;
81 }
82 return
84 sign, (uint_fast32_t) sig32, roundingMode, exact );
85
86}
◆ f16_to_i64_r_minMag()
| int_fast64_t f16_to_i64_r_minMag | ( | float16_t | a, |
| bool | exact ) |
Definition at line 44 of file f16_to_i64_r_minMag.c.
45{
47 uint_fast16_t uiA;
48 int_fast8_t exp;
49 uint_fast16_t frac;
50 int_fast8_t shiftDist;
51 bool sign;
52 int_fast32_t alignedSig;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF16UI( uiA );
59 frac = fracF16UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = exp - 0x0F;
63 if ( shiftDist < 0 ) {
64 if ( exact && (exp | frac) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF16UI( uiA );
72 if ( exp == 0x1F ) {
74 return
75 (exp == 0x1F) && frac ? i64_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
81 if ( exact && (alignedSig & 0x3FF) ) {
83 }
84 alignedSig >>= 10;
85 return sign ? -alignedSig : alignedSig;
86
87}
◆ f16_to_ui32()
| uint_fast32_t f16_to_ui32 | ( | float16_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f16_to_ui32.c.
45{
47 uint_fast16_t uiA;
48 bool sign;
49 int_fast8_t exp;
50 uint_fast16_t frac;
51 uint_fast32_t sig32;
52 int_fast8_t shiftDist;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 sign = signF16UI( uiA );
59 exp = expF16UI( uiA );
60 frac = fracF16UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63 if ( exp == 0x1F ) {
65 return
66 frac ? ui32_fromNaN
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sig32 = frac;
72 if ( exp ) {
73 sig32 |= 0x0400;
74 shiftDist = exp - 0x19;
75 if ( (0 <= shiftDist) && ! sign ) {
76 return sig32<<shiftDist;
77 }
78 shiftDist = exp - 0x0D;
79 if ( 0 < shiftDist ) sig32 <<= shiftDist;
80 }
82
83}
◆ f16_to_ui32_r_minMag()
| uint_fast32_t f16_to_ui32_r_minMag | ( | float16_t | a, |
| bool | exact ) |
Definition at line 44 of file f16_to_ui32_r_minMag.c.
45{
47 uint_fast16_t uiA;
48 int_fast8_t exp;
49 uint_fast16_t frac;
50 int_fast8_t shiftDist;
51 bool sign;
52 uint_fast32_t alignedSig;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF16UI( uiA );
59 frac = fracF16UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = exp - 0x0F;
63 if ( shiftDist < 0 ) {
64 if ( exact && (exp | frac) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF16UI( uiA );
72 if ( sign || (exp == 0x1F) ) {
74 return
75 (exp == 0x1F) && frac ? ui32_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
81 if ( exact && (alignedSig & 0x3FF) ) {
83 }
84 return alignedSig>>10;
85
86}
◆ f16_to_ui64()
| uint_fast64_t f16_to_ui64 | ( | float16_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f16_to_ui64.c.
45{
47 uint_fast16_t uiA;
48 bool sign;
49 int_fast8_t exp;
50 uint_fast16_t frac;
51 uint_fast32_t sig32;
52 int_fast8_t shiftDist;
53#ifndef SOFTFLOAT_FAST_INT64
54 uint32_t extSig[3];
55#endif
56
57 /*------------------------------------------------------------------------
58 *------------------------------------------------------------------------*/
60 uiA = uA.ui;
61 sign = signF16UI( uiA );
62 exp = expF16UI( uiA );
63 frac = fracF16UI( uiA );
64 /*------------------------------------------------------------------------
65 *------------------------------------------------------------------------*/
66 if ( exp == 0x1F ) {
68 return
69 frac ? ui64_fromNaN
71 }
72 /*------------------------------------------------------------------------
73 *------------------------------------------------------------------------*/
74 sig32 = frac;
75 if ( exp ) {
76 sig32 |= 0x0400;
77 shiftDist = exp - 0x19;
78 if ( (0 <= shiftDist) && ! sign ) {
79 return sig32<<shiftDist;
80 }
81 shiftDist = exp - 0x0D;
82 if ( 0 < shiftDist ) sig32 <<= shiftDist;
83 }
84#ifdef SOFTFLOAT_FAST_INT64
85 return
87 sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact );
88#else
89 extSig[indexWord( 3, 2 )] = 0;
90 extSig[indexWord( 3, 1 )] = sig32>>12;
91 extSig[indexWord( 3, 0 )] = sig32<<20;
93#endif
94
95}
uint_fast64_t softfloat_roundToUI64(bool sign, uint_fast64_t sig, uint_fast64_t sigExtra, uint_fast8_t roundingMode, bool exact)
Definition s_roundToUI64.c:45
◆ f16_to_ui64_r_minMag()
| uint_fast64_t f16_to_ui64_r_minMag | ( | float16_t | a, |
| bool | exact ) |
Definition at line 44 of file f16_to_ui64_r_minMag.c.
45{
47 uint_fast16_t uiA;
48 int_fast8_t exp;
49 uint_fast16_t frac;
50 int_fast8_t shiftDist;
51 bool sign;
52 uint_fast32_t alignedSig;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF16UI( uiA );
59 frac = fracF16UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = exp - 0x0F;
63 if ( shiftDist < 0 ) {
64 if ( exact && (exp | frac) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF16UI( uiA );
72 if ( sign || (exp == 0x1F) ) {
74 return
75 (exp == 0x1F) && frac ? ui64_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
81 if ( exact && (alignedSig & 0x3FF) ) {
83 }
84 return alignedSig>>10;
85
86}
◆ f32_add()
Definition at line 43 of file f32_add.c.
44{
46 uint_fast32_t uiA;
48 uint_fast32_t uiB;
49#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
51#endif
52
53 uA.f = a;
54 uiA = uA.ui;
55 uB.f = b;
56 uiB = uB.ui;
57#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
60 } else {
62 }
63#else
64 magsFuncPtr =
66 return (*magsFuncPtr)( uiA, uiB );
67#endif
68
69}
float32_t softfloat_addMagsF32(uint_fast32_t, uint_fast32_t)
Definition s_addMagsF32.c:43
float32_t softfloat_subMagsF32(uint_fast32_t, uint_fast32_t)
Definition s_subMagsF32.c:44
Definition softfloat_types.h:51
◆ f32_div()
Definition at line 44 of file f32_div.c.
45{
47 uint_fast32_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast32_t sigA;
52 uint_fast32_t uiB;
53 bool signB;
54 int_fast16_t expB;
55 uint_fast32_t sigB;
56 bool signZ;
58 int_fast16_t expZ;
59#ifdef SOFTFLOAT_FAST_DIV64TO32
60 uint_fast64_t sig64A;
61 uint_fast32_t sigZ;
62#else
63 uint_fast32_t sigZ;
64 uint_fast64_t rem;
65#endif
66 uint_fast32_t uiZ;
68
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
72 uiA = uA.ui;
73 signA = signF32UI( uiA );
74 expA = expF32UI( uiA );
75 sigA = fracF32UI( uiA );
76 uB.f = b;
77 uiB = uB.ui;
78 signB = signF32UI( uiB );
79 expB = expF32UI( uiB );
80 sigB = fracF32UI( uiB );
81 signZ = signA ^ signB;
82 /*------------------------------------------------------------------------
83 *------------------------------------------------------------------------*/
84 if ( expA == 0xFF ) {
85 if ( sigA ) goto propagateNaN;
86 if ( expB == 0xFF ) {
87 if ( sigB ) goto propagateNaN;
88 goto invalid;
89 }
90 goto infinity;
91 }
92 if ( expB == 0xFF ) {
93 if ( sigB ) goto propagateNaN;
94 goto zero;
95 }
96 /*------------------------------------------------------------------------
97 *------------------------------------------------------------------------*/
98 if ( ! expB ) {
99 if ( ! sigB ) {
100 if ( ! (expA | sigA) ) goto invalid;
102 goto infinity;
103 }
104 normExpSig = softfloat_normSubnormalF32Sig( sigB );
105 expB = normExpSig.exp;
106 sigB = normExpSig.sig;
107 }
108 if ( ! expA ) {
109 if ( ! sigA ) goto zero;
110 normExpSig = softfloat_normSubnormalF32Sig( sigA );
111 expA = normExpSig.exp;
112 sigA = normExpSig.sig;
113 }
114 /*------------------------------------------------------------------------
115 *------------------------------------------------------------------------*/
116 expZ = expA - expB + 0x7E;
117 sigA |= 0x00800000;
118 sigB |= 0x00800000;
119#ifdef SOFTFLOAT_FAST_DIV64TO32
120 if ( sigA < sigB ) {
121 --expZ;
122 sig64A = (uint_fast64_t) sigA<<31;
123 } else {
124 sig64A = (uint_fast64_t) sigA<<30;
125 }
126 sigZ = sig64A / sigB;
128#else
129 if ( sigA < sigB ) {
130 --expZ;
131 sigA <<= 8;
132 } else {
133 sigA <<= 7;
134 }
135 sigB <<= 8;
137 /*------------------------------------------------------------------------
138 *------------------------------------------------------------------------*/
139 sigZ += 2;
140 if ( (sigZ & 0x3F) < 2 ) {
141 sigZ &= ~3;
142#ifdef SOFTFLOAT_FAST_INT64
144#else
146#endif
148 sigZ -= 4;
149 } else {
150 if ( rem ) sigZ |= 1;
151 }
152 }
153#endif
155 /*------------------------------------------------------------------------
156 *------------------------------------------------------------------------*/
157 propagateNaN:
158 uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
159 goto uiZ;
160 /*------------------------------------------------------------------------
161 *------------------------------------------------------------------------*/
162 invalid:
164 uiZ = defaultNaNF32UI;
165 goto uiZ;
166 /*------------------------------------------------------------------------
167 *------------------------------------------------------------------------*/
168 infinity:
169 uiZ = packToF32UI( signZ, 0xFF, 0 );
170 goto uiZ;
171 /*------------------------------------------------------------------------
172 *------------------------------------------------------------------------*/
173 zero:
174 uiZ = packToF32UI( signZ, 0, 0 );
175 uiZ:
176 uZ.ui = uiZ;
177 return uZ.f;
178
179}
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB)
Definition s_propagateNaNF32UI.c:51
struct exp16_sig32 softfloat_normSubnormalF32Sig(uint_fast32_t)
Definition s_normSubnormalF32Sig.c:41
Definition internals.h:111
◆ f32_eq()
Definition at line 44 of file f32_eq.c.
45{
47 uint_fast32_t uiA;
49 uint_fast32_t uiB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
56 if (
58 ) {
60 }
61 return false;
62 }
64
65}
◆ f32_eq_signaling()
Definition at line 43 of file f32_eq_signaling.c.
44{
46 uint_fast32_t uiA;
48 uint_fast32_t uiB;
49
51 uiA = uA.ui;
52 uB.f = b;
53 uiB = uB.ui;
56 return false;
57 }
59
60}
◆ f32_isSignalingNaN()
| bool f32_isSignalingNaN | ( | float32_t | a | ) |
Definition at line 43 of file f32_isSignalingNaN.c.
◆ f32_le()
Definition at line 43 of file f32_le.c.
44{
46 uint_fast32_t uiA;
48 uint_fast32_t uiB;
49 bool signA, signB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
57 return false;
58 }
59 signA = signF32UI( uiA );
60 signB = signF32UI( uiB );
61 return
62 (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1)
63 : (uiA == uiB) || (signA ^ (uiA < uiB));
64
65}
◆ f32_le_quiet()
Definition at line 44 of file f32_le_quiet.c.
45{
47 uint_fast32_t uiA;
49 uint_fast32_t uiB;
50 bool signA, signB;
51
53 uiA = uA.ui;
54 uB.f = b;
55 uiB = uB.ui;
57 if (
59 ) {
61 }
62 return false;
63 }
64 signA = signF32UI( uiA );
65 signB = signF32UI( uiB );
66 return
67 (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1)
68 : (uiA == uiB) || (signA ^ (uiA < uiB));
69
70}
◆ f32_lt()
Definition at line 43 of file f32_lt.c.
44{
46 uint_fast32_t uiA;
48 uint_fast32_t uiB;
49 bool signA, signB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
57 return false;
58 }
59 signA = signF32UI( uiA );
60 signB = signF32UI( uiB );
61 return
62 (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0)
63 : (uiA != uiB) && (signA ^ (uiA < uiB));
64
65}
◆ f32_lt_quiet()
Definition at line 44 of file f32_lt_quiet.c.
45{
47 uint_fast32_t uiA;
49 uint_fast32_t uiB;
50 bool signA, signB;
51
53 uiA = uA.ui;
54 uB.f = b;
55 uiB = uB.ui;
57 if (
59 ) {
61 }
62 return false;
63 }
64 signA = signF32UI( uiA );
65 signB = signF32UI( uiB );
66 return
67 (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0)
68 : (uiA != uiB) && (signA ^ (uiA < uiB));
69
70}
◆ f32_mul()
Definition at line 44 of file f32_mul.c.
45{
47 uint_fast32_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast32_t sigA;
52 uint_fast32_t uiB;
53 bool signB;
54 int_fast16_t expB;
55 uint_fast32_t sigB;
56 bool signZ;
57 uint_fast32_t magBits;
59 int_fast16_t expZ;
60 uint_fast32_t sigZ, uiZ;
62
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
66 uiA = uA.ui;
67 signA = signF32UI( uiA );
68 expA = expF32UI( uiA );
69 sigA = fracF32UI( uiA );
70 uB.f = b;
71 uiB = uB.ui;
72 signB = signF32UI( uiB );
73 expB = expF32UI( uiB );
74 sigB = fracF32UI( uiB );
75 signZ = signA ^ signB;
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( expA == 0xFF ) {
79 if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN;
80 magBits = expB | sigB;
81 goto infArg;
82 }
83 if ( expB == 0xFF ) {
84 if ( sigB ) goto propagateNaN;
85 magBits = expA | sigA;
86 goto infArg;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( ! expA ) {
91 if ( ! sigA ) goto zero;
92 normExpSig = softfloat_normSubnormalF32Sig( sigA );
93 expA = normExpSig.exp;
94 sigA = normExpSig.sig;
95 }
96 if ( ! expB ) {
97 if ( ! sigB ) goto zero;
98 normExpSig = softfloat_normSubnormalF32Sig( sigB );
99 expB = normExpSig.exp;
100 sigB = normExpSig.sig;
101 }
102 /*------------------------------------------------------------------------
103 *------------------------------------------------------------------------*/
104 expZ = expA + expB - 0x7F;
105 sigA = (sigA | 0x00800000)<<7;
106 sigB = (sigB | 0x00800000)<<8;
108 if ( sigZ < 0x40000000 ) {
109 --expZ;
110 sigZ <<= 1;
111 }
113 /*------------------------------------------------------------------------
114 *------------------------------------------------------------------------*/
115 propagateNaN:
116 uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
117 goto uiZ;
118 /*------------------------------------------------------------------------
119 *------------------------------------------------------------------------*/
120 infArg:
121 if ( ! magBits ) {
123 uiZ = defaultNaNF32UI;
124 } else {
125 uiZ = packToF32UI( signZ, 0xFF, 0 );
126 }
127 goto uiZ;
128 /*------------------------------------------------------------------------
129 *------------------------------------------------------------------------*/
130 zero:
131 uiZ = packToF32UI( signZ, 0, 0 );
132 uiZ:
133 uZ.ui = uiZ;
134 return uZ.f;
135
136}
◆ f32_mulAdd()
Definition at line 42 of file f32_mulAdd.c.
43{
45 uint_fast32_t uiA;
47 uint_fast32_t uiB;
49 uint_fast32_t uiC;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
55 uC.f = c;
56 uiC = uC.ui;
58
59}
float32_t softfloat_mulAddF32(uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t)
Definition s_mulAddF32.c:45
◆ f32_rem()
Definition at line 44 of file f32_rem.c.
45{
47 uint_fast32_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast32_t sigA;
52 uint_fast32_t uiB;
53 int_fast16_t expB;
54 uint_fast32_t sigB;
56 uint32_t rem;
57 int_fast16_t expDiff;
58 uint32_t q, recip32, altRem, meanRem;
59 bool signRem;
60 uint_fast32_t uiZ;
62
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
66 uiA = uA.ui;
67 signA = signF32UI( uiA );
68 expA = expF32UI( uiA );
69 sigA = fracF32UI( uiA );
70 uB.f = b;
71 uiB = uB.ui;
72 expB = expF32UI( uiB );
73 sigB = fracF32UI( uiB );
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( expA == 0xFF ) {
77 if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN;
78 goto invalid;
79 }
80 if ( expB == 0xFF ) {
81 if ( sigB ) goto propagateNaN;
83 }
84 /*------------------------------------------------------------------------
85 *------------------------------------------------------------------------*/
86 if ( ! expB ) {
87 if ( ! sigB ) goto invalid;
88 normExpSig = softfloat_normSubnormalF32Sig( sigB );
89 expB = normExpSig.exp;
90 sigB = normExpSig.sig;
91 }
92 if ( ! expA ) {
94 normExpSig = softfloat_normSubnormalF32Sig( sigA );
95 expA = normExpSig.exp;
96 sigA = normExpSig.sig;
97 }
98 /*------------------------------------------------------------------------
99 *------------------------------------------------------------------------*/
100 rem = sigA | 0x00800000;
101 sigB |= 0x00800000;
102 expDiff = expA - expB;
103 if ( expDiff < 1 ) {
105 sigB <<= 6;
106 if ( expDiff ) {
107 rem <<= 5;
108 q = 0;
109 } else {
110 rem <<= 6;
111 q = (sigB <= rem);
112 if ( q ) rem -= sigB;
113 }
114 } else {
115 recip32 = softfloat_approxRecip32_1( sigB<<8 );
116 /*--------------------------------------------------------------------
117 | Changing the shift of `rem' here requires also changing the initial
118 | subtraction from `expDiff'.
119 *--------------------------------------------------------------------*/
120 rem <<= 7;
121 expDiff -= 31;
122 /*--------------------------------------------------------------------
123 | The scale of `sigB' affects how many bits are obtained during each
124 | cycle of the loop. Currently this is 29 bits per loop iteration,
125 | which is believed to be the maximum possible.
126 *--------------------------------------------------------------------*/
127 sigB <<= 6;
128 for (;;) {
129 q = (rem * (uint_fast64_t) recip32)>>32;
130 if ( expDiff < 0 ) break;
131 rem = -(q * (uint32_t) sigB);
132 expDiff -= 29;
133 }
134 /*--------------------------------------------------------------------
135 | (`expDiff' cannot be less than -30 here.)
136 *--------------------------------------------------------------------*/
137 q >>= ~expDiff & 31;
138 rem = (rem<<(expDiff + 30)) - q * (uint32_t) sigB;
139 }
140 /*------------------------------------------------------------------------
141 *------------------------------------------------------------------------*/
142 do {
143 altRem = rem;
144 ++q;
145 rem -= sigB;
146 } while ( ! (rem & 0x80000000) );
147 meanRem = rem + altRem;
148 if ( (meanRem & 0x80000000) || (! meanRem && (q & 1)) ) rem = altRem;
149 signRem = signA;
150 if ( 0x80000000 <= rem ) {
151 signRem = ! signRem;
152 rem = -rem;
153 }
155 /*------------------------------------------------------------------------
156 *------------------------------------------------------------------------*/
157 propagateNaN:
158 uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
159 goto uiZ;
160 invalid:
162 uiZ = defaultNaNF32UI;
163 uiZ:
164 uZ.ui = uiZ;
165 return uZ.f;
166
167}
float32_t softfloat_normRoundPackToF32(bool, int_fast16_t, uint_fast32_t)
Definition s_normRoundPackToF32.c:43
◆ f32_roundToInt()
| float32_t f32_roundToInt | ( | float32_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f32_roundToInt.c.
45{
47 uint_fast32_t uiA;
48 int_fast16_t exp;
49 uint_fast32_t uiZ, lastBitMask, roundBitsMask;
51
52 /*------------------------------------------------------------------------
53 *------------------------------------------------------------------------*/
55 uiA = uA.ui;
56 exp = expF32UI( uiA );
57 /*------------------------------------------------------------------------
58 *------------------------------------------------------------------------*/
59 if ( exp <= 0x7E ) {
62 uiZ = uiA & packToF32UI( 1, 0, 0 );
63 switch ( roundingMode ) {
68 break;
71 break;
74 break;
75#ifdef SOFTFLOAT_ROUND_ODD
77 uiZ |= packToF32UI( 0, 0x7F, 0 );
78 break;
79#endif
80 }
81 goto uiZ;
82 }
83 /*------------------------------------------------------------------------
84 *------------------------------------------------------------------------*/
85 if ( 0x96 <= exp ) {
87 uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
88 goto uiZ;
89 }
91 }
92 /*------------------------------------------------------------------------
93 *------------------------------------------------------------------------*/
94 uiZ = uiA;
95 lastBitMask = (uint_fast32_t) 1<<(0x96 - exp);
96 roundBitsMask = lastBitMask - 1;
98 uiZ += lastBitMask>>1;
100 uiZ += lastBitMask>>1;
101 if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
102 } else if (
103 roundingMode
105 ) {
106 uiZ += roundBitsMask;
107 }
108 uiZ &= ~roundBitsMask;
109 if ( uiZ != uiA ) {
110#ifdef SOFTFLOAT_ROUND_ODD
112#endif
114 }
115 uiZ:
116 uZ.ui = uiZ;
117 return uZ.f;
118
119}
◆ f32_sqrt()
Definition at line 44 of file f32_sqrt.c.
45{
47 uint_fast32_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast32_t sigA, uiZ;
52 int_fast16_t expZ;
53 uint_fast32_t sigZ, shiftedSigZ;
54 uint32_t negRem;
56
57 /*------------------------------------------------------------------------
58 *------------------------------------------------------------------------*/
60 uiA = uA.ui;
61 signA = signF32UI( uiA );
62 expA = expF32UI( uiA );
63 sigA = fracF32UI( uiA );
64 /*------------------------------------------------------------------------
65 *------------------------------------------------------------------------*/
66 if ( expA == 0xFF ) {
67 if ( sigA ) {
68 uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
69 goto uiZ;
70 }
72 goto invalid;
73 }
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( signA ) {
78 goto invalid;
79 }
80 /*------------------------------------------------------------------------
81 *------------------------------------------------------------------------*/
82 if ( ! expA ) {
84 normExpSig = softfloat_normSubnormalF32Sig( sigA );
85 expA = normExpSig.exp;
86 sigA = normExpSig.sig;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 expZ = ((expA - 0x7F)>>1) + 0x7E;
91 expA &= 1;
92 sigA = (sigA | 0x00800000)<<8;
93 sigZ =
95 >>32;
96 if ( expA ) sigZ >>= 1;
97 /*------------------------------------------------------------------------
98 *------------------------------------------------------------------------*/
99 sigZ += 2;
100 if ( (sigZ & 0x3F) < 2 ) {
101 shiftedSigZ = sigZ>>2;
102 negRem = shiftedSigZ * shiftedSigZ;
103 sigZ &= ~3;
104 if ( negRem & 0x80000000 ) {
105 sigZ |= 1;
106 } else {
107 if ( negRem ) --sigZ;
108 }
109 }
111 /*------------------------------------------------------------------------
112 *------------------------------------------------------------------------*/
113 invalid:
115 uiZ = defaultNaNF32UI;
116 uiZ:
117 uZ.ui = uiZ;
118 return uZ.f;
119
120}
◆ f32_sub()
Definition at line 43 of file f32_sub.c.
44{
46 uint_fast32_t uiA;
48 uint_fast32_t uiB;
49#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
51#endif
52
53 uA.f = a;
54 uiA = uA.ui;
55 uB.f = b;
56 uiB = uB.ui;
57#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
60 } else {
62 }
63#else
64 magsFuncPtr =
66 return (*magsFuncPtr)( uiA, uiB );
67#endif
68
69}
◆ f32_to_extF80M()
| void f32_to_extF80M | ( | float32_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 55 of file f32_to_extF80M.c.
56{
59 uint32_t uiA;
60 bool sign;
61 int_fast16_t exp;
62 uint32_t frac;
64 uint_fast16_t uiZ64;
65 uint32_t uiZ32;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uA.f = a;
72 uiA = uA.ui;
73 sign = signF32UI( uiA );
74 exp = expF32UI( uiA );
75 frac = fracF32UI( uiA );
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( exp == 0xFF ) {
79 if ( frac ) {
82 return;
83 }
84 uiZ64 = packToExtF80UI64( sign, 0x7FFF );
85 uiZ32 = 0x80000000;
86 goto uiZ;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( ! exp ) {
91 if ( ! frac ) {
92 uiZ64 = packToExtF80UI64( sign, 0 );
93 uiZ32 = 0;
94 goto uiZ;
95 }
96 normExpSig = softfloat_normSubnormalF32Sig( frac );
97 exp = normExpSig.exp;
98 frac = normExpSig.sig;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 );
103 uiZ32 = 0x80000000 | (uint32_t) frac<<8;
104 uiZ:
105 zSPtr->signExp = uiZ64;
107
108}
◆ f32_to_f128M()
| void f32_to_f128M | ( | float32_t | a, |
| float128_t * | zPtr ) |
Definition at line 55 of file f32_to_f128M.c.
56{
57 uint32_t *zWPtr;
59 uint32_t uiA;
60 bool sign;
61 int_fast16_t exp;
62 uint32_t frac, uiZ64;
64 uint32_t uiZ96;
66 uint64_t frac64;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
70 zWPtr = (uint32_t *) zPtr;
71 /*------------------------------------------------------------------------
72 *------------------------------------------------------------------------*/
73 uA.f = a;
74 uiA = uA.ui;
75 sign = signF32UI( uiA );
77 frac = fracF32UI( uiA );
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 uiZ64 = 0;
82 if ( frac ) {
85 return;
86 }
87 uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
88 goto uiZ;
89 }
90 /*------------------------------------------------------------------------
91 *------------------------------------------------------------------------*/
93 if ( ! frac ) {
94 uiZ96 = packToF128UI96( sign, 0, 0 );
95 goto uiZ;
96 }
97 normExpSig = softfloat_normSubnormalF32Sig( frac );
98 exp = normExpSig.exp - 1;
99 frac = normExpSig.sig;
100 }
101 /*------------------------------------------------------------------------
102 *------------------------------------------------------------------------*/
103 frac64 = (uint64_t) frac<<25;
105 uiZ64 = frac64;
106 uiZ:
107 zWPtr[indexWord( 4, 3 )] = uiZ96;
108 zWPtr[indexWord( 4, 2 )] = uiZ64;
109 zWPtr[indexWord( 4, 1 )] = 0;
110 zWPtr[indexWord( 4, 0 )] = 0;
111
112}
◆ f32_to_f16()
Definition at line 44 of file f32_to_f16.c.
45{
47 uint_fast32_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast32_t frac;
52 uint_fast16_t uiZ, frac16;
54
55 /*------------------------------------------------------------------------
56 *------------------------------------------------------------------------*/
58 uiA = uA.ui;
59 sign = signF32UI( uiA );
60 exp = expF32UI( uiA );
61 frac = fracF32UI( uiA );
62 /*------------------------------------------------------------------------
63 *------------------------------------------------------------------------*/
64 if ( exp == 0xFF ) {
65 if ( frac ) {
68 } else {
69 uiZ = packToF16UI( sign, 0x1F, 0 );
70 }
71 goto uiZ;
72 }
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
75 frac16 = frac>>9 | ((frac & 0x1FF) != 0);
76 if ( ! (exp | frac16) ) {
77 uiZ = packToF16UI( sign, 0, 0 );
78 goto uiZ;
79 }
80 /*------------------------------------------------------------------------
81 *------------------------------------------------------------------------*/
83 uiZ:
84 uZ.ui = uiZ;
85 return uZ.f;
86
87}
◆ f32_to_f64()
Definition at line 44 of file f32_to_f64.c.
45{
47 uint_fast32_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast32_t frac;
52 uint_fast64_t uiZ;
55
56 /*------------------------------------------------------------------------
57 *------------------------------------------------------------------------*/
59 uiA = uA.ui;
60 sign = signF32UI( uiA );
61 exp = expF32UI( uiA );
62 frac = fracF32UI( uiA );
63 /*------------------------------------------------------------------------
64 *------------------------------------------------------------------------*/
65 if ( exp == 0xFF ) {
66 if ( frac ) {
69 } else {
70 uiZ = packToF64UI( sign, 0x7FF, 0 );
71 }
72 goto uiZ;
73 }
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
76 if ( ! exp ) {
77 if ( ! frac ) {
78 uiZ = packToF64UI( sign, 0, 0 );
79 goto uiZ;
80 }
81 normExpSig = softfloat_normSubnormalF32Sig( frac );
82 exp = normExpSig.exp - 1;
83 frac = normExpSig.sig;
84 }
85 /*------------------------------------------------------------------------
86 *------------------------------------------------------------------------*/
88 uiZ:
89 uZ.ui = uiZ;
90 return uZ.f;
91
92}
◆ f32_to_i32()
| int_fast32_t f32_to_i32 | ( | float32_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f32_to_i32.c.
45{
47 uint_fast32_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast32_t sig;
51 uint_fast64_t sig64;
52 int_fast16_t shiftDist;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 sign = signF32UI( uiA );
59 exp = expF32UI( uiA );
60 sig = fracF32UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
64 if ( (exp == 0xFF) && sig ) {
65#if (i32_fromNaN == i32_fromPosOverflow)
66 sign = 0;
67#elif (i32_fromNaN == i32_fromNegOverflow)
68 sign = 1;
69#else
72#endif
73 }
74#endif
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp ) sig |= 0x00800000;
78 sig64 = (uint_fast64_t) sig<<32;
79 shiftDist = 0xAA - exp;
82
83}
◆ f32_to_i32_r_minMag()
| int_fast32_t f32_to_i32_r_minMag | ( | float32_t | a, |
| bool | exact ) |
Definition at line 44 of file f32_to_i32_r_minMag.c.
45{
47 uint_fast32_t uiA;
48 int_fast16_t exp;
49 uint_fast32_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 int_fast32_t absZ;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF32UI( uiA );
59 sig = fracF32UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = 0x9E - exp;
63 if ( 32 <= shiftDist ) {
64 if ( exact && (exp | sig) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF32UI( uiA );
72 if ( shiftDist <= 0 ) {
75 return
76 (exp == 0xFF) && sig ? i32_fromNaN
78 }
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 sig = (sig | 0x00800000)<<8;
82 absZ = sig>>shiftDist;
85 }
86 return sign ? -absZ : absZ;
87
88}
◆ f32_to_i64()
| int_fast64_t f32_to_i64 | ( | float32_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f32_to_i64.c.
45{
47 uint_fast32_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast32_t sig;
51 int_fast16_t shiftDist;
52#ifdef SOFTFLOAT_FAST_INT64
53 uint_fast64_t sig64, extra;
54 struct uint64_extra sig64Extra;
55#else
56 uint32_t extSig[3];
57#endif
58
59 /*------------------------------------------------------------------------
60 *------------------------------------------------------------------------*/
62 uiA = uA.ui;
63 sign = signF32UI( uiA );
64 exp = expF32UI( uiA );
65 sig = fracF32UI( uiA );
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
68 shiftDist = 0xBE - exp;
69 if ( shiftDist < 0 ) {
71 return
72 (exp == 0xFF) && sig ? i64_fromNaN
74 }
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp ) sig |= 0x00800000;
78#ifdef SOFTFLOAT_FAST_INT64
79 sig64 = (uint_fast64_t) sig<<40;
80 extra = 0;
81 if ( shiftDist ) {
82 sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
83 sig64 = sig64Extra.v;
84 extra = sig64Extra.extra;
85 }
87#else
88 extSig[indexWord( 3, 2 )] = sig<<8;
89 extSig[indexWord( 3, 1 )] = 0;
90 extSig[indexWord( 3, 0 )] = 0;
93#endif
94
95}
int_fast64_t softfloat_roundToI64(bool sign, uint_fast64_t sig, uint_fast64_t sigExtra, uint_fast8_t roundingMode, bool exact)
Definition s_roundToI64.c:45
struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist)
Definition s_shiftRightJam64Extra.c:44
◆ f32_to_i64_r_minMag()
| int_fast64_t f32_to_i64_r_minMag | ( | float32_t | a, |
| bool | exact ) |
Definition at line 44 of file f32_to_i64_r_minMag.c.
45{
47 uint_fast32_t uiA;
48 int_fast16_t exp;
49 uint_fast32_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 uint_fast64_t sig64;
53 int_fast64_t absZ;
54
55 /*------------------------------------------------------------------------
56 *------------------------------------------------------------------------*/
58 uiA = uA.ui;
59 exp = expF32UI( uiA );
60 sig = fracF32UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63 shiftDist = 0xBE - exp;
64 if ( 64 <= shiftDist ) {
65 if ( exact && (exp | sig) ) {
67 }
68 return 0;
69 }
70 /*------------------------------------------------------------------------
71 *------------------------------------------------------------------------*/
72 sign = signF32UI( uiA );
73 if ( shiftDist <= 0 ) {
76 }
78 return
79 (exp == 0xFF) && sig ? i64_fromNaN
81 }
82 /*------------------------------------------------------------------------
83 *------------------------------------------------------------------------*/
84 sig |= 0x00800000;
85 sig64 = (uint_fast64_t) sig<<40;
86 absZ = sig64>>shiftDist;
87 shiftDist = 40 - shiftDist;
90 }
91 return sign ? -absZ : absZ;
92
93}
◆ f32_to_ui32()
| uint_fast32_t f32_to_ui32 | ( | float32_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f32_to_ui32.c.
45{
47 uint_fast32_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast32_t sig;
51 uint_fast64_t sig64;
52 int_fast16_t shiftDist;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 sign = signF32UI( uiA );
59 exp = expF32UI( uiA );
60 sig = fracF32UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
64 if ( (exp == 0xFF) && sig ) {
65#if (ui32_fromNaN == ui32_fromPosOverflow)
66 sign = 0;
67#elif (ui32_fromNaN == ui32_fromNegOverflow)
68 sign = 1;
69#else
72#endif
73 }
74#endif
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp ) sig |= 0x00800000;
78 sig64 = (uint_fast64_t) sig<<32;
79 shiftDist = 0xAA - exp;
82
83}
◆ f32_to_ui32_r_minMag()
| uint_fast32_t f32_to_ui32_r_minMag | ( | float32_t | a, |
| bool | exact ) |
Definition at line 44 of file f32_to_ui32_r_minMag.c.
45{
47 uint_fast32_t uiA;
48 int_fast16_t exp;
49 uint_fast32_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 uint_fast32_t z;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF32UI( uiA );
59 sig = fracF32UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = 0x9E - exp;
63 if ( 32 <= shiftDist ) {
64 if ( exact && (exp | sig) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF32UI( uiA );
72 if ( sign || (shiftDist < 0) ) {
74 return
75 (exp == 0xFF) && sig ? ui32_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 sig = (sig | 0x00800000)<<8;
81 z = sig>>shiftDist;
82 if ( exact && (z<<shiftDist != sig) ) {
84 }
85 return z;
86
87}
◆ f32_to_ui64()
| uint_fast64_t f32_to_ui64 | ( | float32_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f32_to_ui64.c.
45{
47 uint_fast32_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast32_t sig;
51 int_fast16_t shiftDist;
52#ifdef SOFTFLOAT_FAST_INT64
53 uint_fast64_t sig64, extra;
54 struct uint64_extra sig64Extra;
55#else
56 uint32_t extSig[3];
57#endif
58
59 /*------------------------------------------------------------------------
60 *------------------------------------------------------------------------*/
62 uiA = uA.ui;
63 sign = signF32UI( uiA );
64 exp = expF32UI( uiA );
65 sig = fracF32UI( uiA );
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
68 shiftDist = 0xBE - exp;
69 if ( shiftDist < 0 ) {
71 return
72 (exp == 0xFF) && sig ? ui64_fromNaN
74 }
75 /*------------------------------------------------------------------------
76 *------------------------------------------------------------------------*/
77 if ( exp ) sig |= 0x00800000;
78#ifdef SOFTFLOAT_FAST_INT64
79 sig64 = (uint_fast64_t) sig<<40;
80 extra = 0;
81 if ( shiftDist ) {
82 sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
83 sig64 = sig64Extra.v;
84 extra = sig64Extra.extra;
85 }
87#else
88 extSig[indexWord( 3, 2 )] = sig<<8;
89 extSig[indexWord( 3, 1 )] = 0;
90 extSig[indexWord( 3, 0 )] = 0;
93#endif
94
95}
◆ f32_to_ui64_r_minMag()
| uint_fast64_t f32_to_ui64_r_minMag | ( | float32_t | a, |
| bool | exact ) |
Definition at line 44 of file f32_to_ui64_r_minMag.c.
45{
47 uint_fast32_t uiA;
48 int_fast16_t exp;
49 uint_fast32_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 uint_fast64_t sig64, z;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF32UI( uiA );
59 sig = fracF32UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = 0xBE - exp;
63 if ( 64 <= shiftDist ) {
64 if ( exact && (exp | sig) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF32UI( uiA );
72 if ( sign || (shiftDist < 0) ) {
74 return
75 (exp == 0xFF) && sig ? ui64_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 sig |= 0x00800000;
81 sig64 = (uint_fast64_t) sig<<40;
82 z = sig64>>shiftDist;
83 shiftDist = 40 - shiftDist;
86 }
87 return z;
88
89}
◆ f64_add()
Definition at line 43 of file f64_add.c.
44{
46 uint_fast64_t uiA;
47 bool signA;
49 uint_fast64_t uiB;
50 bool signB;
51#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
53#endif
54
55 uA.f = a;
56 uiA = uA.ui;
57 signA = signF64UI( uiA );
58 uB.f = b;
59 uiB = uB.ui;
60 signB = signF64UI( uiB );
61#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
62 if ( signA == signB ) {
64 } else {
66 }
67#else
68 magsFuncPtr =
70 return (*magsFuncPtr)( uiA, uiB, signA );
71#endif
72
73}
float64_t softfloat_subMagsF64(uint_fast64_t, uint_fast64_t, bool)
Definition s_subMagsF64.c:45
float64_t softfloat_addMagsF64(uint_fast64_t, uint_fast64_t, bool)
Definition s_addMagsF64.c:44
Definition softfloat_types.h:52
◆ f64_div()
Definition at line 44 of file f64_div.c.
45{
47 uint_fast64_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast64_t sigA;
52 uint_fast64_t uiB;
53 bool signB;
54 int_fast16_t expB;
55 uint_fast64_t sigB;
56 bool signZ;
58 int_fast16_t expZ;
59 uint32_t recip32, sig32Z, doubleTerm;
60 uint_fast64_t rem;
61 uint32_t q;
62 uint_fast64_t sigZ;
63 uint_fast64_t uiZ;
65
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
69 uiA = uA.ui;
70 signA = signF64UI( uiA );
71 expA = expF64UI( uiA );
72 sigA = fracF64UI( uiA );
73 uB.f = b;
74 uiB = uB.ui;
75 signB = signF64UI( uiB );
76 expB = expF64UI( uiB );
77 sigB = fracF64UI( uiB );
78 signZ = signA ^ signB;
79 /*------------------------------------------------------------------------
80 *------------------------------------------------------------------------*/
81 if ( expA == 0x7FF ) {
82 if ( sigA ) goto propagateNaN;
83 if ( expB == 0x7FF ) {
84 if ( sigB ) goto propagateNaN;
85 goto invalid;
86 }
87 goto infinity;
88 }
89 if ( expB == 0x7FF ) {
90 if ( sigB ) goto propagateNaN;
91 goto zero;
92 }
93 /*------------------------------------------------------------------------
94 *------------------------------------------------------------------------*/
95 if ( ! expB ) {
96 if ( ! sigB ) {
97 if ( ! (expA | sigA) ) goto invalid;
99 goto infinity;
100 }
101 normExpSig = softfloat_normSubnormalF64Sig( sigB );
102 expB = normExpSig.exp;
103 sigB = normExpSig.sig;
104 }
105 if ( ! expA ) {
106 if ( ! sigA ) goto zero;
107 normExpSig = softfloat_normSubnormalF64Sig( sigA );
108 expA = normExpSig.exp;
109 sigA = normExpSig.sig;
110 }
111 /*------------------------------------------------------------------------
112 *------------------------------------------------------------------------*/
113 expZ = expA - expB + 0x3FE;
114 sigA |= UINT64_C( 0x0010000000000000 );
115 sigB |= UINT64_C( 0x0010000000000000 );
116 if ( sigA < sigB ) {
117 --expZ;
118 sigA <<= 11;
119 } else {
120 sigA <<= 10;
121 }
122 sigB <<= 11;
123 recip32 = softfloat_approxRecip32_1( sigB>>32 ) - 2;
125 doubleTerm = sig32Z<<1;
126 rem =
131 /*------------------------------------------------------------------------
132 *------------------------------------------------------------------------*/
133 if ( (sigZ & 0x1FF) < 4<<4 ) {
134 q &= ~7;
135 sigZ &= ~(uint_fast64_t) 0x7F;
136 doubleTerm = q<<1;
137 rem =
141 sigZ -= 1<<7;
142 } else {
143 if ( rem ) sigZ |= 1;
144 }
145 }
147 /*------------------------------------------------------------------------
148 *------------------------------------------------------------------------*/
149 propagateNaN:
150 uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
151 goto uiZ;
152 /*------------------------------------------------------------------------
153 *------------------------------------------------------------------------*/
154 invalid:
156 uiZ = defaultNaNF64UI;
157 goto uiZ;
158 /*------------------------------------------------------------------------
159 *------------------------------------------------------------------------*/
160 infinity:
161 uiZ = packToF64UI( signZ, 0x7FF, 0 );
162 goto uiZ;
163 /*------------------------------------------------------------------------
164 *------------------------------------------------------------------------*/
165 zero:
166 uiZ = packToF64UI( signZ, 0, 0 );
167 uiZ:
168 uZ.ui = uiZ;
169 return uZ.f;
170
171}
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB)
Definition s_propagateNaNF64UI.c:51
struct exp16_sig64 softfloat_normSubnormalF64Sig(uint_fast64_t)
Definition s_normSubnormalF64Sig.c:41
Definition internals.h:132
◆ f64_eq()
Definition at line 44 of file f64_eq.c.
45{
47 uint_fast64_t uiA;
49 uint_fast64_t uiB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
56 if (
58 ) {
60 }
61 return false;
62 }
64
65}
◆ f64_eq_signaling()
Definition at line 43 of file f64_eq_signaling.c.
44{
46 uint_fast64_t uiA;
48 uint_fast64_t uiB;
49
51 uiA = uA.ui;
52 uB.f = b;
53 uiB = uB.ui;
56 return false;
57 }
59
60}
◆ f64_isSignalingNaN()
| bool f64_isSignalingNaN | ( | float64_t | a | ) |
Definition at line 43 of file f64_isSignalingNaN.c.
◆ f64_le()
Definition at line 43 of file f64_le.c.
44{
46 uint_fast64_t uiA;
48 uint_fast64_t uiB;
49 bool signA, signB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
57 return false;
58 }
59 signA = signF64UI( uiA );
60 signB = signF64UI( uiB );
61 return
62 (signA != signB)
63 ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
64 : (uiA == uiB) || (signA ^ (uiA < uiB));
65
66}
◆ f64_le_quiet()
Definition at line 44 of file f64_le_quiet.c.
45{
47 uint_fast64_t uiA;
49 uint_fast64_t uiB;
50 bool signA, signB;
51
53 uiA = uA.ui;
54 uB.f = b;
55 uiB = uB.ui;
57 if (
59 ) {
61 }
62 return false;
63 }
64 signA = signF64UI( uiA );
65 signB = signF64UI( uiB );
66 return
67 (signA != signB)
68 ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
69 : (uiA == uiB) || (signA ^ (uiA < uiB));
70
71}
◆ f64_lt()
Definition at line 43 of file f64_lt.c.
44{
46 uint_fast64_t uiA;
48 uint_fast64_t uiB;
49 bool signA, signB;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
57 return false;
58 }
59 signA = signF64UI( uiA );
60 signB = signF64UI( uiB );
61 return
62 (signA != signB)
63 ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
64 : (uiA != uiB) && (signA ^ (uiA < uiB));
65
66}
◆ f64_lt_quiet()
Definition at line 44 of file f64_lt_quiet.c.
45{
47 uint_fast64_t uiA;
49 uint_fast64_t uiB;
50 bool signA, signB;
51
53 uiA = uA.ui;
54 uB.f = b;
55 uiB = uB.ui;
57 if (
59 ) {
61 }
62 return false;
63 }
64 signA = signF64UI( uiA );
65 signB = signF64UI( uiB );
66 return
67 (signA != signB)
68 ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
69 : (uiA != uiB) && (signA ^ (uiA < uiB));
70
71}
◆ f64_mul()
Definition at line 44 of file f64_mul.c.
45{
47 uint_fast64_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast64_t sigA;
52 uint_fast64_t uiB;
53 bool signB;
54 int_fast16_t expB;
55 uint_fast64_t sigB;
56 bool signZ;
57 uint_fast64_t magBits;
59 int_fast16_t expZ;
60#ifdef SOFTFLOAT_FAST_INT64
61 struct uint128 sig128Z;
62#else
63 uint32_t sig128Z[4];
64#endif
65 uint_fast64_t sigZ, uiZ;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uiA = uA.ui;
72 signA = signF64UI( uiA );
73 expA = expF64UI( uiA );
74 sigA = fracF64UI( uiA );
75 uB.f = b;
76 uiB = uB.ui;
77 signB = signF64UI( uiB );
78 expB = expF64UI( uiB );
79 sigB = fracF64UI( uiB );
80 signZ = signA ^ signB;
81 /*------------------------------------------------------------------------
82 *------------------------------------------------------------------------*/
83 if ( expA == 0x7FF ) {
84 if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN;
85 magBits = expB | sigB;
86 goto infArg;
87 }
88 if ( expB == 0x7FF ) {
89 if ( sigB ) goto propagateNaN;
90 magBits = expA | sigA;
91 goto infArg;
92 }
93 /*------------------------------------------------------------------------
94 *------------------------------------------------------------------------*/
95 if ( ! expA ) {
96 if ( ! sigA ) goto zero;
97 normExpSig = softfloat_normSubnormalF64Sig( sigA );
98 expA = normExpSig.exp;
99 sigA = normExpSig.sig;
100 }
101 if ( ! expB ) {
102 if ( ! sigB ) goto zero;
103 normExpSig = softfloat_normSubnormalF64Sig( sigB );
104 expB = normExpSig.exp;
105 sigB = normExpSig.sig;
106 }
107 /*------------------------------------------------------------------------
108 *------------------------------------------------------------------------*/
109 expZ = expA + expB - 0x3FF;
110 sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
111 sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11;
112#ifdef SOFTFLOAT_FAST_INT64
113 sig128Z = softfloat_mul64To128( sigA, sigB );
114 sigZ = sig128Z.v64 | (sig128Z.v0 != 0);
115#else
116 softfloat_mul64To128M( sigA, sigB, sig128Z );
117 sigZ =
120#endif
122 --expZ;
123 sigZ <<= 1;
124 }
126 /*------------------------------------------------------------------------
127 *------------------------------------------------------------------------*/
128 propagateNaN:
129 uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
130 goto uiZ;
131 /*------------------------------------------------------------------------
132 *------------------------------------------------------------------------*/
133 infArg:
134 if ( ! magBits ) {
136 uiZ = defaultNaNF64UI;
137 } else {
138 uiZ = packToF64UI( signZ, 0x7FF, 0 );
139 }
140 goto uiZ;
141 /*------------------------------------------------------------------------
142 *------------------------------------------------------------------------*/
143 zero:
144 uiZ = packToF64UI( signZ, 0, 0 );
145 uiZ:
146 uZ.ui = uiZ;
147 return uZ.f;
148
149}
struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b)
Definition s_mul64To128.c:43
◆ f64_mulAdd()
Definition at line 42 of file f64_mulAdd.c.
43{
45 uint_fast64_t uiA;
47 uint_fast64_t uiB;
49 uint_fast64_t uiC;
50
52 uiA = uA.ui;
53 uB.f = b;
54 uiB = uB.ui;
55 uC.f = c;
56 uiC = uC.ui;
58
59}
float64_t softfloat_mulAddF64(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t)
Definition s_mulAddF64.c:247
◆ f64_rem()
Definition at line 44 of file f64_rem.c.
45{
47 uint_fast64_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast64_t sigA;
52 uint_fast64_t uiB;
53 int_fast16_t expB;
54 uint_fast64_t sigB;
56 uint64_t rem;
57 int_fast16_t expDiff;
58 uint32_t q, recip32;
59 uint_fast64_t q64;
60 uint64_t altRem, meanRem;
61 bool signRem;
62 uint_fast64_t uiZ;
64
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
68 uiA = uA.ui;
69 signA = signF64UI( uiA );
70 expA = expF64UI( uiA );
71 sigA = fracF64UI( uiA );
72 uB.f = b;
73 uiB = uB.ui;
74 expB = expF64UI( uiB );
75 sigB = fracF64UI( uiB );
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( expA == 0x7FF ) {
79 if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN;
80 goto invalid;
81 }
82 if ( expB == 0x7FF ) {
83 if ( sigB ) goto propagateNaN;
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
91 if ( ! expB ) {
92 if ( ! sigB ) goto invalid;
93 normExpSig = softfloat_normSubnormalF64Sig( sigB );
94 expB = normExpSig.exp;
95 sigB = normExpSig.sig;
96 }
97 if ( ! expA ) {
99 normExpSig = softfloat_normSubnormalF64Sig( sigA );
100 expA = normExpSig.exp;
101 sigA = normExpSig.sig;
102 }
103 /*------------------------------------------------------------------------
104 *------------------------------------------------------------------------*/
105 rem = sigA | UINT64_C( 0x0010000000000000 );
106 sigB |= UINT64_C( 0x0010000000000000 );
107 expDiff = expA - expB;
108 if ( expDiff < 1 ) {
110 sigB <<= 9;
111 if ( expDiff ) {
112 rem <<= 8;
113 q = 0;
114 } else {
115 rem <<= 9;
116 q = (sigB <= rem);
117 if ( q ) rem -= sigB;
118 }
119 } else {
120 recip32 = softfloat_approxRecip32_1( sigB>>21 );
121 /*--------------------------------------------------------------------
122 | Changing the shift of `rem' here requires also changing the initial
123 | subtraction from `expDiff'.
124 *--------------------------------------------------------------------*/
125 rem <<= 9;
126 expDiff -= 30;
127 /*--------------------------------------------------------------------
128 | The scale of `sigB' affects how many bits are obtained during each
129 | cycle of the loop. Currently this is 29 bits per loop iteration,
130 | the maximum possible.
131 *--------------------------------------------------------------------*/
132 sigB <<= 9;
133 for (;;) {
135 if ( expDiff < 0 ) break;
136 q = (q64 + 0x80000000)>>32;
137#ifdef SOFTFLOAT_FAST_INT64
138 rem <<= 29;
139#else
141#endif
142 rem -= q * (uint64_t) sigB;
144 expDiff -= 29;
145 }
146 /*--------------------------------------------------------------------
147 | (`expDiff' cannot be less than -29 here.)
148 *--------------------------------------------------------------------*/
149 q = (uint32_t) (q64>>32)>>(~expDiff & 31);
150 rem = (rem<<(expDiff + 30)) - q * (uint64_t) sigB;
152 altRem = rem + sigB;
153 goto selectRem;
154 }
155 }
156 /*------------------------------------------------------------------------
157 *------------------------------------------------------------------------*/
158 do {
159 altRem = rem;
160 ++q;
161 rem -= sigB;
163 selectRem:
164 meanRem = rem + altRem;
165 if (
166 (meanRem & UINT64_C( 0x8000000000000000 )) || (! meanRem && (q & 1))
167 ) {
168 rem = altRem;
169 }
170 signRem = signA;
172 signRem = ! signRem;
173 rem = -rem;
174 }
176 /*------------------------------------------------------------------------
177 *------------------------------------------------------------------------*/
178 propagateNaN:
179 uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
180 goto uiZ;
181 invalid:
183 uiZ = defaultNaNF64UI;
184 uiZ:
185 uZ.ui = uiZ;
186 return uZ.f;
187
188}
float64_t softfloat_normRoundPackToF64(bool, int_fast16_t, uint_fast64_t)
Definition s_normRoundPackToF64.c:43
◆ f64_roundToInt()
| float64_t f64_roundToInt | ( | float64_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f64_roundToInt.c.
45{
47 uint_fast64_t uiA;
48 int_fast16_t exp;
49 uint_fast64_t uiZ, lastBitMask, roundBitsMask;
51
52 /*------------------------------------------------------------------------
53 *------------------------------------------------------------------------*/
55 uiA = uA.ui;
56 exp = expF64UI( uiA );
57 /*------------------------------------------------------------------------
58 *------------------------------------------------------------------------*/
59 if ( exp <= 0x3FE ) {
62 uiZ = uiA & packToF64UI( 1, 0, 0 );
63 switch ( roundingMode ) {
68 break;
71 break;
74 break;
75#ifdef SOFTFLOAT_ROUND_ODD
77 uiZ |= packToF64UI( 0, 0x3FF, 0 );
78 break;
79#endif
80 }
81 goto uiZ;
82 }
83 /*------------------------------------------------------------------------
84 *------------------------------------------------------------------------*/
85 if ( 0x433 <= exp ) {
87 uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
88 goto uiZ;
89 }
91 }
92 /*------------------------------------------------------------------------
93 *------------------------------------------------------------------------*/
94 uiZ = uiA;
95 lastBitMask = (uint_fast64_t) 1<<(0x433 - exp);
96 roundBitsMask = lastBitMask - 1;
98 uiZ += lastBitMask>>1;
100 uiZ += lastBitMask>>1;
101 if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
102 } else if (
103 roundingMode
105 ) {
106 uiZ += roundBitsMask;
107 }
108 uiZ &= ~roundBitsMask;
109 if ( uiZ != uiA ) {
110#ifdef SOFTFLOAT_ROUND_ODD
112#endif
114 }
115 uiZ:
116 uZ.ui = uiZ;
117 return uZ.f;
118
119}
◆ f64_sqrt()
Definition at line 44 of file f64_sqrt.c.
45{
47 uint_fast64_t uiA;
48 bool signA;
49 int_fast16_t expA;
50 uint_fast64_t sigA, uiZ;
52 int_fast16_t expZ;
53 uint32_t sig32A, recipSqrt32, sig32Z;
54 uint_fast64_t rem;
55 uint32_t q;
56 uint_fast64_t sigZ, shiftedSigZ;
58
59 /*------------------------------------------------------------------------
60 *------------------------------------------------------------------------*/
62 uiA = uA.ui;
63 signA = signF64UI( uiA );
64 expA = expF64UI( uiA );
65 sigA = fracF64UI( uiA );
66 /*------------------------------------------------------------------------
67 *------------------------------------------------------------------------*/
68 if ( expA == 0x7FF ) {
69 if ( sigA ) {
70 uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
71 goto uiZ;
72 }
74 goto invalid;
75 }
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( signA ) {
80 goto invalid;
81 }
82 /*------------------------------------------------------------------------
83 *------------------------------------------------------------------------*/
84 if ( ! expA ) {
86 normExpSig = softfloat_normSubnormalF64Sig( sigA );
87 expA = normExpSig.exp;
88 sigA = normExpSig.sig;
89 }
90 /*------------------------------------------------------------------------
91 | (`sig32Z' is guaranteed to be a lower bound on the square root of
92 | `sig32A', which makes `sig32Z' also a lower bound on the square root of
93 | `sigA'.)
94 *------------------------------------------------------------------------*/
95 expZ = ((expA - 0x3FF)>>1) + 0x3FE;
96 expA &= 1;
97 sigA |= UINT64_C( 0x0010000000000000 );
98 sig32A = sigA>>21;
99 recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
100 sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
101 if ( expA ) {
102 sigA <<= 8;
103 sig32Z >>= 1;
104 } else {
105 sigA <<= 9;
106 }
107 rem = sigA - (uint_fast64_t) sig32Z * sig32Z;
110 /*------------------------------------------------------------------------
111 *------------------------------------------------------------------------*/
112 if ( (sigZ & 0x1FF) < 0x22 ) {
113 sigZ &= ~(uint_fast64_t) 0x3F;
114 shiftedSigZ = sigZ>>6;
115 rem = (sigA<<52) - shiftedSigZ * shiftedSigZ;
117 --sigZ;
118 } else {
119 if ( rem ) sigZ |= 1;
120 }
121 }
123 /*------------------------------------------------------------------------
124 *------------------------------------------------------------------------*/
125 invalid:
127 uiZ = defaultNaNF64UI;
128 uiZ:
129 uZ.ui = uiZ;
130 return uZ.f;
131
132}
◆ f64_sub()
Definition at line 43 of file f64_sub.c.
44{
46 uint_fast64_t uiA;
47 bool signA;
49 uint_fast64_t uiB;
50 bool signB;
51#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
53#endif
54
55 uA.f = a;
56 uiA = uA.ui;
57 signA = signF64UI( uiA );
58 uB.f = b;
59 uiB = uB.ui;
60 signB = signF64UI( uiB );
61#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
62 if ( signA == signB ) {
64 } else {
66 }
67#else
68 magsFuncPtr =
70 return (*magsFuncPtr)( uiA, uiB, signA );
71#endif
72
73}
◆ f64_to_extF80M()
| void f64_to_extF80M | ( | float64_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 55 of file f64_to_extF80M.c.
56{
59 uint64_t uiA;
60 bool sign;
61 int_fast16_t exp;
62 uint64_t frac;
64 uint_fast16_t uiZ64;
65 uint64_t uiZ0;
67
68 /*------------------------------------------------------------------------
69 *------------------------------------------------------------------------*/
71 uA.f = a;
72 uiA = uA.ui;
73 sign = signF64UI( uiA );
74 exp = expF64UI( uiA );
75 frac = fracF64UI( uiA );
76 /*------------------------------------------------------------------------
77 *------------------------------------------------------------------------*/
78 if ( exp == 0x7FF ) {
79 if ( frac ) {
82 return;
83 }
84 uiZ64 = packToExtF80UI64( sign, 0x7FFF );
85 uiZ0 = UINT64_C( 0x8000000000000000 );
86 goto uiZ;
87 }
88 /*------------------------------------------------------------------------
89 *------------------------------------------------------------------------*/
90 if ( ! exp ) {
91 if ( ! frac ) {
92 uiZ64 = packToExtF80UI64( sign, 0 );
93 uiZ0 = 0;
94 goto uiZ;
95 }
96 normExpSig = softfloat_normSubnormalF64Sig( frac );
97 exp = normExpSig.exp;
98 frac = normExpSig.sig;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
102 uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 );
103 uiZ0 = UINT64_C( 0x8000000000000000 ) | frac<<11;
104 uiZ:
105 zSPtr->signExp = uiZ64;
106 zSPtr->signif = uiZ0;
107
108}
◆ f64_to_f128M()
| void f64_to_f128M | ( | float64_t | a, |
| float128_t * | zPtr ) |
Definition at line 55 of file f64_to_f128M.c.
56{
57 uint32_t *zWPtr;
59 uint64_t uiA;
60 bool sign;
61 int_fast16_t exp;
62 uint64_t frac;
64 uint32_t uiZ96;
66
67 /*------------------------------------------------------------------------
68 *------------------------------------------------------------------------*/
69 zWPtr = (uint32_t *) zPtr;
70 /*------------------------------------------------------------------------
71 *------------------------------------------------------------------------*/
72 uA.f = a;
73 uiA = uA.ui;
74 sign = signF64UI( uiA );
76 frac = fracF64UI( uiA );
77 /*------------------------------------------------------------------------
78 *------------------------------------------------------------------------*/
79 zWPtr[indexWord( 4, 0 )] = 0;
81 if ( frac ) {
84 return;
85 }
86 uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
87 goto uiZ;
88 }
89 /*------------------------------------------------------------------------
90 *------------------------------------------------------------------------*/
92 if ( ! frac ) {
93 uiZ96 = packToF128UI96( sign, 0, 0 );
94 goto uiZ;
95 }
96 normExpSig = softfloat_normSubnormalF64Sig( frac );
97 exp = normExpSig.exp - 1;
98 frac = normExpSig.sig;
99 }
100 /*------------------------------------------------------------------------
101 *------------------------------------------------------------------------*/
103 frac >>= 4;
105 zWPtr[indexWord( 4, 2 )] = frac;
106 return;
107 /*------------------------------------------------------------------------
108 *------------------------------------------------------------------------*/
109 uiZ:
110 zWPtr[indexWord( 4, 3 )] = uiZ96;
111 zWPtr[indexWord( 4, 2 )] = 0;
112 zWPtr[indexWord( 4, 1 )] = 0;
113
114}
◆ f64_to_f16()
Definition at line 44 of file f64_to_f16.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t frac;
52 uint_fast16_t uiZ, frac16;
54
55 /*------------------------------------------------------------------------
56 *------------------------------------------------------------------------*/
58 uiA = uA.ui;
59 sign = signF64UI( uiA );
60 exp = expF64UI( uiA );
61 frac = fracF64UI( uiA );
62 /*------------------------------------------------------------------------
63 *------------------------------------------------------------------------*/
64 if ( exp == 0x7FF ) {
65 if ( frac ) {
68 } else {
69 uiZ = packToF16UI( sign, 0x1F, 0 );
70 }
71 goto uiZ;
72 }
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
75 frac16 = softfloat_shortShiftRightJam64( frac, 38 );
76 if ( ! (exp | frac16) ) {
77 uiZ = packToF16UI( sign, 0, 0 );
78 goto uiZ;
79 }
80 /*------------------------------------------------------------------------
81 *------------------------------------------------------------------------*/
83 uiZ:
84 uZ.ui = uiZ;
85 return uZ.f;
86
87}
◆ f64_to_f32()
Definition at line 44 of file f64_to_f32.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t frac;
52 uint_fast32_t uiZ, frac32;
54
55 /*------------------------------------------------------------------------
56 *------------------------------------------------------------------------*/
58 uiA = uA.ui;
59 sign = signF64UI( uiA );
60 exp = expF64UI( uiA );
61 frac = fracF64UI( uiA );
62 /*------------------------------------------------------------------------
63 *------------------------------------------------------------------------*/
64 if ( exp == 0x7FF ) {
65 if ( frac ) {
68 } else {
69 uiZ = packToF32UI( sign, 0xFF, 0 );
70 }
71 goto uiZ;
72 }
73 /*------------------------------------------------------------------------
74 *------------------------------------------------------------------------*/
75 frac32 = softfloat_shortShiftRightJam64( frac, 22 );
76 if ( ! (exp | frac32) ) {
77 uiZ = packToF32UI( sign, 0, 0 );
78 goto uiZ;
79 }
80 /*------------------------------------------------------------------------
81 *------------------------------------------------------------------------*/
83 uiZ:
84 uZ.ui = uiZ;
85 return uZ.f;
86
87}
◆ f64_to_i32()
| int_fast32_t f64_to_i32 | ( | float64_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f64_to_i32.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t sig;
51 int_fast16_t shiftDist;
52
53 /*------------------------------------------------------------------------
54 *------------------------------------------------------------------------*/
56 uiA = uA.ui;
57 sign = signF64UI( uiA );
58 exp = expF64UI( uiA );
59 sig = fracF64UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
63 if ( (exp == 0x7FF) && sig ) {
64#if (i32_fromNaN == i32_fromPosOverflow)
65 sign = 0;
66#elif (i32_fromNaN == i32_fromNegOverflow)
67 sign = 1;
68#else
71#endif
72 }
73#endif
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
77 shiftDist = 0x427 - exp;
80
81}
◆ f64_to_i32_r_minMag()
| int_fast32_t f64_to_i32_r_minMag | ( | float64_t | a, |
| bool | exact ) |
Definition at line 44 of file f64_to_i32_r_minMag.c.
45{
47 uint_fast64_t uiA;
48 int_fast16_t exp;
49 uint_fast64_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 int_fast32_t absZ;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF64UI( uiA );
59 sig = fracF64UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = 0x433 - exp;
63 if ( 53 <= shiftDist ) {
64 if ( exact && (exp | sig) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF64UI( uiA );
72 if ( shiftDist < 22 ) {
73 if (
74 sign && (exp == 0x41E) && (sig < UINT64_C( 0x0000000000200000 ))
75 ) {
76 if ( exact && sig ) {
78 }
79 return -0x7FFFFFFF - 1;
80 }
82 return
83 (exp == 0x7FF) && sig ? i32_fromNaN
85 }
86 /*------------------------------------------------------------------------
87 *------------------------------------------------------------------------*/
88 sig |= UINT64_C( 0x0010000000000000 );
89 absZ = sig>>shiftDist;
92 }
93 return sign ? -absZ : absZ;
94
95}
◆ f64_to_i64()
| int_fast64_t f64_to_i64 | ( | float64_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f64_to_i64.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t sig;
51 int_fast16_t shiftDist;
52#ifdef SOFTFLOAT_FAST_INT64
53 struct uint64_extra sigExtra;
54#else
55 uint32_t extSig[3];
56#endif
57
58 /*------------------------------------------------------------------------
59 *------------------------------------------------------------------------*/
61 uiA = uA.ui;
62 sign = signF64UI( uiA );
63 exp = expF64UI( uiA );
64 sig = fracF64UI( uiA );
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
68 shiftDist = 0x433 - exp;
69#ifdef SOFTFLOAT_FAST_INT64
70 if ( shiftDist <= 0 ) {
71 if ( shiftDist < -11 ) goto invalid;
72 sigExtra.v = sig<<-shiftDist;
73 sigExtra.extra = 0;
74 } else {
75 sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
76 }
77 return
79 sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
80#else
81 extSig[indexWord( 3, 0 )] = 0;
82 if ( shiftDist <= 0 ) {
83 if ( shiftDist < -11 ) goto invalid;
84 sig <<= -shiftDist;
85 extSig[indexWord( 3, 2 )] = sig>>32;
86 extSig[indexWord( 3, 1 )] = sig;
87 } else {
88 extSig[indexWord( 3, 2 )] = sig>>32;
89 extSig[indexWord( 3, 1 )] = sig;
90 softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
91 }
93#endif
94 /*------------------------------------------------------------------------
95 *------------------------------------------------------------------------*/
96 invalid:
98 return
101
102}
◆ f64_to_i64_r_minMag()
| int_fast64_t f64_to_i64_r_minMag | ( | float64_t | a, |
| bool | exact ) |
Definition at line 44 of file f64_to_i64_r_minMag.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t sig;
51 int_fast16_t shiftDist;
52 int_fast64_t absZ;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 sign = signF64UI( uiA );
59 exp = expF64UI( uiA );
60 sig = fracF64UI( uiA );
61 /*------------------------------------------------------------------------
62 *------------------------------------------------------------------------*/
63 shiftDist = 0x433 - exp;
64 if ( shiftDist <= 0 ) {
65 /*--------------------------------------------------------------------
66 *--------------------------------------------------------------------*/
67 if ( shiftDist < -10 ) {
70 }
72 return
73 (exp == 0x7FF) && sig ? i64_fromNaN
75 }
76 /*--------------------------------------------------------------------
77 *--------------------------------------------------------------------*/
78 sig |= UINT64_C( 0x0010000000000000 );
79 absZ = sig<<-shiftDist;
80 } else {
81 /*--------------------------------------------------------------------
82 *--------------------------------------------------------------------*/
83 if ( 53 <= shiftDist ) {
84 if ( exact && (exp | sig) ) {
86 }
87 return 0;
88 }
89 /*--------------------------------------------------------------------
90 *--------------------------------------------------------------------*/
91 sig |= UINT64_C( 0x0010000000000000 );
92 absZ = sig>>shiftDist;
93 if ( exact && (absZ<<shiftDist != sig) ) {
95 }
96 }
97 return sign ? -absZ : absZ;
98
99}
◆ f64_to_ui32()
| uint_fast32_t f64_to_ui32 | ( | float64_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f64_to_ui32.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t sig;
51 int_fast16_t shiftDist;
52
53 /*------------------------------------------------------------------------
54 *------------------------------------------------------------------------*/
56 uiA = uA.ui;
57 sign = signF64UI( uiA );
58 exp = expF64UI( uiA );
59 sig = fracF64UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
63 if ( (exp == 0x7FF) && sig ) {
64#if (ui32_fromNaN == ui32_fromPosOverflow)
65 sign = 0;
66#elif (ui32_fromNaN == ui32_fromNegOverflow)
67 sign = 1;
68#else
71#endif
72 }
73#endif
74 /*------------------------------------------------------------------------
75 *------------------------------------------------------------------------*/
77 shiftDist = 0x427 - exp;
80
81}
◆ f64_to_ui32_r_minMag()
| uint_fast32_t f64_to_ui32_r_minMag | ( | float64_t | a, |
| bool | exact ) |
Definition at line 44 of file f64_to_ui32_r_minMag.c.
45{
47 uint_fast64_t uiA;
48 int_fast16_t exp;
49 uint_fast64_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 uint_fast32_t z;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF64UI( uiA );
59 sig = fracF64UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = 0x433 - exp;
63 if ( 53 <= shiftDist ) {
64 if ( exact && (exp | sig) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF64UI( uiA );
72 if ( sign || (shiftDist < 21) ) {
74 return
75 (exp == 0x7FF) && sig ? ui32_fromNaN
77 }
78 /*------------------------------------------------------------------------
79 *------------------------------------------------------------------------*/
80 sig |= UINT64_C( 0x0010000000000000 );
81 z = sig>>shiftDist;
84 }
85 return z;
86
87}
◆ f64_to_ui64()
| uint_fast64_t f64_to_ui64 | ( | float64_t | a, |
| uint_fast8_t | roundingMode, | ||
| bool | exact ) |
Definition at line 44 of file f64_to_ui64.c.
45{
47 uint_fast64_t uiA;
48 bool sign;
49 int_fast16_t exp;
50 uint_fast64_t sig;
51 int_fast16_t shiftDist;
52#ifdef SOFTFLOAT_FAST_INT64
53 struct uint64_extra sigExtra;
54#else
55 uint32_t extSig[3];
56#endif
57
58 /*------------------------------------------------------------------------
59 *------------------------------------------------------------------------*/
61 uiA = uA.ui;
62 sign = signF64UI( uiA );
63 exp = expF64UI( uiA );
64 sig = fracF64UI( uiA );
65 /*------------------------------------------------------------------------
66 *------------------------------------------------------------------------*/
68 shiftDist = 0x433 - exp;
69#ifdef SOFTFLOAT_FAST_INT64
70 if ( shiftDist <= 0 ) {
71 if ( shiftDist < -11 ) goto invalid;
72 sigExtra.v = sig<<-shiftDist;
73 sigExtra.extra = 0;
74 } else {
75 sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
76 }
77 return
79 sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
80#else
81 extSig[indexWord( 3, 0 )] = 0;
82 if ( shiftDist <= 0 ) {
83 if ( shiftDist < -11 ) goto invalid;
84 sig <<= -shiftDist;
85 extSig[indexWord( 3, 2 )] = sig>>32;
86 extSig[indexWord( 3, 1 )] = sig;
87 } else {
88 extSig[indexWord( 3, 2 )] = sig>>32;
89 extSig[indexWord( 3, 1 )] = sig;
90 softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
91 }
93#endif
94 /*------------------------------------------------------------------------
95 *------------------------------------------------------------------------*/
96 invalid:
98 return
101
102}
◆ f64_to_ui64_r_minMag()
| uint_fast64_t f64_to_ui64_r_minMag | ( | float64_t | a, |
| bool | exact ) |
Definition at line 44 of file f64_to_ui64_r_minMag.c.
45{
47 uint_fast64_t uiA;
48 int_fast16_t exp;
49 uint_fast64_t sig;
50 int_fast16_t shiftDist;
51 bool sign;
52 uint_fast64_t z;
53
54 /*------------------------------------------------------------------------
55 *------------------------------------------------------------------------*/
57 uiA = uA.ui;
58 exp = expF64UI( uiA );
59 sig = fracF64UI( uiA );
60 /*------------------------------------------------------------------------
61 *------------------------------------------------------------------------*/
62 shiftDist = 0x433 - exp;
63 if ( 53 <= shiftDist ) {
64 if ( exact && (exp | sig) ) {
66 }
67 return 0;
68 }
69 /*------------------------------------------------------------------------
70 *------------------------------------------------------------------------*/
71 sign = signF64UI( uiA );
72 if ( sign ) goto invalid;
73 if ( shiftDist <= 0 ) {
74 if ( shiftDist < -11 ) goto invalid;
75 z = (sig | UINT64_C( 0x0010000000000000 ))<<-shiftDist;
76 } else {
77 sig |= UINT64_C( 0x0010000000000000 );
78 z = sig>>shiftDist;
81 }
82 }
83 return z;
84 /*------------------------------------------------------------------------
85 *------------------------------------------------------------------------*/
86 invalid:
88 return
89 (exp == 0x7FF) && sig ? ui64_fromNaN
91
92}
◆ i32_to_extF80M()
| void i32_to_extF80M | ( | int32_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 53 of file i32_to_extF80M.c.
54{
56 uint_fast16_t uiZ64;
57 uint64_t sigZ;
58 bool sign;
59 uint32_t absA;
60 int_fast8_t shiftDist;
61
63 uiZ64 = 0;
64 sigZ = 0;
66 sign = (a < 0);
68 shiftDist = softfloat_countLeadingZeros32( absA );
69 uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );
70 sigZ = (uint64_t) (absA<<shiftDist)<<32;
71 }
72 zSPtr->signExp = uiZ64;
73 zSPtr->signif = sigZ;
74
75}
#define softfloat_countLeadingZeros32
Definition s_countLeadingZeros32.c:42
◆ i32_to_f128M()
| void i32_to_f128M | ( | int32_t | a, |
| float128_t * | zPtr ) |
Definition at line 53 of file i32_to_f128M.c.
54{
55 uint32_t *zWPtr;
56 uint32_t uiZ96, uiZ64;
57 bool sign;
58 uint32_t absA;
59 int_fast8_t shiftDist;
60 uint64_t normAbsA;
61
62 zWPtr = (uint32_t *) zPtr;
63 uiZ96 = 0;
64 uiZ64 = 0;
66 sign = (a < 0);
68 shiftDist = softfloat_countLeadingZeros32( absA ) + 17;
69 normAbsA = (uint64_t) absA<<shiftDist;
70 uiZ96 = packToF128UI96( sign, 0x402E - shiftDist, normAbsA>>32 );
71 uiZ64 = normAbsA;
72 }
73 zWPtr[indexWord( 4, 3 )] = uiZ96;
74 zWPtr[indexWord( 4, 2 )] = uiZ64;
75 zWPtr[indexWord( 4, 1 )] = 0;
76 zWPtr[indexWord( 4, 0 )] = 0;
77
78}
◆ i32_to_f16()
Definition at line 43 of file i32_to_f16.c.
44{
45 bool sign;
46 uint_fast32_t absA;
47 int_fast8_t shiftDist;
49 uint_fast16_t sig;
50
51 sign = (a < 0);
53 shiftDist = softfloat_countLeadingZeros32( absA ) - 21;
54 if ( 0 <= shiftDist ) {
55 u.ui =
57 sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist )
58 : 0;
59 return u.f;
60 } else {
61 shiftDist += 4;
62 sig =
63 (shiftDist < 0)
64 ? absA>>(-shiftDist)
65 | ((uint32_t) (absA<<(shiftDist & 31)) != 0)
66 : (uint_fast16_t) absA<<shiftDist;
68 }
69
70}
◆ i32_to_f32()
Definition at line 43 of file i32_to_f32.c.
44{
45 bool sign;
47 uint_fast32_t absA;
48
49 sign = (a < 0);
51 uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0;
52 return uZ.f;
53 }
56
57}
◆ i32_to_f64()
Definition at line 43 of file i32_to_f64.c.
44{
45 uint_fast64_t uiZ;
46 bool sign;
47 uint_fast32_t absA;
48 int_fast8_t shiftDist;
50
52 uiZ = 0;
53 } else {
54 sign = (a < 0);
56 shiftDist = softfloat_countLeadingZeros32( absA ) + 21;
57 uiZ =
58 packToF64UI(
59 sign, 0x432 - shiftDist, (uint_fast64_t) absA<<shiftDist );
60 }
61 uZ.ui = uiZ;
62 return uZ.f;
63
64}
◆ i64_to_extF80M()
| void i64_to_extF80M | ( | int64_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 53 of file i64_to_extF80M.c.
54{
56 uint_fast16_t uiZ64;
57 uint64_t sigZ;
58 bool sign;
59 uint64_t absA;
60 int_fast8_t shiftDist;
61
63 uiZ64 = 0;
64 sigZ = 0;
66 sign = (a < 0);
68 shiftDist = softfloat_countLeadingZeros64( absA );
69 uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );
70 sigZ = absA<<shiftDist;
71 }
72 zSPtr->signExp = uiZ64;
73 zSPtr->signif = sigZ;
74
75}
#define softfloat_countLeadingZeros64
Definition s_countLeadingZeros64.c:42
◆ i64_to_f128M()
| void i64_to_f128M | ( | int64_t | a, |
| float128_t * | zPtr ) |
Definition at line 53 of file i64_to_f128M.c.
54{
55 uint32_t *zWPtr;
56 uint32_t uiZ96, uiZ64;
57 bool sign;
58 uint64_t absA;
59 uint_fast8_t shiftDist;
60 uint32_t *ptr;
61
62 zWPtr = (uint32_t *) zPtr;
63 uiZ96 = 0;
64 uiZ64 = 0;
65 zWPtr[indexWord( 4, 1 )] = 0;
66 zWPtr[indexWord( 4, 0 )] = 0;
68 sign = (a < 0);
70 shiftDist = softfloat_countLeadingZeros64( absA ) + 17;
71 if ( shiftDist < 32 ) {
72 ptr = zWPtr + indexMultiwordHi( 4, 3 );
73 ptr[indexWord( 3, 2 )] = 0;
74 ptr[indexWord( 3, 1 )] = absA>>32;
75 ptr[indexWord( 3, 0 )] = absA;
76 softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );
77 ptr[indexWordHi( 3 )] =
78 packToF128UI96(
79 sign, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );
80 return;
81 }
82 absA <<= shiftDist - 32;
83 uiZ96 = packToF128UI96( sign, 0x404E - shiftDist, absA>>32 );
84 uiZ64 = absA;
85 }
86 zWPtr[indexWord( 4, 3 )] = uiZ96;
87 zWPtr[indexWord( 4, 2 )] = uiZ64;
88
89}
#define softfloat_shortShiftLeft96M(aPtr, dist, zPtr)
Definition primitives.h:695
◆ i64_to_f16()
Definition at line 43 of file i64_to_f16.c.
44{
45 bool sign;
46 uint_fast64_t absA;
47 int_fast8_t shiftDist;
49 uint_fast16_t sig;
50
51 sign = (a < 0);
53 shiftDist = softfloat_countLeadingZeros64( absA ) - 53;
54 if ( 0 <= shiftDist ) {
55 u.ui =
57 sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist )
58 : 0;
59 return u.f;
60 } else {
61 shiftDist += 4;
62 sig =
63 (shiftDist < 0)
64 ? softfloat_shortShiftRightJam64( absA, -shiftDist )
65 : (uint_fast16_t) absA<<shiftDist;
67 }
68
69}
◆ i64_to_f32()
Definition at line 43 of file i64_to_f32.c.
44{
45 bool sign;
46 uint_fast64_t absA;
47 int_fast8_t shiftDist;
49 uint_fast32_t sig;
50
51 sign = (a < 0);
53 shiftDist = softfloat_countLeadingZeros64( absA ) - 40;
54 if ( 0 <= shiftDist ) {
55 u.ui =
57 sign, 0x95 - shiftDist, (uint_fast32_t) absA<<shiftDist )
58 : 0;
59 return u.f;
60 } else {
61 shiftDist += 7;
62 sig =
63 (shiftDist < 0)
64 ? softfloat_shortShiftRightJam64( absA, -shiftDist )
65 : (uint_fast32_t) absA<<shiftDist;
67 }
68
69}
◆ i64_to_f64()
Definition at line 43 of file i64_to_f64.c.
44{
45 bool sign;
47 uint_fast64_t absA;
48
49 sign = (a < 0);
51 uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0;
52 return uZ.f;
53 }
56
57}
◆ softfloat_raiseFlags()
| void softfloat_raiseFlags | ( | uint_fast8_t | flags | ) |
Definition at line 46 of file softfloat_raiseFlags.c.
◆ ui32_to_extF80M()
| void ui32_to_extF80M | ( | uint32_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 53 of file ui32_to_extF80M.c.
54{
56 uint_fast16_t uiZ64;
57 uint64_t sigZ;
58 int_fast8_t shiftDist;
59
61 uiZ64 = 0;
62 sigZ = 0;
65 uiZ64 = packToExtF80UI64( 0, 0x401E - shiftDist );
67 }
68 zSPtr->signExp = uiZ64;
69 zSPtr->signif = sigZ;
70
71}
◆ ui32_to_f128M()
| void ui32_to_f128M | ( | uint32_t | a, |
| float128_t * | zPtr ) |
Definition at line 53 of file ui32_to_f128M.c.
54{
55 uint32_t *zWPtr, uiZ96, uiZ64;
56 int_fast8_t shiftDist;
57 uint64_t normA;
58
59 zWPtr = (uint32_t *) zPtr;
60 uiZ96 = 0;
61 uiZ64 = 0;
65 uiZ96 = packToF128UI96( 0, 0x402E - shiftDist, normA>>32 );
66 uiZ64 = normA;
67 }
68 zWPtr[indexWord( 4, 3 )] = uiZ96;
69 zWPtr[indexWord( 4, 2 )] = uiZ64;
70 zWPtr[indexWord( 4, 1 )] = 0;
71 zWPtr[indexWord( 4, 0 )] = 0;
72
73}
◆ ui32_to_f16()
Definition at line 42 of file ui32_to_f16.c.
43{
44 int_fast8_t shiftDist;
46 uint_fast16_t sig;
47
49 if ( 0 <= shiftDist ) {
50 u.ui =
53 : 0;
54 return u.f;
55 } else {
56 shiftDist += 4;
57 sig =
58 (shiftDist < 0)
62 }
63
64}
Here is the call graph for this function:
◆ ui32_to_f32()
Definition at line 42 of file ui32_to_f32.c.
43{
45
47 uZ.ui = 0;
48 return uZ.f;
49 }
52 } else {
54 }
55
56}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ ui32_to_f64()
Definition at line 42 of file ui32_to_f64.c.
43{
44 uint_fast64_t uiZ;
45 int_fast8_t shiftDist;
47
49 uiZ = 0;
50 } else {
52 uiZ =
54 }
55 uZ.ui = uiZ;
56 return uZ.f;
57
58}
Here is the caller graph for this function:
◆ ui64_to_extF80M()
| void ui64_to_extF80M | ( | uint64_t | a, |
| extFloat80_t * | zPtr ) |
Definition at line 53 of file ui64_to_extF80M.c.
54{
56 uint_fast16_t uiZ64;
57 uint64_t sigZ;
58 int_fast8_t shiftDist;
59
61 uiZ64 = 0;
62 sigZ = 0;
65 uiZ64 = packToExtF80UI64( 0, 0x403E - shiftDist );
66 sigZ = a<<shiftDist;
67 }
68 zSPtr->signExp = uiZ64;
69 zSPtr->signif = sigZ;
70
71}
◆ ui64_to_f128M()
| void ui64_to_f128M | ( | uint64_t | a, |
| float128_t * | zPtr ) |
Definition at line 53 of file ui64_to_f128M.c.
54{
55 uint32_t *zWPtr, uiZ96, uiZ64;
56 uint_fast8_t shiftDist;
57 uint32_t *ptr;
58
59 zWPtr = (uint32_t *) zPtr;
60 uiZ96 = 0;
61 uiZ64 = 0;
62 zWPtr[indexWord( 4, 1 )] = 0;
63 zWPtr[indexWord( 4, 0 )] = 0;
66 if ( shiftDist < 32 ) {
67 ptr = zWPtr + indexMultiwordHi( 4, 3 );
68 ptr[indexWord( 3, 2 )] = 0;
71 softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );
72 ptr[indexWordHi( 3 )] =
74 return;
75 }
76 a <<= shiftDist - 32;
78 uiZ64 = a;
79 }
80 zWPtr[indexWord( 4, 3 )] = uiZ96;
81 zWPtr[indexWord( 4, 2 )] = uiZ64;
82
83}
◆ ui64_to_f16()
Definition at line 42 of file ui64_to_f16.c.
43{
44 int_fast8_t shiftDist;
46 uint_fast16_t sig;
47
49 if ( 0 <= shiftDist ) {
50 u.ui =
53 : 0;
54 return u.f;
55 } else {
56 shiftDist += 4;
57 sig =
61 }
62
63}
Here is the call graph for this function:
◆ ui64_to_f32()
Definition at line 42 of file ui64_to_f32.c.
43{
44 int_fast8_t shiftDist;
46 uint_fast32_t sig;
47
49 if ( 0 <= shiftDist ) {
50 u.ui =
53 : 0;
54 return u.f;
55 } else {
56 shiftDist += 7;
57 sig =
61 }
62
63}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ ui64_to_f64()
Definition at line 42 of file ui64_to_f64.c.
43{
45
47 uZ.ui = 0;
48 return uZ.f;
49 }
51 return
54 } else {
56 }
57
58}
Here is the call graph for this function:
Here is the caller graph for this function:
Variable Documentation
◆ extF80_roundingPrecision
|
extern |
Definition at line 51 of file softfloat_state.c.
◆ softfloat_detectTininess
|
extern |
Definition at line 48 of file softfloat_state.c.
◆ softfloat_exceptionFlags
|
extern |
Definition at line 49 of file softfloat_state.c.
◆ softfloat_roundingMode
|
extern |
Definition at line 47 of file softfloat_state.c.
