Root/
Source at commit 1321 created 12 years 8 months ago. By meklort, Add __extendsfdf2 from LLVM | |
---|---|
1 | //===-- lib/extendsfdf2.c - single -> double conversion -----------*- C -*-===//␊ |
2 | //␊ |
3 | // The LLVM Compiler Infrastructure␊ |
4 | //␊ |
5 | // This file is dual licensed under the MIT and the University of Illinois Open␊ |
6 | // Source Licenses. See LICENSE.TXT for details.␊ |
7 | //␊ |
8 | //===----------------------------------------------------------------------===//␊ |
9 | //␊ |
10 | // This file implements a fairly generic conversion from a narrower to a wider␊ |
11 | // IEEE-754 floating-point type. The constants and types defined following the␊ |
12 | // includes below parameterize the conversion.␊ |
13 | //␊ |
14 | // This routine can be trivially adapted to support conversions from ␊ |
15 | // half-precision or to quad-precision. It does not support types that don't␊ |
16 | // use the usual IEEE-754 interchange formats; specifically, some work would be␊ |
17 | // needed to adapt it to (for example) the Intel 80-bit format or PowerPC␊ |
18 | // double-double format.␊ |
19 | //␊ |
20 | // Note please, however, that this implementation is only intended to support␊ |
21 | // *widening* operations; if you need to convert to a *narrower* floating-point␊ |
22 | // type (e.g. double -> float), then this routine will not do what you want it␊ |
23 | // to.␊ |
24 | //␊ |
25 | // It also requires that integer types at least as large as both formats␊ |
26 | // are available on the target platform; this may pose a problem when trying␊ |
27 | // to add support for quad on some 32-bit systems, for example. You also may␊ |
28 | // run into trouble finding an appropriate CLZ function for wide source types;␊ |
29 | // you will likely need to roll your own on some platforms.␊ |
30 | //␊ |
31 | // Finally, the following assumptions are made:␊ |
32 | //␊ |
33 | // 1. floating-point types and integer types have the same endianness on the␊ |
34 | // target platform␊ |
35 | //␊ |
36 | // 2. quiet NaNs, if supported, are indicated by the leading bit of the␊ |
37 | // significand field being set␊ |
38 | //␊ |
39 | //===----------------------------------------------------------------------===//␊ |
40 | ␊ |
41 | #include <stdint.h>␊ |
42 | #include <limits.h>␊ |
43 | ␊ |
44 | //#include "abi.h"␊ |
45 | ␊ |
46 | typedef float src_t;␊ |
47 | typedef uint32_t src_rep_t;␊ |
48 | #define SRC_REP_C UINT32_C␊ |
49 | static const int srcSigBits = 23;␊ |
50 | #define src_rep_t_clz __builtin_clz␊ |
51 | ␊ |
52 | typedef double dst_t;␊ |
53 | typedef uint64_t dst_rep_t;␊ |
54 | #define DST_REP_C UINT64_C␊ |
55 | static const int dstSigBits = 52;␊ |
56 | ␊ |
57 | // End of specialization parameters. Two helper routines for conversion to and␊ |
58 | // from the representation of floating-point data as integer values follow.␊ |
59 | ␊ |
60 | static inline src_rep_t srcToRep(src_t x) {␊ |
61 | const union { src_t f; src_rep_t i; } rep = {.f = x};␊ |
62 | return rep.i;␊ |
63 | }␊ |
64 | ␊ |
65 | static inline dst_t dstFromRep(dst_rep_t x) {␊ |
66 | const union { dst_t f; dst_rep_t i; } rep = {.i = x};␊ |
67 | return rep.f;␊ |
68 | }␊ |
69 | ␊ |
70 | // End helper routines. Conversion implementation follows.␊ |
71 | ␊ |
72 | dst_t __extendsfdf2(src_t a) {␊ |
73 | ␊ |
74 | // Various constants whose values follow from the type parameters.␊ |
75 | // Any reasonable optimizer will fold and propagate all of these.␊ |
76 | const int srcBits = sizeof(src_t)*CHAR_BIT;␊ |
77 | const int srcExpBits = srcBits - srcSigBits - 1;␊ |
78 | const int srcInfExp = (1 << srcExpBits) - 1;␊ |
79 | const int srcExpBias = srcInfExp >> 1;␊ |
80 | ␊ |
81 | const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits;␊ |
82 | const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits;␊ |
83 | const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits);␊ |
84 | const src_rep_t srcAbsMask = srcSignMask - 1;␊ |
85 | const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1);␊ |
86 | const src_rep_t srcNaNCode = srcQNaN - 1;␊ |
87 | ␊ |
88 | const int dstBits = sizeof(dst_t)*CHAR_BIT;␊ |
89 | const int dstExpBits = dstBits - dstSigBits - 1;␊ |
90 | const int dstInfExp = (1 << dstExpBits) - 1;␊ |
91 | const int dstExpBias = dstInfExp >> 1;␊ |
92 | ␊ |
93 | const dst_rep_t dstMinNormal = DST_REP_C(1) << dstSigBits;␊ |
94 | ␊ |
95 | // Break a into a sign and representation of the absolute value␊ |
96 | const src_rep_t aRep = srcToRep(a);␊ |
97 | const src_rep_t aAbs = aRep & srcAbsMask;␊ |
98 | const src_rep_t sign = aRep & srcSignMask;␊ |
99 | dst_rep_t absResult;␊ |
100 | ␊ |
101 | if (aAbs - srcMinNormal < srcInfinity - srcMinNormal) {␊ |
102 | // a is a normal number.␊ |
103 | // Extend to the destination type by shifting the significand and␊ |
104 | // exponent into the proper position and rebiasing the exponent.␊ |
105 | absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits);␊ |
106 | absResult += (dst_rep_t)(dstExpBias - srcExpBias) << dstSigBits;␊ |
107 | }␊ |
108 | ␊ |
109 | else if (aAbs >= srcInfinity) {␊ |
110 | // a is NaN or infinity.␊ |
111 | // Conjure the result by beginning with infinity, then setting the qNaN␊ |
112 | // bit (if needed) and right-aligning the rest of the trailing NaN␊ |
113 | // payload field.␊ |
114 | absResult = (dst_rep_t)dstInfExp << dstSigBits;␊ |
115 | absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigBits - srcSigBits);␊ |
116 | absResult |= aAbs & srcNaNCode;␊ |
117 | }␊ |
118 | ␊ |
119 | else if (aAbs) {␊ |
120 | // a is denormal.␊ |
121 | // renormalize the significand and clear the leading bit, then insert␊ |
122 | // the correct adjusted exponent in the destination type.␊ |
123 | const int scale = src_rep_t_clz(aAbs) - src_rep_t_clz(srcMinNormal);␊ |
124 | absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits + scale);␊ |
125 | absResult ^= dstMinNormal;␊ |
126 | const int resultExponent = dstExpBias - srcExpBias - scale + 1;␊ |
127 | absResult |= (dst_rep_t)resultExponent << dstSigBits;␊ |
128 | }␊ |
129 | ␉␊ |
130 | else {␊ |
131 | // a is zero.␊ |
132 | absResult = 0;␊ |
133 | }␊ |
134 | ␊ |
135 | // Apply the signbit to (dst_t)abs(a).␊ |
136 | const dst_rep_t result = absResult | (dst_rep_t)sign << (dstBits - srcBits);␊ |
137 | return dstFromRep(result);␊ |
138 | } |