This is an archive of the discontinued LLVM Phabricator instance.

Differential D60351

[builtins] Reformat builtins with clang-format
ClosedPublic

Authored by phosek on Apr 5 2019, 6:10 PM.

Details

Reviewers
saugustine
echristo
jfb
Commits
rG082b89b25faa: [builtins] Reformat builtins with clang-format
rCRT359410: [builtins] Reformat builtins with clang-format
rL359410: [builtins] Reformat builtins with clang-format
Summary

Update formatting to use the LLVM style.

Diff Detail

Repository
rL LLVM

Event Timeline

phosek created this revision.Apr 5 2019, 6:10 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptApr 5 2019, 6:10 PM
Herald added subscribers: llvm-commits, Restricted Project, jfb and 7 others. · View Herald Transcript
phosek retitled this revision from [compiler-rt] Reformat builtins with clang-format to [builtins] Reformat builtins with clang-format.Apr 5 2019, 6:10 PM
thakis added a subscriber: thakis.Apr 5 2019, 7:45 PM
thakis added inline comments.
compiler-rt/lib/builtins/lshrti3.c
31 ↗(On Diff #193991)

clang-format interacts poorly with some of the comments in these files. Maybe look through the diff yourself locally, there's a few places that could use manual cleaning up.

jfb added a comment.Apr 6 2019, 2:38 PM

I'd much rather see format updates happen as the files are touched, instead of all-out like this, because it makes mergebots sad.

jfb added a reviewer: jfb.Apr 6 2019, 2:50 PM
Herald added a subscriber: dexonsmith. · View Herald TranscriptApr 6 2019, 2:50 PM
thakis added a comment.Apr 7 2019, 10:02 AM
In D60351#1457455, @jfb wrote:

I'd much rather see format updates happen as the files are touched, instead of all-out like this, because it makes mergebots sad.

Huh, usually the guidance is "land reformat in a separate commit". And we've mass-reformated code that didn't follow LLVM style before, e.g. lldb. What's different here?

jfb added a comment.Apr 7 2019, 1:54 PM
In D60351#1457640, @thakis wrote:
In D60351#1457455, @jfb wrote:

I'd much rather see format updates happen as the files are touched, instead of all-out like this, because it makes mergebots sad.

Huh, usually the guidance is "land reformat in a separate commit". And we've mass-reformated code that didn't follow LLVM style before, e.g. lldb. What's different here?

Do you intend to change all these files in the near future? If we want to go by guidance:

"Avoid committing formatting- or whitespace-only changes outside of code you plan to make subsequent changes to. Also, try to separate formatting or whitespace changes from functional changes, either by correcting the format first (ideally) or afterward. Such changes should be highly localized and the commit message should clearly state that the commit is not intended to change functionality, usually by stating it is NFC." from https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

Agreed that format changes should happen as NFC commits, but I'm just not a fan of commits that just do that because the code is "wrong". Unless there's subsequent changes coming to each file, it's useless churn that hurts mergebots and makes the history annoying to follow.

Not that this is "over my dead body". I'm just asking if the motivation is just "oh hey it's wrongly formatted, let's fix the format". If so, I'm not a fan. I'd much rather fix code as we change it.

jfb added a comment.Apr 8 2019, 9:21 AM

Thanks @echristo for pointing out "[RFC] compiler-rt builtins cleanup and refactoring". You do intend to modify this code, so a reformat ahead of time is then fine. Please link to the RFC in the commit message.

echristo accepted this revision.Apr 8 2019, 10:03 AM

LGTM.

This revision is now accepted and ready to land.Apr 8 2019, 10:03 AM
Closed by commit rL359410: [builtins] Reformat builtins with clang-format (authored by phosek). · Explain WhyApr 28 2019, 2:54 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: delcypher. · View Herald TranscriptApr 28 2019, 2:54 PM
nikic added a subscriber: nikic.Jul 12 2019, 9:53 AM
nikic added inline comments.
compiler-rt/trunk/lib/builtins/arm/sync-ops.h
37

It looks like this reformatted to illegal assembly:

compiler-rt/lib/builtins/arm/sync_fetch_and_add_8.S:21: Error: bad instruction `push{r4, r5,r6,lr}'

The whitespace between push and { likely needs to be preserved.

Herald added a subscriber: • wuzish. · View Herald TranscriptJul 12 2019, 9:53 AM
nikic mentioned this in rL365957: [builtins] Fix assembly in arm sync-ops.h.Jul 12 2019, 1:52 PM
nikic mentioned this in rGa205ebb09cc5: [builtins] Fix assembly in arm sync-ops.h.
nikic added inline comments.Jul 12 2019, 2:12 PM
compiler-rt/trunk/lib/builtins/arm/sync-ops.h
37

I've added back the space in rL365957.

devnexen mentioned this in rL374070: [builtins] Unbreak build on FreeBSD armv7 after D60351.Oct 8 2019, 8:45 AM
devnexen mentioned this in rGd80c2520d9f8: [builtins] Unbreak build on FreeBSD armv7 after D60351.

Revision Contents

PathSize
compiler-rt/
trunk/
lib/
builtins/
14 lines
14 lines
15 lines
8 lines
8 lines
4 lines
25 lines
25 lines
25 lines
94 lines
arm/
8 lines
8 lines
5 lines
8 lines
8 lines
86 lines
40 lines
37 lines
42 lines
39 lines
269 lines
9 lines
211 lines
17 lines
62 lines
14 lines
49 lines
30 lines
164 lines
164 lines
138 lines
46 lines
17 lines
69 lines
14 lines
71 lines
348 lines
19 lines
8 lines
12 lines
72 lines
314 lines
30 lines
73 lines
375 lines
19 lines
71 lines
416 lines
43 lines
14 lines
2 lines
10 lines
8 lines
2 lines
21 lines
13 lines
21 lines
21 lines
9 lines
5 lines
21 lines
9 lines
5 lines
5 lines
5 lines
5 lines
22 lines
9 lines
5 lines
24 lines
9 lines
5 lines
5 lines
5 lines
5 lines
32 lines
31 lines
41 lines
41 lines
47 lines
138 lines
105 lines
50 lines
39 lines
63 lines
77 lines
50 lines
100 lines
99 lines
100 lines
106 lines
140 lines
97 lines
31 lines
31 lines
42 lines
60 lines
31 lines
94 lines
93 lines
94 lines
100 lines
265 lines
33 lines
132 lines
40 lines
36 lines
281 lines
204 lines
18 lines
178 lines
343 lines
26 lines
40 lines
16 lines
147 lines
1 line
40 lines
37 lines
20 lines
6 lines
20 lines
98 lines
8 lines
57 lines
65 lines
65 lines
65 lines
97 lines
8 lines
93 lines
4 lines
57 lines
61 lines
61 lines
61 lines
98 lines
9 lines
12 lines
9 lines
12 lines
12 lines
12 lines
12 lines
6 lines
10 lines
14 lines
12 lines
34 lines
26 lines
46 lines
27 lines
27 lines
27 lines
27 lines
ppc/
20 lines
157 lines
185 lines
101 lines
49 lines
62 lines
127 lines
82 lines
78 lines
127 lines
153 lines
9 lines
9 lines
5 lines
25 lines
25 lines
25 lines
51 lines
8 lines
8 lines
10 lines
4 lines
4 lines
43 lines
30 lines
6 lines
378 lines
10 lines
390 lines
82 lines
6 lines
10 lines
6 lines
10 lines
5 lines
x86_64/
5 lines
5 lines
5 lines

Diff 197039

compiler-rt/trunk/lib/builtins/absvdi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: absolute value */ /* Returns: absolute value */
/* Effects: aborts if abs(x) < 0 */ /* Effects: aborts if abs(x) < 0 */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __absvdi2(di_int a) {
__absvdi2(di_int a)
{
const int N = (int)(sizeof(di_int) * CHAR_BIT); const int N = (int)(sizeof(di_int) * CHAR_BIT);
if (a == ((di_int)1 << (N-1))) if (a == ((di_int)1 << (N - 1)))
compilerrt_abort(); compilerrt_abort();
const di_int t = a >> (N - 1); const di_int t = a >> (N - 1);
return (a ^ t) - t; return (a ^ t) - t;
} }

compiler-rt/trunk/lib/builtins/absvsi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: absolute value */ /* Returns: absolute value */
/* Effects: aborts if abs(x) < 0 */ /* Effects: aborts if abs(x) < 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __absvsi2(si_int a) {
__absvsi2(si_int a)
{
const int N = (int)(sizeof(si_int) * CHAR_BIT); const int N = (int)(sizeof(si_int) * CHAR_BIT);
if (a == (1 << (N-1))) if (a == (1 << (N - 1)))
compilerrt_abort(); compilerrt_abort();
const si_int t = a >> (N - 1); const si_int t = a >> (N - 1);
return (a ^ t) - t; return (a ^ t) - t;
} }

compiler-rt/trunk/lib/builtins/absvti2.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: absolute value */ /* Returns: absolute value */
/* Effects: aborts if abs(x) < 0 */ /* Effects: aborts if abs(x) < 0 */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __absvti2(ti_int a) {
__absvti2(ti_int a)
{
const int N = (int)(sizeof(ti_int) * CHAR_BIT); const int N = (int)(sizeof(ti_int) * CHAR_BIT);
if (a == ((ti_int)1 << (N-1))) if (a == ((ti_int)1 << (N - 1)))
compilerrt_abort(); compilerrt_abort();
const ti_int s = a >> (N - 1); const ti_int s = a >> (N - 1);
return (a ^ s) - s; return (a ^ s) - s;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/adddf3.c

//===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===// //===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements double-precision soft-float addition with the IEEE-754 // This file implements double-precision soft-float addition with the IEEE-754
// default rounding (to nearest, ties to even). // default rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_add_impl.inc" #include "fp_add_impl.inc"
COMPILER_RT_ABI double __adddf3(double a, double b){ COMPILER_RT_ABI double __adddf3(double a, double b) { return __addXf3__(a, b); }
return __addXf3__(a, b);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_dadd(double a, double b) { AEABI_RTABI double __aeabi_dadd(double a, double b) { return __adddf3(a, b); }
return __adddf3(a, b);
}
#else #else
AEABI_RTABI double __aeabi_dadd(double a, double b) COMPILER_RT_ALIAS(__adddf3); AEABI_RTABI double __aeabi_dadd(double a, double b) COMPILER_RT_ALIAS(__adddf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/addsf3.c

//===-- lib/addsf3.c - Single-precision addition ------------------*- C -*-===// //===-- lib/addsf3.c - Single-precision addition ------------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements single-precision soft-float addition with the IEEE-754 // This file implements single-precision soft-float addition with the IEEE-754
// default rounding (to nearest, ties to even). // default rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_add_impl.inc" #include "fp_add_impl.inc"
COMPILER_RT_ABI float __addsf3(float a, float b) { COMPILER_RT_ABI float __addsf3(float a, float b) { return __addXf3__(a, b); }
return __addXf3__(a, b);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_fadd(float a, float b) { AEABI_RTABI float __aeabi_fadd(float a, float b) { return __addsf3(a, b); }
return __addsf3(a, b);
}
#else #else
AEABI_RTABI float __aeabi_fadd(float a, float b) COMPILER_RT_ALIAS(__addsf3); AEABI_RTABI float __aeabi_fadd(float a, float b) COMPILER_RT_ALIAS(__addsf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/addtf3.c

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#include "fp_add_impl.inc" #include "fp_add_impl.inc"
COMPILER_RT_ABI long double __addtf3(long double a, long double b){ COMPILER_RT_ABI long double __addtf3(long double a, long double b) {
return __addXf3__(a, b); return __addXf3__(a, b);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/addvdi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a + b */ /* Returns: a + b */
/* Effects: aborts if a + b overflows */ /* Effects: aborts if a + b overflows */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __addvdi3(di_int a, di_int b) {
__addvdi3(di_int a, di_int b)
{
di_int s = (du_int) a + (du_int) b; di_int s = (du_int)a + (du_int)b;
if (b >= 0) if (b >= 0) {
{
if (s < a) if (s < a)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (s >= a) if (s >= a)
compilerrt_abort(); compilerrt_abort();
} }
return s; return s;
} }

compiler-rt/trunk/lib/builtins/addvsi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a + b */ /* Returns: a + b */
/* Effects: aborts if a + b overflows */ /* Effects: aborts if a + b overflows */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __addvsi3(si_int a, si_int b) {
__addvsi3(si_int a, si_int b)
{
si_int s = (su_int) a + (su_int) b; si_int s = (su_int)a + (su_int)b;
if (b >= 0) if (b >= 0) {
{
if (s < a) if (s < a)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (s >= a) if (s >= a)
compilerrt_abort(); compilerrt_abort();
} }
return s; return s;
} }

compiler-rt/trunk/lib/builtins/addvti3.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a + b */ /* Returns: a + b */
/* Effects: aborts if a + b overflows */ /* Effects: aborts if a + b overflows */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __addvti3(ti_int a, ti_int b) {
__addvti3(ti_int a, ti_int b)
{
ti_int s = (tu_int) a + (tu_int) b; ti_int s = (tu_int)a + (tu_int)b;
if (b >= 0) if (b >= 0) {
{
if (s < a) if (s < a)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (s >= a) if (s >= a)
compilerrt_abort(); compilerrt_abort();
} }
return s; return s;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/apple_versioning.c

/* ===-- apple_versioning.c - Adds versioning symbols for ld ---------------=== /* ===-- apple_versioning.c - Adds versioning symbols for ld ---------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#if __APPLE__ #if __APPLE__
#include <Availability.h> #include <Availability.h>
#if __IPHONE_OS_VERSION_MIN_REQUIRED #if __IPHONE_OS_VERSION_MIN_REQUIRED
#define NOT_HERE_BEFORE_10_6(sym) #define NOT_HERE_BEFORE_10_6(sym)
#define NOT_HERE_IN_10_8_AND_EARLIER(sym) \ #define NOT_HERE_IN_10_8_AND_EARLIER(sym) \
extern const char sym##_tmp61 __asm("$ld$hide$os6.1$_" #sym ); \ extern const char sym##_tmp61 __asm("$ld$hide$os6.1$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp61 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp61 = 0; \
extern const char sym##_tmp60 __asm("$ld$hide$os6.0$_" #sym ); \ extern const char sym##_tmp60 __asm("$ld$hide$os6.0$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp60 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp60 = 0; \
extern const char sym##_tmp51 __asm("$ld$hide$os5.1$_" #sym ); \ extern const char sym##_tmp51 __asm("$ld$hide$os5.1$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp51 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp51 = 0; \
extern const char sym##_tmp50 __asm("$ld$hide$os5.0$_" #sym ); \ extern const char sym##_tmp50 __asm("$ld$hide$os5.0$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp50 = 0; __attribute__((visibility("default"))) const char sym##_tmp50 = 0;
#else #else
#define NOT_HERE_BEFORE_10_6(sym) \ #define NOT_HERE_BEFORE_10_6(sym) \
extern const char sym##_tmp4 __asm("$ld$hide$os10.4$_" #sym ); \ extern const char sym##_tmp4 __asm("$ld$hide$os10.4$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp4 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp4 = 0; \
extern const char sym##_tmp5 __asm("$ld$hide$os10.5$_" #sym ); \ extern const char sym##_tmp5 __asm("$ld$hide$os10.5$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp5 = 0; __attribute__((visibility("default"))) const char sym##_tmp5 = 0;
#define NOT_HERE_IN_10_8_AND_EARLIER(sym) \ #define NOT_HERE_IN_10_8_AND_EARLIER(sym) \
extern const char sym##_tmp8 __asm("$ld$hide$os10.8$_" #sym ); \ extern const char sym##_tmp8 __asm("$ld$hide$os10.8$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp8 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp8 = 0; \
extern const char sym##_tmp7 __asm("$ld$hide$os10.7$_" #sym ); \ extern const char sym##_tmp7 __asm("$ld$hide$os10.7$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp7 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp7 = 0; \
extern const char sym##_tmp6 __asm("$ld$hide$os10.6$_" #sym ); \ extern const char sym##_tmp6 __asm("$ld$hide$os10.6$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp6 = 0; __attribute__((visibility("default"))) const char sym##_tmp6 = 0;
#endif #endif
/* Symbols in libSystem.dylib in 10.6 and later, /* Symbols in libSystem.dylib in 10.6 and later,
* but are in libgcc_s.dylib in earlier versions * but are in libgcc_s.dylib in earlier versions
*/ */
NOT_HERE_BEFORE_10_6(__absvdi2) NOT_HERE_BEFORE_10_6(__absvdi2)
NOT_HERE_BEFORE_10_6(__absvsi2) NOT_HERE_BEFORE_10_6(__absvsi2)
NOT_HERE_BEFORE_10_6(__absvti2) NOT_HERE_BEFORE_10_6(__absvti2)
NOT_HERE_BEFORE_10_6(__addvdi3) NOT_HERE_BEFORE_10_6(__addvdi3)
NOT_HERE_BEFORE_10_6(__addvsi3) NOT_HERE_BEFORE_10_6(__addvsi3)
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
NOT_HERE_BEFORE_10_6(__ucmpti2) NOT_HERE_BEFORE_10_6(__ucmpti2)
NOT_HERE_BEFORE_10_6(__udivdi3) NOT_HERE_BEFORE_10_6(__udivdi3)
NOT_HERE_BEFORE_10_6(__udivmoddi4) NOT_HERE_BEFORE_10_6(__udivmoddi4)
NOT_HERE_BEFORE_10_6(__udivmodti4) NOT_HERE_BEFORE_10_6(__udivmodti4)
NOT_HERE_BEFORE_10_6(__udivti3) NOT_HERE_BEFORE_10_6(__udivti3)
NOT_HERE_BEFORE_10_6(__umoddi3) NOT_HERE_BEFORE_10_6(__umoddi3)
NOT_HERE_BEFORE_10_6(__umodti3) NOT_HERE_BEFORE_10_6(__umodti3)
#if __ppc__ #if __ppc__
NOT_HERE_BEFORE_10_6(__gcc_qadd) NOT_HERE_BEFORE_10_6(__gcc_qadd)
NOT_HERE_BEFORE_10_6(__gcc_qdiv) NOT_HERE_BEFORE_10_6(__gcc_qdiv)
NOT_HERE_BEFORE_10_6(__gcc_qmul) NOT_HERE_BEFORE_10_6(__gcc_qmul)
NOT_HERE_BEFORE_10_6(__gcc_qsub) NOT_HERE_BEFORE_10_6(__gcc_qsub)
NOT_HERE_BEFORE_10_6(__trampoline_setup) NOT_HERE_BEFORE_10_6(__trampoline_setup)
#endif /* __ppc__ */ #endif /* __ppc__ */
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load_8) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load_8)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_1) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_1)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_2) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_2)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_4) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_4)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_8) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_8)
#if __arm__ && __DYNAMIC__ #if __arm__ && __DYNAMIC__
#define NOT_HERE_UNTIL_AFTER_4_3(sym) \ #define NOT_HERE_UNTIL_AFTER_4_3(sym) \
extern const char sym##_tmp1 __asm("$ld$hide$os3.0$_" #sym ); \ extern const char sym##_tmp1 __asm("$ld$hide$os3.0$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp1 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp1 = 0; \
extern const char sym##_tmp2 __asm("$ld$hide$os3.1$_" #sym ); \ extern const char sym##_tmp2 __asm("$ld$hide$os3.1$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp2 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp2 = 0; \
extern const char sym##_tmp3 __asm("$ld$hide$os3.2$_" #sym ); \ extern const char sym##_tmp3 __asm("$ld$hide$os3.2$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp3 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp3 = 0; \
extern const char sym##_tmp4 __asm("$ld$hide$os4.0$_" #sym ); \ extern const char sym##_tmp4 __asm("$ld$hide$os4.0$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp4 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp4 = 0; \
extern const char sym##_tmp5 __asm("$ld$hide$os4.1$_" #sym ); \ extern const char sym##_tmp5 __asm("$ld$hide$os4.1$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp5 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp5 = 0; \
extern const char sym##_tmp6 __asm("$ld$hide$os4.2$_" #sym ); \ extern const char sym##_tmp6 __asm("$ld$hide$os4.2$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp6 = 0; \ __attribute__((visibility("default"))) const char sym##_tmp6 = 0; \
extern const char sym##_tmp7 __asm("$ld$hide$os4.3$_" #sym ); \ extern const char sym##_tmp7 __asm("$ld$hide$os4.3$_" #sym); \
__attribute__((visibility("default"))) const char sym##_tmp7 = 0; __attribute__((visibility("default"))) const char sym##_tmp7 = 0;
NOT_HERE_UNTIL_AFTER_4_3(__absvdi2) NOT_HERE_UNTIL_AFTER_4_3(__absvdi2)
NOT_HERE_UNTIL_AFTER_4_3(__absvsi2) NOT_HERE_UNTIL_AFTER_4_3(__absvsi2)
NOT_HERE_UNTIL_AFTER_4_3(__adddf3) NOT_HERE_UNTIL_AFTER_4_3(__adddf3)
NOT_HERE_UNTIL_AFTER_4_3(__adddf3vfp) NOT_HERE_UNTIL_AFTER_4_3(__adddf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__addsf3) NOT_HERE_UNTIL_AFTER_4_3(__addsf3)
NOT_HERE_UNTIL_AFTER_4_3(__addsf3vfp) NOT_HERE_UNTIL_AFTER_4_3(__addsf3vfp)
NOT_HERE_UNTIL_AFTER_4_3(__addvdi3) NOT_HERE_UNTIL_AFTER_4_3(__addvdi3)
NOT_HERE_UNTIL_AFTER_4_3(__addvsi3) NOT_HERE_UNTIL_AFTER_4_3(__addvsi3)
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines
NOT_HERE_UNTIL_AFTER_4_3(__unorddf2vfp) NOT_HERE_UNTIL_AFTER_4_3(__unorddf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__unordsf2) NOT_HERE_UNTIL_AFTER_4_3(__unordsf2)
NOT_HERE_UNTIL_AFTER_4_3(__unordsf2vfp) NOT_HERE_UNTIL_AFTER_4_3(__unordsf2vfp)
NOT_HERE_UNTIL_AFTER_4_3(__divmodsi4) NOT_HERE_UNTIL_AFTER_4_3(__divmodsi4)
NOT_HERE_UNTIL_AFTER_4_3(__udivmodsi4) NOT_HERE_UNTIL_AFTER_4_3(__udivmodsi4)
#endif // __arm__ && __DYNAMIC__ #endif // __arm__ && __DYNAMIC__
#else /* !__APPLE__ */ #else /* !__APPLE__ */
extern int avoid_empty_file; extern int avoid_empty_file;
#endif /* !__APPLE__*/ #endif /* !__APPLE__*/

compiler-rt/trunk/lib/builtins/arm/aeabi_cdcmpeq_check_nan.c

//===-- lib/arm/aeabi_cdcmpeq_helper.c - Helper for cdcmpeq ---------------===// //===-- lib/arm/aeabi_cdcmpeq_helper.c - Helper for cdcmpeq ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <stdint.h>
#include "../int_lib.h" #include "../int_lib.h"
#include <stdint.h>
AEABI_RTABI __attribute__((visibility("hidden"))) AEABI_RTABI __attribute__((visibility("hidden"))) int
int __aeabi_cdcmpeq_check_nan(double a, double b) { __aeabi_cdcmpeq_check_nan(double a, double b) {
return __builtin_isnan(a) || __builtin_isnan(b); return __builtin_isnan(a) || __builtin_isnan(b);
} }

compiler-rt/trunk/lib/builtins/arm/aeabi_cfcmpeq_check_nan.c

//===-- lib/arm/aeabi_cfcmpeq_helper.c - Helper for cdcmpeq ---------------===// //===-- lib/arm/aeabi_cfcmpeq_helper.c - Helper for cdcmpeq ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <stdint.h>
#include "../int_lib.h" #include "../int_lib.h"
#include <stdint.h>
AEABI_RTABI __attribute__((visibility("hidden"))) AEABI_RTABI __attribute__((visibility("hidden"))) int
int __aeabi_cfcmpeq_check_nan(float a, float b) { __aeabi_cfcmpeq_check_nan(float a, float b) {
return __builtin_isnan(a) || __builtin_isnan(b); return __builtin_isnan(a) || __builtin_isnan(b);
} }

compiler-rt/trunk/lib/builtins/arm/aeabi_div0.c

Show All 30 Lines
extern unsigned char declaration; extern unsigned char declaration;
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI int __attribute__((weak)) __attribute__((visibility("hidden"))) AEABI_RTABI int __attribute__((weak)) __attribute__((visibility("hidden")))
__aeabi_idiv0(int return_value) { __aeabi_idiv0(int return_value) {
return return_value; return return_value;
} }
AEABI_RTABI long long __attribute__((weak)) __attribute__((visibility("hidden"))) AEABI_RTABI long long __attribute__((weak))
__aeabi_ldiv0(long long return_value) { __attribute__((visibility("hidden"))) __aeabi_ldiv0(long long return_value) {
return return_value; return return_value;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/arm/aeabi_drsub.c

//===-- lib/arm/aeabi_drsub.c - Double-precision subtraction --------------===// //===-- lib/arm/aeabi_drsub.c - Double-precision subtraction --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "../fp_lib.h" #include "../fp_lib.h"
AEABI_RTABI fp_t AEABI_RTABI fp_t __aeabi_dsub(fp_t, fp_t);
__aeabi_dsub(fp_t, fp_t);
AEABI_RTABI fp_t AEABI_RTABI fp_t __aeabi_drsub(fp_t a, fp_t b) { return __aeabi_dsub(b, a); }
__aeabi_drsub(fp_t a, fp_t b) {
return __aeabi_dsub(b, a);
}

compiler-rt/trunk/lib/builtins/arm/aeabi_frsub.c

//===-- lib/arm/aeabi_frsub.c - Single-precision subtraction --------------===// //===-- lib/arm/aeabi_frsub.c - Single-precision subtraction --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "../fp_lib.h" #include "../fp_lib.h"
AEABI_RTABI fp_t AEABI_RTABI fp_t __aeabi_fsub(fp_t, fp_t);
__aeabi_fsub(fp_t, fp_t);
AEABI_RTABI fp_t AEABI_RTABI fp_t __aeabi_frsub(fp_t a, fp_t b) { return __aeabi_fsub(b, a); }
__aeabi_frsub(fp_t a, fp_t b) {
return __aeabi_fsub(b, a);
}

compiler-rt/trunk/lib/builtins/arm/sync-ops.h

/*===-- sync-ops.h - --===// /*===-- sync-ops.h - --===//
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
*===----------------------------------------------------------------------===// *===----------------------------------------------------------------------===//
* *
* This file implements outline macros for the __sync_fetch_and_* * This file implements outline macros for the __sync_fetch_and_*
* operations. Different instantiations will generate appropriate assembly for * operations. Different instantiations will generate appropriate assembly for
* ARM and Thumb-2 versions of the functions. * ARM and Thumb-2 versions of the functions.
* *
*===----------------------------------------------------------------------===*/ *===----------------------------------------------------------------------===*/
#include "../assembly.h" #include "../assembly.h"
#define SYNC_OP_4(op) \ #define SYNC_OP_4(op) \
.p2align 2 ; \ .p2align 2; \
.thumb ; \ .thumb; \
.syntax unified ; \ .syntax unified; \
DEFINE_COMPILERRT_THUMB_FUNCTION(__sync_fetch_and_ ## op) \ DEFINE_COMPILERRT_THUMB_FUNCTION(__sync_fetch_and_##op) \
dmb ; \ dmb; \
mov r12, r0 ; \ mov r12, r0; \
LOCAL_LABEL(tryatomic_ ## op): \ LOCAL_LABEL(tryatomic_##op) : ldrex r0, [r12]; \
ldrex r0, [r12] ; \
op(r2, r0, r1) ; \ op(r2, r0, r1); \
strex r3, r2, [r12] ; \ strex r3, r2, [r12]; \
cmp r3, #0 ; \ cmp r3, #0; \
bne LOCAL_LABEL(tryatomic_ ## op) ; \ bne LOCAL_LABEL(tryatomic_##op); \
dmb ; \ dmb; \
bx lr bx lr
#define SYNC_OP_8(op) \ #define SYNC_OP_8(op) \
.p2align 2 ; \ .p2align 2; \
.thumb ; \ .thumb; \
.syntax unified ; \ .syntax unified; \
DEFINE_COMPILERRT_THUMB_FUNCTION(__sync_fetch_and_ ## op) \ DEFINE_COMPILERRT_THUMB_FUNCTION(__sync_fetch_and_##op) \
push {r4, r5, r6, lr} ; \ push{r4, r5, r6, lr}; \
nikicUnsubmitted
Not Done
ReplyInline Actions

It looks like this reformatted to illegal assembly:

compiler-rt/lib/builtins/arm/sync_fetch_and_add_8.S:21: Error: bad instruction `push{r4, r5,r6,lr}'

The whitespace between push and { likely needs to be preserved.

nikic: It looks like this reformatted to illegal assembly: ``` compiler…
nikicUnsubmitted
Not Done
ReplyInline Actions

I've added back the space in rL365957.

nikic: I've added back the space in rL365957.
dmb ; \ dmb; \
mov r12, r0 ; \ mov r12, r0; \
LOCAL_LABEL(tryatomic_ ## op): \ LOCAL_LABEL(tryatomic_##op) : ldrexd r0, r1, [r12]; \
ldrexd r0, r1, [r12] ; \
op(r4, r5, r0, r1, r2, r3) ; \ op(r4, r5, r0, r1, r2, r3); \
strexd r6, r4, r5, [r12] ; \ strexd r6, r4, r5, [r12]; \
cmp r6, #0 ; \ cmp r6, #0; \
bne LOCAL_LABEL(tryatomic_ ## op) ; \ bne LOCAL_LABEL(tryatomic_##op); \
dmb ; \ dmb; \
pop {r4, r5, r6, pc} pop { r4, r5, r6, pc }
#define MINMAX_4(rD, rN, rM, cmp_kind) \ #define MINMAX_4(rD, rN, rM, cmp_kind) \
cmp rN, rM ; \ cmp rN, rM; \
mov rD, rM ; \ mov rD, rM; \
it cmp_kind ; \ it cmp_kind; \
mov##cmp_kind rD, rN mov##cmp_kind rD, rN
#define MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, cmp_kind) \ #define MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, cmp_kind) \
cmp rN_LO, rM_LO ; \ cmp rN_LO, rM_LO; \
sbcs rN_HI, rM_HI ; \ sbcs rN_HI, rM_HI; \
mov rD_LO, rM_LO ; \ mov rD_LO, rM_LO; \
mov rD_HI, rM_HI ; \ mov rD_HI, rM_HI; \
itt cmp_kind ; \ itt cmp_kind; \
mov##cmp_kind rD_LO, rN_LO ; \ mov##cmp_kind rD_LO, rN_LO; \
mov##cmp_kind rD_HI, rN_HI mov##cmp_kind rD_HI, rN_HI

compiler-rt/trunk/lib/builtins/ashldi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a << b */ /* Returns: a << b */
/* Precondition: 0 <= b < bits_in_dword */ /* Precondition: 0 <= b < bits_in_dword */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __ashldi3(di_int a, si_int b) {
__ashldi3(di_int a, si_int b)
{
const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT); const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);
dwords input; dwords input;
dwords result; dwords result;
input.all = a; input.all = a;
if (b & bits_in_word) /* bits_in_word <= b < bits_in_dword */ if (b & bits_in_word) /* bits_in_word <= b < bits_in_dword */
{ {
result.s.low = 0; result.s.low = 0;
result.s.high = input.s.low << (b - bits_in_word); result.s.high = input.s.low << (b - bits_in_word);
} } else /* 0 <= b < bits_in_word */
else /* 0 <= b < bits_in_word */
{ {
if (b == 0) if (b == 0)
return a; return a;
result.s.low = input.s.low << b; result.s.low = input.s.low << b;
result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_word - b)); result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_word - b));
} }
return result.all; return result.all;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI di_int __aeabi_llsl(di_int a, si_int b) COMPILER_RT_ALIAS(__ashldi3); AEABI_RTABI di_int __aeabi_llsl(di_int a, si_int b)
COMPILER_RT_ALIAS(__ashldi3);
#endif #endif

compiler-rt/trunk/lib/builtins/ashlti3.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a << b */ /* Returns: a << b */
/* Precondition: 0 <= b < bits_in_tword */ /* Precondition: 0 <= b < bits_in_tword */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __ashlti3(ti_int a, si_int b) {
__ashlti3(ti_int a, si_int b)
{
const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT); const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
twords input; twords input;
twords result; twords result;
input.all = a; input.all = a;
if (b & bits_in_dword) /* bits_in_dword <= b < bits_in_tword */ if (b & bits_in_dword) /* bits_in_dword <= b < bits_in_tword */
{ {
result.s.low = 0; result.s.low = 0;
result.s.high = input.s.low << (b - bits_in_dword); result.s.high = input.s.low << (b - bits_in_dword);
} } else /* 0 <= b < bits_in_dword */
else /* 0 <= b < bits_in_dword */
{ {
if (b == 0) if (b == 0)
return a; return a;
result.s.low = input.s.low << b; result.s.low = input.s.low << b;
result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_dword - b)); result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_dword - b));
} }
return result.all; return result.all;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/ashrdi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: arithmetic a >> b */ /* Returns: arithmetic a >> b */
/* Precondition: 0 <= b < bits_in_dword */ /* Precondition: 0 <= b < bits_in_dword */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __ashrdi3(di_int a, si_int b) {
__ashrdi3(di_int a, si_int b)
{
const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT); const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);
dwords input; dwords input;
dwords result; dwords result;
input.all = a; input.all = a;
if (b & bits_in_word) /* bits_in_word <= b < bits_in_dword */ if (b & bits_in_word) /* bits_in_word <= b < bits_in_dword */
{ {
/* result.s.high = input.s.high < 0 ? -1 : 0 */ /* result.s.high = input.s.high < 0 ? -1 : 0 */
result.s.high = input.s.high >> (bits_in_word - 1); result.s.high = input.s.high >> (bits_in_word - 1);
result.s.low = input.s.high >> (b - bits_in_word); result.s.low = input.s.high >> (b - bits_in_word);
} } else /* 0 <= b < bits_in_word */
else /* 0 <= b < bits_in_word */
{ {
if (b == 0) if (b == 0)
return a; return a;
result.s.high = input.s.high >> b; result.s.high = input.s.high >> b;
result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b); result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b);
} }
return result.all; return result.all;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI di_int __aeabi_lasr(di_int a, si_int b) COMPILER_RT_ALIAS(__ashrdi3); AEABI_RTABI di_int __aeabi_lasr(di_int a, si_int b)
COMPILER_RT_ALIAS(__ashrdi3);
#endif #endif

compiler-rt/trunk/lib/builtins/ashrti3.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: arithmetic a >> b */ /* Returns: arithmetic a >> b */
/* Precondition: 0 <= b < bits_in_tword */ /* Precondition: 0 <= b < bits_in_tword */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __ashrti3(ti_int a, si_int b) {
__ashrti3(ti_int a, si_int b)
{
const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT); const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
twords input; twords input;
twords result; twords result;
input.all = a; input.all = a;
if (b & bits_in_dword) /* bits_in_dword <= b < bits_in_tword */ if (b & bits_in_dword) /* bits_in_dword <= b < bits_in_tword */
{ {
/* result.s.high = input.s.high < 0 ? -1 : 0 */ /* result.s.high = input.s.high < 0 ? -1 : 0 */
result.s.high = input.s.high >> (bits_in_dword - 1); result.s.high = input.s.high >> (bits_in_dword - 1);
result.s.low = input.s.high >> (b - bits_in_dword); result.s.low = input.s.high >> (b - bits_in_dword);
} } else /* 0 <= b < bits_in_dword */
else /* 0 <= b < bits_in_dword */
{ {
if (b == 0) if (b == 0)
return a; return a;
result.s.high = input.s.high >> b; result.s.high = input.s.high >> b;
result.s.low = (input.s.high << (bits_in_dword - b)) | (input.s.low >> b); result.s.low = (input.s.high << (bits_in_dword - b)) | (input.s.low >> b);
} }
return result.all; return result.all;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/atomic.c

/*===-- atomic.c - Implement support functions for atomic operations.------=== /*===-- atomic.c - Implement support functions for atomic operations.------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
*===----------------------------------------------------------------------=== *===----------------------------------------------------------------------===
* *
* atomic.c defines a set of functions for performing atomic accesses on * atomic.c defines a set of functions for performing atomic accesses on
* arbitrary-sized memory locations. This design uses locks that should * arbitrary-sized memory locations. This design uses locks that should
* be fast in the uncontended case, for two reasons: * be fast in the uncontended case, for two reasons:
* *
* 1) This code must work with C programs that do not link to anything * 1) This code must work with C programs that do not link to anything
* (including pthreads) and so it should not depend on any pthread * (including pthreads) and so it should not depend on any pthread
* functions. * functions.
* 2) Atomic operations, rather than explicit mutexes, are most commonly used * 2) Atomic operations, rather than explicit mutexes, are most commonly used
* on code where contended operations are rate. * on code where contended operations are rate.
* *
* To avoid needing a per-object lock, this code allocates an array of * To avoid needing a per-object lock, this code allocates an array of
* locks and hashes the object pointers to find the one that it should use. * locks and hashes the object pointers to find the one that it should use.
* For operations that must be atomic on two locations, the lower lock is * For operations that must be atomic on two locations, the lower lock is
* always acquired first, to avoid deadlock. * always acquired first, to avoid deadlock.
* *
*===----------------------------------------------------------------------=== *===----------------------------------------------------------------------===
*/ */
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include "assembly.h" #include "assembly.h"
// Clang objects if you redefine a builtin. This little hack allows us to // Clang objects if you redefine a builtin. This little hack allows us to
// define a function with the same name as an intrinsic. // define a function with the same name as an intrinsic.
#pragma redefine_extname __atomic_load_c SYMBOL_NAME(__atomic_load) #pragma redefine_extname __atomic_load_c SYMBOL_NAME(__atomic_load)
#pragma redefine_extname __atomic_store_c SYMBOL_NAME(__atomic_store) #pragma redefine_extname __atomic_store_c SYMBOL_NAME(__atomic_store)
#pragma redefine_extname __atomic_exchange_c SYMBOL_NAME(__atomic_exchange) #pragma redefine_extname __atomic_exchange_c SYMBOL_NAME(__atomic_exchange)
#pragma redefine_extname __atomic_compare_exchange_c SYMBOL_NAME(__atomic_compare_exchange) #pragma redefine_extname __atomic_compare_exchange_c SYMBOL_NAME( \
__atomic_compare_exchange)
/// Number of locks. This allocates one page on 32-bit platforms, two on /// Number of locks. This allocates one page on 32-bit platforms, two on
/// 64-bit. This can be specified externally if a different trade between /// 64-bit. This can be specified externally if a different trade between
/// memory usage and contention probability is required for a given platform. /// memory usage and contention probability is required for a given platform.
#ifndef SPINLOCK_COUNT #ifndef SPINLOCK_COUNT
#define SPINLOCK_COUNT (1<<10) #define SPINLOCK_COUNT (1 << 10)
#endif #endif
static const long SPINLOCK_MASK = SPINLOCK_COUNT - 1; static const long SPINLOCK_MASK = SPINLOCK_COUNT - 1;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Platform-specific lock implementation. Falls back to spinlocks if none is // Platform-specific lock implementation. Falls back to spinlocks if none is
// defined. Each platform should define the Lock type, and corresponding // defined. Each platform should define the Lock type, and corresponding
// lock() and unlock() functions. // lock() and unlock() functions.
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#ifdef __FreeBSD__ #ifdef __FreeBSD__
#include <errno.h> #include <errno.h>
#include <sys/types.h>
#include <machine/atomic.h> #include <machine/atomic.h>
#include <sys/types.h>
#include <sys/umtx.h> #include <sys/umtx.h>
typedef struct _usem Lock; typedef struct _usem Lock;
__inline static void unlock(Lock *l) { __inline static void unlock(Lock *l) {
__c11_atomic_store((_Atomic(uint32_t)*)&l->_count, 1, __ATOMIC_RELEASE); __c11_atomic_store((_Atomic(uint32_t) *)&l->_count, 1, __ATOMIC_RELEASE);
__c11_atomic_thread_fence(__ATOMIC_SEQ_CST); __c11_atomic_thread_fence(__ATOMIC_SEQ_CST);
if (l->_has_waiters) if (l->_has_waiters)
_umtx_op(l, UMTX_OP_SEM_WAKE, 1, 0, 0); _umtx_op(l, UMTX_OP_SEM_WAKE, 1, 0, 0);
} }
__inline static void lock(Lock *l) { __inline static void lock(Lock *l) {
uint32_t old = 1; uint32_t old = 1;
while (!__c11_atomic_compare_exchange_weak((_Atomic(uint32_t)*)&l->_count, &old, while (!__c11_atomic_compare_exchange_weak((_Atomic(uint32_t) *)&l->_count,
0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) { &old, 0, __ATOMIC_ACQUIRE,
__ATOMIC_RELAXED)) {
_umtx_op(l, UMTX_OP_SEM_WAIT, 0, 0, 0); _umtx_op(l, UMTX_OP_SEM_WAIT, 0, 0, 0);
old = 1; old = 1;
} }
} }
/// locks for atomic operations /// locks for atomic operations
static Lock locks[SPINLOCK_COUNT] = { [0 ... SPINLOCK_COUNT-1] = {0,1,0} }; static Lock locks[SPINLOCK_COUNT] = {[0 ... SPINLOCK_COUNT - 1] = {0, 1, 0}};
#elif defined(__APPLE__) #elif defined(__APPLE__)
#include <libkern/OSAtomic.h> #include <libkern/OSAtomic.h>
typedef OSSpinLock Lock; typedef OSSpinLock Lock;
__inline static void unlock(Lock *l) { __inline static void unlock(Lock *l) { OSSpinLockUnlock(l); }
OSSpinLockUnlock(l);
}
/// Locks a lock. In the current implementation, this is potentially /// Locks a lock. In the current implementation, this is potentially
/// unbounded in the contended case. /// unbounded in the contended case.
__inline static void lock(Lock *l) { __inline static void lock(Lock *l) { OSSpinLockLock(l); }
OSSpinLockLock(l);
}
static Lock locks[SPINLOCK_COUNT]; // initialized to OS_SPINLOCK_INIT which is 0 static Lock locks[SPINLOCK_COUNT]; // initialized to OS_SPINLOCK_INIT which is 0
#else #else
typedef _Atomic(uintptr_t) Lock; typedef _Atomic(uintptr_t) Lock;
/// Unlock a lock. This is a release operation. /// Unlock a lock. This is a release operation.
__inline static void unlock(Lock *l) { __inline static void unlock(Lock *l) {
__c11_atomic_store(l, 0, __ATOMIC_RELEASE); __c11_atomic_store(l, 0, __ATOMIC_RELEASE);
} }
/// Locks a lock. In the current implementation, this is potentially /// Locks a lock. In the current implementation, this is potentially
/// unbounded in the contended case. /// unbounded in the contended case.
__inline static void lock(Lock *l) { __inline static void lock(Lock *l) {
uintptr_t old = 0; uintptr_t old = 0;
while (!__c11_atomic_compare_exchange_weak(l, &old, 1, __ATOMIC_ACQUIRE, while (!__c11_atomic_compare_exchange_weak(l, &old, 1, __ATOMIC_ACQUIRE,
__ATOMIC_RELAXED)) __ATOMIC_RELAXED))
old = 0; old = 0;
} }
/// locks for atomic operations /// locks for atomic operations
static Lock locks[SPINLOCK_COUNT]; static Lock locks[SPINLOCK_COUNT];
#endif #endif
/// Returns a lock to use for a given pointer. /// Returns a lock to use for a given pointer.
static __inline Lock *lock_for_pointer(void *ptr) { static __inline Lock *lock_for_pointer(void *ptr) {
intptr_t hash = (intptr_t)ptr; intptr_t hash = (intptr_t)ptr;
// Disregard the lowest 4 bits. We want all values that may be part of the // Disregard the lowest 4 bits. We want all values that may be part of the
// same memory operation to hash to the same value and therefore use the same // same memory operation to hash to the same value and therefore use the same
// lock. // lock.
hash >>= 4; hash >>= 4;
// Use the next bits as the basis for the hash // Use the next bits as the basis for the hash
intptr_t low = hash & SPINLOCK_MASK; intptr_t low = hash & SPINLOCK_MASK;
// Now use the high(er) set of bits to perturb the hash, so that we don't // Now use the high(er) set of bits to perturb the hash, so that we don't
// get collisions from atomic fields in a single object // get collisions from atomic fields in a single object
hash >>= 16; hash >>= 16;
hash ^= low; hash ^= low;
// Return a pointer to the word to use // Return a pointer to the word to use
return locks + (hash & SPINLOCK_MASK); return locks + (hash & SPINLOCK_MASK);
} }
/// Macros for determining whether a size is lock free. Clang can not yet /// Macros for determining whether a size is lock free. Clang can not yet
/// codegen __atomic_is_lock_free(16), so for now we assume 16-byte values are /// codegen __atomic_is_lock_free(16), so for now we assume 16-byte values are
/// not lock free. /// not lock free.
#define IS_LOCK_FREE_1 __c11_atomic_is_lock_free(1) #define IS_LOCK_FREE_1 __c11_atomic_is_lock_free(1)
#define IS_LOCK_FREE_2 __c11_atomic_is_lock_free(2) #define IS_LOCK_FREE_2 __c11_atomic_is_lock_free(2)
#define IS_LOCK_FREE_4 __c11_atomic_is_lock_free(4) #define IS_LOCK_FREE_4 __c11_atomic_is_lock_free(4)
#define IS_LOCK_FREE_8 __c11_atomic_is_lock_free(8) #define IS_LOCK_FREE_8 __c11_atomic_is_lock_free(8)
#define IS_LOCK_FREE_16 0 #define IS_LOCK_FREE_16 0
/// Macro that calls the compiler-generated lock-free versions of functions /// Macro that calls the compiler-generated lock-free versions of functions
/// when they exist. /// when they exist.
#define LOCK_FREE_CASES() \ #define LOCK_FREE_CASES() \
do {\ do { \
switch (size) {\ switch (size) { \
case 1:\ case 1: \
if (IS_LOCK_FREE_1) {\ if (IS_LOCK_FREE_1) { \
LOCK_FREE_ACTION(uint8_t);\ LOCK_FREE_ACTION(uint8_t); \
}\ } \
break; \ break; \
case 2:\ case 2: \
if (IS_LOCK_FREE_2) {\ if (IS_LOCK_FREE_2) { \
LOCK_FREE_ACTION(uint16_t);\ LOCK_FREE_ACTION(uint16_t); \
}\ } \
break; \ break; \
case 4:\ case 4: \
if (IS_LOCK_FREE_4) {\ if (IS_LOCK_FREE_4) { \
LOCK_FREE_ACTION(uint32_t);\ LOCK_FREE_ACTION(uint32_t); \
}\ } \
break; \ break; \
case 8:\ case 8: \
if (IS_LOCK_FREE_8) {\ if (IS_LOCK_FREE_8) { \
LOCK_FREE_ACTION(uint64_t);\ LOCK_FREE_ACTION(uint64_t); \
}\ } \
break; \ break; \
case 16:\ case 16: \
if (IS_LOCK_FREE_16) {\ if (IS_LOCK_FREE_16) { \
/* FIXME: __uint128_t isn't available on 32 bit platforms. /* FIXME: __uint128_t isn't available on 32 bit platforms. \
LOCK_FREE_ACTION(__uint128_t);*/\ LOCK_FREE_ACTION(__uint128_t);*/ \
}\ } \
break; \ break; \
}\ } \
} while (0) } while (0)
/// An atomic load operation. This is atomic with respect to the source /// An atomic load operation. This is atomic with respect to the source
/// pointer only. /// pointer only.
void __atomic_load_c(int size, void *src, void *dest, int model) { void __atomic_load_c(int size, void *src, void *dest, int model) {
#define LOCK_FREE_ACTION(type) \ #define LOCK_FREE_ACTION(type) \
*((type*)dest) = __c11_atomic_load((_Atomic(type)*)src, model);\ *((type *)dest) = __c11_atomic_load((_Atomic(type) *)src, model); \
return; return;
LOCK_FREE_CASES(); LOCK_FREE_CASES();
#undef LOCK_FREE_ACTION #undef LOCK_FREE_ACTION
Lock *l = lock_for_pointer(src); Lock *l = lock_for_pointer(src);
lock(l); lock(l);
memcpy(dest, src, size); memcpy(dest, src, size);
unlock(l); unlock(l);
} }
/// An atomic store operation. This is atomic with respect to the destination /// An atomic store operation. This is atomic with respect to the destination
/// pointer only. /// pointer only.
void __atomic_store_c(int size, void *dest, void *src, int model) { void __atomic_store_c(int size, void *dest, void *src, int model) {
#define LOCK_FREE_ACTION(type) \ #define LOCK_FREE_ACTION(type) \
__c11_atomic_store((_Atomic(type)*)dest, *(type*)src, model);\ __c11_atomic_store((_Atomic(type) *)dest, *(type *)src, model); \
return; return;
LOCK_FREE_CASES(); LOCK_FREE_CASES();
#undef LOCK_FREE_ACTION #undef LOCK_FREE_ACTION
Lock *l = lock_for_pointer(dest); Lock *l = lock_for_pointer(dest);
lock(l); lock(l);
memcpy(dest, src, size); memcpy(dest, src, size);
unlock(l); unlock(l);
} }
/// Atomic compare and exchange operation. If the value at *ptr is identical /// Atomic compare and exchange operation. If the value at *ptr is identical
/// to the value at *expected, then this copies value at *desired to *ptr. If /// to the value at *expected, then this copies value at *desired to *ptr. If
/// they are not, then this stores the current value from *ptr in *expected. /// they are not, then this stores the current value from *ptr in *expected.
/// ///
/// This function returns 1 if the exchange takes place or 0 if it fails. /// This function returns 1 if the exchange takes place or 0 if it fails.
int __atomic_compare_exchange_c(int size, void *ptr, void *expected, int __atomic_compare_exchange_c(int size, void *ptr, void *expected,
void *desired, int success, int failure) { void *desired, int success, int failure) {
#define LOCK_FREE_ACTION(type) \ #define LOCK_FREE_ACTION(type) \
return __c11_atomic_compare_exchange_strong((_Atomic(type)*)ptr, (type*)expected,\ return __c11_atomic_compare_exchange_strong( \
*(type*)desired, success, failure) (_Atomic(type) *)ptr, (type *)expected, *(type *)desired, success, \
failure)
LOCK_FREE_CASES(); LOCK_FREE_CASES();
#undef LOCK_FREE_ACTION #undef LOCK_FREE_ACTION
Lock *l = lock_for_pointer(ptr); Lock *l = lock_for_pointer(ptr);
lock(l); lock(l);
if (memcmp(ptr, expected, size) == 0) { if (memcmp(ptr, expected, size) == 0) {
memcpy(ptr, desired, size); memcpy(ptr, desired, size);
unlock(l); unlock(l);
return 1; return 1;
} }
memcpy(expected, ptr, size); memcpy(expected, ptr, size);
unlock(l); unlock(l);
return 0; return 0;
} }
/// Performs an atomic exchange operation between two pointers. This is atomic /// Performs an atomic exchange operation between two pointers. This is atomic
/// with respect to the target address. /// with respect to the target address.
void __atomic_exchange_c(int size, void *ptr, void *val, void *old, int model) { void __atomic_exchange_c(int size, void *ptr, void *val, void *old, int model) {
#define LOCK_FREE_ACTION(type) \ #define LOCK_FREE_ACTION(type) \
*(type*)old = __c11_atomic_exchange((_Atomic(type)*)ptr, *(type*)val,\ *(type *)old = \
model);\ __c11_atomic_exchange((_Atomic(type) *)ptr, *(type *)val, model); \
return; return;
LOCK_FREE_CASES(); LOCK_FREE_CASES();
#undef LOCK_FREE_ACTION #undef LOCK_FREE_ACTION
Lock *l = lock_for_pointer(ptr); Lock *l = lock_for_pointer(ptr);
lock(l); lock(l);
memcpy(old, ptr, size); memcpy(old, ptr, size);
memcpy(ptr, val, size); memcpy(ptr, val, size);
unlock(l); unlock(l);
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Where the size is known at compile time, the compiler may emit calls to // Where the size is known at compile time, the compiler may emit calls to
// specialised versions of the above functions. // specialised versions of the above functions.
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#ifdef __SIZEOF_INT128__ #ifdef __SIZEOF_INT128__
#define OPTIMISED_CASES\ #define OPTIMISED_CASES \
OPTIMISED_CASE(1, IS_LOCK_FREE_1, uint8_t)\ OPTIMISED_CASE(1, IS_LOCK_FREE_1, uint8_t) \
OPTIMISED_CASE(2, IS_LOCK_FREE_2, uint16_t)\ OPTIMISED_CASE(2, IS_LOCK_FREE_2, uint16_t) \
OPTIMISED_CASE(4, IS_LOCK_FREE_4, uint32_t)\ OPTIMISED_CASE(4, IS_LOCK_FREE_4, uint32_t) \
OPTIMISED_CASE(8, IS_LOCK_FREE_8, uint64_t)\ OPTIMISED_CASE(8, IS_LOCK_FREE_8, uint64_t) \
OPTIMISED_CASE(16, IS_LOCK_FREE_16, __uint128_t) OPTIMISED_CASE(16, IS_LOCK_FREE_16, __uint128_t)
#else #else
#define OPTIMISED_CASES\ #define OPTIMISED_CASES \
OPTIMISED_CASE(1, IS_LOCK_FREE_1, uint8_t)\ OPTIMISED_CASE(1, IS_LOCK_FREE_1, uint8_t) \
OPTIMISED_CASE(2, IS_LOCK_FREE_2, uint16_t)\ OPTIMISED_CASE(2, IS_LOCK_FREE_2, uint16_t) \
OPTIMISED_CASE(4, IS_LOCK_FREE_4, uint32_t)\ OPTIMISED_CASE(4, IS_LOCK_FREE_4, uint32_t) \
OPTIMISED_CASE(8, IS_LOCK_FREE_8, uint64_t) OPTIMISED_CASE(8, IS_LOCK_FREE_8, uint64_t)
#endif #endif
#define OPTIMISED_CASE(n, lockfree, type)\ #define OPTIMISED_CASE(n, lockfree, type) \
type __atomic_load_##n(type *src, int model) {\ type __atomic_load_##n(type *src, int model) { \
if (lockfree)\ if (lockfree) \
return __c11_atomic_load((_Atomic(type)*)src, model);\ return __c11_atomic_load((_Atomic(type) *)src, model); \
Lock *l = lock_for_pointer(src);\ Lock *l = lock_for_pointer(src); \
lock(l);\ lock(l); \
type val = *src;\ type val = *src; \
unlock(l);\ unlock(l); \
return val;\ return val; \
} }
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type)\ #define OPTIMISED_CASE(n, lockfree, type) \
void __atomic_store_##n(type *dest, type val, int model) {\ void __atomic_store_##n(type *dest, type val, int model) { \
if (lockfree) {\ if (lockfree) { \
__c11_atomic_store((_Atomic(type)*)dest, val, model);\ __c11_atomic_store((_Atomic(type) *)dest, val, model); \
return;\ return; \
}\ } \
Lock *l = lock_for_pointer(dest);\ Lock *l = lock_for_pointer(dest); \
lock(l);\ lock(l); \
*dest = val;\ *dest = val; \
unlock(l);\ unlock(l); \
return;\ return; \
} }
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type)\ #define OPTIMISED_CASE(n, lockfree, type) \
type __atomic_exchange_##n(type *dest, type val, int model) {\ type __atomic_exchange_##n(type *dest, type val, int model) { \
if (lockfree)\ if (lockfree) \
return __c11_atomic_exchange((_Atomic(type)*)dest, val, model);\ return __c11_atomic_exchange((_Atomic(type) *)dest, val, model); \
Lock *l = lock_for_pointer(dest);\ Lock *l = lock_for_pointer(dest); \
lock(l);\ lock(l); \
type tmp = *dest;\ type tmp = *dest; \
*dest = val;\ *dest = val; \
unlock(l);\ unlock(l); \
return tmp;\ return tmp; \
} }
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type)\ #define OPTIMISED_CASE(n, lockfree, type) \
int __atomic_compare_exchange_##n(type *ptr, type *expected, type desired,\ int __atomic_compare_exchange_##n(type *ptr, type *expected, type desired, \
int success, int failure) {\ int success, int failure) { \
if (lockfree)\ if (lockfree) \
return __c11_atomic_compare_exchange_strong((_Atomic(type)*)ptr, expected, desired,\ return __c11_atomic_compare_exchange_strong( \
success, failure);\ (_Atomic(type) *)ptr, expected, desired, success, failure); \
Lock *l = lock_for_pointer(ptr);\ Lock *l = lock_for_pointer(ptr); \
lock(l);\ lock(l); \
if (*ptr == *expected) {\ if (*ptr == *expected) { \
*ptr = desired;\ *ptr = desired; \
unlock(l);\ unlock(l); \
return 1;\ return 1; \
}\ } \
*expected = *ptr;\ *expected = *ptr; \
unlock(l);\ unlock(l); \
return 0;\ return 0; \
} }
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Atomic read-modify-write operations for integers of various sizes. // Atomic read-modify-write operations for integers of various sizes.
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define ATOMIC_RMW(n, lockfree, type, opname, op) \ #define ATOMIC_RMW(n, lockfree, type, opname, op) \
type __atomic_fetch_##opname##_##n(type *ptr, type val, int model) {\ type __atomic_fetch_##opname##_##n(type *ptr, type val, int model) { \
if (lockfree) \ if (lockfree) \
return __c11_atomic_fetch_##opname((_Atomic(type)*)ptr, val, model);\ return __c11_atomic_fetch_##opname((_Atomic(type) *)ptr, val, model); \
Lock *l = lock_for_pointer(ptr);\ Lock *l = lock_for_pointer(ptr); \
lock(l);\ lock(l); \
type tmp = *ptr;\ type tmp = *ptr; \
*ptr = tmp op val;\ *ptr = tmp op val; \
unlock(l);\ unlock(l); \
return tmp;\ return tmp; \
} }
#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, add, +) #define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, add, +)
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, sub, -) #define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, sub, -)
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, and, &) #define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, and, &)
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, or, |) #define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, or, |)
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE
#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, xor, ^) #define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, xor, ^)
OPTIMISED_CASES OPTIMISED_CASES
#undef OPTIMISED_CASE #undef OPTIMISED_CASE

compiler-rt/trunk/lib/builtins/bswapsi2.c

/* ===-- bswapsi2.c - Implement __bswapsi2 ---------------------------------=== /* ===-- bswapsi2.c - Implement __bswapsi2 ---------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
* This file implements __bswapsi2 for the compiler_rt library. * This file implements __bswapsi2 for the compiler_rt library.
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI uint32_t __bswapsi2(uint32_t u) { COMPILER_RT_ABI uint32_t __bswapsi2(uint32_t u) {
return ( return ((((u)&0xff000000) >> 24) |
(((u)&0xff000000) >> 24) |
(((u)&0x00ff0000) >> 8) | (((u)&0x00ff0000) >> 8) |
(((u)&0x0000ff00) << 8) | (((u)&0x0000ff00) << 8) |
(((u)&0x000000ff) << 24)); (((u)&0x000000ff) << 24));
} }

compiler-rt/trunk/lib/builtins/clear_cache.c

/* ===-- clear_cache.c - Implement __clear_cache ---------------------------=== /* ===-- clear_cache.c - Implement __clear_cache ---------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#include <assert.h> #include <assert.h>
#include <stddef.h> #include <stddef.h>
#if __APPLE__ #if __APPLE__
#include <libkern/OSCacheControl.h> #include <libkern/OSCacheControl.h>
#endif #endif
#if defined(_WIN32) #if defined(_WIN32)
/* Forward declare Win32 APIs since the GCC mode driver does not handle the /* Forward declare Win32 APIs since the GCC mode driver does not handle the
newer SDKs as well as needed. */ newer SDKs as well as needed. */
uint32_t FlushInstructionCache(uintptr_t hProcess, void *lpBaseAddress, uint32_t FlushInstructionCache(uintptr_t hProcess, void *lpBaseAddress,
uintptr_t dwSize); uintptr_t dwSize);
uintptr_t GetCurrentProcess(void); uintptr_t GetCurrentProcess(void);
#endif #endif
#if defined(__FreeBSD__) && defined(__arm__) #if defined(__FreeBSD__) && defined(__arm__)
#include <sys/types.h>
#include <machine/sysarch.h> #include <machine/sysarch.h>
#include <sys/types.h>
#endif #endif
#if defined(__NetBSD__) && defined(__arm__) #if defined(__NetBSD__) && defined(__arm__)
#include <machine/sysarch.h> #include <machine/sysarch.h>
#endif #endif
#if defined(__OpenBSD__) && defined(__mips__) #if defined(__OpenBSD__) && defined(__mips__)
#include <sys/types.h>
#include <machine/sysarch.h> #include <machine/sysarch.h>
#include <sys/types.h>
#endif #endif
#if defined(__linux__) && defined(__mips__) #if defined(__linux__) && defined(__mips__)
#include <sys/cachectl.h> #include <sys/cachectl.h>
#include <sys/syscall.h> #include <sys/syscall.h>
#include <unistd.h> #include <unistd.h>
#if defined(__ANDROID__) && defined(__LP64__) #if defined(__ANDROID__) && defined(__LP64__)
/* /*
* clear_mips_cache - Invalidates instruction cache for Mips. * clear_mips_cache - Invalidates instruction cache for Mips.
*/ */
static void clear_mips_cache(const void* Addr, size_t Size) { static void clear_mips_cache(const void *Addr, size_t Size) {
__asm__ volatile ( __asm__ volatile(
".set push\n" ".set push\n"
".set noreorder\n" ".set noreorder\n"
".set noat\n" ".set noat\n"
"beq %[Size], $zero, 20f\n" /* If size == 0, branch around. */ "beq %[Size], $zero, 20f\n" /* If size == 0, branch around. */
"nop\n" "nop\n"
"daddu %[Size], %[Addr], %[Size]\n" /* Calculate end address + 1 */ "daddu %[Size], %[Addr], %[Size]\n" /* Calculate end address + 1 */
"rdhwr $v0, $1\n" /* Get step size for SYNCI. "rdhwr $v0, $1\n" /* Get step size for SYNCI.
$1 is $HW_SYNCI_Step */ $1 is $HW_SYNCI_Step */
"beq $v0, $zero, 20f\n" /* If no caches require "beq $v0, $zero, 20f\n" /* If no caches require
synchronization, branch synchronization, branch
around. */ around. */
"nop\n" "nop\n"
"10:\n" "10:\n"
"synci 0(%[Addr])\n" /* Synchronize all caches around "synci 0(%[Addr])\n" /* Synchronize all caches around
address. */ address. */
"daddu %[Addr], %[Addr], $v0\n" /* Add step size. */ "daddu %[Addr], %[Addr], $v0\n" /* Add step size. */
"sltu $at, %[Addr], %[Size]\n" /* Compare current with end "sltu $at, %[Addr], %[Size]\n" /* Compare current with end
address. */ address. */
"bne $at, $zero, 10b\n" /* Branch if more to do. */ "bne $at, $zero, 10b\n" /* Branch if more to do. */
"nop\n" "nop\n"
"sync\n" /* Clear memory hazards. */ "sync\n" /* Clear memory hazards. */
"20:\n" "20:\n"
"bal 30f\n" "bal 30f\n"
"nop\n" "nop\n"
"30:\n" "30:\n"
"daddiu $ra, $ra, 12\n" /* $ra has a value of $pc here. "daddiu $ra, $ra, 12\n" /* $ra has a value of $pc here.
Add offset of 12 to point to the Add offset of 12 to point to the
instruction after the last nop. instruction after the last nop.
*/ */
"jr.hb $ra\n" /* Return, clearing instruction "jr.hb $ra\n" /* Return, clearing instruction
hazards. */ hazards. */
"nop\n" "nop\n"
".set pop\n" ".set pop\n"
: [Addr] "+r"(Addr), [Size] "+r"(Size) : [ Addr ] "+r"(Addr), [ Size ] "+r"(Size)::"at", "ra", "v0", "memory");
:: "at", "ra", "v0", "memory"
);
} }
#endif #endif
#endif #endif
/* /*
* The compiler generates calls to __clear_cache() when creating * The compiler generates calls to __clear_cache() when creating
* trampoline functions on the stack for use with nested functions. * trampoline functions on the stack for use with nested functions.
* It is expected to invalidate the instruction cache for the * It is expected to invalidate the instruction cache for the
* specified range. * specified range.
*/ */
void __clear_cache(void *start, void *end) { void __clear_cache(void *start, void *end) {
#if __i386__ || __x86_64__ || defined(_M_IX86) || defined(_M_X64) #if __i386__ || __x86_64__ || defined(_M_IX86) || defined(_M_X64)
/* /*
* Intel processors have a unified instruction and data cache * Intel processors have a unified instruction and data cache
* so there is nothing to do * so there is nothing to do
*/ */
#elif defined(_WIN32) && (defined(__arm__) || defined(__aarch64__)) #elif defined(_WIN32) && (defined(__arm__) || defined(__aarch64__))
FlushInstructionCache(GetCurrentProcess(), start, end - start); FlushInstructionCache(GetCurrentProcess(), start, end - start);
#elif defined(__arm__) && !defined(__APPLE__) #elif defined(__arm__) && !defined(__APPLE__)
#if defined(__FreeBSD__) || defined(__NetBSD__) #if defined(__FreeBSD__) || defined(__NetBSD__)
struct arm_sync_icache_args arg; struct arm_sync_icache_args arg;
arg.addr = (uintptr_t)start; arg.addr = (uintptr_t)start;
arg.len = (uintptr_t)end - (uintptr_t)start; arg.len = (uintptr_t)end - (uintptr_t)start;
sysarch(ARM_SYNC_ICACHE, &arg); sysarch(ARM_SYNC_ICACHE, &arg);
#elif defined(__linux__) #elif defined(__linux__)
/* /*
* We used to include asm/unistd.h for the __ARM_NR_cacheflush define, but * We used to include asm/unistd.h for the __ARM_NR_cacheflush define, but
* it also brought many other unused defines, as well as a dependency on * it also brought many other unused defines, as well as a dependency on
* kernel headers to be installed. * kernel headers to be installed.
* *
* This value is stable at least since Linux 3.13 and should remain so for * This value is stable at least since Linux 3.13 and should remain so for
* compatibility reasons, warranting it's re-definition here. * compatibility reasons, warranting it's re-definition here.
*/ */
#define __ARM_NR_cacheflush 0x0f0002 #define __ARM_NR_cacheflush 0x0f0002
register int start_reg __asm("r0") = (int) (intptr_t) start; register int start_reg __asm("r0") = (int)(intptr_t)start;
const register int end_reg __asm("r1") = (int) (intptr_t) end; const register int end_reg __asm("r1") = (int)(intptr_t)end;
const register int flags __asm("r2") = 0; const register int flags __asm("r2") = 0;
const register int syscall_nr __asm("r7") = __ARM_NR_cacheflush; const register int syscall_nr __asm("r7") = __ARM_NR_cacheflush;
__asm __volatile("svc 0x0" __asm __volatile("svc 0x0"
: "=r"(start_reg) : "=r"(start_reg)
: "r"(syscall_nr), "r"(start_reg), "r"(end_reg), : "r"(syscall_nr), "r"(start_reg), "r"(end_reg), "r"(flags));
"r"(flags));
assert(start_reg == 0 && "Cache flush syscall failed."); assert(start_reg == 0 && "Cache flush syscall failed.");
#else #else
compilerrt_abort(); compilerrt_abort();
#endif #endif
#elif defined(__linux__) && defined(__mips__) #elif defined(__linux__) && defined(__mips__)
const uintptr_t start_int = (uintptr_t) start; const uintptr_t start_int = (uintptr_t)start;
const uintptr_t end_int = (uintptr_t) end; const uintptr_t end_int = (uintptr_t)end;
#if defined(__ANDROID__) && defined(__LP64__) #if defined(__ANDROID__) && defined(__LP64__)
// Call synci implementation for short address range. // Call synci implementation for short address range.
const uintptr_t address_range_limit = 256; const uintptr_t address_range_limit = 256;
if ((end_int - start_int) <= address_range_limit) { if ((end_int - start_int) <= address_range_limit) {
clear_mips_cache(start, (end_int - start_int)); clear_mips_cache(start, (end_int - start_int));
} else { } else {
syscall(__NR_cacheflush, start, (end_int - start_int), BCACHE); syscall(__NR_cacheflush, start, (end_int - start_int), BCACHE);
} }
#else #else
syscall(__NR_cacheflush, start, (end_int - start_int), BCACHE); syscall(__NR_cacheflush, start, (end_int - start_int), BCACHE);
#endif #endif
#elif defined(__mips__) && defined(__OpenBSD__) #elif defined(__mips__) && defined(__OpenBSD__)
cacheflush(start, (uintptr_t)end - (uintptr_t)start, BCACHE); cacheflush(start, (uintptr_t)end - (uintptr_t)start, BCACHE);
#elif defined(__aarch64__) && !defined(__APPLE__) #elif defined(__aarch64__) && !defined(__APPLE__)
uint64_t xstart = (uint64_t)(uintptr_t) start; uint64_t xstart = (uint64_t)(uintptr_t)start;
uint64_t xend = (uint64_t)(uintptr_t) end; uint64_t xend = (uint64_t)(uintptr_t)end;
uint64_t addr; uint64_t addr;
// Get Cache Type Info // Get Cache Type Info
uint64_t ctr_el0; uint64_t ctr_el0;
__asm __volatile("mrs %0, ctr_el0" : "=r"(ctr_el0)); __asm __volatile("mrs %0, ctr_el0" : "=r"(ctr_el0));
/* /*
* dc & ic instructions must use 64bit registers so we don't use * dc & ic instructions must use 64bit registers so we don't use
* uintptr_t in case this runs in an IPL32 environment. * uintptr_t in case this runs in an IPL32 environment.
*/ */
const size_t dcache_line_size = 4 << ((ctr_el0 >> 16) & 15); const size_t dcache_line_size = 4 << ((ctr_el0 >> 16) & 15);
for (addr = xstart & ~(dcache_line_size - 1); addr < xend; for (addr = xstart & ~(dcache_line_size - 1); addr < xend;
addr += dcache_line_size) addr += dcache_line_size)
__asm __volatile("dc cvau, %0" :: "r"(addr)); __asm __volatile("dc cvau, %0" ::"r"(addr));
__asm __volatile("dsb ish"); __asm __volatile("dsb ish");
const size_t icache_line_size = 4 << ((ctr_el0 >> 0) & 15); const size_t icache_line_size = 4 << ((ctr_el0 >> 0) & 15);
for (addr = xstart & ~(icache_line_size - 1); addr < xend; for (addr = xstart & ~(icache_line_size - 1); addr < xend;
addr += icache_line_size) addr += icache_line_size)
__asm __volatile("ic ivau, %0" :: "r"(addr)); __asm __volatile("ic ivau, %0" ::"r"(addr));
__asm __volatile("isb sy"); __asm __volatile("isb sy");
#elif defined (__powerpc64__) #elif defined(__powerpc64__)
const size_t line_size = 32; const size_t line_size = 32;
const size_t len = (uintptr_t)end - (uintptr_t)start; const size_t len = (uintptr_t)end - (uintptr_t)start;
const uintptr_t mask = ~(line_size - 1); const uintptr_t mask = ~(line_size - 1);
const uintptr_t start_line = ((uintptr_t)start) & mask; const uintptr_t start_line = ((uintptr_t)start) & mask;
const uintptr_t end_line = ((uintptr_t)start + len + line_size - 1) & mask; const uintptr_t end_line = ((uintptr_t)start + len + line_size - 1) & mask;
for (uintptr_t line = start_line; line < end_line; line += line_size) for (uintptr_t line = start_line; line < end_line; line += line_size)
__asm__ volatile("dcbf 0, %0" : : "r"(line)); __asm__ volatile("dcbf 0, %0" : : "r"(line));
__asm__ volatile("sync"); __asm__ volatile("sync");
for (uintptr_t line = start_line; line < end_line; line += line_size) for (uintptr_t line = start_line; line < end_line; line += line_size)
__asm__ volatile("icbi 0, %0" : : "r"(line)); __asm__ volatile("icbi 0, %0" : : "r"(line));
__asm__ volatile("isync"); __asm__ volatile("isync");
#else #else
#if __APPLE__ #if __APPLE__
/* On Darwin, sys_icache_invalidate() provides this functionality */ /* On Darwin, sys_icache_invalidate() provides this functionality */
sys_icache_invalidate(start, end-start); sys_icache_invalidate(start, end - start);
#else #else
compilerrt_abort(); compilerrt_abort();
#endif #endif
#endif #endif
} }

compiler-rt/trunk/lib/builtins/clzdi2.c

Show All 10 Lines
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: the number of leading 0-bits */ /* Returns: the number of leading 0-bits */
#if !defined(__clang__) && \ #if !defined(__clang__) && \
((defined(__sparc__) && defined(__arch64__)) || \ ((defined(__sparc__) && defined(__arch64__)) || defined(__mips64) || \
defined(__mips64) || \
(defined(__riscv) && __SIZEOF_POINTER__ >= 8)) (defined(__riscv) && __SIZEOF_POINTER__ >= 8))
/* On 64-bit architectures with neither a native clz instruction nor a native /* On 64-bit architectures with neither a native clz instruction nor a native
* ctz instruction, gcc resolves __builtin_clz to __clzdi2 rather than * ctz instruction, gcc resolves __builtin_clz to __clzdi2 rather than
* __clzsi2, leading to infinite recursion. */ * __clzsi2, leading to infinite recursion. */
#define __builtin_clz(a) __clzsi2(a) #define __builtin_clz(a) __clzsi2(a)
extern si_int __clzsi2(si_int); extern si_int __clzsi2(si_int);
#endif #endif
/* Precondition: a != 0 */ /* Precondition: a != 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __clzdi2(di_int a) {
__clzdi2(di_int a)
{
dwords x; dwords x;
x.all = a; x.all = a;
const si_int f = -(x.s.high == 0); const si_int f = -(x.s.high == 0);
return __builtin_clz((x.s.high & ~f) | (x.s.low & f)) + return __builtin_clz((x.s.high & ~f) | (x.s.low & f)) +
(f & ((si_int)(sizeof(si_int) * CHAR_BIT))); (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
} }

compiler-rt/trunk/lib/builtins/clzsi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: the number of leading 0-bits */ /* Returns: the number of leading 0-bits */
/* Precondition: a != 0 */ /* Precondition: a != 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __clzsi2(si_int a) {
__clzsi2(si_int a)
{
su_int x = (su_int)a; su_int x = (su_int)a;
si_int t = ((x & 0xFFFF0000) == 0) << 4; /* if (x is small) t = 16 else 0 */ si_int t = ((x & 0xFFFF0000) == 0) << 4; /* if (x is small) t = 16 else 0 */
x >>= 16 - t; /* x = [0 - 0xFFFF] */ x >>= 16 - t; /* x = [0 - 0xFFFF] */
su_int r = t; /* r = [0, 16] */ su_int r = t; /* r = [0, 16] */
/* return r + clz(x) */ /* return r + clz(x) */
t = ((x & 0xFF00) == 0) << 3; t = ((x & 0xFF00) == 0) << 3;
x >>= 8 - t; /* x = [0 - 0xFF] */ x >>= 8 - t; /* x = [0 - 0xFF] */
r += t; /* r = [0, 8, 16, 24] */ r += t; /* r = [0, 8, 16, 24] */
/* return r + clz(x) */ /* return r + clz(x) */
t = ((x & 0xF0) == 0) << 2; t = ((x & 0xF0) == 0) << 2;
x >>= 4 - t; /* x = [0 - 0xF] */ x >>= 4 - t; /* x = [0 - 0xF] */
r += t; /* r = [0, 4, 8, 12, 16, 20, 24, 28] */ r += t; /* r = [0, 4, 8, 12, 16, 20, 24, 28] */
/* return r + clz(x) */ /* return r + clz(x) */
t = ((x & 0xC) == 0) << 1; t = ((x & 0xC) == 0) << 1;
x >>= 2 - t; /* x = [0 - 3] */ x >>= 2 - t; /* x = [0 - 3] */
r += t; /* r = [0 - 30] and is even */ r += t; /* r = [0 - 30] and is even */
/* return r + clz(x) */ /* return r + clz(x) */
/* switch (x) /* switch (x)
* { * {
* case 0: * case 0:
* return r + 2; * return r + 2;
* case 1: * case 1:
* return r + 1; * return r + 1;
* case 2: * case 2:
* case 3: * case 3:
* return r; * return r;
* } * }
*/ */
return r + ((2 - x) & -((x & 2) == 0)); return r + ((2 - x) & -((x & 2) == 0));
} }

compiler-rt/trunk/lib/builtins/clzti2.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: the number of leading 0-bits */ /* Returns: the number of leading 0-bits */
/* Precondition: a != 0 */ /* Precondition: a != 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __clzti2(ti_int a) {
__clzti2(ti_int a)
{
twords x; twords x;
x.all = a; x.all = a;
const di_int f = -(x.s.high == 0); const di_int f = -(x.s.high == 0);
return __builtin_clzll((x.s.high & ~f) | (x.s.low & f)) + return __builtin_clzll((x.s.high & ~f) | (x.s.low & f)) +
((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT))); ((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT)));
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/cmpdi2.c

/* ===-- cmpdi2.c - Implement __cmpdi2 -------------------------------------=== /* ===-- cmpdi2.c - Implement __cmpdi2 -------------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
* This file implements __cmpdi2 for the compiler_rt library. * This file implements __cmpdi2 for the compiler_rt library.
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: if (a < b) returns 0 /* Returns: if (a < b) returns 0
* if (a == b) returns 1 * if (a == b) returns 1
* if (a > b) returns 2 * if (a > b) returns 2
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __cmpdi2(di_int a, di_int b) {
__cmpdi2(di_int a, di_int b)
{
dwords x; dwords x;
x.all = a; x.all = a;
dwords y; dwords y;
y.all = b; y.all = b;
if (x.s.high < y.s.high) if (x.s.high < y.s.high)
return 0; return 0;
if (x.s.high > y.s.high) if (x.s.high > y.s.high)
return 2; return 2;
if (x.s.low < y.s.low) if (x.s.low < y.s.low)
return 0; return 0;
if (x.s.low > y.s.low) if (x.s.low > y.s.low)
return 2; return 2;
return 1; return 1;
} }
#ifdef __ARM_EABI__ #ifdef __ARM_EABI__
/* Returns: if (a < b) returns -1 /* Returns: if (a < b) returns -1
* if (a == b) returns 0 * if (a == b) returns 0
* if (a > b) returns 1 * if (a > b) returns 1
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __aeabi_lcmp(di_int a, di_int b) {
__aeabi_lcmp(di_int a, di_int b)
{
return __cmpdi2(a, b) - 1; return __cmpdi2(a, b) - 1;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/cmpti2.c

Show All 14 Lines
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: if (a < b) returns 0 /* Returns: if (a < b) returns 0
* if (a == b) returns 1 * if (a == b) returns 1
* if (a > b) returns 2 * if (a > b) returns 2
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __cmpti2(ti_int a, ti_int b) {
__cmpti2(ti_int a, ti_int b)
{
twords x; twords x;
x.all = a; x.all = a;
twords y; twords y;
y.all = b; y.all = b;
if (x.s.high < y.s.high) if (x.s.high < y.s.high)
return 0; return 0;
if (x.s.high > y.s.high) if (x.s.high > y.s.high)
return 2; return 2;
if (x.s.low < y.s.low) if (x.s.low < y.s.low)
return 0; return 0;
if (x.s.low > y.s.low) if (x.s.low > y.s.low)
return 2; return 2;
return 1; return 1;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/comparedf2.c

Show All 33 Lines
// Note that __ledf2( ) and __gedf2( ) are identical except in their handling of // Note that __ledf2( ) and __gedf2( ) are identical except in their handling of
// NaN values. // NaN values.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
enum LE_RESULT { enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 };
LE_LESS = -1,
LE_EQUAL = 0,
LE_GREATER = 1,
LE_UNORDERED = 1
};
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __ledf2(fp_t a, fp_t b) {
__ledf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
// If either a or b is NaN, they are unordered. // If either a or b is NaN, they are unordered.
if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED; if (aAbs > infRep || bAbs > infRep)
return LE_UNORDERED;
// If a and b are both zeros, they are equal. // If a and b are both zeros, they are equal.
if ((aAbs | bAbs) == 0) return LE_EQUAL; if ((aAbs | bAbs) == 0)
return LE_EQUAL;
// If at least one of a and b is positive, we get the same result comparing // If at least one of a and b is positive, we get the same result comparing
// a and b as signed integers as we would with a floating-point compare. // a and b as signed integers as we would with a floating-point compare.
if ((aInt & bInt) >= 0) { if ((aInt & bInt) >= 0) {
if (aInt < bInt) return LE_LESS; if (aInt < bInt)
else if (aInt == bInt) return LE_EQUAL; return LE_LESS;
else return LE_GREATER; else if (aInt == bInt)
return LE_EQUAL;
else
return LE_GREATER;
} }
// Otherwise, both are negative, so we need to flip the sense of the // Otherwise, both are negative, so we need to flip the sense of the
// comparison to get the correct result. (This assumes a twos- or ones- // comparison to get the correct result. (This assumes a twos- or ones-
// complement integer representation; if integers are represented in a // complement integer representation; if integers are represented in a
// sign-magnitude representation, then this flip is incorrect). // sign-magnitude representation, then this flip is incorrect).
else { else {
if (aInt > bInt) return LE_LESS; if (aInt > bInt)
else if (aInt == bInt) return LE_EQUAL; return LE_LESS;
else return LE_GREATER; else if (aInt == bInt)
return LE_EQUAL;
else
return LE_GREATER;
} }
} }
#if defined(__ELF__) #if defined(__ELF__)
// Alias for libgcc compatibility // Alias for libgcc compatibility
FNALIAS(__cmpdf2, __ledf2); FNALIAS(__cmpdf2, __ledf2);
#endif #endif
enum GE_RESULT { enum GE_RESULT {
GE_LESS = -1, GE_LESS = -1,
GE_EQUAL = 0, GE_EQUAL = 0,
GE_GREATER = 1, GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED GE_UNORDERED = -1 // Note: different from LE_UNORDERED
}; };
COMPILER_RT_ABI enum GE_RESULT COMPILER_RT_ABI enum GE_RESULT __gedf2(fp_t a, fp_t b) {
__gedf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED; if (aAbs > infRep || bAbs > infRep)
if ((aAbs | bAbs) == 0) return GE_EQUAL; return GE_UNORDERED;
if ((aAbs | bAbs) == 0)
return GE_EQUAL;
if ((aInt & bInt) >= 0) { if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS; if (aInt < bInt)
else if (aInt == bInt) return GE_EQUAL; return GE_LESS;
else return GE_GREATER; else if (aInt == bInt)
return GE_EQUAL;
else
return GE_GREATER;
} else { } else {
if (aInt > bInt) return GE_LESS; if (aInt > bInt)
else if (aInt == bInt) return GE_EQUAL; return GE_LESS;
else return GE_GREATER; else if (aInt == bInt)
return GE_EQUAL;
else
return GE_GREATER;
} }
} }
COMPILER_RT_ABI int COMPILER_RT_ABI int __unorddf2(fp_t a, fp_t b) {
__unorddf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep; return aAbs > infRep || bAbs > infRep;
} }
// The following are alternative names for the preceding routines. // The following are alternative names for the preceding routines.
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __eqdf2(fp_t a, fp_t b) { return __ledf2(a, b); }
__eqdf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __ltdf2(fp_t a, fp_t b) { return __ledf2(a, b); }
__ltdf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __nedf2(fp_t a, fp_t b) { return __ledf2(a, b); }
__nedf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}
COMPILER_RT_ABI enum GE_RESULT COMPILER_RT_ABI enum GE_RESULT __gtdf2(fp_t a, fp_t b) { return __gedf2(a, b); }
__gtdf2(fp_t a, fp_t b) {
return __gedf2(a, b);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) { AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) { return __unorddf2(a, b); }
return __unorddf2(a, b);
}
#else #else
AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unorddf2); AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unorddf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/comparesf2.c

Show All 33 Lines
// Note that __lesf2( ) and __gesf2( ) are identical except in their handling of // Note that __lesf2( ) and __gesf2( ) are identical except in their handling of
// NaN values. // NaN values.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
enum LE_RESULT { enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 };
LE_LESS = -1,
LE_EQUAL = 0,
LE_GREATER = 1,
LE_UNORDERED = 1
};
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __lesf2(fp_t a, fp_t b) {
__lesf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
// If either a or b is NaN, they are unordered. // If either a or b is NaN, they are unordered.
if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED; if (aAbs > infRep || bAbs > infRep)
return LE_UNORDERED;
// If a and b are both zeros, they are equal. // If a and b are both zeros, they are equal.
if ((aAbs | bAbs) == 0) return LE_EQUAL; if ((aAbs | bAbs) == 0)
return LE_EQUAL;
// If at least one of a and b is positive, we get the same result comparing // If at least one of a and b is positive, we get the same result comparing
// a and b as signed integers as we would with a fp_ting-point compare. // a and b as signed integers as we would with a fp_ting-point compare.
if ((aInt & bInt) >= 0) { if ((aInt & bInt) >= 0) {
if (aInt < bInt) return LE_LESS; if (aInt < bInt)
else if (aInt == bInt) return LE_EQUAL; return LE_LESS;
else return LE_GREATER; else if (aInt == bInt)
return LE_EQUAL;
else
return LE_GREATER;
} }
// Otherwise, both are negative, so we need to flip the sense of the // Otherwise, both are negative, so we need to flip the sense of the
// comparison to get the correct result. (This assumes a twos- or ones- // comparison to get the correct result. (This assumes a twos- or ones-
// complement integer representation; if integers are represented in a // complement integer representation; if integers are represented in a
// sign-magnitude representation, then this flip is incorrect). // sign-magnitude representation, then this flip is incorrect).
else { else {
if (aInt > bInt) return LE_LESS; if (aInt > bInt)
else if (aInt == bInt) return LE_EQUAL; return LE_LESS;
else return LE_GREATER; else if (aInt == bInt)
return LE_EQUAL;
else
return LE_GREATER;
} }
} }
#if defined(__ELF__) #if defined(__ELF__)
// Alias for libgcc compatibility // Alias for libgcc compatibility
FNALIAS(__cmpsf2, __lesf2); FNALIAS(__cmpsf2, __lesf2);
#endif #endif
enum GE_RESULT { enum GE_RESULT {
GE_LESS = -1, GE_LESS = -1,
GE_EQUAL = 0, GE_EQUAL = 0,
GE_GREATER = 1, GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED GE_UNORDERED = -1 // Note: different from LE_UNORDERED
}; };
COMPILER_RT_ABI enum GE_RESULT COMPILER_RT_ABI enum GE_RESULT __gesf2(fp_t a, fp_t b) {
__gesf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED; if (aAbs > infRep || bAbs > infRep)
if ((aAbs | bAbs) == 0) return GE_EQUAL; return GE_UNORDERED;
if ((aAbs | bAbs) == 0)
return GE_EQUAL;
if ((aInt & bInt) >= 0) { if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS; if (aInt < bInt)
else if (aInt == bInt) return GE_EQUAL; return GE_LESS;
else return GE_GREATER; else if (aInt == bInt)
return GE_EQUAL;
else
return GE_GREATER;
} else { } else {
if (aInt > bInt) return GE_LESS; if (aInt > bInt)
else if (aInt == bInt) return GE_EQUAL; return GE_LESS;
else return GE_GREATER; else if (aInt == bInt)
return GE_EQUAL;
else
return GE_GREATER;
} }
} }
COMPILER_RT_ABI int COMPILER_RT_ABI int __unordsf2(fp_t a, fp_t b) {
__unordsf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep; return aAbs > infRep || bAbs > infRep;
} }
// The following are alternative names for the preceding routines. // The following are alternative names for the preceding routines.
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __eqsf2(fp_t a, fp_t b) { return __lesf2(a, b); }
__eqsf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __ltsf2(fp_t a, fp_t b) { return __lesf2(a, b); }
__ltsf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}
COMPILER_RT_ABI enum LE_RESULT COMPILER_RT_ABI enum LE_RESULT __nesf2(fp_t a, fp_t b) { return __lesf2(a, b); }
__nesf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}
COMPILER_RT_ABI enum GE_RESULT COMPILER_RT_ABI enum GE_RESULT __gtsf2(fp_t a, fp_t b) { return __gesf2(a, b); }
__gtsf2(fp_t a, fp_t b) {
return __gesf2(a, b);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) { AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) { return __unordsf2(a, b); }
return __unordsf2(a, b);
}
#else #else
AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unordsf2); AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unordsf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/comparetf2.c

Show All 34 Lines
// NaN values. // NaN values.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
enum LE_RESULT { enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 };
LE_LESS = -1,
LE_EQUAL = 0,
LE_GREATER = 1,
LE_UNORDERED = 1
};
COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) { COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
// If either a or b is NaN, they are unordered. // If either a or b is NaN, they are unordered.
if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED; if (aAbs > infRep || bAbs > infRep)
return LE_UNORDERED;
// If a and b are both zeros, they are equal. // If a and b are both zeros, they are equal.
if ((aAbs | bAbs) == 0) return LE_EQUAL; if ((aAbs | bAbs) == 0)
return LE_EQUAL;
// If at least one of a and b is positive, we get the same result comparing // If at least one of a and b is positive, we get the same result comparing
// a and b as signed integers as we would with a floating-point compare. // a and b as signed integers as we would with a floating-point compare.
if ((aInt & bInt) >= 0) { if ((aInt & bInt) >= 0) {
if (aInt < bInt) return LE_LESS; if (aInt < bInt)
else if (aInt == bInt) return LE_EQUAL; return LE_LESS;
else return LE_GREATER; else if (aInt == bInt)
} return LE_EQUAL;
else { else
return LE_GREATER;
} else {
// Otherwise, both are negative, so we need to flip the sense of the // Otherwise, both are negative, so we need to flip the sense of the
// comparison to get the correct result. (This assumes a twos- or ones- // comparison to get the correct result. (This assumes a twos- or ones-
// complement integer representation; if integers are represented in a // complement integer representation; if integers are represented in a
// sign-magnitude representation, then this flip is incorrect). // sign-magnitude representation, then this flip is incorrect).
if (aInt > bInt) return LE_LESS; if (aInt > bInt)
else if (aInt == bInt) return LE_EQUAL; return LE_LESS;
else return LE_GREATER; else if (aInt == bInt)
return LE_EQUAL;
else
return LE_GREATER;
} }
} }
#if defined(__ELF__) #if defined(__ELF__)
// Alias for libgcc compatibility // Alias for libgcc compatibility
FNALIAS(__cmptf2, __letf2); FNALIAS(__cmptf2, __letf2);
#endif #endif
enum GE_RESULT { enum GE_RESULT {
GE_LESS = -1, GE_LESS = -1,
GE_EQUAL = 0, GE_EQUAL = 0,
GE_GREATER = 1, GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED GE_UNORDERED = -1 // Note: different from LE_UNORDERED
}; };
COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) { COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED; if (aAbs > infRep || bAbs > infRep)
if ((aAbs | bAbs) == 0) return GE_EQUAL; return GE_UNORDERED;
if ((aAbs | bAbs) == 0)
return GE_EQUAL;
if ((aInt & bInt) >= 0) { if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS; if (aInt < bInt)
else if (aInt == bInt) return GE_EQUAL; return GE_LESS;
else return GE_GREATER; else if (aInt == bInt)
return GE_EQUAL;
else
return GE_GREATER;
} else { } else {
if (aInt > bInt) return GE_LESS; if (aInt > bInt)
else if (aInt == bInt) return GE_EQUAL; return GE_LESS;
else return GE_GREATER; else if (aInt == bInt)
return GE_EQUAL;
else
return GE_GREATER;
} }
} }
COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) { COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep; return aAbs > infRep || bAbs > infRep;
} }
// The following are alternative names for the preceding routines. // The following are alternative names for the preceding routines.
COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) { COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) { return __letf2(a, b); }
return __letf2(a, b);
}
COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) { COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) { return __letf2(a, b); }
return __letf2(a, b);
}
COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) { COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) { return __letf2(a, b); }
return __letf2(a, b);
}
COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) { COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) { return __getf2(a, b); }
return __getf2(a, b);
}
#endif #endif

compiler-rt/trunk/lib/builtins/cpu_model.c

//===-- cpu_model.c - Support for __cpu_model builtin ------------*- C -*-===// //===-- cpu_model.c - Support for __cpu_model builtin ------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file is based on LLVM's lib/Support/Host.cpp. // This file is based on LLVM's lib/Support/Host.cpp.
// It implements the operating system Host concept and builtin // It implements the operating system Host concept and builtin
// __cpu_model for the compiler_rt library, for x86 only. // __cpu_model for the compiler_rt library, for x86 only.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if (defined(__i386__) || defined(_M_IX86) || \ #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || \
defined(__x86_64__) || defined(_M_X64)) && \ defined(_M_X64)) && \
(defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)) (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER))
#include <assert.h> #include <assert.h>
#define bool int #define bool int
#define true 1 #define true 1
#define false 0 #define false 0
▲ Show 20 Lines • Show All 237 Lines • ▼ Show 20 Lines if (*Family == 6 || *Family == 0xf) {
if (*Family == 0xf) if (*Family == 0xf)
// Examine extended family ID if family ID is F. // Examine extended family ID if family ID is F.
*Family += (EAX >> 20) & 0xff; // Bits 20 - 27 *Family += (EAX >> 20) & 0xff; // Bits 20 - 27
// Examine extended model ID if family ID is 6 or F. // Examine extended model ID if family ID is 6 or F.
*Model += ((EAX >> 16) & 0xf) << 4; // Bits 16 - 19 *Model += ((EAX >> 16) & 0xf) << 4; // Bits 16 - 19
} }
} }
static void static void getIntelProcessorTypeAndSubtype(unsigned Family, unsigned Model,
getIntelProcessorTypeAndSubtype(unsigned Family, unsigned Model, unsigned Brand_id,
unsigned Brand_id, unsigned Features, unsigned Features,
unsigned Features2, unsigned *Type, unsigned Features2, unsigned *Type,
unsigned *Subtype) { unsigned *Subtype) {
if (Brand_id != 0) if (Brand_id != 0)
return; return;
switch (Family) { switch (Family) {
case 6: case 6:
switch (Model) { switch (Model) {
case 0x0f: // Intel Core 2 Duo processor, Intel Core 2 Duo mobile case 0x0f: // Intel Core 2 Duo processor, Intel Core 2 Duo mobile
// processor, Intel Core 2 Quad processor, Intel Core 2 Quad // processor, Intel Core 2 Quad processor, Intel Core 2 Quad
// mobile processor, Intel Core 2 Extreme processor, Intel // mobile processor, Intel Core 2 Extreme processor, Intel
Show All 9 Lines case 0x1d: // Intel Xeon processor MP. All processors are manufactured using
// the 45 nm process. // the 45 nm process.
*Type = INTEL_CORE2; // "penryn" *Type = INTEL_CORE2; // "penryn"
break; break;
case 0x1a: // Intel Core i7 processor and Intel Xeon processor. All case 0x1a: // Intel Core i7 processor and Intel Xeon processor. All
// processors are manufactured using the 45 nm process. // processors are manufactured using the 45 nm process.
case 0x1e: // Intel(R) Core(TM) i7 CPU 870 @ 2.93GHz. case 0x1e: // Intel(R) Core(TM) i7 CPU 870 @ 2.93GHz.
// As found in a Summer 2010 model iMac. // As found in a Summer 2010 model iMac.
case 0x1f: case 0x1f:
case 0x2e: // Nehalem EX case 0x2e: // Nehalem EX
*Type = INTEL_COREI7; // "nehalem" *Type = INTEL_COREI7; // "nehalem"
*Subtype = INTEL_COREI7_NEHALEM; *Subtype = INTEL_COREI7_NEHALEM;
break; break;
case 0x25: // Intel Core i7, laptop version. case 0x25: // Intel Core i7, laptop version.
case 0x2c: // Intel Core i7 processor and Intel Xeon processor. All case 0x2c: // Intel Core i7 processor and Intel Xeon processor. All
// processors are manufactured using the 32 nm process. // processors are manufactured using the 32 nm process.
case 0x2f: // Westmere EX case 0x2f: // Westmere EX
*Type = INTEL_COREI7; // "westmere" *Type = INTEL_COREI7; // "westmere"
*Subtype = INTEL_COREI7_WESTMERE; *Subtype = INTEL_COREI7_WESTMERE;
break; break;
case 0x2a: // Intel Core i7 processor. All processors are manufactured case 0x2a: // Intel Core i7 processor. All processors are manufactured
// using the 32 nm process. // using the 32 nm process.
case 0x2d: case 0x2d:
*Type = INTEL_COREI7; //"sandybridge" *Type = INTEL_COREI7; //"sandybridge"
*Subtype = INTEL_COREI7_SANDYBRIDGE; *Subtype = INTEL_COREI7_SANDYBRIDGE;
break; break;
case 0x3a: case 0x3a:
case 0x3e: // Ivy Bridge EP case 0x3e: // Ivy Bridge EP
*Type = INTEL_COREI7; // "ivybridge" *Type = INTEL_COREI7; // "ivybridge"
*Subtype = INTEL_COREI7_IVYBRIDGE; *Subtype = INTEL_COREI7_IVYBRIDGE;
break; break;
// Haswell: // Haswell:
case 0x3c: case 0x3c:
case 0x3f: case 0x3f:
case 0x45: case 0x45:
case 0x46: case 0x46:
*Type = INTEL_COREI7; // "haswell" *Type = INTEL_COREI7; // "haswell"
*Subtype = INTEL_COREI7_HASWELL; *Subtype = INTEL_COREI7_HASWELL;
break; break;
// Broadwell: // Broadwell:
case 0x3d: case 0x3d:
case 0x47: case 0x47:
case 0x4f: case 0x4f:
case 0x56: case 0x56:
*Type = INTEL_COREI7; // "broadwell" *Type = INTEL_COREI7; // "broadwell"
*Subtype = INTEL_COREI7_BROADWELL; *Subtype = INTEL_COREI7_BROADWELL;
break; break;
// Skylake: // Skylake:
case 0x4e: // Skylake mobile case 0x4e: // Skylake mobile
case 0x5e: // Skylake desktop case 0x5e: // Skylake desktop
case 0x8e: // Kaby Lake mobile case 0x8e: // Kaby Lake mobile
case 0x9e: // Kaby Lake desktop case 0x9e: // Kaby Lake desktop
*Type = INTEL_COREI7; // "skylake" *Type = INTEL_COREI7; // "skylake"
*Subtype = INTEL_COREI7_SKYLAKE; *Subtype = INTEL_COREI7_SKYLAKE;
break; break;
// Skylake Xeon: // Skylake Xeon:
case 0x55: case 0x55:
*Type = INTEL_COREI7; *Type = INTEL_COREI7;
if (Features2 & (1 << (FEATURE_AVX512VNNI - 32))) if (Features2 & (1 << (FEATURE_AVX512VNNI - 32)))
Show All 39 Lines case 0x57:
break; break;
case 0x85: case 0x85:
*Type = INTEL_KNM; // knm *Type = INTEL_KNM; // knm
break; break;
default: // Unknown family 6 CPU. default: // Unknown family 6 CPU.
break; break;
break; break;
} }
default: default:
break; // Unknown. break; // Unknown.
} }
} }
static void getAMDProcessorTypeAndSubtype(unsigned Family, unsigned Model, static void getAMDProcessorTypeAndSubtype(unsigned Family, unsigned Model,
unsigned Features, unsigned Features2, unsigned Features, unsigned Features2,
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf, static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf,
unsigned *FeaturesOut, unsigned *FeaturesOut,
unsigned *Features2Out) { unsigned *Features2Out) {
unsigned Features = 0; unsigned Features = 0;
unsigned Features2 = 0; unsigned Features2 = 0;
unsigned EAX, EBX; unsigned EAX, EBX;
#define setFeature(F) \ #define setFeature(F) \
do { \ do { \
if (F < 32) \ if (F < 32) \
Features |= 1U << (F & 0x1f); \ Features |= 1U << (F & 0x1f); \
else if (F < 64) \ else if (F < 64) \
Features2 |= 1U << ((F - 32) & 0x1f); \ Features2 |= 1U << ((F - 32) & 0x1f); \
} while (0) } while (0)
if ((EDX >> 15) & 1) if ((EDX >> 15) & 1)
setFeature(FEATURE_CMOV); setFeature(FEATURE_CMOV);
if ((EDX >> 23) & 1) if ((EDX >> 23) & 1)
setFeature(FEATURE_MMX); setFeature(FEATURE_MMX);
if ((EDX >> 25) & 1) if ((EDX >> 25) & 1)
setFeature(FEATURE_SSE); setFeature(FEATURE_SSE);
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines
unsigned int __cpu_features2; unsigned int __cpu_features2;
/* A constructor function that is sets __cpu_model and __cpu_features2 with /* A constructor function that is sets __cpu_model and __cpu_features2 with
the right values. This needs to run only once. This constructor is the right values. This needs to run only once. This constructor is
given the highest priority and it should run before constructors without given the highest priority and it should run before constructors without
the priority set. However, it still runs after ifunc initializers and the priority set. However, it still runs after ifunc initializers and
needs to be called explicitly there. */ needs to be called explicitly there. */
int CONSTRUCTOR_ATTRIBUTE int CONSTRUCTOR_ATTRIBUTE __cpu_indicator_init(void) {
__cpu_indicator_init(void) {
unsigned EAX, EBX, ECX, EDX; unsigned EAX, EBX, ECX, EDX;
unsigned MaxLeaf = 5; unsigned MaxLeaf = 5;
unsigned Vendor; unsigned Vendor;
unsigned Model, Family, Brand_id; unsigned Model, Family, Brand_id;
unsigned Features = 0; unsigned Features = 0;
unsigned Features2 = 0; unsigned Features2 = 0;
/* This function needs to run just once. */ /* This function needs to run just once. */
Show All 15 Linesint CONSTRUCTOR_ATTRIBUTE __cpu_indicator_init(void) {
/* Find available features. */ /* Find available features. */
getAvailableFeatures(ECX, EDX, MaxLeaf, &Features, &Features2); getAvailableFeatures(ECX, EDX, MaxLeaf, &Features, &Features2);
__cpu_model.__cpu_features[0] = Features; __cpu_model.__cpu_features[0] = Features;
__cpu_features2 = Features2; __cpu_features2 = Features2;
if (Vendor == SIG_INTEL) { if (Vendor == SIG_INTEL) {
/* Get CPU type. */ /* Get CPU type. */
getIntelProcessorTypeAndSubtype(Family, Model, Brand_id, Features, getIntelProcessorTypeAndSubtype(Family, Model, Brand_id, Features,
Features2, Features2, &(__cpu_model.__cpu_type),
&(__cpu_model.__cpu_type),
&(__cpu_model.__cpu_subtype)); &(__cpu_model.__cpu_subtype));
__cpu_model.__cpu_vendor = VENDOR_INTEL; __cpu_model.__cpu_vendor = VENDOR_INTEL;
} else if (Vendor == SIG_AMD) { } else if (Vendor == SIG_AMD) {
/* Get CPU type. */ /* Get CPU type. */
getAMDProcessorTypeAndSubtype(Family, Model, Features, Features2, getAMDProcessorTypeAndSubtype(Family, Model, Features, Features2,
&(__cpu_model.__cpu_type), &(__cpu_model.__cpu_type),
&(__cpu_model.__cpu_subtype)); &(__cpu_model.__cpu_subtype));
__cpu_model.__cpu_vendor = VENDOR_AMD; __cpu_model.__cpu_vendor = VENDOR_AMD;
Show All 11 Lines

compiler-rt/trunk/lib/builtins/ctzdi2.c

Show All 10 Lines
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: the number of trailing 0-bits */ /* Returns: the number of trailing 0-bits */
#if !defined(__clang__) && \ #if !defined(__clang__) && \
((defined(__sparc__) && defined(__arch64__)) || \ ((defined(__sparc__) && defined(__arch64__)) || defined(__mips64) || \
defined(__mips64) || \
(defined(__riscv) && __SIZEOF_POINTER__ >= 8)) (defined(__riscv) && __SIZEOF_POINTER__ >= 8))
/* On 64-bit architectures with neither a native clz instruction nor a native /* On 64-bit architectures with neither a native clz instruction nor a native
* ctz instruction, gcc resolves __builtin_ctz to __ctzdi2 rather than * ctz instruction, gcc resolves __builtin_ctz to __ctzdi2 rather than
* __ctzsi2, leading to infinite recursion. */ * __ctzsi2, leading to infinite recursion. */
#define __builtin_ctz(a) __ctzsi2(a) #define __builtin_ctz(a) __ctzsi2(a)
extern si_int __ctzsi2(si_int); extern si_int __ctzsi2(si_int);
#endif #endif
/* Precondition: a != 0 */ /* Precondition: a != 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ctzdi2(di_int a) {
__ctzdi2(di_int a)
{
dwords x; dwords x;
x.all = a; x.all = a;
const si_int f = -(x.s.low == 0); const si_int f = -(x.s.low == 0);
return __builtin_ctz((x.s.high & f) | (x.s.low & ~f)) + return __builtin_ctz((x.s.high & f) | (x.s.low & ~f)) +
(f & ((si_int)(sizeof(si_int) * CHAR_BIT))); (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
} }

compiler-rt/trunk/lib/builtins/ctzsi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: the number of trailing 0-bits */ /* Returns: the number of trailing 0-bits */
/* Precondition: a != 0 */ /* Precondition: a != 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ctzsi2(si_int a) {
__ctzsi2(si_int a)
{
su_int x = (su_int)a; su_int x = (su_int)a;
si_int t = ((x & 0x0000FFFF) == 0) << 4; /* if (x has no small bits) t = 16 else 0 */ si_int t = ((x & 0x0000FFFF) == 0)
<< 4; /* if (x has no small bits) t = 16 else 0 */
x >>= t; /* x = [0 - 0xFFFF] + higher garbage bits */ x >>= t; /* x = [0 - 0xFFFF] + higher garbage bits */
su_int r = t; /* r = [0, 16] */ su_int r = t; /* r = [0, 16] */
/* return r + ctz(x) */ /* return r + ctz(x) */
t = ((x & 0x00FF) == 0) << 3; t = ((x & 0x00FF) == 0) << 3;
x >>= t; /* x = [0 - 0xFF] + higher garbage bits */ x >>= t; /* x = [0 - 0xFF] + higher garbage bits */
r += t; /* r = [0, 8, 16, 24] */ r += t; /* r = [0, 8, 16, 24] */
/* return r + ctz(x) */ /* return r + ctz(x) */
t = ((x & 0x0F) == 0) << 2; t = ((x & 0x0F) == 0) << 2;
x >>= t; /* x = [0 - 0xF] + higher garbage bits */ x >>= t; /* x = [0 - 0xF] + higher garbage bits */
r += t; /* r = [0, 4, 8, 12, 16, 20, 24, 28] */ r += t; /* r = [0, 4, 8, 12, 16, 20, 24, 28] */
/* return r + ctz(x) */ /* return r + ctz(x) */
t = ((x & 0x3) == 0) << 1; t = ((x & 0x3) == 0) << 1;
x >>= t; x >>= t;
x &= 3; /* x = [0 - 3] */ x &= 3; /* x = [0 - 3] */
r += t; /* r = [0 - 30] and is even */ r += t; /* r = [0 - 30] and is even */
/* return r + ctz(x) */ /* return r + ctz(x) */
/* The branch-less return statement below is equivalent /* The branch-less return statement below is equivalent
* to the following switch statement: * to the following switch statement:
* switch (x) * switch (x)
* { * {
* case 0: * case 0:
* return r + 2; * return r + 2;
* case 2: * case 2:
* return r + 1; * return r + 1;
* case 1: * case 1:
* case 3: * case 3:
* return r; * return r;
* } * }
*/ */
return r + ((2 - (x >> 1)) & -((x & 1) == 0)); return r + ((2 - (x >> 1)) & -((x & 1) == 0));
} }

compiler-rt/trunk/lib/builtins/ctzti2.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: the number of trailing 0-bits */ /* Returns: the number of trailing 0-bits */
/* Precondition: a != 0 */ /* Precondition: a != 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ctzti2(ti_int a) {
__ctzti2(ti_int a)
{
twords x; twords x;
x.all = a; x.all = a;
const di_int f = -(x.s.low == 0); const di_int f = -(x.s.low == 0);
return __builtin_ctzll((x.s.high & f) | (x.s.low & ~f)) + return __builtin_ctzll((x.s.high & f) | (x.s.low & ~f)) +
((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT))); ((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT)));
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/divdc3.c

Show All 12 Lines
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the quotient of (a + ib) / (c + id) */ /* Returns: the quotient of (a + ib) / (c + id) */
COMPILER_RT_ABI Dcomplex COMPILER_RT_ABI Dcomplex __divdc3(double __a, double __b, double __c,
__divdc3(double __a, double __b, double __c, double __d) double __d) {
{
int __ilogbw = 0; int __ilogbw = 0;
double __logbw = __compiler_rt_logb(crt_fmax(crt_fabs(__c), crt_fabs(__d))); double __logbw = __compiler_rt_logb(crt_fmax(crt_fabs(__c), crt_fabs(__d)));
if (crt_isfinite(__logbw)) if (crt_isfinite(__logbw)) {
{
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbn(__c, -__ilogbw); __c = crt_scalbn(__c, -__ilogbw);
__d = crt_scalbn(__d, -__ilogbw); __d = crt_scalbn(__d, -__ilogbw);
} }
double __denom = __c * __c + __d * __d; double __denom = __c * __c + __d * __d;
Dcomplex z; Dcomplex z;
COMPLEX_REAL(z) = crt_scalbn((__a * __c + __b * __d) / __denom, -__ilogbw); COMPLEX_REAL(z) = crt_scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
COMPLEX_IMAGINARY(z) = crt_scalbn((__b * __c - __a * __d) / __denom, -__ilogbw); COMPLEX_IMAGINARY(z) =
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) crt_scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
{ if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b))) if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b))) {
{
COMPLEX_REAL(z) = crt_copysign(CRT_INFINITY, __c) * __a; COMPLEX_REAL(z) = crt_copysign(CRT_INFINITY, __c) * __a;
COMPLEX_IMAGINARY(z) = crt_copysign(CRT_INFINITY, __c) * __b; COMPLEX_IMAGINARY(z) = crt_copysign(CRT_INFINITY, __c) * __b;
} } else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__c) &&
else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__d)) {
crt_isfinite(__c) && crt_isfinite(__d))
{
__a = crt_copysign(crt_isinf(__a) ? 1.0 : 0.0, __a); __a = crt_copysign(crt_isinf(__a) ? 1.0 : 0.0, __a);
__b = crt_copysign(crt_isinf(__b) ? 1.0 : 0.0, __b); __b = crt_copysign(crt_isinf(__b) ? 1.0 : 0.0, __b);
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
} } else if (crt_isinf(__logbw) && __logbw > 0.0 && crt_isfinite(__a) &&
else if (crt_isinf(__logbw) && __logbw > 0.0 && crt_isfinite(__b)) {
crt_isfinite(__a) && crt_isfinite(__b))
{
__c = crt_copysign(crt_isinf(__c) ? 1.0 : 0.0, __c); __c = crt_copysign(crt_isinf(__c) ? 1.0 : 0.0, __c);
__d = crt_copysign(crt_isinf(__d) ? 1.0 : 0.0, __d); __d = crt_copysign(crt_isinf(__d) ? 1.0 : 0.0, __d);
COMPLEX_REAL(z) = 0.0 * (__a * __c + __b * __d); COMPLEX_REAL(z) = 0.0 * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d);
} }
} }
return z; return z;
} }

compiler-rt/trunk/lib/builtins/divdf3.c

Show All 12 Lines
// It should be a fairly straightforward exercise to implement gradual // It should be a fairly straightforward exercise to implement gradual
// underflow with correct rounding. // underflow with correct rounding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __divdf3(fp_t a, fp_t b) {
__divdf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
// Detect if a or b is zero, denormal, infinity, or NaN. // Detect if a or b is zero, denormal, infinity, or NaN.
if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) { if (aExponent - 1U >= maxExponent - 1U ||
bExponent - 1U >= maxExponent - 1U) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
// NaN / anything = qNaN // NaN / anything = qNaN
if (aAbs > infRep) return fromRep(toRep(a) | quietBit); if (aAbs > infRep)
return fromRep(toRep(a) | quietBit);
// anything / NaN = qNaN // anything / NaN = qNaN
if (bAbs > infRep) return fromRep(toRep(b) | quietBit); if (bAbs > infRep)
return fromRep(toRep(b) | quietBit);
if (aAbs == infRep) { if (aAbs == infRep) {
// infinity / infinity = NaN // infinity / infinity = NaN
if (bAbs == infRep) return fromRep(qnanRep); if (bAbs == infRep)
return fromRep(qnanRep);
// infinity / anything else = +/- infinity // infinity / anything else = +/- infinity
else return fromRep(aAbs | quotientSign); else
return fromRep(aAbs | quotientSign);
} }
// anything else / infinity = +/- 0 // anything else / infinity = +/- 0
if (bAbs == infRep) return fromRep(quotientSign); if (bAbs == infRep)
return fromRep(quotientSign);
if (!aAbs) { if (!aAbs) {
// zero / zero = NaN // zero / zero = NaN
if (!bAbs) return fromRep(qnanRep); if (!bAbs)
return fromRep(qnanRep);
// zero / anything else = +/- zero // zero / anything else = +/- zero
else return fromRep(quotientSign); else
return fromRep(quotientSign);
} }
// anything else / zero = +/- infinity // anything else / zero = +/- infinity
if (!bAbs) return fromRep(infRep | quotientSign); if (!bAbs)
return fromRep(infRep | quotientSign);
// one or both of a or b is denormal, the other (if applicable) is a // one or both of a or b is denormal, the other (if applicable) is a
// normal number. Renormalize one or both of a and b, and set scale to // normal number. Renormalize one or both of a and b, and set scale to
// include the necessary exponent adjustment. // include the necessary exponent adjustment.
if (aAbs < implicitBit) scale += normalize(&aSignificand); if (aAbs < implicitBit)
if (bAbs < implicitBit) scale -= normalize(&bSignificand); scale += normalize(&aSignificand);
if (bAbs < implicitBit)
scale -= normalize(&bSignificand);
} }
// Or in the implicit significand bit. (If we fell through from the // Or in the implicit significand bit. (If we fell through from the
// denormal path it was already set by normalize( ), but setting it twice // denormal path it was already set by normalize( ), but setting it twice
// won't hurt anything.) // won't hurt anything.)
aSignificand |= implicitBit; aSignificand |= implicitBit;
bSignificand |= implicitBit; bSignificand |= implicitBit;
int quotientExponent = aExponent - bExponent + scale; int quotientExponent = aExponent - bExponent + scale;
// Align the significand of b as a Q31 fixed-point number in the range // Align the significand of b as a Q31 fixed-point number in the range
// [1, 2.0) and get a Q32 approximate reciprocal using a small minimax // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
// polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This
// is accurate to about 3.5 binary digits. // is accurate to about 3.5 binary digits.
const uint32_t q31b = bSignificand >> 21; const uint32_t q31b = bSignificand >> 21;
uint32_t recip32 = UINT32_C(0x7504f333) - q31b; uint32_t recip32 = UINT32_C(0x7504f333) - q31b;
// Now refine the reciprocal estimate using a Newton-Raphson iteration: // Now refine the reciprocal estimate using a Newton-Raphson iteration:
// //
// x1 = x0 * (2 - x0 * b) // x1 = x0 * (2 - x0 * b)
// //
// This doubles the number of correct binary digits in the approximation // This doubles the number of correct binary digits in the approximation
// with each iteration, so after three iterations, we have about 28 binary // with each iteration, so after three iterations, we have about 28 binary
// digits of accuracy. // digits of accuracy.
uint32_t correction32; uint32_t correction32;
correction32 = -((uint64_t)recip32 * q31b >> 32); correction32 = -((uint64_t)recip32 * q31b >> 32);
recip32 = (uint64_t)recip32 * correction32 >> 31; recip32 = (uint64_t)recip32 * correction32 >> 31;
correction32 = -((uint64_t)recip32 * q31b >> 32); correction32 = -((uint64_t)recip32 * q31b >> 32);
recip32 = (uint64_t)recip32 * correction32 >> 31; recip32 = (uint64_t)recip32 * correction32 >> 31;
correction32 = -((uint64_t)recip32 * q31b >> 32); correction32 = -((uint64_t)recip32 * q31b >> 32);
recip32 = (uint64_t)recip32 * correction32 >> 31; recip32 = (uint64_t)recip32 * correction32 >> 31;
// recip32 might have overflowed to exactly zero in the preceding // recip32 might have overflowed to exactly zero in the preceding
// computation if the high word of b is exactly 1.0. This would sabotage // computation if the high word of b is exactly 1.0. This would sabotage
// the full-width final stage of the computation that follows, so we adjust // the full-width final stage of the computation that follows, so we adjust
// recip32 downward by one bit. // recip32 downward by one bit.
recip32--; recip32--;
// We need to perform one more iteration to get us to 56 binary digits; // We need to perform one more iteration to get us to 56 binary digits;
// The last iteration needs to happen with extra precision. // The last iteration needs to happen with extra precision.
const uint32_t q63blo = bSignificand << 11; const uint32_t q63blo = bSignificand << 11;
uint64_t correction, reciprocal; uint64_t correction, reciprocal;
correction = -((uint64_t)recip32*q31b + ((uint64_t)recip32*q63blo >> 32)); correction = -((uint64_t)recip32 * q31b + ((uint64_t)recip32 * q63blo >> 32));
uint32_t cHi = correction >> 32; uint32_t cHi = correction >> 32;
uint32_t cLo = correction; uint32_t cLo = correction;
reciprocal = (uint64_t)recip32*cHi + ((uint64_t)recip32*cLo >> 32); reciprocal = (uint64_t)recip32 * cHi + ((uint64_t)recip32 * cLo >> 32);
// We already adjusted the 32-bit estimate, now we need to adjust the final // We already adjusted the 32-bit estimate, now we need to adjust the final
// 64-bit reciprocal estimate downward to ensure that it is strictly smaller // 64-bit reciprocal estimate downward to ensure that it is strictly smaller
// than the infinitely precise exact reciprocal. Because the computation // than the infinitely precise exact reciprocal. Because the computation
// of the Newton-Raphson step is truncating at every step, this adjustment // of the Newton-Raphson step is truncating at every step, this adjustment
// is small; most of the work is already done. // is small; most of the work is already done.
reciprocal -= 2; reciprocal -= 2;
// The numerical reciprocal is accurate to within 2^-56, lies in the // The numerical reciprocal is accurate to within 2^-56, lies in the
// interval [0.5, 1.0), and is strictly smaller than the true reciprocal // interval [0.5, 1.0), and is strictly smaller than the true reciprocal
// of b. Multiplying a by this reciprocal thus gives a numerical q = a/b // of b. Multiplying a by this reciprocal thus gives a numerical q = a/b
// in Q53 with the following properties: // in Q53 with the following properties:
// //
// 1. q < a/b // 1. q < a/b
// 2. q is in the interval [0.5, 2.0) // 2. q is in the interval [0.5, 2.0)
// 3. the error in q is bounded away from 2^-53 (actually, we have a // 3. the error in q is bounded away from 2^-53 (actually, we have a
// couple of bits to spare, but this is all we need). // couple of bits to spare, but this is all we need).
// We need a 64 x 64 multiply high to compute q, which isn't a basic // We need a 64 x 64 multiply high to compute q, which isn't a basic
// operation in C, so we need to be a little bit fussy. // operation in C, so we need to be a little bit fussy.
rep_t quotient, quotientLo; rep_t quotient, quotientLo;
wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo); wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo);
// Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0). // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
// In either case, we are going to compute a residual of the form // In either case, we are going to compute a residual of the form
// //
// r = a - q*b // r = a - q*b
// //
// We know from the construction of q that r satisfies: // We know from the construction of q that r satisfies:
// //
// 0 <= r < ulp(q)*b // 0 <= r < ulp(q)*b
// //
// if r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we // if r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we
// already have the correct result. The exact halfway case cannot occur. // already have the correct result. The exact halfway case cannot occur.
// We also take this time to right shift quotient if it falls in the [1,2) // We also take this time to right shift quotient if it falls in the [1,2)
// range and adjust the exponent accordingly. // range and adjust the exponent accordingly.
rep_t residual; rep_t residual;
if (quotient < (implicitBit << 1)) { if (quotient < (implicitBit << 1)) {
residual = (aSignificand << 53) - quotient * bSignificand; residual = (aSignificand << 53) - quotient * bSignificand;
quotientExponent--; quotientExponent--;
} else { } else {
quotient >>= 1; quotient >>= 1;
residual = (aSignificand << 52) - quotient * bSignificand; residual = (aSignificand << 52) - quotient * bSignificand;
} }
const int writtenExponent = quotientExponent + exponentBias; const int writtenExponent = quotientExponent + exponentBias;
if (writtenExponent >= maxExponent) { if (writtenExponent >= maxExponent) {
// If we have overflowed the exponent, return infinity. // If we have overflowed the exponent, return infinity.
return fromRep(infRep | quotientSign); return fromRep(infRep | quotientSign);
} }
else if (writtenExponent < 1) { else if (writtenExponent < 1) {
if (writtenExponent == 0) { if (writtenExponent == 0) {
// Check whether the rounded result is normal. // Check whether the rounded result is normal.
const bool round = (residual << 1) > bSignificand; const bool round = (residual << 1) > bSignificand;
// Clear the implicit bit. // Clear the implicit bit.
rep_t absResult = quotient & significandMask; rep_t absResult = quotient & significandMask;
// Round. // Round.
absResult += round; absResult += round;
if (absResult & ~significandMask) { if (absResult & ~significandMask) {
// The rounded result is normal; return it. // The rounded result is normal; return it.
return fromRep(absResult | quotientSign); return fromRep(absResult | quotientSign);
} }
} }
// Flush denormals to zero. In the future, it would be nice to add // Flush denormals to zero. In the future, it would be nice to add
// code to round them correctly. // code to round them correctly.
return fromRep(quotientSign); return fromRep(quotientSign);
} }
else { else {
const bool round = (residual << 1) > bSignificand; const bool round = (residual << 1) > bSignificand;
// Clear the implicit bit // Clear the implicit bit
rep_t absResult = quotient & significandMask; rep_t absResult = quotient & significandMask;
// Insert the exponent // Insert the exponent
absResult |= (rep_t)writtenExponent << significandBits; absResult |= (rep_t)writtenExponent << significandBits;
// Round // Round
absResult += round; absResult += round;
// Insert the sign and return // Insert the sign and return
const double result = fromRep(absResult | quotientSign); const double result = fromRep(absResult | quotientSign);
return result; return result;
} }
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) { AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) { return __divdf3(a, b); }
return __divdf3(a, b);
}
#else #else
AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) COMPILER_RT_ALIAS(__divdf3); AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) COMPILER_RT_ALIAS(__divdf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/divdi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ /* Returns: a / b */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b) {
__divdi3(di_int a, di_int b)
{
const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1; const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1;
di_int s_a = a >> bits_in_dword_m1; /* s_a = a < 0 ? -1 : 0 */ di_int s_a = a >> bits_in_dword_m1; /* s_a = a < 0 ? -1 : 0 */
di_int s_b = b >> bits_in_dword_m1; /* s_b = b < 0 ? -1 : 0 */ di_int s_b = b >> bits_in_dword_m1; /* s_b = b < 0 ? -1 : 0 */
a = (a ^ s_a) - s_a; /* negate if s_a == -1 */ a = (a ^ s_a) - s_a; /* negate if s_a == -1 */
b = (b ^ s_b) - s_b; /* negate if s_b == -1 */ b = (b ^ s_b) - s_b; /* negate if s_b == -1 */
s_a ^= s_b; /*sign of quotient */ s_a ^= s_b; /*sign of quotient */
return (__udivmoddi4(a, b, (du_int*)0) ^ s_a) - s_a; /* negate if s_a == -1 */ return (__udivmoddi4(a, b, (du_int *)0) ^ s_a) -
s_a; /* negate if s_a == -1 */
} }

compiler-rt/trunk/lib/builtins/divmoddi4.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b, *rem = a % b */ /* Returns: a / b, *rem = a % b */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __divmoddi4(di_int a, di_int b, di_int *rem) {
__divmoddi4(di_int a, di_int b, di_int* rem)
{
di_int d = __divdi3(a,b); di_int d = __divdi3(a, b);
*rem = a - (d*b); *rem = a - (d * b);
return d; return d;
} }

compiler-rt/trunk/lib/builtins/divmodsi4.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b, *rem = a % b */ /* Returns: a / b, *rem = a % b */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __divmodsi4(si_int a, si_int b, si_int *rem) {
__divmodsi4(si_int a, si_int b, si_int* rem)
{
si_int d = __divsi3(a,b); si_int d = __divsi3(a, b);
*rem = a - (d*b); *rem = a - (d * b);
return d; return d;
} }

compiler-rt/trunk/lib/builtins/divsc3.c

Show All 12 Lines
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the quotient of (a + ib) / (c + id) */ /* Returns: the quotient of (a + ib) / (c + id) */
COMPILER_RT_ABI Fcomplex COMPILER_RT_ABI Fcomplex __divsc3(float __a, float __b, float __c, float __d) {
__divsc3(float __a, float __b, float __c, float __d)
{
int __ilogbw = 0; int __ilogbw = 0;
float __logbw = float __logbw =
__compiler_rt_logbf(crt_fmaxf(crt_fabsf(__c), crt_fabsf(__d))); __compiler_rt_logbf(crt_fmaxf(crt_fabsf(__c), crt_fabsf(__d)));
if (crt_isfinite(__logbw)) if (crt_isfinite(__logbw)) {
{
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbnf(__c, -__ilogbw); __c = crt_scalbnf(__c, -__ilogbw);
__d = crt_scalbnf(__d, -__ilogbw); __d = crt_scalbnf(__d, -__ilogbw);
} }
float __denom = __c * __c + __d * __d; float __denom = __c * __c + __d * __d;
Fcomplex z; Fcomplex z;
COMPLEX_REAL(z) = crt_scalbnf((__a * __c + __b * __d) / __denom, -__ilogbw); COMPLEX_REAL(z) = crt_scalbnf((__a * __c + __b * __d) / __denom, -__ilogbw);
COMPLEX_IMAGINARY(z) = crt_scalbnf((__b * __c - __a * __d) / __denom, -__ilogbw); COMPLEX_IMAGINARY(z) =
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) crt_scalbnf((__b * __c - __a * __d) / __denom, -__ilogbw);
{ if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
if ((__denom == 0) && (!crt_isnan(__a) || !crt_isnan(__b))) if ((__denom == 0) && (!crt_isnan(__a) || !crt_isnan(__b))) {
{
COMPLEX_REAL(z) = crt_copysignf(CRT_INFINITY, __c) * __a; COMPLEX_REAL(z) = crt_copysignf(CRT_INFINITY, __c) * __a;
COMPLEX_IMAGINARY(z) = crt_copysignf(CRT_INFINITY, __c) * __b; COMPLEX_IMAGINARY(z) = crt_copysignf(CRT_INFINITY, __c) * __b;
} } else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__c) &&
else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__d)) {
crt_isfinite(__c) && crt_isfinite(__d))
{
__a = crt_copysignf(crt_isinf(__a) ? 1 : 0, __a); __a = crt_copysignf(crt_isinf(__a) ? 1 : 0, __a);
__b = crt_copysignf(crt_isinf(__b) ? 1 : 0, __b); __b = crt_copysignf(crt_isinf(__b) ? 1 : 0, __b);
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
} } else if (crt_isinf(__logbw) && __logbw > 0 && crt_isfinite(__a) &&
else if (crt_isinf(__logbw) && __logbw > 0 && crt_isfinite(__b)) {
crt_isfinite(__a) && crt_isfinite(__b))
{
__c = crt_copysignf(crt_isinf(__c) ? 1 : 0, __c); __c = crt_copysignf(crt_isinf(__c) ? 1 : 0, __c);
__d = crt_copysignf(crt_isinf(__d) ? 1 : 0, __d); __d = crt_copysignf(crt_isinf(__d) ? 1 : 0, __d);
COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d); COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d);
} }
} }
return z; return z;
} }

compiler-rt/trunk/lib/builtins/divsf3.c

Show All 12 Lines
// It should be a fairly straightforward exercise to implement gradual // It should be a fairly straightforward exercise to implement gradual
// underflow with correct rounding. // underflow with correct rounding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __divsf3(fp_t a, fp_t b) {
__divsf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
// Detect if a or b is zero, denormal, infinity, or NaN. // Detect if a or b is zero, denormal, infinity, or NaN.
if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) { if (aExponent - 1U >= maxExponent - 1U ||
bExponent - 1U >= maxExponent - 1U) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
// NaN / anything = qNaN // NaN / anything = qNaN
if (aAbs > infRep) return fromRep(toRep(a) | quietBit); if (aAbs > infRep)
return fromRep(toRep(a) | quietBit);
// anything / NaN = qNaN // anything / NaN = qNaN
if (bAbs > infRep) return fromRep(toRep(b) | quietBit); if (bAbs > infRep)
return fromRep(toRep(b) | quietBit);
if (aAbs == infRep) { if (aAbs == infRep) {
// infinity / infinity = NaN // infinity / infinity = NaN
if (bAbs == infRep) return fromRep(qnanRep); if (bAbs == infRep)
return fromRep(qnanRep);
// infinity / anything else = +/- infinity // infinity / anything else = +/- infinity
else return fromRep(aAbs | quotientSign); else
return fromRep(aAbs | quotientSign);
} }
// anything else / infinity = +/- 0 // anything else / infinity = +/- 0
if (bAbs == infRep) return fromRep(quotientSign); if (bAbs == infRep)
return fromRep(quotientSign);
if (!aAbs) { if (!aAbs) {
// zero / zero = NaN // zero / zero = NaN
if (!bAbs) return fromRep(qnanRep); if (!bAbs)
return fromRep(qnanRep);
// zero / anything else = +/- zero // zero / anything else = +/- zero
else return fromRep(quotientSign); else
return fromRep(quotientSign);
} }
// anything else / zero = +/- infinity // anything else / zero = +/- infinity
if (!bAbs) return fromRep(infRep | quotientSign); if (!bAbs)
return fromRep(infRep | quotientSign);
// one or both of a or b is denormal, the other (if applicable) is a // one or both of a or b is denormal, the other (if applicable) is a
// normal number. Renormalize one or both of a and b, and set scale to // normal number. Renormalize one or both of a and b, and set scale to
// include the necessary exponent adjustment. // include the necessary exponent adjustment.
if (aAbs < implicitBit) scale += normalize(&aSignificand); if (aAbs < implicitBit)
if (bAbs < implicitBit) scale -= normalize(&bSignificand); scale += normalize(&aSignificand);
if (bAbs < implicitBit)
scale -= normalize(&bSignificand);
} }
// Or in the implicit significand bit. (If we fell through from the // Or in the implicit significand bit. (If we fell through from the
// denormal path it was already set by normalize( ), but setting it twice // denormal path it was already set by normalize( ), but setting it twice
// won't hurt anything.) // won't hurt anything.)
aSignificand |= implicitBit; aSignificand |= implicitBit;
bSignificand |= implicitBit; bSignificand |= implicitBit;
int quotientExponent = aExponent - bExponent + scale; int quotientExponent = aExponent - bExponent + scale;
// Align the significand of b as a Q31 fixed-point number in the range // Align the significand of b as a Q31 fixed-point number in the range
// [1, 2.0) and get a Q32 approximate reciprocal using a small minimax // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
// polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This
// is accurate to about 3.5 binary digits. // is accurate to about 3.5 binary digits.
uint32_t q31b = bSignificand << 8; uint32_t q31b = bSignificand << 8;
uint32_t reciprocal = UINT32_C(0x7504f333) - q31b; uint32_t reciprocal = UINT32_C(0x7504f333) - q31b;
// Now refine the reciprocal estimate using a Newton-Raphson iteration: // Now refine the reciprocal estimate using a Newton-Raphson iteration:
// //
// x1 = x0 * (2 - x0 * b) // x1 = x0 * (2 - x0 * b)
// //
// This doubles the number of correct binary digits in the approximation // This doubles the number of correct binary digits in the approximation
// with each iteration, so after three iterations, we have about 28 binary // with each iteration, so after three iterations, we have about 28 binary
// digits of accuracy. // digits of accuracy.
uint32_t correction; uint32_t correction;
correction = -((uint64_t)reciprocal * q31b >> 32); correction = -((uint64_t)reciprocal * q31b >> 32);
reciprocal = (uint64_t)reciprocal * correction >> 31; reciprocal = (uint64_t)reciprocal * correction >> 31;
correction = -((uint64_t)reciprocal * q31b >> 32); correction = -((uint64_t)reciprocal * q31b >> 32);
reciprocal = (uint64_t)reciprocal * correction >> 31; reciprocal = (uint64_t)reciprocal * correction >> 31;
correction = -((uint64_t)reciprocal * q31b >> 32); correction = -((uint64_t)reciprocal * q31b >> 32);
reciprocal = (uint64_t)reciprocal * correction >> 31; reciprocal = (uint64_t)reciprocal * correction >> 31;
// Exhaustive testing shows that the error in reciprocal after three steps // Exhaustive testing shows that the error in reciprocal after three steps
// is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our // is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our
// expectations. We bump the reciprocal by a tiny value to force the error // expectations. We bump the reciprocal by a tiny value to force the error
// to be strictly positive (in the range [0x1.4fdfp-37,0x1.287246p-29], to // to be strictly positive (in the range [0x1.4fdfp-37,0x1.287246p-29], to
// be specific). This also causes 1/1 to give a sensible approximation // be specific). This also causes 1/1 to give a sensible approximation
// instead of zero (due to overflow). // instead of zero (due to overflow).
reciprocal -= 2; reciprocal -= 2;
// The numerical reciprocal is accurate to within 2^-28, lies in the // The numerical reciprocal is accurate to within 2^-28, lies in the
// interval [0x1.000000eep-1, 0x1.fffffffcp-1], and is strictly smaller // interval [0x1.000000eep-1, 0x1.fffffffcp-1], and is strictly smaller
// than the true reciprocal of b. Multiplying a by this reciprocal thus // than the true reciprocal of b. Multiplying a by this reciprocal thus
// gives a numerical q = a/b in Q24 with the following properties: // gives a numerical q = a/b in Q24 with the following properties:
// //
// 1. q < a/b // 1. q < a/b
// 2. q is in the interval [0x1.000000eep-1, 0x1.fffffffcp0) // 2. q is in the interval [0x1.000000eep-1, 0x1.fffffffcp0)
// 3. the error in q is at most 2^-24 + 2^-27 -- the 2^24 term comes // 3. the error in q is at most 2^-24 + 2^-27 -- the 2^24 term comes
// from the fact that we truncate the product, and the 2^27 term // from the fact that we truncate the product, and the 2^27 term
// is the error in the reciprocal of b scaled by the maximum // is the error in the reciprocal of b scaled by the maximum
// possible value of a. As a consequence of this error bound, // possible value of a. As a consequence of this error bound,
// either q or nextafter(q) is the correctly rounded // either q or nextafter(q) is the correctly rounded
rep_t quotient = (uint64_t)reciprocal*(aSignificand << 1) >> 32; rep_t quotient = (uint64_t)reciprocal * (aSignificand << 1) >> 32;
// Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0). // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
// In either case, we are going to compute a residual of the form // In either case, we are going to compute a residual of the form
// //
// r = a - q*b // r = a - q*b
// //
// We know from the construction of q that r satisfies: // We know from the construction of q that r satisfies:
// //
// 0 <= r < ulp(q)*b // 0 <= r < ulp(q)*b
// //
// if r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we // if r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we
// already have the correct result. The exact halfway case cannot occur. // already have the correct result. The exact halfway case cannot occur.
// We also take this time to right shift quotient if it falls in the [1,2) // We also take this time to right shift quotient if it falls in the [1,2)
// range and adjust the exponent accordingly. // range and adjust the exponent accordingly.
rep_t residual; rep_t residual;
if (quotient < (implicitBit << 1)) { if (quotient < (implicitBit << 1)) {
residual = (aSignificand << 24) - quotient * bSignificand; residual = (aSignificand << 24) - quotient * bSignificand;
quotientExponent--; quotientExponent--;
} else { } else {
quotient >>= 1; quotient >>= 1;
residual = (aSignificand << 23) - quotient * bSignificand; residual = (aSignificand << 23) - quotient * bSignificand;
} }
const int writtenExponent = quotientExponent + exponentBias; const int writtenExponent = quotientExponent + exponentBias;
if (writtenExponent >= maxExponent) { if (writtenExponent >= maxExponent) {
// If we have overflowed the exponent, return infinity. // If we have overflowed the exponent, return infinity.
return fromRep(infRep | quotientSign); return fromRep(infRep | quotientSign);
} }
else if (writtenExponent < 1) { else if (writtenExponent < 1) {
if (writtenExponent == 0) { if (writtenExponent == 0) {
// Check whether the rounded result is normal. // Check whether the rounded result is normal.
const bool round = (residual << 1) > bSignificand; const bool round = (residual << 1) > bSignificand;
// Clear the implicit bit. // Clear the implicit bit.
rep_t absResult = quotient & significandMask; rep_t absResult = quotient & significandMask;
// Round. // Round.
absResult += round; absResult += round;
if (absResult & ~significandMask) { if (absResult & ~significandMask) {
// The rounded result is normal; return it. // The rounded result is normal; return it.
return fromRep(absResult | quotientSign); return fromRep(absResult | quotientSign);
} }
} }
// Flush denormals to zero. In the future, it would be nice to add // Flush denormals to zero. In the future, it would be nice to add
// code to round them correctly. // code to round them correctly.
return fromRep(quotientSign); return fromRep(quotientSign);
} }
else { else {
const bool round = (residual << 1) > bSignificand; const bool round = (residual << 1) > bSignificand;
// Clear the implicit bit // Clear the implicit bit
rep_t absResult = quotient & significandMask; rep_t absResult = quotient & significandMask;
// Insert the exponent // Insert the exponent
absResult |= (rep_t)writtenExponent << significandBits; absResult |= (rep_t)writtenExponent << significandBits;
// Round // Round
absResult += round; absResult += round;
// Insert the sign and return // Insert the sign and return
return fromRep(absResult | quotientSign); return fromRep(absResult | quotientSign);
} }
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) { AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) { return __divsf3(a, b); }
return __divsf3(a, b);
}
#else #else
AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) COMPILER_RT_ALIAS(__divsf3); AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) COMPILER_RT_ALIAS(__divsf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/divsi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ /* Returns: a / b */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b) {
__divsi3(si_int a, si_int b)
{
const int bits_in_word_m1 = (int)(sizeof(si_int) * CHAR_BIT) - 1; const int bits_in_word_m1 = (int)(sizeof(si_int) * CHAR_BIT) - 1;
si_int s_a = a >> bits_in_word_m1; /* s_a = a < 0 ? -1 : 0 */ si_int s_a = a >> bits_in_word_m1; /* s_a = a < 0 ? -1 : 0 */
si_int s_b = b >> bits_in_word_m1; /* s_b = b < 0 ? -1 : 0 */ si_int s_b = b >> bits_in_word_m1; /* s_b = b < 0 ? -1 : 0 */
a = (a ^ s_a) - s_a; /* negate if s_a == -1 */ a = (a ^ s_a) - s_a; /* negate if s_a == -1 */
b = (b ^ s_b) - s_b; /* negate if s_b == -1 */ b = (b ^ s_b) - s_b; /* negate if s_b == -1 */
s_a ^= s_b; /* sign of quotient */ s_a ^= s_b; /* sign of quotient */
/* /*
* On CPUs without unsigned hardware division support, * On CPUs without unsigned hardware division support,
* this calls __udivsi3 (notice the cast to su_int). * this calls __udivsi3 (notice the cast to su_int).
* On CPUs with unsigned hardware division support, * On CPUs with unsigned hardware division support,
* this uses the unsigned division instruction. * this uses the unsigned division instruction.
*/ */
return ((su_int)a/(su_int)b ^ s_a) - s_a; /* negate if s_a == -1 */ return ((su_int)a / (su_int)b ^ s_a) - s_a; /* negate if s_a == -1 */
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI si_int __aeabi_idiv(si_int a, si_int b) COMPILER_RT_ALIAS(__divsi3); AEABI_RTABI si_int __aeabi_idiv(si_int a, si_int b) COMPILER_RT_ALIAS(__divsi3);
#endif #endif

compiler-rt/trunk/lib/builtins/divtc3.c

Show All 12 Lines
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the quotient of (a + ib) / (c + id) */ /* Returns: the quotient of (a + ib) / (c + id) */
COMPILER_RT_ABI Lcomplex COMPILER_RT_ABI Lcomplex __divtc3(long double __a, long double __b,
__divtc3(long double __a, long double __b, long double __c, long double __d) long double __c, long double __d) {
{
int __ilogbw = 0; int __ilogbw = 0;
long double __logbw = long double __logbw =
__compiler_rt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d))); __compiler_rt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
if (crt_isfinite(__logbw)) if (crt_isfinite(__logbw)) {
{
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbnl(__c, -__ilogbw); __c = crt_scalbnl(__c, -__ilogbw);
__d = crt_scalbnl(__d, -__ilogbw); __d = crt_scalbnl(__d, -__ilogbw);
} }
long double __denom = __c * __c + __d * __d; long double __denom = __c * __c + __d * __d;
Lcomplex z; Lcomplex z;
COMPLEX_REAL(z) = crt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw); COMPLEX_REAL(z) = crt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw);
COMPLEX_IMAGINARY(z) = crt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw); COMPLEX_IMAGINARY(z) =
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) crt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw);
{ if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b))) if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b))) {
{
COMPLEX_REAL(z) = crt_copysignl(CRT_INFINITY, __c) * __a; COMPLEX_REAL(z) = crt_copysignl(CRT_INFINITY, __c) * __a;
COMPLEX_IMAGINARY(z) = crt_copysignl(CRT_INFINITY, __c) * __b; COMPLEX_IMAGINARY(z) = crt_copysignl(CRT_INFINITY, __c) * __b;
} } else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__c) &&
else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__d)) {
crt_isfinite(__c) && crt_isfinite(__d))
{
__a = crt_copysignl(crt_isinf(__a) ? 1.0 : 0.0, __a); __a = crt_copysignl(crt_isinf(__a) ? 1.0 : 0.0, __a);
__b = crt_copysignl(crt_isinf(__b) ? 1.0 : 0.0, __b); __b = crt_copysignl(crt_isinf(__b) ? 1.0 : 0.0, __b);
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
} } else if (crt_isinf(__logbw) && __logbw > 0.0 && crt_isfinite(__a) &&
else if (crt_isinf(__logbw) && __logbw > 0.0 && crt_isfinite(__b)) {
crt_isfinite(__a) && crt_isfinite(__b))
{
__c = crt_copysignl(crt_isinf(__c) ? 1.0 : 0.0, __c); __c = crt_copysignl(crt_isinf(__c) ? 1.0 : 0.0, __c);
__d = crt_copysignl(crt_isinf(__d) ? 1.0 : 0.0, __d); __d = crt_copysignl(crt_isinf(__d) ? 1.0 : 0.0, __d);
COMPLEX_REAL(z) = 0.0 * (__a * __c + __b * __d); COMPLEX_REAL(z) = 0.0 * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d);
} }
} }
return z; return z;
} }

compiler-rt/trunk/lib/builtins/divtf3.c

Show All 15 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __divtf3(fp_t a, fp_t b) { COMPILER_RT_ABI fp_t __divtf3(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
// Detect if a or b is zero, denormal, infinity, or NaN. // Detect if a or b is zero, denormal, infinity, or NaN.
if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) { if (aExponent - 1U >= maxExponent - 1U ||
bExponent - 1U >= maxExponent - 1U) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
// NaN / anything = qNaN // NaN / anything = qNaN
if (aAbs > infRep) return fromRep(toRep(a) | quietBit); if (aAbs > infRep)
return fromRep(toRep(a) | quietBit);
// anything / NaN = qNaN // anything / NaN = qNaN
if (bAbs > infRep) return fromRep(toRep(b) | quietBit); if (bAbs > infRep)
return fromRep(toRep(b) | quietBit);
if (aAbs == infRep) { if (aAbs == infRep) {
// infinity / infinity = NaN // infinity / infinity = NaN
if (bAbs == infRep) return fromRep(qnanRep); if (bAbs == infRep)
return fromRep(qnanRep);
// infinity / anything else = +/- infinity // infinity / anything else = +/- infinity
else return fromRep(aAbs | quotientSign); else
return fromRep(aAbs | quotientSign);
} }
// anything else / infinity = +/- 0 // anything else / infinity = +/- 0
if (bAbs == infRep) return fromRep(quotientSign); if (bAbs == infRep)
return fromRep(quotientSign);
if (!aAbs) { if (!aAbs) {
// zero / zero = NaN // zero / zero = NaN
if (!bAbs) return fromRep(qnanRep); if (!bAbs)
return fromRep(qnanRep);
// zero / anything else = +/- zero // zero / anything else = +/- zero
else return fromRep(quotientSign); else
return fromRep(quotientSign);
} }
// anything else / zero = +/- infinity // anything else / zero = +/- infinity
if (!bAbs) return fromRep(infRep | quotientSign); if (!bAbs)
return fromRep(infRep | quotientSign);
// one or both of a or b is denormal, the other (if applicable) is a // one or both of a or b is denormal, the other (if applicable) is a
// normal number. Renormalize one or both of a and b, and set scale to // normal number. Renormalize one or both of a and b, and set scale to
// include the necessary exponent adjustment. // include the necessary exponent adjustment.
if (aAbs < implicitBit) scale += normalize(&aSignificand); if (aAbs < implicitBit)
if (bAbs < implicitBit) scale -= normalize(&bSignificand); scale += normalize(&aSignificand);
if (bAbs < implicitBit)
scale -= normalize(&bSignificand);
} }
// Or in the implicit significand bit. (If we fell through from the // Or in the implicit significand bit. (If we fell through from the
// denormal path it was already set by normalize( ), but setting it twice // denormal path it was already set by normalize( ), but setting it twice
// won't hurt anything.) // won't hurt anything.)
aSignificand |= implicitBit; aSignificand |= implicitBit;
bSignificand |= implicitBit; bSignificand |= implicitBit;
int quotientExponent = aExponent - bExponent + scale; int quotientExponent = aExponent - bExponent + scale;
// Align the significand of b as a Q63 fixed-point number in the range // Align the significand of b as a Q63 fixed-point number in the range
// [1, 2.0) and get a Q64 approximate reciprocal using a small minimax // [1, 2.0) and get a Q64 approximate reciprocal using a small minimax
// polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This
// is accurate to about 3.5 binary digits. // is accurate to about 3.5 binary digits.
const uint64_t q63b = bSignificand >> 49; const uint64_t q63b = bSignificand >> 49;
uint64_t recip64 = UINT64_C(0x7504f333F9DE6484) - q63b; uint64_t recip64 = UINT64_C(0x7504f333F9DE6484) - q63b;
// 0x7504f333F9DE6484 / 2^64 + 1 = 3/4 + 1/sqrt(2) // 0x7504f333F9DE6484 / 2^64 + 1 = 3/4 + 1/sqrt(2)
// Now refine the reciprocal estimate using a Newton-Raphson iteration: // Now refine the reciprocal estimate using a Newton-Raphson iteration:
// //
// x1 = x0 * (2 - x0 * b) // x1 = x0 * (2 - x0 * b)
// //
// This doubles the number of correct binary digits in the approximation // This doubles the number of correct binary digits in the approximation
// with each iteration. // with each iteration.
uint64_t correction64; uint64_t correction64;
correction64 = -((rep_t)recip64 * q63b >> 64); correction64 = -((rep_t)recip64 * q63b >> 64);
recip64 = (rep_t)recip64 * correction64 >> 63; recip64 = (rep_t)recip64 * correction64 >> 63;
correction64 = -((rep_t)recip64 * q63b >> 64); correction64 = -((rep_t)recip64 * q63b >> 64);
recip64 = (rep_t)recip64 * correction64 >> 63; recip64 = (rep_t)recip64 * correction64 >> 63;
correction64 = -((rep_t)recip64 * q63b >> 64); correction64 = -((rep_t)recip64 * q63b >> 64);
recip64 = (rep_t)recip64 * correction64 >> 63; recip64 = (rep_t)recip64 * correction64 >> 63;
correction64 = -((rep_t)recip64 * q63b >> 64); correction64 = -((rep_t)recip64 * q63b >> 64);
recip64 = (rep_t)recip64 * correction64 >> 63; recip64 = (rep_t)recip64 * correction64 >> 63;
correction64 = -((rep_t)recip64 * q63b >> 64); correction64 = -((rep_t)recip64 * q63b >> 64);
recip64 = (rep_t)recip64 * correction64 >> 63; recip64 = (rep_t)recip64 * correction64 >> 63;
// recip64 might have overflowed to exactly zero in the preceeding // recip64 might have overflowed to exactly zero in the preceeding
// computation if the high word of b is exactly 1.0. This would sabotage // computation if the high word of b is exactly 1.0. This would sabotage
// the full-width final stage of the computation that follows, so we adjust // the full-width final stage of the computation that follows, so we adjust
// recip64 downward by one bit. // recip64 downward by one bit.
recip64--; recip64--;
// We need to perform one more iteration to get us to 112 binary digits; // We need to perform one more iteration to get us to 112 binary digits;
// The last iteration needs to happen with extra precision. // The last iteration needs to happen with extra precision.
const uint64_t q127blo = bSignificand << 15; const uint64_t q127blo = bSignificand << 15;
rep_t correction, reciprocal; rep_t correction, reciprocal;
// NOTE: This operation is equivalent to __multi3, which is not implemented // NOTE: This operation is equivalent to __multi3, which is not implemented
// in some architechure // in some architechure
rep_t r64q63, r64q127, r64cH, r64cL, dummy; rep_t r64q63, r64q127, r64cH, r64cL, dummy;
wideMultiply((rep_t)recip64, (rep_t)q63b, &dummy, &r64q63); wideMultiply((rep_t)recip64, (rep_t)q63b, &dummy, &r64q63);
wideMultiply((rep_t)recip64, (rep_t)q127blo, &dummy, &r64q127); wideMultiply((rep_t)recip64, (rep_t)q127blo, &dummy, &r64q127);
correction = -(r64q63 + (r64q127 >> 64)); correction = -(r64q63 + (r64q127 >> 64));
uint64_t cHi = correction >> 64; uint64_t cHi = correction >> 64;
uint64_t cLo = correction; uint64_t cLo = correction;
wideMultiply((rep_t)recip64, (rep_t)cHi, &dummy, &r64cH); wideMultiply((rep_t)recip64, (rep_t)cHi, &dummy, &r64cH);
wideMultiply((rep_t)recip64, (rep_t)cLo, &dummy, &r64cL); wideMultiply((rep_t)recip64, (rep_t)cLo, &dummy, &r64cL);
reciprocal = r64cH + (r64cL >> 64); reciprocal = r64cH + (r64cL >> 64);
// We already adjusted the 64-bit estimate, now we need to adjust the final // We already adjusted the 64-bit estimate, now we need to adjust the final
// 128-bit reciprocal estimate downward to ensure that it is strictly smaller // 128-bit reciprocal estimate downward to ensure that it is strictly smaller
// than the infinitely precise exact reciprocal. Because the computation // than the infinitely precise exact reciprocal. Because the computation
// of the Newton-Raphson step is truncating at every step, this adjustment // of the Newton-Raphson step is truncating at every step, this adjustment
// is small; most of the work is already done. // is small; most of the work is already done.
reciprocal -= 2; reciprocal -= 2;
// The numerical reciprocal is accurate to within 2^-112, lies in the // The numerical reciprocal is accurate to within 2^-112, lies in the
// interval [0.5, 1.0), and is strictly smaller than the true reciprocal // interval [0.5, 1.0), and is strictly smaller than the true reciprocal
// of b. Multiplying a by this reciprocal thus gives a numerical q = a/b // of b. Multiplying a by this reciprocal thus gives a numerical q = a/b
// in Q127 with the following properties: // in Q127 with the following properties:
// //
// 1. q < a/b // 1. q < a/b
// 2. q is in the interval [0.5, 2.0) // 2. q is in the interval [0.5, 2.0)
// 3. the error in q is bounded away from 2^-113 (actually, we have a // 3. the error in q is bounded away from 2^-113 (actually, we have a
// couple of bits to spare, but this is all we need). // couple of bits to spare, but this is all we need).
// We need a 128 x 128 multiply high to compute q, which isn't a basic // We need a 128 x 128 multiply high to compute q, which isn't a basic
// operation in C, so we need to be a little bit fussy. // operation in C, so we need to be a little bit fussy.
rep_t quotient, quotientLo; rep_t quotient, quotientLo;
wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo); wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo);
// Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0). // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
// In either case, we are going to compute a residual of the form // In either case, we are going to compute a residual of the form
// //
// r = a - q*b // r = a - q*b
// //
// We know from the construction of q that r satisfies: // We know from the construction of q that r satisfies:
// //
// 0 <= r < ulp(q)*b // 0 <= r < ulp(q)*b
// //
// if r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we // if r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we
// already have the correct result. The exact halfway case cannot occur. // already have the correct result. The exact halfway case cannot occur.
// We also take this time to right shift quotient if it falls in the [1,2) // We also take this time to right shift quotient if it falls in the [1,2)
// range and adjust the exponent accordingly. // range and adjust the exponent accordingly.
rep_t residual; rep_t residual;
rep_t qb; rep_t qb;
if (quotient < (implicitBit << 1)) { if (quotient < (implicitBit << 1)) {
wideMultiply(quotient, bSignificand, &dummy, &qb); wideMultiply(quotient, bSignificand, &dummy, &qb);
residual = (aSignificand << 113) - qb; residual = (aSignificand << 113) - qb;
quotientExponent--; quotientExponent--;
} else { } else {
quotient >>= 1; quotient >>= 1;
wideMultiply(quotient, bSignificand, &dummy, &qb); wideMultiply(quotient, bSignificand, &dummy, &qb);
residual = (aSignificand << 112) - qb; residual = (aSignificand << 112) - qb;
} }
const int writtenExponent = quotientExponent + exponentBias; const int writtenExponent = quotientExponent + exponentBias;
if (writtenExponent >= maxExponent) { if (writtenExponent >= maxExponent) {
// If we have overflowed the exponent, return infinity. // If we have overflowed the exponent, return infinity.
return fromRep(infRep | quotientSign); return fromRep(infRep | quotientSign);
} } else if (writtenExponent < 1) {
else if (writtenExponent < 1) {
if (writtenExponent == 0) { if (writtenExponent == 0) {
// Check whether the rounded result is normal. // Check whether the rounded result is normal.
const bool round = (residual << 1) > bSignificand; const bool round = (residual << 1) > bSignificand;
// Clear the implicit bit. // Clear the implicit bit.
rep_t absResult = quotient & significandMask; rep_t absResult = quotient & significandMask;
// Round. // Round.
absResult += round; absResult += round;
if (absResult & ~significandMask) { if (absResult & ~significandMask) {
// The rounded result is normal; return it. // The rounded result is normal; return it.
return fromRep(absResult | quotientSign); return fromRep(absResult | quotientSign);
} }
} }
// Flush denormals to zero. In the future, it would be nice to add // Flush denormals to zero. In the future, it would be nice to add
// code to round them correctly. // code to round them correctly.
return fromRep(quotientSign); return fromRep(quotientSign);
} } else {
else {
const bool round = (residual << 1) >= bSignificand; const bool round = (residual << 1) >= bSignificand;
// Clear the implicit bit // Clear the implicit bit
rep_t absResult = quotient & significandMask; rep_t absResult = quotient & significandMask;
// Insert the exponent // Insert the exponent
absResult |= (rep_t)writtenExponent << significandBits; absResult |= (rep_t)writtenExponent << significandBits;
// Round // Round
absResult += round; absResult += round;
// Insert the sign and return // Insert the sign and return
const long double result = fromRep(absResult | quotientSign); const long double result = fromRep(absResult | quotientSign);
return result; return result;
} }
} }
#endif #endif

compiler-rt/trunk/lib/builtins/divti3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a / b */ /* Returns: a / b */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __divti3(ti_int a, ti_int b) {
__divti3(ti_int a, ti_int b)
{
const int bits_in_tword_m1 = (int)(sizeof(ti_int) * CHAR_BIT) - 1; const int bits_in_tword_m1 = (int)(sizeof(ti_int) * CHAR_BIT) - 1;
ti_int s_a = a >> bits_in_tword_m1; /* s_a = a < 0 ? -1 : 0 */ ti_int s_a = a >> bits_in_tword_m1; /* s_a = a < 0 ? -1 : 0 */
ti_int s_b = b >> bits_in_tword_m1; /* s_b = b < 0 ? -1 : 0 */ ti_int s_b = b >> bits_in_tword_m1; /* s_b = b < 0 ? -1 : 0 */
a = (a ^ s_a) - s_a; /* negate if s_a == -1 */ a = (a ^ s_a) - s_a; /* negate if s_a == -1 */
b = (b ^ s_b) - s_b; /* negate if s_b == -1 */ b = (b ^ s_b) - s_b; /* negate if s_b == -1 */
s_a ^= s_b; /* sign of quotient */ s_a ^= s_b; /* sign of quotient */
return (__udivmodti4(a, b, (tu_int*)0) ^ s_a) - s_a; /* negate if s_a == -1 */ return (__udivmodti4(a, b, (tu_int *)0) ^ s_a) -
s_a; /* negate if s_a == -1 */
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/divxc3.c

Show All 11 Lines
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the quotient of (a + ib) / (c + id) */ /* Returns: the quotient of (a + ib) / (c + id) */
COMPILER_RT_ABI Lcomplex COMPILER_RT_ABI Lcomplex __divxc3(long double __a, long double __b,
__divxc3(long double __a, long double __b, long double __c, long double __d) long double __c, long double __d) {
{
int __ilogbw = 0; int __ilogbw = 0;
long double __logbw = crt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d))); long double __logbw = crt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
if (crt_isfinite(__logbw)) if (crt_isfinite(__logbw)) {
{
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbnl(__c, -__ilogbw); __c = crt_scalbnl(__c, -__ilogbw);
__d = crt_scalbnl(__d, -__ilogbw); __d = crt_scalbnl(__d, -__ilogbw);
} }
long double __denom = __c * __c + __d * __d; long double __denom = __c * __c + __d * __d;
Lcomplex z; Lcomplex z;
COMPLEX_REAL(z) = crt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw); COMPLEX_REAL(z) = crt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw);
COMPLEX_IMAGINARY(z) = crt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw); COMPLEX_IMAGINARY(z) =
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) crt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw);
{ if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
if ((__denom == 0) && (!crt_isnan(__a) || !crt_isnan(__b))) if ((__denom == 0) && (!crt_isnan(__a) || !crt_isnan(__b))) {
{
COMPLEX_REAL(z) = crt_copysignl(CRT_INFINITY, __c) * __a; COMPLEX_REAL(z) = crt_copysignl(CRT_INFINITY, __c) * __a;
COMPLEX_IMAGINARY(z) = crt_copysignl(CRT_INFINITY, __c) * __b; COMPLEX_IMAGINARY(z) = crt_copysignl(CRT_INFINITY, __c) * __b;
} } else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__c) &&
else if ((crt_isinf(__a) || crt_isinf(__b)) && crt_isfinite(__d)) {
crt_isfinite(__c) && crt_isfinite(__d))
{
__a = crt_copysignl(crt_isinf(__a) ? 1 : 0, __a); __a = crt_copysignl(crt_isinf(__a) ? 1 : 0, __a);
__b = crt_copysignl(crt_isinf(__b) ? 1 : 0, __b); __b = crt_copysignl(crt_isinf(__b) ? 1 : 0, __b);
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
} } else if (crt_isinf(__logbw) && __logbw > 0 && crt_isfinite(__a) &&
else if (crt_isinf(__logbw) && __logbw > 0 && crt_isfinite(__b)) {
crt_isfinite(__a) && crt_isfinite(__b))
{
__c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c); __c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c);
__d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d); __d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d);
COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d); COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d);
COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d); COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d);
} }
} }
return z; return z;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/emutls.c

/* ===---------- emutls.c - Implements __emutls_get_address ---------------=== /* ===---------- emutls.c - Implements __emutls_get_address ---------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "int_lib.h" #include "int_lib.h"
#include "int_util.h"
#ifdef __BIONIC__ #ifdef __BIONIC__
/* There are 4 pthread key cleanup rounds on Bionic. Delay emutls deallocation /* There are 4 pthread key cleanup rounds on Bionic. Delay emutls deallocation
to round 2. We need to delay deallocation because: to round 2. We need to delay deallocation because:
- Android versions older than M lack __cxa_thread_atexit_impl, so apps - Android versions older than M lack __cxa_thread_atexit_impl, so apps
use a pthread key destructor to call C++ destructors. use a pthread key destructor to call C++ destructors.
- Apps might use __thread/thread_local variables in pthread destructors. - Apps might use __thread/thread_local variables in pthread destructors.
We can't wait until the final two rounds, because jemalloc needs two rounds We can't wait until the final two rounds, because jemalloc needs two rounds
after the final malloc/free call to free its thread-specific data (see after the final malloc/free call to free its thread-specific data (see
https://reviews.llvm.org/D46978#1107507). */ https://reviews.llvm.org/D46978#1107507). */
#define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 1 #define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 1
#else #else
#define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 0 #define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 0
#endif #endif
typedef struct emutls_address_array { typedef struct emutls_address_array {
uintptr_t skip_destructor_rounds; uintptr_t skip_destructor_rounds;
uintptr_t size; /* number of elements in the 'data' array */ uintptr_t size; /* number of elements in the 'data' array */
void* data[]; void *data[];
} emutls_address_array; } emutls_address_array;
static void emutls_shutdown(emutls_address_array *array); static void emutls_shutdown(emutls_address_array *array);
#ifndef _WIN32 #ifndef _WIN32
#include <pthread.h> #include <pthread.h>
static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_key_t emutls_pthread_key; static pthread_key_t emutls_pthread_key;
static bool emutls_key_created = false; static bool emutls_key_created = false;
typedef unsigned int gcc_word __attribute__((mode(word))); typedef unsigned int gcc_word __attribute__((mode(word)));
typedef unsigned int gcc_pointer __attribute__((mode(pointer))); typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
/* Default is not to use posix_memalign, so systems like Android /* Default is not to use posix_memalign, so systems like Android
* can use thread local data without heavier POSIX memory allocators. * can use thread local data without heavier POSIX memory allocators.
*/ */
#ifndef EMUTLS_USE_POSIX_MEMALIGN #ifndef EMUTLS_USE_POSIX_MEMALIGN
#define EMUTLS_USE_POSIX_MEMALIGN 0 #define EMUTLS_USE_POSIX_MEMALIGN 0
#endif #endif
static __inline void *emutls_memalign_alloc(size_t align, size_t size) { static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
void *base; void *base;
#if EMUTLS_USE_POSIX_MEMALIGN #if EMUTLS_USE_POSIX_MEMALIGN
if (posix_memalign(&base, align, size) != 0) if (posix_memalign(&base, align, size) != 0)
abort(); abort();
#else #else
#define EXTRA_ALIGN_PTR_BYTES (align - 1 + sizeof(void*)) #define EXTRA_ALIGN_PTR_BYTES (align - 1 + sizeof(void *))
char* object; char *object;
if ((object = (char*)malloc(EXTRA_ALIGN_PTR_BYTES + size)) == NULL) if ((object = (char *)malloc(EXTRA_ALIGN_PTR_BYTES + size)) == NULL)
abort(); abort();
base = (void*)(((uintptr_t)(object + EXTRA_ALIGN_PTR_BYTES)) base = (void *)(((uintptr_t)(object + EXTRA_ALIGN_PTR_BYTES)) &
& ~(uintptr_t)(align - 1)); ~(uintptr_t)(align - 1));
((void**)base)[-1] = object; ((void **)base)[-1] = object;
#endif #endif
return base; return base;
} }
static __inline void emutls_memalign_free(void *base) { static __inline void emutls_memalign_free(void *base) {
#if EMUTLS_USE_POSIX_MEMALIGN #if EMUTLS_USE_POSIX_MEMALIGN
free(base); free(base);
#else #else
/* The mallocated address is in ((void**)base)[-1] */ /* The mallocated address is in ((void**)base)[-1] */
free(((void**)base)[-1]); free(((void **)base)[-1]);
#endif #endif
} }
static __inline void emutls_setspecific(emutls_address_array *value) { static __inline void emutls_setspecific(emutls_address_array *value) {
pthread_setspecific(emutls_pthread_key, (void*) value); pthread_setspecific(emutls_pthread_key, (void *)value);
} }
static __inline emutls_address_array* emutls_getspecific() { static __inline emutls_address_array *emutls_getspecific() {
return (emutls_address_array*) pthread_getspecific(emutls_pthread_key); return (emutls_address_array *)pthread_getspecific(emutls_pthread_key);
} }
static void emutls_key_destructor(void* ptr) { static void emutls_key_destructor(void *ptr) {
emutls_address_array *array = (emutls_address_array*)ptr; emutls_address_array *array = (emutls_address_array *)ptr;
if (array->skip_destructor_rounds > 0) { if (array->skip_destructor_rounds > 0) {
/* emutls is deallocated using a pthread key destructor. These /* emutls is deallocated using a pthread key destructor. These
* destructors are called in several rounds to accommodate destructor * destructors are called in several rounds to accommodate destructor
* functions that (re)initialize key values with pthread_setspecific. * functions that (re)initialize key values with pthread_setspecific.
* Delay the emutls deallocation to accommodate other end-of-thread * Delay the emutls deallocation to accommodate other end-of-thread
* cleanup tasks like calling thread_local destructors (e.g. the * cleanup tasks like calling thread_local destructors (e.g. the
* __cxa_thread_atexit fallback in libc++abi). * __cxa_thread_atexit fallback in libc++abi).
*/ */
array->skip_destructor_rounds--; array->skip_destructor_rounds--;
emutls_setspecific(array); emutls_setspecific(array);
} else { } else {
emutls_shutdown(array); emutls_shutdown(array);
free(ptr); free(ptr);
} }
} }
static __inline void emutls_init(void) { static __inline void emutls_init(void) {
if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0) if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0)
abort(); abort();
emutls_key_created = true; emutls_key_created = true;
} }
static __inline void emutls_init_once(void) { static __inline void emutls_init_once(void) {
static pthread_once_t once = PTHREAD_ONCE_INIT; static pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once(&once, emutls_init); pthread_once(&once, emutls_init);
} }
static __inline void emutls_lock() { static __inline void emutls_lock() { pthread_mutex_lock(&emutls_mutex); }
pthread_mutex_lock(&emutls_mutex);
}
static __inline void emutls_unlock() { static __inline void emutls_unlock() { pthread_mutex_unlock(&emutls_mutex); }
pthread_mutex_unlock(&emutls_mutex);
}
#else /* _WIN32 */ #else /* _WIN32 */
#include <windows.h> #include <assert.h>
#include <malloc.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <windows.h>
static LPCRITICAL_SECTION emutls_mutex; static LPCRITICAL_SECTION emutls_mutex;
static DWORD emutls_tls_index = TLS_OUT_OF_INDEXES; static DWORD emutls_tls_index = TLS_OUT_OF_INDEXES;
typedef uintptr_t gcc_word; typedef uintptr_t gcc_word;
typedef void * gcc_pointer; typedef void *gcc_pointer;
static void win_error(DWORD last_err, const char *hint) { static void win_error(DWORD last_err, const char *hint) {
char *buffer = NULL; char *buffer = NULL;
if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_MAX_WIDTH_MASK, FORMAT_MESSAGE_MAX_WIDTH_MASK,
NULL, last_err, 0, (LPSTR)&buffer, 1, NULL)) { NULL, last_err, 0, (LPSTR)&buffer, 1, NULL)) {
fprintf(stderr, "Windows error: %s\n", buffer); fprintf(stderr, "Windows error: %s\n", buffer);
} else { } else {
fprintf(stderr, "Unkown Windows error: %s\n", hint); fprintf(stderr, "Unkown Windows error: %s\n", hint);
} }
LocalFree(buffer); LocalFree(buffer);
} }
static __inline void win_abort(DWORD last_err, const char *hint) { static __inline void win_abort(DWORD last_err, const char *hint) {
win_error(last_err, hint); win_error(last_err, hint);
abort(); abort();
} }
static __inline void *emutls_memalign_alloc(size_t align, size_t size) { static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
void *base = _aligned_malloc(size, align); void *base = _aligned_malloc(size, align);
if (!base) if (!base)
win_abort(GetLastError(), "_aligned_malloc"); win_abort(GetLastError(), "_aligned_malloc");
return base; return base;
} }
static __inline void emutls_memalign_free(void *base) { static __inline void emutls_memalign_free(void *base) { _aligned_free(base); }
_aligned_free(base);
}
static void emutls_exit(void) { static void emutls_exit(void) {
if (emutls_mutex) { if (emutls_mutex) {
DeleteCriticalSection(emutls_mutex); DeleteCriticalSection(emutls_mutex);
_aligned_free(emutls_mutex); _aligned_free(emutls_mutex);
emutls_mutex = NULL; emutls_mutex = NULL;
} }
if (emutls_tls_index != TLS_OUT_OF_INDEXES) { if (emutls_tls_index != TLS_OUT_OF_INDEXES) {
emutls_shutdown((emutls_address_array*)TlsGetValue(emutls_tls_index)); emutls_shutdown((emutls_address_array *)TlsGetValue(emutls_tls_index));
TlsFree(emutls_tls_index); TlsFree(emutls_tls_index);
emutls_tls_index = TLS_OUT_OF_INDEXES; emutls_tls_index = TLS_OUT_OF_INDEXES;
} }
} }
#pragma warning (push) #pragma warning(push)
#pragma warning (disable : 4100) #pragma warning(disable : 4100)
static BOOL CALLBACK emutls_init(PINIT_ONCE p0, PVOID p1, PVOID *p2) { static BOOL CALLBACK emutls_init(PINIT_ONCE p0, PVOID p1, PVOID *p2) {
emutls_mutex = (LPCRITICAL_SECTION)_aligned_malloc(sizeof(CRITICAL_SECTION), 16); emutls_mutex =
(LPCRITICAL_SECTION)_aligned_malloc(sizeof(CRITICAL_SECTION), 16);
if (!emutls_mutex) { if (!emutls_mutex) {
win_error(GetLastError(), "_aligned_malloc"); win_error(GetLastError(), "_aligned_malloc");
return FALSE; return FALSE;
} }
InitializeCriticalSection(emutls_mutex); InitializeCriticalSection(emutls_mutex);
emutls_tls_index = TlsAlloc(); emutls_tls_index = TlsAlloc();
if (emutls_tls_index == TLS_OUT_OF_INDEXES) { if (emutls_tls_index == TLS_OUT_OF_INDEXES) {
emutls_exit(); emutls_exit();
win_error(GetLastError(), "TlsAlloc"); win_error(GetLastError(), "TlsAlloc");
return FALSE; return FALSE;
} }
atexit(&emutls_exit); atexit(&emutls_exit);
return TRUE; return TRUE;
} }
static __inline void emutls_init_once(void) { static __inline void emutls_init_once(void) {
static INIT_ONCE once; static INIT_ONCE once;
InitOnceExecuteOnce(&once, emutls_init, NULL, NULL); InitOnceExecuteOnce(&once, emutls_init, NULL, NULL);
} }
static __inline void emutls_lock() { static __inline void emutls_lock() { EnterCriticalSection(emutls_mutex); }
EnterCriticalSection(emutls_mutex);
}
static __inline void emutls_unlock() { static __inline void emutls_unlock() { LeaveCriticalSection(emutls_mutex); }
LeaveCriticalSection(emutls_mutex);
}
static __inline void emutls_setspecific(emutls_address_array *value) { static __inline void emutls_setspecific(emutls_address_array *value) {
if (TlsSetValue(emutls_tls_index, (LPVOID) value) == 0) if (TlsSetValue(emutls_tls_index, (LPVOID)value) == 0)
win_abort(GetLastError(), "TlsSetValue"); win_abort(GetLastError(), "TlsSetValue");
} }
static __inline emutls_address_array* emutls_getspecific() { static __inline emutls_address_array *emutls_getspecific() {
LPVOID value = TlsGetValue(emutls_tls_index); LPVOID value = TlsGetValue(emutls_tls_index);
if (value == NULL) { if (value == NULL) {
const DWORD err = GetLastError(); const DWORD err = GetLastError();
if (err != ERROR_SUCCESS) if (err != ERROR_SUCCESS)
win_abort(err, "TlsGetValue"); win_abort(err, "TlsGetValue");
} }
return (emutls_address_array*) value; return (emutls_address_array *)value;
} }
/* Provide atomic load/store functions for emutls_get_index if built with MSVC. /* Provide atomic load/store functions for emutls_get_index if built with MSVC.
*/ */
#if !defined(__ATOMIC_RELEASE) #if !defined(__ATOMIC_RELEASE)
#include <intrin.h> #include <intrin.h>
enum { __ATOMIC_ACQUIRE = 2, __ATOMIC_RELEASE = 3 }; enum { __ATOMIC_ACQUIRE = 2, __ATOMIC_RELEASE = 3 };
static __inline uintptr_t __atomic_load_n(void *ptr, unsigned type) { static __inline uintptr_t __atomic_load_n(void *ptr, unsigned type) {
assert(type == __ATOMIC_ACQUIRE); assert(type == __ATOMIC_ACQUIRE);
// These return the previous value - but since we do an OR with 0, // These return the previous value - but since we do an OR with 0,
// it's equivalent to a plain load. // it's equivalent to a plain load.
#ifdef _WIN64 #ifdef _WIN64
return InterlockedOr64(ptr, 0); return InterlockedOr64(ptr, 0);
#else #else
return InterlockedOr(ptr, 0); return InterlockedOr(ptr, 0);
#endif #endif
} }
static __inline void __atomic_store_n(void *ptr, uintptr_t val, unsigned type) { static __inline void __atomic_store_n(void *ptr, uintptr_t val, unsigned type) {
assert(type == __ATOMIC_RELEASE); assert(type == __ATOMIC_RELEASE);
InterlockedExchangePointer((void *volatile *)ptr, (void *)val); InterlockedExchangePointer((void *volatile *)ptr, (void *)val);
} }
#endif /* __ATOMIC_RELEASE */ #endif /* __ATOMIC_RELEASE */
#pragma warning (pop) #pragma warning(pop)
#endif /* _WIN32 */ #endif /* _WIN32 */
static size_t emutls_num_object = 0; /* number of allocated TLS objects */ static size_t emutls_num_object = 0; /* number of allocated TLS objects */
/* Free the allocated TLS data /* Free the allocated TLS data
*/ */
static void emutls_shutdown(emutls_address_array *array) { static void emutls_shutdown(emutls_address_array *array) {
if (array) { if (array) {
uintptr_t i; uintptr_t i;
for (i = 0; i < array->size; ++i) { for (i = 0; i < array->size; ++i) {
if (array->data[i]) if (array->data[i])
emutls_memalign_free(array->data[i]); emutls_memalign_free(array->data[i]);
} }
} }
} }
/* For every TLS variable xyz, /* For every TLS variable xyz,
* there is one __emutls_control variable named __emutls_v.xyz. * there is one __emutls_control variable named __emutls_v.xyz.
* If xyz has non-zero initial value, __emutls_v.xyz's "value" * If xyz has non-zero initial value, __emutls_v.xyz's "value"
* will point to __emutls_t.xyz, which has the initial value. * will point to __emutls_t.xyz, which has the initial value.
*/ */
typedef struct __emutls_control { typedef struct __emutls_control {
/* Must use gcc_word here, instead of size_t, to match GCC. When /* Must use gcc_word here, instead of size_t, to match GCC. When
gcc_word is larger than size_t, the upper extra bits are all gcc_word is larger than size_t, the upper extra bits are all
zeros. We can use variables of size_t to operate on size and zeros. We can use variables of size_t to operate on size and
align. */ align. */
gcc_word size; /* size of the object in bytes */ gcc_word size; /* size of the object in bytes */
gcc_word align; /* alignment of the object in bytes */ gcc_word align; /* alignment of the object in bytes */
union { union {
uintptr_t index; /* data[index-1] is the object address */ uintptr_t index; /* data[index-1] is the object address */
void* address; /* object address, when in single thread env */ void *address; /* object address, when in single thread env */
} object; } object;
void* value; /* null or non-zero initial value for the object */ void *value; /* null or non-zero initial value for the object */
} __emutls_control; } __emutls_control;
/* Emulated TLS objects are always allocated at run-time. */ /* Emulated TLS objects are always allocated at run-time. */
static __inline void *emutls_allocate_object(__emutls_control *control) { static __inline void *emutls_allocate_object(__emutls_control *control) {
/* Use standard C types, check with gcc's emutls.o. */ /* Use standard C types, check with gcc's emutls.o. */
COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(gcc_pointer)); COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(gcc_pointer));
COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(void*)); COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(void *));
size_t size = control->size; size_t size = control->size;
size_t align = control->align; size_t align = control->align;
void* base; void *base;
if (align < sizeof(void*)) if (align < sizeof(void *))
align = sizeof(void*); align = sizeof(void *);
/* Make sure that align is power of 2. */ /* Make sure that align is power of 2. */
if ((align & (align - 1)) != 0) if ((align & (align - 1)) != 0)
abort(); abort();
base = emutls_memalign_alloc(align, size); base = emutls_memalign_alloc(align, size);
if (control->value) if (control->value)
memcpy(base, control->value, size); memcpy(base, control->value, size);
else else
memset(base, 0, size); memset(base, 0, size);
return base; return base;
} }
/* Returns control->object.index; set index if not allocated yet. */ /* Returns control->object.index; set index if not allocated yet. */
static __inline uintptr_t emutls_get_index(__emutls_control *control) { static __inline uintptr_t emutls_get_index(__emutls_control *control) {
uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE); uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE);
if (!index) { if (!index) {
emutls_init_once(); emutls_init_once();
emutls_lock(); emutls_lock();
index = control->object.index; index = control->object.index;
if (!index) { if (!index) {
index = ++emutls_num_object; index = ++emutls_num_object;
__atomic_store_n(&control->object.index, index, __ATOMIC_RELEASE); __atomic_store_n(&control->object.index, index, __ATOMIC_RELEASE);
} }
emutls_unlock(); emutls_unlock();
} }
return index; return index;
} }
/* Updates newly allocated thread local emutls_address_array. */ /* Updates newly allocated thread local emutls_address_array. */
static __inline void emutls_check_array_set_size(emutls_address_array *array, static __inline void emutls_check_array_set_size(emutls_address_array *array,
uintptr_t size) { uintptr_t size) {
if (array == NULL) if (array == NULL)
abort(); abort();
array->size = size; array->size = size;
emutls_setspecific(array); emutls_setspecific(array);
} }
/* Returns the new 'data' array size, number of elements, /* Returns the new 'data' array size, number of elements,
* which must be no smaller than the given index. * which must be no smaller than the given index.
*/ */
static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) { static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) {
/* Need to allocate emutls_address_array with extra slots /* Need to allocate emutls_address_array with extra slots
* to store the header. * to store the header.
* Round up the emutls_address_array size to multiple of 16. * Round up the emutls_address_array size to multiple of 16.
*/ */
uintptr_t header_words = sizeof(emutls_address_array) / sizeof(void *); uintptr_t header_words = sizeof(emutls_address_array) / sizeof(void *);
return ((index + header_words + 15) & ~((uintptr_t)15)) - header_words; return ((index + header_words + 15) & ~((uintptr_t)15)) - header_words;
} }
/* Returns the size in bytes required for an emutls_address_array with /* Returns the size in bytes required for an emutls_address_array with
* N number of elements for data field. * N number of elements for data field.
*/ */
static __inline uintptr_t emutls_asize(uintptr_t N) { static __inline uintptr_t emutls_asize(uintptr_t N) {
return N * sizeof(void *) + sizeof(emutls_address_array); return N * sizeof(void *) + sizeof(emutls_address_array);
} }
/* Returns the thread local emutls_address_array. /* Returns the thread local emutls_address_array.
* Extends its size if necessary to hold address at index. * Extends its size if necessary to hold address at index.
*/ */
static __inline emutls_address_array * static __inline emutls_address_array *
emutls_get_address_array(uintptr_t index) { emutls_get_address_array(uintptr_t index) {
emutls_address_array* array = emutls_getspecific(); emutls_address_array *array = emutls_getspecific();
if (array == NULL) { if (array == NULL) {
uintptr_t new_size = emutls_new_data_array_size(index); uintptr_t new_size = emutls_new_data_array_size(index);
array = (emutls_address_array*) malloc(emutls_asize(new_size)); array = (emutls_address_array *)malloc(emutls_asize(new_size));
if (array) { if (array) {
memset(array->data, 0, new_size * sizeof(void*)); memset(array->data, 0, new_size * sizeof(void *));
array->skip_destructor_rounds = EMUTLS_SKIP_DESTRUCTOR_ROUNDS; array->skip_destructor_rounds = EMUTLS_SKIP_DESTRUCTOR_ROUNDS;
} }
emutls_check_array_set_size(array, new_size); emutls_check_array_set_size(array, new_size);
} else if (index > array->size) { } else if (index > array->size) {
uintptr_t orig_size = array->size; uintptr_t orig_size = array->size;
uintptr_t new_size = emutls_new_data_array_size(index); uintptr_t new_size = emutls_new_data_array_size(index);
array = (emutls_address_array*) realloc(array, emutls_asize(new_size)); array = (emutls_address_array *)realloc(array, emutls_asize(new_size));
if (array) if (array)
memset(array->data + orig_size, 0, memset(array->data + orig_size, 0,
(new_size - orig_size) * sizeof(void*)); (new_size - orig_size) * sizeof(void *));
emutls_check_array_set_size(array, new_size); emutls_check_array_set_size(array, new_size);
} }
return array; return array;
} }
void* __emutls_get_address(__emutls_control* control) { void *__emutls_get_address(__emutls_control *control) {
uintptr_t index = emutls_get_index(control); uintptr_t index = emutls_get_index(control);
emutls_address_array* array = emutls_get_address_array(index--); emutls_address_array *array = emutls_get_address_array(index--);
if (array->data[index] == NULL) if (array->data[index] == NULL)
array->data[index] = emutls_allocate_object(control); array->data[index] = emutls_allocate_object(control);
return array->data[index]; return array->data[index];
} }
#ifdef __BIONIC__ #ifdef __BIONIC__
/* Called by Bionic on dlclose to delete the emutls pthread key. */ /* Called by Bionic on dlclose to delete the emutls pthread key. */
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden"))) void __emutls_unregister_key(void) {
void __emutls_unregister_key(void) {
if (emutls_key_created) { if (emutls_key_created) {
pthread_key_delete(emutls_pthread_key); pthread_key_delete(emutls_pthread_key);
emutls_key_created = false; emutls_key_created = false;
} }
} }
#endif #endif

compiler-rt/trunk/lib/builtins/enable_execute_stack.c

Show All 23 Lines
#include <windows.h> #include <windows.h>
#else #else
#ifndef __APPLE__ #ifndef __APPLE__
#include <unistd.h> #include <unistd.h>
#endif /* __APPLE__ */ #endif /* __APPLE__ */
#endif /* _WIN32 */ #endif /* _WIN32 */
#if __LP64__ #if __LP64__
#define TRAMPOLINE_SIZE 48 #define TRAMPOLINE_SIZE 48
#else #else
#define TRAMPOLINE_SIZE 40 #define TRAMPOLINE_SIZE 40
#endif #endif
/* /*
* The compiler generates calls to __enable_execute_stack() when creating * The compiler generates calls to __enable_execute_stack() when creating
* trampoline functions on the stack for use with nested functions. * trampoline functions on the stack for use with nested functions.
* It is expected to mark the page(s) containing the address * It is expected to mark the page(s) containing the address
* and the next 48 bytes as executable. Since the stack is normally rw- * and the next 48 bytes as executable. Since the stack is normally rw-
* that means changing the protection on those page(s) to rwx. * that means changing the protection on those page(s) to rwx.
*/ */
COMPILER_RT_ABI void COMPILER_RT_ABI void __enable_execute_stack(void *addr) {
__enable_execute_stack(void* addr)
{
#if _WIN32 #if _WIN32
MEMORY_BASIC_INFORMATION mbi; MEMORY_BASIC_INFORMATION mbi;
if (!VirtualQuery (addr, &mbi, sizeof(mbi))) if (!VirtualQuery(addr, &mbi, sizeof(mbi)))
return; /* We should probably assert here because there is no return value */ return; /* We should probably assert here because there is no return value
VirtualProtect (mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &mbi.Protect); */
VirtualProtect(mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE,
&mbi.Protect);
#else #else
#if __APPLE__ #if __APPLE__
/* On Darwin, pagesize is always 4096 bytes */ /* On Darwin, pagesize is always 4096 bytes */
const uintptr_t pageSize = 4096; const uintptr_t pageSize = 4096;
#elif !defined(HAVE_SYSCONF) #elif !defined(HAVE_SYSCONF)
#error "HAVE_SYSCONF not defined! See enable_execute_stack.c" #error "HAVE_SYSCONF not defined! See enable_execute_stack.c"
#else #else
const uintptr_t pageSize = sysconf(_SC_PAGESIZE); const uintptr_t pageSize = sysconf(_SC_PAGESIZE);
#endif /* __APPLE__ */ #endif /* __APPLE__ */
const uintptr_t pageAlignMask = ~(pageSize-1); const uintptr_t pageAlignMask = ~(pageSize - 1);
uintptr_t p = (uintptr_t)addr; uintptr_t p = (uintptr_t)addr;
unsigned char* startPage = (unsigned char*)(p & pageAlignMask); unsigned char *startPage = (unsigned char *)(p & pageAlignMask);
unsigned char* endPage = (unsigned char*)((p+TRAMPOLINE_SIZE+pageSize) & pageAlignMask); unsigned char *endPage =
(unsigned char *)((p + TRAMPOLINE_SIZE + pageSize) & pageAlignMask);
size_t length = endPage - startPage; size_t length = endPage - startPage;
(void) mprotect((void *)startPage, length, PROT_READ | PROT_WRITE | PROT_EXEC); (void)mprotect((void *)startPage, length, PROT_READ | PROT_WRITE | PROT_EXEC);
#endif #endif
} }

compiler-rt/trunk/lib/builtins/eprintf.c

/* ===---------- eprintf.c - Implements __eprintf --------------------------=== /* ===---------- eprintf.c - Implements __eprintf --------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
/* /*
* __eprintf() was used in an old version of <assert.h>. * __eprintf() was used in an old version of <assert.h>.
* It can eventually go away, but it is needed when linking * It can eventually go away, but it is needed when linking
* .o files built with the old <assert.h>. * .o files built with the old <assert.h>.
* *
* It should never be exported from a dylib, so it is marked * It should never be exported from a dylib, so it is marked
* visibility hidden. * visibility hidden.
*/ */
#ifndef _WIN32 #ifndef _WIN32
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden")))
#endif #endif
COMPILER_RT_ABI void COMPILER_RT_ABI void
__eprintf(const char* format, const char* assertion_expression, __eprintf(const char *format, const char *assertion_expression,
const char* line, const char* file) const char *line, const char *file) {
{
fprintf(stderr, format, assertion_expression, line, file); fprintf(stderr, format, assertion_expression, line, file);
fflush(stderr); fflush(stderr);
compilerrt_abort(); compilerrt_abort();
} }

compiler-rt/trunk/lib/builtins/extenddftf2.c

Show All 10 Lines
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#define SRC_DOUBLE #define SRC_DOUBLE
#define DST_QUAD #define DST_QUAD
#include "fp_extend_impl.inc" #include "fp_extend_impl.inc"
COMPILER_RT_ABI long double __extenddftf2(double a) { COMPILER_RT_ABI long double __extenddftf2(double a) {
return __extendXfYf2__(a); return __extendXfYf2__(a);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/extendhfsf2.c

//===-- lib/extendhfsf2.c - half -> single conversion -------------*- C -*-===// //===-- lib/extendhfsf2.c - half -> single conversion -------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
#define SRC_HALF #define SRC_HALF
#define DST_SINGLE #define DST_SINGLE
#include "fp_extend_impl.inc" #include "fp_extend_impl.inc"
// Use a forwarding definition and noinline to implement a poor man's alias, // Use a forwarding definition and noinline to implement a poor man's alias,
// as there isn't a good cross-platform way of defining one. // as there isn't a good cross-platform way of defining one.
COMPILER_RT_ABI NOINLINE float __extendhfsf2(uint16_t a) { COMPILER_RT_ABI NOINLINE float __extendhfsf2(uint16_t a) {
return __extendXfYf2__(a); return __extendXfYf2__(a);
} }
COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) { COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) { return __extendhfsf2(a); }
return __extendhfsf2(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_h2f(uint16_t a) { AEABI_RTABI float __aeabi_h2f(uint16_t a) { return __extendhfsf2(a); }
return __extendhfsf2(a);
}
#else #else
AEABI_RTABI float __aeabi_h2f(uint16_t a) COMPILER_RT_ALIAS(__extendhfsf2); AEABI_RTABI float __aeabi_h2f(uint16_t a) COMPILER_RT_ALIAS(__extendhfsf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/extendsfdf2.c

//===-- lib/extendsfdf2.c - single -> double conversion -----------*- C -*-===// //===-- lib/extendsfdf2.c - single -> double conversion -----------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
#define SRC_SINGLE #define SRC_SINGLE
#define DST_DOUBLE #define DST_DOUBLE
#include "fp_extend_impl.inc" #include "fp_extend_impl.inc"
COMPILER_RT_ABI double __extendsfdf2(float a) { COMPILER_RT_ABI double __extendsfdf2(float a) { return __extendXfYf2__(a); }
return __extendXfYf2__(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_f2d(float a) { AEABI_RTABI double __aeabi_f2d(float a) { return __extendsfdf2(a); }
return __extendsfdf2(a);
}
#else #else
AEABI_RTABI double __aeabi_f2d(float a) COMPILER_RT_ALIAS(__extendsfdf2); AEABI_RTABI double __aeabi_f2d(float a) COMPILER_RT_ALIAS(__extendsfdf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/extendsftf2.c

Show All 10 Lines
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#define SRC_SINGLE #define SRC_SINGLE
#define DST_QUAD #define DST_QUAD
#include "fp_extend_impl.inc" #include "fp_extend_impl.inc"
COMPILER_RT_ABI long double __extendsftf2(float a) { COMPILER_RT_ABI long double __extendsftf2(float a) {
return __extendXfYf2__(a); return __extendXfYf2__(a);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/ffsdi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: the index of the least significant 1-bit in a, or /* Returns: the index of the least significant 1-bit in a, or
* the value zero if a is zero. The least significant bit is index one. * the value zero if a is zero. The least significant bit is index one.
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ffsdi2(di_int a) {
__ffsdi2(di_int a)
{
dwords x; dwords x;
x.all = a; x.all = a;
if (x.s.low == 0) if (x.s.low == 0) {
{
if (x.s.high == 0) if (x.s.high == 0)
return 0; return 0;
return __builtin_ctz(x.s.high) + (1 + sizeof(si_int) * CHAR_BIT); return __builtin_ctz(x.s.high) + (1 + sizeof(si_int) * CHAR_BIT);
} }
return __builtin_ctz(x.s.low) + 1; return __builtin_ctz(x.s.low) + 1;
} }

compiler-rt/trunk/lib/builtins/ffssi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: the index of the least significant 1-bit in a, or /* Returns: the index of the least significant 1-bit in a, or
* the value zero if a is zero. The least significant bit is index one. * the value zero if a is zero. The least significant bit is index one.
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ffssi2(si_int a) {
__ffssi2(si_int a) if (a == 0) {
{
if (a == 0)
{
return 0; return 0;
} }
return __builtin_ctz(a) + 1; return __builtin_ctz(a) + 1;
} }

compiler-rt/trunk/lib/builtins/ffsti2.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: the index of the least significant 1-bit in a, or /* Returns: the index of the least significant 1-bit in a, or
* the value zero if a is zero. The least significant bit is index one. * the value zero if a is zero. The least significant bit is index one.
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ffsti2(ti_int a) {
__ffsti2(ti_int a)
{
twords x; twords x;
x.all = a; x.all = a;
if (x.s.low == 0) if (x.s.low == 0) {
{
if (x.s.high == 0) if (x.s.high == 0)
return 0; return 0;
return __builtin_ctzll(x.s.high) + (1 + sizeof(di_int) * CHAR_BIT); return __builtin_ctzll(x.s.high) + (1 + sizeof(di_int) * CHAR_BIT);
} }
return __builtin_ctzll(x.s.low) + 1; return __builtin_ctzll(x.s.low) + 1;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/fixdfdi.c

Show All 11 Lines
#ifndef __SOFT_FP__ #ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; can set the invalid /* Support for systems that have hardware floating-point; can set the invalid
* flag as a side-effect of computation. * flag as a side-effect of computation.
*/ */
COMPILER_RT_ABI du_int __fixunsdfdi(double a); COMPILER_RT_ABI du_int __fixunsdfdi(double a);
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __fixdfdi(double a) {
__fixdfdi(double a)
{
if (a < 0.0) { if (a < 0.0) {
return -__fixunsdfdi(-a); return -__fixunsdfdi(-a);
} }
return __fixunsdfdi(a); return __fixunsdfdi(a);
} }
#else #else
/* Support for systems that don't have hardware floating-point; there are no /* Support for systems that don't have hardware floating-point; there are no
* flags to set, and we don't want to code-gen to an unknown soft-float * flags to set, and we don't want to code-gen to an unknown soft-float
* implementation. * implementation.
*/ */
typedef di_int fixint_t; typedef di_int fixint_t;
typedef du_int fixuint_t; typedef du_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __fixdfdi(fp_t a) { return __fixint(a); }
__fixdfdi(fp_t a) {
return __fixint(a);
}
#endif #endif
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { return __fixdfdi(a); }
return __fixdfdi(a);
}
#else #else
AEABI_RTABI di_int __aeabi_d2lz(fp_t a) COMPILER_RT_ALIAS(__fixdfdi); AEABI_RTABI di_int __aeabi_d2lz(fp_t a) COMPILER_RT_ALIAS(__fixdfdi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixdfsi.c

/* ===-- fixdfsi.c - Implement __fixdfsi -----------------------------------=== /* ===-- fixdfsi.c - Implement __fixdfsi -----------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef si_int fixint_t; typedef si_int fixint_t;
typedef su_int fixuint_t; typedef su_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __fixdfsi(fp_t a) { return __fixint(a); }
__fixdfsi(fp_t a) {
return __fixint(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI si_int __aeabi_d2iz(fp_t a) { AEABI_RTABI si_int __aeabi_d2iz(fp_t a) { return __fixdfsi(a); }
return __fixdfsi(a);
}
#else #else
AEABI_RTABI si_int __aeabi_d2iz(fp_t a) COMPILER_RT_ALIAS(__fixdfsi); AEABI_RTABI si_int __aeabi_d2iz(fp_t a) COMPILER_RT_ALIAS(__fixdfsi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixdfti.c

Show All 11 Lines
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef ti_int fixint_t; typedef ti_int fixint_t;
typedef tu_int fixuint_t; typedef tu_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __fixdfti(fp_t a) { return __fixint(a); }
__fixdfti(fp_t a) {
return __fixint(a);
}
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/fixsfdi.c

Show All 11 Lines
#ifndef __SOFT_FP__ #ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; can set the invalid /* Support for systems that have hardware floating-point; can set the invalid
* flag as a side-effect of computation. * flag as a side-effect of computation.
*/ */
COMPILER_RT_ABI du_int __fixunssfdi(float a); COMPILER_RT_ABI du_int __fixunssfdi(float a);
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __fixsfdi(float a) {
__fixsfdi(float a)
{
if (a < 0.0f) { if (a < 0.0f) {
return -__fixunssfdi(-a); return -__fixunssfdi(-a);
} }
return __fixunssfdi(a); return __fixunssfdi(a);
} }
#else #else
/* Support for systems that don't have hardware floating-point; there are no /* Support for systems that don't have hardware floating-point; there are no
* flags to set, and we don't want to code-gen to an unknown soft-float * flags to set, and we don't want to code-gen to an unknown soft-float
* implementation. * implementation.
*/ */
typedef di_int fixint_t; typedef di_int fixint_t;
typedef du_int fixuint_t; typedef du_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __fixsfdi(fp_t a) { return __fixint(a); }
__fixsfdi(fp_t a) {
return __fixint(a);
}
#endif #endif
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI di_int __aeabi_f2lz(fp_t a) { AEABI_RTABI di_int __aeabi_f2lz(fp_t a) { return __fixsfdi(a); }
return __fixsfdi(a);
}
#else #else
AEABI_RTABI di_int __aeabi_f2lz(fp_t a) COMPILER_RT_ALIAS(__fixsfdi); AEABI_RTABI di_int __aeabi_f2lz(fp_t a) COMPILER_RT_ALIAS(__fixsfdi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixsfsi.c

/* ===-- fixsfsi.c - Implement __fixsfsi -----------------------------------=== /* ===-- fixsfsi.c - Implement __fixsfsi -----------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef si_int fixint_t; typedef si_int fixint_t;
typedef su_int fixuint_t; typedef su_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __fixsfsi(fp_t a) { return __fixint(a); }
__fixsfsi(fp_t a) {
return __fixint(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI si_int __aeabi_f2iz(fp_t a) { AEABI_RTABI si_int __aeabi_f2iz(fp_t a) { return __fixsfsi(a); }
return __fixsfsi(a);
}
#else #else
AEABI_RTABI si_int __aeabi_f2iz(fp_t a) COMPILER_RT_ALIAS(__fixsfsi); AEABI_RTABI si_int __aeabi_f2iz(fp_t a) COMPILER_RT_ALIAS(__fixsfsi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixsfti.c

Show All 11 Lines
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef ti_int fixint_t; typedef ti_int fixint_t;
typedef tu_int fixuint_t; typedef tu_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __fixsfti(fp_t a) { return __fixint(a); }
__fixsfti(fp_t a) {
return __fixint(a);
}
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/fixtfdi.c

Show All 9 Lines
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
typedef di_int fixint_t; typedef di_int fixint_t;
typedef du_int fixuint_t; typedef du_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __fixtfdi(fp_t a) { return __fixint(a); }
__fixtfdi(fp_t a) {
return __fixint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixtfsi.c

Show All 9 Lines
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
typedef si_int fixint_t; typedef si_int fixint_t;
typedef su_int fixuint_t; typedef su_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __fixtfsi(fp_t a) { return __fixint(a); }
__fixtfsi(fp_t a) {
return __fixint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixtfti.c

Show All 9 Lines
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
typedef ti_int fixint_t; typedef ti_int fixint_t;
typedef tu_int fixuint_t; typedef tu_int fixuint_t;
#include "fp_fixint_impl.inc" #include "fp_fixint_impl.inc"
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __fixtfti(fp_t a) { return __fixint(a); }
__fixtfti(fp_t a) {
return __fixint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixunsdfdi.c

Show All 9 Lines
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#ifndef __SOFT_FP__ #ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; can set the invalid /* Support for systems that have hardware floating-point; can set the invalid
* flag as a side-effect of computation. * flag as a side-effect of computation.
*/ */
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __fixunsdfdi(double a) {
__fixunsdfdi(double a) if (a <= 0.0)
{ return 0;
if (a <= 0.0) return 0;
su_int high = a / 4294967296.f; /* a / 0x1p32f; */ su_int high = a / 4294967296.f; /* a / 0x1p32f; */
su_int low = a - (double)high * 4294967296.f; /* high * 0x1p32f; */ su_int low = a - (double)high * 4294967296.f; /* high * 0x1p32f; */
return ((du_int)high << 32) | low; return ((du_int)high << 32) | low;
} }
#else #else
/* Support for systems that don't have hardware floating-point; there are no /* Support for systems that don't have hardware floating-point; there are no
* flags to set, and we don't want to code-gen to an unknown soft-float * flags to set, and we don't want to code-gen to an unknown soft-float
* implementation. * implementation.
*/ */
typedef du_int fixuint_t; typedef du_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __fixunsdfdi(fp_t a) { return __fixuint(a); }
__fixunsdfdi(fp_t a) {
return __fixuint(a);
}
#endif #endif
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) { AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) { return __fixunsdfdi(a); }
return __fixunsdfdi(a);
}
#else #else
AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) COMPILER_RT_ALIAS(__fixunsdfdi); AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) COMPILER_RT_ALIAS(__fixunsdfdi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixunsdfsi.c

/* ===-- fixunsdfsi.c - Implement __fixunsdfsi -----------------------------=== /* ===-- fixunsdfsi.c - Implement __fixunsdfsi -----------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef su_int fixuint_t; typedef su_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __fixunsdfsi(fp_t a) { return __fixuint(a); }
__fixunsdfsi(fp_t a) {
return __fixuint(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) { AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) { return __fixunsdfsi(a); }
return __fixunsdfsi(a);
}
#else #else
AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) COMPILER_RT_ALIAS(__fixunsdfsi); AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) COMPILER_RT_ALIAS(__fixunsdfsi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixunsdfti.c

Show All 9 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef tu_int fixuint_t; typedef tu_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __fixunsdfti(fp_t a) { return __fixuint(a); }
__fixunsdfti(fp_t a) {
return __fixuint(a);
}
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/fixunssfdi.c

Show All 9 Lines
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#ifndef __SOFT_FP__ #ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; can set the invalid /* Support for systems that have hardware floating-point; can set the invalid
* flag as a side-effect of computation. * flag as a side-effect of computation.
*/ */
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __fixunssfdi(float a) {
__fixunssfdi(float a) if (a <= 0.0f)
{ return 0;
if (a <= 0.0f) return 0;
double da = a; double da = a;
su_int high = da / 4294967296.f; /* da / 0x1p32f; */ su_int high = da / 4294967296.f; /* da / 0x1p32f; */
su_int low = da - (double)high * 4294967296.f; /* high * 0x1p32f; */ su_int low = da - (double)high * 4294967296.f; /* high * 0x1p32f; */
return ((du_int)high << 32) | low; return ((du_int)high << 32) | low;
} }
#else #else
/* Support for systems that don't have hardware floating-point; there are no /* Support for systems that don't have hardware floating-point; there are no
* flags to set, and we don't want to code-gen to an unknown soft-float * flags to set, and we don't want to code-gen to an unknown soft-float
* implementation. * implementation.
*/ */
typedef du_int fixuint_t; typedef du_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __fixunssfdi(fp_t a) { return __fixuint(a); }
__fixunssfdi(fp_t a) {
return __fixuint(a);
}
#endif #endif
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) { AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) { return __fixunssfdi(a); }
return __fixunssfdi(a);
}
#else #else
AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) COMPILER_RT_ALIAS(__fixunssfdi); AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) COMPILER_RT_ALIAS(__fixunssfdi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixunssfsi.c

Show All 10 Lines
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
typedef su_int fixuint_t; typedef su_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __fixunssfsi(fp_t a) { return __fixuint(a); }
__fixunssfsi(fp_t a) {
return __fixuint(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) { AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) { return __fixunssfsi(a); }
return __fixunssfsi(a);
}
#else #else
AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) COMPILER_RT_ALIAS(__fixunssfsi); AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) COMPILER_RT_ALIAS(__fixunssfsi);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/fixunssfti.c

Show All 12 Lines
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) #if defined(CRT_HAS_128BIT)
typedef tu_int fixuint_t; typedef tu_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __fixunssfti(fp_t a) { return __fixuint(a); }
__fixunssfti(fp_t a) {
return __fixuint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixunstfdi.c

/* ===-- fixunstfdi.c - Implement __fixunstfdi -----------------------------=== /* ===-- fixunstfdi.c - Implement __fixunstfdi -----------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
typedef du_int fixuint_t; typedef du_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __fixunstfdi(fp_t a) { return __fixuint(a); }
__fixunstfdi(fp_t a) {
return __fixuint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixunstfsi.c

/* ===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------=== /* ===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
typedef su_int fixuint_t; typedef su_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __fixunstfsi(fp_t a) { return __fixuint(a); }
__fixunstfsi(fp_t a) {
return __fixuint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixunstfti.c

/* ===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------=== /* ===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
typedef tu_int fixuint_t; typedef tu_int fixuint_t;
#include "fp_fixuint_impl.inc" #include "fp_fixuint_impl.inc"
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __fixunstfti(fp_t a) { return __fixuint(a); }
__fixunstfti(fp_t a) {
return __fixuint(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/fixunsxfdi.c

Show All 13 Lines
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a to a unsigned long long, rounding toward zero. /* Returns: convert a to a unsigned long long, rounding toward zero.
* Negative values all become zero. * Negative values all become zero.
*/ */
/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes /* Assumption: long double is an intel 80 bit floating point type padded with 6
* du_int is a 64 bit integral type * bytes du_int is a 64 bit integral type value in long double is representable
* value in long double is representable in du_int or is negative * in du_int or is negative (no range checking performed)
* (no range checking performed)
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __fixunsxfdi(long double a) {
__fixunsxfdi(long double a)
{
long_double_bits fb; long_double_bits fb;
fb.f = a; fb.f = a;
int e = (fb.u.high.s.low & 0x00007FFF) - 16383; int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
if (e < 0 || (fb.u.high.s.low & 0x00008000)) if (e < 0 || (fb.u.high.s.low & 0x00008000))
return 0; return 0;
if ((unsigned)e > sizeof(du_int) * CHAR_BIT) if ((unsigned)e > sizeof(du_int) * CHAR_BIT)
return ~(du_int)0; return ~(du_int)0;
return fb.u.low.all >> (63 - e); return fb.u.low.all >> (63 - e);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/fixunsxfsi.c

Show All 13 Lines
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a to a unsigned int, rounding toward zero. /* Returns: convert a to a unsigned int, rounding toward zero.
* Negative values all become zero. * Negative values all become zero.
*/ */
/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes /* Assumption: long double is an intel 80 bit floating point type padded with 6
* su_int is a 32 bit integral type * bytes su_int is a 32 bit integral type value in long double is representable
* value in long double is representable in su_int or is negative * in su_int or is negative
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __fixunsxfsi(long double a) {
__fixunsxfsi(long double a)
{
long_double_bits fb; long_double_bits fb;
fb.f = a; fb.f = a;
int e = (fb.u.high.s.low & 0x00007FFF) - 16383; int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
if (e < 0 || (fb.u.high.s.low & 0x00008000)) if (e < 0 || (fb.u.high.s.low & 0x00008000))
return 0; return 0;
if ((unsigned)e > sizeof(su_int) * CHAR_BIT) if ((unsigned)e > sizeof(su_int) * CHAR_BIT)
return ~(su_int)0; return ~(su_int)0;
return fb.u.low.s.high >> (31 - e); return fb.u.low.s.high >> (31 - e);
} }
#endif /* !_ARCH_PPC */ #endif /* !_ARCH_PPC */

compiler-rt/trunk/lib/builtins/fixunsxfti.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a unsigned long long, rounding toward zero. /* Returns: convert a to a unsigned long long, rounding toward zero.
* Negative values all become zero. * Negative values all become zero.
*/ */
/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes /* Assumption: long double is an intel 80 bit floating point type padded with 6
* tu_int is a 128 bit integral type * bytes tu_int is a 128 bit integral type value in long double is representable
* value in long double is representable in tu_int or is negative * in tu_int or is negative
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __fixunsxfti(long double a) {
__fixunsxfti(long double a)
{
long_double_bits fb; long_double_bits fb;
fb.f = a; fb.f = a;
int e = (fb.u.high.s.low & 0x00007FFF) - 16383; int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
if (e < 0 || (fb.u.high.s.low & 0x00008000)) if (e < 0 || (fb.u.high.s.low & 0x00008000))
return 0; return 0;
if ((unsigned)e > sizeof(tu_int) * CHAR_BIT) if ((unsigned)e > sizeof(tu_int) * CHAR_BIT)
return ~(tu_int)0; return ~(tu_int)0;
tu_int r = fb.u.low.all; tu_int r = fb.u.low.all;
if (e > 63) if (e > 63)
r <<= (e - 63); r <<= (e - 63);
else else
r >>= (63 - e); r >>= (63 - e);
return r; return r;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/fixxfdi.c

Show All 11 Lines
*/ */
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a to a signed long long, rounding toward zero. */ /* Returns: convert a to a signed long long, rounding toward zero. */
/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes /* Assumption: long double is an intel 80 bit floating point type padded with 6
* di_int is a 64 bit integral type * bytes di_int is a 64 bit integral type value in long double is representable
* value in long double is representable in di_int (no range checking performed) * in di_int (no range checking performed)
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __fixxfdi(long double a) {
__fixxfdi(long double a)
{
const di_int di_max = (di_int)((~(du_int)0) / 2); const di_int di_max = (di_int)((~(du_int)0) / 2);
const di_int di_min = -di_max - 1; const di_int di_min = -di_max - 1;
long_double_bits fb; long_double_bits fb;
fb.f = a; fb.f = a;
int e = (fb.u.high.s.low & 0x00007FFF) - 16383; int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
if (e < 0) if (e < 0)
return 0; return 0;
if ((unsigned)e >= sizeof(di_int) * CHAR_BIT) if ((unsigned)e >= sizeof(di_int) * CHAR_BIT)
return a > 0 ? di_max : di_min; return a > 0 ? di_max : di_min;
di_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15); di_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15);
di_int r = fb.u.low.all; di_int r = fb.u.low.all;
r = (du_int)r >> (63 - e); r = (du_int)r >> (63 - e);
return (r ^ s) - s; return (r ^ s) - s;
} }
#endif /* !_ARCH_PPC */ #endif /* !_ARCH_PPC */

compiler-rt/trunk/lib/builtins/fixxfti.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a signed long long, rounding toward zero. */ /* Returns: convert a to a signed long long, rounding toward zero. */
/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes /* Assumption: long double is an intel 80 bit floating point type padded with 6
* ti_int is a 128 bit integral type * bytes ti_int is a 128 bit integral type value in long double is representable
* value in long double is representable in ti_int * in ti_int
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __fixxfti(long double a) {
__fixxfti(long double a)
{
const ti_int ti_max = (ti_int)((~(tu_int)0) / 2); const ti_int ti_max = (ti_int)((~(tu_int)0) / 2);
const ti_int ti_min = -ti_max - 1; const ti_int ti_min = -ti_max - 1;
long_double_bits fb; long_double_bits fb;
fb.f = a; fb.f = a;
int e = (fb.u.high.s.low & 0x00007FFF) - 16383; int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
if (e < 0) if (e < 0)
return 0; return 0;
ti_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15); ti_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15);
ti_int r = fb.u.low.all; ti_int r = fb.u.low.all;
if ((unsigned)e >= sizeof(ti_int) * CHAR_BIT) if ((unsigned)e >= sizeof(ti_int) * CHAR_BIT)
return a > 0 ? ti_max : ti_min; return a > 0 ? ti_max : ti_min;
if (e > 63) if (e > 63)
r <<= (e - 63); r <<= (e - 63);
else else
r >>= (63 - e); r >>= (63 - e);
return (r ^ s) - s; return (r ^ s) - s;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/floatdidf.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a to a double, rounding toward even. */ /* Returns: convert a to a double, rounding toward even. */
/* Assumption: double is a IEEE 64 bit floating point type /* Assumption: double is a IEEE 64 bit floating point type
* di_int is a 64 bit integral type * di_int is a 64 bit integral type
*/ */
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm */
#ifndef __SOFT_FP__ #ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; we'll set the inexact flag /* Support for systems that have hardware floating-point; we'll set the inexact
* as a side-effect of this computation. * flag as a side-effect of this computation.
*/ */
COMPILER_RT_ABI double COMPILER_RT_ABI double __floatdidf(di_int a) {
__floatdidf(di_int a)
{
static const double twop52 = 4503599627370496.0; // 0x1.0p52 static const double twop52 = 4503599627370496.0; // 0x1.0p52
static const double twop32 = 4294967296.0; // 0x1.0p32 static const double twop32 = 4294967296.0; // 0x1.0p32
union { int64_t x; double d; } low = { .d = twop52 }; union {
int64_t x;
double d;
} low = {.d = twop52};
const double high = (int32_t)(a >> 32) * twop32; const double high = (int32_t)(a >> 32) * twop32;
low.x |= a & INT64_C(0x00000000ffffffff); low.x |= a & INT64_C(0x00000000ffffffff);
const double result = (high - twop52) + low.d; const double result = (high - twop52) + low.d;
return result; return result;
} }
#else #else
/* Support for systems that don't have hardware floating-point; there are no flags to /* Support for systems that don't have hardware floating-point; there are no
* set, and we don't want to code-gen to an unknown soft-float implementation. * flags to set, and we don't want to code-gen to an unknown soft-float
* implementation.
*/ */
COMPILER_RT_ABI double COMPILER_RT_ABI double __floatdidf(di_int a) {
__floatdidf(di_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(di_int) * CHAR_BIT; const unsigned N = sizeof(di_int) * CHAR_BIT;
const di_int s = a >> (N-1); const di_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int sd = N - __builtin_clzll(a); /* number of significant digits */ int sd = N - __builtin_clzll(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > DBL_MANT_DIG) if (sd > DBL_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit DBL_MANT_DIG-1 bits to the right of 1 * P = bit DBL_MANT_DIG-1 bits to the right of 1
* Q = bit DBL_MANT_DIG bits to the right of 1 * Q = bit DBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case DBL_MANT_DIG + 1: case DBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case DBL_MANT_DIG + 2: case DBL_MANT_DIG + 2:
break; break;
default: default:
a = ((du_int)a >> (sd - (DBL_MANT_DIG+2))) | a = ((du_int)a >> (sd - (DBL_MANT_DIG + 2))) |
((a & ((du_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0); ((a & ((du_int)(-1) >> ((N + DBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */ /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
if (a & ((du_int)1 << DBL_MANT_DIG)) if (a & ((du_int)1 << DBL_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} } else {
else
{
a <<= (DBL_MANT_DIG - sd); a <<= (DBL_MANT_DIG - sd);
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} }
double_bits fb; double_bits fb;
fb.u.s.high = ((su_int)s & 0x80000000) | /* sign */ fb.u.s.high = ((su_int)s & 0x80000000) | /* sign */
((e + 1023) << 20) | /* exponent */ ((e + 1023) << 20) | /* exponent */
((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */ ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
fb.u.s.low = (su_int)a; /* mantissa-low */ fb.u.s.low = (su_int)a; /* mantissa-low */
return fb.f; return fb.f;
} }
#endif #endif
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_l2d(di_int a) { AEABI_RTABI double __aeabi_l2d(di_int a) { return __floatdidf(a); }
return __floatdidf(a);
}
#else #else
AEABI_RTABI double __aeabi_l2d(di_int a) COMPILER_RT_ALIAS(__floatdidf); AEABI_RTABI double __aeabi_l2d(di_int a) COMPILER_RT_ALIAS(__floatdidf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatdisf.c

/*===-- floatdisf.c - Implement __floatdisf -------------------------------=== /*===-- floatdisf.c - Implement __floatdisf -------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
*===----------------------------------------------------------------------=== *===----------------------------------------------------------------------===
* *
* This file implements __floatdisf for the compiler_rt library. * This file implements __floatdisf for the compiler_rt library.
* *
*===----------------------------------------------------------------------=== *===----------------------------------------------------------------------===
*/ */
/* Returns: convert a to a float, rounding toward even.*/ /* Returns: convert a to a float, rounding toward even.*/
/* Assumption: float is a IEEE 32 bit floating point type /* Assumption: float is a IEEE 32 bit floating point type
* di_int is a 64 bit integral type * di_int is a 64 bit integral type
*/ */
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI float COMPILER_RT_ABI float __floatdisf(di_int a) {
__floatdisf(di_int a)
{
if (a == 0) if (a == 0)
return 0.0F; return 0.0F;
const unsigned N = sizeof(di_int) * CHAR_BIT; const unsigned N = sizeof(di_int) * CHAR_BIT;
const di_int s = a >> (N-1); const di_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int sd = N - __builtin_clzll(a); /* number of significant digits */ int sd = N - __builtin_clzll(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > FLT_MANT_DIG) if (sd > FLT_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit FLT_MANT_DIG-1 bits to the right of 1 * P = bit FLT_MANT_DIG-1 bits to the right of 1
* Q = bit FLT_MANT_DIG bits to the right of 1 * Q = bit FLT_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case FLT_MANT_DIG + 1: case FLT_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case FLT_MANT_DIG + 2: case FLT_MANT_DIG + 2:
break; break;
default: default:
a = ((du_int)a >> (sd - (FLT_MANT_DIG+2))) | a = ((du_int)a >> (sd - (FLT_MANT_DIG + 2))) |
((a & ((du_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0); ((a & ((du_int)(-1) >> ((N + FLT_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */ /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
if (a & ((du_int)1 << FLT_MANT_DIG)) if (a & ((du_int)1 << FLT_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} } else {
else
{
a <<= (FLT_MANT_DIG - sd); a <<= (FLT_MANT_DIG - sd);
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} }
float_bits fb; float_bits fb;
fb.u = ((su_int)s & 0x80000000) | /* sign */ fb.u = ((su_int)s & 0x80000000) | /* sign */
((e + 127) << 23) | /* exponent */ ((e + 127) << 23) | /* exponent */
((su_int)a & 0x007FFFFF); /* mantissa */ ((su_int)a & 0x007FFFFF); /* mantissa */
return fb.f; return fb.f;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_l2f(di_int a) { AEABI_RTABI float __aeabi_l2f(di_int a) { return __floatdisf(a); }
return __floatdisf(a);
}
#else #else
AEABI_RTABI float __aeabi_l2f(di_int a) COMPILER_RT_ALIAS(__floatdisf); AEABI_RTABI float __aeabi_l2f(di_int a) COMPILER_RT_ALIAS(__floatdisf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatditf.c

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatditf(di_int a) { COMPILER_RT_ABI fp_t __floatditf(di_int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
rep_t sign = 0; rep_t sign = 0;
du_int aAbs = (du_int)a; du_int aAbs = (du_int)a;
if (a < 0) { if (a < 0) {
sign = signBit; sign = signBit;
aAbs = ~(du_int)a + 1U; aAbs = ~(du_int)a + 1U;
} }
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clzll(aAbs); const int exponent = (aWidth - 1) - __builtin_clzll(aAbs);
rep_t result; rep_t result;
// Shift a into the significand field, rounding if it is a right-shift // Shift a into the significand field, rounding if it is a right-shift
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)aAbs << shift ^ implicitBit; result = (rep_t)aAbs << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
// Insert the sign bit and return // Insert the sign bit and return
return fromRep(result | sign); return fromRep(result | sign);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/floatdixf.c

/* ===-- floatdixf.c - Implement __floatdixf -------------------------------=== /* ===-- floatdixf.c - Implement __floatdixf -------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
* This file implements __floatdixf for the compiler_rt library. * This file implements __floatdixf for the compiler_rt library.
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a to a long double, rounding toward even. */ /* Returns: convert a to a long double, rounding toward even. */
/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits /* Assumption: long double is a IEEE 80 bit floating point type padded to 128
* di_int is a 64 bit integral type * bits di_int is a 64 bit integral type
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI long double COMPILER_RT_ABI long double __floatdixf(di_int a) {
__floatdixf(di_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(di_int) * CHAR_BIT; const unsigned N = sizeof(di_int) * CHAR_BIT;
const di_int s = a >> (N-1); const di_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int clz = __builtin_clzll(a); int clz = __builtin_clzll(a);
int e = (N - 1) - clz ; /* exponent */ int e = (N - 1) - clz; /* exponent */
long_double_bits fb; long_double_bits fb;
fb.u.high.s.low = ((su_int)s & 0x00008000) | /* sign */ fb.u.high.s.low = ((su_int)s & 0x00008000) | /* sign */
(e + 16383); /* exponent */ (e + 16383); /* exponent */
fb.u.low.all = a << clz; /* mantissa */ fb.u.low.all = a << clz; /* mantissa */
return fb.f; return fb.f;
} }
#endif /* !_ARCH_PPC */ #endif /* !_ARCH_PPC */

compiler-rt/trunk/lib/builtins/floatsidf.c

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __floatsidf(int a) {
__floatsidf(int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
rep_t sign = 0; rep_t sign = 0;
if (a < 0) { if (a < 0) {
sign = signBit; sign = signBit;
a = -a; a = -a;
} }
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clz(a); const int exponent = (aWidth - 1) - __builtin_clz(a);
rep_t result; rep_t result;
// Shift a into the significand field and clear the implicit bit. Extra // Shift a into the significand field and clear the implicit bit. Extra
// cast to unsigned int is necessary to get the correct behavior for // cast to unsigned int is necessary to get the correct behavior for
// the input INT_MIN. // the input INT_MIN.
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)(unsigned int)a << shift ^ implicitBit; result = (rep_t)(unsigned int)a << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
// Insert the sign bit and return // Insert the sign bit and return
return fromRep(result | sign); return fromRep(result | sign);
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_i2d(int a) { AEABI_RTABI fp_t __aeabi_i2d(int a) { return __floatsidf(a); }
return __floatsidf(a);
}
#else #else
AEABI_RTABI fp_t __aeabi_i2d(int a) COMPILER_RT_ALIAS(__floatsidf); AEABI_RTABI fp_t __aeabi_i2d(int a) COMPILER_RT_ALIAS(__floatsidf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatsisf.c

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __floatsisf(int a) {
__floatsisf(int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
rep_t sign = 0; rep_t sign = 0;
if (a < 0) { if (a < 0) {
sign = signBit; sign = signBit;
a = -a; a = -a;
} }
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clz(a); const int exponent = (aWidth - 1) - __builtin_clz(a);
rep_t result; rep_t result;
// Shift a into the significand field, rounding if it is a right-shift // Shift a into the significand field, rounding if it is a right-shift
if (exponent <= significandBits) { if (exponent <= significandBits) {
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)a << shift ^ implicitBit; result = (rep_t)a << shift ^ implicitBit;
} else { } else {
const int shift = exponent - significandBits; const int shift = exponent - significandBits;
result = (rep_t)a >> shift ^ implicitBit; result = (rep_t)a >> shift ^ implicitBit;
rep_t round = (rep_t)a << (typeWidth - shift); rep_t round = (rep_t)a << (typeWidth - shift);
if (round > signBit) result++; if (round > signBit)
if (round == signBit) result += result & 1; result++;
if (round == signBit)
result += result & 1;
} }
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
// Insert the sign bit and return // Insert the sign bit and return
return fromRep(result | sign); return fromRep(result | sign);
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_i2f(int a) { AEABI_RTABI fp_t __aeabi_i2f(int a) { return __floatsisf(a); }
return __floatsisf(a);
}
#else #else
AEABI_RTABI fp_t __aeabi_i2f(int a) COMPILER_RT_ALIAS(__floatsisf); AEABI_RTABI fp_t __aeabi_i2f(int a) COMPILER_RT_ALIAS(__floatsisf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatsitf.c

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatsitf(int a) { COMPILER_RT_ABI fp_t __floatsitf(int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
rep_t sign = 0; rep_t sign = 0;
unsigned aAbs = (unsigned)a; unsigned aAbs = (unsigned)a;
if (a < 0) { if (a < 0) {
sign = signBit; sign = signBit;
aAbs = ~(unsigned)a + 1U; aAbs = ~(unsigned)a + 1U;
} }
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clz(aAbs); const int exponent = (aWidth - 1) - __builtin_clz(aAbs);
rep_t result; rep_t result;
// Shift a into the significand field and clear the implicit bit. // Shift a into the significand field and clear the implicit bit.
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)aAbs << shift ^ implicitBit; result = (rep_t)aAbs << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
// Insert the sign bit and return // Insert the sign bit and return
return fromRep(result | sign); return fromRep(result | sign);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/floattidf.c

Show All 15 Lines
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a double, rounding toward even.*/ /* Returns: convert a to a double, rounding toward even.*/
/* Assumption: double is a IEEE 64 bit floating point type /* Assumption: double is a IEEE 64 bit floating point type
* ti_int is a 128 bit integral type * ti_int is a 128 bit integral type
*/ */
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm */
COMPILER_RT_ABI double COMPILER_RT_ABI double __floattidf(ti_int a) {
__floattidf(ti_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(ti_int) * CHAR_BIT; const unsigned N = sizeof(ti_int) * CHAR_BIT;
const ti_int s = a >> (N-1); const ti_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > DBL_MANT_DIG) if (sd > DBL_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit DBL_MANT_DIG-1 bits to the right of 1 * P = bit DBL_MANT_DIG-1 bits to the right of 1
* Q = bit DBL_MANT_DIG bits to the right of 1 * Q = bit DBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case DBL_MANT_DIG + 1: case DBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case DBL_MANT_DIG + 2: case DBL_MANT_DIG + 2:
break; break;
default: default:
a = ((tu_int)a >> (sd - (DBL_MANT_DIG+2))) | a = ((tu_int)a >> (sd - (DBL_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + DBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */ /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
if (a & ((tu_int)1 << DBL_MANT_DIG)) if (a & ((tu_int)1 << DBL_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} } else {
else
{
a <<= (DBL_MANT_DIG - sd); a <<= (DBL_MANT_DIG - sd);
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} }
double_bits fb; double_bits fb;
fb.u.s.high = ((su_int)s & 0x80000000) | /* sign */ fb.u.s.high = ((su_int)s & 0x80000000) | /* sign */
((e + 1023) << 20) | /* exponent */ ((e + 1023) << 20) | /* exponent */
((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */ ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
fb.u.s.low = (su_int)a; /* mantissa-low */ fb.u.s.low = (su_int)a; /* mantissa-low */
return fb.f; return fb.f;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/floattisf.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a float, rounding toward even. */ /* Returns: convert a to a float, rounding toward even. */
/* Assumption: float is a IEEE 32 bit floating point type /* Assumption: float is a IEEE 32 bit floating point type
* ti_int is a 128 bit integral type * ti_int is a 128 bit integral type
*/ */
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
COMPILER_RT_ABI float COMPILER_RT_ABI float __floattisf(ti_int a) {
__floattisf(ti_int a)
{
if (a == 0) if (a == 0)
return 0.0F; return 0.0F;
const unsigned N = sizeof(ti_int) * CHAR_BIT; const unsigned N = sizeof(ti_int) * CHAR_BIT;
const ti_int s = a >> (N-1); const ti_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > FLT_MANT_DIG) if (sd > FLT_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit FLT_MANT_DIG-1 bits to the right of 1 * P = bit FLT_MANT_DIG-1 bits to the right of 1
* Q = bit FLT_MANT_DIG bits to the right of 1 * Q = bit FLT_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case FLT_MANT_DIG + 1: case FLT_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case FLT_MANT_DIG + 2: case FLT_MANT_DIG + 2:
break; break;
default: default:
a = ((tu_int)a >> (sd - (FLT_MANT_DIG+2))) | a = ((tu_int)a >> (sd - (FLT_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + FLT_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */ /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
if (a & ((tu_int)1 << FLT_MANT_DIG)) if (a & ((tu_int)1 << FLT_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} } else {
else
{
a <<= (FLT_MANT_DIG - sd); a <<= (FLT_MANT_DIG - sd);
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} }
float_bits fb; float_bits fb;
fb.u = ((su_int)s & 0x80000000) | /* sign */ fb.u = ((su_int)s & 0x80000000) | /* sign */
((e + 127) << 23) | /* exponent */ ((e + 127) << 23) | /* exponent */
((su_int)a & 0x007FFFFF); /* mantissa */ ((su_int)a & 0x007FFFFF); /* mantissa */
return fb.f; return fb.f;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/floattitf.c

Show All 16 Lines
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a ti_int to a fp_t, rounding toward even. */ /* Returns: convert a ti_int to a fp_t, rounding toward even. */
/* Assumption: fp_t is a IEEE 128 bit floating point type /* Assumption: fp_t is a IEEE 128 bit floating point type
* ti_int is a 128 bit integral type * ti_int is a 128 bit integral type
*/ */
/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | /* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __floattitf(ti_int a) {
__floattitf(ti_int a) {
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(ti_int) * CHAR_BIT; const unsigned N = sizeof(ti_int) * CHAR_BIT;
const ti_int s = a >> (N-1); const ti_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > LDBL_MANT_DIG) { if (sd > LDBL_MANT_DIG) {
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit LDBL_MANT_DIG-1 bits to the right of 1 * P = bit LDBL_MANT_DIG-1 bits to the right of 1
* Q = bit LDBL_MANT_DIG bits to the right of 1 * Q = bit LDBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) { switch (sd) {
case LDBL_MANT_DIG + 1: case LDBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case LDBL_MANT_DIG + 2: case LDBL_MANT_DIG + 2:
break; break;
default: default:
a = ((tu_int)a >> (sd - (LDBL_MANT_DIG+2))) | a = ((tu_int)a >> (sd - (LDBL_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */ /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
if (a & ((tu_int)1 << LDBL_MANT_DIG)) { if (a & ((tu_int)1 << LDBL_MANT_DIG)) {
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} else { } else {
a <<= (LDBL_MANT_DIG - sd); a <<= (LDBL_MANT_DIG - sd);
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} }
long_double_bits fb; long_double_bits fb;
fb.u.high.all = (s & 0x8000000000000000LL) /* sign */ fb.u.high.all = (s & 0x8000000000000000LL) /* sign */
| (du_int)(e + 16383) << 48 /* exponent */ | (du_int)(e + 16383) << 48 /* exponent */
| ((a >> 64) & 0x0000ffffffffffffLL); /* significand */ | ((a >> 64) & 0x0000ffffffffffffLL); /* significand */
fb.u.low.all = (du_int)(a); fb.u.low.all = (du_int)(a);
return fb.f; return fb.f;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/floattixf.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a long double, rounding toward even. */ /* Returns: convert a to a long double, rounding toward even. */
/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits /* Assumption: long double is a IEEE 80 bit floating point type padded to 128
* ti_int is a 128 bit integral type * bits ti_int is a 128 bit integral type
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI long double COMPILER_RT_ABI long double __floattixf(ti_int a) {
__floattixf(ti_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(ti_int) * CHAR_BIT; const unsigned N = sizeof(ti_int) * CHAR_BIT;
const ti_int s = a >> (N-1); const ti_int s = a >> (N - 1);
a = (a ^ s) - s; a = (a ^ s) - s;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > LDBL_MANT_DIG) if (sd > LDBL_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit LDBL_MANT_DIG-1 bits to the right of 1 * P = bit LDBL_MANT_DIG-1 bits to the right of 1
* Q = bit LDBL_MANT_DIG bits to the right of 1 * Q = bit LDBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case LDBL_MANT_DIG + 1: case LDBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case LDBL_MANT_DIG + 2: case LDBL_MANT_DIG + 2:
break; break;
default: default:
a = ((tu_int)a >> (sd - (LDBL_MANT_DIG+2))) | a = ((tu_int)a >> (sd - (LDBL_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */ /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
if (a & ((tu_int)1 << LDBL_MANT_DIG)) if (a & ((tu_int)1 << LDBL_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} } else {
else
{
a <<= (LDBL_MANT_DIG - sd); a <<= (LDBL_MANT_DIG - sd);
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} }
long_double_bits fb; long_double_bits fb;
fb.u.high.s.low = ((su_int)s & 0x8000) | /* sign */ fb.u.high.s.low = ((su_int)s & 0x8000) | /* sign */
(e + 16383); /* exponent */ (e + 16383); /* exponent */
fb.u.low.all = (du_int)a; /* mantissa */ fb.u.low.all = (du_int)a; /* mantissa */
return fb.f; return fb.f;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/floatundidf.c

Show All 11 Lines
*/ */
/* Returns: convert a to a double, rounding toward even. */ /* Returns: convert a to a double, rounding toward even. */
/* Assumption: double is a IEEE 64 bit floating point type /* Assumption: double is a IEEE 64 bit floating point type
* du_int is a 64 bit integral type * du_int is a 64 bit integral type
*/ */
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm */
#include "int_lib.h" #include "int_lib.h"
#ifndef __SOFT_FP__ #ifndef __SOFT_FP__
/* Support for systems that have hardware floating-point; we'll set the inexact flag /* Support for systems that have hardware floating-point; we'll set the inexact
* as a side-effect of this computation. * flag as a side-effect of this computation.
*/ */
COMPILER_RT_ABI double COMPILER_RT_ABI double __floatundidf(du_int a) {
__floatundidf(du_int a)
{
static const double twop52 = 4503599627370496.0; // 0x1.0p52 static const double twop52 = 4503599627370496.0; // 0x1.0p52
static const double twop84 = 19342813113834066795298816.0; // 0x1.0p84 static const double twop84 = 19342813113834066795298816.0; // 0x1.0p84
static const double twop84_plus_twop52 = 19342813118337666422669312.0; // 0x1.00000001p84 static const double twop84_plus_twop52 =
19342813118337666422669312.0; // 0x1.00000001p84
union { uint64_t x; double d; } high = { .d = twop84 }; union {
union { uint64_t x; double d; } low = { .d = twop52 }; uint64_t x;
double d;
} high = {.d = twop84};
union {
uint64_t x;
double d;
} low = {.d = twop52};
high.x |= a >> 32; high.x |= a >> 32;
low.x |= a & UINT64_C(0x00000000ffffffff); low.x |= a & UINT64_C(0x00000000ffffffff);
const double result = (high.d - twop84_plus_twop52) + low.d; const double result = (high.d - twop84_plus_twop52) + low.d;
return result; return result;
} }
#else #else
/* Support for systems that don't have hardware floating-point; there are no flags to /* Support for systems that don't have hardware floating-point; there are no
* set, and we don't want to code-gen to an unknown soft-float implementation. * flags to set, and we don't want to code-gen to an unknown soft-float
* implementation.
*/ */
COMPILER_RT_ABI double COMPILER_RT_ABI double __floatundidf(du_int a) {
__floatundidf(du_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(du_int) * CHAR_BIT; const unsigned N = sizeof(du_int) * CHAR_BIT;
int sd = N - __builtin_clzll(a); /* number of significant digits */ int sd = N - __builtin_clzll(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > DBL_MANT_DIG) if (sd > DBL_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit DBL_MANT_DIG-1 bits to the right of 1 * P = bit DBL_MANT_DIG-1 bits to the right of 1
* Q = bit DBL_MANT_DIG bits to the right of 1 * Q = bit DBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case DBL_MANT_DIG + 1: case DBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case DBL_MANT_DIG + 2: case DBL_MANT_DIG + 2:
break; break;
default: default:
a = (a >> (sd - (DBL_MANT_DIG+2))) | a = (a >> (sd - (DBL_MANT_DIG + 2))) |
((a & ((du_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0); ((a & ((du_int)(-1) >> ((N + DBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */ /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
if (a & ((du_int)1 << DBL_MANT_DIG)) if (a & ((du_int)1 << DBL_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} } else {
else
{
a <<= (DBL_MANT_DIG - sd); a <<= (DBL_MANT_DIG - sd);
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} }
double_bits fb; double_bits fb;
fb.u.s.high = ((e + 1023) << 20) | /* exponent */ fb.u.s.high = ((e + 1023) << 20) | /* exponent */
((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */ ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
fb.u.s.low = (su_int)a; /* mantissa-low */ fb.u.s.low = (su_int)a; /* mantissa-low */
return fb.f; return fb.f;
} }
#endif #endif
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_ul2d(du_int a) { AEABI_RTABI double __aeabi_ul2d(du_int a) { return __floatundidf(a); }
return __floatundidf(a);
}
#else #else
AEABI_RTABI double __aeabi_ul2d(du_int a) COMPILER_RT_ALIAS(__floatundidf); AEABI_RTABI double __aeabi_ul2d(du_int a) COMPILER_RT_ALIAS(__floatundidf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatundisf.c

/*===-- floatundisf.c - Implement __floatundisf ---------------------------=== /*===-- floatundisf.c - Implement __floatundisf ---------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
* This file implements __floatundisf for the compiler_rt library. * This file implements __floatundisf for the compiler_rt library.
* *
*===----------------------------------------------------------------------=== *===----------------------------------------------------------------------===
*/ */
/* Returns: convert a to a float, rounding toward even. */ /* Returns: convert a to a float, rounding toward even. */
/* Assumption: float is a IEEE 32 bit floating point type /* Assumption: float is a IEEE 32 bit floating point type
* du_int is a 64 bit integral type * du_int is a 64 bit integral type
*/ */
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI float COMPILER_RT_ABI float __floatundisf(du_int a) {
__floatundisf(du_int a)
{
if (a == 0) if (a == 0)
return 0.0F; return 0.0F;
const unsigned N = sizeof(du_int) * CHAR_BIT; const unsigned N = sizeof(du_int) * CHAR_BIT;
int sd = N - __builtin_clzll(a); /* number of significant digits */ int sd = N - __builtin_clzll(a); /* number of significant digits */
int e = sd - 1; /* 8 exponent */ int e = sd - 1; /* 8 exponent */
if (sd > FLT_MANT_DIG) if (sd > FLT_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit FLT_MANT_DIG-1 bits to the right of 1 * P = bit FLT_MANT_DIG-1 bits to the right of 1
* Q = bit FLT_MANT_DIG bits to the right of 1 * Q = bit FLT_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case FLT_MANT_DIG + 1: case FLT_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case FLT_MANT_DIG + 2: case FLT_MANT_DIG + 2:
break; break;
default: default:
a = (a >> (sd - (FLT_MANT_DIG+2))) | a = (a >> (sd - (FLT_MANT_DIG + 2))) |
((a & ((du_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0); ((a & ((du_int)(-1) >> ((N + FLT_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */ /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
if (a & ((du_int)1 << FLT_MANT_DIG)) if (a & ((du_int)1 << FLT_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} } else {
else
{
a <<= (FLT_MANT_DIG - sd); a <<= (FLT_MANT_DIG - sd);
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} }
float_bits fb; float_bits fb;
fb.u = ((e + 127) << 23) | /* exponent */ fb.u = ((e + 127) << 23) | /* exponent */
((su_int)a & 0x007FFFFF); /* mantissa */ ((su_int)a & 0x007FFFFF); /* mantissa */
return fb.f; return fb.f;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_ul2f(du_int a) { AEABI_RTABI float __aeabi_ul2f(du_int a) { return __floatundisf(a); }
return __floatundisf(a);
}
#else #else
AEABI_RTABI float __aeabi_ul2f(du_int a) COMPILER_RT_ALIAS(__floatundisf); AEABI_RTABI float __aeabi_ul2f(du_int a) COMPILER_RT_ALIAS(__floatundisf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatunditf.c

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatunditf(du_int a) { COMPILER_RT_ABI fp_t __floatunditf(du_int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) return fromRep(0); if (a == 0)
return fromRep(0);
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clzll(a); const int exponent = (aWidth - 1) - __builtin_clzll(a);
rep_t result; rep_t result;
// Shift a into the significand field and clear the implicit bit. // Shift a into the significand field and clear the implicit bit.
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)a << shift ^ implicitBit; result = (rep_t)a << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
return fromRep(result); return fromRep(result);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/floatundixf.c

Show All 11 Lines
*/ */
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a to a long double, rounding toward even. */ /* Returns: convert a to a long double, rounding toward even. */
/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits /* Assumption: long double is a IEEE 80 bit floating point type padded to 128
* du_int is a 64 bit integral type * bits du_int is a 64 bit integral type
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI long double COMPILER_RT_ABI long double __floatundixf(du_int a) {
__floatundixf(du_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(du_int) * CHAR_BIT; const unsigned N = sizeof(du_int) * CHAR_BIT;
int clz = __builtin_clzll(a); int clz = __builtin_clzll(a);
int e = (N - 1) - clz ; /* exponent */ int e = (N - 1) - clz; /* exponent */
long_double_bits fb; long_double_bits fb;
fb.u.high.s.low = (e + 16383); /* exponent */ fb.u.high.s.low = (e + 16383); /* exponent */
fb.u.low.all = a << clz; /* mantissa */ fb.u.low.all = a << clz; /* mantissa */
return fb.f; return fb.f;
} }
#endif /* _ARCH_PPC */ #endif /* _ARCH_PPC */

compiler-rt/trunk/lib/builtins/floatunsidf.c

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __floatunsidf(unsigned int a) {
__floatunsidf(unsigned int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) return fromRep(0); if (a == 0)
return fromRep(0);
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clz(a); const int exponent = (aWidth - 1) - __builtin_clz(a);
rep_t result; rep_t result;
// Shift a into the significand field and clear the implicit bit. // Shift a into the significand field and clear the implicit bit.
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)a << shift ^ implicitBit; result = (rep_t)a << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
return fromRep(result); return fromRep(result);
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) { AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) { return __floatunsidf(a); }
return __floatunsidf(a);
}
#else #else
AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) COMPILER_RT_ALIAS(__floatunsidf); AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) COMPILER_RT_ALIAS(__floatunsidf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatunsisf.c

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __floatunsisf(unsigned int a) {
__floatunsisf(unsigned int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) return fromRep(0); if (a == 0)
return fromRep(0);
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clz(a); const int exponent = (aWidth - 1) - __builtin_clz(a);
rep_t result; rep_t result;
// Shift a into the significand field, rounding if it is a right-shift // Shift a into the significand field, rounding if it is a right-shift
if (exponent <= significandBits) { if (exponent <= significandBits) {
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)a << shift ^ implicitBit; result = (rep_t)a << shift ^ implicitBit;
} else { } else {
const int shift = exponent - significandBits; const int shift = exponent - significandBits;
result = (rep_t)a >> shift ^ implicitBit; result = (rep_t)a >> shift ^ implicitBit;
rep_t round = (rep_t)a << (typeWidth - shift); rep_t round = (rep_t)a << (typeWidth - shift);
if (round > signBit) result++; if (round > signBit)
if (round == signBit) result += result & 1; result++;
if (round == signBit)
result += result & 1;
} }
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
return fromRep(result); return fromRep(result);
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) { AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) { return __floatunsisf(a); }
return __floatunsisf(a);
}
#else #else
AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) COMPILER_RT_ALIAS(__floatunsisf); AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) COMPILER_RT_ALIAS(__floatunsisf);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/floatunsitf.c

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatunsitf(unsigned int a) { COMPILER_RT_ABI fp_t __floatunsitf(unsigned int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) return fromRep(0); if (a == 0)
return fromRep(0);
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
const int exponent = (aWidth - 1) - __builtin_clz(a); const int exponent = (aWidth - 1) - __builtin_clz(a);
rep_t result; rep_t result;
// Shift a into the significand field and clear the implicit bit. // Shift a into the significand field and clear the implicit bit.
const int shift = significandBits - exponent; const int shift = significandBits - exponent;
result = (rep_t)a << shift ^ implicitBit; result = (rep_t)a << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
return fromRep(result); return fromRep(result);
} }
#endif #endif

compiler-rt/trunk/lib/builtins/floatuntidf.c

Show All 15 Lines
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a double, rounding toward even. */ /* Returns: convert a to a double, rounding toward even. */
/* Assumption: double is a IEEE 64 bit floating point type /* Assumption: double is a IEEE 64 bit floating point type
* tu_int is a 128 bit integral type * tu_int is a 128 bit integral type
*/ */
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm */
COMPILER_RT_ABI double COMPILER_RT_ABI double __floatuntidf(tu_int a) {
__floatuntidf(tu_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(tu_int) * CHAR_BIT; const unsigned N = sizeof(tu_int) * CHAR_BIT;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > DBL_MANT_DIG) if (sd > DBL_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit DBL_MANT_DIG-1 bits to the right of 1 * P = bit DBL_MANT_DIG-1 bits to the right of 1
* Q = bit DBL_MANT_DIG bits to the right of 1 * Q = bit DBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case DBL_MANT_DIG + 1: case DBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case DBL_MANT_DIG + 2: case DBL_MANT_DIG + 2:
break; break;
default: default:
a = (a >> (sd - (DBL_MANT_DIG+2))) | a = (a >> (sd - (DBL_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + DBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */ /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
if (a & ((tu_int)1 << DBL_MANT_DIG)) if (a & ((tu_int)1 << DBL_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} } else {
else
{
a <<= (DBL_MANT_DIG - sd); a <<= (DBL_MANT_DIG - sd);
/* a is now rounded to DBL_MANT_DIG bits */ /* a is now rounded to DBL_MANT_DIG bits */
} }
double_bits fb; double_bits fb;
fb.u.s.high = ((e + 1023) << 20) | /* exponent */ fb.u.s.high = ((e + 1023) << 20) | /* exponent */
((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */ ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
fb.u.s.low = (su_int)a; /* mantissa-low */ fb.u.s.low = (su_int)a; /* mantissa-low */
return fb.f; return fb.f;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/floatuntisf.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a float, rounding toward even. */ /* Returns: convert a to a float, rounding toward even. */
/* Assumption: float is a IEEE 32 bit floating point type /* Assumption: float is a IEEE 32 bit floating point type
* tu_int is a 128 bit integral type * tu_int is a 128 bit integral type
*/ */
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */ /* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
COMPILER_RT_ABI float COMPILER_RT_ABI float __floatuntisf(tu_int a) {
__floatuntisf(tu_int a)
{
if (a == 0) if (a == 0)
return 0.0F; return 0.0F;
const unsigned N = sizeof(tu_int) * CHAR_BIT; const unsigned N = sizeof(tu_int) * CHAR_BIT;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > FLT_MANT_DIG) if (sd > FLT_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit FLT_MANT_DIG-1 bits to the right of 1 * P = bit FLT_MANT_DIG-1 bits to the right of 1
* Q = bit FLT_MANT_DIG bits to the right of 1 * Q = bit FLT_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case FLT_MANT_DIG + 1: case FLT_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case FLT_MANT_DIG + 2: case FLT_MANT_DIG + 2:
break; break;
default: default:
a = (a >> (sd - (FLT_MANT_DIG+2))) | a = (a >> (sd - (FLT_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + FLT_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */ /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
if (a & ((tu_int)1 << FLT_MANT_DIG)) if (a & ((tu_int)1 << FLT_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} } else {
else
{
a <<= (FLT_MANT_DIG - sd); a <<= (FLT_MANT_DIG - sd);
/* a is now rounded to FLT_MANT_DIG bits */ /* a is now rounded to FLT_MANT_DIG bits */
} }
float_bits fb; float_bits fb;
fb.u = ((e + 127) << 23) | /* exponent */ fb.u = ((e + 127) << 23) | /* exponent */
((su_int)a & 0x007FFFFF); /* mantissa */ ((su_int)a & 0x007FFFFF); /* mantissa */
return fb.f; return fb.f;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/floatuntitf.c

Show All 16 Lines
#include "int_lib.h" #include "int_lib.h"
/* Returns: convert a tu_int to a fp_t, rounding toward even. */ /* Returns: convert a tu_int to a fp_t, rounding toward even. */
/* Assumption: fp_t is a IEEE 128 bit floating point type /* Assumption: fp_t is a IEEE 128 bit floating point type
* tu_int is a 128 bit integral type * tu_int is a 128 bit integral type
*/ */
/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | /* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __floatuntitf(tu_int a) {
__floatuntitf(tu_int a) {
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(tu_int) * CHAR_BIT; const unsigned N = sizeof(tu_int) * CHAR_BIT;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > LDBL_MANT_DIG) { if (sd > LDBL_MANT_DIG) {
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit LDBL_MANT_DIG-1 bits to the right of 1 * P = bit LDBL_MANT_DIG-1 bits to the right of 1
* Q = bit LDBL_MANT_DIG bits to the right of 1 * Q = bit LDBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) { switch (sd) {
case LDBL_MANT_DIG + 1: case LDBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case LDBL_MANT_DIG + 2: case LDBL_MANT_DIG + 2:
break; break;
default: default:
a = (a >> (sd - (LDBL_MANT_DIG+2))) | a = (a >> (sd - (LDBL_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */ /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
if (a & ((tu_int)1 << LDBL_MANT_DIG)) { if (a & ((tu_int)1 << LDBL_MANT_DIG)) {
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} else { } else {
a <<= (LDBL_MANT_DIG - sd); a <<= (LDBL_MANT_DIG - sd);
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} }
long_double_bits fb; long_double_bits fb;
fb.u.high.all = (du_int)(e + 16383) << 48 /* exponent */ fb.u.high.all = (du_int)(e + 16383) << 48 /* exponent */
| ((a >> 64) & 0x0000ffffffffffffLL); /* significand */ | ((a >> 64) & 0x0000ffffffffffffLL); /* significand */
fb.u.low.all = (du_int)(a); fb.u.low.all = (du_int)(a);
return fb.f; return fb.f;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/floatuntixf.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: convert a to a long double, rounding toward even. */ /* Returns: convert a to a long double, rounding toward even. */
/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits /* Assumption: long double is a IEEE 80 bit floating point type padded to 128
* tu_int is a 128 bit integral type * bits tu_int is a 128 bit integral type
*/ */
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
* 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
* mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI long double COMPILER_RT_ABI long double __floatuntixf(tu_int a) {
__floatuntixf(tu_int a)
{
if (a == 0) if (a == 0)
return 0.0; return 0.0;
const unsigned N = sizeof(tu_int) * CHAR_BIT; const unsigned N = sizeof(tu_int) * CHAR_BIT;
int sd = N - __clzti2(a); /* number of significant digits */ int sd = N - __clzti2(a); /* number of significant digits */
int e = sd - 1; /* exponent */ int e = sd - 1; /* exponent */
if (sd > LDBL_MANT_DIG) if (sd > LDBL_MANT_DIG) {
{
/* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx /* start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
* finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
* 12345678901234567890123456 * 12345678901234567890123456
* 1 = msb 1 bit * 1 = msb 1 bit
* P = bit LDBL_MANT_DIG-1 bits to the right of 1 * P = bit LDBL_MANT_DIG-1 bits to the right of 1
* Q = bit LDBL_MANT_DIG bits to the right of 1 * Q = bit LDBL_MANT_DIG bits to the right of 1
* R = "or" of all bits to the right of Q * R = "or" of all bits to the right of Q
*/ */
switch (sd) switch (sd) {
{
case LDBL_MANT_DIG + 1: case LDBL_MANT_DIG + 1:
a <<= 1; a <<= 1;
break; break;
case LDBL_MANT_DIG + 2: case LDBL_MANT_DIG + 2:
break; break;
default: default:
a = (a >> (sd - (LDBL_MANT_DIG+2))) | a = (a >> (sd - (LDBL_MANT_DIG + 2))) |
((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0); ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG + 2) - sd))) != 0);
}; };
/* finish: */ /* finish: */
a |= (a & 4) != 0; /* Or P into R */ a |= (a & 4) != 0; /* Or P into R */
++a; /* round - this step may add a significant bit */ ++a; /* round - this step may add a significant bit */
a >>= 2; /* dump Q and R */ a >>= 2; /* dump Q and R */
/* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */ /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
if (a & ((tu_int)1 << LDBL_MANT_DIG)) if (a & ((tu_int)1 << LDBL_MANT_DIG)) {
{
a >>= 1; a >>= 1;
++e; ++e;
} }
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} } else {
else
{
a <<= (LDBL_MANT_DIG - sd); a <<= (LDBL_MANT_DIG - sd);
/* a is now rounded to LDBL_MANT_DIG bits */ /* a is now rounded to LDBL_MANT_DIG bits */
} }
long_double_bits fb; long_double_bits fb;
fb.u.high.s.low = (e + 16383); /* exponent */ fb.u.high.s.low = (e + 16383); /* exponent */
fb.u.low.all = (du_int)a; /* mantissa */ fb.u.low.all = (du_int)a; /* mantissa */
return fb.f; return fb.f;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/fp_add_impl.inc

//===----- lib/fp_add_impl.inc - floaing point addition -----------*- C -*-===// //===----- lib/fp_add_impl.inc - floaing point addition -----------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements soft-float addition with the IEEE-754 default rounding // This file implements soft-float addition with the IEEE-754 default rounding
// (to nearest, ties to even). // (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "fp_lib.h" #include "fp_lib.h"
static __inline fp_t __addXf3__(fp_t a, fp_t b) { static __inline fp_t __addXf3__(fp_t a, fp_t b) {
rep_t aRep = toRep(a); rep_t aRep = toRep(a);
rep_t bRep = toRep(b); rep_t bRep = toRep(b);
const rep_t aAbs = aRep & absMask; const rep_t aAbs = aRep & absMask;
const rep_t bAbs = bRep & absMask; const rep_t bAbs = bRep & absMask;
// Detect if a or b is zero, infinity, or NaN. // Detect if a or b is zero, infinity, or NaN.
if (aAbs - REP_C(1) >= infRep - REP_C(1) || if (aAbs - REP_C(1) >= infRep - REP_C(1) ||
bAbs - REP_C(1) >= infRep - REP_C(1)) { bAbs - REP_C(1) >= infRep - REP_C(1)) {
// NaN + anything = qNaN // NaN + anything = qNaN
if (aAbs > infRep) return fromRep(toRep(a) | quietBit); if (aAbs > infRep)
return fromRep(toRep(a) | quietBit);
// anything + NaN = qNaN // anything + NaN = qNaN
if (bAbs > infRep) return fromRep(toRep(b) | quietBit); if (bAbs > infRep)
return fromRep(toRep(b) | quietBit);
if (aAbs == infRep) { if (aAbs == infRep) {
// +/-infinity + -/+infinity = qNaN // +/-infinity + -/+infinity = qNaN
if ((toRep(a) ^ toRep(b)) == signBit) return fromRep(qnanRep); if ((toRep(a) ^ toRep(b)) == signBit)
return fromRep(qnanRep);
// +/-infinity + anything remaining = +/- infinity // +/-infinity + anything remaining = +/- infinity
else return a; else
return a;
} }
// anything remaining + +/-infinity = +/-infinity // anything remaining + +/-infinity = +/-infinity
if (bAbs == infRep) return b; if (bAbs == infRep)
return b;
// zero + anything = anything // zero + anything = anything
if (!aAbs) { if (!aAbs) {
// but we need to get the sign right for zero + zero // but we need to get the sign right for zero + zero
if (!bAbs) return fromRep(toRep(a) & toRep(b)); if (!bAbs)
else return b; return fromRep(toRep(a) & toRep(b));
else
return b;
} }
// anything + zero = anything // anything + zero = anything
if (!bAbs) return a; if (!bAbs)
return a;
} }
// Swap a and b if necessary so that a has the larger absolute value. // Swap a and b if necessary so that a has the larger absolute value.
if (bAbs > aAbs) { if (bAbs > aAbs) {
const rep_t temp = aRep; const rep_t temp = aRep;
aRep = bRep; aRep = bRep;
bRep = temp; bRep = temp;
} }
// Extract the exponent and significand from the (possibly swapped) a and b. // Extract the exponent and significand from the (possibly swapped) a and b.
int aExponent = aRep >> significandBits & maxExponent; int aExponent = aRep >> significandBits & maxExponent;
int bExponent = bRep >> significandBits & maxExponent; int bExponent = bRep >> significandBits & maxExponent;
rep_t aSignificand = aRep & significandMask; rep_t aSignificand = aRep & significandMask;
rep_t bSignificand = bRep & significandMask; rep_t bSignificand = bRep & significandMask;
// Normalize any denormals, and adjust the exponent accordingly. // Normalize any denormals, and adjust the exponent accordingly.
if (aExponent == 0) aExponent = normalize(&aSignificand); if (aExponent == 0)
if (bExponent == 0) bExponent = normalize(&bSignificand); aExponent = normalize(&aSignificand);
if (bExponent == 0)
bExponent = normalize(&bSignificand);
// The sign of the result is the sign of the larger operand, a. If they // The sign of the result is the sign of the larger operand, a. If they
// have opposite signs, we are performing a subtraction; otherwise addition. // have opposite signs, we are performing a subtraction; otherwise addition.
const rep_t resultSign = aRep & signBit; const rep_t resultSign = aRep & signBit;
const bool subtraction = (aRep ^ bRep) & signBit; const bool subtraction = (aRep ^ bRep) & signBit;
// Shift the significands to give us round, guard and sticky, and or in the // Shift the significands to give us round, guard and sticky, and or in the
// implicit significand bit. (If we fell through from the denormal path it // implicit significand bit. (If we fell through from the denormal path it
// was already set by normalize( ), but setting it twice won't hurt // was already set by normalize( ), but setting it twice won't hurt
// anything.) // anything.)
aSignificand = (aSignificand | implicitBit) << 3; aSignificand = (aSignificand | implicitBit) << 3;
bSignificand = (bSignificand | implicitBit) << 3; bSignificand = (bSignificand | implicitBit) << 3;
// Shift the significand of b by the difference in exponents, with a sticky // Shift the significand of b by the difference in exponents, with a sticky
// bottom bit to get rounding correct. // bottom bit to get rounding correct.
const unsigned int align = aExponent - bExponent; const unsigned int align = aExponent - bExponent;
if (align) { if (align) {
if (align < typeWidth) { if (align < typeWidth) {
const bool sticky = bSignificand << (typeWidth - align); const bool sticky = bSignificand << (typeWidth - align);
bSignificand = bSignificand >> align | sticky; bSignificand = bSignificand >> align | sticky;
} else { } else {
bSignificand = 1; // sticky; b is known to be non-zero. bSignificand = 1; // sticky; b is known to be non-zero.
} }
} }
if (subtraction) { if (subtraction) {
aSignificand -= bSignificand; aSignificand -= bSignificand;
// If a == -b, return +zero. // If a == -b, return +zero.
if (aSignificand == 0) return fromRep(0); if (aSignificand == 0)
return fromRep(0);
// If partial cancellation occured, we need to left-shift the result // If partial cancellation occured, we need to left-shift the result
// and adjust the exponent: // and adjust the exponent:
if (aSignificand < implicitBit << 3) { if (aSignificand < implicitBit << 3) {
const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3); const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3);
aSignificand <<= shift; aSignificand <<= shift;
aExponent -= shift; aExponent -= shift;
} }
} } else /* addition */ {
else /* addition */ {
aSignificand += bSignificand; aSignificand += bSignificand;
// If the addition carried up, we need to right-shift the result and // If the addition carried up, we need to right-shift the result and
// adjust the exponent: // adjust the exponent:
if (aSignificand & implicitBit << 4) { if (aSignificand & implicitBit << 4) {
const bool sticky = aSignificand & 1; const bool sticky = aSignificand & 1;
aSignificand = aSignificand >> 1 | sticky; aSignificand = aSignificand >> 1 | sticky;
aExponent += 1; aExponent += 1;
} }
} }
// If we have overflowed the type, return +/- infinity: // If we have overflowed the type, return +/- infinity:
if (aExponent >= maxExponent) return fromRep(infRep | resultSign); if (aExponent >= maxExponent)
return fromRep(infRep | resultSign);
if (aExponent <= 0) { if (aExponent <= 0) {
// Result is denormal before rounding; the exponent is zero and we // Result is denormal before rounding; the exponent is zero and we
// need to shift the significand. // need to shift the significand.
const int shift = 1 - aExponent; const int shift = 1 - aExponent;
const bool sticky = aSignificand << (typeWidth - shift); const bool sticky = aSignificand << (typeWidth - shift);
aSignificand = aSignificand >> shift | sticky; aSignificand = aSignificand >> shift | sticky;
aExponent = 0; aExponent = 0;
} }
// Low three bits are round, guard, and sticky. // Low three bits are round, guard, and sticky.
const int roundGuardSticky = aSignificand & 0x7; const int roundGuardSticky = aSignificand & 0x7;
// Shift the significand into place, and mask off the implicit bit. // Shift the significand into place, and mask off the implicit bit.
rep_t result = aSignificand >> 3 & significandMask; rep_t result = aSignificand >> 3 & significandMask;
// Insert the exponent and sign. // Insert the exponent and sign.
result |= (rep_t)aExponent << significandBits; result |= (rep_t)aExponent << significandBits;
result |= resultSign; result |= resultSign;
// Final rounding. The result may overflow to infinity, but that is the // Final rounding. The result may overflow to infinity, but that is the
// correct result in that case. // correct result in that case.
if (roundGuardSticky > 0x4) result++; if (roundGuardSticky > 0x4)
if (roundGuardSticky == 0x4) result += result & 1; result++;
if (roundGuardSticky == 0x4)
result += result & 1;
return fromRep(result); return fromRep(result);
} }

compiler-rt/trunk/lib/builtins/fp_extend.h

//===-lib/fp_extend.h - low precision -> high precision conversion -*- C -*-===// //===-lib/fp_extend.h - low precision -> high precision conversion -*- C
//-*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Set source and destination setting // Set source and destination setting
Show All 14 Lines
#elif defined SRC_DOUBLE #elif defined SRC_DOUBLE
typedef double src_t; typedef double src_t;
typedef uint64_t src_rep_t; typedef uint64_t src_rep_t;
#define SRC_REP_C UINT64_C #define SRC_REP_C UINT64_C
static const int srcSigBits = 52; static const int srcSigBits = 52;
static __inline int src_rep_t_clz(src_rep_t a) { static __inline int src_rep_t_clz(src_rep_t a) {
#if defined __LP64__ #if defined __LP64__
return __builtin_clzl(a); return __builtin_clzl(a);
#else #else
if (a & REP_C(0xffffffff00000000)) if (a & REP_C(0xffffffff00000000))
return __builtin_clz(a >> 32); return __builtin_clz(a >> 32);
else else
return 32 + __builtin_clz(a & REP_C(0xffffffff)); return 32 + __builtin_clz(a & REP_C(0xffffffff));
#endif #endif
} }
#elif defined SRC_HALF #elif defined SRC_HALF
typedef uint16_t src_t; typedef uint16_t src_t;
typedef uint16_t src_rep_t; typedef uint16_t src_rep_t;
#define SRC_REP_C UINT16_C #define SRC_REP_C UINT16_C
static const int srcSigBits = 10; static const int srcSigBits = 10;
#define src_rep_t_clz __builtin_clz #define src_rep_t_clz __builtin_clz
#else #else
#error Source should be half, single, or double precision! #error Source should be half, single, or double precision!
#endif //end source precision #endif // end source precision
#if defined DST_SINGLE #if defined DST_SINGLE
typedef float dst_t; typedef float dst_t;
typedef uint32_t dst_rep_t; typedef uint32_t dst_rep_t;
#define DST_REP_C UINT32_C #define DST_REP_C UINT32_C
static const int dstSigBits = 23; static const int dstSigBits = 23;
#elif defined DST_DOUBLE #elif defined DST_DOUBLE
typedef double dst_t; typedef double dst_t;
typedef uint64_t dst_rep_t; typedef uint64_t dst_rep_t;
#define DST_REP_C UINT64_C #define DST_REP_C UINT64_C
static const int dstSigBits = 52; static const int dstSigBits = 52;
#elif defined DST_QUAD #elif defined DST_QUAD
typedef long double dst_t; typedef long double dst_t;
typedef __uint128_t dst_rep_t; typedef __uint128_t dst_rep_t;
#define DST_REP_C (__uint128_t) #define DST_REP_C (__uint128_t)
static const int dstSigBits = 112; static const int dstSigBits = 112;
#else #else
#error Destination should be single, double, or quad precision! #error Destination should be single, double, or quad precision!
#endif //end destination precision #endif // end destination precision
// End of specialization parameters. Two helper routines for conversion to and // End of specialization parameters. Two helper routines for conversion to and
// from the representation of floating-point data as integer values follow. // from the representation of floating-point data as integer values follow.
static __inline src_rep_t srcToRep(src_t x) { static __inline src_rep_t srcToRep(src_t x) {
const union { src_t f; src_rep_t i; } rep = {.f = x}; const union {
src_t f;
src_rep_t i;
} rep = {.f = x};
return rep.i; return rep.i;
} }
static __inline dst_t dstFromRep(dst_rep_t x) { static __inline dst_t dstFromRep(dst_rep_t x) {
const union { dst_t f; dst_rep_t i; } rep = {.i = x}; const union {
dst_t f;
dst_rep_t i;
} rep = {.i = x};
return rep.f; return rep.f;
} }
// End helper routines. Conversion implementation follows. // End helper routines. Conversion implementation follows.
#endif //FP_EXTEND_HEADER #endif // FP_EXTEND_HEADER

compiler-rt/trunk/lib/builtins/fp_extend_impl.inc

Show All 32 Lines
// 2. quiet NaNs, if supported, are indicated by the leading bit of the // 2. quiet NaNs, if supported, are indicated by the leading bit of the
// significand field being set // significand field being set
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "fp_extend.h" #include "fp_extend.h"
static __inline dst_t __extendXfYf2__(src_t a) { static __inline dst_t __extendXfYf2__(src_t a) {
// Various constants whose values follow from the type parameters. // Various constants whose values follow from the type parameters.
// Any reasonable optimizer will fold and propagate all of these. // Any reasonable optimizer will fold and propagate all of these.
const int srcBits = sizeof(src_t)*CHAR_BIT; const int srcBits = sizeof(src_t) * CHAR_BIT;
const int srcExpBits = srcBits - srcSigBits - 1; const int srcExpBits = srcBits - srcSigBits - 1;
const int srcInfExp = (1 << srcExpBits) - 1; const int srcInfExp = (1 << srcExpBits) - 1;
const int srcExpBias = srcInfExp >> 1; const int srcExpBias = srcInfExp >> 1;
const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits; const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits;
const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits; const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits;
const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits); const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits);
const src_rep_t srcAbsMask = srcSignMask - 1; const src_rep_t srcAbsMask = srcSignMask - 1;
const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1); const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1);
const src_rep_t srcNaNCode = srcQNaN - 1; const src_rep_t srcNaNCode = srcQNaN - 1;
const int dstBits = sizeof(dst_t)*CHAR_BIT; const int dstBits = sizeof(dst_t) * CHAR_BIT;
const int dstExpBits = dstBits - dstSigBits - 1; const int dstExpBits = dstBits - dstSigBits - 1;
const int dstInfExp = (1 << dstExpBits) - 1; const int dstInfExp = (1 << dstExpBits) - 1;
const int dstExpBias = dstInfExp >> 1; const int dstExpBias = dstInfExp >> 1;
const dst_rep_t dstMinNormal = DST_REP_C(1) << dstSigBits; const dst_rep_t dstMinNormal = DST_REP_C(1) << dstSigBits;
// Break a into a sign and representation of the absolute value // Break a into a sign and representation of the absolute value
const src_rep_t aRep = srcToRep(a); const src_rep_t aRep = srcToRep(a);
const src_rep_t aAbs = aRep & srcAbsMask; const src_rep_t aAbs = aRep & srcAbsMask;
const src_rep_t sign = aRep & srcSignMask; const src_rep_t sign = aRep & srcSignMask;
dst_rep_t absResult; dst_rep_t absResult;
// If sizeof(src_rep_t) < sizeof(int), the subtraction result is promoted // If sizeof(src_rep_t) < sizeof(int), the subtraction result is promoted
// to (signed) int. To avoid that, explicitly cast to src_rep_t. // to (signed) int. To avoid that, explicitly cast to src_rep_t.
if ((src_rep_t)(aAbs - srcMinNormal) < srcInfinity - srcMinNormal) { if ((src_rep_t)(aAbs - srcMinNormal) < srcInfinity - srcMinNormal) {
// a is a normal number. // a is a normal number.
// Extend to the destination type by shifting the significand and // Extend to the destination type by shifting the significand and
// exponent into the proper position and rebiasing the exponent. // exponent into the proper position and rebiasing the exponent.
absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits); absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits);
absResult += (dst_rep_t)(dstExpBias - srcExpBias) << dstSigBits; absResult += (dst_rep_t)(dstExpBias - srcExpBias) << dstSigBits;
} }
else if (aAbs >= srcInfinity) { else if (aAbs >= srcInfinity) {
// a is NaN or infinity. // a is NaN or infinity.
// Conjure the result by beginning with infinity, then setting the qNaN // Conjure the result by beginning with infinity, then setting the qNaN
// bit (if needed) and right-aligning the rest of the trailing NaN // bit (if needed) and right-aligning the rest of the trailing NaN
// payload field. // payload field.
absResult = (dst_rep_t)dstInfExp << dstSigBits; absResult = (dst_rep_t)dstInfExp << dstSigBits;
absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigBits - srcSigBits); absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigBits - srcSigBits);
absResult |= (dst_rep_t)(aAbs & srcNaNCode) << (dstSigBits - srcSigBits); absResult |= (dst_rep_t)(aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
} }
else if (aAbs) { else if (aAbs) {
// a is denormal. // a is denormal.
// renormalize the significand and clear the leading bit, then insert // renormalize the significand and clear the leading bit, then insert
// the correct adjusted exponent in the destination type. // the correct adjusted exponent in the destination type.
const int scale = src_rep_t_clz(aAbs) - src_rep_t_clz(srcMinNormal); const int scale = src_rep_t_clz(aAbs) - src_rep_t_clz(srcMinNormal);
absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits + scale); absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits + scale);
absResult ^= dstMinNormal; absResult ^= dstMinNormal;
const int resultExponent = dstExpBias - srcExpBias - scale + 1; const int resultExponent = dstExpBias - srcExpBias - scale + 1;
absResult |= (dst_rep_t)resultExponent << dstSigBits; absResult |= (dst_rep_t)resultExponent << dstSigBits;
} }
else { else {
// a is zero. // a is zero.
absResult = 0; absResult = 0;
} }
// Apply the signbit to (dst_t)abs(a). // Apply the signbit to (dst_t)abs(a).
const dst_rep_t result = absResult | (dst_rep_t)sign << (dstBits - srcBits); const dst_rep_t result = absResult | (dst_rep_t)sign << (dstBits - srcBits);
return dstFromRep(result); return dstFromRep(result);
} }

compiler-rt/trunk/lib/builtins/fp_fixint_impl.inc

//===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===// //===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements float to integer conversion for the // This file implements float to integer conversion for the
// compiler-rt library. // compiler-rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "fp_lib.h" #include "fp_lib.h"
static __inline fixint_t __fixint(fp_t a) { static __inline fixint_t __fixint(fp_t a) {
const fixint_t fixint_max = (fixint_t)((~(fixuint_t)0) / 2); const fixint_t fixint_max = (fixint_t)((~(fixuint_t)0) / 2);
const fixint_t fixint_min = -fixint_max - 1; const fixint_t fixint_min = -fixint_max - 1;
// Break a into sign, exponent, significand // Break a into sign, exponent, significand
const rep_t aRep = toRep(a); const rep_t aRep = toRep(a);
const rep_t aAbs = aRep & absMask; const rep_t aAbs = aRep & absMask;
const fixint_t sign = aRep & signBit ? -1 : 1; const fixint_t sign = aRep & signBit ? -1 : 1;
const int exponent = (aAbs >> significandBits) - exponentBias; const int exponent = (aAbs >> significandBits) - exponentBias;
const rep_t significand = (aAbs & significandMask) | implicitBit; const rep_t significand = (aAbs & significandMask) | implicitBit;
// If exponent is negative, the result is zero. // If exponent is negative, the result is zero.
if (exponent < 0) if (exponent < 0)
return 0; return 0;
// If the value is too large for the integer type, saturate. // If the value is too large for the integer type, saturate.
if ((unsigned)exponent >= sizeof(fixint_t) * CHAR_BIT) if ((unsigned)exponent >= sizeof(fixint_t) * CHAR_BIT)
return sign == 1 ? fixint_max : fixint_min; return sign == 1 ? fixint_max : fixint_min;
// If 0 <= exponent < significandBits, right shift to get the result. // If 0 <= exponent < significandBits, right shift to get the result.
// Otherwise, shift left. // Otherwise, shift left.
if (exponent < significandBits) if (exponent < significandBits)
return sign * (significand >> (significandBits - exponent)); return sign * (significand >> (significandBits - exponent));
else else
return sign * ((fixint_t)significand << (exponent - significandBits)); return sign * ((fixint_t)significand << (exponent - significandBits));
} }

compiler-rt/trunk/lib/builtins/fp_fixuint_impl.inc

//===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===// //===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements float to unsigned integer conversion for the // This file implements float to unsigned integer conversion for the
// compiler-rt library. // compiler-rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "fp_lib.h" #include "fp_lib.h"
static __inline fixuint_t __fixuint(fp_t a) { static __inline fixuint_t __fixuint(fp_t a) {
// Break a into sign, exponent, significand // Break a into sign, exponent, significand
const rep_t aRep = toRep(a); const rep_t aRep = toRep(a);
const rep_t aAbs = aRep & absMask; const rep_t aAbs = aRep & absMask;
const int sign = aRep & signBit ? -1 : 1; const int sign = aRep & signBit ? -1 : 1;
const int exponent = (aAbs >> significandBits) - exponentBias; const int exponent = (aAbs >> significandBits) - exponentBias;
const rep_t significand = (aAbs & significandMask) | implicitBit; const rep_t significand = (aAbs & significandMask) | implicitBit;
// If either the value or the exponent is negative, the result is zero. // If either the value or the exponent is negative, the result is zero.
if (sign == -1 || exponent < 0) if (sign == -1 || exponent < 0)
return 0; return 0;
// If the value is too large for the integer type, saturate. // If the value is too large for the integer type, saturate.
if ((unsigned)exponent >= sizeof(fixuint_t) * CHAR_BIT) if ((unsigned)exponent >= sizeof(fixuint_t) * CHAR_BIT)
return ~(fixuint_t)0; return ~(fixuint_t)0;
// If 0 <= exponent < significandBits, right shift to get the result. // If 0 <= exponent < significandBits, right shift to get the result.
// Otherwise, shift left. // Otherwise, shift left.
if (exponent < significandBits) if (exponent < significandBits)
return significand >> (significandBits - exponent); return significand >> (significandBits - exponent);
else else
return (fixuint_t)significand << (exponent - significandBits); return (fixuint_t)significand << (exponent - significandBits);
} }

compiler-rt/trunk/lib/builtins/fp_lib.h

Show All 14 Lines
// binary32, binary64 and binary 128 types, respectively, and that integer // binary32, binary64 and binary 128 types, respectively, and that integer
// endianness matches floating point endianness on the target platform. // endianness matches floating point endianness on the target platform.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef FP_LIB_HEADER #ifndef FP_LIB_HEADER
#define FP_LIB_HEADER #define FP_LIB_HEADER
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
// x86_64 FreeBSD prior v9.3 define fixed-width types incorrectly in // x86_64 FreeBSD prior v9.3 define fixed-width types incorrectly in
// 32-bit mode. // 32-bit mode.
#if defined(__FreeBSD__) && defined(__i386__) #if defined(__FreeBSD__) && defined(__i386__)
# include <sys/param.h> #include <sys/param.h>
# if __FreeBSD_version < 903000 // v9.3 #if __FreeBSD_version < 903000 // v9.3
# define uint64_t unsigned long long #define uint64_t unsigned long long
# define int64_t long long #define int64_t long long
# undef UINT64_C #undef UINT64_C
# define UINT64_C(c) (c ## ULL) #define UINT64_C(c) (c##ULL)
# endif #endif
#endif #endif
#if defined SINGLE_PRECISION #if defined SINGLE_PRECISION
typedef uint32_t rep_t; typedef uint32_t rep_t;
typedef int32_t srep_t; typedef int32_t srep_t;
typedef float fp_t; typedef float fp_t;
#define REP_C UINT32_C #define REP_C UINT32_C
#define significandBits 23 #define significandBits 23
static __inline int rep_clz(rep_t a) { static __inline int rep_clz(rep_t a) { return __builtin_clz(a); }
return __builtin_clz(a);
}
// 32x32 --> 64 bit multiply // 32x32 --> 64 bit multiply
static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
const uint64_t product = (uint64_t)a*b; const uint64_t product = (uint64_t)a * b;
*hi = product >> 32; *hi = product >> 32;
*lo = product; *lo = product;
} }
COMPILER_RT_ABI fp_t __addsf3(fp_t a, fp_t b); COMPILER_RT_ABI fp_t __addsf3(fp_t a, fp_t b);
#elif defined DOUBLE_PRECISION #elif defined DOUBLE_PRECISION
typedef uint64_t rep_t; typedef uint64_t rep_t;
typedef int64_t srep_t; typedef int64_t srep_t;
typedef double fp_t; typedef double fp_t;
#define REP_C UINT64_C #define REP_C UINT64_C
#define significandBits 52 #define significandBits 52
static __inline int rep_clz(rep_t a) { static __inline int rep_clz(rep_t a) {
#if defined __LP64__ #if defined __LP64__
return __builtin_clzl(a); return __builtin_clzl(a);
#else #else
if (a & REP_C(0xffffffff00000000)) if (a & REP_C(0xffffffff00000000))
return __builtin_clz(a >> 32); return __builtin_clz(a >> 32);
else else
return 32 + __builtin_clz(a & REP_C(0xffffffff)); return 32 + __builtin_clz(a & REP_C(0xffffffff));
#endif #endif
} }
#define loWord(a) (a & 0xffffffffU) #define loWord(a) (a & 0xffffffffU)
#define hiWord(a) (a >> 32) #define hiWord(a) (a >> 32)
// 64x64 -> 128 wide multiply for platforms that don't have such an operation; // 64x64 -> 128 wide multiply for platforms that don't have such an operation;
// many 64-bit platforms have this operation, but they tend to have hardware // many 64-bit platforms have this operation, but they tend to have hardware
// floating-point, so we don't bother with a special case for them here. // floating-point, so we don't bother with a special case for them here.
static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
// Each of the component 32x32 -> 64 products // Each of the component 32x32 -> 64 products
const uint64_t plolo = loWord(a) * loWord(b); const uint64_t plolo = loWord(a) * loWord(b);
const uint64_t plohi = loWord(a) * hiWord(b); const uint64_t plohi = loWord(a) * hiWord(b);
const uint64_t philo = hiWord(a) * loWord(b); const uint64_t philo = hiWord(a) * loWord(b);
const uint64_t phihi = hiWord(a) * hiWord(b); const uint64_t phihi = hiWord(a) * hiWord(b);
// Sum terms that contribute to lo in a way that allows us to get the carry // Sum terms that contribute to lo in a way that allows us to get the carry
const uint64_t r0 = loWord(plolo); const uint64_t r0 = loWord(plolo);
const uint64_t r1 = hiWord(plolo) + loWord(plohi) + loWord(philo); const uint64_t r1 = hiWord(plolo) + loWord(plohi) + loWord(philo);
*lo = r0 + (r1 << 32); *lo = r0 + (r1 << 32);
// Sum terms contributing to hi with the carry from lo // Sum terms contributing to hi with the carry from lo
*hi = hiWord(plohi) + hiWord(philo) + hiWord(r1) + phihi; *hi = hiWord(plohi) + hiWord(philo) + hiWord(r1) + phihi;
} }
#undef loWord #undef loWord
#undef hiWord #undef hiWord
COMPILER_RT_ABI fp_t __adddf3(fp_t a, fp_t b); COMPILER_RT_ABI fp_t __adddf3(fp_t a, fp_t b);
#elif defined QUAD_PRECISION #elif defined QUAD_PRECISION
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#define CRT_LDBL_128BIT #define CRT_LDBL_128BIT
typedef __uint128_t rep_t; typedef __uint128_t rep_t;
typedef __int128_t srep_t; typedef __int128_t srep_t;
typedef long double fp_t; typedef long double fp_t;
#define REP_C (__uint128_t) #define REP_C (__uint128_t)
// Note: Since there is no explicit way to tell compiler the constant is a // Note: Since there is no explicit way to tell compiler the constant is a
// 128-bit integer, we let the constant be casted to 128-bit integer // 128-bit integer, we let the constant be casted to 128-bit integer
#define significandBits 112 #define significandBits 112
static __inline int rep_clz(rep_t a) { static __inline int rep_clz(rep_t a) {
const union const union {
{
__uint128_t ll; __uint128_t ll;
#if _YUGA_BIG_ENDIAN #if _YUGA_BIG_ENDIAN
struct { uint64_t high, low; } s; struct {
uint64_t high, low;
} s;
#else #else
struct { uint64_t low, high; } s; struct {
uint64_t low, high;
} s;
#endif #endif
} uu = { .ll = a }; } uu = {.ll = a};
uint64_t word; uint64_t word;
uint64_t add; uint64_t add;
if (uu.s.high){ if (uu.s.high) {
word = uu.s.high; word = uu.s.high;
add = 0; add = 0;
} } else {
else{
word = uu.s.low; word = uu.s.low;
add = 64; add = 64;
} }
return __builtin_clzll(word) + add; return __builtin_clzll(word) + add;
} }
#define Word_LoMask UINT64_C(0x00000000ffffffff) #define Word_LoMask UINT64_C(0x00000000ffffffff)
#define Word_HiMask UINT64_C(0xffffffff00000000) #define Word_HiMask UINT64_C(0xffffffff00000000)
#define Word_FullMask UINT64_C(0xffffffffffffffff) #define Word_FullMask UINT64_C(0xffffffffffffffff)
#define Word_1(a) (uint64_t)((a >> 96) & Word_LoMask) #define Word_1(a) (uint64_t)((a >> 96) & Word_LoMask)
#define Word_2(a) (uint64_t)((a >> 64) & Word_LoMask) #define Word_2(a) (uint64_t)((a >> 64) & Word_LoMask)
#define Word_3(a) (uint64_t)((a >> 32) & Word_LoMask) #define Word_3(a) (uint64_t)((a >> 32) & Word_LoMask)
#define Word_4(a) (uint64_t)(a & Word_LoMask) #define Word_4(a) (uint64_t)(a & Word_LoMask)
// 128x128 -> 256 wide multiply for platforms that don't have such an operation; // 128x128 -> 256 wide multiply for platforms that don't have such an operation;
// many 64-bit platforms have this operation, but they tend to have hardware // many 64-bit platforms have this operation, but they tend to have hardware
// floating-point, so we don't bother with a special case for them here. // floating-point, so we don't bother with a special case for them here.
static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
const uint64_t product11 = Word_1(a) * Word_1(b); const uint64_t product11 = Word_1(a) * Word_1(b);
const uint64_t product12 = Word_1(a) * Word_2(b); const uint64_t product12 = Word_1(a) * Word_2(b);
const uint64_t product13 = Word_1(a) * Word_3(b); const uint64_t product13 = Word_1(a) * Word_3(b);
const uint64_t product14 = Word_1(a) * Word_4(b); const uint64_t product14 = Word_1(a) * Word_4(b);
const uint64_t product21 = Word_2(a) * Word_1(b); const uint64_t product21 = Word_2(a) * Word_1(b);
const uint64_t product22 = Word_2(a) * Word_2(b); const uint64_t product22 = Word_2(a) * Word_2(b);
const uint64_t product23 = Word_2(a) * Word_3(b); const uint64_t product23 = Word_2(a) * Word_3(b);
const uint64_t product24 = Word_2(a) * Word_4(b); const uint64_t product24 = Word_2(a) * Word_4(b);
const uint64_t product31 = Word_3(a) * Word_1(b); const uint64_t product31 = Word_3(a) * Word_1(b);
const uint64_t product32 = Word_3(a) * Word_2(b); const uint64_t product32 = Word_3(a) * Word_2(b);
const uint64_t product33 = Word_3(a) * Word_3(b); const uint64_t product33 = Word_3(a) * Word_3(b);
const uint64_t product34 = Word_3(a) * Word_4(b); const uint64_t product34 = Word_3(a) * Word_4(b);
const uint64_t product41 = Word_4(a) * Word_1(b); const uint64_t product41 = Word_4(a) * Word_1(b);
const uint64_t product42 = Word_4(a) * Word_2(b); const uint64_t product42 = Word_4(a) * Word_2(b);
const uint64_t product43 = Word_4(a) * Word_3(b); const uint64_t product43 = Word_4(a) * Word_3(b);
const uint64_t product44 = Word_4(a) * Word_4(b); const uint64_t product44 = Word_4(a) * Word_4(b);
const __uint128_t sum0 = (__uint128_t)product44; const __uint128_t sum0 = (__uint128_t)product44;
const __uint128_t sum1 = (__uint128_t)product34 + const __uint128_t sum1 = (__uint128_t)product34 + (__uint128_t)product43;
(__uint128_t)product43; const __uint128_t sum2 =
const __uint128_t sum2 = (__uint128_t)product24 + (__uint128_t)product24 + (__uint128_t)product33 + (__uint128_t)product42;
(__uint128_t)product33 + const __uint128_t sum3 = (__uint128_t)product14 + (__uint128_t)product23 +
(__uint128_t)product42; (__uint128_t)product32 + (__uint128_t)product41;
const __uint128_t sum3 = (__uint128_t)product14 + const __uint128_t sum4 =
(__uint128_t)product23 + (__uint128_t)product13 + (__uint128_t)product22 + (__uint128_t)product31;
(__uint128_t)product32 + const __uint128_t sum5 = (__uint128_t)product12 + (__uint128_t)product21;
(__uint128_t)product41;
const __uint128_t sum4 = (__uint128_t)product13 +
(__uint128_t)product22 +
(__uint128_t)product31;
const __uint128_t sum5 = (__uint128_t)product12 +
(__uint128_t)product21;
const __uint128_t sum6 = (__uint128_t)product11; const __uint128_t sum6 = (__uint128_t)product11;
const __uint128_t r0 = (sum0 & Word_FullMask) + const __uint128_t r0 = (sum0 & Word_FullMask) + ((sum1 & Word_LoMask) << 32);
((sum1 & Word_LoMask) << 32); const __uint128_t r1 = (sum0 >> 64) + ((sum1 >> 32) & Word_FullMask) +
const __uint128_t r1 = (sum0 >> 64) + (sum2 & Word_FullMask) + ((sum3 << 32) & Word_HiMask);
((sum1 >> 32) & Word_FullMask) +
(sum2 & Word_FullMask) +
((sum3 << 32) & Word_HiMask);
*lo = r0 + (r1 << 64); *lo = r0 + (r1 << 64);
*hi = (r1 >> 64) + *hi = (r1 >> 64) + (sum1 >> 96) + (sum2 >> 64) + (sum3 >> 32) + sum4 +
(sum1 >> 96) + (sum5 << 32) + (sum6 << 64);
(sum2 >> 64) +
(sum3 >> 32) +
sum4 +
(sum5 << 32) +
(sum6 << 64);
} }
#undef Word_1 #undef Word_1
#undef Word_2 #undef Word_2
#undef Word_3 #undef Word_3
#undef Word_4 #undef Word_4
#undef Word_HiMask #undef Word_HiMask
#undef Word_LoMask #undef Word_LoMask
#undef Word_FullMask #undef Word_FullMask
#endif // __LDBL_MANT_DIG__ == 113 #endif // __LDBL_MANT_DIG__ == 113
#else #else
#error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined. #error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined.
#endif #endif
#if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) || defined(CRT_LDBL_128BIT) #if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) || \
defined(CRT_LDBL_128BIT)
#define typeWidth (sizeof(rep_t)*CHAR_BIT) #define typeWidth (sizeof(rep_t) * CHAR_BIT)
#define exponentBits (typeWidth - significandBits - 1) #define exponentBits (typeWidth - significandBits - 1)
#define maxExponent ((1 << exponentBits) - 1) #define maxExponent ((1 << exponentBits) - 1)
#define exponentBias (maxExponent >> 1) #define exponentBias (maxExponent >> 1)
#define implicitBit (REP_C(1) << significandBits) #define implicitBit (REP_C(1) << significandBits)
#define significandMask (implicitBit - 1U) #define significandMask (implicitBit - 1U)
#define signBit (REP_C(1) << (significandBits + exponentBits)) #define signBit (REP_C(1) << (significandBits + exponentBits))
#define absMask (signBit - 1U) #define absMask (signBit - 1U)
#define exponentMask (absMask ^ significandMask) #define exponentMask (absMask ^ significandMask)
#define oneRep ((rep_t)exponentBias << significandBits) #define oneRep ((rep_t)exponentBias << significandBits)
#define infRep exponentMask #define infRep exponentMask
#define quietBit (implicitBit >> 1) #define quietBit (implicitBit >> 1)
#define qnanRep (exponentMask | quietBit) #define qnanRep (exponentMask | quietBit)
static __inline rep_t toRep(fp_t x) { static __inline rep_t toRep(fp_t x) {
const union { fp_t f; rep_t i; } rep = {.f = x}; const union {
fp_t f;
rep_t i;
} rep = {.f = x};
return rep.i; return rep.i;
} }
static __inline fp_t fromRep(rep_t x) { static __inline fp_t fromRep(rep_t x) {
const union { fp_t f; rep_t i; } rep = {.i = x}; const union {
fp_t f;
rep_t i;
} rep = {.i = x};
return rep.f; return rep.f;
} }
static __inline int normalize(rep_t *significand) { static __inline int normalize(rep_t *significand) {
const int shift = rep_clz(*significand) - rep_clz(implicitBit); const int shift = rep_clz(*significand) - rep_clz(implicitBit);
*significand <<= shift; *significand <<= shift;
return 1 - shift; return 1 - shift;
} }
static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) { static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) {
*hi = *hi << count | *lo >> (typeWidth - count); *hi = *hi << count | *lo >> (typeWidth - count);
*lo = *lo << count; *lo = *lo << count;
} }
static __inline void wideRightShiftWithSticky(rep_t *hi, rep_t *lo, unsigned int count) { static __inline void wideRightShiftWithSticky(rep_t *hi, rep_t *lo,
unsigned int count) {
if (count < typeWidth) { if (count < typeWidth) {
const bool sticky = *lo << (typeWidth - count); const bool sticky = *lo << (typeWidth - count);
*lo = *hi << (typeWidth - count) | *lo >> count | sticky; *lo = *hi << (typeWidth - count) | *lo >> count | sticky;
*hi = *hi >> count; *hi = *hi >> count;
} } else if (count < 2 * typeWidth) {
else if (count < 2*typeWidth) {
const bool sticky = *hi << (2*typeWidth - count) | *lo; const bool sticky = *hi << (2 * typeWidth - count) | *lo;
*lo = *hi >> (count - typeWidth) | sticky; *lo = *hi >> (count - typeWidth) | sticky;
*hi = 0; *hi = 0;
} else { } else {
const bool sticky = *hi | *lo; const bool sticky = *hi | *lo;
*lo = sticky; *lo = sticky;
*hi = 0; *hi = 0;
} }
} }
// Implements logb methods (logb, logbf, logbl) for IEEE-754. This avoids // Implements logb methods (logb, logbf, logbl) for IEEE-754. This avoids
// pulling in a libm dependency from compiler-rt, but is not meant to replace // pulling in a libm dependency from compiler-rt, but is not meant to replace
// it (i.e. code calling logb() should get the one from libm, not this), hence // it (i.e. code calling logb() should get the one from libm, not this), hence
// the __compiler_rt prefix. // the __compiler_rt prefix.
static __inline fp_t __compiler_rt_logbX(fp_t x) { static __inline fp_t __compiler_rt_logbX(fp_t x) {
rep_t rep = toRep(x); rep_t rep = toRep(x);
int exp = (rep & exponentMask) >> significandBits; int exp = (rep & exponentMask) >> significandBits;
// Abnormal cases: // Abnormal cases:
// 1) +/- inf returns +inf; NaN returns NaN // 1) +/- inf returns +inf; NaN returns NaN
// 2) 0.0 returns -inf // 2) 0.0 returns -inf
if (exp == maxExponent) { if (exp == maxExponent) {
if (((rep & signBit) == 0) || (x != x)) { if (((rep & signBit) == 0) || (x != x)) {
return x; // NaN or +inf: return x return x; // NaN or +inf: return x
} else { } else {
return -x; // -inf: return -x return -x; // -inf: return -x
} }
} else if (x == 0.0) { } else if (x == 0.0) {
// 0.0: return -inf // 0.0: return -inf
return fromRep(infRep | signBit); return fromRep(infRep | signBit);
} }
if (exp != 0) { if (exp != 0) {
// Normal number // Normal number
return exp - exponentBias; // Unbias exponent return exp - exponentBias; // Unbias exponent
} else { } else {
// Subnormal number; normalize and repeat // Subnormal number; normalize and repeat
rep &= absMask; rep &= absMask;
const int shift = 1 - normalize(&rep); const int shift = 1 - normalize(&rep);
exp = (rep & exponentMask) >> significandBits; exp = (rep & exponentMask) >> significandBits;
return exp - exponentBias - shift; // Unbias exponent return exp - exponentBias - shift; // Unbias exponent
} }
} }
#endif #endif
#if defined(SINGLE_PRECISION) #if defined(SINGLE_PRECISION)
static __inline fp_t __compiler_rt_logbf(fp_t x) { static __inline fp_t __compiler_rt_logbf(fp_t x) {
return __compiler_rt_logbX(x); return __compiler_rt_logbX(x);
} }
#elif defined(DOUBLE_PRECISION) #elif defined(DOUBLE_PRECISION)
static __inline fp_t __compiler_rt_logb(fp_t x) { static __inline fp_t __compiler_rt_logb(fp_t x) {
return __compiler_rt_logbX(x); return __compiler_rt_logbX(x);
} }
#elif defined(QUAD_PRECISION) #elif defined(QUAD_PRECISION)
#if defined(CRT_LDBL_128BIT) #if defined(CRT_LDBL_128BIT)
static __inline fp_t __compiler_rt_logbl(fp_t x) { static __inline fp_t __compiler_rt_logbl(fp_t x) {
return __compiler_rt_logbX(x); return __compiler_rt_logbX(x);
} }
#else #else
// The generic implementation only works for ieee754 floating point. For other // The generic implementation only works for ieee754 floating point. For other
// floating point types, continue to rely on the libm implementation for now. // floating point types, continue to rely on the libm implementation for now.
static __inline long double __compiler_rt_logbl(long double x) { static __inline long double __compiler_rt_logbl(long double x) {
return crt_logbl(x); return crt_logbl(x);
} }
#endif #endif
#endif #endif
#endif // FP_LIB_HEADER #endif // FP_LIB_HEADER

compiler-rt/trunk/lib/builtins/fp_mul_impl.inc

//===---- lib/fp_mul_impl.inc - floating point multiplication -----*- C -*-===// //===---- lib/fp_mul_impl.inc - floating point multiplication -----*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements soft-float multiplication with the IEEE-754 default // This file implements soft-float multiplication with the IEEE-754 default
// rounding (to nearest, ties to even). // rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "fp_lib.h" #include "fp_lib.h"
static __inline fp_t __mulXf3__(fp_t a, fp_t b) { static __inline fp_t __mulXf3__(fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t productSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t productSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
// Detect if a or b is zero, denormal, infinity, or NaN. // Detect if a or b is zero, denormal, infinity, or NaN.
if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) { if (aExponent - 1U >= maxExponent - 1U ||
bExponent - 1U >= maxExponent - 1U) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
// NaN * anything = qNaN // NaN * anything = qNaN
if (aAbs > infRep) return fromRep(toRep(a) | quietBit); if (aAbs > infRep)
return fromRep(toRep(a) | quietBit);
// anything * NaN = qNaN // anything * NaN = qNaN
if (bAbs > infRep) return fromRep(toRep(b) | quietBit); if (bAbs > infRep)
return fromRep(toRep(b) | quietBit);
if (aAbs == infRep) { if (aAbs == infRep) {
// infinity * non-zero = +/- infinity // infinity * non-zero = +/- infinity
if (bAbs) return fromRep(aAbs | productSign); if (bAbs)
return fromRep(aAbs | productSign);
// infinity * zero = NaN // infinity * zero = NaN
else return fromRep(qnanRep); else
return fromRep(qnanRep);
} }
if (bAbs == infRep) { if (bAbs == infRep) {
//? non-zero * infinity = +/- infinity //? non-zero * infinity = +/- infinity
if (aAbs) return fromRep(bAbs | productSign); if (aAbs)
return fromRep(bAbs | productSign);
// zero * infinity = NaN // zero * infinity = NaN
else return fromRep(qnanRep); else
return fromRep(qnanRep);
} }
// zero * anything = +/- zero // zero * anything = +/- zero
if (!aAbs) return fromRep(productSign); if (!aAbs)
return fromRep(productSign);
// anything * zero = +/- zero // anything * zero = +/- zero
if (!bAbs) return fromRep(productSign); if (!bAbs)
return fromRep(productSign);
// one or both of a or b is denormal, the other (if applicable) is a // one or both of a or b is denormal, the other (if applicable) is a
// normal number. Renormalize one or both of a and b, and set scale to // normal number. Renormalize one or both of a and b, and set scale to
// include the necessary exponent adjustment. // include the necessary exponent adjustment.
if (aAbs < implicitBit) scale += normalize(&aSignificand); if (aAbs < implicitBit)
if (bAbs < implicitBit) scale += normalize(&bSignificand); scale += normalize(&aSignificand);
if (bAbs < implicitBit)
scale += normalize(&bSignificand);
} }
// Or in the implicit significand bit. (If we fell through from the // Or in the implicit significand bit. (If we fell through from the
// denormal path it was already set by normalize( ), but setting it twice // denormal path it was already set by normalize( ), but setting it twice
// won't hurt anything.) // won't hurt anything.)
aSignificand |= implicitBit; aSignificand |= implicitBit;
bSignificand |= implicitBit; bSignificand |= implicitBit;
// Get the significand of a*b. Before multiplying the significands, shift // Get the significand of a*b. Before multiplying the significands, shift
// one of them left to left-align it in the field. Thus, the product will // one of them left to left-align it in the field. Thus, the product will
// have (exponentBits + 2) integral digits, all but two of which must be // have (exponentBits + 2) integral digits, all but two of which must be
// zero. Normalizing this result is just a conditional left-shift by one // zero. Normalizing this result is just a conditional left-shift by one
// and bumping the exponent accordingly. // and bumping the exponent accordingly.
rep_t productHi, productLo; rep_t productHi, productLo;
wideMultiply(aSignificand, bSignificand << exponentBits, wideMultiply(aSignificand, bSignificand << exponentBits, &productHi,
&productHi, &productLo); &productLo);
int productExponent = aExponent + bExponent - exponentBias + scale; int productExponent = aExponent + bExponent - exponentBias + scale;
// Normalize the significand, adjust exponent if needed. // Normalize the significand, adjust exponent if needed.
if (productHi & implicitBit) productExponent++; if (productHi & implicitBit)
else wideLeftShift(&productHi, &productLo, 1); productExponent++;
else
wideLeftShift(&productHi, &productLo, 1);
// If we have overflowed the type, return +/- infinity. // If we have overflowed the type, return +/- infinity.
if (productExponent >= maxExponent) return fromRep(infRep | productSign); if (productExponent >= maxExponent)
return fromRep(infRep | productSign);
if (productExponent <= 0) { if (productExponent <= 0) {
// Result is denormal before rounding // Result is denormal before rounding
// //
// If the result is so small that it just underflows to zero, return // If the result is so small that it just underflows to zero, return
// a zero of the appropriate sign. Mathematically there is no need to // a zero of the appropriate sign. Mathematically there is no need to
// handle this case separately, but we make it a special case to // handle this case separately, but we make it a special case to
// simplify the shift logic. // simplify the shift logic.
const unsigned int shift = REP_C(1) - (unsigned int)productExponent; const unsigned int shift = REP_C(1) - (unsigned int)productExponent;
if (shift >= typeWidth) return fromRep(productSign); if (shift >= typeWidth)
return fromRep(productSign);
// Otherwise, shift the significand of the result so that the round // Otherwise, shift the significand of the result so that the round
// bit is the high bit of productLo. // bit is the high bit of productLo.
wideRightShiftWithSticky(&productHi, &productLo, shift); wideRightShiftWithSticky(&productHi, &productLo, shift);
} } else {
else {
// Result is normal before rounding; insert the exponent. // Result is normal before rounding; insert the exponent.
productHi &= significandMask; productHi &= significandMask;
productHi |= (rep_t)productExponent << significandBits; productHi |= (rep_t)productExponent << significandBits;
} }
// Insert the sign of the result: // Insert the sign of the result:
productHi |= productSign; productHi |= productSign;
// Final rounding. The final result may overflow to infinity, or underflow // Final rounding. The final result may overflow to infinity, or underflow
// to zero, but those are the correct results in those cases. We use the // to zero, but those are the correct results in those cases. We use the
// default IEEE-754 round-to-nearest, ties-to-even rounding mode. // default IEEE-754 round-to-nearest, ties-to-even rounding mode.
if (productLo > signBit) productHi++; if (productLo > signBit)
if (productLo == signBit) productHi += productHi & 1; productHi++;
if (productLo == signBit)
productHi += productHi & 1;
return fromRep(productHi); return fromRep(productHi);
} }

compiler-rt/trunk/lib/builtins/fp_trunc.h

Show All 29 Lines
#elif defined SRC_QUAD #elif defined SRC_QUAD
typedef long double src_t; typedef long double src_t;
typedef __uint128_t src_rep_t; typedef __uint128_t src_rep_t;
#define SRC_REP_C (__uint128_t) #define SRC_REP_C (__uint128_t)
static const int srcSigBits = 112; static const int srcSigBits = 112;
#else #else
#error Source should be double precision or quad precision! #error Source should be double precision or quad precision!
#endif //end source precision #endif // end source precision
#if defined DST_DOUBLE #if defined DST_DOUBLE
typedef double dst_t; typedef double dst_t;
typedef uint64_t dst_rep_t; typedef uint64_t dst_rep_t;
#define DST_REP_C UINT64_C #define DST_REP_C UINT64_C
static const int dstSigBits = 52; static const int dstSigBits = 52;
#elif defined DST_SINGLE #elif defined DST_SINGLE
typedef float dst_t; typedef float dst_t;
typedef uint32_t dst_rep_t; typedef uint32_t dst_rep_t;
#define DST_REP_C UINT32_C #define DST_REP_C UINT32_C
static const int dstSigBits = 23; static const int dstSigBits = 23;
#elif defined DST_HALF #elif defined DST_HALF
typedef uint16_t dst_t; typedef uint16_t dst_t;
typedef uint16_t dst_rep_t; typedef uint16_t dst_rep_t;
#define DST_REP_C UINT16_C #define DST_REP_C UINT16_C
static const int dstSigBits = 10; static const int dstSigBits = 10;
#else #else
#error Destination should be single precision or double precision! #error Destination should be single precision or double precision!
#endif //end destination precision #endif // end destination precision
// End of specialization parameters. Two helper routines for conversion to and // End of specialization parameters. Two helper routines for conversion to and
// from the representation of floating-point data as integer values follow. // from the representation of floating-point data as integer values follow.
static __inline src_rep_t srcToRep(src_t x) { static __inline src_rep_t srcToRep(src_t x) {
const union { src_t f; src_rep_t i; } rep = {.f = x}; const union {
src_t f;
src_rep_t i;
} rep = {.f = x};
return rep.i; return rep.i;
} }
static __inline dst_t dstFromRep(dst_rep_t x) { static __inline dst_t dstFromRep(dst_rep_t x) {
const union { dst_t f; dst_rep_t i; } rep = {.i = x}; const union {
dst_t f;
dst_rep_t i;
} rep = {.i = x};
return rep.f; return rep.f;
} }
#endif // FP_TRUNC_HEADER #endif // FP_TRUNC_HEADER

compiler-rt/trunk/lib/builtins/fp_trunc_impl.inc

Show All 33 Lines
// 2. quiet NaNs, if supported, are indicated by the leading bit of the // 2. quiet NaNs, if supported, are indicated by the leading bit of the
// significand field being set // significand field being set
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "fp_trunc.h" #include "fp_trunc.h"
static __inline dst_t __truncXfYf2__(src_t a) { static __inline dst_t __truncXfYf2__(src_t a) {
// Various constants whose values follow from the type parameters. // Various constants whose values follow from the type parameters.
// Any reasonable optimizer will fold and propagate all of these. // Any reasonable optimizer will fold and propagate all of these.
const int srcBits = sizeof(src_t)*CHAR_BIT; const int srcBits = sizeof(src_t) * CHAR_BIT;
const int srcExpBits = srcBits - srcSigBits - 1; const int srcExpBits = srcBits - srcSigBits - 1;
const int srcInfExp = (1 << srcExpBits) - 1; const int srcInfExp = (1 << srcExpBits) - 1;
const int srcExpBias = srcInfExp >> 1; const int srcExpBias = srcInfExp >> 1;
const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits; const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits;
const src_rep_t srcSignificandMask = srcMinNormal - 1; const src_rep_t srcSignificandMask = srcMinNormal - 1;
const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits; const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits;
const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits); const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits);
const src_rep_t srcAbsMask = srcSignMask - 1; const src_rep_t srcAbsMask = srcSignMask - 1;
const src_rep_t roundMask = (SRC_REP_C(1) << (srcSigBits - dstSigBits)) - 1; const src_rep_t roundMask = (SRC_REP_C(1) << (srcSigBits - dstSigBits)) - 1;
const src_rep_t halfway = SRC_REP_C(1) << (srcSigBits - dstSigBits - 1); const src_rep_t halfway = SRC_REP_C(1) << (srcSigBits - dstSigBits - 1);
const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1); const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1);
const src_rep_t srcNaNCode = srcQNaN - 1; const src_rep_t srcNaNCode = srcQNaN - 1;
const int dstBits = sizeof(dst_t)*CHAR_BIT; const int dstBits = sizeof(dst_t) * CHAR_BIT;
const int dstExpBits = dstBits - dstSigBits - 1; const int dstExpBits = dstBits - dstSigBits - 1;
const int dstInfExp = (1 << dstExpBits) - 1; const int dstInfExp = (1 << dstExpBits) - 1;
const int dstExpBias = dstInfExp >> 1; const int dstExpBias = dstInfExp >> 1;
const int underflowExponent = srcExpBias + 1 - dstExpBias; const int underflowExponent = srcExpBias + 1 - dstExpBias;
const int overflowExponent = srcExpBias + dstInfExp - dstExpBias; const int overflowExponent = srcExpBias + dstInfExp - dstExpBias;
const src_rep_t underflow = (src_rep_t)underflowExponent << srcSigBits; const src_rep_t underflow = (src_rep_t)underflowExponent << srcSigBits;
const src_rep_t overflow = (src_rep_t)overflowExponent << srcSigBits; const src_rep_t overflow = (src_rep_t)overflowExponent << srcSigBits;
const dst_rep_t dstQNaN = DST_REP_C(1) << (dstSigBits - 1); const dst_rep_t dstQNaN = DST_REP_C(1) << (dstSigBits - 1);
const dst_rep_t dstNaNCode = dstQNaN - 1; const dst_rep_t dstNaNCode = dstQNaN - 1;
// Break a into a sign and representation of the absolute value // Break a into a sign and representation of the absolute value
const src_rep_t aRep = srcToRep(a); const src_rep_t aRep = srcToRep(a);
const src_rep_t aAbs = aRep & srcAbsMask; const src_rep_t aAbs = aRep & srcAbsMask;
const src_rep_t sign = aRep & srcSignMask; const src_rep_t sign = aRep & srcSignMask;
dst_rep_t absResult; dst_rep_t absResult;
if (aAbs - underflow < aAbs - overflow) { if (aAbs - underflow < aAbs - overflow) {
// The exponent of a is within the range of normal numbers in the // The exponent of a is within the range of normal numbers in the
// destination format. We can convert by simply right-shifting with // destination format. We can convert by simply right-shifting with
// rounding and adjusting the exponent. // rounding and adjusting the exponent.
absResult = aAbs >> (srcSigBits - dstSigBits); absResult = aAbs >> (srcSigBits - dstSigBits);
absResult -= (dst_rep_t)(srcExpBias - dstExpBias) << dstSigBits; absResult -= (dst_rep_t)(srcExpBias - dstExpBias) << dstSigBits;
const src_rep_t roundBits = aAbs & roundMask; const src_rep_t roundBits = aAbs & roundMask;
// Round to nearest // Round to nearest
if (roundBits > halfway) if (roundBits > halfway)
absResult++; absResult++;
// Ties to even // Ties to even
else if (roundBits == halfway) else if (roundBits == halfway)
absResult += absResult & 1; absResult += absResult & 1;
} } else if (aAbs > srcInfinity) {
else if (aAbs > srcInfinity) {
// a is NaN. // a is NaN.
// Conjure the result by beginning with infinity, setting the qNaN // Conjure the result by beginning with infinity, setting the qNaN
// bit and inserting the (truncated) trailing NaN field. // bit and inserting the (truncated) trailing NaN field.
absResult = (dst_rep_t)dstInfExp << dstSigBits; absResult = (dst_rep_t)dstInfExp << dstSigBits;
absResult |= dstQNaN; absResult |= dstQNaN;
absResult |= ((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode; absResult |=
} ((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode;
else if (aAbs >= overflow) { } else if (aAbs >= overflow) {
// a overflows to infinity. // a overflows to infinity.
absResult = (dst_rep_t)dstInfExp << dstSigBits; absResult = (dst_rep_t)dstInfExp << dstSigBits;
} } else {
else {
// a underflows on conversion to the destination type or is an exact // a underflows on conversion to the destination type or is an exact
// zero. The result may be a denormal or zero. Extract the exponent // zero. The result may be a denormal or zero. Extract the exponent
// to get the shift amount for the denormalization. // to get the shift amount for the denormalization.
const int aExp = aAbs >> srcSigBits; const int aExp = aAbs >> srcSigBits;
const int shift = srcExpBias - dstExpBias - aExp + 1; const int shift = srcExpBias - dstExpBias - aExp + 1;
const src_rep_t significand = (aRep & srcSignificandMask) | srcMinNormal; const src_rep_t significand = (aRep & srcSignificandMask) | srcMinNormal;
// Right shift by the denormalization amount with sticky. // Right shift by the denormalization amount with sticky.
if (shift > srcSigBits) { if (shift > srcSigBits) {
absResult = 0; absResult = 0;
} else { } else {
const bool sticky = significand << (srcBits - shift); const bool sticky = significand << (srcBits - shift);
src_rep_t denormalizedSignificand = significand >> shift | sticky; src_rep_t denormalizedSignificand = significand >> shift | sticky;
absResult = denormalizedSignificand >> (srcSigBits - dstSigBits); absResult = denormalizedSignificand >> (srcSigBits - dstSigBits);
const src_rep_t roundBits = denormalizedSignificand & roundMask; const src_rep_t roundBits = denormalizedSignificand & roundMask;
// Round to nearest // Round to nearest
if (roundBits > halfway) if (roundBits > halfway)
absResult++; absResult++;
// Ties to even // Ties to even
else if (roundBits == halfway) else if (roundBits == halfway)
absResult += absResult & 1; absResult += absResult & 1;
} }
} }
// Apply the signbit to (dst_t)abs(a). // Apply the signbit to (dst_t)abs(a).
const dst_rep_t result = absResult | sign >> (srcBits - dstBits); const dst_rep_t result = absResult | sign >> (srcBits - dstBits);
return dstFromRep(result); return dstFromRep(result);
} }

compiler-rt/trunk/lib/builtins/gcc_personality_v0.c

/* ===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------=== /* ===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
*/ */
#include "int_lib.h" #include "int_lib.h"
#include <unwind.h> #include <unwind.h>
#if defined(__arm__) && !defined(__ARM_DWARF_EH__) && !defined(__USING_SJLJ_EXCEPTIONS__) #if defined(__arm__) && !defined(__ARM_DWARF_EH__) && \
!defined(__USING_SJLJ_EXCEPTIONS__)
/* /*
* When building with older compilers (e.g. clang <3.9), it is possible that we * When building with older compilers (e.g. clang <3.9), it is possible that we
* have a version of unwind.h which does not provide the EHABI declarations * have a version of unwind.h which does not provide the EHABI declarations
* which are quired for the C personality to conform to the specification. In * which are quired for the C personality to conform to the specification. In
* order to provide forward compatibility for such compilers, we re-declare the * order to provide forward compatibility for such compilers, we re-declare the
* necessary interfaces in the helper to permit a standalone compilation of the * necessary interfaces in the helper to permit a standalone compilation of the
* builtins (which contains the C unwinding personality for historical reasons). * builtins (which contains the C unwinding personality for historical reasons).
*/ */
#include "unwind-ehabi-helpers.h" #include "unwind-ehabi-helpers.h"
#endif #endif
/* /*
* Pointer encodings documented at: * Pointer encodings documented at:
* http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html * http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
*/ */
#define DW_EH_PE_omit 0xff /* no data follows */ #define DW_EH_PE_omit 0xff /* no data follows */
#define DW_EH_PE_absptr 0x00 #define DW_EH_PE_absptr 0x00
#define DW_EH_PE_uleb128 0x01 #define DW_EH_PE_uleb128 0x01
#define DW_EH_PE_udata2 0x02 #define DW_EH_PE_udata2 0x02
#define DW_EH_PE_udata4 0x03 #define DW_EH_PE_udata4 0x03
#define DW_EH_PE_udata8 0x04 #define DW_EH_PE_udata8 0x04
#define DW_EH_PE_sleb128 0x09 #define DW_EH_PE_sleb128 0x09
#define DW_EH_PE_sdata2 0x0A #define DW_EH_PE_sdata2 0x0A
#define DW_EH_PE_sdata4 0x0B #define DW_EH_PE_sdata4 0x0B
#define DW_EH_PE_sdata8 0x0C #define DW_EH_PE_sdata8 0x0C
#define DW_EH_PE_pcrel 0x10 #define DW_EH_PE_pcrel 0x10
#define DW_EH_PE_textrel 0x20 #define DW_EH_PE_textrel 0x20
#define DW_EH_PE_datarel 0x30 #define DW_EH_PE_datarel 0x30
#define DW_EH_PE_funcrel 0x40 #define DW_EH_PE_funcrel 0x40
#define DW_EH_PE_aligned 0x50 #define DW_EH_PE_aligned 0x50
#define DW_EH_PE_indirect 0x80 /* gcc extension */ #define DW_EH_PE_indirect 0x80 /* gcc extension */
/* read a uleb128 encoded value and advance pointer */ /* read a uleb128 encoded value and advance pointer */
static uintptr_t readULEB128(const uint8_t** data) static uintptr_t readULEB128(const uint8_t **data) {
{
uintptr_t result = 0; uintptr_t result = 0;
uintptr_t shift = 0; uintptr_t shift = 0;
unsigned char byte; unsigned char byte;
const uint8_t* p = *data; const uint8_t *p = *data;
do { do {
byte = *p++; byte = *p++;
result |= (byte & 0x7f) << shift; result |= (byte & 0x7f) << shift;
shift += 7; shift += 7;
} while (byte & 0x80); } while (byte & 0x80);
*data = p; *data = p;
return result; return result;
} }
/* read a pointer encoded value and advance pointer */ /* read a pointer encoded value and advance pointer */
static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding) static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
{
const uint8_t* p = *data; const uint8_t *p = *data;
uintptr_t result = 0; uintptr_t result = 0;
if ( encoding == DW_EH_PE_omit ) if (encoding == DW_EH_PE_omit)
return 0; return 0;
/* first get value */ /* first get value */
switch (encoding & 0x0F) { switch (encoding & 0x0F) {
case DW_EH_PE_absptr: case DW_EH_PE_absptr:
result = *((const uintptr_t*)p); result = *((const uintptr_t *)p);
p += sizeof(uintptr_t); p += sizeof(uintptr_t);
break; break;
case DW_EH_PE_uleb128: case DW_EH_PE_uleb128:
result = readULEB128(&p); result = readULEB128(&p);
break; break;
case DW_EH_PE_udata2: case DW_EH_PE_udata2:
result = *((const uint16_t*)p); result = *((const uint16_t *)p);
p += sizeof(uint16_t); p += sizeof(uint16_t);
break; break;
case DW_EH_PE_udata4: case DW_EH_PE_udata4:
result = *((const uint32_t*)p); result = *((const uint32_t *)p);
p += sizeof(uint32_t); p += sizeof(uint32_t);
break; break;
case DW_EH_PE_udata8: case DW_EH_PE_udata8:
result = *((const uint64_t*)p); result = *((const uint64_t *)p);
p += sizeof(uint64_t); p += sizeof(uint64_t);
break; break;
case DW_EH_PE_sdata2: case DW_EH_PE_sdata2:
result = *((const int16_t*)p); result = *((const int16_t *)p);
p += sizeof(int16_t); p += sizeof(int16_t);
break; break;
case DW_EH_PE_sdata4: case DW_EH_PE_sdata4:
result = *((const int32_t*)p); result = *((const int32_t *)p);
p += sizeof(int32_t); p += sizeof(int32_t);
break; break;
case DW_EH_PE_sdata8: case DW_EH_PE_sdata8:
result = *((const int64_t*)p); result = *((const int64_t *)p);
p += sizeof(int64_t); p += sizeof(int64_t);
break; break;
case DW_EH_PE_sleb128: case DW_EH_PE_sleb128:
default: default:
/* not supported */ /* not supported */
compilerrt_abort(); compilerrt_abort();
break; break;
} }
/* then add relative offset */ /* then add relative offset */
switch ( encoding & 0x70 ) { switch (encoding & 0x70) {
case DW_EH_PE_absptr: case DW_EH_PE_absptr:
/* do nothing */ /* do nothing */
break; break;
case DW_EH_PE_pcrel: case DW_EH_PE_pcrel:
result += (uintptr_t)(*data); result += (uintptr_t)(*data);
break; break;
case DW_EH_PE_textrel: case DW_EH_PE_textrel:
case DW_EH_PE_datarel: case DW_EH_PE_datarel:
case DW_EH_PE_funcrel: case DW_EH_PE_funcrel:
case DW_EH_PE_aligned: case DW_EH_PE_aligned:
default: default:
/* not supported */ /* not supported */
compilerrt_abort(); compilerrt_abort();
break; break;
} }
/* then apply indirection */ /* then apply indirection */
if (encoding & DW_EH_PE_indirect) { if (encoding & DW_EH_PE_indirect) {
result = *((const uintptr_t*)result); result = *((const uintptr_t *)result);
} }
*data = p; *data = p;
return result; return result;
} }
#if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) && \ #if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) && \
!defined(__ARM_DWARF_EH__) !defined(__ARM_DWARF_EH__)
#define USING_ARM_EHABI 1 #define USING_ARM_EHABI 1
_Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *, _Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *,
struct _Unwind_Context *); struct _Unwind_Context *);
#endif #endif
static inline _Unwind_Reason_Code static inline _Unwind_Reason_Code
continueUnwind(struct _Unwind_Exception *exceptionObject, continueUnwind(struct _Unwind_Exception *exceptionObject,
struct _Unwind_Context *context) { struct _Unwind_Context *context) {
#if USING_ARM_EHABI #if USING_ARM_EHABI
/* /*
* On ARM EHABI the personality routine is responsible for actually * On ARM EHABI the personality routine is responsible for actually
* unwinding a single stack frame before returning (ARM EHABI Sec. 6.1). * unwinding a single stack frame before returning (ARM EHABI Sec. 6.1).
*/ */
if (__gnu_unwind_frame(exceptionObject, context) != _URC_OK) if (__gnu_unwind_frame(exceptionObject, context) != _URC_OK)
return _URC_FAILURE; return _URC_FAILURE;
#endif #endif
return _URC_CONTINUE_UNWIND; return _URC_CONTINUE_UNWIND;
} }
/* /*
* The C compiler makes references to __gcc_personality_v0 in * The C compiler makes references to __gcc_personality_v0 in
* the dwarf unwind information for translation units that use * the dwarf unwind information for translation units that use
* __attribute__((cleanup(xx))) on local variables. * __attribute__((cleanup(xx))) on local variables.
* This personality routine is called by the system unwinder * This personality routine is called by the system unwinder
* on each frame as the stack is unwound during a C++ exception * on each frame as the stack is unwound during a C++ exception
* throw through a C function compiled with -fexceptions. * throw through a C function compiled with -fexceptions.
*/ */
#if __USING_SJLJ_EXCEPTIONS__ #if __USING_SJLJ_EXCEPTIONS__
/* the setjump-longjump based exceptions personality routine has a /* the setjump-longjump based exceptions personality routine has a
* different name */ * different name */
COMPILER_RT_ABI _Unwind_Reason_Code COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_sj0(
__gcc_personality_sj0(int version, _Unwind_Action actions, int version, _Unwind_Action actions, uint64_t exceptionClass,
uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject, struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
struct _Unwind_Context *context)
#elif USING_ARM_EHABI #elif USING_ARM_EHABI
/* The ARM EHABI personality routine has a different signature. */ /* The ARM EHABI personality routine has a different signature. */
COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0( COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
_Unwind_State state, struct _Unwind_Exception *exceptionObject, _Unwind_State state, struct _Unwind_Exception *exceptionObject,
struct _Unwind_Context *context) struct _Unwind_Context *context)
#else #else
COMPILER_RT_ABI _Unwind_Reason_Code COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
__gcc_personality_v0(int version, _Unwind_Action actions, int version, _Unwind_Action actions, uint64_t exceptionClass,
uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject, struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
struct _Unwind_Context *context)
#endif #endif
{ {
/* Since C does not have catch clauses, there is nothing to do during */ /* Since C does not have catch clauses, there is nothing to do during */
/* phase 1 (the search phase). */ /* phase 1 (the search phase). */
#if USING_ARM_EHABI #if USING_ARM_EHABI
/* After resuming from a cleanup we should also continue on to the next /* After resuming from a cleanup we should also continue on to the next
* frame straight away. */ * frame straight away. */
if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING) if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
#else #else
if ( actions & _UA_SEARCH_PHASE ) if (actions & _UA_SEARCH_PHASE)
#endif #endif
return continueUnwind(exceptionObject, context); return continueUnwind(exceptionObject, context);
/* There is nothing to do if there is no LSDA for this frame. */ /* There is nothing to do if there is no LSDA for this frame. */
const uint8_t* lsda = (uint8_t*)_Unwind_GetLanguageSpecificData(context); const uint8_t *lsda = (uint8_t *)_Unwind_GetLanguageSpecificData(context);
if ( lsda == (uint8_t*) 0 ) if (lsda == (uint8_t *)0)
return continueUnwind(exceptionObject, context); return continueUnwind(exceptionObject, context);
uintptr_t pc = (uintptr_t)_Unwind_GetIP(context)-1; uintptr_t pc = (uintptr_t)_Unwind_GetIP(context) - 1;
uintptr_t funcStart = (uintptr_t)_Unwind_GetRegionStart(context); uintptr_t funcStart = (uintptr_t)_Unwind_GetRegionStart(context);
uintptr_t pcOffset = pc - funcStart; uintptr_t pcOffset = pc - funcStart;
/* Parse LSDA header. */ /* Parse LSDA header. */
uint8_t lpStartEncoding = *lsda++; uint8_t lpStartEncoding = *lsda++;
if (lpStartEncoding != DW_EH_PE_omit) { if (lpStartEncoding != DW_EH_PE_omit) {
readEncodedPointer(&lsda, lpStartEncoding); readEncodedPointer(&lsda, lpStartEncoding);
} }
uint8_t ttypeEncoding = *lsda++; uint8_t ttypeEncoding = *lsda++;
if (ttypeEncoding != DW_EH_PE_omit) { if (ttypeEncoding != DW_EH_PE_omit) {
readULEB128(&lsda); readULEB128(&lsda);
} }
/* Walk call-site table looking for range that includes current PC. */ /* Walk call-site table looking for range that includes current PC. */
uint8_t callSiteEncoding = *lsda++; uint8_t callSiteEncoding = *lsda++;
uint32_t callSiteTableLength = readULEB128(&lsda); uint32_t callSiteTableLength = readULEB128(&lsda);
const uint8_t* callSiteTableStart = lsda; const uint8_t *callSiteTableStart = lsda;
const uint8_t* callSiteTableEnd = callSiteTableStart + callSiteTableLength; const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength;
const uint8_t* p=callSiteTableStart; const uint8_t *p = callSiteTableStart;
while (p < callSiteTableEnd) { while (p < callSiteTableEnd) {
uintptr_t start = readEncodedPointer(&p, callSiteEncoding); uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
uintptr_t length = readEncodedPointer(&p, callSiteEncoding); uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding); uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);
readULEB128(&p); /* action value not used for C code */ readULEB128(&p); /* action value not used for C code */
if ( landingPad == 0 ) if (landingPad == 0)
continue; /* no landing pad for this entry */ continue; /* no landing pad for this entry */
if ( (start <= pcOffset) && (pcOffset < (start+length)) ) { if ((start <= pcOffset) && (pcOffset < (start + length))) {
/* Found landing pad for the PC. /* Found landing pad for the PC.
* Set Instruction Pointer to so we re-enter function * Set Instruction Pointer to so we re-enter function
* at landing pad. The landing pad is created by the compiler * at landing pad. The landing pad is created by the compiler
* to take two parameters in registers. * to take two parameters in registers.
*/ */
_Unwind_SetGR(context, __builtin_eh_return_data_regno(0), _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
(uintptr_t)exceptionObject); (uintptr_t)exceptionObject);
_Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0); _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
_Unwind_SetIP(context, (funcStart + landingPad)); _Unwind_SetIP(context, (funcStart + landingPad));
return _URC_INSTALL_CONTEXT; return _URC_INSTALL_CONTEXT;
} }
} }
/* No landing pad found, continue unwinding. */ /* No landing pad found, continue unwinding. */
return continueUnwind(exceptionObject, context); return continueUnwind(exceptionObject, context);
} }

compiler-rt/trunk/lib/builtins/int_endianness.h

Show All 9 Lines
* This file is not part of the interface of this library. * This file is not part of the interface of this library.
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#ifndef INT_ENDIANNESS_H #ifndef INT_ENDIANNESS_H
#define INT_ENDIANNESS_H #define INT_ENDIANNESS_H
#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
defined(__ORDER_LITTLE_ENDIAN__) defined(__ORDER_LITTLE_ENDIAN__)
/* Clang and GCC provide built-in endianness definitions. */ /* Clang and GCC provide built-in endianness definitions. */
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define _YUGA_LITTLE_ENDIAN 0 #define _YUGA_LITTLE_ENDIAN 0
#define _YUGA_BIG_ENDIAN 1 #define _YUGA_BIG_ENDIAN 1
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_LITTLE_ENDIAN 1
#define _YUGA_BIG_ENDIAN 0 #define _YUGA_BIG_ENDIAN 0
#endif /* __BYTE_ORDER__ */ #endif /* __BYTE_ORDER__ */
#else /* Compilers other than Clang or GCC. */ #else /* Compilers other than Clang or GCC. */
#if defined(__SVR4) && defined(__sun) #if defined(__SVR4) && defined(__sun)
#include <sys/byteorder.h> #include <sys/byteorder.h>
#if defined(_BIG_ENDIAN) #if defined(_BIG_ENDIAN)
#define _YUGA_LITTLE_ENDIAN 0 #define _YUGA_LITTLE_ENDIAN 0
#define _YUGA_BIG_ENDIAN 1 #define _YUGA_BIG_ENDIAN 1
#elif defined(_LITTLE_ENDIAN) #elif defined(_LITTLE_ENDIAN)
#define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_LITTLE_ENDIAN 1
#define _YUGA_BIG_ENDIAN 0 #define _YUGA_BIG_ENDIAN 0
#else /* !_LITTLE_ENDIAN */ #else /* !_LITTLE_ENDIAN */
#error "unknown endianness" #error "unknown endianness"
#endif /* !_LITTLE_ENDIAN */ #endif /* !_LITTLE_ENDIAN */
#endif /* Solaris and AuroraUX. */ #endif /* Solaris and AuroraUX. */
/* .. */ /* .. */
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \ #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \
defined(__minix) defined(__minix)
#include <sys/endian.h> #include <sys/endian.h>
#if _BYTE_ORDER == _BIG_ENDIAN #if _BYTE_ORDER == _BIG_ENDIAN
#define _YUGA_LITTLE_ENDIAN 0 #define _YUGA_LITTLE_ENDIAN 0
#define _YUGA_BIG_ENDIAN 1 #define _YUGA_BIG_ENDIAN 1
#elif _BYTE_ORDER == _LITTLE_ENDIAN #elif _BYTE_ORDER == _LITTLE_ENDIAN
#define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_LITTLE_ENDIAN 1
#define _YUGA_BIG_ENDIAN 0 #define _YUGA_BIG_ENDIAN 0
#endif /* _BYTE_ORDER */ #endif /* _BYTE_ORDER */
#endif /* *BSD */ #endif /* *BSD */
#if defined(__OpenBSD__) #if defined(__OpenBSD__)
#include <machine/endian.h> #include <machine/endian.h>
#if _BYTE_ORDER == _BIG_ENDIAN #if _BYTE_ORDER == _BIG_ENDIAN
#define _YUGA_LITTLE_ENDIAN 0 #define _YUGA_LITTLE_ENDIAN 0
#define _YUGA_BIG_ENDIAN 1 #define _YUGA_BIG_ENDIAN 1
#elif _BYTE_ORDER == _LITTLE_ENDIAN #elif _BYTE_ORDER == _LITTLE_ENDIAN
#define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_LITTLE_ENDIAN 1
#define _YUGA_BIG_ENDIAN 0 #define _YUGA_BIG_ENDIAN 0
#endif /* _BYTE_ORDER */ #endif /* _BYTE_ORDER */
#endif /* OpenBSD */ #endif /* OpenBSD */
/* .. */ /* .. */
/* Mac OSX has __BIG_ENDIAN__ or __LITTLE_ENDIAN__ automatically set by the /* Mac OSX has __BIG_ENDIAN__ or __LITTLE_ENDIAN__ automatically set by the
* compiler (at least with GCC) */ * compiler (at least with GCC) */
#if defined(__APPLE__) || defined(__ellcc__ ) #if defined(__APPLE__) || defined(__ellcc__)
#ifdef __BIG_ENDIAN__ #ifdef __BIG_ENDIAN__
#if __BIG_ENDIAN__ #if __BIG_ENDIAN__
#define _YUGA_LITTLE_ENDIAN 0 #define _YUGA_LITTLE_ENDIAN 0
#define _YUGA_BIG_ENDIAN 1 #define _YUGA_BIG_ENDIAN 1
#endif #endif
#endif /* __BIG_ENDIAN__ */ #endif /* __BIG_ENDIAN__ */
#ifdef __LITTLE_ENDIAN__ #ifdef __LITTLE_ENDIAN__
#if __LITTLE_ENDIAN__ #if __LITTLE_ENDIAN__
#define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_LITTLE_ENDIAN 1
#define _YUGA_BIG_ENDIAN 0 #define _YUGA_BIG_ENDIAN 0
#endif #endif
#endif /* __LITTLE_ENDIAN__ */ #endif /* __LITTLE_ENDIAN__ */
#endif /* Mac OSX */ #endif /* Mac OSX */
/* .. */ /* .. */
#if defined(_WIN32) #if defined(_WIN32)
#define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_LITTLE_ENDIAN 1
#define _YUGA_BIG_ENDIAN 0 #define _YUGA_BIG_ENDIAN 0
#endif /* Windows */ #endif /* Windows */
#endif /* Clang or GCC. */ #endif /* Clang or GCC. */
/* . */ /* . */
#if !defined(_YUGA_LITTLE_ENDIAN) || !defined(_YUGA_BIG_ENDIAN) #if !defined(_YUGA_LITTLE_ENDIAN) || !defined(_YUGA_BIG_ENDIAN)
#error Unable to determine endian #error Unable to determine endian
#endif /* Check we found an endianness correctly. */ #endif /* Check we found an endianness correctly. */
#endif /* INT_ENDIANNESS_H */ #endif /* INT_ENDIANNESS_H */

compiler-rt/trunk/lib/builtins/int_lib.h

Show All 14 Lines
#ifndef INT_LIB_H #ifndef INT_LIB_H
#define INT_LIB_H #define INT_LIB_H
/* Assumption: Signed integral is 2's complement. */ /* Assumption: Signed integral is 2's complement. */
/* Assumption: Right shift of signed negative is arithmetic shift. */ /* Assumption: Right shift of signed negative is arithmetic shift. */
/* Assumption: Endianness is little or big (not mixed). */ /* Assumption: Endianness is little or big (not mixed). */
#if defined(__ELF__) #if defined(__ELF__)
#define FNALIAS(alias_name, original_name) \ #define FNALIAS(alias_name, original_name) \
void alias_name() __attribute__((__alias__(#original_name))) void alias_name() __attribute__((__alias__(#original_name)))
#define COMPILER_RT_ALIAS(aliasee) __attribute__((__alias__(#aliasee))) #define COMPILER_RT_ALIAS(aliasee) __attribute__((__alias__(#aliasee)))
#else #else
#define FNALIAS(alias, name) _Pragma("GCC error(\"alias unsupported on this file format\")") #define FNALIAS(alias, name) \
#define COMPILER_RT_ALIAS(aliasee) _Pragma("GCC error(\"alias unsupported on this file format\")") _Pragma("GCC error(\"alias unsupported on this file format\")")
#define COMPILER_RT_ALIAS(aliasee) \
_Pragma("GCC error(\"alias unsupported on this file format\")")
#endif #endif
/* ABI macro definitions */ /* ABI macro definitions */
#if __ARM_EABI__ #if __ARM_EABI__
# ifdef COMPILER_RT_ARMHF_TARGET #ifdef COMPILER_RT_ARMHF_TARGET
# define COMPILER_RT_ABI #define COMPILER_RT_ABI
# else #else
# define COMPILER_RT_ABI __attribute__((__pcs__("aapcs"))) #define COMPILER_RT_ABI __attribute__((__pcs__("aapcs")))
# endif #endif
#else #else
# define COMPILER_RT_ABI #define COMPILER_RT_ABI
#endif #endif
#define AEABI_RTABI __attribute__((__pcs__("aapcs"))) #define AEABI_RTABI __attribute__((__pcs__("aapcs")))
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#define ALWAYS_INLINE __forceinline #define ALWAYS_INLINE __forceinline
#define NOINLINE __declspec(noinline) #define NOINLINE __declspec(noinline)
#define NORETURN __declspec(noreturn) #define NORETURN __declspec(noreturn)
#define UNUSED #define UNUSED
#else #else
#define ALWAYS_INLINE __attribute__((always_inline)) #define ALWAYS_INLINE __attribute__((always_inline))
#define NOINLINE __attribute__((noinline)) #define NOINLINE __attribute__((noinline))
#define NORETURN __attribute__((noreturn)) #define NORETURN __attribute__((noreturn))
#define UNUSED __attribute__((unused)) #define UNUSED __attribute__((unused))
#endif #endif
#if defined(__NetBSD__) && (defined(_KERNEL) || defined(_STANDALONE)) #if defined(__NetBSD__) && (defined(_KERNEL) || defined(_STANDALONE))
/* /*
* Kernel and boot environment can't use normal headers, * Kernel and boot environment can't use normal headers,
* so use the equivalent system headers. * so use the equivalent system headers.
*/ */
# include <machine/limits.h> #include <machine/limits.h>
# include <sys/stdint.h> #include <sys/stdint.h>
# include <sys/types.h> #include <sys/types.h>
#else #else
/* Include the standard compiler builtin headers we use functionality from. */ /* Include the standard compiler builtin headers we use functionality from. */
#include <float.h>
# include <limits.h> #include <limits.h>
# include <stdint.h>
# include <stdbool.h> #include <stdbool.h>
# include <float.h> #include <stdint.h>
#endif #endif
/* Include the commonly used internal type definitions. */ /* Include the commonly used internal type definitions. */
#include "int_types.h" #include "int_types.h"
/* Include internal utility function declarations. */ /* Include internal utility function declarations. */
#include "int_util.h" #include "int_util.h"
COMPILER_RT_ABI si_int __paritysi2(si_int a); COMPILER_RT_ABI si_int __paritysi2(si_int a);
COMPILER_RT_ABI si_int __paritydi2(di_int a); COMPILER_RT_ABI si_int __paritydi2(di_int a);
COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b); COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b); COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d); COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d);
COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int* rem); COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int *rem);
COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem); COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int *rem);
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
COMPILER_RT_ABI si_int __clzti2(ti_int a); COMPILER_RT_ABI si_int __clzti2(ti_int a);
COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem); COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int *rem);
#endif #endif
/* Definitions for builtins unavailable on MSVC */ /* Definitions for builtins unavailable on MSVC */
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#include <intrin.h> #include <intrin.h>
uint32_t __inline __builtin_ctz(uint32_t value) { uint32_t __inline __builtin_ctz(uint32_t value) {
unsigned long trailing_zero = 0; unsigned long trailing_zero = 0;
Show All 35 Lines

compiler-rt/trunk/lib/builtins/int_math.h

Show All 15 Lines
* *
* ===-----------------------------------------------------------------------=== * ===-----------------------------------------------------------------------===
*/ */
#ifndef INT_MATH_H #ifndef INT_MATH_H
#define INT_MATH_H #define INT_MATH_H
#ifndef __has_builtin #ifndef __has_builtin
# define __has_builtin(x) 0 #define __has_builtin(x) 0
#endif #endif
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#endif #endif
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#define CRT_INFINITY INFINITY #define CRT_INFINITY INFINITY
#else #else
#define CRT_INFINITY __builtin_huge_valf() #define CRT_INFINITY __builtin_huge_valf()
#endif #endif
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#define crt_isfinite(x) _finite((x)) #define crt_isfinite(x) _finite((x))
#define crt_isinf(x) !_finite((x)) #define crt_isinf(x) !_finite((x))
#define crt_isnan(x) _isnan((x)) #define crt_isnan(x) _isnan((x))
#else #else
/* Define crt_isfinite in terms of the builtin if available, otherwise provide /* Define crt_isfinite in terms of the builtin if available, otherwise provide
* an alternate version in terms of our other functions. This supports some * an alternate version in terms of our other functions. This supports some
* versions of GCC which didn't have __builtin_isfinite. * versions of GCC which didn't have __builtin_isfinite.
*/ */
#if __has_builtin(__builtin_isfinite) #if __has_builtin(__builtin_isfinite)
# define crt_isfinite(x) __builtin_isfinite((x)) #define crt_isfinite(x) __builtin_isfinite((x))
#elif defined(__GNUC__) #elif defined(__GNUC__)
# define crt_isfinite(x) \ #define crt_isfinite(x) \
__extension__(({ \ __extension__(({ \
__typeof((x)) x_ = (x); \ __typeof((x)) x_ = (x); \
!crt_isinf(x_) && !crt_isnan(x_); \ !crt_isinf(x_) && !crt_isnan(x_); \
})) }))
#else #else
# error "Do not know how to check for infinity" #error "Do not know how to check for infinity"
#endif /* __has_builtin(__builtin_isfinite) */ #endif /* __has_builtin(__builtin_isfinite) */
#define crt_isinf(x) __builtin_isinf((x)) #define crt_isinf(x) __builtin_isinf((x))
#define crt_isnan(x) __builtin_isnan((x)) #define crt_isnan(x) __builtin_isnan((x))
#endif /* _MSC_VER */ #endif /* _MSC_VER */
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#define crt_copysign(x, y) copysign((x), (y)) #define crt_copysign(x, y) copysign((x), (y))
#define crt_copysignf(x, y) copysignf((x), (y)) #define crt_copysignf(x, y) copysignf((x), (y))
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

compiler-rt/trunk/lib/builtins/int_types.h

Show All 17 Lines
#define INT_TYPES_H #define INT_TYPES_H
#include "int_endianness.h" #include "int_endianness.h"
/* si_int is defined in Linux sysroot's asm-generic/siginfo.h */ /* si_int is defined in Linux sysroot's asm-generic/siginfo.h */
#ifdef si_int #ifdef si_int
#undef si_int #undef si_int
#endif #endif
typedef int si_int; typedef int si_int;
typedef unsigned su_int; typedef unsigned su_int;
typedef long long di_int; typedef long long di_int;
typedef unsigned long long du_int; typedef unsigned long long du_int;
typedef union typedef union {
{
di_int all; di_int all;
struct struct {
{
#if _YUGA_LITTLE_ENDIAN #if _YUGA_LITTLE_ENDIAN
su_int low; su_int low;
si_int high; si_int high;
#else #else
si_int high; si_int high;
su_int low; su_int low;
#endif /* _YUGA_LITTLE_ENDIAN */ #endif /* _YUGA_LITTLE_ENDIAN */
}s; } s;
} dwords; } dwords;
typedef union typedef union {
{
du_int all; du_int all;
struct struct {
{
#if _YUGA_LITTLE_ENDIAN #if _YUGA_LITTLE_ENDIAN
su_int low; su_int low;
su_int high; su_int high;
#else #else
su_int high; su_int high;
su_int low; su_int low;
#endif /* _YUGA_LITTLE_ENDIAN */ #endif /* _YUGA_LITTLE_ENDIAN */
}s; } s;
} udwords; } udwords;
#if defined(__LP64__) || defined(__wasm__) || defined(__mips64) || \ #if defined(__LP64__) || defined(__wasm__) || defined(__mips64) || \
defined(__riscv) || defined(_WIN64) defined(__riscv) || defined(_WIN64)
#define CRT_HAS_128BIT #define CRT_HAS_128BIT
#endif #endif
/* MSVC doesn't have a working 128bit integer type. Users should really compile /* MSVC doesn't have a working 128bit integer type. Users should really compile
* compiler-rt with clang, but if they happen to be doing a standalone build for * compiler-rt with clang, but if they happen to be doing a standalone build for
* asan or something else, disable the 128 bit parts so things sort of work. * asan or something else, disable the 128 bit parts so things sort of work.
*/ */
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#undef CRT_HAS_128BIT #undef CRT_HAS_128BIT
#endif #endif
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
typedef int ti_int __attribute__ ((mode (TI))); typedef int ti_int __attribute__((mode(TI)));
typedef unsigned tu_int __attribute__ ((mode (TI))); typedef unsigned tu_int __attribute__((mode(TI)));
typedef union typedef union {
{
ti_int all; ti_int all;
struct struct {
{
#if _YUGA_LITTLE_ENDIAN #if _YUGA_LITTLE_ENDIAN
du_int low; du_int low;
di_int high; di_int high;
#else #else
di_int high; di_int high;
du_int low; du_int low;
#endif /* _YUGA_LITTLE_ENDIAN */ #endif /* _YUGA_LITTLE_ENDIAN */
}s; } s;
} twords; } twords;
typedef union typedef union {
{
tu_int all; tu_int all;
struct struct {
{
#if _YUGA_LITTLE_ENDIAN #if _YUGA_LITTLE_ENDIAN
du_int low; du_int low;
du_int high; du_int high;
#else #else
du_int high; du_int high;
du_int low; du_int low;
#endif /* _YUGA_LITTLE_ENDIAN */ #endif /* _YUGA_LITTLE_ENDIAN */
}s; } s;
} utwords; } utwords;
static __inline ti_int make_ti(di_int h, di_int l) { static __inline ti_int make_ti(di_int h, di_int l) {
twords r; twords r;
r.s.high = h; r.s.high = h;
r.s.low = l; r.s.low = l;
return r.all; return r.all;
} }
static __inline tu_int make_tu(du_int h, du_int l) { static __inline tu_int make_tu(du_int h, du_int l) {
utwords r; utwords r;
r.s.high = h; r.s.high = h;
r.s.low = l; r.s.low = l;
return r.all; return r.all;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */
typedef union typedef union {
{
su_int u; su_int u;
float f; float f;
} float_bits; } float_bits;
typedef union typedef union {
{
udwords u; udwords u;
double f; double f;
} double_bits; } double_bits;
typedef struct typedef struct {
{
#if _YUGA_LITTLE_ENDIAN #if _YUGA_LITTLE_ENDIAN
udwords low; udwords low;
udwords high; udwords high;
#else #else
udwords high; udwords high;
udwords low; udwords low;
#endif /* _YUGA_LITTLE_ENDIAN */ #endif /* _YUGA_LITTLE_ENDIAN */
} uqwords; } uqwords;
/* Check if the target supports 80 bit extended precision long doubles. /* Check if the target supports 80 bit extended precision long doubles.
* Notably, on x86 Windows, MSVC only provides a 64-bit long double, but GCC * Notably, on x86 Windows, MSVC only provides a 64-bit long double, but GCC
* still makes it 80 bits. Clang will match whatever compiler it is trying to * still makes it 80 bits. Clang will match whatever compiler it is trying to
* be compatible with. * be compatible with.
*/ */
#if ((defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER)) || \ #if ((defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER)) || \
defined(__m68k__) || defined(__ia64__) defined(__m68k__) || defined(__ia64__)
#define HAS_80_BIT_LONG_DOUBLE 1 #define HAS_80_BIT_LONG_DOUBLE 1
#else #else
#define HAS_80_BIT_LONG_DOUBLE 0 #define HAS_80_BIT_LONG_DOUBLE 0
#endif #endif
typedef union typedef union {
{
uqwords u; uqwords u;
long double f; long double f;
} long_double_bits; } long_double_bits;
#if __STDC_VERSION__ >= 199901L #if __STDC_VERSION__ >= 199901L
typedef float _Complex Fcomplex; typedef float _Complex Fcomplex;
typedef double _Complex Dcomplex; typedef double _Complex Dcomplex;
typedef long double _Complex Lcomplex; typedef long double _Complex Lcomplex;
#define COMPLEX_REAL(x) __real__(x) #define COMPLEX_REAL(x) __real__(x)
#define COMPLEX_IMAGINARY(x) __imag__(x) #define COMPLEX_IMAGINARY(x) __imag__(x)
#else #else
typedef struct { float real, imaginary; } Fcomplex; typedef struct {
float real, imaginary;
typedef struct { double real, imaginary; } Dcomplex; } Fcomplex;
typedef struct { long double real, imaginary; } Lcomplex; typedef struct {
double real, imaginary;
} Dcomplex;
typedef struct {
long double real, imaginary;
} Lcomplex;
#define COMPLEX_REAL(x) (x).real #define COMPLEX_REAL(x) (x).real
#define COMPLEX_IMAGINARY(x) (x).imaginary #define COMPLEX_IMAGINARY(x) (x).imaginary
#endif #endif
#endif /* INT_TYPES_H */ #endif /* INT_TYPES_H */

compiler-rt/trunk/lib/builtins/int_util.c

/* ===-- int_util.c - Implement internal utilities --------------------------=== /* ===-- int_util.c - Implement internal utilities --------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#include "int_util.h"
/* NOTE: The definitions in this file are declared weak because we clients to be /* NOTE: The definitions in this file are declared weak because we clients to be
* able to arbitrarily package individual functions into separate .a files. If * able to arbitrarily package individual functions into separate .a files. If
* we did not declare these weak, some link situations might end up seeing * we did not declare these weak, some link situations might end up seeing
* duplicate strong definitions of the same symbol. * duplicate strong definitions of the same symbol.
* *
* We can't use this solution for kernel use (which may not support weak), but * We can't use this solution for kernel use (which may not support weak), but
* currently expect that when built for kernel use all the functionality is * currently expect that when built for kernel use all the functionality is
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

compiler-rt/trunk/lib/builtins/lshrdi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: logical a >> b */ /* Returns: logical a >> b */
/* Precondition: 0 <= b < bits_in_dword */ /* Precondition: 0 <= b < bits_in_dword */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __lshrdi3(di_int a, si_int b) {
__lshrdi3(di_int a, si_int b)
{
const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT); const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);
udwords input; udwords input;
udwords result; udwords result;
input.all = a; input.all = a;
if (b & bits_in_word) /* bits_in_word <= b < bits_in_dword */ if (b & bits_in_word) /* bits_in_word <= b < bits_in_dword */
{ {
result.s.high = 0; result.s.high = 0;
result.s.low = input.s.high >> (b - bits_in_word); result.s.low = input.s.high >> (b - bits_in_word);
} } else /* 0 <= b < bits_in_word */
else /* 0 <= b < bits_in_word */
{ {
if (b == 0) if (b == 0)
return a; return a;
result.s.high = input.s.high >> b; result.s.high = input.s.high >> b;
result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b); result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b);
} }
return result.all; return result.all;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI di_int __aeabi_llsr(di_int a, si_int b) COMPILER_RT_ALIAS(__lshrdi3); AEABI_RTABI di_int __aeabi_llsr(di_int a, si_int b)
COMPILER_RT_ALIAS(__lshrdi3);
#endif #endif

compiler-rt/trunk/lib/builtins/lshrti3.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: logical a >> b */ /* Returns: logical a >> b */
/* Precondition: 0 <= b < bits_in_tword */ /* Precondition: 0 <= b < bits_in_tword */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __lshrti3(ti_int a, si_int b) {
__lshrti3(ti_int a, si_int b)
{
const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT); const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
utwords input; utwords input;
utwords result; utwords result;
input.all = a; input.all = a;
if (b & bits_in_dword) /* bits_in_dword <= b < bits_in_tword */ if (b & bits_in_dword) /* bits_in_dword <= b < bits_in_tword */
{ {
result.s.high = 0; result.s.high = 0;
result.s.low = input.s.high >> (b - bits_in_dword); result.s.low = input.s.high >> (b - bits_in_dword);
} } else /* 0 <= b < bits_in_dword */
else /* 0 <= b < bits_in_dword */
{ {
if (b == 0) if (b == 0)
return a; return a;
result.s.high = input.s.high >> b; result.s.high = input.s.high >> b;
result.s.low = (input.s.high << (bits_in_dword - b)) | (input.s.low >> b); result.s.low = (input.s.high << (bits_in_dword - b)) | (input.s.low >> b);
} }
return result.all; return result.all;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/moddi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ /* Returns: a % b */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __moddi3(di_int a, di_int b) {
__moddi3(di_int a, di_int b)
{
const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1; const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1;
di_int s = b >> bits_in_dword_m1; /* s = b < 0 ? -1 : 0 */ di_int s = b >> bits_in_dword_m1; /* s = b < 0 ? -1 : 0 */
b = (b ^ s) - s; /* negate if s == -1 */ b = (b ^ s) - s; /* negate if s == -1 */
s = a >> bits_in_dword_m1; /* s = a < 0 ? -1 : 0 */ s = a >> bits_in_dword_m1; /* s = a < 0 ? -1 : 0 */
a = (a ^ s) - s; /* negate if s == -1 */ a = (a ^ s) - s; /* negate if s == -1 */
du_int r; du_int r;
__udivmoddi4(a, b, &r); __udivmoddi4(a, b, &r);
return ((di_int)r ^ s) - s; /* negate if s == -1 */ return ((di_int)r ^ s) - s; /* negate if s == -1 */
} }

compiler-rt/trunk/lib/builtins/modsi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ /* Returns: a % b */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __modsi3(si_int a, si_int b) {
__modsi3(si_int a, si_int b)
{
return a - __divsi3(a, b) * b; return a - __divsi3(a, b) * b;
} }

compiler-rt/trunk/lib/builtins/modti3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/*Returns: a % b */ /*Returns: a % b */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __modti3(ti_int a, ti_int b) {
__modti3(ti_int a, ti_int b)
{
const int bits_in_tword_m1 = (int)(sizeof(ti_int) * CHAR_BIT) - 1; const int bits_in_tword_m1 = (int)(sizeof(ti_int) * CHAR_BIT) - 1;
ti_int s = b >> bits_in_tword_m1; /* s = b < 0 ? -1 : 0 */ ti_int s = b >> bits_in_tword_m1; /* s = b < 0 ? -1 : 0 */
b = (b ^ s) - s; /* negate if s == -1 */ b = (b ^ s) - s; /* negate if s == -1 */
s = a >> bits_in_tword_m1; /* s = a < 0 ? -1 : 0 */ s = a >> bits_in_tword_m1; /* s = a < 0 ? -1 : 0 */
a = (a ^ s) - s; /* negate if s == -1 */ a = (a ^ s) - s; /* negate if s == -1 */
tu_int r; tu_int r;
__udivmodti4(a, b, &r); __udivmodti4(a, b, &r);
return ((ti_int)r ^ s) - s; /* negate if s == -1 */ return ((ti_int)r ^ s) - s; /* negate if s == -1 */
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/muldc3.c

Show All 10 Lines
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the product of a + ib and c + id */ /* Returns: the product of a + ib and c + id */
COMPILER_RT_ABI Dcomplex COMPILER_RT_ABI Dcomplex __muldc3(double __a, double __b, double __c,
__muldc3(double __a, double __b, double __c, double __d) double __d) {
{
double __ac = __a * __c; double __ac = __a * __c;
double __bd = __b * __d; double __bd = __b * __d;
double __ad = __a * __d; double __ad = __a * __d;
double __bc = __b * __c; double __bc = __b * __c;
Dcomplex z; Dcomplex z;
COMPLEX_REAL(z) = __ac - __bd; COMPLEX_REAL(z) = __ac - __bd;
COMPLEX_IMAGINARY(z) = __ad + __bc; COMPLEX_IMAGINARY(z) = __ad + __bc;
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
{
int __recalc = 0; int __recalc = 0;
if (crt_isinf(__a) || crt_isinf(__b)) if (crt_isinf(__a) || crt_isinf(__b)) {
{
__a = crt_copysign(crt_isinf(__a) ? 1 : 0, __a); __a = crt_copysign(crt_isinf(__a) ? 1 : 0, __a);
__b = crt_copysign(crt_isinf(__b) ? 1 : 0, __b); __b = crt_copysign(crt_isinf(__b) ? 1 : 0, __b);
if (crt_isnan(__c)) if (crt_isnan(__c))
__c = crt_copysign(0, __c); __c = crt_copysign(0, __c);
if (crt_isnan(__d)) if (crt_isnan(__d))
__d = crt_copysign(0, __d); __d = crt_copysign(0, __d);
__recalc = 1; __recalc = 1;
} }
if (crt_isinf(__c) || crt_isinf(__d)) if (crt_isinf(__c) || crt_isinf(__d)) {
{
__c = crt_copysign(crt_isinf(__c) ? 1 : 0, __c); __c = crt_copysign(crt_isinf(__c) ? 1 : 0, __c);
__d = crt_copysign(crt_isinf(__d) ? 1 : 0, __d); __d = crt_copysign(crt_isinf(__d) ? 1 : 0, __d);
if (crt_isnan(__a)) if (crt_isnan(__a))
__a = crt_copysign(0, __a); __a = crt_copysign(0, __a);
if (crt_isnan(__b)) if (crt_isnan(__b))
__b = crt_copysign(0, __b); __b = crt_copysign(0, __b);
__recalc = 1; __recalc = 1;
} }
if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) || if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) || crt_isinf(__ad) ||
crt_isinf(__ad) || crt_isinf(__bc))) crt_isinf(__bc))) {
{
if (crt_isnan(__a)) if (crt_isnan(__a))
__a = crt_copysign(0, __a); __a = crt_copysign(0, __a);
if (crt_isnan(__b)) if (crt_isnan(__b))
__b = crt_copysign(0, __b); __b = crt_copysign(0, __b);
if (crt_isnan(__c)) if (crt_isnan(__c))
__c = crt_copysign(0, __c); __c = crt_copysign(0, __c);
if (crt_isnan(__d)) if (crt_isnan(__d))
__d = crt_copysign(0, __d); __d = crt_copysign(0, __d);
__recalc = 1; __recalc = 1;
} }
if (__recalc) if (__recalc) {
{
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
} }
} }
return z; return z;
} }

compiler-rt/trunk/lib/builtins/muldf3.c

//===-- lib/muldf3.c - Double-precision multiplication ------------*- C -*-===// //===-- lib/muldf3.c - Double-precision multiplication ------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements double-precision soft-float multiplication // This file implements double-precision soft-float multiplication
// with the IEEE-754 default rounding (to nearest, ties to even). // with the IEEE-754 default rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_mul_impl.inc" #include "fp_mul_impl.inc"
COMPILER_RT_ABI fp_t __muldf3(fp_t a, fp_t b) { COMPILER_RT_ABI fp_t __muldf3(fp_t a, fp_t b) { return __mulXf3__(a, b); }
return __mulXf3__(a, b);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) { AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) { return __muldf3(a, b); }
return __muldf3(a, b);
}
#else #else
AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) COMPILER_RT_ALIAS(__muldf3); AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) COMPILER_RT_ALIAS(__muldf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/muldi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a * b */ /* Returns: a * b */
static static di_int __muldsi3(su_int a, su_int b) {
di_int
__muldsi3(su_int a, su_int b)
{
dwords r; dwords r;
const int bits_in_word_2 = (int)(sizeof(si_int) * CHAR_BIT) / 2; const int bits_in_word_2 = (int)(sizeof(si_int) * CHAR_BIT) / 2;
const su_int lower_mask = (su_int)~0 >> bits_in_word_2; const su_int lower_mask = (su_int)~0 >> bits_in_word_2;
r.s.low = (a & lower_mask) * (b & lower_mask); r.s.low = (a & lower_mask) * (b & lower_mask);
su_int t = r.s.low >> bits_in_word_2; su_int t = r.s.low >> bits_in_word_2;
r.s.low &= lower_mask; r.s.low &= lower_mask;
t += (a >> bits_in_word_2) * (b & lower_mask); t += (a >> bits_in_word_2) * (b & lower_mask);
r.s.low += (t & lower_mask) << bits_in_word_2; r.s.low += (t & lower_mask) << bits_in_word_2;
r.s.high = t >> bits_in_word_2; r.s.high = t >> bits_in_word_2;
t = r.s.low >> bits_in_word_2; t = r.s.low >> bits_in_word_2;
r.s.low &= lower_mask; r.s.low &= lower_mask;
t += (b >> bits_in_word_2) * (a & lower_mask); t += (b >> bits_in_word_2) * (a & lower_mask);
r.s.low += (t & lower_mask) << bits_in_word_2; r.s.low += (t & lower_mask) << bits_in_word_2;
r.s.high += t >> bits_in_word_2; r.s.high += t >> bits_in_word_2;
r.s.high += (a >> bits_in_word_2) * (b >> bits_in_word_2); r.s.high += (a >> bits_in_word_2) * (b >> bits_in_word_2);
return r.all; return r.all;
} }
/* Returns: a * b */ /* Returns: a * b */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __muldi3(di_int a, di_int b) {
__muldi3(di_int a, di_int b)
{
dwords x; dwords x;
x.all = a; x.all = a;
dwords y; dwords y;
y.all = b; y.all = b;
dwords r; dwords r;
r.all = __muldsi3(x.s.low, y.s.low); r.all = __muldsi3(x.s.low, y.s.low);
r.s.high += x.s.high * y.s.low + x.s.low * y.s.high; r.s.high += x.s.high * y.s.low + x.s.low * y.s.high;
return r.all; return r.all;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI di_int __aeabi_lmul(di_int a, di_int b) COMPILER_RT_ALIAS(__muldi3); AEABI_RTABI di_int __aeabi_lmul(di_int a, di_int b) COMPILER_RT_ALIAS(__muldi3);
#endif #endif

compiler-rt/trunk/lib/builtins/mulodi4.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a * b */ /* Returns: a * b */
/* Effects: sets *overflow to 1 if a * b overflows */ /* Effects: sets *overflow to 1 if a * b overflows */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int *overflow) {
__mulodi4(di_int a, di_int b, int* overflow)
{
const int N = (int)(sizeof(di_int) * CHAR_BIT); const int N = (int)(sizeof(di_int) * CHAR_BIT);
const di_int MIN = (di_int)1 << (N-1); const di_int MIN = (di_int)1 << (N - 1);
const di_int MAX = ~MIN; const di_int MAX = ~MIN;
*overflow = 0; *overflow = 0;
di_int result = a * b; di_int result = a * b;
if (a == MIN) if (a == MIN) {
{
if (b != 0 && b != 1) if (b != 0 && b != 1)
*overflow = 1; *overflow = 1;
return result; return result;
} }
if (b == MIN) if (b == MIN) {
{
if (a != 0 && a != 1) if (a != 0 && a != 1)
*overflow = 1; *overflow = 1;
return result; return result;
} }
di_int sa = a >> (N - 1); di_int sa = a >> (N - 1);
di_int abs_a = (a ^ sa) - sa; di_int abs_a = (a ^ sa) - sa;
di_int sb = b >> (N - 1); di_int sb = b >> (N - 1);
di_int abs_b = (b ^ sb) - sb; di_int abs_b = (b ^ sb) - sb;
if (abs_a < 2 || abs_b < 2) if (abs_a < 2 || abs_b < 2)
return result; return result;
if (sa == sb) if (sa == sb) {
{
if (abs_a > MAX / abs_b) if (abs_a > MAX / abs_b)
*overflow = 1; *overflow = 1;
} } else {
else
{
if (abs_a > MIN / -abs_b) if (abs_a > MIN / -abs_b)
*overflow = 1; *overflow = 1;
} }
return result; return result;
} }

compiler-rt/trunk/lib/builtins/mulosi4.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a * b */ /* Returns: a * b */
/* Effects: sets *overflow to 1 if a * b overflows */ /* Effects: sets *overflow to 1 if a * b overflows */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __mulosi4(si_int a, si_int b, int *overflow) {
__mulosi4(si_int a, si_int b, int* overflow)
{
const int N = (int)(sizeof(si_int) * CHAR_BIT); const int N = (int)(sizeof(si_int) * CHAR_BIT);
const si_int MIN = (si_int)1 << (N-1); const si_int MIN = (si_int)1 << (N - 1);
const si_int MAX = ~MIN; const si_int MAX = ~MIN;
*overflow = 0; *overflow = 0;
si_int result = a * b; si_int result = a * b;
if (a == MIN) if (a == MIN) {
{
if (b != 0 && b != 1) if (b != 0 && b != 1)
*overflow = 1; *overflow = 1;
return result; return result;
} }
if (b == MIN) if (b == MIN) {
{
if (a != 0 && a != 1) if (a != 0 && a != 1)
*overflow = 1; *overflow = 1;
return result; return result;
} }
si_int sa = a >> (N - 1); si_int sa = a >> (N - 1);
si_int abs_a = (a ^ sa) - sa; si_int abs_a = (a ^ sa) - sa;
si_int sb = b >> (N - 1); si_int sb = b >> (N - 1);
si_int abs_b = (b ^ sb) - sb; si_int abs_b = (b ^ sb) - sb;
if (abs_a < 2 || abs_b < 2) if (abs_a < 2 || abs_b < 2)
return result; return result;
if (sa == sb) if (sa == sb) {
{
if (abs_a > MAX / abs_b) if (abs_a > MAX / abs_b)
*overflow = 1; *overflow = 1;
} } else {
else
{
if (abs_a > MIN / -abs_b) if (abs_a > MIN / -abs_b)
*overflow = 1; *overflow = 1;
} }
return result; return result;
} }

compiler-rt/trunk/lib/builtins/muloti4.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a * b */ /* Returns: a * b */
/* Effects: sets *overflow to 1 if a * b overflows */ /* Effects: sets *overflow to 1 if a * b overflows */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __muloti4(ti_int a, ti_int b, int *overflow) {
__muloti4(ti_int a, ti_int b, int* overflow)
{
const int N = (int)(sizeof(ti_int) * CHAR_BIT); const int N = (int)(sizeof(ti_int) * CHAR_BIT);
const ti_int MIN = (ti_int)1 << (N-1); const ti_int MIN = (ti_int)1 << (N - 1);
const ti_int MAX = ~MIN; const ti_int MAX = ~MIN;
*overflow = 0; *overflow = 0;
ti_int result = a * b; ti_int result = a * b;
if (a == MIN) if (a == MIN) {
{
if (b != 0 && b != 1) if (b != 0 && b != 1)
*overflow = 1; *overflow = 1;
return result; return result;
} }
if (b == MIN) if (b == MIN) {
{
if (a != 0 && a != 1) if (a != 0 && a != 1)
*overflow = 1; *overflow = 1;
return result; return result;
} }
ti_int sa = a >> (N - 1); ti_int sa = a >> (N - 1);
ti_int abs_a = (a ^ sa) - sa; ti_int abs_a = (a ^ sa) - sa;
ti_int sb = b >> (N - 1); ti_int sb = b >> (N - 1);
ti_int abs_b = (b ^ sb) - sb; ti_int abs_b = (b ^ sb) - sb;
if (abs_a < 2 || abs_b < 2) if (abs_a < 2 || abs_b < 2)
return result; return result;
if (sa == sb) if (sa == sb) {
{
if (abs_a > MAX / abs_b) if (abs_a > MAX / abs_b)
*overflow = 1; *overflow = 1;
} } else {
else
{
if (abs_a > MIN / -abs_b) if (abs_a > MIN / -abs_b)
*overflow = 1; *overflow = 1;
} }
return result; return result;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/mulsc3.c

Show All 10 Lines
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the product of a + ib and c + id */ /* Returns: the product of a + ib and c + id */
COMPILER_RT_ABI Fcomplex COMPILER_RT_ABI Fcomplex __mulsc3(float __a, float __b, float __c, float __d) {
__mulsc3(float __a, float __b, float __c, float __d)
{
float __ac = __a * __c; float __ac = __a * __c;
float __bd = __b * __d; float __bd = __b * __d;
float __ad = __a * __d; float __ad = __a * __d;
float __bc = __b * __c; float __bc = __b * __c;
Fcomplex z; Fcomplex z;
COMPLEX_REAL(z) = __ac - __bd; COMPLEX_REAL(z) = __ac - __bd;
COMPLEX_IMAGINARY(z) = __ad + __bc; COMPLEX_IMAGINARY(z) = __ad + __bc;
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
{
int __recalc = 0; int __recalc = 0;
if (crt_isinf(__a) || crt_isinf(__b)) if (crt_isinf(__a) || crt_isinf(__b)) {
{
__a = crt_copysignf(crt_isinf(__a) ? 1 : 0, __a); __a = crt_copysignf(crt_isinf(__a) ? 1 : 0, __a);
__b = crt_copysignf(crt_isinf(__b) ? 1 : 0, __b); __b = crt_copysignf(crt_isinf(__b) ? 1 : 0, __b);
if (crt_isnan(__c)) if (crt_isnan(__c))
__c = crt_copysignf(0, __c); __c = crt_copysignf(0, __c);
if (crt_isnan(__d)) if (crt_isnan(__d))
__d = crt_copysignf(0, __d); __d = crt_copysignf(0, __d);
__recalc = 1; __recalc = 1;
} }
if (crt_isinf(__c) || crt_isinf(__d)) if (crt_isinf(__c) || crt_isinf(__d)) {
{
__c = crt_copysignf(crt_isinf(__c) ? 1 : 0, __c); __c = crt_copysignf(crt_isinf(__c) ? 1 : 0, __c);
__d = crt_copysignf(crt_isinf(__d) ? 1 : 0, __d); __d = crt_copysignf(crt_isinf(__d) ? 1 : 0, __d);
if (crt_isnan(__a)) if (crt_isnan(__a))
__a = crt_copysignf(0, __a); __a = crt_copysignf(0, __a);
if (crt_isnan(__b)) if (crt_isnan(__b))
__b = crt_copysignf(0, __b); __b = crt_copysignf(0, __b);
__recalc = 1; __recalc = 1;
} }
if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) || if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) || crt_isinf(__ad) ||
crt_isinf(__ad) || crt_isinf(__bc))) crt_isinf(__bc))) {
{
if (crt_isnan(__a)) if (crt_isnan(__a))
__a = crt_copysignf(0, __a); __a = crt_copysignf(0, __a);
if (crt_isnan(__b)) if (crt_isnan(__b))
__b = crt_copysignf(0, __b); __b = crt_copysignf(0, __b);
if (crt_isnan(__c)) if (crt_isnan(__c))
__c = crt_copysignf(0, __c); __c = crt_copysignf(0, __c);
if (crt_isnan(__d)) if (crt_isnan(__d))
__d = crt_copysignf(0, __d); __d = crt_copysignf(0, __d);
__recalc = 1; __recalc = 1;
} }
if (__recalc) if (__recalc) {
{
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
} }
} }
return z; return z;
} }

compiler-rt/trunk/lib/builtins/mulsf3.c

//===-- lib/mulsf3.c - Single-precision multiplication ------------*- C -*-===// //===-- lib/mulsf3.c - Single-precision multiplication ------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements single-precision soft-float multiplication // This file implements single-precision soft-float multiplication
// with the IEEE-754 default rounding (to nearest, ties to even). // with the IEEE-754 default rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_mul_impl.inc" #include "fp_mul_impl.inc"
COMPILER_RT_ABI fp_t __mulsf3(fp_t a, fp_t b) { COMPILER_RT_ABI fp_t __mulsf3(fp_t a, fp_t b) { return __mulXf3__(a, b); }
return __mulXf3__(a, b);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) { AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) { return __mulsf3(a, b); }
return __mulsf3(a, b);
}
#else #else
AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) COMPILER_RT_ALIAS(__mulsf3); AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) COMPILER_RT_ALIAS(__mulsf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/multc3.c

Show All 10 Lines
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the product of a + ib and c + id */ /* Returns: the product of a + ib and c + id */
COMPILER_RT_ABI long double _Complex COMPILER_RT_ABI long double _Complex __multc3(long double a, long double b,
__multc3(long double a, long double b, long double c, long double d) long double c, long double d) {
{
long double ac = a * c; long double ac = a * c;
long double bd = b * d; long double bd = b * d;
long double ad = a * d; long double ad = a * d;
long double bc = b * c; long double bc = b * c;
long double _Complex z; long double _Complex z;
__real__ z = ac - bd; __real__ z = ac - bd;
__imag__ z = ad + bc; __imag__ z = ad + bc;
if (crt_isnan(__real__ z) && crt_isnan(__imag__ z)) { if (crt_isnan(__real__ z) && crt_isnan(__imag__ z)) {
int recalc = 0; int recalc = 0;
if (crt_isinf(a) || crt_isinf(b)) { if (crt_isinf(a) || crt_isinf(b)) {
a = crt_copysignl(crt_isinf(a) ? 1 : 0, a); a = crt_copysignl(crt_isinf(a) ? 1 : 0, a);
b = crt_copysignl(crt_isinf(b) ? 1 : 0, b); b = crt_copysignl(crt_isinf(b) ? 1 : 0, b);
if (crt_isnan(c)) if (crt_isnan(c))
c = crt_copysignl(0, c); c = crt_copysignl(0, c);
if (crt_isnan(d)) if (crt_isnan(d))
d = crt_copysignl(0, d); d = crt_copysignl(0, d);
recalc = 1; recalc = 1;
} }
if (crt_isinf(c) || crt_isinf(d)) { if (crt_isinf(c) || crt_isinf(d)) {
c = crt_copysignl(crt_isinf(c) ? 1 : 0, c); c = crt_copysignl(crt_isinf(c) ? 1 : 0, c);
d = crt_copysignl(crt_isinf(d) ? 1 : 0, d); d = crt_copysignl(crt_isinf(d) ? 1 : 0, d);
if (crt_isnan(a)) if (crt_isnan(a))
a = crt_copysignl(0, a); a = crt_copysignl(0, a);
if (crt_isnan(b)) if (crt_isnan(b))
b = crt_copysignl(0, b); b = crt_copysignl(0, b);
recalc = 1; recalc = 1;
} }
if (!recalc && (crt_isinf(ac) || crt_isinf(bd) || if (!recalc &&
crt_isinf(ad) || crt_isinf(bc))) { (crt_isinf(ac) || crt_isinf(bd) || crt_isinf(ad) || crt_isinf(bc))) {
if (crt_isnan(a)) if (crt_isnan(a))
a = crt_copysignl(0, a); a = crt_copysignl(0, a);
if (crt_isnan(b)) if (crt_isnan(b))
b = crt_copysignl(0, b); b = crt_copysignl(0, b);
if (crt_isnan(c)) if (crt_isnan(c))
c = crt_copysignl(0, c); c = crt_copysignl(0, c);
if (crt_isnan(d)) if (crt_isnan(d))
d = crt_copysignl(0, d); d = crt_copysignl(0, d);
recalc = 1; recalc = 1;
} }
if (recalc) { if (recalc) {
__real__ z = CRT_INFINITY * (a * c - b * d); __real__ z = CRT_INFINITY * (a * c - b * d);
__imag__ z = CRT_INFINITY * (a * d + b * c); __imag__ z = CRT_INFINITY * (a * d + b * c);
} }
} }
return z; return z;
} }

compiler-rt/trunk/lib/builtins/multf3.c

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#include "fp_mul_impl.inc" #include "fp_mul_impl.inc"
COMPILER_RT_ABI fp_t __multf3(fp_t a, fp_t b) { COMPILER_RT_ABI fp_t __multf3(fp_t a, fp_t b) { return __mulXf3__(a, b); }
return __mulXf3__(a, b);
}
#endif #endif

compiler-rt/trunk/lib/builtins/multi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a * b */ /* Returns: a * b */
static static ti_int __mulddi3(du_int a, du_int b) {
ti_int
__mulddi3(du_int a, du_int b)
{
twords r; twords r;
const int bits_in_dword_2 = (int)(sizeof(di_int) * CHAR_BIT) / 2; const int bits_in_dword_2 = (int)(sizeof(di_int) * CHAR_BIT) / 2;
const du_int lower_mask = (du_int)~0 >> bits_in_dword_2; const du_int lower_mask = (du_int)~0 >> bits_in_dword_2;
r.s.low = (a & lower_mask) * (b & lower_mask); r.s.low = (a & lower_mask) * (b & lower_mask);
du_int t = r.s.low >> bits_in_dword_2; du_int t = r.s.low >> bits_in_dword_2;
r.s.low &= lower_mask; r.s.low &= lower_mask;
t += (a >> bits_in_dword_2) * (b & lower_mask); t += (a >> bits_in_dword_2) * (b & lower_mask);
r.s.low += (t & lower_mask) << bits_in_dword_2; r.s.low += (t & lower_mask) << bits_in_dword_2;
r.s.high = t >> bits_in_dword_2; r.s.high = t >> bits_in_dword_2;
t = r.s.low >> bits_in_dword_2; t = r.s.low >> bits_in_dword_2;
r.s.low &= lower_mask; r.s.low &= lower_mask;
t += (b >> bits_in_dword_2) * (a & lower_mask); t += (b >> bits_in_dword_2) * (a & lower_mask);
r.s.low += (t & lower_mask) << bits_in_dword_2; r.s.low += (t & lower_mask) << bits_in_dword_2;
r.s.high += t >> bits_in_dword_2; r.s.high += t >> bits_in_dword_2;
r.s.high += (a >> bits_in_dword_2) * (b >> bits_in_dword_2); r.s.high += (a >> bits_in_dword_2) * (b >> bits_in_dword_2);
return r.all; return r.all;
} }
/* Returns: a * b */ /* Returns: a * b */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __multi3(ti_int a, ti_int b) {
__multi3(ti_int a, ti_int b)
{
twords x; twords x;
x.all = a; x.all = a;
twords y; twords y;
y.all = b; y.all = b;
twords r; twords r;
r.all = __mulddi3(x.s.low, y.s.low); r.all = __mulddi3(x.s.low, y.s.low);
r.s.high += x.s.high * y.s.low + x.s.low * y.s.high; r.s.high += x.s.high * y.s.low + x.s.low * y.s.high;
return r.all; return r.all;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/mulvdi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a * b */ /* Returns: a * b */
/* Effects: aborts if a * b overflows */ /* Effects: aborts if a * b overflows */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __mulvdi3(di_int a, di_int b) {
__mulvdi3(di_int a, di_int b)
{
const int N = (int)(sizeof(di_int) * CHAR_BIT); const int N = (int)(sizeof(di_int) * CHAR_BIT);
const di_int MIN = (di_int)1 << (N-1); const di_int MIN = (di_int)1 << (N - 1);
const di_int MAX = ~MIN; const di_int MAX = ~MIN;
if (a == MIN) if (a == MIN) {
{
if (b == 0 || b == 1) if (b == 0 || b == 1)
return a * b; return a * b;
compilerrt_abort(); compilerrt_abort();
} }
if (b == MIN) if (b == MIN) {
{
if (a == 0 || a == 1) if (a == 0 || a == 1)
return a * b; return a * b;
compilerrt_abort(); compilerrt_abort();
} }
di_int sa = a >> (N - 1); di_int sa = a >> (N - 1);
di_int abs_a = (a ^ sa) - sa; di_int abs_a = (a ^ sa) - sa;
di_int sb = b >> (N - 1); di_int sb = b >> (N - 1);
di_int abs_b = (b ^ sb) - sb; di_int abs_b = (b ^ sb) - sb;
if (abs_a < 2 || abs_b < 2) if (abs_a < 2 || abs_b < 2)
return a * b; return a * b;
if (sa == sb) if (sa == sb) {
{
if (abs_a > MAX / abs_b) if (abs_a > MAX / abs_b)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (abs_a > MIN / -abs_b) if (abs_a > MIN / -abs_b)
compilerrt_abort(); compilerrt_abort();
} }
return a * b; return a * b;
} }

compiler-rt/trunk/lib/builtins/mulvsi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a * b */ /* Returns: a * b */
/* Effects: aborts if a * b overflows */ /* Effects: aborts if a * b overflows */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __mulvsi3(si_int a, si_int b) {
__mulvsi3(si_int a, si_int b)
{
const int N = (int)(sizeof(si_int) * CHAR_BIT); const int N = (int)(sizeof(si_int) * CHAR_BIT);
const si_int MIN = (si_int)1 << (N-1); const si_int MIN = (si_int)1 << (N - 1);
const si_int MAX = ~MIN; const si_int MAX = ~MIN;
if (a == MIN) if (a == MIN) {
{
if (b == 0 || b == 1) if (b == 0 || b == 1)
return a * b; return a * b;
compilerrt_abort(); compilerrt_abort();
} }
if (b == MIN) if (b == MIN) {
{
if (a == 0 || a == 1) if (a == 0 || a == 1)
return a * b; return a * b;
compilerrt_abort(); compilerrt_abort();
} }
si_int sa = a >> (N - 1); si_int sa = a >> (N - 1);
si_int abs_a = (a ^ sa) - sa; si_int abs_a = (a ^ sa) - sa;
si_int sb = b >> (N - 1); si_int sb = b >> (N - 1);
si_int abs_b = (b ^ sb) - sb; si_int abs_b = (b ^ sb) - sb;
if (abs_a < 2 || abs_b < 2) if (abs_a < 2 || abs_b < 2)
return a * b; return a * b;
if (sa == sb) if (sa == sb) {
{
if (abs_a > MAX / abs_b) if (abs_a > MAX / abs_b)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (abs_a > MIN / -abs_b) if (abs_a > MIN / -abs_b)
compilerrt_abort(); compilerrt_abort();
} }
return a * b; return a * b;
} }

compiler-rt/trunk/lib/builtins/mulvti3.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a * b */ /* Returns: a * b */
/* Effects: aborts if a * b overflows */ /* Effects: aborts if a * b overflows */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __mulvti3(ti_int a, ti_int b) {
__mulvti3(ti_int a, ti_int b)
{
const int N = (int)(sizeof(ti_int) * CHAR_BIT); const int N = (int)(sizeof(ti_int) * CHAR_BIT);
const ti_int MIN = (ti_int)1 << (N-1); const ti_int MIN = (ti_int)1 << (N - 1);
const ti_int MAX = ~MIN; const ti_int MAX = ~MIN;
if (a == MIN) if (a == MIN) {
{
if (b == 0 || b == 1) if (b == 0 || b == 1)
return a * b; return a * b;
compilerrt_abort(); compilerrt_abort();
} }
if (b == MIN) if (b == MIN) {
{
if (a == 0 || a == 1) if (a == 0 || a == 1)
return a * b; return a * b;
compilerrt_abort(); compilerrt_abort();
} }
ti_int sa = a >> (N - 1); ti_int sa = a >> (N - 1);
ti_int abs_a = (a ^ sa) - sa; ti_int abs_a = (a ^ sa) - sa;
ti_int sb = b >> (N - 1); ti_int sb = b >> (N - 1);
ti_int abs_b = (b ^ sb) - sb; ti_int abs_b = (b ^ sb) - sb;
if (abs_a < 2 || abs_b < 2) if (abs_a < 2 || abs_b < 2)
return a * b; return a * b;
if (sa == sb) if (sa == sb) {
{
if (abs_a > MAX / abs_b) if (abs_a > MAX / abs_b)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (abs_a > MIN / -abs_b) if (abs_a > MIN / -abs_b)
compilerrt_abort(); compilerrt_abort();
} }
return a * b; return a * b;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/mulxc3.c

Show All 12 Lines
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
/* Returns: the product of a + ib and c + id */ /* Returns: the product of a + ib and c + id */
COMPILER_RT_ABI Lcomplex COMPILER_RT_ABI Lcomplex __mulxc3(long double __a, long double __b,
__mulxc3(long double __a, long double __b, long double __c, long double __d) long double __c, long double __d) {
{
long double __ac = __a * __c; long double __ac = __a * __c;
long double __bd = __b * __d; long double __bd = __b * __d;
long double __ad = __a * __d; long double __ad = __a * __d;
long double __bc = __b * __c; long double __bc = __b * __c;
Lcomplex z; Lcomplex z;
COMPLEX_REAL(z) = __ac - __bd; COMPLEX_REAL(z) = __ac - __bd;
COMPLEX_IMAGINARY(z) = __ad + __bc; COMPLEX_IMAGINARY(z) = __ad + __bc;
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
{
int __recalc = 0; int __recalc = 0;
if (crt_isinf(__a) || crt_isinf(__b)) if (crt_isinf(__a) || crt_isinf(__b)) {
{
__a = crt_copysignl(crt_isinf(__a) ? 1 : 0, __a); __a = crt_copysignl(crt_isinf(__a) ? 1 : 0, __a);
__b = crt_copysignl(crt_isinf(__b) ? 1 : 0, __b); __b = crt_copysignl(crt_isinf(__b) ? 1 : 0, __b);
if (crt_isnan(__c)) if (crt_isnan(__c))
__c = crt_copysignl(0, __c); __c = crt_copysignl(0, __c);
if (crt_isnan(__d)) if (crt_isnan(__d))
__d = crt_copysignl(0, __d); __d = crt_copysignl(0, __d);
__recalc = 1; __recalc = 1;
} }
if (crt_isinf(__c) || crt_isinf(__d)) if (crt_isinf(__c) || crt_isinf(__d)) {
{
__c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c); __c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c);
__d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d); __d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d);
if (crt_isnan(__a)) if (crt_isnan(__a))
__a = crt_copysignl(0, __a); __a = crt_copysignl(0, __a);
if (crt_isnan(__b)) if (crt_isnan(__b))
__b = crt_copysignl(0, __b); __b = crt_copysignl(0, __b);
__recalc = 1; __recalc = 1;
} }
if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) || if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) || crt_isinf(__ad) ||
crt_isinf(__ad) || crt_isinf(__bc))) crt_isinf(__bc))) {
{
if (crt_isnan(__a)) if (crt_isnan(__a))
__a = crt_copysignl(0, __a); __a = crt_copysignl(0, __a);
if (crt_isnan(__b)) if (crt_isnan(__b))
__b = crt_copysignl(0, __b); __b = crt_copysignl(0, __b);
if (crt_isnan(__c)) if (crt_isnan(__c))
__c = crt_copysignl(0, __c); __c = crt_copysignl(0, __c);
if (crt_isnan(__d)) if (crt_isnan(__d))
__d = crt_copysignl(0, __d); __d = crt_copysignl(0, __d);
__recalc = 1; __recalc = 1;
} }
if (__recalc) if (__recalc) {
{
COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d); COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c); COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
} }
} }
return z; return z;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/negdf2.c

//===-- lib/negdf2.c - double-precision negation ------------------*- C -*-===// //===-- lib/negdf2.c - double-precision negation ------------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements double-precision soft-float negation. // This file implements double-precision soft-float negation.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __negdf2(fp_t a) { return fromRep(toRep(a) ^ signBit); }
__negdf2(fp_t a) {
return fromRep(toRep(a) ^ signBit);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_dneg(fp_t a) { AEABI_RTABI fp_t __aeabi_dneg(fp_t a) { return __negdf2(a); }
return __negdf2(a);
}
#else #else
AEABI_RTABI fp_t __aeabi_dneg(fp_t a) COMPILER_RT_ALIAS(__negdf2); AEABI_RTABI fp_t __aeabi_dneg(fp_t a) COMPILER_RT_ALIAS(__negdf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/negdi2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: -a */ /* Returns: -a */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __negdi2(di_int a) {
__negdi2(di_int a)
{
/* Note: this routine is here for API compatibility; any sane compiler /* Note: this routine is here for API compatibility; any sane compiler
* should expand it inline. * should expand it inline.
*/ */
return -a; return -a;
} }

compiler-rt/trunk/lib/builtins/negsf2.c

//===-- lib/negsf2.c - single-precision negation ------------------*- C -*-===// //===-- lib/negsf2.c - single-precision negation ------------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements single-precision soft-float negation. // This file implements single-precision soft-float negation.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __negsf2(fp_t a) { return fromRep(toRep(a) ^ signBit); }
__negsf2(fp_t a) {
return fromRep(toRep(a) ^ signBit);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_fneg(fp_t a) { AEABI_RTABI fp_t __aeabi_fneg(fp_t a) { return __negsf2(a); }
return __negsf2(a);
}
#else #else
AEABI_RTABI fp_t __aeabi_fneg(fp_t a) COMPILER_RT_ALIAS(__negsf2); AEABI_RTABI fp_t __aeabi_fneg(fp_t a) COMPILER_RT_ALIAS(__negsf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/negti2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: -a */ /* Returns: -a */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __negti2(ti_int a) {
__negti2(ti_int a)
{
/* Note: this routine is here for API compatibility; any sane compiler /* Note: this routine is here for API compatibility; any sane compiler
* should expand it inline. * should expand it inline.
*/ */
return -a; return -a;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/negvdi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: -a */ /* Returns: -a */
/* Effects: aborts if -a overflows */ /* Effects: aborts if -a overflows */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __negvdi2(di_int a) {
__negvdi2(di_int a)
{
const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT)-1); const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT) - 1);
if (a == MIN) if (a == MIN)
compilerrt_abort(); compilerrt_abort();
return -a; return -a;
} }

compiler-rt/trunk/lib/builtins/negvsi2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: -a */ /* Returns: -a */
/* Effects: aborts if -a overflows */ /* Effects: aborts if -a overflows */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __negvsi2(si_int a) {
__negvsi2(si_int a)
{
const si_int MIN = (si_int)1 << ((int)(sizeof(si_int) * CHAR_BIT)-1); const si_int MIN = (si_int)1 << ((int)(sizeof(si_int) * CHAR_BIT) - 1);
if (a == MIN) if (a == MIN)
compilerrt_abort(); compilerrt_abort();
return -a; return -a;
} }

compiler-rt/trunk/lib/builtins/negvti2.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: -a */ /* Returns: -a */
/* Effects: aborts if -a overflows */ /* Effects: aborts if -a overflows */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __negvti2(ti_int a) {
__negvti2(ti_int a)
{
const ti_int MIN = (ti_int)1 << ((int)(sizeof(ti_int) * CHAR_BIT)-1); const ti_int MIN = (ti_int)1 << ((int)(sizeof(ti_int) * CHAR_BIT) - 1);
if (a == MIN) if (a == MIN)
compilerrt_abort(); compilerrt_abort();
return -a; return -a;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/os_version_check.c

Show All 24 Lines
/* These three variables hold the host's OS version. */ /* These three variables hold the host's OS version. */
static int32_t GlobalMajor, GlobalMinor, GlobalSubminor; static int32_t GlobalMajor, GlobalMinor, GlobalSubminor;
static dispatch_once_t DispatchOnceCounter; static dispatch_once_t DispatchOnceCounter;
/* We can't include <CoreFoundation/CoreFoundation.h> directly from here, so /* We can't include <CoreFoundation/CoreFoundation.h> directly from here, so
* just forward declare everything that we need from it. */ * just forward declare everything that we need from it. */
typedef const void *CFDataRef, *CFAllocatorRef, *CFPropertyListRef, typedef const void *CFDataRef, *CFAllocatorRef, *CFPropertyListRef,
*CFStringRef, *CFDictionaryRef, *CFTypeRef, *CFErrorRef; *CFStringRef, *CFDictionaryRef, *CFTypeRef, *CFErrorRef;
#if __LLP64__ #if __LLP64__
typedef unsigned long long CFTypeID; typedef unsigned long long CFTypeID;
typedef unsigned long long CFOptionFlags; typedef unsigned long long CFOptionFlags;
typedef signed long long CFIndex; typedef signed long long CFIndex;
#else #else
typedef unsigned long CFTypeID; typedef unsigned long CFTypeID;
typedef unsigned long CFOptionFlags; typedef unsigned long CFOptionFlags;
Show All 40 Lines if (!NullAllocator)
return; return;
const CFAllocatorRef AllocatorNull = *(const CFAllocatorRef *)NullAllocator; const CFAllocatorRef AllocatorNull = *(const CFAllocatorRef *)NullAllocator;
CFDataCreateWithBytesNoCopyFuncTy CFDataCreateWithBytesNoCopyFunc = CFDataCreateWithBytesNoCopyFuncTy CFDataCreateWithBytesNoCopyFunc =
(CFDataCreateWithBytesNoCopyFuncTy)dlsym(RTLD_DEFAULT, (CFDataCreateWithBytesNoCopyFuncTy)dlsym(RTLD_DEFAULT,
"CFDataCreateWithBytesNoCopy"); "CFDataCreateWithBytesNoCopy");
if (!CFDataCreateWithBytesNoCopyFunc) if (!CFDataCreateWithBytesNoCopyFunc)
return; return;
CFPropertyListCreateWithDataFuncTy CFPropertyListCreateWithDataFunc = CFPropertyListCreateWithDataFuncTy CFPropertyListCreateWithDataFunc =
(CFPropertyListCreateWithDataFuncTy)dlsym( (CFPropertyListCreateWithDataFuncTy)dlsym(RTLD_DEFAULT,
RTLD_DEFAULT, "CFPropertyListCreateWithData"); "CFPropertyListCreateWithData");
/* CFPropertyListCreateWithData was introduced only in macOS 10.6+, so it /* CFPropertyListCreateWithData was introduced only in macOS 10.6+, so it
* will be NULL on earlier OS versions. */ * will be NULL on earlier OS versions. */
#pragma clang diagnostic push #pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations" #pragma clang diagnostic ignored "-Wdeprecated-declarations"
CFPropertyListCreateFromXMLDataFuncTy CFPropertyListCreateFromXMLDataFunc = CFPropertyListCreateFromXMLDataFuncTy CFPropertyListCreateFromXMLDataFunc =
(CFPropertyListCreateFromXMLDataFuncTy)dlsym( (CFPropertyListCreateFromXMLDataFuncTy)dlsym(
RTLD_DEFAULT, "CFPropertyListCreateFromXMLData"); RTLD_DEFAULT, "CFPropertyListCreateFromXMLData");
#pragma clang diagnostic pop #pragma clang diagnostic pop
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

compiler-rt/trunk/lib/builtins/paritydi2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: 1 if number of bits is odd else returns 0 */ /* Returns: 1 if number of bits is odd else returns 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __paritydi2(di_int a) {
__paritydi2(di_int a)
{
dwords x; dwords x;
x.all = a; x.all = a;
return __paritysi2(x.s.high ^ x.s.low); return __paritysi2(x.s.high ^ x.s.low);
} }

compiler-rt/trunk/lib/builtins/paritysi2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: 1 if number of bits is odd else returns 0 */ /* Returns: 1 if number of bits is odd else returns 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __paritysi2(si_int a) {
__paritysi2(si_int a)
{
su_int x = (su_int)a; su_int x = (su_int)a;
x ^= x >> 16; x ^= x >> 16;
x ^= x >> 8; x ^= x >> 8;
x ^= x >> 4; x ^= x >> 4;
return (0x6996 >> (x & 0xF)) & 1; return (0x6996 >> (x & 0xF)) & 1;
} }

compiler-rt/trunk/lib/builtins/parityti2.c

/* ===-- parityti2.c - Implement __parityti2 -------------------------------=== /* ===-- parityti2.c - Implement __parityti2 -------------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
* This file implements __parityti2 for the compiler_rt library. * This file implements __parityti2 for the compiler_rt library.
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: 1 if number of bits is odd else returns 0 */ /* Returns: 1 if number of bits is odd else returns 0 */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __parityti2(ti_int a) {
__parityti2(ti_int a)
{
twords x; twords x;
x.all = a; x.all = a;
return __paritydi2(x.s.high ^ x.s.low); return __paritydi2(x.s.high ^ x.s.low);
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/popcountdi2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: count of 1 bits */ /* Returns: count of 1 bits */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __popcountdi2(di_int a) {
__popcountdi2(di_int a)
{
du_int x2 = (du_int)a; du_int x2 = (du_int)a;
x2 = x2 - ((x2 >> 1) & 0x5555555555555555uLL); x2 = x2 - ((x2 >> 1) & 0x5555555555555555uLL);
/* Every 2 bits holds the sum of every pair of bits (32) */ /* Every 2 bits holds the sum of every pair of bits (32) */
x2 = ((x2 >> 2) & 0x3333333333333333uLL) + (x2 & 0x3333333333333333uLL); x2 = ((x2 >> 2) & 0x3333333333333333uLL) + (x2 & 0x3333333333333333uLL);
/* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (16) */ /* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (16)
*/
x2 = (x2 + (x2 >> 4)) & 0x0F0F0F0F0F0F0F0FuLL; x2 = (x2 + (x2 >> 4)) & 0x0F0F0F0F0F0F0F0FuLL;
/* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (8) */ /* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (8)
*/
su_int x = (su_int)(x2 + (x2 >> 32)); su_int x = (su_int)(x2 + (x2 >> 32));
/* The lower 32 bits hold four 16 bit sums (5 significant bits). */ /* The lower 32 bits hold four 16 bit sums (5 significant bits). */
/* Upper 32 bits are garbage */ /* Upper 32 bits are garbage */
x = x + (x >> 16); x = x + (x >> 16);
/* The lower 16 bits hold two 32 bit sums (6 significant bits). */ /* The lower 16 bits hold two 32 bit sums (6 significant bits). */
/* Upper 16 bits are garbage */ /* Upper 16 bits are garbage */
return (x + (x >> 8)) & 0x0000007F; /* (7 significant bits) */ return (x + (x >> 8)) & 0x0000007F; /* (7 significant bits) */
} }

compiler-rt/trunk/lib/builtins/popcountsi2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: count of 1 bits */ /* Returns: count of 1 bits */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __popcountsi2(si_int a) {
__popcountsi2(si_int a)
{
su_int x = (su_int)a; su_int x = (su_int)a;
x = x - ((x >> 1) & 0x55555555); x = x - ((x >> 1) & 0x55555555);
/* Every 2 bits holds the sum of every pair of bits */ /* Every 2 bits holds the sum of every pair of bits */
x = ((x >> 2) & 0x33333333) + (x & 0x33333333); x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
/* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) */ /* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) */
x = (x + (x >> 4)) & 0x0F0F0F0F; x = (x + (x >> 4)) & 0x0F0F0F0F;
/* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) */ /* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) */
x = (x + (x >> 16)); x = (x + (x >> 16));
/* The lower 16 bits hold two 8 bit sums (5 significant bits).*/ /* The lower 16 bits hold two 8 bit sums (5 significant bits).*/
/* Upper 16 bits are garbage */ /* Upper 16 bits are garbage */
return (x + (x >> 8)) & 0x0000003F; /* (6 significant bits) */ return (x + (x >> 8)) & 0x0000003F; /* (6 significant bits) */
} }

compiler-rt/trunk/lib/builtins/popcountti2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: count of 1 bits */ /* Returns: count of 1 bits */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __popcountti2(ti_int a) {
__popcountti2(ti_int a)
{
tu_int x3 = (tu_int)a; tu_int x3 = (tu_int)a;
x3 = x3 - ((x3 >> 1) & (((tu_int)0x5555555555555555uLL << 64) | x3 = x3 - ((x3 >> 1) &
0x5555555555555555uLL)); (((tu_int)0x5555555555555555uLL << 64) | 0x5555555555555555uLL));
/* Every 2 bits holds the sum of every pair of bits (64) */ /* Every 2 bits holds the sum of every pair of bits (64) */
x3 = ((x3 >> 2) & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)) x3 = ((x3 >> 2) &
+ (x3 & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)); (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)) +
/* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (32) */ (x3 & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL));
x3 = (x3 + (x3 >> 4)) /* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (32)
& (((tu_int)0x0F0F0F0F0F0F0F0FuLL << 64) | 0x0F0F0F0F0F0F0F0FuLL); */
/* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (16) */ x3 = (x3 + (x3 >> 4)) &
(((tu_int)0x0F0F0F0F0F0F0F0FuLL << 64) | 0x0F0F0F0F0F0F0F0FuLL);
/* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (16)
*/
du_int x2 = (du_int)(x3 + (x3 >> 64)); du_int x2 = (du_int)(x3 + (x3 >> 64));
/* Every 8 bits holds the sum of every 8-set of bits (5 significant bits) (8) */ /* Every 8 bits holds the sum of every 8-set of bits (5 significant bits) (8)
*/
su_int x = (su_int)(x2 + (x2 >> 32)); su_int x = (su_int)(x2 + (x2 >> 32));
/* Every 8 bits holds the sum of every 8-set of bits (6 significant bits) (4) */ /* Every 8 bits holds the sum of every 8-set of bits (6 significant bits) (4)
*/
x = x + (x >> 16); x = x + (x >> 16);
/* Every 8 bits holds the sum of every 8-set of bits (7 significant bits) (2) */ /* Every 8 bits holds the sum of every 8-set of bits (7 significant bits) (2)
*/
/* Upper 16 bits are garbage */ /* Upper 16 bits are garbage */
return (x + (x >> 8)) & 0xFF; /* (8 significant bits) */ return (x + (x >> 8)) & 0xFF; /* (8 significant bits) */
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/powidf2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a ^ b */ /* Returns: a ^ b */
COMPILER_RT_ABI double COMPILER_RT_ABI double __powidf2(double a, si_int b) {
__powidf2(double a, si_int b)
{
const int recip = b < 0; const int recip = b < 0;
double r = 1; double r = 1;
while (1) while (1) {
{
if (b & 1) if (b & 1)
r *= a; r *= a;
b /= 2; b /= 2;
if (b == 0) if (b == 0)
break; break;
a *= a; a *= a;
} }
return recip ? 1/r : r; return recip ? 1 / r : r;
} }

compiler-rt/trunk/lib/builtins/powisf2.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a ^ b */ /* Returns: a ^ b */
COMPILER_RT_ABI float COMPILER_RT_ABI float __powisf2(float a, si_int b) {
__powisf2(float a, si_int b)
{
const int recip = b < 0; const int recip = b < 0;
float r = 1; float r = 1;
while (1) while (1) {
{
if (b & 1) if (b & 1)
r *= a; r *= a;
b /= 2; b /= 2;
if (b == 0) if (b == 0)
break; break;
a *= a; a *= a;
} }
return recip ? 1/r : r; return recip ? 1 / r : r;
} }

compiler-rt/trunk/lib/builtins/powitf2.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#if _ARCH_PPC #if _ARCH_PPC
/* Returns: a ^ b */ /* Returns: a ^ b */
COMPILER_RT_ABI long double COMPILER_RT_ABI long double __powitf2(long double a, si_int b) {
__powitf2(long double a, si_int b)
{
const int recip = b < 0; const int recip = b < 0;
long double r = 1; long double r = 1;
while (1) while (1) {
{
if (b & 1) if (b & 1)
r *= a; r *= a;
b /= 2; b /= 2;
if (b == 0) if (b == 0)
break; break;
a *= a; a *= a;
} }
return recip ? 1/r : r; return recip ? 1 / r : r;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/powixf2.c

Show All 11 Lines
*/ */
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
/* Returns: a ^ b */ /* Returns: a ^ b */
COMPILER_RT_ABI long double COMPILER_RT_ABI long double __powixf2(long double a, si_int b) {
__powixf2(long double a, si_int b)
{
const int recip = b < 0; const int recip = b < 0;
long double r = 1; long double r = 1;
while (1) while (1) {
{
if (b & 1) if (b & 1)
r *= a; r *= a;
b /= 2; b /= 2;
if (b == 0) if (b == 0)
break; break;
a *= a; a *= a;
} }
return recip ? 1/r : r; return recip ? 1 / r : r;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/ppc/DD.h

#ifndef COMPILERRT_DD_HEADER #ifndef COMPILERRT_DD_HEADER
#define COMPILERRT_DD_HEADER #define COMPILERRT_DD_HEADER
#include "../int_lib.h" #include "../int_lib.h"
typedef union { typedef union {
long double ld; long double ld;
struct { struct {
double hi; double hi;
double lo; double lo;
}s; } s;
} DD; } DD;
typedef union { typedef union {
double d; double d;
uint64_t x; uint64_t x;
} doublebits; } doublebits;
#define LOWORDER(xy,xHi,xLo,yHi,yLo) \ #define LOWORDER(xy, xHi, xLo, yHi, yLo) \
(((((xHi)*(yHi) - (xy)) + (xHi)*(yLo)) + (xLo)*(yHi)) + (xLo)*(yLo)) (((((xHi) * (yHi) - (xy)) + (xHi) * (yLo)) + (xLo) * (yHi)) + (xLo) * (yLo))
static __inline ALWAYS_INLINE double local_fabs(double x) { static __inline ALWAYS_INLINE double local_fabs(double x) {
doublebits result = {.d = x}; doublebits result = {.d = x};
result.x &= UINT64_C(0x7fffffffffffffff); result.x &= UINT64_C(0x7fffffffffffffff);
return result.d; return result.d;
} }
static __inline ALWAYS_INLINE double high26bits(double x) { static __inline ALWAYS_INLINE double high26bits(double x) {
Show All 17 Lines

compiler-rt/trunk/lib/builtins/ppc/divtc3.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
#include "DD.h"
#include "../int_math.h" #include "../int_math.h"
#include "DD.h"
// Use DOUBLE_PRECISION because the soft-fp method we use is logb (on the upper // Use DOUBLE_PRECISION because the soft-fp method we use is logb (on the upper
// half of the long doubles), even though this file defines complex division for // half of the long doubles), even though this file defines complex division for
// 128-bit floats. // 128-bit floats.
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "../fp_lib.h" #include "../fp_lib.h"
#if !defined(CRT_INFINITY) && defined(HUGE_VAL) #if !defined(CRT_INFINITY) && defined(HUGE_VAL)
#define CRT_INFINITY HUGE_VAL #define CRT_INFINITY HUGE_VAL
#endif /* CRT_INFINITY */ #endif /* CRT_INFINITY */
#define makeFinite(x) { \ #define makeFinite(x) \
{ \
(x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \ (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
(x).s.lo = 0.0; \ (x).s.lo = 0.0; \
} }
long double _Complex long double _Complex __divtc3(long double a, long double b, long double c,
__divtc3(long double a, long double b, long double c, long double d) long double d) {
{
DD cDD = { .ld = c }; DD cDD = {.ld = c};
DD dDD = { .ld = d }; DD dDD = {.ld = d};
int ilogbw = 0; int ilogbw = 0;
const double logbw = __compiler_rt_logb( const double logbw =
crt_fmax(crt_fabs(cDD.s.hi), crt_fabs(dDD.s.hi))); __compiler_rt_logb(crt_fmax(crt_fabs(cDD.s.hi), crt_fabs(dDD.s.hi)));
if (crt_isfinite(logbw)) if (crt_isfinite(logbw)) {
{
ilogbw = (int)logbw; ilogbw = (int)logbw;
cDD.s.hi = crt_scalbn(cDD.s.hi, -ilogbw); cDD.s.hi = crt_scalbn(cDD.s.hi, -ilogbw);
cDD.s.lo = crt_scalbn(cDD.s.lo, -ilogbw); cDD.s.lo = crt_scalbn(cDD.s.lo, -ilogbw);
dDD.s.hi = crt_scalbn(dDD.s.hi, -ilogbw); dDD.s.hi = crt_scalbn(dDD.s.hi, -ilogbw);
dDD.s.lo = crt_scalbn(dDD.s.lo, -ilogbw); dDD.s.lo = crt_scalbn(dDD.s.lo, -ilogbw);
} }
const long double denom = __gcc_qadd(__gcc_qmul(cDD.ld, cDD.ld), __gcc_qmul(dDD.ld, dDD.ld)); const long double denom =
const long double realNumerator = __gcc_qadd(__gcc_qmul(a,cDD.ld), __gcc_qmul(b,dDD.ld)); __gcc_qadd(__gcc_qmul(cDD.ld, cDD.ld), __gcc_qmul(dDD.ld, dDD.ld));
const long double imagNumerator = __gcc_qsub(__gcc_qmul(b,cDD.ld), __gcc_qmul(a,dDD.ld)); const long double realNumerator =
__gcc_qadd(__gcc_qmul(a, cDD.ld), __gcc_qmul(b, dDD.ld));
const long double imagNumerator =
__gcc_qsub(__gcc_qmul(b, cDD.ld), __gcc_qmul(a, dDD.ld));
DD real = { .ld = __gcc_qdiv(realNumerator, denom) }; DD real = {.ld = __gcc_qdiv(realNumerator, denom)};
DD imag = { .ld = __gcc_qdiv(imagNumerator, denom) }; DD imag = {.ld = __gcc_qdiv(imagNumerator, denom)};
real.s.hi = crt_scalbn(real.s.hi, -ilogbw); real.s.hi = crt_scalbn(real.s.hi, -ilogbw);
real.s.lo = crt_scalbn(real.s.lo, -ilogbw); real.s.lo = crt_scalbn(real.s.lo, -ilogbw);
imag.s.hi = crt_scalbn(imag.s.hi, -ilogbw); imag.s.hi = crt_scalbn(imag.s.hi, -ilogbw);
imag.s.lo = crt_scalbn(imag.s.lo, -ilogbw); imag.s.lo = crt_scalbn(imag.s.lo, -ilogbw);
if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi)) if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi)) {
{
DD aDD = { .ld = a }; DD aDD = {.ld = a};
DD bDD = { .ld = b }; DD bDD = {.ld = b};
DD rDD = { .ld = denom }; DD rDD = {.ld = denom};
if ((rDD.s.hi == 0.0) && (!crt_isnan(aDD.s.hi) || if ((rDD.s.hi == 0.0) && (!crt_isnan(aDD.s.hi) || !crt_isnan(bDD.s.hi))) {
!crt_isnan(bDD.s.hi)))
{
real.s.hi = crt_copysign(CRT_INFINITY,cDD.s.hi) * aDD.s.hi; real.s.hi = crt_copysign(CRT_INFINITY, cDD.s.hi) * aDD.s.hi;
real.s.lo = 0.0; real.s.lo = 0.0;
imag.s.hi = crt_copysign(CRT_INFINITY,cDD.s.hi) * bDD.s.hi; imag.s.hi = crt_copysign(CRT_INFINITY, cDD.s.hi) * bDD.s.hi;
imag.s.lo = 0.0; imag.s.lo = 0.0;
} }
else if ((crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) && else if ((crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) &&
crt_isfinite(cDD.s.hi) && crt_isfinite(dDD.s.hi)) crt_isfinite(cDD.s.hi) && crt_isfinite(dDD.s.hi)) {
{
makeFinite(aDD); makeFinite(aDD);
makeFinite(bDD); makeFinite(bDD);
real.s.hi = CRT_INFINITY * (aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi); real.s.hi = CRT_INFINITY * (aDD.s.hi * cDD.s.hi + bDD.s.hi * dDD.s.hi);
real.s.lo = 0.0; real.s.lo = 0.0;
imag.s.hi = CRT_INFINITY * (bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi); imag.s.hi = CRT_INFINITY * (bDD.s.hi * cDD.s.hi - aDD.s.hi * dDD.s.hi);
imag.s.lo = 0.0; imag.s.lo = 0.0;
} }
else if ((crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) && else if ((crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) &&
crt_isfinite(aDD.s.hi) && crt_isfinite(bDD.s.hi)) crt_isfinite(aDD.s.hi) && crt_isfinite(bDD.s.hi)) {
{
makeFinite(cDD); makeFinite(cDD);
makeFinite(dDD); makeFinite(dDD);
real.s.hi = crt_copysign(0.0,(aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi)); real.s.hi =
crt_copysign(0.0, (aDD.s.hi * cDD.s.hi + bDD.s.hi * dDD.s.hi));
real.s.lo = 0.0; real.s.lo = 0.0;
imag.s.hi = crt_copysign(0.0,(bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi)); imag.s.hi =
crt_copysign(0.0, (bDD.s.hi * cDD.s.hi - aDD.s.hi * dDD.s.hi));
imag.s.lo = 0.0; imag.s.lo = 0.0;
} }
} }
long double _Complex z; long double _Complex z;
__real__ z = real.ld; __real__ z = real.ld;
__imag__ z = imag.ld; __imag__ z = imag.ld;
return z; return z;
} }

compiler-rt/trunk/lib/builtins/ppc/fixtfdi.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* int64_t __fixunstfdi(long double x); /* int64_t __fixunstfdi(long double x);
* This file implements the PowerPC 128-bit double-double -> int64_t conversion * This file implements the PowerPC 128-bit double-double -> int64_t conversion
*/ */
#include "DD.h"
#include "../int_math.h" #include "../int_math.h"
#include "DD.h"
uint64_t __fixtfdi(long double input) uint64_t __fixtfdi(long double input) {
{
const DD x = { .ld = input }; const DD x = {.ld = input};
const doublebits hibits = { .d = x.s.hi }; const doublebits hibits = {.d = x.s.hi};
const uint32_t absHighWord = (uint32_t)(hibits.x >> 32) & UINT32_C(0x7fffffff); const uint32_t absHighWord =
(uint32_t)(hibits.x >> 32) & UINT32_C(0x7fffffff);
const uint32_t absHighWordMinusOne = absHighWord - UINT32_C(0x3ff00000); const uint32_t absHighWordMinusOne = absHighWord - UINT32_C(0x3ff00000);
/* If (1.0 - tiny) <= input < 0x1.0p63: */ /* If (1.0 - tiny) <= input < 0x1.0p63: */
if (UINT32_C(0x03f00000) > absHighWordMinusOne) if (UINT32_C(0x03f00000) > absHighWordMinusOne) {
{ /* Do an unsigned conversion of the absolute value, then restore the sign.
/* Do an unsigned conversion of the absolute value, then restore the sign. */ */
const int unbiasedHeadExponent = absHighWordMinusOne >> 20; const int unbiasedHeadExponent = absHighWordMinusOne >> 20;
int64_t result = hibits.x & INT64_C(0x000fffffffffffff); /* mantissa(hi) */ int64_t result = hibits.x & INT64_C(0x000fffffffffffff); /* mantissa(hi) */
result |= INT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */ result |= INT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */
result <<= 10; /* mantissa(hi) with one zero preceding bit. */ result <<= 10; /* mantissa(hi) with one zero preceding bit. */
const int64_t hiNegationMask = ((int64_t)(hibits.x)) >> 63; const int64_t hiNegationMask = ((int64_t)(hibits.x)) >> 63;
/* If the tail is non-zero, we need to patch in the tail bits. */ /* If the tail is non-zero, we need to patch in the tail bits. */
if (0.0 != x.s.lo) if (0.0 != x.s.lo) {
{
const doublebits lobits = { .d = x.s.lo }; const doublebits lobits = {.d = x.s.lo};
int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff); int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
tailMantissa |= INT64_C(0x0010000000000000); tailMantissa |= INT64_C(0x0010000000000000);
/* At this point we have the mantissa of |tail| */ /* At this point we have the mantissa of |tail| */
/* We need to negate it if head and tail have different signs. */ /* We need to negate it if head and tail have different signs. */
const int64_t loNegationMask = ((int64_t)(lobits.x)) >> 63; const int64_t loNegationMask = ((int64_t)(lobits.x)) >> 63;
const int64_t negationMask = loNegationMask ^ hiNegationMask; const int64_t negationMask = loNegationMask ^ hiNegationMask;
tailMantissa = (tailMantissa ^ negationMask) - negationMask; tailMantissa = (tailMantissa ^ negationMask) - negationMask;
/* Now we have the mantissa of tail as a signed 2s-complement integer */ /* Now we have the mantissa of tail as a signed 2s-complement integer */
const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff; const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
/* Shift the tail mantissa into the right position, accounting for the /* Shift the tail mantissa into the right position, accounting for the
* bias of 10 that we shifted the head mantissa by. * bias of 10 that we shifted the head mantissa by.
*/ */
tailMantissa >>= (unbiasedHeadExponent - (biasedTailExponent - (1023 - 10))); tailMantissa >>=
(unbiasedHeadExponent - (biasedTailExponent - (1023 - 10)));
result += tailMantissa; result += tailMantissa;
} }
result >>= (62 - unbiasedHeadExponent); result >>= (62 - unbiasedHeadExponent);
/* Restore the sign of the result and return */ /* Restore the sign of the result and return */
result = (result ^ hiNegationMask) - hiNegationMask; result = (result ^ hiNegationMask) - hiNegationMask;
return result; return result;
} }
/* Edge cases handled here: */ /* Edge cases handled here: */
/* |x| < 1, result is zero. */ /* |x| < 1, result is zero. */
if (1.0 > crt_fabs(x.s.hi)) if (1.0 > crt_fabs(x.s.hi))
return INT64_C(0); return INT64_C(0);
/* x very close to INT64_MIN, care must be taken to see which side we are on. */ /* x very close to INT64_MIN, care must be taken to see which side we are on.
*/
if (x.s.hi == -0x1.0p63) { if (x.s.hi == -0x1.0p63) {
int64_t result = INT64_MIN; int64_t result = INT64_MIN;
if (0.0 < x.s.lo) if (0.0 < x.s.lo) {
{ /* If the tail is positive, the correct result is something other than
/* If the tail is positive, the correct result is something other than INT64_MIN. * INT64_MIN. we'll need to figure out what it is.
* we'll need to figure out what it is.
*/ */
const doublebits lobits = { .d = x.s.lo }; const doublebits lobits = {.d = x.s.lo};
int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff); int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
tailMantissa |= INT64_C(0x0010000000000000); tailMantissa |= INT64_C(0x0010000000000000);
/* Now we negate the tailMantissa */ /* Now we negate the tailMantissa */
tailMantissa = (tailMantissa ^ INT64_C(-1)) + INT64_C(1); tailMantissa = (tailMantissa ^ INT64_C(-1)) + INT64_C(1);
/* And shift it by the appropriate amount */ /* And shift it by the appropriate amount */
const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff; const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
tailMantissa >>= 1075 - biasedTailExponent; tailMantissa >>= 1075 - biasedTailExponent;
result -= tailMantissa; result -= tailMantissa;
} }
return result; return result;
} }
/* Signed overflows, infinities, and NaNs */ /* Signed overflows, infinities, and NaNs */
if (x.s.hi > 0.0) if (x.s.hi > 0.0)
return INT64_MAX; return INT64_MAX;
else else
return INT64_MIN; return INT64_MIN;
} }

compiler-rt/trunk/lib/builtins/ppc/fixunstfdi.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* uint64_t __fixunstfdi(long double x); */ /* uint64_t __fixunstfdi(long double x); */
/* This file implements the PowerPC 128-bit double-double -> uint64_t conversion */ /* This file implements the PowerPC 128-bit double-double -> uint64_t conversion
*/
#include "DD.h" #include "DD.h"
uint64_t __fixunstfdi(long double input) uint64_t __fixunstfdi(long double input) {
{
const DD x = { .ld = input }; const DD x = {.ld = input};
const doublebits hibits = { .d = x.s.hi }; const doublebits hibits = {.d = x.s.hi};
const uint32_t highWordMinusOne = (uint32_t)(hibits.x >> 32) - UINT32_C(0x3ff00000); const uint32_t highWordMinusOne =
(uint32_t)(hibits.x >> 32) - UINT32_C(0x3ff00000);
/* If (1.0 - tiny) <= input < 0x1.0p64: */ /* If (1.0 - tiny) <= input < 0x1.0p64: */
if (UINT32_C(0x04000000) > highWordMinusOne) if (UINT32_C(0x04000000) > highWordMinusOne) {
{
const int unbiasedHeadExponent = highWordMinusOne >> 20; const int unbiasedHeadExponent = highWordMinusOne >> 20;
uint64_t result = hibits.x & UINT64_C(0x000fffffffffffff); /* mantissa(hi) */ uint64_t result =
hibits.x & UINT64_C(0x000fffffffffffff); /* mantissa(hi) */
result |= UINT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */ result |= UINT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */
result <<= 11; /* mantissa(hi) left aligned in the int64 field. */ result <<= 11; /* mantissa(hi) left aligned in the int64 field. */
/* If the tail is non-zero, we need to patch in the tail bits. */ /* If the tail is non-zero, we need to patch in the tail bits. */
if (0.0 != x.s.lo) if (0.0 != x.s.lo) {
{
const doublebits lobits = { .d = x.s.lo }; const doublebits lobits = {.d = x.s.lo};
int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff); int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
tailMantissa |= INT64_C(0x0010000000000000); tailMantissa |= INT64_C(0x0010000000000000);
/* At this point we have the mantissa of |tail| */ /* At this point we have the mantissa of |tail| */
const int64_t negationMask = ((int64_t)(lobits.x)) >> 63; const int64_t negationMask = ((int64_t)(lobits.x)) >> 63;
tailMantissa = (tailMantissa ^ negationMask) - negationMask; tailMantissa = (tailMantissa ^ negationMask) - negationMask;
/* Now we have the mantissa of tail as a signed 2s-complement integer */ /* Now we have the mantissa of tail as a signed 2s-complement integer */
const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff; const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
/* Shift the tail mantissa into the right position, accounting for the /* Shift the tail mantissa into the right position, accounting for the
* bias of 11 that we shifted the head mantissa by. * bias of 11 that we shifted the head mantissa by.
*/ */
tailMantissa >>= (unbiasedHeadExponent - (biasedTailExponent - (1023 - 11))); tailMantissa >>=
(unbiasedHeadExponent - (biasedTailExponent - (1023 - 11)));
result += tailMantissa; result += tailMantissa;
} }
result >>= (63 - unbiasedHeadExponent); result >>= (63 - unbiasedHeadExponent);
return result; return result;
} }
/* Edge cases are handled here, with saturation. */ /* Edge cases are handled here, with saturation. */
if (1.0 > x.s.hi) if (1.0 > x.s.hi)
return UINT64_C(0); return UINT64_C(0);
else else
return UINT64_MAX; return UINT64_MAX;
} }

compiler-rt/trunk/lib/builtins/ppc/floatditf.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __floatditf(long long x); */ /* long double __floatditf(long long x); */
/* This file implements the PowerPC long long -> long double conversion */ /* This file implements the PowerPC long long -> long double conversion */
#include "DD.h" #include "DD.h"
long double __floatditf(int64_t a) { long double __floatditf(int64_t a) {
static const double twop32 = 0x1.0p32; static const double twop32 = 0x1.0p32;
static const double twop52 = 0x1.0p52; static const double twop52 = 0x1.0p52;
doublebits low = { .d = twop52 }; doublebits low = {.d = twop52};
low.x |= a & UINT64_C(0x00000000ffffffff); /* 0x1.0p52 + low 32 bits of a. */ low.x |= a & UINT64_C(0x00000000ffffffff); /* 0x1.0p52 + low 32 bits of a. */
const double high_addend = (double)((int32_t)(a >> 32))*twop32 - twop52; const double high_addend = (double)((int32_t)(a >> 32)) * twop32 - twop52;
/* At this point, we have two double precision numbers /* At this point, we have two double precision numbers
* high_addend and low.d, and we wish to return their sum * high_addend and low.d, and we wish to return their sum
* as a canonicalized long double: * as a canonicalized long double:
*/ */
/* This implementation sets the inexact flag spuriously. /* This implementation sets the inexact flag spuriously.
* This could be avoided, but at some substantial cost. * This could be avoided, but at some substantial cost.
*/ */
DD result; DD result;
result.s.hi = high_addend + low.d; result.s.hi = high_addend + low.d;
result.s.lo = (high_addend - result.s.hi) + low.d; result.s.lo = (high_addend - result.s.hi) + low.d;
return result.ld; return result.ld;
} }

compiler-rt/trunk/lib/builtins/ppc/floatunditf.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __floatunditf(unsigned long long x); */ /* long double __floatunditf(unsigned long long x); */
/* This file implements the PowerPC unsigned long long -> long double conversion */ /* This file implements the PowerPC unsigned long long -> long double conversion
*/
#include "DD.h" #include "DD.h"
long double __floatunditf(uint64_t a) { long double __floatunditf(uint64_t a) {
/* Begins with an exact copy of the code from __floatundidf */ /* Begins with an exact copy of the code from __floatundidf */
static const double twop52 = 0x1.0p52; static const double twop52 = 0x1.0p52;
static const double twop84 = 0x1.0p84; static const double twop84 = 0x1.0p84;
static const double twop84_plus_twop52 = 0x1.00000001p84; static const double twop84_plus_twop52 = 0x1.00000001p84;
doublebits high = { .d = twop84 }; doublebits high = {.d = twop84};
doublebits low = { .d = twop52 }; doublebits low = {.d = twop52};
high.x |= a >> 32; /* 0x1.0p84 + high 32 bits of a */ high.x |= a >> 32; /* 0x1.0p84 + high 32 bits of a */
low.x |= a & UINT64_C(0x00000000ffffffff); /* 0x1.0p52 + low 32 bits of a */ low.x |= a & UINT64_C(0x00000000ffffffff); /* 0x1.0p52 + low 32 bits of a */
const double high_addend = high.d - twop84_plus_twop52; const double high_addend = high.d - twop84_plus_twop52;
/* At this point, we have two double precision numbers /* At this point, we have two double precision numbers
* high_addend and low.d, and we wish to return their sum * high_addend and low.d, and we wish to return their sum
* as a canonicalized long double: * as a canonicalized long double:
*/ */
/* This implementation sets the inexact flag spuriously. */ /* This implementation sets the inexact flag spuriously. */
/* This could be avoided, but at some substantial cost. */ /* This could be avoided, but at some substantial cost. */
DD result; DD result;
result.s.hi = high_addend + low.d; result.s.hi = high_addend + low.d;
result.s.lo = (high_addend - result.s.hi) + low.d; result.s.lo = (high_addend - result.s.hi) + low.d;
return result.ld; return result.ld;
} }

compiler-rt/trunk/lib/builtins/ppc/gcc_qadd.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __gcc_qadd(long double x, long double y); /* long double __gcc_qadd(long double x, long double y);
* This file implements the PowerPC 128-bit double-double add operation. * This file implements the PowerPC 128-bit double-double add operation.
* This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!) * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
*/ */
#include "DD.h" #include "DD.h"
long double __gcc_qadd(long double x, long double y) long double __gcc_qadd(long double x, long double y) {
{
static const uint32_t infinityHi = UINT32_C(0x7ff00000); static const uint32_t infinityHi = UINT32_C(0x7ff00000);
DD dst = { .ld = x }, src = { .ld = y }; DD dst = {.ld = x}, src = {.ld = y};
register double A = dst.s.hi, a = dst.s.lo, register double A = dst.s.hi, a = dst.s.lo, B = src.s.hi, b = src.s.lo;
B = src.s.hi, b = src.s.lo;
/* If both operands are zero: */ /* If both operands are zero: */
if ((A == 0.0) && (B == 0.0)) { if ((A == 0.0) && (B == 0.0)) {
dst.s.hi = A + B; dst.s.hi = A + B;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
/* If either operand is NaN or infinity: */ /* If either operand is NaN or infinity: */
const doublebits abits = { .d = A }; const doublebits abits = {.d = A};
const doublebits bbits = { .d = B }; const doublebits bbits = {.d = B};
if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) || if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
(((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) { (((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
dst.s.hi = A + B; dst.s.hi = A + B;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
/* If the computation overflows: */ /* If the computation overflows: */
/* This may be playing things a little bit fast and loose, but it will do for a start. */ /* This may be playing things a little bit fast and loose, but it will do for
* a start. */
const double testForOverflow = A + (B + (a + b)); const double testForOverflow = A + (B + (a + b));
const doublebits testbits = { .d = testForOverflow }; const doublebits testbits = {.d = testForOverflow};
if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) { if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
dst.s.hi = testForOverflow; dst.s.hi = testForOverflow;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
double H, h; double H, h;
double T, t; double T, t;
double W, w; double W, w;
double Y; double Y;
H = B + (A - (A + B)); H = B + (A - (A + B));
T = b + (a - (a + b)); T = b + (a - (a + b));
h = A + (B - (A + B)); h = A + (B - (A + B));
t = a + (b - (a + b)); t = a + (b - (a + b));
if (local_fabs(A) <= local_fabs(B)) if (local_fabs(A) <= local_fabs(B))
w = (a + b) + h; w = (a + b) + h;
else else
w = (a + b) + H; w = (a + b) + H;
W = (A + B) + w; W = (A + B) + w;
Y = (A + B) - W; Y = (A + B) - W;
Y += w; Y += w;
if (local_fabs(a) <= local_fabs(b)) if (local_fabs(a) <= local_fabs(b))
w = t + Y; w = t + Y;
else else
w = T + Y; w = T + Y;
dst.s.hi = Y = W + w; dst.s.hi = Y = W + w;
dst.s.lo = (W - Y) + w; dst.s.lo = (W - Y) + w;
return dst.ld; return dst.ld;
} }

compiler-rt/trunk/lib/builtins/ppc/gcc_qdiv.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __gcc_qdiv(long double x, long double y); /* long double __gcc_qdiv(long double x, long double y);
* This file implements the PowerPC 128-bit double-double division operation. * This file implements the PowerPC 128-bit double-double division operation.
* This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!) * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
*/ */
#include "DD.h" #include "DD.h"
long double __gcc_qdiv(long double a, long double b) long double __gcc_qdiv(long double a, long double b) {
{
static const uint32_t infinityHi = UINT32_C(0x7ff00000); static const uint32_t infinityHi = UINT32_C(0x7ff00000);
DD dst = { .ld = a }, src = { .ld = b }; DD dst = {.ld = a}, src = {.ld = b};
register double x = dst.s.hi, x1 = dst.s.lo, register double x = dst.s.hi, x1 = dst.s.lo, y = src.s.hi, y1 = src.s.lo;
y = src.s.hi, y1 = src.s.lo;
double yHi, yLo, qHi, qLo; double yHi, yLo, qHi, qLo;
double yq, tmp, q; double yq, tmp, q;
q = x / y; q = x / y;
/* Detect special cases */ /* Detect special cases */
if (q == 0.0) { if (q == 0.0) {
dst.s.hi = q; dst.s.hi = q;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
const doublebits qBits = { .d = q }; const doublebits qBits = {.d = q};
if (((uint32_t)(qBits.x >> 32) & infinityHi) == infinityHi) { if (((uint32_t)(qBits.x >> 32) & infinityHi) == infinityHi) {
dst.s.hi = q; dst.s.hi = q;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
yHi = high26bits(y); yHi = high26bits(y);
qHi = high26bits(q); qHi = high26bits(q);
yq = y * q; yq = y * q;
yLo = y - yHi; yLo = y - yHi;
qLo = q - qHi; qLo = q - qHi;
tmp = LOWORDER(yq, yHi, yLo, qHi, qLo); tmp = LOWORDER(yq, yHi, yLo, qHi, qLo);
tmp = (x - yq) - tmp; tmp = (x - yq) - tmp;
tmp = ((tmp + x1) - y1 * q) / y; tmp = ((tmp + x1) - y1 * q) / y;
x = q + tmp; x = q + tmp;
dst.s.lo = (q - x) + tmp; dst.s.lo = (q - x) + tmp;
dst.s.hi = x; dst.s.hi = x;
return dst.ld; return dst.ld;
} }

compiler-rt/trunk/lib/builtins/ppc/gcc_qmul.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __gcc_qmul(long double x, long double y); /* long double __gcc_qmul(long double x, long double y);
* This file implements the PowerPC 128-bit double-double multiply operation. * This file implements the PowerPC 128-bit double-double multiply operation.
* This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!) * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
*/ */
#include "DD.h" #include "DD.h"
long double __gcc_qmul(long double x, long double y) long double __gcc_qmul(long double x, long double y) {
{
static const uint32_t infinityHi = UINT32_C(0x7ff00000); static const uint32_t infinityHi = UINT32_C(0x7ff00000);
DD dst = { .ld = x }, src = { .ld = y }; DD dst = {.ld = x}, src = {.ld = y};
register double A = dst.s.hi, a = dst.s.lo, register double A = dst.s.hi, a = dst.s.lo, B = src.s.hi, b = src.s.lo;
B = src.s.hi, b = src.s.lo;
double aHi, aLo, bHi, bLo; double aHi, aLo, bHi, bLo;
double ab, tmp, tau; double ab, tmp, tau;
ab = A * B; ab = A * B;
/* Detect special cases */ /* Detect special cases */
if (ab == 0.0) { if (ab == 0.0) {
dst.s.hi = ab; dst.s.hi = ab;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
const doublebits abBits = { .d = ab }; const doublebits abBits = {.d = ab};
if (((uint32_t)(abBits.x >> 32) & infinityHi) == infinityHi) { if (((uint32_t)(abBits.x >> 32) & infinityHi) == infinityHi) {
dst.s.hi = ab; dst.s.hi = ab;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
/* Generic cases handled here. */ /* Generic cases handled here. */
aHi = high26bits(A); aHi = high26bits(A);
bHi = high26bits(B); bHi = high26bits(B);
aLo = A - aHi; aLo = A - aHi;
bLo = B - bHi; bLo = B - bHi;
tmp = LOWORDER(ab, aHi, aLo, bHi, bLo); tmp = LOWORDER(ab, aHi, aLo, bHi, bLo);
tmp += (A * b + a * B); tmp += (A * b + a * B);
tau = ab + tmp; tau = ab + tmp;
dst.s.lo = (ab - tau) + tmp; dst.s.lo = (ab - tau) + tmp;
dst.s.hi = tau; dst.s.hi = tau;
return dst.ld; return dst.ld;
} }

compiler-rt/trunk/lib/builtins/ppc/gcc_qsub.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __gcc_qsub(long double x, long double y); /* long double __gcc_qsub(long double x, long double y);
* This file implements the PowerPC 128-bit double-double add operation. * This file implements the PowerPC 128-bit double-double add operation.
* This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!) * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
*/ */
#include "DD.h" #include "DD.h"
long double __gcc_qsub(long double x, long double y) long double __gcc_qsub(long double x, long double y) {
{
static const uint32_t infinityHi = UINT32_C(0x7ff00000); static const uint32_t infinityHi = UINT32_C(0x7ff00000);
DD dst = { .ld = x }, src = { .ld = y }; DD dst = {.ld = x}, src = {.ld = y};
register double A = dst.s.hi, a = dst.s.lo, register double A = dst.s.hi, a = dst.s.lo, B = -src.s.hi, b = -src.s.lo;
B = -src.s.hi, b = -src.s.lo;
/* If both operands are zero: */ /* If both operands are zero: */
if ((A == 0.0) && (B == 0.0)) { if ((A == 0.0) && (B == 0.0)) {
dst.s.hi = A + B; dst.s.hi = A + B;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
/* If either operand is NaN or infinity: */ /* If either operand is NaN or infinity: */
const doublebits abits = { .d = A }; const doublebits abits = {.d = A};
const doublebits bbits = { .d = B }; const doublebits bbits = {.d = B};
if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) || if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
(((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) { (((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
dst.s.hi = A + B; dst.s.hi = A + B;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
/* If the computation overflows: */ /* If the computation overflows: */
/* This may be playing things a little bit fast and loose, but it will do for a start. */ /* This may be playing things a little bit fast and loose, but it will do for
* a start. */
const double testForOverflow = A + (B + (a + b)); const double testForOverflow = A + (B + (a + b));
const doublebits testbits = { .d = testForOverflow }; const doublebits testbits = {.d = testForOverflow};
if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) { if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
dst.s.hi = testForOverflow; dst.s.hi = testForOverflow;
dst.s.lo = 0.0; dst.s.lo = 0.0;
return dst.ld; return dst.ld;
} }
double H, h; double H, h;
double T, t; double T, t;
double W, w; double W, w;
double Y; double Y;
H = B + (A - (A + B)); H = B + (A - (A + B));
T = b + (a - (a + b)); T = b + (a - (a + b));
h = A + (B - (A + B)); h = A + (B - (A + B));
t = a + (b - (a + b)); t = a + (b - (a + b));
if (local_fabs(A) <= local_fabs(B)) if (local_fabs(A) <= local_fabs(B))
w = (a + b) + h; w = (a + b) + h;
else else
w = (a + b) + H; w = (a + b) + H;
W = (A + B) + w; W = (A + B) + w;
Y = (A + B) - W; Y = (A + B) - W;
Y += w; Y += w;
if (local_fabs(a) <= local_fabs(b)) if (local_fabs(a) <= local_fabs(b))
w = t + Y; w = t + Y;
else else
w = T + Y; w = T + Y;
dst.s.hi = Y = W + w; dst.s.hi = Y = W + w;
dst.s.lo = (W - Y) + w; dst.s.lo = (W - Y) + w;
return dst.ld; return dst.ld;
} }

compiler-rt/trunk/lib/builtins/ppc/multc3.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
#include "DD.h"
#include "../int_math.h" #include "../int_math.h"
#include "DD.h"
#define makeFinite(x) { \ #define makeFinite(x) \
{ \
(x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \ (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
(x).s.lo = 0.0; \ (x).s.lo = 0.0; \
} }
#define zeroNaN(x) { \ #define zeroNaN(x) \
{ \
if (crt_isnan((x).s.hi)) { \ if (crt_isnan((x).s.hi)) { \
(x).s.hi = crt_copysign(0.0, (x).s.hi); \ (x).s.hi = crt_copysign(0.0, (x).s.hi); \
(x).s.lo = 0.0; \ (x).s.lo = 0.0; \
} \ } \
} }
long double _Complex long double _Complex __multc3(long double a, long double b, long double c,
__multc3(long double a, long double b, long double c, long double d) long double d) {
{
long double ac = __gcc_qmul(a,c); long double ac = __gcc_qmul(a, c);
long double bd = __gcc_qmul(b,d); long double bd = __gcc_qmul(b, d);
long double ad = __gcc_qmul(a,d); long double ad = __gcc_qmul(a, d);
long double bc = __gcc_qmul(b,c); long double bc = __gcc_qmul(b, c);
DD real = { .ld = __gcc_qsub(ac,bd) }; DD real = {.ld = __gcc_qsub(ac, bd)};
DD imag = { .ld = __gcc_qadd(ad,bc) }; DD imag = {.ld = __gcc_qadd(ad, bc)};
if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi)) if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi)) {
{
int recalc = 0; int recalc = 0;
DD aDD = { .ld = a }; DD aDD = {.ld = a};
DD bDD = { .ld = b }; DD bDD = {.ld = b};
DD cDD = { .ld = c }; DD cDD = {.ld = c};
DD dDD = { .ld = d }; DD dDD = {.ld = d};
if (crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) if (crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) {
{
makeFinite(aDD); makeFinite(aDD);
makeFinite(bDD); makeFinite(bDD);
zeroNaN(cDD); zeroNaN(cDD);
zeroNaN(dDD); zeroNaN(dDD);
recalc = 1; recalc = 1;
} }
if (crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) if (crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) {
{
makeFinite(cDD); makeFinite(cDD);
makeFinite(dDD); makeFinite(dDD);
zeroNaN(aDD); zeroNaN(aDD);
zeroNaN(bDD); zeroNaN(bDD);
recalc = 1; recalc = 1;
} }
if (!recalc) if (!recalc) {
{
DD acDD = { .ld = ac }; DD acDD = {.ld = ac};
DD bdDD = { .ld = bd }; DD bdDD = {.ld = bd};
DD adDD = { .ld = ad }; DD adDD = {.ld = ad};
DD bcDD = { .ld = bc }; DD bcDD = {.ld = bc};
if (crt_isinf(acDD.s.hi) || crt_isinf(bdDD.s.hi) || if (crt_isinf(acDD.s.hi) || crt_isinf(bdDD.s.hi) ||
crt_isinf(adDD.s.hi) || crt_isinf(bcDD.s.hi)) crt_isinf(adDD.s.hi) || crt_isinf(bcDD.s.hi)) {
{
zeroNaN(aDD); zeroNaN(aDD);
zeroNaN(bDD); zeroNaN(bDD);
zeroNaN(cDD); zeroNaN(cDD);
zeroNaN(dDD); zeroNaN(dDD);
recalc = 1; recalc = 1;
} }
} }
if (recalc) if (recalc) {
{
real.s.hi = CRT_INFINITY * (aDD.s.hi*cDD.s.hi - bDD.s.hi*dDD.s.hi); real.s.hi = CRT_INFINITY * (aDD.s.hi * cDD.s.hi - bDD.s.hi * dDD.s.hi);
real.s.lo = 0.0; real.s.lo = 0.0;
imag.s.hi = CRT_INFINITY * (aDD.s.hi*dDD.s.hi + bDD.s.hi*cDD.s.hi); imag.s.hi = CRT_INFINITY * (aDD.s.hi * dDD.s.hi + bDD.s.hi * cDD.s.hi);
imag.s.lo = 0.0; imag.s.lo = 0.0;
} }
} }
long double _Complex z; long double _Complex z;
__real__ z = real.ld; __real__ z = real.ld;
__imag__ z = imag.ld; __imag__ z = imag.ld;
return z; return z;
} }

compiler-rt/trunk/lib/builtins/subdf3.c

Show All 9 Lines
// IEEE-754 default rounding (to nearest, ties to even). // IEEE-754 default rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
// Subtraction; flip the sign bit of b and add. // Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __subdf3(fp_t a, fp_t b) {
__subdf3(fp_t a, fp_t b) {
return __adddf3(a, fromRep(toRep(b) ^ signBit)); return __adddf3(a, fromRep(toRep(b) ^ signBit));
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) { AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) { return __subdf3(a, b); }
return __subdf3(a, b);
}
#else #else
AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) COMPILER_RT_ALIAS(__subdf3); AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) COMPILER_RT_ALIAS(__subdf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/subsf3.c

Show All 9 Lines
// IEEE-754 default rounding (to nearest, ties to even). // IEEE-754 default rounding (to nearest, ties to even).
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
// Subtraction; flip the sign bit of b and add. // Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __subsf3(fp_t a, fp_t b) {
__subsf3(fp_t a, fp_t b) {
return __addsf3(a, fromRep(toRep(b) ^ signBit)); return __addsf3(a, fromRep(toRep(b) ^ signBit));
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) { AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) { return __subsf3(a, b); }
return __subsf3(a, b);
}
#else #else
AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) COMPILER_RT_ALIAS(__subsf3); AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) COMPILER_RT_ALIAS(__subsf3);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/subtf3.c

Show All 12 Lines
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b); COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b);
// Subtraction; flip the sign bit of b and add. // Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t COMPILER_RT_ABI fp_t __subtf3(fp_t a, fp_t b) {
__subtf3(fp_t a, fp_t b) {
return __addtf3(a, fromRep(toRep(b) ^ signBit)); return __addtf3(a, fromRep(toRep(b) ^ signBit));
} }
#endif #endif

compiler-rt/trunk/lib/builtins/subvdi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a - b */ /* Returns: a - b */
/* Effects: aborts if a - b overflows */ /* Effects: aborts if a - b overflows */
COMPILER_RT_ABI di_int COMPILER_RT_ABI di_int __subvdi3(di_int a, di_int b) {
__subvdi3(di_int a, di_int b)
{
di_int s = (du_int) a - (du_int) b; di_int s = (du_int)a - (du_int)b;
if (b >= 0) if (b >= 0) {
{
if (s > a) if (s > a)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (s <= a) if (s <= a)
compilerrt_abort(); compilerrt_abort();
} }
return s; return s;
} }

compiler-rt/trunk/lib/builtins/subvsi3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a - b */ /* Returns: a - b */
/* Effects: aborts if a - b overflows */ /* Effects: aborts if a - b overflows */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __subvsi3(si_int a, si_int b) {
__subvsi3(si_int a, si_int b)
{
si_int s = (su_int) a - (su_int) b; si_int s = (su_int)a - (su_int)b;
if (b >= 0) if (b >= 0) {
{
if (s > a) if (s > a)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (s <= a) if (s <= a)
compilerrt_abort(); compilerrt_abort();
} }
return s; return s;
} }

compiler-rt/trunk/lib/builtins/subvti3.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a - b */ /* Returns: a - b */
/* Effects: aborts if a - b overflows */ /* Effects: aborts if a - b overflows */
COMPILER_RT_ABI ti_int COMPILER_RT_ABI ti_int __subvti3(ti_int a, ti_int b) {
__subvti3(ti_int a, ti_int b)
{
ti_int s = (tu_int) a - (tu_int) b; ti_int s = (tu_int)a - (tu_int)b;
if (b >= 0) if (b >= 0) {
{
if (s > a) if (s > a)
compilerrt_abort(); compilerrt_abort();
} } else {
else
{
if (s <= a) if (s <= a)
compilerrt_abort(); compilerrt_abort();
} }
return s; return s;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/trampoline_setup.c

/* ===----- trampoline_setup.c - Implement __trampoline_setup -------------=== /* ===----- trampoline_setup.c - Implement __trampoline_setup -------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
extern void __clear_cache(void* start, void* end); extern void __clear_cache(void *start, void *end);
/* /*
* The ppc compiler generates calls to __trampoline_setup() when creating * The ppc compiler generates calls to __trampoline_setup() when creating
* trampoline functions on the stack for use with nested functions. * trampoline functions on the stack for use with nested functions.
* This function creates a custom 40-byte trampoline function on the stack * This function creates a custom 40-byte trampoline function on the stack
* which loads r11 with a pointer to the outer function's locals * which loads r11 with a pointer to the outer function's locals
* and then jumps to the target nested function. * and then jumps to the target nested function.
*/ */
#if __ppc__ && !defined(__powerpc64__) #if __ppc__ && !defined(__powerpc64__)
COMPILER_RT_ABI void COMPILER_RT_ABI void __trampoline_setup(uint32_t *trampOnStack,
__trampoline_setup(uint32_t* trampOnStack, int trampSizeAllocated, int trampSizeAllocated,
const void* realFunc, void* localsPtr) const void *realFunc, void *localsPtr) {
{
/* should never happen, but if compiler did not allocate */ /* should never happen, but if compiler did not allocate */
/* enough space on stack for the trampoline, abort */ /* enough space on stack for the trampoline, abort */
if ( trampSizeAllocated < 40 ) if (trampSizeAllocated < 40)
compilerrt_abort(); compilerrt_abort();
/* create trampoline */ /* create trampoline */
trampOnStack[0] = 0x7c0802a6; /* mflr r0 */ trampOnStack[0] = 0x7c0802a6; /* mflr r0 */
trampOnStack[1] = 0x4800000d; /* bl Lbase */ trampOnStack[1] = 0x4800000d; /* bl Lbase */
trampOnStack[2] = (uint32_t)realFunc; trampOnStack[2] = (uint32_t)realFunc;
trampOnStack[3] = (uint32_t)localsPtr; trampOnStack[3] = (uint32_t)localsPtr;
trampOnStack[4] = 0x7d6802a6; /* Lbase: mflr r11 */ trampOnStack[4] = 0x7d6802a6; /* Lbase: mflr r11 */
trampOnStack[5] = 0x818b0000; /* lwz r12,0(r11) */ trampOnStack[5] = 0x818b0000; /* lwz r12,0(r11) */
trampOnStack[6] = 0x7c0803a6; /* mtlr r0 */ trampOnStack[6] = 0x7c0803a6; /* mtlr r0 */
trampOnStack[7] = 0x7d8903a6; /* mtctr r12 */ trampOnStack[7] = 0x7d8903a6; /* mtctr r12 */
trampOnStack[8] = 0x816b0004; /* lwz r11,4(r11) */ trampOnStack[8] = 0x816b0004; /* lwz r11,4(r11) */
trampOnStack[9] = 0x4e800420; /* bctr */ trampOnStack[9] = 0x4e800420; /* bctr */
/* clear instruction cache */ /* clear instruction cache */
__clear_cache(trampOnStack, &trampOnStack[10]); __clear_cache(trampOnStack, &trampOnStack[10]);
} }
#endif /* __ppc__ && !defined(__powerpc64__) */ #endif /* __ppc__ && !defined(__powerpc64__) */

compiler-rt/trunk/lib/builtins/truncdfhf2.c

//===-- lib/truncdfhf2.c - double -> half conversion --------------*- C -*-===// //===-- lib/truncdfhf2.c - double -> half conversion --------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SRC_DOUBLE #define SRC_DOUBLE
#define DST_HALF #define DST_HALF
#include "fp_trunc_impl.inc" #include "fp_trunc_impl.inc"
COMPILER_RT_ABI uint16_t __truncdfhf2(double a) { COMPILER_RT_ABI uint16_t __truncdfhf2(double a) { return __truncXfYf2__(a); }
return __truncXfYf2__(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI uint16_t __aeabi_d2h(double a) { AEABI_RTABI uint16_t __aeabi_d2h(double a) { return __truncdfhf2(a); }
return __truncdfhf2(a);
}
#else #else
AEABI_RTABI uint16_t __aeabi_d2h(double a) COMPILER_RT_ALIAS(__truncdfhf2); AEABI_RTABI uint16_t __aeabi_d2h(double a) COMPILER_RT_ALIAS(__truncdfhf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/truncdfsf2.c

//===-- lib/truncdfsf2.c - double -> single conversion ------------*- C -*-===// //===-- lib/truncdfsf2.c - double -> single conversion ------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SRC_DOUBLE #define SRC_DOUBLE
#define DST_SINGLE #define DST_SINGLE
#include "fp_trunc_impl.inc" #include "fp_trunc_impl.inc"
COMPILER_RT_ABI float __truncdfsf2(double a) { COMPILER_RT_ABI float __truncdfsf2(double a) { return __truncXfYf2__(a); }
return __truncXfYf2__(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_d2f(double a) { AEABI_RTABI float __aeabi_d2f(double a) { return __truncdfsf2(a); }
return __truncdfsf2(a);
}
#else #else
AEABI_RTABI float __aeabi_d2f(double a) COMPILER_RT_ALIAS(__truncdfsf2); AEABI_RTABI float __aeabi_d2f(double a) COMPILER_RT_ALIAS(__truncdfsf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/truncsfhf2.c

//===-- lib/truncsfhf2.c - single -> half conversion --------------*- C -*-===// //===-- lib/truncsfhf2.c - single -> half conversion --------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SRC_SINGLE #define SRC_SINGLE
#define DST_HALF #define DST_HALF
#include "fp_trunc_impl.inc" #include "fp_trunc_impl.inc"
// Use a forwarding definition and noinline to implement a poor man's alias, // Use a forwarding definition and noinline to implement a poor man's alias,
// as there isn't a good cross-platform way of defining one. // as there isn't a good cross-platform way of defining one.
COMPILER_RT_ABI NOINLINE uint16_t __truncsfhf2(float a) { COMPILER_RT_ABI NOINLINE uint16_t __truncsfhf2(float a) {
return __truncXfYf2__(a); return __truncXfYf2__(a);
} }
COMPILER_RT_ABI uint16_t __gnu_f2h_ieee(float a) { COMPILER_RT_ABI uint16_t __gnu_f2h_ieee(float a) { return __truncsfhf2(a); }
return __truncsfhf2(a);
}
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI uint16_t __aeabi_f2h(float a) { AEABI_RTABI uint16_t __aeabi_f2h(float a) { return __truncsfhf2(a); }
return __truncsfhf2(a);
}
#else #else
AEABI_RTABI uint16_t __aeabi_f2h(float a) COMPILER_RT_ALIAS(__truncsfhf2); AEABI_RTABI uint16_t __aeabi_f2h(float a) COMPILER_RT_ALIAS(__truncsfhf2);
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/trunctfdf2.c

//===-- lib/truncdfsf2.c - quad -> double conversion --------------*- C -*-===// //===-- lib/truncdfsf2.c - quad -> double conversion --------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#define SRC_QUAD #define SRC_QUAD
#define DST_DOUBLE #define DST_DOUBLE
#include "fp_trunc_impl.inc" #include "fp_trunc_impl.inc"
COMPILER_RT_ABI double __trunctfdf2(long double a) { COMPILER_RT_ABI double __trunctfdf2(long double a) { return __truncXfYf2__(a); }
return __truncXfYf2__(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/trunctfsf2.c

//===-- lib/trunctfsf2.c - quad -> single conversion --------------*- C -*-===// //===-- lib/trunctfsf2.c - quad -> single conversion --------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#define SRC_QUAD #define SRC_QUAD
#define DST_SINGLE #define DST_SINGLE
#include "fp_trunc_impl.inc" #include "fp_trunc_impl.inc"
COMPILER_RT_ABI float __trunctfsf2(long double a) { COMPILER_RT_ABI float __trunctfsf2(long double a) { return __truncXfYf2__(a); }
return __truncXfYf2__(a);
}
#endif #endif

compiler-rt/trunk/lib/builtins/ucmpdi2.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
/* Returns: if (a < b) returns 0 /* Returns: if (a < b) returns 0
* if (a == b) returns 1 * if (a == b) returns 1
* if (a > b) returns 2 * if (a > b) returns 2
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ucmpdi2(du_int a, du_int b) {
__ucmpdi2(du_int a, du_int b)
{
udwords x; udwords x;
x.all = a; x.all = a;
udwords y; udwords y;
y.all = b; y.all = b;
if (x.s.high < y.s.high) if (x.s.high < y.s.high)
return 0; return 0;
if (x.s.high > y.s.high) if (x.s.high > y.s.high)
return 2; return 2;
if (x.s.low < y.s.low) if (x.s.low < y.s.low)
return 0; return 0;
if (x.s.low > y.s.low) if (x.s.low > y.s.low)
return 2; return 2;
return 1; return 1;
} }
#ifdef __ARM_EABI__ #ifdef __ARM_EABI__
/* Returns: if (a < b) returns -1 /* Returns: if (a < b) returns -1
* if (a == b) returns 0 * if (a == b) returns 0
* if (a > b) returns 1 * if (a > b) returns 1
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __aeabi_ulcmp(di_int a, di_int b) {
__aeabi_ulcmp(di_int a, di_int b)
{
return __ucmpdi2(a, b) - 1; return __ucmpdi2(a, b) - 1;
} }
#endif #endif

compiler-rt/trunk/lib/builtins/ucmpti2.c

Show All 14 Lines
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: if (a < b) returns 0 /* Returns: if (a < b) returns 0
* if (a == b) returns 1 * if (a == b) returns 1
* if (a > b) returns 2 * if (a > b) returns 2
*/ */
COMPILER_RT_ABI si_int COMPILER_RT_ABI si_int __ucmpti2(tu_int a, tu_int b) {
__ucmpti2(tu_int a, tu_int b)
{
utwords x; utwords x;
x.all = a; x.all = a;
utwords y; utwords y;
y.all = b; y.all = b;
if (x.s.high < y.s.high) if (x.s.high < y.s.high)
return 0; return 0;
if (x.s.high > y.s.high) if (x.s.high > y.s.high)
return 2; return 2;
if (x.s.low < y.s.low) if (x.s.low < y.s.low)
return 0; return 0;
if (x.s.low > y.s.low) if (x.s.low > y.s.low)
return 2; return 2;
return 1; return 1;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/udivdi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ /* Returns: a / b */
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b) {
__udivdi3(du_int a, du_int b)
{
return __udivmoddi4(a, b, 0); return __udivmoddi4(a, b, 0);
} }

compiler-rt/trunk/lib/builtins/udivmoddi4.c

Show All 13 Lines
#include "int_lib.h" #include "int_lib.h"
/* Effects: if rem != 0, *rem = a % b /* Effects: if rem != 0, *rem = a % b
* Returns: a / b * Returns: a / b
*/ */
/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */ /* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int *rem) {
__udivmoddi4(du_int a, du_int b, du_int* rem)
{
const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT; const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;
const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT; const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT;
udwords n; udwords n;
n.all = a; n.all = a;
udwords d; udwords d;
d.all = b; d.all = b;
udwords q; udwords q;
udwords r; udwords r;
unsigned sr; unsigned sr;
/* special cases, X is unknown, K != 0 */ /* special cases, X is unknown, K != 0 */
if (n.s.high == 0) if (n.s.high == 0) {
{ if (d.s.high == 0) {
if (d.s.high == 0)
{
/* 0 X /* 0 X
* --- * ---
* 0 X * 0 X
*/ */
if (rem) if (rem)
*rem = n.s.low % d.s.low; *rem = n.s.low % d.s.low;
return n.s.low / d.s.low; return n.s.low / d.s.low;
} }
/* 0 X /* 0 X
* --- * ---
* K X * K X
*/ */
if (rem) if (rem)
*rem = n.s.low; *rem = n.s.low;
return 0; return 0;
} }
/* n.s.high != 0 */ /* n.s.high != 0 */
if (d.s.low == 0) if (d.s.low == 0) {
{ if (d.s.high == 0) {
if (d.s.high == 0)
{
/* K X /* K X
* --- * ---
* 0 0 * 0 0
*/ */
if (rem) if (rem)
*rem = n.s.high % d.s.low; *rem = n.s.high % d.s.low;
return n.s.high / d.s.low; return n.s.high / d.s.low;
} }
/* d.s.high != 0 */ /* d.s.high != 0 */
if (n.s.low == 0) if (n.s.low == 0) {
{
/* K 0 /* K 0
* --- * ---
* K 0 * K 0
*/ */
if (rem) if (rem) {
{
r.s.high = n.s.high % d.s.high; r.s.high = n.s.high % d.s.high;
r.s.low = 0; r.s.low = 0;
*rem = r.all; *rem = r.all;
} }
return n.s.high / d.s.high; return n.s.high / d.s.high;
} }
/* K K /* K K
* --- * ---
* K 0 * K 0
*/ */
if ((d.s.high & (d.s.high - 1)) == 0) /* if d is a power of 2 */ if ((d.s.high & (d.s.high - 1)) == 0) /* if d is a power of 2 */
{ {
if (rem) if (rem) {
{
r.s.low = n.s.low; r.s.low = n.s.low;
r.s.high = n.s.high & (d.s.high - 1); r.s.high = n.s.high & (d.s.high - 1);
*rem = r.all; *rem = r.all;
} }
return n.s.high >> __builtin_ctz(d.s.high); return n.s.high >> __builtin_ctz(d.s.high);
} }
/* K K /* K K
* --- * ---
* K 0 * K 0
*/ */
sr = __builtin_clz(d.s.high) - __builtin_clz(n.s.high); sr = __builtin_clz(d.s.high) - __builtin_clz(n.s.high);
/* 0 <= sr <= n_uword_bits - 2 or sr large */ /* 0 <= sr <= n_uword_bits - 2 or sr large */
if (sr > n_uword_bits - 2) if (sr > n_uword_bits - 2) {
{
if (rem) if (rem)
*rem = n.all; *rem = n.all;
return 0; return 0;
} }
++sr; ++sr;
/* 1 <= sr <= n_uword_bits - 1 */ /* 1 <= sr <= n_uword_bits - 1 */
/* q.all = n.all << (n_udword_bits - sr); */ /* q.all = n.all << (n_udword_bits - sr); */
q.s.low = 0; q.s.low = 0;
q.s.high = n.s.low << (n_uword_bits - sr); q.s.high = n.s.low << (n_uword_bits - sr);
/* r.all = n.all >> sr; */ /* r.all = n.all >> sr; */
r.s.high = n.s.high >> sr; r.s.high = n.s.high >> sr;
r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr); r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
} } else /* d.s.low != 0 */
else /* d.s.low != 0 */
{
if (d.s.high == 0)
{ {
if (d.s.high == 0) {
/* K X /* K X
* --- * ---
* 0 K * 0 K
*/ */
if ((d.s.low & (d.s.low - 1)) == 0) /* if d is a power of 2 */ if ((d.s.low & (d.s.low - 1)) == 0) /* if d is a power of 2 */
{ {
if (rem) if (rem)
*rem = n.s.low & (d.s.low - 1); *rem = n.s.low & (d.s.low - 1);
if (d.s.low == 1) if (d.s.low == 1)
return n.all; return n.all;
sr = __builtin_ctz(d.s.low); sr = __builtin_ctz(d.s.low);
q.s.high = n.s.high >> sr; q.s.high = n.s.high >> sr;
q.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr); q.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
return q.all; return q.all;
} }
/* K X /* K X
* --- * ---
* 0 K * 0 K
*/ */
sr = 1 + n_uword_bits + __builtin_clz(d.s.low) - __builtin_clz(n.s.high); sr = 1 + n_uword_bits + __builtin_clz(d.s.low) - __builtin_clz(n.s.high);
/* 2 <= sr <= n_udword_bits - 1 /* 2 <= sr <= n_udword_bits - 1
* q.all = n.all << (n_udword_bits - sr); * q.all = n.all << (n_udword_bits - sr);
* r.all = n.all >> sr; * r.all = n.all >> sr;
*/ */
if (sr == n_uword_bits) if (sr == n_uword_bits) {
{
q.s.low = 0; q.s.low = 0;
q.s.high = n.s.low; q.s.high = n.s.low;
r.s.high = 0; r.s.high = 0;
r.s.low = n.s.high; r.s.low = n.s.high;
} } else if (sr < n_uword_bits) // 2 <= sr <= n_uword_bits - 1
else if (sr < n_uword_bits) // 2 <= sr <= n_uword_bits - 1
{ {
q.s.low = 0; q.s.low = 0;
q.s.high = n.s.low << (n_uword_bits - sr); q.s.high = n.s.low << (n_uword_bits - sr);
r.s.high = n.s.high >> sr; r.s.high = n.s.high >> sr;
r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr); r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
} } else // n_uword_bits + 1 <= sr <= n_udword_bits - 1
else // n_uword_bits + 1 <= sr <= n_udword_bits - 1
{ {
q.s.low = n.s.low << (n_udword_bits - sr); q.s.low = n.s.low << (n_udword_bits - sr);
q.s.high = (n.s.high << (n_udword_bits - sr)) | q.s.high = (n.s.high << (n_udword_bits - sr)) |
(n.s.low >> (sr - n_uword_bits)); (n.s.low >> (sr - n_uword_bits));
r.s.high = 0; r.s.high = 0;
r.s.low = n.s.high >> (sr - n_uword_bits); r.s.low = n.s.high >> (sr - n_uword_bits);
} }
} } else {
else
{
/* K X /* K X
* --- * ---
* K K * K K
*/ */
sr = __builtin_clz(d.s.high) - __builtin_clz(n.s.high); sr = __builtin_clz(d.s.high) - __builtin_clz(n.s.high);
/* 0 <= sr <= n_uword_bits - 1 or sr large */ /* 0 <= sr <= n_uword_bits - 1 or sr large */
if (sr > n_uword_bits - 1) if (sr > n_uword_bits - 1) {
{
if (rem) if (rem)
*rem = n.all; *rem = n.all;
return 0; return 0;
} }
++sr; ++sr;
/* 1 <= sr <= n_uword_bits */ /* 1 <= sr <= n_uword_bits */
/* q.all = n.all << (n_udword_bits - sr); */ /* q.all = n.all << (n_udword_bits - sr); */
q.s.low = 0; q.s.low = 0;
if (sr == n_uword_bits) if (sr == n_uword_bits) {
{
q.s.high = n.s.low; q.s.high = n.s.low;
r.s.high = 0; r.s.high = 0;
r.s.low = n.s.high; r.s.low = n.s.high;
} } else {
else
{
q.s.high = n.s.low << (n_uword_bits - sr); q.s.high = n.s.low << (n_uword_bits - sr);
r.s.high = n.s.high >> sr; r.s.high = n.s.high >> sr;
r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr); r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
} }
} }
} }
/* Not a special case /* Not a special case
* q and r are initialized with: * q and r are initialized with:
* q.all = n.all << (n_udword_bits - sr); * q.all = n.all << (n_udword_bits - sr);
* r.all = n.all >> sr; * r.all = n.all >> sr;
* 1 <= sr <= n_udword_bits - 1 * 1 <= sr <= n_udword_bits - 1
*/ */
su_int carry = 0; su_int carry = 0;
for (; sr > 0; --sr) for (; sr > 0; --sr) {
{
/* r:q = ((r:q) << 1) | carry */ /* r:q = ((r:q) << 1) | carry */
r.s.high = (r.s.high << 1) | (r.s.low >> (n_uword_bits - 1)); r.s.high = (r.s.high << 1) | (r.s.low >> (n_uword_bits - 1));
r.s.low = (r.s.low << 1) | (q.s.high >> (n_uword_bits - 1)); r.s.low = (r.s.low << 1) | (q.s.high >> (n_uword_bits - 1));
q.s.high = (q.s.high << 1) | (q.s.low >> (n_uword_bits - 1)); q.s.high = (q.s.high << 1) | (q.s.low >> (n_uword_bits - 1));
q.s.low = (q.s.low << 1) | carry; q.s.low = (q.s.low << 1) | carry;
/* carry = 0; /* carry = 0;
* if (r.all >= d.all) * if (r.all >= d.all)
* { * {
* r.all -= d.all; * r.all -= d.all;
* carry = 1; * carry = 1;
* } * }
*/ */
const di_int s = (di_int)(d.all - r.all - 1) >> (n_udword_bits - 1); const di_int s = (di_int)(d.all - r.all - 1) >> (n_udword_bits - 1);
carry = s & 1; carry = s & 1;
r.all -= d.all & s; r.all -= d.all & s;
} }
q.all = (q.all << 1) | carry; q.all = (q.all << 1) | carry;
if (rem) if (rem)
*rem = r.all; *rem = r.all;
return q.all; return q.all;
} }

compiler-rt/trunk/lib/builtins/udivmodsi4.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b, *rem = a % b */ /* Returns: a / b, *rem = a % b */
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int *rem) {
__udivmodsi4(su_int a, su_int b, su_int* rem)
{
si_int d = __udivsi3(a,b); si_int d = __udivsi3(a, b);
*rem = a - (d*b); *rem = a - (d * b);
return d; return d;
} }

compiler-rt/trunk/lib/builtins/udivmodti4.c

/* ===-- udivmodti4.c - Implement __udivmodti4 -----------------------------=== /* ===-- udivmodti4.c - Implement __udivmodti4 -----------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
* *
* This file implements __udivmodti4 for the compiler_rt library. * This file implements __udivmodti4 for the compiler_rt library.
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Effects: if rem != 0, *rem = a % b /* Effects: if rem != 0, *rem = a % b
* Returns: a / b * Returns: a / b
*/ */
/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */ /* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int *rem) {
__udivmodti4(tu_int a, tu_int b, tu_int* rem)
{
const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT; const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT;
const unsigned n_utword_bits = sizeof(tu_int) * CHAR_BIT; const unsigned n_utword_bits = sizeof(tu_int) * CHAR_BIT;
utwords n; utwords n;
n.all = a; n.all = a;
utwords d; utwords d;
d.all = b; d.all = b;
utwords q; utwords q;
utwords r; utwords r;
unsigned sr; unsigned sr;
/* special cases, X is unknown, K != 0 */ /* special cases, X is unknown, K != 0 */
if (n.s.high == 0) if (n.s.high == 0) {
{ if (d.s.high == 0) {
if (d.s.high == 0)
{
/* 0 X /* 0 X
* --- * ---
* 0 X * 0 X
*/ */
if (rem) if (rem)
*rem = n.s.low % d.s.low; *rem = n.s.low % d.s.low;
return n.s.low / d.s.low; return n.s.low / d.s.low;
} }
/* 0 X /* 0 X
* --- * ---
* K X * K X
*/ */
if (rem) if (rem)
*rem = n.s.low; *rem = n.s.low;
return 0; return 0;
} }
/* n.s.high != 0 */ /* n.s.high != 0 */
if (d.s.low == 0) if (d.s.low == 0) {
{ if (d.s.high == 0) {
if (d.s.high == 0)
{
/* K X /* K X
* --- * ---
* 0 0 * 0 0
*/ */
if (rem) if (rem)
*rem = n.s.high % d.s.low; *rem = n.s.high % d.s.low;
return n.s.high / d.s.low; return n.s.high / d.s.low;
} }
/* d.s.high != 0 */ /* d.s.high != 0 */
if (n.s.low == 0) if (n.s.low == 0) {
{
/* K 0 /* K 0
* --- * ---
* K 0 * K 0
*/ */
if (rem) if (rem) {
{
r.s.high = n.s.high % d.s.high; r.s.high = n.s.high % d.s.high;
r.s.low = 0; r.s.low = 0;
*rem = r.all; *rem = r.all;
} }
return n.s.high / d.s.high; return n.s.high / d.s.high;
} }
/* K K /* K K
* --- * ---
* K 0 * K 0
*/ */
if ((d.s.high & (d.s.high - 1)) == 0) /* if d is a power of 2 */ if ((d.s.high & (d.s.high - 1)) == 0) /* if d is a power of 2 */
{ {
if (rem) if (rem) {
{
r.s.low = n.s.low; r.s.low = n.s.low;
r.s.high = n.s.high & (d.s.high - 1); r.s.high = n.s.high & (d.s.high - 1);
*rem = r.all; *rem = r.all;
} }
return n.s.high >> __builtin_ctzll(d.s.high); return n.s.high >> __builtin_ctzll(d.s.high);
} }
/* K K /* K K
* --- * ---
* K 0 * K 0
*/ */
sr = __builtin_clzll(d.s.high) - __builtin_clzll(n.s.high); sr = __builtin_clzll(d.s.high) - __builtin_clzll(n.s.high);
/* 0 <= sr <= n_udword_bits - 2 or sr large */ /* 0 <= sr <= n_udword_bits - 2 or sr large */
if (sr > n_udword_bits - 2) if (sr > n_udword_bits - 2) {
{
if (rem) if (rem)
*rem = n.all; *rem = n.all;
return 0; return 0;
} }
++sr; ++sr;
/* 1 <= sr <= n_udword_bits - 1 */ /* 1 <= sr <= n_udword_bits - 1 */
/* q.all = n.all << (n_utword_bits - sr); */ /* q.all = n.all << (n_utword_bits - sr); */
q.s.low = 0; q.s.low = 0;
q.s.high = n.s.low << (n_udword_bits - sr); q.s.high = n.s.low << (n_udword_bits - sr);
/* r.all = n.all >> sr; */ /* r.all = n.all >> sr; */
r.s.high = n.s.high >> sr; r.s.high = n.s.high >> sr;
r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr); r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
} } else /* d.s.low != 0 */
else /* d.s.low != 0 */
{
if (d.s.high == 0)
{ {
if (d.s.high == 0) {
/* K X /* K X
* --- * ---
* 0 K * 0 K
*/ */
if ((d.s.low & (d.s.low - 1)) == 0) /* if d is a power of 2 */ if ((d.s.low & (d.s.low - 1)) == 0) /* if d is a power of 2 */
{ {
if (rem) if (rem)
*rem = n.s.low & (d.s.low - 1); *rem = n.s.low & (d.s.low - 1);
if (d.s.low == 1) if (d.s.low == 1)
return n.all; return n.all;
sr = __builtin_ctzll(d.s.low); sr = __builtin_ctzll(d.s.low);
q.s.high = n.s.high >> sr; q.s.high = n.s.high >> sr;
q.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr); q.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
return q.all; return q.all;
} }
/* K X /* K X
* --- * ---
* 0 K * 0 K
*/ */
sr = 1 + n_udword_bits + __builtin_clzll(d.s.low) sr = 1 + n_udword_bits + __builtin_clzll(d.s.low) -
- __builtin_clzll(n.s.high); __builtin_clzll(n.s.high);
/* 2 <= sr <= n_utword_bits - 1 /* 2 <= sr <= n_utword_bits - 1
* q.all = n.all << (n_utword_bits - sr); * q.all = n.all << (n_utword_bits - sr);
* r.all = n.all >> sr; * r.all = n.all >> sr;
*/ */
if (sr == n_udword_bits) if (sr == n_udword_bits) {
{
q.s.low = 0; q.s.low = 0;
q.s.high = n.s.low; q.s.high = n.s.low;
r.s.high = 0; r.s.high = 0;
r.s.low = n.s.high; r.s.low = n.s.high;
} } else if (sr < n_udword_bits) // 2 <= sr <= n_udword_bits - 1
else if (sr < n_udword_bits) // 2 <= sr <= n_udword_bits - 1
{ {
q.s.low = 0; q.s.low = 0;
q.s.high = n.s.low << (n_udword_bits - sr); q.s.high = n.s.low << (n_udword_bits - sr);
r.s.high = n.s.high >> sr; r.s.high = n.s.high >> sr;
r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr); r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
} } else // n_udword_bits + 1 <= sr <= n_utword_bits - 1
else // n_udword_bits + 1 <= sr <= n_utword_bits - 1
{ {
q.s.low = n.s.low << (n_utword_bits - sr); q.s.low = n.s.low << (n_utword_bits - sr);
q.s.high = (n.s.high << (n_utword_bits - sr)) | q.s.high = (n.s.high << (n_utword_bits - sr)) |
(n.s.low >> (sr - n_udword_bits)); (n.s.low >> (sr - n_udword_bits));
r.s.high = 0; r.s.high = 0;
r.s.low = n.s.high >> (sr - n_udword_bits); r.s.low = n.s.high >> (sr - n_udword_bits);
} }
} } else {
else
{
/* K X /* K X
* --- * ---
* K K * K K
*/ */
sr = __builtin_clzll(d.s.high) - __builtin_clzll(n.s.high); sr = __builtin_clzll(d.s.high) - __builtin_clzll(n.s.high);
/*0 <= sr <= n_udword_bits - 1 or sr large */ /*0 <= sr <= n_udword_bits - 1 or sr large */
if (sr > n_udword_bits - 1) if (sr > n_udword_bits - 1) {
{
if (rem) if (rem)
*rem = n.all; *rem = n.all;
return 0; return 0;
} }
++sr; ++sr;
/* 1 <= sr <= n_udword_bits /* 1 <= sr <= n_udword_bits
* q.all = n.all << (n_utword_bits - sr); * q.all = n.all << (n_utword_bits - sr);
* r.all = n.all >> sr; * r.all = n.all >> sr;
*/ */
q.s.low = 0; q.s.low = 0;
if (sr == n_udword_bits) if (sr == n_udword_bits) {
{
q.s.high = n.s.low; q.s.high = n.s.low;
r.s.high = 0; r.s.high = 0;
r.s.low = n.s.high; r.s.low = n.s.high;
} } else {
else
{
r.s.high = n.s.high >> sr; r.s.high = n.s.high >> sr;
r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr); r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
q.s.high = n.s.low << (n_udword_bits - sr); q.s.high = n.s.low << (n_udword_bits - sr);
} }
} }
} }
/* Not a special case /* Not a special case
* q and r are initialized with: * q and r are initialized with:
* q.all = n.all << (n_utword_bits - sr); * q.all = n.all << (n_utword_bits - sr);
* r.all = n.all >> sr; * r.all = n.all >> sr;
* 1 <= sr <= n_utword_bits - 1 * 1 <= sr <= n_utword_bits - 1
*/ */
su_int carry = 0; su_int carry = 0;
for (; sr > 0; --sr) for (; sr > 0; --sr) {
{
/* r:q = ((r:q) << 1) | carry */ /* r:q = ((r:q) << 1) | carry */
r.s.high = (r.s.high << 1) | (r.s.low >> (n_udword_bits - 1)); r.s.high = (r.s.high << 1) | (r.s.low >> (n_udword_bits - 1));
r.s.low = (r.s.low << 1) | (q.s.high >> (n_udword_bits - 1)); r.s.low = (r.s.low << 1) | (q.s.high >> (n_udword_bits - 1));
q.s.high = (q.s.high << 1) | (q.s.low >> (n_udword_bits - 1)); q.s.high = (q.s.high << 1) | (q.s.low >> (n_udword_bits - 1));
q.s.low = (q.s.low << 1) | carry; q.s.low = (q.s.low << 1) | carry;
/* carry = 0; /* carry = 0;
* if (r.all >= d.all) * if (r.all >= d.all)
* { * {
* r.all -= d.all; * r.all -= d.all;
* carry = 1; * carry = 1;
* } * }
*/ */
const ti_int s = (ti_int)(d.all - r.all - 1) >> (n_utword_bits - 1); const ti_int s = (ti_int)(d.all - r.all - 1) >> (n_utword_bits - 1);
carry = s & 1; carry = s & 1;
r.all -= d.all & s; r.all -= d.all & s;
} }
q.all = (q.all << 1) | carry; q.all = (q.all << 1) | carry;
if (rem) if (rem)
*rem = r.all; *rem = r.all;
return q.all; return q.all;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/udivsi3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ /* Returns: a / b */
/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */ /* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
/* This function should not call __divsi3! */ /* This function should not call __divsi3! */
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d) {
__udivsi3(su_int n, su_int d)
{
const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT; const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;
su_int q; su_int q;
su_int r; su_int r;
unsigned sr; unsigned sr;
/* special cases */ /* special cases */
if (d == 0) if (d == 0)
return 0; /* ?! */ return 0; /* ?! */
if (n == 0) if (n == 0)
return 0; return 0;
sr = __builtin_clz(d) - __builtin_clz(n); sr = __builtin_clz(d) - __builtin_clz(n);
/* 0 <= sr <= n_uword_bits - 1 or sr large */ /* 0 <= sr <= n_uword_bits - 1 or sr large */
if (sr > n_uword_bits - 1) /* d > r */ if (sr > n_uword_bits - 1) /* d > r */
return 0; return 0;
if (sr == n_uword_bits - 1) /* d == 1 */ if (sr == n_uword_bits - 1) /* d == 1 */
return n; return n;
++sr; ++sr;
/* 1 <= sr <= n_uword_bits - 1 */ /* 1 <= sr <= n_uword_bits - 1 */
/* Not a special case */ /* Not a special case */
q = n << (n_uword_bits - sr); q = n << (n_uword_bits - sr);
r = n >> sr; r = n >> sr;
su_int carry = 0; su_int carry = 0;
for (; sr > 0; --sr) for (; sr > 0; --sr) {
{
/* r:q = ((r:q) << 1) | carry */ /* r:q = ((r:q) << 1) | carry */
r = (r << 1) | (q >> (n_uword_bits - 1)); r = (r << 1) | (q >> (n_uword_bits - 1));
q = (q << 1) | carry; q = (q << 1) | carry;
/* carry = 0; /* carry = 0;
* if (r.all >= d.all) * if (r.all >= d.all)
* { * {
* r.all -= d.all; * r.all -= d.all;
* carry = 1; * carry = 1;
* } * }
*/ */
const si_int s = (si_int)(d - r - 1) >> (n_uword_bits - 1); const si_int s = (si_int)(d - r - 1) >> (n_uword_bits - 1);
carry = s & 1; carry = s & 1;
r -= d & s; r -= d & s;
} }
q = (q << 1) | carry; q = (q << 1) | carry;
return q; return q;
} }
#if defined(__ARM_EABI__) #if defined(__ARM_EABI__)
AEABI_RTABI su_int __aeabi_uidiv(su_int n, su_int d) COMPILER_RT_ALIAS(__udivsi3); AEABI_RTABI su_int __aeabi_uidiv(su_int n, su_int d)
COMPILER_RT_ALIAS(__udivsi3);
#endif #endif

compiler-rt/trunk/lib/builtins/udivti3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a / b */ /* Returns: a / b */
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __udivti3(tu_int a, tu_int b) {
__udivti3(tu_int a, tu_int b)
{
return __udivmodti4(a, b, 0); return __udivmodti4(a, b, 0);
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/umoddi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ /* Returns: a % b */
COMPILER_RT_ABI du_int COMPILER_RT_ABI du_int __umoddi3(du_int a, du_int b) {
__umoddi3(du_int a, du_int b)
{
du_int r; du_int r;
__udivmoddi4(a, b, &r); __udivmoddi4(a, b, &r);
return r; return r;
} }

compiler-rt/trunk/lib/builtins/umodsi3.c

Show All 9 Lines
* *
* ===----------------------------------------------------------------------=== * ===----------------------------------------------------------------------===
*/ */
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ /* Returns: a % b */
COMPILER_RT_ABI su_int COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b) {
__umodsi3(su_int a, su_int b)
{
return a - __udivsi3(a, b) * b; return a - __udivsi3(a, b) * b;
} }

compiler-rt/trunk/lib/builtins/umodti3.c

Show All 11 Lines
*/ */
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a % b */ /* Returns: a % b */
COMPILER_RT_ABI tu_int COMPILER_RT_ABI tu_int __umodti3(tu_int a, tu_int b) {
__umodti3(tu_int a, tu_int b)
{
tu_int r; tu_int r;
__udivmodti4(a, b, &r); __udivmodti4(a, b, &r);
return r; return r;
} }
#endif /* CRT_HAS_128BIT */ #endif /* CRT_HAS_128BIT */

compiler-rt/trunk/lib/builtins/unwind-ehabi-helpers.h

Show All 29 Lines
* does not support EHABI as of the introduction of this header. As such, we * does not support EHABI as of the introduction of this header. As such, we
* are fairly certain that we are in the LLVM case. Here, _Unwind_State is a * are fairly certain that we are in the LLVM case. Here, _Unwind_State is a
* typedef, and so we can get away with a redeclaration. * typedef, and so we can get away with a redeclaration.
* *
* Guarded redefinitions of the needed unwind state prevent the redefinition of * Guarded redefinitions of the needed unwind state prevent the redefinition of
* those states. * those states.
*/ */
#define _URC_OK 0 #define _URC_OK 0
#define _URC_FAILURE 9 #define _URC_FAILURE 9
typedef uint32_t _Unwind_State; typedef uint32_t _Unwind_State;
#if !defined(_US_UNWIND_FRAME_STARTING) #if !defined(_US_UNWIND_FRAME_STARTING)
#define _US_UNWIND_FRAME_STARTING ((_Unwind_State)1) #define _US_UNWIND_FRAME_STARTING ((_Unwind_State)1)
#endif #endif
#if !defined(_US_ACTION_MASK) #if !defined(_US_ACTION_MASK)
#define _US_ACTION_MASK ((_Unwind_State)3) #define _US_ACTION_MASK ((_Unwind_State)3)
#endif #endif
#endif #endif
#endif #endif

compiler-rt/trunk/lib/builtins/x86_64/floatdidf.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* double __floatdidf(di_int a); */ /* double __floatdidf(di_int a); */
#if defined(__x86_64__) || defined(_M_X64) #if defined(__x86_64__) || defined(_M_X64)
#include "../int_lib.h" #include "../int_lib.h"
double __floatdidf(int64_t a) double __floatdidf(int64_t a) { return (double)a; }
{
return (double)a;
}
#endif /* __x86_64__ */ #endif /* __x86_64__ */

compiler-rt/trunk/lib/builtins/x86_64/floatdisf.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
#if defined(__x86_64__) || defined(_M_X64) #if defined(__x86_64__) || defined(_M_X64)
#include "../int_lib.h" #include "../int_lib.h"
float __floatdisf(int64_t a) float __floatdisf(int64_t a) { return (float)a; }
{
return (float)a;
}
#endif /* __x86_64__ */ #endif /* __x86_64__ */

compiler-rt/trunk/lib/builtins/x86_64/floatdixf.c

/* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. /* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
/* long double __floatdixf(di_int a); */ /* long double __floatdixf(di_int a); */
#ifdef __x86_64__ #ifdef __x86_64__
#include "../int_lib.h" #include "../int_lib.h"
long double __floatdixf(int64_t a) long double __floatdixf(int64_t a) { return (long double)a; }
{
return (long double)a;
}
#endif /* __i386__ */ #endif /* __i386__ */