/src/qemu/include/fpu/softfloat.h
Line | Count | Source |
1 | | /* |
2 | | * QEMU float support |
3 | | * |
4 | | * The code in this source file is derived from release 2a of the SoftFloat |
5 | | * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and |
6 | | * some later contributions) are provided under that license, as detailed below. |
7 | | * It has subsequently been modified by contributors to the QEMU Project, |
8 | | * so some portions are provided under: |
9 | | * the SoftFloat-2a license |
10 | | * the BSD license |
11 | | * GPL-v2-or-later |
12 | | * |
13 | | * Any future contributions to this file after December 1st 2014 will be |
14 | | * taken to be licensed under the Softfloat-2a license unless specifically |
15 | | * indicated otherwise. |
16 | | */ |
17 | | |
18 | | /* |
19 | | =============================================================================== |
20 | | This C header file is part of the SoftFloat IEC/IEEE Floating-point |
21 | | Arithmetic Package, Release 2a. |
22 | | |
23 | | Written by John R. Hauser. This work was made possible in part by the |
24 | | International Computer Science Institute, located at Suite 600, 1947 Center |
25 | | Street, Berkeley, California 94704. Funding was partially provided by the |
26 | | National Science Foundation under grant MIP-9311980. The original version |
27 | | of this code was written as part of a project to build a fixed-point vector |
28 | | processor in collaboration with the University of California at Berkeley, |
29 | | overseen by Profs. Nelson Morgan and John Wawrzynek. More information |
30 | | is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ |
31 | | arithmetic/SoftFloat.html'. |
32 | | |
33 | | THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort |
34 | | has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT |
35 | | TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO |
36 | | PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY |
37 | | AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. |
38 | | |
39 | | Derivative works are acceptable, even for commercial purposes, so long as |
40 | | (1) they include prominent notice that the work is derivative, and (2) they |
41 | | include prominent notice akin to these four paragraphs for those parts of |
42 | | this code that are retained. |
43 | | |
44 | | =============================================================================== |
45 | | */ |
46 | | |
47 | | /* BSD licensing: |
48 | | * Copyright (c) 2006, Fabrice Bellard |
49 | | * All rights reserved. |
50 | | * |
51 | | * Redistribution and use in source and binary forms, with or without |
52 | | * modification, are permitted provided that the following conditions are met: |
53 | | * |
54 | | * 1. Redistributions of source code must retain the above copyright notice, |
55 | | * this list of conditions and the following disclaimer. |
56 | | * |
57 | | * 2. Redistributions in binary form must reproduce the above copyright notice, |
58 | | * this list of conditions and the following disclaimer in the documentation |
59 | | * and/or other materials provided with the distribution. |
60 | | * |
61 | | * 3. Neither the name of the copyright holder nor the names of its contributors |
62 | | * may be used to endorse or promote products derived from this software without |
63 | | * specific prior written permission. |
64 | | * |
65 | | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
66 | | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
67 | | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
68 | | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
69 | | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
70 | | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
71 | | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
72 | | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
73 | | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
74 | | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
75 | | * THE POSSIBILITY OF SUCH DAMAGE. |
76 | | */ |
77 | | |
78 | | /* Portions of this work are licensed under the terms of the GNU GPL, |
79 | | * version 2 or later. See the COPYING file in the top-level directory. |
80 | | */ |
81 | | |
82 | | #ifndef SOFTFLOAT_H |
83 | | #define SOFTFLOAT_H |
84 | | |
85 | | /*---------------------------------------------------------------------------- |
86 | | | Software IEC/IEEE floating-point ordering relations |
87 | | *----------------------------------------------------------------------------*/ |
88 | | |
89 | | typedef enum { |
90 | | float_relation_less = -1, |
91 | | float_relation_equal = 0, |
92 | | float_relation_greater = 1, |
93 | | float_relation_unordered = 2 |
94 | | } FloatRelation; |
95 | | |
96 | | #include "fpu/softfloat-types.h" |
97 | | #include "fpu/softfloat-helpers.h" |
98 | | #include "qemu/int128.h" |
99 | | |
100 | | /*---------------------------------------------------------------------------- |
101 | | | Routine to raise any or all of the software IEC/IEEE floating-point |
102 | | | exception flags. |
103 | | *----------------------------------------------------------------------------*/ |
104 | | static inline void float_raise(FloatExceptionFlags flags, float_status *status) |
105 | 0 | { |
106 | 0 | status->float_exception_flags |= flags; |
107 | 0 | } Unexecuted instantiation: softfloat.c:float_raise Unexecuted instantiation: fpu_helper.c:float_raise Unexecuted instantiation: translate.c:float_raise |
108 | | |
109 | | /*---------------------------------------------------------------------------- |
110 | | | If `a' is denormal and we are in flush-to-zero mode then set the |
111 | | | input-denormal exception and return zero. Otherwise just return the value. |
112 | | *----------------------------------------------------------------------------*/ |
113 | | float16 float16_squash_input_denormal(float16 a, float_status *status); |
114 | | float32 float32_squash_input_denormal(float32 a, float_status *status); |
115 | | float64 float64_squash_input_denormal(float64 a, float_status *status); |
116 | | bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status); |
117 | | |
118 | | /*---------------------------------------------------------------------------- |
119 | | | Options to indicate which negations to perform in float*_muladd() |
120 | | | Using these differs from negating an input or output before calling |
121 | | | the muladd function in that this means that a NaN doesn't have its |
122 | | | sign bit inverted before it is propagated. |
123 | | | |
124 | | | With float_muladd_suppress_add_product_zero, if A or B is zero |
125 | | | such that the product is a true zero, then return C without addition. |
126 | | | This preserves the sign of C when C is +/- 0. Used for Hexagon. |
127 | | *----------------------------------------------------------------------------*/ |
128 | | enum { |
129 | | float_muladd_negate_c = 1, |
130 | | float_muladd_negate_product = 2, |
131 | | float_muladd_negate_result = 4, |
132 | | float_muladd_suppress_add_product_zero = 8, |
133 | | }; |
134 | | |
135 | | /*---------------------------------------------------------------------------- |
136 | | | Options to indicate which negations to perform in float*_minmax() |
137 | | *----------------------------------------------------------------------------*/ |
138 | | |
139 | | /* Flags for parts_minmax. */ |
140 | | enum { |
141 | | /* Set for minimum; clear for maximum. */ |
142 | | float_minmax_ismin = 1, |
143 | | /* Set for the IEEE 754-2008 minNum() and maxNum() operations. */ |
144 | | float_minmax_isnum = 2, |
145 | | /* Set for the IEEE 754-2008 minNumMag() and minNumMag() operations. */ |
146 | | float_minmax_ismag = 4, |
147 | | /* |
148 | | * Set for the IEEE 754-2019 minimumNumber() and maximumNumber() |
149 | | * operations. |
150 | | */ |
151 | | float_minmax_isnumber = 8, |
152 | | }; |
153 | | |
154 | | /*---------------------------------------------------------------------------- |
155 | | | Software IEC/IEEE integer-to-floating-point conversion routines. |
156 | | *----------------------------------------------------------------------------*/ |
157 | | |
158 | | float16 int16_to_float16_scalbn(int16_t a, int, float_status *status); |
159 | | float16 int32_to_float16_scalbn(int32_t a, int, float_status *status); |
160 | | float16 int64_to_float16_scalbn(int64_t a, int, float_status *status); |
161 | | float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status); |
162 | | float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status); |
163 | | float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status); |
164 | | |
165 | | float16 int8_to_float16(int8_t a, float_status *status); |
166 | | float16 int16_to_float16(int16_t a, float_status *status); |
167 | | float16 int32_to_float16(int32_t a, float_status *status); |
168 | | float16 int64_to_float16(int64_t a, float_status *status); |
169 | | float16 uint8_to_float16(uint8_t a, float_status *status); |
170 | | float16 uint16_to_float16(uint16_t a, float_status *status); |
171 | | float16 uint32_to_float16(uint32_t a, float_status *status); |
172 | | float16 uint64_to_float16(uint64_t a, float_status *status); |
173 | | |
174 | | float32 int16_to_float32_scalbn(int16_t, int, float_status *status); |
175 | | float32 int32_to_float32_scalbn(int32_t, int, float_status *status); |
176 | | float32 int64_to_float32_scalbn(int64_t, int, float_status *status); |
177 | | float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status); |
178 | | float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status); |
179 | | float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status); |
180 | | |
181 | | float32 int16_to_float32(int16_t, float_status *status); |
182 | | float32 int32_to_float32(int32_t, float_status *status); |
183 | | float32 int64_to_float32(int64_t, float_status *status); |
184 | | float32 uint16_to_float32(uint16_t, float_status *status); |
185 | | float32 uint32_to_float32(uint32_t, float_status *status); |
186 | | float32 uint64_to_float32(uint64_t, float_status *status); |
187 | | |
188 | | float64 int16_to_float64_scalbn(int16_t, int, float_status *status); |
189 | | float64 int32_to_float64_scalbn(int32_t, int, float_status *status); |
190 | | float64 int64_to_float64_scalbn(int64_t, int, float_status *status); |
191 | | float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status); |
192 | | float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status); |
193 | | float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status); |
194 | | |
195 | | float64 int16_to_float64(int16_t, float_status *status); |
196 | | float64 int32_to_float64(int32_t, float_status *status); |
197 | | float64 int64_to_float64(int64_t, float_status *status); |
198 | | float64 uint16_to_float64(uint16_t, float_status *status); |
199 | | float64 uint32_to_float64(uint32_t, float_status *status); |
200 | | float64 uint64_to_float64(uint64_t, float_status *status); |
201 | | |
202 | | floatx80 int32_to_floatx80(int32_t, float_status *status); |
203 | | floatx80 int64_to_floatx80(int64_t, float_status *status); |
204 | | |
205 | | float128 int32_to_float128(int32_t, float_status *status); |
206 | | float128 int64_to_float128(int64_t, float_status *status); |
207 | | float128 int128_to_float128(Int128, float_status *status); |
208 | | float128 uint64_to_float128(uint64_t, float_status *status); |
209 | | float128 uint128_to_float128(Int128, float_status *status); |
210 | | |
211 | | /*---------------------------------------------------------------------------- |
212 | | | OCP FP{4,8} conversion routines. |
213 | | *----------------------------------------------------------------------------*/ |
214 | | |
215 | | float8_e4m3 float4_e2m1_to_float8_e4m3(float4_e2m1, float_status *status); |
216 | | |
217 | | bfloat16 float8_e4m3_to_bfloat16(float8_e4m3, float_status *status); |
218 | | float8_e4m3 bfloat16_to_float8_e4m3(bfloat16, bool sat, float_status *status); |
219 | | float8_e4m3 float32_to_float8_e4m3(float32, bool sat, float_status *status); |
220 | | |
221 | | bfloat16 float8_e5m2_to_bfloat16(float8_e5m2, float_status *status); |
222 | | float8_e5m2 bfloat16_to_float8_e5m2(bfloat16, bool sat, float_status *status); |
223 | | float8_e5m2 float32_to_float8_e5m2(float32, bool sat, float_status *status); |
224 | | |
225 | | /*---------------------------------------------------------------------------- |
226 | | | Software half-precision conversion routines. |
227 | | *----------------------------------------------------------------------------*/ |
228 | | |
229 | | float16 float32_to_float16(float32, bool ieee, float_status *status); |
230 | | float32 float16_to_float32(float16, bool ieee, float_status *status); |
231 | | float16 float64_to_float16(float64 a, bool ieee, float_status *status); |
232 | | float64 float16_to_float64(float16 a, bool ieee, float_status *status); |
233 | | |
234 | | int8_t float16_to_int8_scalbn(float16, FloatRoundMode, int, |
235 | | float_status *status); |
236 | | int16_t float16_to_int16_scalbn(float16, FloatRoundMode, int, float_status *); |
237 | | int32_t float16_to_int32_scalbn(float16, FloatRoundMode, int, float_status *); |
238 | | int64_t float16_to_int64_scalbn(float16, FloatRoundMode, int, float_status *); |
239 | | |
240 | | int8_t float16_to_int8(float16, float_status *status); |
241 | | int16_t float16_to_int16(float16, float_status *status); |
242 | | int32_t float16_to_int32(float16, float_status *status); |
243 | | int64_t float16_to_int64(float16, float_status *status); |
244 | | |
245 | | int16_t float16_to_int16_round_to_zero(float16, float_status *status); |
246 | | int32_t float16_to_int32_round_to_zero(float16, float_status *status); |
247 | | int64_t float16_to_int64_round_to_zero(float16, float_status *status); |
248 | | |
249 | | uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode, |
250 | | int, float_status *status); |
251 | | uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode, |
252 | | int, float_status *status); |
253 | | uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode, |
254 | | int, float_status *status); |
255 | | uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode, |
256 | | int, float_status *status); |
257 | | |
258 | | uint8_t float16_to_uint8(float16 a, float_status *status); |
259 | | uint16_t float16_to_uint16(float16 a, float_status *status); |
260 | | uint32_t float16_to_uint32(float16 a, float_status *status); |
261 | | uint64_t float16_to_uint64(float16 a, float_status *status); |
262 | | |
263 | | uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status); |
264 | | uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status); |
265 | | uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status); |
266 | | |
267 | | /*---------------------------------------------------------------------------- |
268 | | | Software half-precision operations. |
269 | | *----------------------------------------------------------------------------*/ |
270 | | |
271 | | float16 float16_round_to_int(float16, float_status *status); |
272 | | float16 float16_add(float16, float16, float_status *status); |
273 | | float16 float16_sub(float16, float16, float_status *status); |
274 | | float16 float16_mul(float16, float16, float_status *status); |
275 | | float16 float16_muladd(float16, float16, float16, int, float_status *status); |
276 | | float16 float16_muladd_scalbn(float16, float16, float16, |
277 | | int, int, float_status *status); |
278 | | float16 float16_div(float16, float16, float_status *status); |
279 | | float16 float16_scalbn(float16, int, float_status *status); |
280 | | float16 float16_minmax(float16, float16, float_status *status, int flags); |
281 | | float16 float16_sqrt(float16, float_status *status); |
282 | | FloatRelation float16_compare(float16, float16, float_status *status); |
283 | | FloatRelation float16_compare_quiet(float16, float16, float_status *status); |
284 | | |
285 | | bool float16_is_quiet_nan(float16, float_status *status); |
286 | | bool float16_is_signaling_nan(float16, float_status *status); |
287 | | float16 float16_silence_nan(float16, float_status *status); |
288 | | |
289 | | static inline bool float16_is_any_nan(float16 a) |
290 | 0 | { |
291 | 0 | return ((float16_val(a) & ~0x8000) > 0x7c00); |
292 | 0 | } Unexecuted instantiation: softfloat.c:float16_is_any_nan Unexecuted instantiation: fpu_helper.c:float16_is_any_nan Unexecuted instantiation: translate.c:float16_is_any_nan |
293 | | |
294 | | static inline bool float16_is_neg(float16 a) |
295 | 0 | { |
296 | 0 | return float16_val(a) >> 15; |
297 | 0 | } Unexecuted instantiation: softfloat.c:float16_is_neg Unexecuted instantiation: fpu_helper.c:float16_is_neg Unexecuted instantiation: translate.c:float16_is_neg |
298 | | |
299 | | static inline bool float16_is_infinity(float16 a) |
300 | 0 | { |
301 | 0 | return (float16_val(a) & 0x7fff) == 0x7c00; |
302 | 0 | } Unexecuted instantiation: softfloat.c:float16_is_infinity Unexecuted instantiation: fpu_helper.c:float16_is_infinity Unexecuted instantiation: translate.c:float16_is_infinity |
303 | | |
304 | | static inline bool float16_is_zero(float16 a) |
305 | 0 | { |
306 | 0 | return (float16_val(a) & 0x7fff) == 0; |
307 | 0 | } Unexecuted instantiation: softfloat.c:float16_is_zero Unexecuted instantiation: fpu_helper.c:float16_is_zero Unexecuted instantiation: translate.c:float16_is_zero |
308 | | |
309 | | static inline bool float16_is_zero_or_denormal(float16 a) |
310 | 0 | { |
311 | 0 | return (float16_val(a) & 0x7c00) == 0; |
312 | 0 | } Unexecuted instantiation: softfloat.c:float16_is_zero_or_denormal Unexecuted instantiation: fpu_helper.c:float16_is_zero_or_denormal Unexecuted instantiation: translate.c:float16_is_zero_or_denormal |
313 | | |
314 | | static inline bool float16_is_normal(float16 a) |
315 | 0 | { |
316 | 0 | return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2; |
317 | 0 | } Unexecuted instantiation: softfloat.c:float16_is_normal Unexecuted instantiation: fpu_helper.c:float16_is_normal Unexecuted instantiation: translate.c:float16_is_normal |
318 | | |
319 | | static inline float16 float16_abs(float16 a) |
320 | 0 | { |
321 | 0 | /* Note that abs does *not* handle NaN specially, nor does |
322 | 0 | * it flush denormal inputs to zero. |
323 | 0 | */ |
324 | 0 | return make_float16(float16_val(a) & 0x7fff); |
325 | 0 | } Unexecuted instantiation: softfloat.c:float16_abs Unexecuted instantiation: fpu_helper.c:float16_abs Unexecuted instantiation: translate.c:float16_abs |
326 | | |
327 | | static inline float16 float16_chs(float16 a) |
328 | 0 | { |
329 | 0 | /* Note that chs does *not* handle NaN specially, nor does |
330 | 0 | * it flush denormal inputs to zero. |
331 | 0 | */ |
332 | 0 | return make_float16(float16_val(a) ^ 0x8000); |
333 | 0 | } Unexecuted instantiation: softfloat.c:float16_chs Unexecuted instantiation: fpu_helper.c:float16_chs Unexecuted instantiation: translate.c:float16_chs |
334 | | |
335 | | static inline float16 float16_set_sign(float16 a, int sign) |
336 | 0 | { |
337 | 0 | return make_float16((float16_val(a) & 0x7fff) | (sign << 15)); |
338 | 0 | } Unexecuted instantiation: softfloat.c:float16_set_sign Unexecuted instantiation: fpu_helper.c:float16_set_sign Unexecuted instantiation: translate.c:float16_set_sign |
339 | | |
340 | | static inline bool float16_eq(float16 a, float16 b, float_status *s) |
341 | 0 | { |
342 | 0 | return float16_compare(a, b, s) == float_relation_equal; |
343 | 0 | } Unexecuted instantiation: softfloat.c:float16_eq Unexecuted instantiation: fpu_helper.c:float16_eq Unexecuted instantiation: translate.c:float16_eq |
344 | | |
345 | | static inline bool float16_le(float16 a, float16 b, float_status *s) |
346 | 0 | { |
347 | 0 | return float16_compare(a, b, s) <= float_relation_equal; |
348 | 0 | } Unexecuted instantiation: softfloat.c:float16_le Unexecuted instantiation: fpu_helper.c:float16_le Unexecuted instantiation: translate.c:float16_le |
349 | | |
350 | | static inline bool float16_lt(float16 a, float16 b, float_status *s) |
351 | 0 | { |
352 | 0 | return float16_compare(a, b, s) < float_relation_equal; |
353 | 0 | } Unexecuted instantiation: softfloat.c:float16_lt Unexecuted instantiation: fpu_helper.c:float16_lt Unexecuted instantiation: translate.c:float16_lt |
354 | | |
355 | | static inline bool float16_unordered(float16 a, float16 b, float_status *s) |
356 | 0 | { |
357 | 0 | return float16_compare(a, b, s) == float_relation_unordered; |
358 | 0 | } Unexecuted instantiation: softfloat.c:float16_unordered Unexecuted instantiation: fpu_helper.c:float16_unordered Unexecuted instantiation: translate.c:float16_unordered |
359 | | |
360 | | static inline bool float16_eq_quiet(float16 a, float16 b, float_status *s) |
361 | 0 | { |
362 | 0 | return float16_compare_quiet(a, b, s) == float_relation_equal; |
363 | 0 | } Unexecuted instantiation: softfloat.c:float16_eq_quiet Unexecuted instantiation: fpu_helper.c:float16_eq_quiet Unexecuted instantiation: translate.c:float16_eq_quiet |
364 | | |
365 | | static inline bool float16_le_quiet(float16 a, float16 b, float_status *s) |
366 | 0 | { |
367 | 0 | return float16_compare_quiet(a, b, s) <= float_relation_equal; |
368 | 0 | } Unexecuted instantiation: softfloat.c:float16_le_quiet Unexecuted instantiation: fpu_helper.c:float16_le_quiet Unexecuted instantiation: translate.c:float16_le_quiet |
369 | | |
370 | | static inline bool float16_lt_quiet(float16 a, float16 b, float_status *s) |
371 | 0 | { |
372 | 0 | return float16_compare_quiet(a, b, s) < float_relation_equal; |
373 | 0 | } Unexecuted instantiation: softfloat.c:float16_lt_quiet Unexecuted instantiation: fpu_helper.c:float16_lt_quiet Unexecuted instantiation: translate.c:float16_lt_quiet |
374 | | |
375 | | static inline bool float16_unordered_quiet(float16 a, float16 b, |
376 | | float_status *s) |
377 | 0 | { |
378 | 0 | return float16_compare_quiet(a, b, s) == float_relation_unordered; |
379 | 0 | } Unexecuted instantiation: softfloat.c:float16_unordered_quiet Unexecuted instantiation: fpu_helper.c:float16_unordered_quiet Unexecuted instantiation: translate.c:float16_unordered_quiet |
380 | | |
381 | 0 | #define float16_zero make_float16(0) |
382 | | #define float16_half make_float16(0x3800) |
383 | | #define float16_one make_float16(0x3c00) |
384 | | #define float16_one_point_five make_float16(0x3e00) |
385 | | #define float16_two make_float16(0x4000) |
386 | | #define float16_three make_float16(0x4200) |
387 | | #define float16_infinity make_float16(0x7c00) |
388 | | |
389 | | /*---------------------------------------------------------------------------- |
390 | | | Software bfloat16 conversion routines. |
391 | | *----------------------------------------------------------------------------*/ |
392 | | |
393 | | bfloat16 bfloat16_round_to_int(bfloat16, float_status *status); |
394 | | bfloat16 float32_to_bfloat16(float32, float_status *status); |
395 | | float32 bfloat16_to_float32(bfloat16, float_status *status); |
396 | | bfloat16 float64_to_bfloat16(float64 a, float_status *status); |
397 | | float64 bfloat16_to_float64(bfloat16 a, float_status *status); |
398 | | |
399 | | int8_t bfloat16_to_int8_scalbn(bfloat16, FloatRoundMode, |
400 | | int, float_status *status); |
401 | | int16_t bfloat16_to_int16_scalbn(bfloat16, FloatRoundMode, |
402 | | int, float_status *status); |
403 | | int32_t bfloat16_to_int32_scalbn(bfloat16, FloatRoundMode, |
404 | | int, float_status *status); |
405 | | int64_t bfloat16_to_int64_scalbn(bfloat16, FloatRoundMode, |
406 | | int, float_status *status); |
407 | | |
408 | | int8_t bfloat16_to_int8(bfloat16, float_status *status); |
409 | | int16_t bfloat16_to_int16(bfloat16, float_status *status); |
410 | | int32_t bfloat16_to_int32(bfloat16, float_status *status); |
411 | | int64_t bfloat16_to_int64(bfloat16, float_status *status); |
412 | | |
413 | | int8_t bfloat16_to_int8_round_to_zero(bfloat16, float_status *status); |
414 | | int16_t bfloat16_to_int16_round_to_zero(bfloat16, float_status *status); |
415 | | int32_t bfloat16_to_int32_round_to_zero(bfloat16, float_status *status); |
416 | | int64_t bfloat16_to_int64_round_to_zero(bfloat16, float_status *status); |
417 | | |
418 | | uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode, |
419 | | int, float_status *status); |
420 | | uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode, |
421 | | int, float_status *status); |
422 | | uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode, |
423 | | int, float_status *status); |
424 | | uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode, |
425 | | int, float_status *status); |
426 | | |
427 | | uint8_t bfloat16_to_uint8(bfloat16 a, float_status *status); |
428 | | uint16_t bfloat16_to_uint16(bfloat16 a, float_status *status); |
429 | | uint32_t bfloat16_to_uint32(bfloat16 a, float_status *status); |
430 | | uint64_t bfloat16_to_uint64(bfloat16 a, float_status *status); |
431 | | |
432 | | uint8_t bfloat16_to_uint8_round_to_zero(bfloat16 a, float_status *status); |
433 | | uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a, float_status *status); |
434 | | uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a, float_status *status); |
435 | | uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a, float_status *status); |
436 | | |
437 | | bfloat16 int8_to_bfloat16_scalbn(int8_t a, int, float_status *status); |
438 | | bfloat16 int16_to_bfloat16_scalbn(int16_t a, int, float_status *status); |
439 | | bfloat16 int32_to_bfloat16_scalbn(int32_t a, int, float_status *status); |
440 | | bfloat16 int64_to_bfloat16_scalbn(int64_t a, int, float_status *status); |
441 | | bfloat16 uint8_to_bfloat16_scalbn(uint8_t a, int, float_status *status); |
442 | | bfloat16 uint16_to_bfloat16_scalbn(uint16_t a, int, float_status *status); |
443 | | bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int, float_status *status); |
444 | | bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int, float_status *status); |
445 | | |
446 | | bfloat16 int8_to_bfloat16(int8_t a, float_status *status); |
447 | | bfloat16 int16_to_bfloat16(int16_t a, float_status *status); |
448 | | bfloat16 int32_to_bfloat16(int32_t a, float_status *status); |
449 | | bfloat16 int64_to_bfloat16(int64_t a, float_status *status); |
450 | | bfloat16 uint8_to_bfloat16(uint8_t a, float_status *status); |
451 | | bfloat16 uint16_to_bfloat16(uint16_t a, float_status *status); |
452 | | bfloat16 uint32_to_bfloat16(uint32_t a, float_status *status); |
453 | | bfloat16 uint64_to_bfloat16(uint64_t a, float_status *status); |
454 | | |
455 | | /*---------------------------------------------------------------------------- |
456 | | | Software bfloat16 operations. |
457 | | *----------------------------------------------------------------------------*/ |
458 | | |
459 | | bfloat16 bfloat16_add(bfloat16, bfloat16, float_status *status); |
460 | | bfloat16 bfloat16_sub(bfloat16, bfloat16, float_status *status); |
461 | | bfloat16 bfloat16_mul(bfloat16, bfloat16, float_status *status); |
462 | | bfloat16 bfloat16_div(bfloat16, bfloat16, float_status *status); |
463 | | bfloat16 bfloat16_muladd(bfloat16, bfloat16, bfloat16, int, |
464 | | float_status *status); |
465 | | float16 bfloat16_scalbn(bfloat16, int, float_status *status); |
466 | | bfloat16 bfloat16_minmax(bfloat16, bfloat16, float_status *status, int flags); |
467 | | bfloat16 bfloat16_sqrt(bfloat16, float_status *status); |
468 | | FloatRelation bfloat16_compare(bfloat16, bfloat16, float_status *status); |
469 | | FloatRelation bfloat16_compare_quiet(bfloat16, bfloat16, float_status *status); |
470 | | |
471 | | bool bfloat16_is_quiet_nan(bfloat16, float_status *status); |
472 | | bool bfloat16_is_signaling_nan(bfloat16, float_status *status); |
473 | | bfloat16 bfloat16_silence_nan(bfloat16, float_status *status); |
474 | | bfloat16 bfloat16_default_nan(float_status *status); |
475 | | |
476 | | static inline bool bfloat16_is_any_nan(bfloat16 a) |
477 | 0 | { |
478 | 0 | return ((a & ~0x8000) > 0x7F80); |
479 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_is_any_nan Unexecuted instantiation: fpu_helper.c:bfloat16_is_any_nan Unexecuted instantiation: translate.c:bfloat16_is_any_nan |
480 | | |
481 | | static inline bool bfloat16_is_neg(bfloat16 a) |
482 | 0 | { |
483 | 0 | return a >> 15; |
484 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_is_neg Unexecuted instantiation: fpu_helper.c:bfloat16_is_neg Unexecuted instantiation: translate.c:bfloat16_is_neg |
485 | | |
486 | | static inline bool bfloat16_is_infinity(bfloat16 a) |
487 | 0 | { |
488 | 0 | return (a & 0x7fff) == 0x7F80; |
489 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_is_infinity Unexecuted instantiation: fpu_helper.c:bfloat16_is_infinity Unexecuted instantiation: translate.c:bfloat16_is_infinity |
490 | | |
491 | | static inline bool bfloat16_is_zero(bfloat16 a) |
492 | 0 | { |
493 | 0 | return (a & 0x7fff) == 0; |
494 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_is_zero Unexecuted instantiation: fpu_helper.c:bfloat16_is_zero Unexecuted instantiation: translate.c:bfloat16_is_zero |
495 | | |
496 | | static inline bool bfloat16_is_zero_or_denormal(bfloat16 a) |
497 | 0 | { |
498 | 0 | return (a & 0x7F80) == 0; |
499 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_is_zero_or_denormal Unexecuted instantiation: fpu_helper.c:bfloat16_is_zero_or_denormal Unexecuted instantiation: translate.c:bfloat16_is_zero_or_denormal |
500 | | |
501 | | static inline bool bfloat16_is_normal(bfloat16 a) |
502 | 0 | { |
503 | 0 | return (((a >> 7) + 1) & 0xff) >= 2; |
504 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_is_normal Unexecuted instantiation: fpu_helper.c:bfloat16_is_normal Unexecuted instantiation: translate.c:bfloat16_is_normal |
505 | | |
506 | | static inline bfloat16 bfloat16_abs(bfloat16 a) |
507 | 0 | { |
508 | 0 | /* Note that abs does *not* handle NaN specially, nor does |
509 | 0 | * it flush denormal inputs to zero. |
510 | 0 | */ |
511 | 0 | return a & 0x7fff; |
512 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_abs Unexecuted instantiation: fpu_helper.c:bfloat16_abs Unexecuted instantiation: translate.c:bfloat16_abs |
513 | | |
514 | | static inline bfloat16 bfloat16_chs(bfloat16 a) |
515 | 0 | { |
516 | 0 | /* Note that chs does *not* handle NaN specially, nor does |
517 | 0 | * it flush denormal inputs to zero. |
518 | 0 | */ |
519 | 0 | return a ^ 0x8000; |
520 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_chs Unexecuted instantiation: fpu_helper.c:bfloat16_chs Unexecuted instantiation: translate.c:bfloat16_chs |
521 | | |
522 | | static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign) |
523 | 0 | { |
524 | 0 | return (a & 0x7fff) | (sign << 15); |
525 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_set_sign Unexecuted instantiation: fpu_helper.c:bfloat16_set_sign Unexecuted instantiation: translate.c:bfloat16_set_sign |
526 | | |
527 | | static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s) |
528 | 0 | { |
529 | 0 | return bfloat16_compare(a, b, s) == float_relation_equal; |
530 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_eq Unexecuted instantiation: fpu_helper.c:bfloat16_eq Unexecuted instantiation: translate.c:bfloat16_eq |
531 | | |
532 | | static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s) |
533 | 0 | { |
534 | 0 | return bfloat16_compare(a, b, s) <= float_relation_equal; |
535 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_le Unexecuted instantiation: fpu_helper.c:bfloat16_le Unexecuted instantiation: translate.c:bfloat16_le |
536 | | |
537 | | static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s) |
538 | 0 | { |
539 | 0 | return bfloat16_compare(a, b, s) < float_relation_equal; |
540 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_lt Unexecuted instantiation: fpu_helper.c:bfloat16_lt Unexecuted instantiation: translate.c:bfloat16_lt |
541 | | |
542 | | static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s) |
543 | 0 | { |
544 | 0 | return bfloat16_compare(a, b, s) == float_relation_unordered; |
545 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_unordered Unexecuted instantiation: fpu_helper.c:bfloat16_unordered Unexecuted instantiation: translate.c:bfloat16_unordered |
546 | | |
547 | | static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s) |
548 | 0 | { |
549 | 0 | return bfloat16_compare_quiet(a, b, s) == float_relation_equal; |
550 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_eq_quiet Unexecuted instantiation: fpu_helper.c:bfloat16_eq_quiet Unexecuted instantiation: translate.c:bfloat16_eq_quiet |
551 | | |
552 | | static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s) |
553 | 0 | { |
554 | 0 | return bfloat16_compare_quiet(a, b, s) <= float_relation_equal; |
555 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_le_quiet Unexecuted instantiation: fpu_helper.c:bfloat16_le_quiet Unexecuted instantiation: translate.c:bfloat16_le_quiet |
556 | | |
557 | | static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s) |
558 | 0 | { |
559 | 0 | return bfloat16_compare_quiet(a, b, s) < float_relation_equal; |
560 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_lt_quiet Unexecuted instantiation: fpu_helper.c:bfloat16_lt_quiet Unexecuted instantiation: translate.c:bfloat16_lt_quiet |
561 | | |
562 | | static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b, |
563 | | float_status *s) |
564 | 0 | { |
565 | 0 | return bfloat16_compare_quiet(a, b, s) == float_relation_unordered; |
566 | 0 | } Unexecuted instantiation: softfloat.c:bfloat16_unordered_quiet Unexecuted instantiation: fpu_helper.c:bfloat16_unordered_quiet Unexecuted instantiation: translate.c:bfloat16_unordered_quiet |
567 | | |
568 | 0 | #define bfloat16_zero 0 |
569 | | #define bfloat16_half 0x3f00 |
570 | | #define bfloat16_one 0x3f80 |
571 | | #define bfloat16_one_point_five 0x3fc0 |
572 | | #define bfloat16_two 0x4000 |
573 | | #define bfloat16_three 0x4040 |
574 | | #define bfloat16_infinity 0x7f80 |
575 | | |
576 | | /*---------------------------------------------------------------------------- |
577 | | | The pattern for a default generated half-precision NaN. |
578 | | *----------------------------------------------------------------------------*/ |
579 | | float16 float16_default_nan(float_status *status); |
580 | | |
581 | | /*---------------------------------------------------------------------------- |
582 | | | Software IEC/IEEE single-precision conversion routines. |
583 | | *----------------------------------------------------------------------------*/ |
584 | | |
585 | | int16_t float32_to_int16_scalbn(float32, FloatRoundMode, int, float_status *); |
586 | | int32_t float32_to_int32_scalbn(float32, FloatRoundMode, int, float_status *); |
587 | | int64_t float32_to_int64_scalbn(float32, FloatRoundMode, int, float_status *); |
588 | | |
589 | | int16_t float32_to_int16(float32, float_status *status); |
590 | | int32_t float32_to_int32(float32, float_status *status); |
591 | | int64_t float32_to_int64(float32, float_status *status); |
592 | | |
593 | | int16_t float32_to_int16_round_to_zero(float32, float_status *status); |
594 | | int32_t float32_to_int32_round_to_zero(float32, float_status *status); |
595 | | int64_t float32_to_int64_round_to_zero(float32, float_status *status); |
596 | | |
597 | | uint16_t float32_to_uint16_scalbn(float32, FloatRoundMode, int, float_status *); |
598 | | uint32_t float32_to_uint32_scalbn(float32, FloatRoundMode, int, float_status *); |
599 | | uint64_t float32_to_uint64_scalbn(float32, FloatRoundMode, int, float_status *); |
600 | | |
601 | | uint16_t float32_to_uint16(float32, float_status *status); |
602 | | uint32_t float32_to_uint32(float32, float_status *status); |
603 | | uint64_t float32_to_uint64(float32, float_status *status); |
604 | | |
605 | | uint16_t float32_to_uint16_round_to_zero(float32, float_status *status); |
606 | | uint32_t float32_to_uint32_round_to_zero(float32, float_status *status); |
607 | | uint64_t float32_to_uint64_round_to_zero(float32, float_status *status); |
608 | | |
609 | | float64 float32_to_float64(float32, float_status *status); |
610 | | floatx80 float32_to_floatx80(float32, float_status *status); |
611 | | float128 float32_to_float128(float32, float_status *status); |
612 | | |
613 | | /*---------------------------------------------------------------------------- |
614 | | | Software IEC/IEEE single-precision operations. |
615 | | *----------------------------------------------------------------------------*/ |
616 | | float32 float32_round_to_int(float32, float_status *status); |
617 | | float32 float32_add(float32, float32, float_status *status); |
618 | | float32 float32_sub(float32, float32, float_status *status); |
619 | | float32 float32_mul(float32, float32, float_status *status); |
620 | | float32 float32_div(float32, float32, float_status *status); |
621 | | float32 float32_rem(float32, float32, float_status *status); |
622 | | float32 float32_muladd(float32, float32, float32, int, float_status *status); |
623 | | float32 float32_muladd_scalbn(float32, float32, float32, |
624 | | int, int, float_status *status); |
625 | | float32 float32_sqrt(float32, float_status *status); |
626 | | float32 float32_exp2(float32, float_status *status); |
627 | | float32 float32_log2(float32, float_status *status); |
628 | | FloatRelation float32_compare(float32, float32, float_status *status); |
629 | | FloatRelation float32_compare_quiet(float32, float32, float_status *status); |
630 | | float32 float32_minmax(float32, float32, float_status *status, int flags); |
631 | | bool float32_is_quiet_nan(float32, float_status *status); |
632 | | bool float32_is_signaling_nan(float32, float_status *status); |
633 | | float32 float32_silence_nan(float32, float_status *status); |
634 | | float32 float32_scalbn(float32, int, float_status *status); |
635 | | |
636 | | static inline float32 float32_abs(float32 a) |
637 | 0 | { |
638 | 0 | /* Note that abs does *not* handle NaN specially, nor does |
639 | 0 | * it flush denormal inputs to zero. |
640 | 0 | */ |
641 | 0 | return make_float32(float32_val(a) & 0x7fffffff); |
642 | 0 | } Unexecuted instantiation: softfloat.c:float32_abs Unexecuted instantiation: fpu_helper.c:float32_abs Unexecuted instantiation: translate.c:float32_abs |
643 | | |
644 | | static inline float32 float32_chs(float32 a) |
645 | 0 | { |
646 | | /* Note that chs does *not* handle NaN specially, nor does |
647 | | * it flush denormal inputs to zero. |
648 | | */ |
649 | 0 | return make_float32(float32_val(a) ^ 0x80000000); |
650 | 0 | } Unexecuted instantiation: softfloat.c:float32_chs Unexecuted instantiation: fpu_helper.c:float32_chs Unexecuted instantiation: translate.c:float32_chs |
651 | | |
652 | | static inline bool float32_is_infinity(float32 a) |
653 | 0 | { |
654 | 0 | return (float32_val(a) & 0x7fffffff) == 0x7f800000; |
655 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_infinity Unexecuted instantiation: fpu_helper.c:float32_is_infinity Unexecuted instantiation: translate.c:float32_is_infinity |
656 | | |
657 | | static inline bool float32_is_neg(float32 a) |
658 | 0 | { |
659 | 0 | return float32_val(a) >> 31; |
660 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_neg Unexecuted instantiation: fpu_helper.c:float32_is_neg Unexecuted instantiation: translate.c:float32_is_neg |
661 | | |
662 | | static inline bool float32_is_zero(float32 a) |
663 | 0 | { |
664 | 0 | return (float32_val(a) & 0x7fffffff) == 0; |
665 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_zero Unexecuted instantiation: fpu_helper.c:float32_is_zero Unexecuted instantiation: translate.c:float32_is_zero |
666 | | |
667 | | static inline bool float32_is_any_nan(float32 a) |
668 | 0 | { |
669 | 0 | return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL); |
670 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_any_nan Unexecuted instantiation: fpu_helper.c:float32_is_any_nan Unexecuted instantiation: translate.c:float32_is_any_nan |
671 | | |
672 | | static inline bool float32_is_zero_or_denormal(float32 a) |
673 | 0 | { |
674 | 0 | return (float32_val(a) & 0x7f800000) == 0; |
675 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_zero_or_denormal Unexecuted instantiation: fpu_helper.c:float32_is_zero_or_denormal Unexecuted instantiation: translate.c:float32_is_zero_or_denormal |
676 | | |
677 | | static inline bool float32_is_normal(float32 a) |
678 | 0 | { |
679 | 0 | return (((float32_val(a) >> 23) + 1) & 0xff) >= 2; |
680 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_normal Unexecuted instantiation: fpu_helper.c:float32_is_normal Unexecuted instantiation: translate.c:float32_is_normal |
681 | | |
682 | | static inline bool float32_is_denormal(float32 a) |
683 | 0 | { |
684 | 0 | return float32_is_zero_or_denormal(a) && !float32_is_zero(a); |
685 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_denormal Unexecuted instantiation: fpu_helper.c:float32_is_denormal Unexecuted instantiation: translate.c:float32_is_denormal |
686 | | |
687 | | static inline bool float32_is_zero_or_normal(float32 a) |
688 | 0 | { |
689 | 0 | return float32_is_normal(a) || float32_is_zero(a); |
690 | 0 | } Unexecuted instantiation: softfloat.c:float32_is_zero_or_normal Unexecuted instantiation: fpu_helper.c:float32_is_zero_or_normal Unexecuted instantiation: translate.c:float32_is_zero_or_normal |
691 | | |
692 | | static inline float32 float32_set_sign(float32 a, int sign) |
693 | 0 | { |
694 | 0 | return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31)); |
695 | 0 | } Unexecuted instantiation: softfloat.c:float32_set_sign Unexecuted instantiation: fpu_helper.c:float32_set_sign Unexecuted instantiation: translate.c:float32_set_sign |
696 | | |
697 | | static inline bool float32_eq(float32 a, float32 b, float_status *s) |
698 | 0 | { |
699 | 0 | return float32_compare(a, b, s) == float_relation_equal; |
700 | 0 | } Unexecuted instantiation: softfloat.c:float32_eq Unexecuted instantiation: fpu_helper.c:float32_eq Unexecuted instantiation: translate.c:float32_eq |
701 | | |
702 | | static inline bool float32_le(float32 a, float32 b, float_status *s) |
703 | 0 | { |
704 | 0 | return float32_compare(a, b, s) <= float_relation_equal; |
705 | 0 | } Unexecuted instantiation: softfloat.c:float32_le Unexecuted instantiation: fpu_helper.c:float32_le Unexecuted instantiation: translate.c:float32_le |
706 | | |
707 | | static inline bool float32_lt(float32 a, float32 b, float_status *s) |
708 | 0 | { |
709 | 0 | return float32_compare(a, b, s) < float_relation_equal; |
710 | 0 | } Unexecuted instantiation: softfloat.c:float32_lt Unexecuted instantiation: fpu_helper.c:float32_lt Unexecuted instantiation: translate.c:float32_lt |
711 | | |
712 | | static inline bool float32_unordered(float32 a, float32 b, float_status *s) |
713 | 0 | { |
714 | 0 | return float32_compare(a, b, s) == float_relation_unordered; |
715 | 0 | } Unexecuted instantiation: softfloat.c:float32_unordered Unexecuted instantiation: fpu_helper.c:float32_unordered Unexecuted instantiation: translate.c:float32_unordered |
716 | | |
717 | | static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s) |
718 | 0 | { |
719 | 0 | return float32_compare_quiet(a, b, s) == float_relation_equal; |
720 | 0 | } Unexecuted instantiation: softfloat.c:float32_eq_quiet Unexecuted instantiation: fpu_helper.c:float32_eq_quiet Unexecuted instantiation: translate.c:float32_eq_quiet |
721 | | |
722 | | static inline bool float32_le_quiet(float32 a, float32 b, float_status *s) |
723 | 0 | { |
724 | 0 | return float32_compare_quiet(a, b, s) <= float_relation_equal; |
725 | 0 | } Unexecuted instantiation: softfloat.c:float32_le_quiet Unexecuted instantiation: fpu_helper.c:float32_le_quiet Unexecuted instantiation: translate.c:float32_le_quiet |
726 | | |
727 | | static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s) |
728 | 0 | { |
729 | 0 | return float32_compare_quiet(a, b, s) < float_relation_equal; |
730 | 0 | } Unexecuted instantiation: softfloat.c:float32_lt_quiet Unexecuted instantiation: fpu_helper.c:float32_lt_quiet Unexecuted instantiation: translate.c:float32_lt_quiet |
731 | | |
732 | | static inline bool float32_unordered_quiet(float32 a, float32 b, |
733 | | float_status *s) |
734 | 0 | { |
735 | 0 | return float32_compare_quiet(a, b, s) == float_relation_unordered; |
736 | 0 | } Unexecuted instantiation: softfloat.c:float32_unordered_quiet Unexecuted instantiation: fpu_helper.c:float32_unordered_quiet Unexecuted instantiation: translate.c:float32_unordered_quiet |
737 | | |
738 | 0 | #define float32_zero make_float32(0) |
739 | | #define float32_half make_float32(0x3f000000) |
740 | 0 | #define float32_one make_float32(0x3f800000) |
741 | | #define float32_one_point_five make_float32(0x3fc00000) |
742 | | #define float32_two make_float32(0x40000000) |
743 | | #define float32_three make_float32(0x40400000) |
744 | | #define float32_infinity make_float32(0x7f800000) |
745 | | |
746 | | /*---------------------------------------------------------------------------- |
747 | | | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a |
748 | | | single-precision floating-point value, returning the result. After being |
749 | | | shifted into the proper positions, the three fields are simply added |
750 | | | together to form the result. This means that any integer portion of `zSig' |
751 | | | will be added into the exponent. Since a properly normalized significand |
752 | | | will have an integer portion equal to 1, the `zExp' input should be 1 less |
753 | | | than the desired result exponent whenever `zSig' is a complete, normalized |
754 | | | significand. |
755 | | *----------------------------------------------------------------------------*/ |
756 | | |
757 | | static inline float32 packFloat32(bool zSign, int zExp, uint32_t zSig) |
758 | 0 | { |
759 | 0 | return make_float32( |
760 | 0 | (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig); |
761 | 0 | } Unexecuted instantiation: softfloat.c:packFloat32 Unexecuted instantiation: fpu_helper.c:packFloat32 Unexecuted instantiation: translate.c:packFloat32 |
762 | | |
763 | | /*---------------------------------------------------------------------------- |
764 | | | The pattern for a default generated single-precision NaN. |
765 | | *----------------------------------------------------------------------------*/ |
766 | | float32 float32_default_nan(float_status *status); |
767 | | |
768 | | /*---------------------------------------------------------------------------- |
769 | | | Software IEC/IEEE double-precision conversion routines. |
770 | | *----------------------------------------------------------------------------*/ |
771 | | |
772 | | int16_t float64_to_int16_scalbn(float64, FloatRoundMode, int, float_status *); |
773 | | int32_t float64_to_int32_scalbn(float64, FloatRoundMode, int, float_status *); |
774 | | int64_t float64_to_int64_scalbn(float64, FloatRoundMode, int, float_status *); |
775 | | |
776 | | int16_t float64_to_int16(float64, float_status *status); |
777 | | int32_t float64_to_int32(float64, float_status *status); |
778 | | int64_t float64_to_int64(float64, float_status *status); |
779 | | |
780 | | int16_t float64_to_int16_round_to_zero(float64, float_status *status); |
781 | | int32_t float64_to_int32_round_to_zero(float64, float_status *status); |
782 | | int64_t float64_to_int64_round_to_zero(float64, float_status *status); |
783 | | |
784 | | int32_t float64_to_int32_modulo(float64, FloatRoundMode, float_status *status); |
785 | | int64_t float64_to_int64_modulo(float64, FloatRoundMode, float_status *status); |
786 | | |
787 | | uint16_t float64_to_uint16_scalbn(float64, FloatRoundMode, int, float_status *); |
788 | | uint32_t float64_to_uint32_scalbn(float64, FloatRoundMode, int, float_status *); |
789 | | uint64_t float64_to_uint64_scalbn(float64, FloatRoundMode, int, float_status *); |
790 | | |
791 | | uint16_t float64_to_uint16(float64, float_status *status); |
792 | | uint32_t float64_to_uint32(float64, float_status *status); |
793 | | uint64_t float64_to_uint64(float64, float_status *status); |
794 | | |
795 | | uint16_t float64_to_uint16_round_to_zero(float64, float_status *status); |
796 | | uint32_t float64_to_uint32_round_to_zero(float64, float_status *status); |
797 | | uint64_t float64_to_uint64_round_to_zero(float64, float_status *status); |
798 | | |
799 | | float32 float64_to_float32(float64, float_status *status); |
800 | | floatx80 float64_to_floatx80(float64, float_status *status); |
801 | | float128 float64_to_float128(float64, float_status *status); |
802 | | |
803 | | /*---------------------------------------------------------------------------- |
804 | | | Software IEC/IEEE double-precision operations. |
805 | | *----------------------------------------------------------------------------*/ |
806 | | float64 float64_round_to_int(float64, float_status *status); |
807 | | float64 float64_add(float64, float64, float_status *status); |
808 | | float64 float64_sub(float64, float64, float_status *status); |
809 | | float64 float64_mul(float64, float64, float_status *status); |
810 | | float64 float64_div(float64, float64, float_status *status); |
811 | | float64 float64_rem(float64, float64, float_status *status); |
812 | | float64 float64_muladd(float64, float64, float64, int, float_status *status); |
813 | | float64 float64_muladd_scalbn(float64, float64, float64, |
814 | | int, int, float_status *status); |
815 | | float64 float64_sqrt(float64, float_status *status); |
816 | | float64 float64_log2(float64, float_status *status); |
817 | | FloatRelation float64_compare(float64, float64, float_status *status); |
818 | | FloatRelation float64_compare_quiet(float64, float64, float_status *status); |
819 | | float64 float64_minmax(float64, float64, float_status *status, int flags); |
820 | | bool float64_is_quiet_nan(float64 a, float_status *status); |
821 | | bool float64_is_signaling_nan(float64, float_status *status); |
822 | | float64 float64_silence_nan(float64, float_status *status); |
823 | | float64 float64_scalbn(float64, int, float_status *status); |
824 | | |
825 | | static inline float64 float64_abs(float64 a) |
826 | 0 | { |
827 | 0 | /* Note that abs does *not* handle NaN specially, nor does |
828 | 0 | * it flush denormal inputs to zero. |
829 | 0 | */ |
830 | 0 | return make_float64(float64_val(a) & 0x7fffffffffffffffLL); |
831 | 0 | } Unexecuted instantiation: softfloat.c:float64_abs Unexecuted instantiation: fpu_helper.c:float64_abs Unexecuted instantiation: translate.c:float64_abs |
832 | | |
833 | | static inline float64 float64_chs(float64 a) |
834 | 0 | { |
835 | | /* Note that chs does *not* handle NaN specially, nor does |
836 | | * it flush denormal inputs to zero. |
837 | | */ |
838 | 0 | return make_float64(float64_val(a) ^ 0x8000000000000000LL); |
839 | 0 | } Unexecuted instantiation: softfloat.c:float64_chs Unexecuted instantiation: fpu_helper.c:float64_chs Unexecuted instantiation: translate.c:float64_chs |
840 | | |
841 | | static inline bool float64_is_infinity(float64 a) |
842 | 0 | { |
843 | 0 | return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; |
844 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_infinity Unexecuted instantiation: fpu_helper.c:float64_is_infinity Unexecuted instantiation: translate.c:float64_is_infinity |
845 | | |
846 | | static inline bool float64_is_neg(float64 a) |
847 | 0 | { |
848 | 0 | return float64_val(a) >> 63; |
849 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_neg Unexecuted instantiation: fpu_helper.c:float64_is_neg Unexecuted instantiation: translate.c:float64_is_neg |
850 | | |
851 | | static inline bool float64_is_zero(float64 a) |
852 | 0 | { |
853 | 0 | return (float64_val(a) & 0x7fffffffffffffffLL) == 0; |
854 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_zero Unexecuted instantiation: fpu_helper.c:float64_is_zero Unexecuted instantiation: translate.c:float64_is_zero |
855 | | |
856 | | static inline bool float64_is_any_nan(float64 a) |
857 | 0 | { |
858 | 0 | return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL); |
859 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_any_nan Unexecuted instantiation: fpu_helper.c:float64_is_any_nan Unexecuted instantiation: translate.c:float64_is_any_nan |
860 | | |
861 | | static inline bool float64_is_zero_or_denormal(float64 a) |
862 | 0 | { |
863 | 0 | return (float64_val(a) & 0x7ff0000000000000LL) == 0; |
864 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_zero_or_denormal Unexecuted instantiation: fpu_helper.c:float64_is_zero_or_denormal Unexecuted instantiation: translate.c:float64_is_zero_or_denormal |
865 | | |
866 | | static inline bool float64_is_normal(float64 a) |
867 | 0 | { |
868 | 0 | return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2; |
869 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_normal Unexecuted instantiation: fpu_helper.c:float64_is_normal Unexecuted instantiation: translate.c:float64_is_normal |
870 | | |
871 | | static inline bool float64_is_denormal(float64 a) |
872 | 0 | { |
873 | 0 | return float64_is_zero_or_denormal(a) && !float64_is_zero(a); |
874 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_denormal Unexecuted instantiation: fpu_helper.c:float64_is_denormal Unexecuted instantiation: translate.c:float64_is_denormal |
875 | | |
876 | | static inline bool float64_is_zero_or_normal(float64 a) |
877 | 0 | { |
878 | 0 | return float64_is_normal(a) || float64_is_zero(a); |
879 | 0 | } Unexecuted instantiation: softfloat.c:float64_is_zero_or_normal Unexecuted instantiation: fpu_helper.c:float64_is_zero_or_normal Unexecuted instantiation: translate.c:float64_is_zero_or_normal |
880 | | |
881 | | static inline float64 float64_set_sign(float64 a, int sign) |
882 | 0 | { |
883 | 0 | return make_float64((float64_val(a) & 0x7fffffffffffffffULL) |
884 | 0 | | ((int64_t)sign << 63)); |
885 | 0 | } Unexecuted instantiation: softfloat.c:float64_set_sign Unexecuted instantiation: fpu_helper.c:float64_set_sign Unexecuted instantiation: translate.c:float64_set_sign |
886 | | |
887 | | static inline bool float64_eq(float64 a, float64 b, float_status *s) |
888 | 0 | { |
889 | 0 | return float64_compare(a, b, s) == float_relation_equal; |
890 | 0 | } Unexecuted instantiation: softfloat.c:float64_eq Unexecuted instantiation: fpu_helper.c:float64_eq Unexecuted instantiation: translate.c:float64_eq |
891 | | |
892 | | static inline bool float64_le(float64 a, float64 b, float_status *s) |
893 | 0 | { |
894 | 0 | return float64_compare(a, b, s) <= float_relation_equal; |
895 | 0 | } Unexecuted instantiation: softfloat.c:float64_le Unexecuted instantiation: fpu_helper.c:float64_le Unexecuted instantiation: translate.c:float64_le |
896 | | |
897 | | static inline bool float64_lt(float64 a, float64 b, float_status *s) |
898 | 0 | { |
899 | 0 | return float64_compare(a, b, s) < float_relation_equal; |
900 | 0 | } Unexecuted instantiation: softfloat.c:float64_lt Unexecuted instantiation: fpu_helper.c:float64_lt Unexecuted instantiation: translate.c:float64_lt |
901 | | |
902 | | static inline bool float64_unordered(float64 a, float64 b, float_status *s) |
903 | 0 | { |
904 | 0 | return float64_compare(a, b, s) == float_relation_unordered; |
905 | 0 | } Unexecuted instantiation: softfloat.c:float64_unordered Unexecuted instantiation: fpu_helper.c:float64_unordered Unexecuted instantiation: translate.c:float64_unordered |
906 | | |
907 | | static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s) |
908 | 0 | { |
909 | 0 | return float64_compare_quiet(a, b, s) == float_relation_equal; |
910 | 0 | } Unexecuted instantiation: softfloat.c:float64_eq_quiet Unexecuted instantiation: fpu_helper.c:float64_eq_quiet Unexecuted instantiation: translate.c:float64_eq_quiet |
911 | | |
912 | | static inline bool float64_le_quiet(float64 a, float64 b, float_status *s) |
913 | 0 | { |
914 | 0 | return float64_compare_quiet(a, b, s) <= float_relation_equal; |
915 | 0 | } Unexecuted instantiation: softfloat.c:float64_le_quiet Unexecuted instantiation: fpu_helper.c:float64_le_quiet Unexecuted instantiation: translate.c:float64_le_quiet |
916 | | |
917 | | static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s) |
918 | 0 | { |
919 | 0 | return float64_compare_quiet(a, b, s) < float_relation_equal; |
920 | 0 | } Unexecuted instantiation: softfloat.c:float64_lt_quiet Unexecuted instantiation: fpu_helper.c:float64_lt_quiet Unexecuted instantiation: translate.c:float64_lt_quiet |
921 | | |
922 | | static inline bool float64_unordered_quiet(float64 a, float64 b, |
923 | | float_status *s) |
924 | 0 | { |
925 | 0 | return float64_compare_quiet(a, b, s) == float_relation_unordered; |
926 | 0 | } Unexecuted instantiation: softfloat.c:float64_unordered_quiet Unexecuted instantiation: fpu_helper.c:float64_unordered_quiet Unexecuted instantiation: translate.c:float64_unordered_quiet |
927 | | |
928 | 0 | #define float64_zero make_float64(0) |
929 | | #define float64_half make_float64(0x3fe0000000000000LL) |
930 | 0 | #define float64_one make_float64(0x3ff0000000000000LL) |
931 | | #define float64_one_point_five make_float64(0x3FF8000000000000ULL) |
932 | | #define float64_two make_float64(0x4000000000000000ULL) |
933 | | #define float64_three make_float64(0x4008000000000000ULL) |
934 | 0 | #define float64_ln2 make_float64(0x3fe62e42fefa39efLL) |
935 | | #define float64_infinity make_float64(0x7ff0000000000000LL) |
936 | | |
937 | | /*---------------------------------------------------------------------------- |
938 | | | The pattern for a default generated double-precision NaN. |
939 | | *----------------------------------------------------------------------------*/ |
940 | | float64 float64_default_nan(float_status *status); |
941 | | |
942 | | /*---------------------------------------------------------------------------- |
943 | | | Software IEC/IEEE double-precision operations, rounding to single precision, |
944 | | | returning a result in double precision, with only one rounding step. |
945 | | *----------------------------------------------------------------------------*/ |
946 | | |
947 | | float64 float64r32_add(float64, float64, float_status *status); |
948 | | float64 float64r32_sub(float64, float64, float_status *status); |
949 | | float64 float64r32_mul(float64, float64, float_status *status); |
950 | | float64 float64r32_div(float64, float64, float_status *status); |
951 | | float64 float64r32_muladd(float64, float64, float64, int, float_status *status); |
952 | | float64 float64r32_sqrt(float64, float_status *status); |
953 | | |
954 | | /*---------------------------------------------------------------------------- |
955 | | | Software IEC/IEEE extended double-precision conversion routines. |
956 | | *----------------------------------------------------------------------------*/ |
957 | | int32_t floatx80_to_int32(floatx80, float_status *status); |
958 | | int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status); |
959 | | int64_t floatx80_to_int64(floatx80, float_status *status); |
960 | | int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status); |
961 | | float32 floatx80_to_float32(floatx80, float_status *status); |
962 | | float64 floatx80_to_float64(floatx80, float_status *status); |
963 | | float128 floatx80_to_float128(floatx80, float_status *status); |
964 | | |
965 | | /*---------------------------------------------------------------------------- |
966 | | | The pattern for an extended double-precision inf. |
967 | | *----------------------------------------------------------------------------*/ |
968 | | floatx80 floatx80_default_inf(bool zSign, float_status *status); |
969 | | |
970 | | /*---------------------------------------------------------------------------- |
971 | | | Software IEC/IEEE extended double-precision operations. |
972 | | *----------------------------------------------------------------------------*/ |
973 | | floatx80 floatx80_round(floatx80 a, float_status *status); |
974 | | floatx80 floatx80_round_to_int(floatx80, float_status *status); |
975 | | floatx80 floatx80_add(floatx80, floatx80, float_status *status); |
976 | | floatx80 floatx80_sub(floatx80, floatx80, float_status *status); |
977 | | floatx80 floatx80_mul(floatx80, floatx80, float_status *status); |
978 | | floatx80 floatx80_div(floatx80, floatx80, float_status *status); |
979 | | floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *, |
980 | | float_status *status); |
981 | | floatx80 floatx80_mod(floatx80, floatx80, float_status *status); |
982 | | floatx80 floatx80_rem(floatx80, floatx80, float_status *status); |
983 | | floatx80 floatx80_sqrt(floatx80, float_status *status); |
984 | | FloatRelation floatx80_compare(floatx80, floatx80, float_status *status); |
985 | | FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status); |
986 | | bool floatx80_is_quiet_nan(floatx80, float_status *status); |
987 | | bool floatx80_is_signaling_nan(floatx80, float_status *status); |
988 | | floatx80 floatx80_silence_nan(floatx80, float_status *status); |
989 | | floatx80 floatx80_scalbn(floatx80, int, float_status *status); |
990 | | |
991 | | static inline floatx80 floatx80_abs(floatx80 a) |
992 | 0 | { |
993 | 0 | a.high &= 0x7fff; |
994 | 0 | return a; |
995 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_abs Unexecuted instantiation: fpu_helper.c:floatx80_abs Unexecuted instantiation: translate.c:floatx80_abs |
996 | | |
997 | | static inline floatx80 floatx80_chs(floatx80 a) |
998 | 0 | { |
999 | 0 | a.high ^= 0x8000; |
1000 | 0 | return a; |
1001 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_chs Unexecuted instantiation: fpu_helper.c:floatx80_chs Unexecuted instantiation: translate.c:floatx80_chs |
1002 | | |
1003 | | static inline bool floatx80_is_infinity(floatx80 a, float_status *status) |
1004 | 0 | { |
1005 | | /* |
1006 | | * It's target-specific whether the Integer bit is permitted |
1007 | | * to be 0 in a valid Infinity value. (x86 says no, m68k says yes). |
1008 | | */ |
1009 | 0 | bool intbit = a.low >> 63; |
1010 | |
|
1011 | 0 | if (!intbit && |
1012 | 0 | !(get_floatx80_behaviour(status) & floatx80_pseudo_inf_valid)) { |
1013 | 0 | return false; |
1014 | 0 | } |
1015 | 0 | return (a.high & 0x7fff) == 0x7fff && !(a.low << 1); |
1016 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_is_infinity Unexecuted instantiation: fpu_helper.c:floatx80_is_infinity Unexecuted instantiation: translate.c:floatx80_is_infinity |
1017 | | |
1018 | | static inline bool floatx80_is_neg(floatx80 a) |
1019 | 0 | { |
1020 | 0 | return a.high >> 15; |
1021 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_is_neg Unexecuted instantiation: fpu_helper.c:floatx80_is_neg Unexecuted instantiation: translate.c:floatx80_is_neg |
1022 | | |
1023 | | static inline bool floatx80_is_zero(floatx80 a) |
1024 | 0 | { |
1025 | 0 | return (a.high & 0x7fff) == 0 && a.low == 0; |
1026 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_is_zero Unexecuted instantiation: fpu_helper.c:floatx80_is_zero Unexecuted instantiation: translate.c:floatx80_is_zero |
1027 | | |
1028 | | static inline bool floatx80_is_zero_or_denormal(floatx80 a) |
1029 | 0 | { |
1030 | 0 | return (a.high & 0x7fff) == 0; |
1031 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_is_zero_or_denormal Unexecuted instantiation: fpu_helper.c:floatx80_is_zero_or_denormal Unexecuted instantiation: translate.c:floatx80_is_zero_or_denormal |
1032 | | |
1033 | | static inline bool floatx80_is_any_nan(floatx80 a) |
1034 | 0 | { |
1035 | 0 | return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); |
1036 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_is_any_nan Unexecuted instantiation: fpu_helper.c:floatx80_is_any_nan Unexecuted instantiation: translate.c:floatx80_is_any_nan |
1037 | | |
1038 | | static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s) |
1039 | 0 | { |
1040 | 0 | return floatx80_compare(a, b, s) == float_relation_equal; |
1041 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_eq Unexecuted instantiation: fpu_helper.c:floatx80_eq Unexecuted instantiation: translate.c:floatx80_eq |
1042 | | |
1043 | | static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s) |
1044 | 0 | { |
1045 | 0 | return floatx80_compare(a, b, s) <= float_relation_equal; |
1046 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_le Unexecuted instantiation: fpu_helper.c:floatx80_le Unexecuted instantiation: translate.c:floatx80_le |
1047 | | |
1048 | | static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s) |
1049 | 0 | { |
1050 | 0 | return floatx80_compare(a, b, s) < float_relation_equal; |
1051 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_lt Unexecuted instantiation: fpu_helper.c:floatx80_lt Unexecuted instantiation: translate.c:floatx80_lt |
1052 | | |
1053 | | static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s) |
1054 | 0 | { |
1055 | 0 | return floatx80_compare(a, b, s) == float_relation_unordered; |
1056 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_unordered Unexecuted instantiation: fpu_helper.c:floatx80_unordered Unexecuted instantiation: translate.c:floatx80_unordered |
1057 | | |
1058 | | static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s) |
1059 | 0 | { |
1060 | 0 | return floatx80_compare_quiet(a, b, s) == float_relation_equal; |
1061 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_eq_quiet Unexecuted instantiation: fpu_helper.c:floatx80_eq_quiet Unexecuted instantiation: translate.c:floatx80_eq_quiet |
1062 | | |
1063 | | static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s) |
1064 | 0 | { |
1065 | 0 | return floatx80_compare_quiet(a, b, s) <= float_relation_equal; |
1066 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_le_quiet Unexecuted instantiation: fpu_helper.c:floatx80_le_quiet Unexecuted instantiation: translate.c:floatx80_le_quiet |
1067 | | |
1068 | | static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s) |
1069 | 0 | { |
1070 | 0 | return floatx80_compare_quiet(a, b, s) < float_relation_equal; |
1071 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_lt_quiet Unexecuted instantiation: fpu_helper.c:floatx80_lt_quiet Unexecuted instantiation: translate.c:floatx80_lt_quiet |
1072 | | |
1073 | | static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b, |
1074 | | float_status *s) |
1075 | 0 | { |
1076 | 0 | return floatx80_compare_quiet(a, b, s) == float_relation_unordered; |
1077 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_unordered_quiet Unexecuted instantiation: fpu_helper.c:floatx80_unordered_quiet Unexecuted instantiation: translate.c:floatx80_unordered_quiet |
1078 | | |
1079 | | /*---------------------------------------------------------------------------- |
1080 | | | Return whether the given value is an invalid floatx80 encoding. |
1081 | | | Invalid floatx80 encodings may arise when the integer bit is not set |
1082 | | | correctly; this is target-specific. In Intel terminology the |
1083 | | | categories are: |
1084 | | | exp == 0, int = 0, mantissa == 0 : zeroes |
1085 | | | exp == 0, int = 0, mantissa != 0 : denormals |
1086 | | | exp == 0, int = 1 : pseudo-denormals |
1087 | | | 0 < exp < 0x7fff, int = 0 : unnormals |
1088 | | | 0 < exp < 0x7fff, int = 1 : normals |
1089 | | | exp == 0x7fff, int = 0, mantissa == 0 : pseudo-infinities |
1090 | | | exp == 0x7fff, int = 1, mantissa == 0 : infinities |
1091 | | | exp == 0x7fff, int = 0, mantissa != 0 : pseudo-NaNs |
1092 | | | exp == 0x7fff, int = 1, mantissa == 0 : NaNs |
1093 | | | |
1094 | | | The usual IEEE cases of zero, denormal, normal, inf and NaN are always valid. |
1095 | | | x87 permits as input also pseudo-denormals. |
1096 | | | m68k permits all those and also pseudo-infinities, pseudo-NaNs and unnormals. |
1097 | | | |
1098 | | | Since we don't have a target that handles floatx80 but prohibits |
1099 | | | pseudo-denormals in input, we don't currently have a floatx80_behaviour |
1100 | | | flag for that case, but instead always accept it. Conveniently this |
1101 | | | means that all cases with either exponent 0 or the integer bit set are |
1102 | | | valid for all targets. |
1103 | | *----------------------------------------------------------------------------*/ |
1104 | | static inline bool floatx80_invalid_encoding(floatx80 a, float_status *s) |
1105 | 0 | { |
1106 | 0 | FloatX80Behaviour rule = get_floatx80_behaviour(s); |
1107 | |
|
1108 | 0 | if ((a.low >> 63) || (a.high & 0x7fff) == 0) { |
1109 | | /* Anything with the Integer bit set or the exponent 0 is valid */ |
1110 | 0 | return false; |
1111 | 0 | } |
1112 | | |
1113 | 0 | if ((a.high & 0x7fff) == 0x7fff) { |
1114 | 0 | if (a.low) { |
1115 | 0 | return !(rule & floatx80_pseudo_nan_valid); |
1116 | 0 | } else { |
1117 | 0 | return !(rule & floatx80_pseudo_inf_valid); |
1118 | 0 | } |
1119 | 0 | } else { |
1120 | 0 | return !(rule & floatx80_unnormal_valid); |
1121 | 0 | } |
1122 | 0 | } Unexecuted instantiation: softfloat.c:floatx80_invalid_encoding Unexecuted instantiation: fpu_helper.c:floatx80_invalid_encoding Unexecuted instantiation: translate.c:floatx80_invalid_encoding |
1123 | | |
1124 | 0 | #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) |
1125 | | #define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL) |
1126 | 0 | #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL) |
1127 | 0 | #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) |
1128 | 0 | #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) |
1129 | | #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) |
1130 | | |
1131 | | /*---------------------------------------------------------------------------- |
1132 | | | Returns the fraction bits of the extended double-precision floating-point |
1133 | | | value `a'. |
1134 | | *----------------------------------------------------------------------------*/ |
1135 | | |
1136 | | static inline uint64_t extractFloatx80Frac(floatx80 a) |
1137 | 0 | { |
1138 | 0 | return a.low; |
1139 | 0 | } Unexecuted instantiation: softfloat.c:extractFloatx80Frac Unexecuted instantiation: fpu_helper.c:extractFloatx80Frac Unexecuted instantiation: translate.c:extractFloatx80Frac |
1140 | | |
1141 | | /*---------------------------------------------------------------------------- |
1142 | | | Returns the exponent bits of the extended double-precision floating-point |
1143 | | | value `a'. |
1144 | | *----------------------------------------------------------------------------*/ |
1145 | | |
1146 | | static inline int32_t extractFloatx80Exp(floatx80 a) |
1147 | 0 | { |
1148 | 0 | return a.high & 0x7FFF; |
1149 | 0 | } Unexecuted instantiation: softfloat.c:extractFloatx80Exp Unexecuted instantiation: fpu_helper.c:extractFloatx80Exp Unexecuted instantiation: translate.c:extractFloatx80Exp |
1150 | | |
1151 | | /*---------------------------------------------------------------------------- |
1152 | | | Returns the sign bit of the extended double-precision floating-point value |
1153 | | | `a'. |
1154 | | *----------------------------------------------------------------------------*/ |
1155 | | |
1156 | | static inline bool extractFloatx80Sign(floatx80 a) |
1157 | 0 | { |
1158 | 0 | return a.high >> 15; |
1159 | 0 | } Unexecuted instantiation: softfloat.c:extractFloatx80Sign Unexecuted instantiation: fpu_helper.c:extractFloatx80Sign Unexecuted instantiation: translate.c:extractFloatx80Sign |
1160 | | |
1161 | | /*---------------------------------------------------------------------------- |
1162 | | | Packs the sign `zSign', exponent `zExp', and significand `zSig' into an |
1163 | | | extended double-precision floating-point value, returning the result. |
1164 | | *----------------------------------------------------------------------------*/ |
1165 | | |
1166 | | static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig) |
1167 | 0 | { |
1168 | 0 | floatx80 z; |
1169 | |
|
1170 | 0 | z.low = zSig; |
1171 | 0 | z.high = (((uint16_t)zSign) << 15) + zExp; |
1172 | 0 | return z; |
1173 | 0 | } Unexecuted instantiation: softfloat.c:packFloatx80 Unexecuted instantiation: fpu_helper.c:packFloatx80 Unexecuted instantiation: translate.c:packFloatx80 |
1174 | | |
1175 | | /*---------------------------------------------------------------------------- |
1176 | | | Normalizes the subnormal extended double-precision floating-point value |
1177 | | | represented by the denormalized significand `aSig'. The normalized exponent |
1178 | | | and significand are stored at the locations pointed to by `zExpPtr' and |
1179 | | | `zSigPtr', respectively. |
1180 | | *----------------------------------------------------------------------------*/ |
1181 | | |
1182 | | void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr, |
1183 | | uint64_t *zSigPtr); |
1184 | | |
1185 | | /*---------------------------------------------------------------------------- |
1186 | | | Takes two extended double-precision floating-point values `a' and `b', one |
1187 | | | of which is a NaN, and returns the appropriate NaN result. If either `a' or |
1188 | | | `b' is a signaling NaN, the invalid exception is raised. |
1189 | | *----------------------------------------------------------------------------*/ |
1190 | | |
1191 | | floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status); |
1192 | | |
1193 | | /*---------------------------------------------------------------------------- |
1194 | | | Takes an abstract floating-point value having sign `zSign', exponent `zExp', |
1195 | | | and extended significand formed by the concatenation of `zSig0' and `zSig1', |
1196 | | | and returns the proper extended double-precision floating-point value |
1197 | | | corresponding to the abstract input. Ordinarily, the abstract value is |
1198 | | | rounded and packed into the extended double-precision format, with the |
1199 | | | inexact exception raised if the abstract input cannot be represented |
1200 | | | exactly. However, if the abstract value is too large, the overflow and |
1201 | | | inexact exceptions are raised and an infinity or maximal finite value is |
1202 | | | returned. If the abstract value is too small, the input value is rounded to |
1203 | | | a subnormal number, and the underflow and inexact exceptions are raised if |
1204 | | | the abstract input cannot be represented exactly as a subnormal extended |
1205 | | | double-precision floating-point number. |
1206 | | | If `roundingPrecision' is 32 or 64, the result is rounded to the same |
1207 | | | number of bits as single or double precision, respectively. Otherwise, the |
1208 | | | result is rounded to the full precision of the extended double-precision |
1209 | | | format. |
1210 | | | The input significand must be normalized or smaller. If the input |
1211 | | | significand is not normalized, `zExp' must be 0; in that case, the result |
1212 | | | returned is a subnormal number, and it must not require rounding. The |
1213 | | | handling of underflow and overflow follows the IEC/IEEE Standard for Binary |
1214 | | | Floating-Point Arithmetic. |
1215 | | *----------------------------------------------------------------------------*/ |
1216 | | |
1217 | | floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign, |
1218 | | int32_t zExp, uint64_t zSig0, uint64_t zSig1, |
1219 | | float_status *status); |
1220 | | |
1221 | | /*---------------------------------------------------------------------------- |
1222 | | | Takes an abstract floating-point value having sign `zSign', exponent |
1223 | | | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1', |
1224 | | | and returns the proper extended double-precision floating-point value |
1225 | | | corresponding to the abstract input. This routine is just like |
1226 | | | `roundAndPackFloatx80' except that the input significand does not have to be |
1227 | | | normalized. |
1228 | | *----------------------------------------------------------------------------*/ |
1229 | | |
1230 | | floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, |
1231 | | bool zSign, int32_t zExp, |
1232 | | uint64_t zSig0, uint64_t zSig1, |
1233 | | float_status *status); |
1234 | | |
1235 | | /*---------------------------------------------------------------------------- |
1236 | | | The pattern for a default generated extended double-precision NaN. |
1237 | | *----------------------------------------------------------------------------*/ |
1238 | | floatx80 floatx80_default_nan(float_status *status); |
1239 | | |
1240 | | /*---------------------------------------------------------------------------- |
1241 | | | Software IEC/IEEE quadruple-precision conversion routines. |
1242 | | *----------------------------------------------------------------------------*/ |
1243 | | int32_t float128_to_int32(float128, float_status *status); |
1244 | | int32_t float128_to_int32_round_to_zero(float128, float_status *status); |
1245 | | int64_t float128_to_int64(float128, float_status *status); |
1246 | | Int128 float128_to_int128(float128, float_status *status); |
1247 | | int64_t float128_to_int64_round_to_zero(float128, float_status *status); |
1248 | | Int128 float128_to_int128_round_to_zero(float128, float_status *status); |
1249 | | uint64_t float128_to_uint64(float128, float_status *status); |
1250 | | Int128 float128_to_uint128(float128, float_status *status); |
1251 | | uint64_t float128_to_uint64_round_to_zero(float128, float_status *status); |
1252 | | Int128 float128_to_uint128_round_to_zero(float128, float_status *status); |
1253 | | uint32_t float128_to_uint32(float128, float_status *status); |
1254 | | uint32_t float128_to_uint32_round_to_zero(float128, float_status *status); |
1255 | | float32 float128_to_float32(float128, float_status *status); |
1256 | | float64 float128_to_float64(float128, float_status *status); |
1257 | | floatx80 float128_to_floatx80(float128, float_status *status); |
1258 | | |
1259 | | /*---------------------------------------------------------------------------- |
1260 | | | Software IEC/IEEE quadruple-precision operations. |
1261 | | *----------------------------------------------------------------------------*/ |
1262 | | float128 float128_round_to_int(float128, float_status *status); |
1263 | | float128 float128_add(float128, float128, float_status *status); |
1264 | | float128 float128_sub(float128, float128, float_status *status); |
1265 | | float128 float128_mul(float128, float128, float_status *status); |
1266 | | float128 float128_muladd(float128, float128, float128, int, |
1267 | | float_status *status); |
1268 | | float128 float128_div(float128, float128, float_status *status); |
1269 | | float128 float128_rem(float128, float128, float_status *status); |
1270 | | float128 float128_sqrt(float128, float_status *status); |
1271 | | FloatRelation float128_compare(float128, float128, float_status *status); |
1272 | | FloatRelation float128_compare_quiet(float128, float128, float_status *status); |
1273 | | float128 float128_minmax(float128, float128, float_status *status, int flags); |
1274 | | bool float128_is_quiet_nan(float128, float_status *status); |
1275 | | bool float128_is_signaling_nan(float128, float_status *status); |
1276 | | float128 float128_silence_nan(float128, float_status *status); |
1277 | | float128 float128_scalbn(float128, int, float_status *status); |
1278 | | |
1279 | | static inline float128 float128_abs(float128 a) |
1280 | 0 | { |
1281 | 0 | a.high &= 0x7fffffffffffffffLL; |
1282 | 0 | return a; |
1283 | 0 | } Unexecuted instantiation: softfloat.c:float128_abs Unexecuted instantiation: fpu_helper.c:float128_abs Unexecuted instantiation: translate.c:float128_abs |
1284 | | |
1285 | | static inline float128 float128_chs(float128 a) |
1286 | 0 | { |
1287 | 0 | a.high ^= 0x8000000000000000LL; |
1288 | 0 | return a; |
1289 | 0 | } Unexecuted instantiation: softfloat.c:float128_chs Unexecuted instantiation: fpu_helper.c:float128_chs Unexecuted instantiation: translate.c:float128_chs |
1290 | | |
1291 | | static inline bool float128_is_infinity(float128 a) |
1292 | 0 | { |
1293 | 0 | return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; |
1294 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_infinity Unexecuted instantiation: fpu_helper.c:float128_is_infinity Unexecuted instantiation: translate.c:float128_is_infinity |
1295 | | |
1296 | | static inline bool float128_is_neg(float128 a) |
1297 | 0 | { |
1298 | 0 | return a.high >> 63; |
1299 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_neg Unexecuted instantiation: fpu_helper.c:float128_is_neg Unexecuted instantiation: translate.c:float128_is_neg |
1300 | | |
1301 | | static inline bool float128_is_zero(float128 a) |
1302 | 0 | { |
1303 | 0 | return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; |
1304 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_zero Unexecuted instantiation: fpu_helper.c:float128_is_zero Unexecuted instantiation: translate.c:float128_is_zero |
1305 | | |
1306 | | static inline bool float128_is_zero_or_denormal(float128 a) |
1307 | 0 | { |
1308 | 0 | return (a.high & 0x7fff000000000000LL) == 0; |
1309 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_zero_or_denormal Unexecuted instantiation: fpu_helper.c:float128_is_zero_or_denormal Unexecuted instantiation: translate.c:float128_is_zero_or_denormal |
1310 | | |
1311 | | static inline bool float128_is_normal(float128 a) |
1312 | 0 | { |
1313 | 0 | return (((a.high >> 48) + 1) & 0x7fff) >= 2; |
1314 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_normal Unexecuted instantiation: fpu_helper.c:float128_is_normal Unexecuted instantiation: translate.c:float128_is_normal |
1315 | | |
1316 | | static inline bool float128_is_denormal(float128 a) |
1317 | 0 | { |
1318 | 0 | return float128_is_zero_or_denormal(a) && !float128_is_zero(a); |
1319 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_denormal Unexecuted instantiation: fpu_helper.c:float128_is_denormal Unexecuted instantiation: translate.c:float128_is_denormal |
1320 | | |
1321 | | static inline bool float128_is_any_nan(float128 a) |
1322 | 0 | { |
1323 | 0 | return ((a.high >> 48) & 0x7fff) == 0x7fff && |
1324 | 0 | ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0)); |
1325 | 0 | } Unexecuted instantiation: softfloat.c:float128_is_any_nan Unexecuted instantiation: fpu_helper.c:float128_is_any_nan Unexecuted instantiation: translate.c:float128_is_any_nan |
1326 | | |
1327 | | static inline bool float128_eq(float128 a, float128 b, float_status *s) |
1328 | 0 | { |
1329 | 0 | return float128_compare(a, b, s) == float_relation_equal; |
1330 | 0 | } Unexecuted instantiation: softfloat.c:float128_eq Unexecuted instantiation: fpu_helper.c:float128_eq Unexecuted instantiation: translate.c:float128_eq |
1331 | | |
1332 | | static inline bool float128_le(float128 a, float128 b, float_status *s) |
1333 | 0 | { |
1334 | 0 | return float128_compare(a, b, s) <= float_relation_equal; |
1335 | 0 | } Unexecuted instantiation: softfloat.c:float128_le Unexecuted instantiation: fpu_helper.c:float128_le Unexecuted instantiation: translate.c:float128_le |
1336 | | |
1337 | | static inline bool float128_lt(float128 a, float128 b, float_status *s) |
1338 | 0 | { |
1339 | 0 | return float128_compare(a, b, s) < float_relation_equal; |
1340 | 0 | } Unexecuted instantiation: softfloat.c:float128_lt Unexecuted instantiation: fpu_helper.c:float128_lt Unexecuted instantiation: translate.c:float128_lt |
1341 | | |
1342 | | static inline bool float128_unordered(float128 a, float128 b, float_status *s) |
1343 | 0 | { |
1344 | 0 | return float128_compare(a, b, s) == float_relation_unordered; |
1345 | 0 | } Unexecuted instantiation: softfloat.c:float128_unordered Unexecuted instantiation: fpu_helper.c:float128_unordered Unexecuted instantiation: translate.c:float128_unordered |
1346 | | |
1347 | | static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s) |
1348 | 0 | { |
1349 | 0 | return float128_compare_quiet(a, b, s) == float_relation_equal; |
1350 | 0 | } Unexecuted instantiation: softfloat.c:float128_eq_quiet Unexecuted instantiation: fpu_helper.c:float128_eq_quiet Unexecuted instantiation: translate.c:float128_eq_quiet |
1351 | | |
1352 | | static inline bool float128_le_quiet(float128 a, float128 b, float_status *s) |
1353 | 0 | { |
1354 | 0 | return float128_compare_quiet(a, b, s) <= float_relation_equal; |
1355 | 0 | } Unexecuted instantiation: softfloat.c:float128_le_quiet Unexecuted instantiation: fpu_helper.c:float128_le_quiet Unexecuted instantiation: translate.c:float128_le_quiet |
1356 | | |
1357 | | static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s) |
1358 | 0 | { |
1359 | 0 | return float128_compare_quiet(a, b, s) < float_relation_equal; |
1360 | 0 | } Unexecuted instantiation: softfloat.c:float128_lt_quiet Unexecuted instantiation: fpu_helper.c:float128_lt_quiet Unexecuted instantiation: translate.c:float128_lt_quiet |
1361 | | |
1362 | | static inline bool float128_unordered_quiet(float128 a, float128 b, |
1363 | | float_status *s) |
1364 | 0 | { |
1365 | 0 | return float128_compare_quiet(a, b, s) == float_relation_unordered; |
1366 | 0 | } Unexecuted instantiation: softfloat.c:float128_unordered_quiet Unexecuted instantiation: fpu_helper.c:float128_unordered_quiet Unexecuted instantiation: translate.c:float128_unordered_quiet |
1367 | | |
1368 | | #define float128_zero make_float128(0, 0) |
1369 | | |
1370 | | /*---------------------------------------------------------------------------- |
1371 | | | The pattern for a default generated quadruple-precision NaN. |
1372 | | *----------------------------------------------------------------------------*/ |
1373 | | float128 float128_default_nan(float_status *status); |
1374 | | |
1375 | | /*---------------------------------------------------------------------------- |
1376 | | | Minumum and maximum functions. |
1377 | | *----------------------------------------------------------------------------*/ |
1378 | | |
1379 | | #define MINMAX_1(type, name, flags) \ |
1380 | | static inline type type##_##name(type a, type b, float_status *s) \ |
1381 | 0 | { return type##_minmax(a, b, s, flags); }Unexecuted instantiation: softfloat.c:float16_max Unexecuted instantiation: softfloat.c:float16_maxnum Unexecuted instantiation: softfloat.c:float16_maxnummag Unexecuted instantiation: softfloat.c:float16_maximum_number Unexecuted instantiation: softfloat.c:float16_min Unexecuted instantiation: softfloat.c:float16_minnum Unexecuted instantiation: softfloat.c:float16_minnummag Unexecuted instantiation: softfloat.c:float16_minimum_number Unexecuted instantiation: softfloat.c:bfloat16_max Unexecuted instantiation: softfloat.c:bfloat16_maxnum Unexecuted instantiation: softfloat.c:bfloat16_maxnummag Unexecuted instantiation: softfloat.c:bfloat16_maximum_number Unexecuted instantiation: softfloat.c:bfloat16_min Unexecuted instantiation: softfloat.c:bfloat16_minnum Unexecuted instantiation: softfloat.c:bfloat16_minnummag Unexecuted instantiation: softfloat.c:bfloat16_minimum_number Unexecuted instantiation: softfloat.c:float32_max Unexecuted instantiation: softfloat.c:float32_maxnum Unexecuted instantiation: softfloat.c:float32_maxnummag Unexecuted instantiation: softfloat.c:float32_maximum_number Unexecuted instantiation: softfloat.c:float32_min Unexecuted instantiation: softfloat.c:float32_minnum Unexecuted instantiation: softfloat.c:float32_minnummag Unexecuted instantiation: softfloat.c:float32_minimum_number Unexecuted instantiation: softfloat.c:float64_max Unexecuted instantiation: softfloat.c:float64_maxnum Unexecuted instantiation: softfloat.c:float64_maxnummag Unexecuted instantiation: softfloat.c:float64_maximum_number Unexecuted instantiation: softfloat.c:float64_min Unexecuted instantiation: softfloat.c:float64_minnum Unexecuted instantiation: softfloat.c:float64_minnummag Unexecuted instantiation: softfloat.c:float64_minimum_number Unexecuted instantiation: softfloat.c:float128_max Unexecuted instantiation: softfloat.c:float128_maxnum Unexecuted instantiation: softfloat.c:float128_maxnummag Unexecuted instantiation: softfloat.c:float128_maximum_number Unexecuted instantiation: softfloat.c:float128_min Unexecuted instantiation: softfloat.c:float128_minnum Unexecuted instantiation: softfloat.c:float128_minnummag Unexecuted instantiation: softfloat.c:float128_minimum_number Unexecuted instantiation: fpu_helper.c:float16_max Unexecuted instantiation: fpu_helper.c:float16_maxnum Unexecuted instantiation: fpu_helper.c:float16_maxnummag Unexecuted instantiation: fpu_helper.c:float16_maximum_number Unexecuted instantiation: fpu_helper.c:float16_min Unexecuted instantiation: fpu_helper.c:float16_minnum Unexecuted instantiation: fpu_helper.c:float16_minnummag Unexecuted instantiation: fpu_helper.c:float16_minimum_number Unexecuted instantiation: fpu_helper.c:bfloat16_max Unexecuted instantiation: fpu_helper.c:bfloat16_maxnum Unexecuted instantiation: fpu_helper.c:bfloat16_maxnummag Unexecuted instantiation: fpu_helper.c:bfloat16_maximum_number Unexecuted instantiation: fpu_helper.c:bfloat16_min Unexecuted instantiation: fpu_helper.c:bfloat16_minnum Unexecuted instantiation: fpu_helper.c:bfloat16_minnummag Unexecuted instantiation: fpu_helper.c:bfloat16_minimum_number Unexecuted instantiation: fpu_helper.c:float32_max Unexecuted instantiation: fpu_helper.c:float32_maxnum Unexecuted instantiation: fpu_helper.c:float32_maxnummag Unexecuted instantiation: fpu_helper.c:float32_maximum_number Unexecuted instantiation: fpu_helper.c:float32_min Unexecuted instantiation: fpu_helper.c:float32_minnum Unexecuted instantiation: fpu_helper.c:float32_minnummag Unexecuted instantiation: fpu_helper.c:float32_minimum_number Unexecuted instantiation: fpu_helper.c:float64_max Unexecuted instantiation: fpu_helper.c:float64_maxnum Unexecuted instantiation: fpu_helper.c:float64_maxnummag Unexecuted instantiation: fpu_helper.c:float64_maximum_number Unexecuted instantiation: fpu_helper.c:float64_min Unexecuted instantiation: fpu_helper.c:float64_minnum Unexecuted instantiation: fpu_helper.c:float64_minnummag Unexecuted instantiation: fpu_helper.c:float64_minimum_number Unexecuted instantiation: fpu_helper.c:float128_max Unexecuted instantiation: fpu_helper.c:float128_maxnum Unexecuted instantiation: fpu_helper.c:float128_maxnummag Unexecuted instantiation: fpu_helper.c:float128_maximum_number Unexecuted instantiation: fpu_helper.c:float128_min Unexecuted instantiation: fpu_helper.c:float128_minnum Unexecuted instantiation: fpu_helper.c:float128_minnummag Unexecuted instantiation: fpu_helper.c:float128_minimum_number Unexecuted instantiation: translate.c:float16_max Unexecuted instantiation: translate.c:float16_maxnum Unexecuted instantiation: translate.c:float16_maxnummag Unexecuted instantiation: translate.c:float16_maximum_number Unexecuted instantiation: translate.c:float16_min Unexecuted instantiation: translate.c:float16_minnum Unexecuted instantiation: translate.c:float16_minnummag Unexecuted instantiation: translate.c:float16_minimum_number Unexecuted instantiation: translate.c:bfloat16_max Unexecuted instantiation: translate.c:bfloat16_maxnum Unexecuted instantiation: translate.c:bfloat16_maxnummag Unexecuted instantiation: translate.c:bfloat16_maximum_number Unexecuted instantiation: translate.c:bfloat16_min Unexecuted instantiation: translate.c:bfloat16_minnum Unexecuted instantiation: translate.c:bfloat16_minnummag Unexecuted instantiation: translate.c:bfloat16_minimum_number Unexecuted instantiation: translate.c:float32_max Unexecuted instantiation: translate.c:float32_maxnum Unexecuted instantiation: translate.c:float32_maxnummag Unexecuted instantiation: translate.c:float32_maximum_number Unexecuted instantiation: translate.c:float32_min Unexecuted instantiation: translate.c:float32_minnum Unexecuted instantiation: translate.c:float32_minnummag Unexecuted instantiation: translate.c:float32_minimum_number Unexecuted instantiation: translate.c:float64_max Unexecuted instantiation: translate.c:float64_maxnum Unexecuted instantiation: translate.c:float64_maxnummag Unexecuted instantiation: translate.c:float64_maximum_number Unexecuted instantiation: translate.c:float64_min Unexecuted instantiation: translate.c:float64_minnum Unexecuted instantiation: translate.c:float64_minnummag Unexecuted instantiation: translate.c:float64_minimum_number Unexecuted instantiation: translate.c:float128_max Unexecuted instantiation: translate.c:float128_maxnum Unexecuted instantiation: translate.c:float128_maxnummag Unexecuted instantiation: translate.c:float128_maximum_number Unexecuted instantiation: translate.c:float128_min Unexecuted instantiation: translate.c:float128_minnum Unexecuted instantiation: translate.c:float128_minnummag Unexecuted instantiation: translate.c:float128_minimum_number |
1382 | | |
1383 | | #define MINMAX_2(type) \ |
1384 | | MINMAX_1(type, max, 0) \ |
1385 | | MINMAX_1(type, maxnum, float_minmax_isnum) \ |
1386 | | MINMAX_1(type, maxnummag, float_minmax_isnum | float_minmax_ismag) \ |
1387 | | MINMAX_1(type, maximum_number, float_minmax_isnumber) \ |
1388 | | MINMAX_1(type, min, float_minmax_ismin) \ |
1389 | | MINMAX_1(type, minnum, float_minmax_ismin | float_minmax_isnum) \ |
1390 | | MINMAX_1(type, minnummag, \ |
1391 | | float_minmax_ismin | float_minmax_isnum | float_minmax_ismag) \ |
1392 | | MINMAX_1(type, minimum_number, \ |
1393 | | float_minmax_ismin | float_minmax_isnumber) |
1394 | | |
1395 | | MINMAX_2(float16) |
1396 | | MINMAX_2(bfloat16) |
1397 | | MINMAX_2(float32) |
1398 | | MINMAX_2(float64) |
1399 | | MINMAX_2(float128) |
1400 | | |
1401 | | #undef MINMAX_1 |
1402 | | #undef MINMAX_2 |
1403 | | |
1404 | | #endif /* SOFTFLOAT_H */ |