| 1 |
|
| 2 |
/*============================================================================ |
| 3 |
|
| 4 |
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic |
| 5 |
Package, Release 3e, by John R. Hauser. |
| 6 |
|
| 7 |
Copyright 2017 The Regents of the University of California. All rights |
| 8 |
reserved. |
| 9 |
|
| 10 |
Redistribution and use in source and binary forms, with or without |
| 11 |
modification, are permitted provided that the following conditions are met: |
| 12 |
|
| 13 |
1. Redistributions of source code must retain the above copyright notice, |
| 14 |
this list of conditions, and the following disclaimer. |
| 15 |
|
| 16 |
2. Redistributions in binary form must reproduce the above copyright notice, |
| 17 |
this list of conditions, and the following disclaimer in the documentation |
| 18 |
and/or other materials provided with the distribution. |
| 19 |
|
| 20 |
3. Neither the name of the University nor the names of its contributors may |
| 21 |
be used to endorse or promote products derived from this software without |
| 22 |
specific prior written permission. |
| 23 |
|
| 24 |
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY |
| 25 |
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| 26 |
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE |
| 27 |
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY |
| 28 |
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| 29 |
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 30 |
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| 31 |
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 32 |
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| 33 |
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 34 |
|
| 35 |
=============================================================================*/ |
| 36 |
|
| 37 |
#ifndef opts_GCC_h |
| 38 |
#define opts_GCC_h 1 |
| 39 |
|
| 40 |
#ifdef INLINE |
| 41 |
|
| 42 |
// #include <stdint.h> |
| 43 |
#include "primitiveTypes.h" |
| 44 |
typedef int8_t int_fast8_t; |
| 45 |
typedef uint8_t uint_fast8_t; |
| 46 |
typedef int16_t int_fast16_t; |
| 47 |
typedef uint16_t uint_fast16_t; |
| 48 |
typedef int32_t int_fast32_t; |
| 49 |
typedef uint32_t uint_fast32_t; |
| 50 |
typedef int64_t int_fast64_t; |
| 51 |
typedef uint64_t uint_fast64_t; |
| 52 |
#define INT64_C(value) value##LL |
| 53 |
#define UINT64_C(value) value##uLL |
| 54 |
|
| 55 |
#ifdef SOFTFLOAT_BUILTIN_CLZ |
| 56 |
|
| 57 |
INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a ) |
| 58 |
{ return a ? __builtin_clz( a ) - 16 : 16; } |
| 59 |
#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16 |
| 60 |
|
| 61 |
INLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a ) |
| 62 |
{ return a ? __builtin_clz( a ) : 32; } |
| 63 |
#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32 |
| 64 |
|
| 65 |
INLINE uint_fast8_t softfloat_countLeadingZeros64( uint64_t a ) |
| 66 |
{ return a ? __builtin_clzll( a ) : 64; } |
| 67 |
#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64 |
| 68 |
|
| 69 |
#endif |
| 70 |
|
| 71 |
#ifdef SOFTFLOAT_INTRINSIC_INT128 |
| 72 |
|
| 73 |
INLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b ) |
| 74 |
{ |
| 75 |
union { unsigned __int128 ui; struct uint128 s; } uZ; |
| 76 |
uZ.ui = (unsigned __int128) a * ((uint_fast64_t) b<<32); |
| 77 |
return uZ.s; |
| 78 |
} |
| 79 |
#define softfloat_mul64ByShifted32To128 softfloat_mul64ByShifted32To128 |
| 80 |
|
| 81 |
INLINE struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b ) |
| 82 |
{ |
| 83 |
union { unsigned __int128 ui; struct uint128 s; } uZ; |
| 84 |
uZ.ui = (unsigned __int128) a * b; |
| 85 |
return uZ.s; |
| 86 |
} |
| 87 |
#define softfloat_mul64To128 softfloat_mul64To128 |
| 88 |
|
| 89 |
INLINE |
| 90 |
struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b ) |
| 91 |
{ |
| 92 |
union { unsigned __int128 ui; struct uint128 s; } uZ; |
| 93 |
uZ.ui = ((unsigned __int128) a64<<64 | a0) * b; |
| 94 |
return uZ.s; |
| 95 |
} |
| 96 |
#define softfloat_mul128By32 softfloat_mul128By32 |
| 97 |
|
| 98 |
INLINE |
| 99 |
void |
| 100 |
softfloat_mul128To256M( |
| 101 |
uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr ) |
| 102 |
{ |
| 103 |
unsigned __int128 z0, mid1, mid, z128; |
| 104 |
z0 = (unsigned __int128) a0 * b0; |
| 105 |
mid1 = (unsigned __int128) a64 * b0; |
| 106 |
mid = mid1 + (unsigned __int128) a0 * b64; |
| 107 |
z128 = (unsigned __int128) a64 * b64; |
| 108 |
z128 += (unsigned __int128) (mid < mid1)<<64 | mid>>64; |
| 109 |
mid <<= 64; |
| 110 |
z0 += mid; |
| 111 |
z128 += (z0 < mid); |
| 112 |
zPtr[indexWord( 4, 0 )] = z0; |
| 113 |
zPtr[indexWord( 4, 1 )] = z0>>64; |
| 114 |
zPtr[indexWord( 4, 2 )] = z128; |
| 115 |
zPtr[indexWord( 4, 3 )] = z128>>64; |
| 116 |
} |
| 117 |
#define softfloat_mul128To256M softfloat_mul128To256M |
| 118 |
|
| 119 |
#endif |
| 120 |
|
| 121 |
#endif |
| 122 |
|
| 123 |
#endif |
| 124 |
|