This is an archive of the discontinued LLVM Phabricator instance.

Differential D60352

[builtins] Use single line C++/C99 comment style
ClosedPublic

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

Details

Reviewers
saugustine
echristo
jfb
Commits
rG0ba22f51d128: [builtins] Use single line C++/C99 comment style
rL359411: [builtins] Use single line C++/C99 comment style
rCRT359411: [builtins] Use single line C++/C99 comment style
Summary

Use the uniform single line C++/99 style for code comments.

Diff Detail

Event Timeline

phosek created this revision.Apr 5 2019, 6:11 PM
Herald added a reviewer: jfb. · View Herald TranscriptApr 5 2019, 6:11 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, Restricted Project, mstorsjo and 6 others. · View Herald Transcript
jfb added a comment.Apr 6 2019, 2:37 PM

Why? This seems like needless churn and is kinda annoying for mergebots.

Herald added a subscriber: dexonsmith. · View Herald TranscriptApr 6 2019, 2:37 PM
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:04 AM

LGTM.

This revision is now accepted and ready to land.Apr 8 2019, 10:04 AM
Closed by commit rCRT359411: [builtins] Use single line C++/C99 comment style (authored by phosek). · Explain WhyApr 28 2019, 3:47 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lib/
builtins/
27 lines
27 lines
29 lines
27 lines
27 lines
29 lines
26 lines
arm/
5 lines
36 lines
49 lines
72 lines
70 lines
26 lines
24 lines
7 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
24 lines
7 lines
2 lines
2 lines
2 lines
2 lines
4 lines
26 lines
26 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
26 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
24 lines
8 lines
2 lines
61 lines
78 lines
59 lines
2 lines
2 lines
33 lines
35 lines
35 lines
37 lines
35 lines
49 lines
23 lines
23 lines
23 lines
23 lines
23 lines
23 lines
23 lines
23 lines
101 lines
33 lines
74 lines
29 lines
37 lines
32 lines
24 lines
33 lines
78 lines
29 lines
25 lines
38 lines
25 lines
26 lines
25 lines
49 lines
25 lines
40 lines
24 lines
129 lines
45 lines
29 lines
1 line
1 line
1 line
1 line
28 lines
28 lines
30 lines
27 lines
15 lines
17 lines
27 lines
15 lines
17 lines
15 lines
15 lines
15 lines
31 lines
15 lines
17 lines
31 lines
23 lines
23 lines
15 lines
15 lines
15 lines
46 lines
48 lines
48 lines
43 lines
43 lines
87 lines
75 lines
49 lines
77 lines
73 lines
55 lines
80 lines
89 lines
73 lines
47 lines
75 lines
71 lines
53 lines
76 lines
111 lines
hexagon/
28 lines
20 lines
30 lines
25 lines
24 lines
96 lines
23 lines
82 lines
14 lines
i386/
10 lines
38 lines
4 lines
4 lines
36 lines
6 lines
24 lines
32 lines
71 lines
53 lines
48 lines
61 lines
35 lines
36 lines
33 lines
35 lines
15 lines
35 lines
25 lines
37 lines
25 lines
27 lines
27 lines
27 lines
29 lines
25 lines
25 lines
29 lines
27 lines
27 lines
29 lines
25 lines
30 lines
32 lines
27 lines
27 lines
29 lines
57 lines
25 lines
25 lines
27 lines
43 lines
37 lines
50 lines
25 lines
25 lines
25 lines
25 lines
ppc/
2 lines
9 lines
58 lines
36 lines
74 lines
27 lines
39 lines
31 lines
26 lines
18 lines
20 lines
26 lines
7 lines
27 lines
27 lines
29 lines
53 lines
37 lines
32 lines
25 lines
161 lines
25 lines
166 lines
58 lines
27 lines
25 lines
25 lines
27 lines
52 lines
x86_64/
11 lines
9 lines
11 lines
2 lines
2 lines

Diff 197042

lib/builtins/absvdi2.c

/*===-- absvdi2.c - Implement __absvdi2 -----------------------------------=== //===-- absvdi2.c - Implement __absvdi2 -----------------------------------===//
* //
* 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 __absvdi2 for the compiler_rt library. // This file implements __absvdi2 for the compiler_rt library.
* //
*===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __absvdi2(di_int a) { COMPILER_RT_ABI di_int __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;
} }

lib/builtins/absvsi2.c

/* ===-- absvsi2.c - Implement __absvsi2 -----------------------------------=== //===-- absvsi2.c - Implement __absvsi2 -----------------------------------===//
* //
* 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 __absvsi2 for the compiler_rt library. // This file implements __absvsi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __absvsi2(si_int a) { COMPILER_RT_ABI si_int __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;
} }

lib/builtins/absvti2.c

/* ===-- absvti2.c - Implement __absvdi2 -----------------------------------=== //===-- absvti2.c - Implement __absvdi2 -----------------------------------===//
* //
* 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 __absvti2 for the compiler_rt library. // This file implements __absvti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __absvti2(ti_int a) { COMPILER_RT_ABI ti_int __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

lib/builtins/addvdi3.c

/* ===-- addvdi3.c - Implement __addvdi3 -----------------------------------=== //===-- addvdi3.c - Implement __addvdi3 -----------------------------------===//
* //
* 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 __addvdi3 for the compiler_rt library. // This file implements __addvdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __addvdi3(di_int a, di_int b) { COMPILER_RT_ABI di_int __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;
} }

lib/builtins/addvsi3.c

/* ===-- addvsi3.c - Implement __addvsi3 -----------------------------------=== //===-- addvsi3.c - Implement __addvsi3 -----------------------------------===//
* //
* 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 __addvsi3 for the compiler_rt library. // This file implements __addvsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __addvsi3(si_int a, si_int b) { COMPILER_RT_ABI si_int __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;
} }

lib/builtins/addvti3.c

/* ===-- addvti3.c - Implement __addvti3 -----------------------------------=== //===-- addvti3.c - Implement __addvti3 -----------------------------------===//
* //
* 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 __addvti3 for the compiler_rt library. // This file implements __addvti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __addvti3(ti_int a, ti_int b) { COMPILER_RT_ABI ti_int __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

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); \
Show All 14 Lines#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)
NOT_HERE_BEFORE_10_6(__addvti3) NOT_HERE_BEFORE_10_6(__addvti3)
NOT_HERE_BEFORE_10_6(__ashldi3) NOT_HERE_BEFORE_10_6(__ashldi3)
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
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__
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_1) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_1)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_2) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_2)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_4) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_4)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_8) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_8)
NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange) NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange)
▲ Show 20 Lines • Show All 171 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__

lib/builtins/arm/adddf3vfp.S

//===-- adddf3vfp.S - Implement adddf3vfp ---------------------------------===// //===-- adddf3vfp.S - Implement adddf3vfp ---------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
//
// double __adddf3vfp(double a, double b) { return a + b; } // double __adddf3vfp(double a, double b) { return a + b; }
// //
// Adds two double precision floating point numbers using the Darwin // Adds two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs // calling convention where double arguments are passsed in GPR pairs
//
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__adddf3vfp) DEFINE_COMPILERRT_FUNCTION(__adddf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vadd.f64 d0, d0, d1 vadd.f64 d0, d0, d1
#else #else
vmov d6, r0, r1 // move first param from r0/r1 pair into d6 vmov d6, r0, r1 // move first param from r0/r1 pair into d6
vmov d7, r2, r3 // move second param from r2/r3 pair into d7 vmov d7, r2, r3 // move second param from r2/r3 pair into d7
vadd.f64 d6, d6, d7 vadd.f64 d6, d6, d7
vmov r0, r1, d6 // move result back to r0/r1 pair vmov r0, r1, d6 // move result back to r0/r1 pair
#endif #endif
bx lr bx lr
END_COMPILERRT_FUNCTION(__adddf3vfp) END_COMPILERRT_FUNCTION(__adddf3vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/addsf3.S

/*===-- addsf3.S - Adds two single precision floating pointer numbers-----===// //===-- addsf3.S - Adds two single precision floating pointer numbers-----===//
* //
* 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 the __addsf3 (single precision floating pointer number // This file implements the __addsf3 (single precision floating pointer number
* addition with the IEEE-754 default rounding (to nearest, ties to even) // addition with the IEEE-754 default rounding (to nearest, ties to even)
* function for the ARM Thumb1 ISA. // function for the ARM Thumb1 ISA.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
#define significandBits 23 #define significandBits 23
#define typeWidth 32 #define typeWidth 32
.syntax unified .syntax unified
.text .text
.thumb .thumb
.p2align 2 .p2align 2
DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_fadd, __addsf3) DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_fadd, __addsf3)
DEFINE_COMPILERRT_THUMB_FUNCTION(__addsf3) DEFINE_COMPILERRT_THUMB_FUNCTION(__addsf3)
push {r4, r5, r6, r7, lr} push {r4, r5, r6, r7, lr}
// Get the absolute value of a and b. // Get the absolute value of a and b.
lsls r2, r0, #1 lsls r2, r0, #1
lsls r3, r1, #1 lsls r3, r1, #1
lsrs r2, r2, #1 /* aAbs */ lsrs r2, r2, #1 // aAbs
beq LOCAL_LABEL(a_zero_nan_inf) beq LOCAL_LABEL(a_zero_nan_inf)
lsrs r3, r3, #1 /* bAbs */ lsrs r3, r3, #1 // bAbs
beq LOCAL_LABEL(zero_nan_inf) beq LOCAL_LABEL(zero_nan_inf)
// Detect if a or b is infinity or Nan. // Detect if a or b is infinity or Nan.
lsrs r6, r2, #(significandBits) lsrs r6, r2, #(significandBits)
lsrs r7, r3, #(significandBits) lsrs r7, r3, #(significandBits)
cmp r6, #0xFF cmp r6, #0xFF
beq LOCAL_LABEL(zero_nan_inf) beq LOCAL_LABEL(zero_nan_inf)
cmp r7, #0xFF cmp r7, #0xFF
beq LOCAL_LABEL(zero_nan_inf) beq LOCAL_LABEL(zero_nan_inf)
// Swap Rep and Abs so that a and aAbs has the larger absolute value. // Swap Rep and Abs so that a and aAbs has the larger absolute value.
cmp r2, r3 cmp r2, r3
bhs LOCAL_LABEL(no_swap) bhs LOCAL_LABEL(no_swap)
movs r4, r0 movs r4, r0
movs r5, r2 movs r5, r2
movs r0, r1 movs r0, r1
movs r2, r3 movs r2, r3
movs r1, r4 movs r1, r4
movs r3, r5 movs r3, r5
LOCAL_LABEL(no_swap): LOCAL_LABEL(no_swap):
// Get the significands and shift them to give us round, guard and sticky. // Get the significands and shift them to give us round, guard and sticky.
lsls r4, r0, #(typeWidth - significandBits) lsls r4, r0, #(typeWidth - significandBits)
lsrs r4, r4, #(typeWidth - significandBits - 3) /* aSignificand << 3 */ lsrs r4, r4, #(typeWidth - significandBits - 3) // aSignificand << 3
lsls r5, r1, #(typeWidth - significandBits) lsls r5, r1, #(typeWidth - significandBits)
lsrs r5, r5, #(typeWidth - significandBits - 3) /* bSignificand << 3 */ lsrs r5, r5, #(typeWidth - significandBits - 3) // bSignificand << 3
// Get the implicitBit. // Get the implicitBit.
movs r6, #1 movs r6, #1
lsls r6, r6, #(significandBits + 3) lsls r6, r6, #(significandBits + 3)
// Get aExponent and set implicit bit if necessary. // Get aExponent and set implicit bit if necessary.
lsrs r2, r2, #(significandBits) lsrs r2, r2, #(significandBits)
beq LOCAL_LABEL(a_done_implicit_bit) beq LOCAL_LABEL(a_done_implicit_bit)
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 LinesLOCAL_LABEL(do_substraction):
movs r2, #0 // aExponent = 0; movs r2, #0 // aExponent = 0;
movs r3, #(typeWidth) // bExponent is dead. movs r3, #(typeWidth) // bExponent is dead.
subs r3, r3, r6 subs r3, r3, r6
movs r7, r4 movs r7, r4
lsls r7, r3 // stickyBit = (bool)(aSignificant << (typeWidth - align)) lsls r7, r3 // stickyBit = (bool)(aSignificant << (typeWidth - align))
beq 1f beq 1f
movs r7, #1 movs r7, #1
1: 1:
lsrs r4, r6 /* aSignificand >> shift */ lsrs r4, r6 // aSignificand >> shift
orrs r4, r7 orrs r4, r7
b LOCAL_LABEL(form_result) b LOCAL_LABEL(form_result)
LOCAL_LABEL(ret_zero): LOCAL_LABEL(ret_zero):
movs r0, #0 movs r0, #0
pop {r4, r5, r6, r7, pc} pop {r4, r5, r6, r7, pc}
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

lib/builtins/arm/aeabi_div0.c

/* ===-- aeabi_div0.c - ARM Runtime ABI support routines for compiler-rt ---=== //===-- aeabi_div0.c - ARM Runtime ABI support routines for compiler-rt ---===//
* //
* 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 the division by zero helper routines as specified by the // This file implements the division by zero helper routines as specified by the
* Run-time ABI for the ARM Architecture. // Run-time ABI for the ARM Architecture.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
/* // RTABI 4.3.2 - Division by zero
* RTABI 4.3.2 - Division by zero //
* // The *div0 functions:
* The *div0 functions: // - Return the value passed to them as a parameter
* - Return the value passed to them as a parameter // - Or, return a fixed value defined by the execution environment (such as 0)
* - Or, return a fixed value defined by the execution environment (such as 0) // - Or, raise a signal (often SIGFPE) or throw an exception, and do not return
* - Or, raise a signal (often SIGFPE) or throw an exception, and do not return //
* // An application may provide its own implementations of the *div0 functions to
* An application may provide its own implementations of the *div0 functions to // for a particular behaviour from the *div and *divmod functions called out of
* for a particular behaviour from the *div and *divmod functions called out of // line.
* line.
*/
#include "../int_lib.h" #include "../int_lib.h"
/* provide an unused declaration to pacify pendantic compilation */ // provide an unused declaration to pacify pendantic compilation
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)) AEABI_RTABI long long __attribute__((weak))
__attribute__((visibility("hidden"))) __aeabi_ldiv0(long long return_value) { __attribute__((visibility("hidden"))) __aeabi_ldiv0(long long return_value) {
return return_value; return return_value;
} }
#endif #endif

lib/builtins/arm/clzdi2.S

/* ===-- clzdi2.c - Implement __clzdi2 -------------------------------------=== //===-- clzdi2.c - Implement __clzdi2 -------------------------------------===//
* //
* 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 count leading zeros for 64bit arguments. // This file implements count leading zeros for 64bit arguments.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "../assembly.h" #include "../assembly.h"
.syntax unified .syntax unified
.text .text
DEFINE_CODE_STATE DEFINE_CODE_STATE
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__clzdi2) DEFINE_COMPILERRT_FUNCTION(__clzdi2)
#ifdef __ARM_FEATURE_CLZ #ifdef __ARM_FEATURE_CLZ
#ifdef __ARMEB__ #ifdef __ARMEB__
cmp r0, 0 cmp r0, 0
itee ne itee ne
clzne r0, r0 clzne r0, r0
clzeq r0, r1 clzeq r0, r1
addeq r0, r0, 32 addeq r0, r0, 32
#else #else
cmp r1, 0 cmp r1, 0
itee ne itee ne
clzne r0, r1 clzne r0, r1
clzeq r0, r0 clzeq r0, r0
addeq r0, r0, 32 addeq r0, r0, 32
#endif #endif
JMP(lr) JMP(lr)
#else #else
/* Assumption: n != 0 */ // Assumption: n != 0
/* // r0: n
* r0: n // r1: upper half of n, overwritten after check
* r1: upper half of n, overwritten after check // r1: count of leading zeros in n + 1
* r1: count of leading zeros in n + 1 // r2: scratch register for shifted r0
* r2: scratch register for shifted r0
*/
#ifdef __ARMEB__ #ifdef __ARMEB__
cmp r0, 0 cmp r0, 0
moveq r0, r1 moveq r0, r1
#else #else
cmp r1, 0 cmp r1, 0
movne r0, r1 movne r0, r1
#endif #endif
movne r1, 1 movne r1, 1
moveq r1, 33 moveq r1, 33
/* // Basic block:
* Basic block: // if ((r0 >> SHIFT) == 0)
* if ((r0 >> SHIFT) == 0) // r1 += SHIFT;
* r1 += SHIFT; // else
* else // r0 >>= SHIFT;
* r0 >>= SHIFT; // for descending powers of two as SHIFT.
* for descending powers of two as SHIFT.
*/
#define BLOCK(shift) \ #define BLOCK(shift) \
lsrs r2, r0, shift; \ lsrs r2, r0, shift; \
movne r0, r2; \ movne r0, r2; \
addeq r1, shift \ addeq r1, shift \
BLOCK(16) BLOCK(16)
BLOCK(8) BLOCK(8)
BLOCK(4) BLOCK(4)
BLOCK(2) BLOCK(2)
/* // The basic block invariants at this point are (r0 >> 2) == 0 and
* The basic block invariants at this point are (r0 >> 2) == 0 and // r0 != 0. This means 1 <= r0 <= 3 and 0 <= (r0 >> 1) <= 1.
* r0 != 0. This means 1 <= r0 <= 3 and 0 <= (r0 >> 1) <= 1. //
* // r0 | (r0 >> 1) == 0 | (r0 >> 1) == 1 | -(r0 >> 1) | 1 - (r0 >> 1)
* r0 | (r0 >> 1) == 0 | (r0 >> 1) == 1 | -(r0 >> 1) | 1 - (r0 >> 1) // ---+----------------+----------------+------------+--------------
* ---+----------------+----------------+------------+-------------- // 1 | 1 | 0 | 0 | 1
* 1 | 1 | 0 | 0 | 1 // 2 | 0 | 1 | -1 | 0
* 2 | 0 | 1 | -1 | 0 // 3 | 0 | 1 | -1 | 0
* 3 | 0 | 1 | -1 | 0 //
* // The r1's initial value of 1 compensates for the 1 here.
* The r1's initial value of 1 compensates for the 1 here.
*/
sub r0, r1, r0, lsr #1 sub r0, r1, r0, lsr #1
JMP(lr) JMP(lr)
#endif // __ARM_FEATURE_CLZ #endif // __ARM_FEATURE_CLZ
END_COMPILERRT_FUNCTION(__clzdi2) END_COMPILERRT_FUNCTION(__clzdi2)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/clzsi2.S

/* ===-- clzsi2.c - Implement __clzsi2 -------------------------------------=== //===-- clzsi2.c - Implement __clzsi2 -------------------------------------===//
* //
* 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 count leading zeros for 32bit arguments. // This file implements count leading zeros for 32bit arguments.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "../assembly.h" #include "../assembly.h"
.syntax unified .syntax unified
.text .text
DEFINE_CODE_STATE DEFINE_CODE_STATE
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__clzsi2) DEFINE_COMPILERRT_FUNCTION(__clzsi2)
#ifdef __ARM_FEATURE_CLZ #ifdef __ARM_FEATURE_CLZ
clz r0, r0 clz r0, r0
JMP(lr) JMP(lr)
#else #else
/* Assumption: n != 0 */ // Assumption: n != 0
/* // r0: n
* r0: n // r1: count of leading zeros in n + 1
* r1: count of leading zeros in n + 1 // r2: scratch register for shifted r0
* r2: scratch register for shifted r0
*/
mov r1, 1 mov r1, 1
/* // Basic block:
* Basic block: // if ((r0 >> SHIFT) == 0)
* if ((r0 >> SHIFT) == 0) // r1 += SHIFT;
* r1 += SHIFT; // else
* else // r0 >>= SHIFT;
* r0 >>= SHIFT; // for descending powers of two as SHIFT.
* for descending powers of two as SHIFT.
*/
#define BLOCK(shift) \ #define BLOCK(shift) \
lsrs r2, r0, shift; \ lsrs r2, r0, shift; \
movne r0, r2; \ movne r0, r2; \
addeq r1, shift \ addeq r1, shift \
BLOCK(16) BLOCK(16)
BLOCK(8) BLOCK(8)
BLOCK(4) BLOCK(4)
BLOCK(2) BLOCK(2)
/* // The basic block invariants at this point are (r0 >> 2) == 0 and
* The basic block invariants at this point are (r0 >> 2) == 0 and // r0 != 0. This means 1 <= r0 <= 3 and 0 <= (r0 >> 1) <= 1.
* r0 != 0. This means 1 <= r0 <= 3 and 0 <= (r0 >> 1) <= 1. //
* // r0 | (r0 >> 1) == 0 | (r0 >> 1) == 1 | -(r0 >> 1) | 1 - (r0 >> 1)
* r0 | (r0 >> 1) == 0 | (r0 >> 1) == 1 | -(r0 >> 1) | 1 - (r0 >> 1) // ---+----------------+----------------+------------+--------------
* ---+----------------+----------------+------------+-------------- // 1 | 1 | 0 | 0 | 1
* 1 | 1 | 0 | 0 | 1 // 2 | 0 | 1 | -1 | 0
* 2 | 0 | 1 | -1 | 0 // 3 | 0 | 1 | -1 | 0
* 3 | 0 | 1 | -1 | 0 //
* // The r1's initial value of 1 compensates for the 1 here.
* The r1's initial value of 1 compensates for the 1 here.
*/
sub r0, r1, r0, lsr #1 sub r0, r1, r0, lsr #1
JMP(lr) JMP(lr)
#endif // __ARM_FEATURE_CLZ #endif // __ARM_FEATURE_CLZ
END_COMPILERRT_FUNCTION(__clzsi2) END_COMPILERRT_FUNCTION(__clzsi2)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/divmodsi4.S

/*===-- divmodsi4.S - 32-bit signed integer divide and modulus ------------===// //===-- divmodsi4.S - 32-bit signed integer divide and modulus ------------===//
* //
* 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 the __divmodsi4 (32-bit signed integer divide and // This file implements the __divmodsi4 (32-bit signed integer divide and
* modulus) function for the ARM architecture. A naive digit-by-digit // modulus) function for the ARM architecture. A naive digit-by-digit
* computation is employed for simplicity. // computation is employed for simplicity.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
#define ESTABLISH_FRAME \ #define ESTABLISH_FRAME \
push {r4-r7, lr} ;\ push {r4-r7, lr} ;\
add r7, sp, #12 add r7, sp, #12
#define CLEAR_FRAME_AND_RETURN \ #define CLEAR_FRAME_AND_RETURN \
pop {r4-r7, pc} pop {r4-r7, pc}
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lib/builtins/arm/divsi3.S

/*===-- divsi3.S - 32-bit signed integer divide ---------------------------===// //===-- divsi3.S - 32-bit signed integer divide ---------------------------===//
* //
* 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 the __divsi3 (32-bit signed integer divide) function // This file implements the __divsi3 (32-bit signed integer divide) function
* for the ARM architecture as a wrapper around the unsigned routine. // for the ARM architecture as a wrapper around the unsigned routine.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
#define ESTABLISH_FRAME \ #define ESTABLISH_FRAME \
push {r4, r7, lr} ;\ push {r4, r7, lr} ;\
add r7, sp, #4 add r7, sp, #4
#define CLEAR_FRAME_AND_RETURN \ #define CLEAR_FRAME_AND_RETURN \
pop {r4, r7, pc} pop {r4, r7, pc}
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

lib/builtins/arm/eqdf2vfp.S

//===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===// //===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
//
// extern int __eqdf2vfp(double a, double b); // extern int __eqdf2vfp(double a, double b);
// //
// Returns one iff a == b and neither is NaN. // Returns one iff a == b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
//
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp) DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
vmov d6, r0, r1 // load r0/r1 pair in double register vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7 vcmp.f64 d6, d7
#endif #endif
vmrs apsr_nzcv, fpscr vmrs apsr_nzcv, fpscr
ITE(eq) ITE(eq)
moveq r0, #1 // set result register to 1 if equal moveq r0, #1 // set result register to 1 if equal
movne r0, #0 movne r0, #0
bx lr bx lr
END_COMPILERRT_FUNCTION(__eqdf2vfp) END_COMPILERRT_FUNCTION(__eqdf2vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/eqsf2vfp.S

//===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===// //===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __eqsf2vfp(float a, float b); // extern int __eqsf2vfp(float a, float b);
// //
// Returns one iff a == b and neither is NaN. // Returns one iff a == b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp) DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/arm/extendsfdf2vfp.S

//===-- extendsfdf2vfp.S - Implement extendsfdf2vfp -----------------------===// //===-- extendsfdf2vfp.S - Implement extendsfdf2vfp -----------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __extendsfdf2vfp(float a); // extern double __extendsfdf2vfp(float a);
// //
// Converts single precision float to double precision result. // Converts single precision float to double precision result.
// Uses Darwin calling convention where a single precision parameter is // Uses Darwin calling convention where a single precision parameter is
// passed in a GPR and a double precision result is returned in R0/R1 pair. // passed in a GPR and a double precision result is returned in R0/R1 pair.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__extendsfdf2vfp) DEFINE_COMPILERRT_FUNCTION(__extendsfdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcvt.f64.f32 d0, s0 vcvt.f64.f32 d0, s0
#else #else
Show All 9 Lines

lib/builtins/arm/fixdfsivfp.S

//===-- fixdfsivfp.S - Implement fixdfsivfp -----------------------===// //===-- fixdfsivfp.S - Implement fixdfsivfp -----------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __fixdfsivfp(double a); // extern int __fixdfsivfp(double a);
// //
// Converts double precision float to a 32-bit int rounding towards zero. // Converts double precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a double precision parameter is // Uses Darwin calling convention where a double precision parameter is
// passed in GPR register pair. // passed in GPR register pair.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixdfsivfp) DEFINE_COMPILERRT_FUNCTION(__fixdfsivfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcvt.s32.f64 s0, d0 vcvt.s32.f64 s0, d0
vmov r0, s0 vmov r0, s0
Show All 10 Lines

lib/builtins/arm/fixsfsivfp.S

//===-- fixsfsivfp.S - Implement fixsfsivfp -----------------------===// //===-- fixsfsivfp.S - Implement fixsfsivfp -----------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __fixsfsivfp(float a); // extern int __fixsfsivfp(float a);
// //
// Converts single precision float to a 32-bit int rounding towards zero. // Converts single precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a single precision parameter is // Uses Darwin calling convention where a single precision parameter is
// passed in a GPR.. // passed in a GPR..
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixsfsivfp) DEFINE_COMPILERRT_FUNCTION(__fixsfsivfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcvt.s32.f32 s0, s0 vcvt.s32.f32 s0, s0
vmov r0, s0 vmov r0, s0
Show All 10 Lines

lib/builtins/arm/fixunsdfsivfp.S

//===-- fixunsdfsivfp.S - Implement fixunsdfsivfp -------------------------===// //===-- fixunsdfsivfp.S - Implement fixunsdfsivfp -------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern unsigned int __fixunsdfsivfp(double a); // extern unsigned int __fixunsdfsivfp(double a);
// //
// Converts double precision float to a 32-bit unsigned int rounding towards // Converts double precision float to a 32-bit unsigned int rounding towards
// zero. All negative values become zero. // zero. All negative values become zero.
// Uses Darwin calling convention where a double precision parameter is // Uses Darwin calling convention where a double precision parameter is
// passed in GPR register pair. // passed in GPR register pair.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixunsdfsivfp) DEFINE_COMPILERRT_FUNCTION(__fixunsdfsivfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcvt.u32.f64 s0, d0 vcvt.u32.f64 s0, d0
vmov r0, s0 vmov r0, s0
Show All 10 Lines

lib/builtins/arm/fixunssfsivfp.S

//===-- fixunssfsivfp.S - Implement fixunssfsivfp -------------------------===// //===-- fixunssfsivfp.S - Implement fixunssfsivfp -------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern unsigned int __fixunssfsivfp(float a); // extern unsigned int __fixunssfsivfp(float a);
// //
// Converts single precision float to a 32-bit unsigned int rounding towards // Converts single precision float to a 32-bit unsigned int rounding towards
// zero. All negative values become zero. // zero. All negative values become zero.
// Uses Darwin calling convention where a single precision parameter is // Uses Darwin calling convention where a single precision parameter is
// passed in a GPR.. // passed in a GPR..
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__fixunssfsivfp) DEFINE_COMPILERRT_FUNCTION(__fixunssfsivfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcvt.u32.f32 s0, s0 vcvt.u32.f32 s0, s0
vmov r0, s0 vmov r0, s0
Show All 10 Lines

lib/builtins/arm/floatsidfvfp.S

//===-- floatsidfvfp.S - Implement floatsidfvfp ---------------------------===// //===-- floatsidfvfp.S - Implement floatsidfvfp ---------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __floatsidfvfp(int a); // extern double __floatsidfvfp(int a);
// //
// Converts a 32-bit int to a double precision float. // Converts a 32-bit int to a double precision float.
// Uses Darwin calling convention where a double precision result is // Uses Darwin calling convention where a double precision result is
// return in GPR register pair. // return in GPR register pair.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatsidfvfp) DEFINE_COMPILERRT_FUNCTION(__floatsidfvfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vmov s0, r0 vmov s0, r0
vcvt.f64.s32 d0, s0 vcvt.f64.s32 d0, s0
Show All 10 Lines

lib/builtins/arm/floatsisfvfp.S

//===-- floatsisfvfp.S - Implement floatsisfvfp ---------------------------===// //===-- floatsisfvfp.S - Implement floatsisfvfp ---------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern float __floatsisfvfp(int a); // extern float __floatsisfvfp(int a);
// //
// Converts single precision float to a 32-bit int rounding towards zero. // Converts single precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a single precision result is // Uses Darwin calling convention where a single precision result is
// return in a GPR.. // return in a GPR..
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatsisfvfp) DEFINE_COMPILERRT_FUNCTION(__floatsisfvfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vmov s0, r0 vmov s0, r0
vcvt.f32.s32 s0, s0 vcvt.f32.s32 s0, s0
Show All 10 Lines

lib/builtins/arm/floatunssidfvfp.S

//===-- floatunssidfvfp.S - Implement floatunssidfvfp ---------------------===// //===-- floatunssidfvfp.S - Implement floatunssidfvfp ---------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __floatunssidfvfp(unsigned int a); // extern double __floatunssidfvfp(unsigned int a);
// //
// Converts a 32-bit int to a double precision float. // Converts a 32-bit int to a double precision float.
// Uses Darwin calling convention where a double precision result is // Uses Darwin calling convention where a double precision result is
// return in GPR register pair. // return in GPR register pair.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatunssidfvfp) DEFINE_COMPILERRT_FUNCTION(__floatunssidfvfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vmov s0, r0 vmov s0, r0
vcvt.f64.u32 d0, s0 vcvt.f64.u32 d0, s0
Show All 10 Lines

lib/builtins/arm/floatunssisfvfp.S

//===-- floatunssisfvfp.S - Implement floatunssisfvfp ---------------------===// //===-- floatunssisfvfp.S - Implement floatunssisfvfp ---------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern float __floatunssisfvfp(unsigned int a); // extern float __floatunssisfvfp(unsigned int a);
// //
// Converts single precision float to a 32-bit int rounding towards zero. // Converts single precision float to a 32-bit int rounding towards zero.
// Uses Darwin calling convention where a single precision result is // Uses Darwin calling convention where a single precision result is
// return in a GPR.. // return in a GPR..
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__floatunssisfvfp) DEFINE_COMPILERRT_FUNCTION(__floatunssisfvfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vmov s0, r0 vmov s0, r0
vcvt.f32.u32 s0, s0 vcvt.f32.u32 s0, s0
Show All 10 Lines

lib/builtins/arm/gedf2vfp.S

//===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===// //===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __gedf2vfp(double a, double b); // extern int __gedf2vfp(double a, double b);
// //
// Returns one iff a >= b and neither is NaN. // Returns one iff a >= b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gedf2vfp) DEFINE_COMPILERRT_FUNCTION(__gedf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

lib/builtins/arm/gesf2vfp.S

//===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===// //===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __gesf2vfp(float a, float b); // extern int __gesf2vfp(float a, float b);
// //
// Returns one iff a >= b and neither is NaN. // Returns one iff a >= b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gesf2vfp) DEFINE_COMPILERRT_FUNCTION(__gesf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/arm/gtdf2vfp.S

//===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===// //===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __gtdf2vfp(double a, double b); // extern double __gtdf2vfp(double a, double b);
// //
// Returns one iff a > b and neither is NaN. // Returns one iff a > b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp) DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

lib/builtins/arm/gtsf2vfp.S

//===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===// //===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __gtsf2vfp(float a, float b); // extern int __gtsf2vfp(float a, float b);
// //
// Returns one iff a > b and neither is NaN. // Returns one iff a > b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp) DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/arm/ledf2vfp.S

//===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===// //===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __ledf2vfp(double a, double b); // extern double __ledf2vfp(double a, double b);
// //
// Returns one iff a <= b and neither is NaN. // Returns one iff a <= b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__ledf2vfp) DEFINE_COMPILERRT_FUNCTION(__ledf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

lib/builtins/arm/lesf2vfp.S

//===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===// //===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __lesf2vfp(float a, float b); // extern int __lesf2vfp(float a, float b);
// //
// Returns one iff a <= b and neither is NaN. // Returns one iff a <= b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__lesf2vfp) DEFINE_COMPILERRT_FUNCTION(__lesf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/arm/ltdf2vfp.S

//===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===// //===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __ltdf2vfp(double a, double b); // extern double __ltdf2vfp(double a, double b);
// //
// Returns one iff a < b and neither is NaN. // Returns one iff a < b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp) DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

lib/builtins/arm/ltsf2vfp.S

//===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===// //===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __ltsf2vfp(float a, float b); // extern int __ltsf2vfp(float a, float b);
// //
// Returns one iff a < b and neither is NaN. // Returns one iff a < b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp) DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/arm/modsi3.S

/*===-- modsi3.S - 32-bit signed integer modulus --------------------------===// //===-- modsi3.S - 32-bit signed integer modulus --------------------------===//
* //
* 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 the __modsi3 (32-bit signed integer modulus) function // This file implements the __modsi3 (32-bit signed integer modulus) function
* for the ARM architecture as a wrapper around the unsigned routine. // for the ARM architecture as a wrapper around the unsigned routine.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
#define ESTABLISH_FRAME \ #define ESTABLISH_FRAME \
push {r4, r7, lr} ;\ push {r4, r7, lr} ;\
add r7, sp, #4 add r7, sp, #4
#define CLEAR_FRAME_AND_RETURN \ #define CLEAR_FRAME_AND_RETURN \
pop {r4, r7, pc} pop {r4, r7, pc}
Show All 39 Lines

lib/builtins/arm/nedf2vfp.S

//===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===// //===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
//
// extern double __nedf2vfp(double a, double b); // extern double __nedf2vfp(double a, double b);
// //
// Returns zero if a and b are unequal and neither is NaN. // Returns zero if a and b are unequal and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
//
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__nedf2vfp) DEFINE_COMPILERRT_FUNCTION(__nedf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
vmov d6, r0, r1 // load r0/r1 pair in double register vmov d6, r0, r1 // load r0/r1 pair in double register
vmov d7, r2, r3 // load r2/r3 pair in double register vmov d7, r2, r3 // load r2/r3 pair in double register
vcmp.f64 d6, d7 vcmp.f64 d6, d7
#endif #endif
vmrs apsr_nzcv, fpscr vmrs apsr_nzcv, fpscr
ITE(ne) ITE(ne)
movne r0, #1 // set result register to 0 if unequal movne r0, #1 // set result register to 0 if unequal
moveq r0, #0 moveq r0, #0
bx lr bx lr
END_COMPILERRT_FUNCTION(__nedf2vfp) END_COMPILERRT_FUNCTION(__nedf2vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/negdf2vfp.S

//===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===// //===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __negdf2vfp(double a, double b); // extern double __negdf2vfp(double a, double b);
// //
// Returns the negation a double precision floating point numbers using the // Returns the negation a double precision floating point numbers using the
// Darwin calling convention where double arguments are passsed in GPR pairs. // Darwin calling convention where double arguments are passsed in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__negdf2vfp) DEFINE_COMPILERRT_FUNCTION(__negdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vneg.f64 d0, d0 vneg.f64 d0, d0
#else #else
eor r1, r1, #-2147483648 // flip sign bit on double in r0/r1 pair eor r1, r1, #-2147483648 // flip sign bit on double in r0/r1 pair
#endif #endif
bx lr bx lr
END_COMPILERRT_FUNCTION(__negdf2vfp) END_COMPILERRT_FUNCTION(__negdf2vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/negsf2vfp.S

//===-- negsf2vfp.S - Implement negsf2vfp ---------------------------------===// //===-- negsf2vfp.S - Implement negsf2vfp ---------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern float __negsf2vfp(float a); // extern float __negsf2vfp(float a);
// //
// Returns the negation of a single precision floating point numbers using the // Returns the negation of a single precision floating point numbers using the
// Darwin calling convention where single arguments are passsed like 32-bit ints // Darwin calling convention where single arguments are passsed like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__negsf2vfp) DEFINE_COMPILERRT_FUNCTION(__negsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vneg.f32 s0, s0 vneg.f32 s0, s0
#else #else
eor r0, r0, #-2147483648 // flip sign bit on float in r0 eor r0, r0, #-2147483648 // flip sign bit on float in r0
#endif #endif
bx lr bx lr
END_COMPILERRT_FUNCTION(__negsf2vfp) END_COMPILERRT_FUNCTION(__negsf2vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/nesf2vfp.S

//===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===// //===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __nesf2vfp(float a, float b); // extern int __nesf2vfp(float a, float b);
// //
// Returns one iff a != b and neither is NaN. // Returns one iff a != b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__nesf2vfp) DEFINE_COMPILERRT_FUNCTION(__nesf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/arm/softfloat-alias.list

# #
# These are soft float functions which can be # These are soft float functions which can be
# aliased to the *vfp functions on arm processors # aliased to the *vfp functions on arm processors
# that support floating point instructions. # that support floating point instructions.
# #
___adddf3vfp ___adddf3 ___adddf3vfp ___adddf3
___addsf3vfp ___addsf3 ___addsf3vfp ___addsf3
___divdf3vfp ___divdf3 ___divdf3vfp ___divdf3
___divsf3vfp ___divsf3 ___divsf3vfp ___divsf3
___extendsfdf2vfp ___extendsfdf2 ___extendsfdf2vfp ___extendsfdf2
Show All 11 Lines

lib/builtins/arm/subdf3vfp.S

//===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===// //===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern double __subdf3vfp(double a, double b); // extern double __subdf3vfp(double a, double b);
// //
// Returns difference between two double precision floating point numbers using // Returns difference between two double precision floating point numbers using
// the Darwin calling convention where double arguments are passsed in GPR pairs // the Darwin calling convention where double arguments are passsed in GPR pairs
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__subdf3vfp) DEFINE_COMPILERRT_FUNCTION(__subdf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vsub.f64 d0, d0, d1 vsub.f64 d0, d0, d1
#else #else
vmov d6, r0, r1 // move first param from r0/r1 pair into d6 vmov d6, r0, r1 // move first param from r0/r1 pair into d6
vmov d7, r2, r3 // move second param from r2/r3 pair into d7 vmov d7, r2, r3 // move second param from r2/r3 pair into d7
vsub.f64 d6, d6, d7 vsub.f64 d6, d6, d7
vmov r0, r1, d6 // move result back to r0/r1 pair vmov r0, r1, d6 // move result back to r0/r1 pair
#endif #endif
bx lr bx lr
END_COMPILERRT_FUNCTION(__subdf3vfp) END_COMPILERRT_FUNCTION(__subdf3vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

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) \
Show All 40 Lines

lib/builtins/arm/sync_fetch_and_add_4.S

/*===-- sync_fetch_and_add_4.S - ------------------------------------------===// //===-- sync_fetch_and_add_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_add_4 function for the ARM // This file implements the __sync_fetch_and_add_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
/* "adds" is 2 bytes shorter than "add". */ // "adds" is 2 bytes shorter than "add".
#define add_4(rD, rN, rM) add rD, rN, rM #define add_4(rD, rN, rM) add rD, rN, rM
SYNC_OP_4(add_4) SYNC_OP_4(add_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_add_8.S

/*===-- sync_fetch_and_add_8.S - ------------------------------------------===// //===-- sync_fetch_and_add_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_add_8 function for the ARM // This file implements the __sync_fetch_and_add_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define add_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \ #define add_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
adds rD_LO, rN_LO, rM_LO ; \ adds rD_LO, rN_LO, rM_LO ; \
adc rD_HI, rN_HI, rM_HI adc rD_HI, rN_HI, rM_HI
SYNC_OP_8(add_8) SYNC_OP_8(add_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_and_4.S

/*===-- sync_fetch_and_and_4.S - ------------------------------------------===// //===-- sync_fetch_and_and_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_and_4 function for the ARM // This file implements the __sync_fetch_and_and_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define and_4(rD, rN, rM) and rD, rN, rM #define and_4(rD, rN, rM) and rD, rN, rM
SYNC_OP_4(and_4) SYNC_OP_4(and_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_and_8.S

/*===-- sync_fetch_and_and_8.S - ------------------------------------------===// //===-- sync_fetch_and_and_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_and_8 function for the ARM // This file implements the __sync_fetch_and_and_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define and_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \ #define and_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
and rD_LO, rN_LO, rM_LO ; \ and rD_LO, rN_LO, rM_LO ; \
and rD_HI, rN_HI, rM_HI and rD_HI, rN_HI, rM_HI
SYNC_OP_8(and_8) SYNC_OP_8(and_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_max_4.S

/*===-- sync_fetch_and_max_4.S - ------------------------------------------===// //===-- sync_fetch_and_max_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_max_4 function for the ARM // This file implements the __sync_fetch_and_max_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define max_4(rD, rN, rM) MINMAX_4(rD, rN, rM, gt) #define max_4(rD, rN, rM) MINMAX_4(rD, rN, rM, gt)
SYNC_OP_4(max_4) SYNC_OP_4(max_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_max_8.S

/*===-- sync_fetch_and_max_8.S - ------------------------------------------===// //===-- sync_fetch_and_max_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_max_8 function for the ARM // This file implements the __sync_fetch_and_max_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define max_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, gt) #define max_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, gt)
SYNC_OP_8(max_8) SYNC_OP_8(max_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_min_4.S

/*===-- sync_fetch_and_min_4.S - ------------------------------------------===// //===-- sync_fetch_and_min_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_min_4 function for the ARM // This file implements the __sync_fetch_and_min_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define min_4(rD, rN, rM) MINMAX_4(rD, rN, rM, lt) #define min_4(rD, rN, rM) MINMAX_4(rD, rN, rM, lt)
SYNC_OP_4(min_4) SYNC_OP_4(min_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_min_8.S

/*===-- sync_fetch_and_min_8.S - ------------------------------------------===// //===-- sync_fetch_and_min_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_min_8 function for the ARM // This file implements the __sync_fetch_and_min_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define min_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, lt) #define min_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, lt)
SYNC_OP_8(min_8) SYNC_OP_8(min_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_nand_4.S

/*===-- sync_fetch_and_nand_4.S - -----------------------------------------===// //===-- sync_fetch_and_nand_4.S - -----------------------------------------===//
* //
* 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 the __sync_fetch_and_nand_4 function for the ARM // This file implements the __sync_fetch_and_nand_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define nand_4(rD, rN, rM) bic rD, rN, rM #define nand_4(rD, rN, rM) bic rD, rN, rM
SYNC_OP_4(nand_4) SYNC_OP_4(nand_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_nand_8.S

/*===-- sync_fetch_and_nand_8.S - ------------------------------------------===// //===-- sync_fetch_and_nand_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_nand_8 function for the ARM // This file implements the __sync_fetch_and_nand_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define nand_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \ #define nand_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
bic rD_LO, rN_LO, rM_LO ; \ bic rD_LO, rN_LO, rM_LO ; \
bic rD_HI, rN_HI, rM_HI bic rD_HI, rN_HI, rM_HI
SYNC_OP_8(nand_8) SYNC_OP_8(nand_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_or_4.S

/*===-- sync_fetch_and_or_4.S - -------------------------------------------===// //===-- sync_fetch_and_or_4.S - -------------------------------------------===//
* //
* 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 the __sync_fetch_and_or_4 function for the ARM // This file implements the __sync_fetch_and_or_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define or_4(rD, rN, rM) orr rD, rN, rM #define or_4(rD, rN, rM) orr rD, rN, rM
SYNC_OP_4(or_4) SYNC_OP_4(or_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_or_8.S

/*===-- sync_fetch_and_or_8.S - -------------------------------------------===// //===-- sync_fetch_and_or_8.S - -------------------------------------------===//
* //
* 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 the __sync_fetch_and_or_8 function for the ARM // This file implements the __sync_fetch_and_or_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define or_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \ #define or_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
orr rD_LO, rN_LO, rM_LO ; \ orr rD_LO, rN_LO, rM_LO ; \
orr rD_HI, rN_HI, rM_HI orr rD_HI, rN_HI, rM_HI
SYNC_OP_8(or_8) SYNC_OP_8(or_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_sub_4.S

/*===-- sync_fetch_and_sub_4.S - ------------------------------------------===// //===-- sync_fetch_and_sub_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_sub_4 function for the ARM // This file implements the __sync_fetch_and_sub_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
/* "subs" is 2 bytes shorter than "sub". */ // "subs" is 2 bytes shorter than "sub".
#define sub_4(rD, rN, rM) sub rD, rN, rM #define sub_4(rD, rN, rM) sub rD, rN, rM
SYNC_OP_4(sub_4) SYNC_OP_4(sub_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_sub_8.S

/*===-- sync_fetch_and_sub_8.S - ------------------------------------------===// //===-- sync_fetch_and_sub_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_sub_8 function for the ARM // This file implements the __sync_fetch_and_sub_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define sub_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \ #define sub_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
subs rD_LO, rN_LO, rM_LO ; \ subs rD_LO, rN_LO, rM_LO ; \
sbc rD_HI, rN_HI, rM_HI sbc rD_HI, rN_HI, rM_HI
SYNC_OP_8(sub_8) SYNC_OP_8(sub_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_umax_4.S

/*===-- sync_fetch_and_umax_4.S - ------------------------------------------===// //===-- sync_fetch_and_umax_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_umax_4 function for the ARM // This file implements the __sync_fetch_and_umax_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define umax_4(rD, rN, rM) MINMAX_4(rD, rN, rM, hi) #define umax_4(rD, rN, rM) MINMAX_4(rD, rN, rM, hi)
SYNC_OP_4(umax_4) SYNC_OP_4(umax_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_umax_8.S

/*===-- sync_fetch_and_umax_8.S - ------------------------------------------===// //===-- sync_fetch_and_umax_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_umax_8 function for the ARM // This file implements the __sync_fetch_and_umax_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define umax_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, hi) #define umax_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, hi)
SYNC_OP_8(umax_8) SYNC_OP_8(umax_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_umin_4.S

/*===-- sync_fetch_and_umin_4.S - ------------------------------------------===// //===-- sync_fetch_and_umin_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_umin_4 function for the ARM // This file implements the __sync_fetch_and_umin_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define umin_4(rD, rN, rM) MINMAX_4(rD, rN, rM, lo) #define umin_4(rD, rN, rM) MINMAX_4(rD, rN, rM, lo)
SYNC_OP_4(umin_4) SYNC_OP_4(umin_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_umin_8.S

/*===-- sync_fetch_and_umin_8.S - ------------------------------------------===// //===-- sync_fetch_and_umin_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_umin_8 function for the ARM // This file implements the __sync_fetch_and_umin_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define umin_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, lo) #define umin_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, lo)
SYNC_OP_8(umin_8) SYNC_OP_8(umin_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_xor_4.S

/*===-- sync_fetch_and_xor_4.S - ------------------------------------------===// //===-- sync_fetch_and_xor_4.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_xor_4 function for the ARM // This file implements the __sync_fetch_and_xor_4 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#define xor_4(rD, rN, rM) eor rD, rN, rM #define xor_4(rD, rN, rM) eor rD, rN, rM
SYNC_OP_4(xor_4) SYNC_OP_4(xor_4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_fetch_and_xor_8.S

/*===-- sync_fetch_and_xor_8.S - ------------------------------------------===// //===-- sync_fetch_and_xor_8.S - ------------------------------------------===//
* //
* 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 the __sync_fetch_and_xor_8 function for the ARM // This file implements the __sync_fetch_and_xor_8 function for the ARM
* architecture. // architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "sync-ops.h" #include "sync-ops.h"
#if __ARM_ARCH_PROFILE != 'M' #if __ARM_ARCH_PROFILE != 'M'
#define xor_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \ #define xor_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
eor rD_LO, rN_LO, rM_LO ; \ eor rD_LO, rN_LO, rM_LO ; \
eor rD_HI, rN_HI, rM_HI eor rD_HI, rN_HI, rM_HI
SYNC_OP_8(xor_8) SYNC_OP_8(xor_8)
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/sync_synchronize.S

//===-- sync_synchronize - Implement memory barrier * ----------------------===// //===-- sync_synchronize - Implement memory barrier * ----------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
//
// When compiling a use of the gcc built-in __sync_synchronize() in thumb1 mode // When compiling a use of the gcc built-in __sync_synchronize() in thumb1 mode
// the compiler may emit a call to __sync_synchronize. // the compiler may emit a call to __sync_synchronize.
// On Darwin the implementation jumps to an OS supplied function named // On Darwin the implementation jumps to an OS supplied function named
// OSMemoryBarrier // OSMemoryBarrier
//
.text .text
.syntax unified .syntax unified
#if __APPLE__ #if __APPLE__
.p2align 2 .p2align 2
DEFINE_COMPILERRT_PRIVATE_FUNCTION(__sync_synchronize) DEFINE_COMPILERRT_PRIVATE_FUNCTION(__sync_synchronize)
stmfd sp!, {r7, lr} stmfd sp!, {r7, lr}
add r7, sp, #0 add r7, sp, #0
bl _OSMemoryBarrier bl _OSMemoryBarrier
ldmfd sp!, {r7, pc} ldmfd sp!, {r7, pc}
END_COMPILERRT_FUNCTION(__sync_synchronize) END_COMPILERRT_FUNCTION(__sync_synchronize)
// tell linker it can break up file at label boundaries // tell linker it can break up file at label boundaries
.subsections_via_symbols .subsections_via_symbols
#endif #endif
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/truncdfsf2vfp.S

//===-- truncdfsf2vfp.S - Implement truncdfsf2vfp -------------------------===// //===-- truncdfsf2vfp.S - Implement truncdfsf2vfp -------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern float __truncdfsf2vfp(double a); // extern float __truncdfsf2vfp(double a);
// //
// Converts double precision float to signle precision result. // Converts double precision float to signle precision result.
// Uses Darwin calling convention where a double precision parameter is // Uses Darwin calling convention where a double precision parameter is
// passed in a R0/R1 pair and a signle precision result is returned in R0. // passed in a R0/R1 pair and a signle precision result is returned in R0.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp) DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcvt.f32.f64 s0, d0 vcvt.f32.f64 s0, d0
#else #else
Show All 9 Lines

lib/builtins/arm/udivmodsi4.S

/*===-- udivmodsi4.S - 32-bit unsigned integer divide and modulus ---------===// //===-- udivmodsi4.S - 32-bit unsigned integer divide and modulus ---------===//
* //
* 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 the __udivmodsi4 (32-bit unsigned integer divide and // This file implements the __udivmodsi4 (32-bit unsigned integer divide and
* modulus) function for the ARM 32-bit architecture. // modulus) function for the ARM 32-bit architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
.syntax unified .syntax unified
.text .text
DEFINE_CODE_STATE DEFINE_CODE_STATE
@ unsigned int __udivmodsi4(unsigned int divident, unsigned int divisor, @ unsigned int __udivmodsi4(unsigned int divident, unsigned int divisor,
Show All 12 Lines#if __ARM_ARCH_EXT_IDIV__
str r1, [r2] str r1, [r2]
bx lr bx lr
#else #else
cmp r1, #1 cmp r1, #1
bcc LOCAL_LABEL(divby0) bcc LOCAL_LABEL(divby0)
beq LOCAL_LABEL(divby1) beq LOCAL_LABEL(divby1)
cmp r0, r1 cmp r0, r1
bcc LOCAL_LABEL(quotient0) bcc LOCAL_LABEL(quotient0)
/*
* Implement division using binary long division algorithm. // Implement division using binary long division algorithm.
* //
* r0 is the numerator, r1 the denominator. // r0 is the numerator, r1 the denominator.
* //
* The code before JMP computes the correct shift I, so that // The code before JMP computes the correct shift I, so that
* r0 and (r1 << I) have the highest bit set in the same position. // r0 and (r1 << I) have the highest bit set in the same position.
* At the time of JMP, ip := .Ldiv0block - 12 * I. // At the time of JMP, ip := .Ldiv0block - 12 * I.
* This depends on the fixed instruction size of block. // This depends on the fixed instruction size of block.
* For ARM mode, this is 12 Bytes, for THUMB mode 14 Bytes. // For ARM mode, this is 12 Bytes, for THUMB mode 14 Bytes.
* //
* block(shift) implements the test-and-update-quotient core. // block(shift) implements the test-and-update-quotient core.
* It assumes (r0 << shift) can be computed without overflow and // It assumes (r0 << shift) can be computed without overflow and
* that (r0 << shift) < 2 * r1. The quotient is stored in r3. // that (r0 << shift) < 2 * r1. The quotient is stored in r3.
*/
# ifdef __ARM_FEATURE_CLZ # ifdef __ARM_FEATURE_CLZ
clz ip, r0 clz ip, r0
clz r3, r1 clz r3, r1
/* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */ // r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3.
sub r3, r3, ip sub r3, r3, ip
# if defined(USE_THUMB_2) # if defined(USE_THUMB_2)
adr ip, LOCAL_LABEL(div0block) + 1 adr ip, LOCAL_LABEL(div0block) + 1
sub ip, ip, r3, lsl #1 sub ip, ip, r3, lsl #1
# else # else
adr ip, LOCAL_LABEL(div0block) adr ip, LOCAL_LABEL(div0block)
# endif # endif
sub ip, ip, r3, lsl #2 sub ip, ip, r3, lsl #2
Show All 24 Lines# endif
movhs r4, r3 movhs r4, r3
subhs ip, #(4 * 12) subhs ip, #(4 * 12)
lsr r3, r4, #2 lsr r3, r4, #2
cmp r3, r1 cmp r3, r1
movhs r4, r3 movhs r4, r3
subhs ip, ip, #(2 * 12) subhs ip, ip, #(2 * 12)
/* Last block, no need to update r3 or r4. */ // Last block, no need to update r3 or r4.
cmp r1, r4, lsr #1 cmp r1, r4, lsr #1
subls ip, ip, #(1 * 12) subls ip, ip, #(1 * 12)
ldr r4, [sp], #8 /* restore r4, we are done with it. */ ldr r4, [sp], #8 // restore r4, we are done with it.
mov r3, #0 mov r3, #0
JMP(ip) JMP(ip)
# endif # endif
#define IMM # #define IMM #
#define block(shift) \ #define block(shift) \
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 LinesLOCAL_LABEL(quotient0):
str r0, [r2] str r0, [r2]
mov r0, #0 mov r0, #0
JMP(lr) JMP(lr)
LOCAL_LABEL(divby1): LOCAL_LABEL(divby1):
mov r3, #0 mov r3, #0
str r3, [r2] str r3, [r2]
JMP(lr) JMP(lr)
#endif /* __ARM_ARCH_EXT_IDIV__ */ #endif // __ARM_ARCH_EXT_IDIV__
LOCAL_LABEL(divby0): LOCAL_LABEL(divby0):
mov r0, #0 mov r0, #0
#ifdef __ARM_EABI__ #ifdef __ARM_EABI__
b __aeabi_idiv0 b __aeabi_idiv0
#else #else
JMP(lr) JMP(lr)
#endif #endif
END_COMPILERRT_FUNCTION(__udivmodsi4) END_COMPILERRT_FUNCTION(__udivmodsi4)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/udivsi3.S

/*===-- udivsi3.S - 32-bit unsigned integer divide ------------------------===// //===-- udivsi3.S - 32-bit unsigned integer divide ------------------------===//
* //
* 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 the __udivsi3 (32-bit unsigned integer divide) // This file implements the __udivsi3 (32-bit unsigned integer divide)
* function for the ARM 32-bit architecture. // function for the ARM 32-bit architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
.syntax unified .syntax unified
.text .text
DEFINE_CODE_STATE DEFINE_CODE_STATE
Show All 13 Lines
LOCAL_LABEL(divby0): LOCAL_LABEL(divby0):
mov r0, #0 mov r0, #0
# ifdef __ARM_EABI__ # ifdef __ARM_EABI__
b __aeabi_idiv0 b __aeabi_idiv0
# else # else
JMP(lr) JMP(lr)
# endif # endif
#else /* ! __ARM_ARCH_EXT_IDIV__ */ #else // ! __ARM_ARCH_EXT_IDIV__
cmp r1, #1 cmp r1, #1
bcc LOCAL_LABEL(divby0) bcc LOCAL_LABEL(divby0)
#if defined(USE_THUMB_1) #if defined(USE_THUMB_1)
bne LOCAL_LABEL(num_neq_denom) bne LOCAL_LABEL(num_neq_denom)
JMP(lr) JMP(lr)
LOCAL_LABEL(num_neq_denom): LOCAL_LABEL(num_neq_denom):
#else #else
IT(eq) IT(eq)
JMPc(lr, eq) JMPc(lr, eq)
#endif #endif
cmp r0, r1 cmp r0, r1
#if defined(USE_THUMB_1) #if defined(USE_THUMB_1)
bhs LOCAL_LABEL(num_ge_denom) bhs LOCAL_LABEL(num_ge_denom)
movs r0, #0 movs r0, #0
JMP(lr) JMP(lr)
LOCAL_LABEL(num_ge_denom): LOCAL_LABEL(num_ge_denom):
#else #else
ITT(cc) ITT(cc)
movcc r0, #0 movcc r0, #0
JMPc(lr, cc) JMPc(lr, cc)
#endif #endif
/* // Implement division using binary long division algorithm.
* Implement division using binary long division algorithm. //
* // r0 is the numerator, r1 the denominator.
* r0 is the numerator, r1 the denominator. //
* // The code before JMP computes the correct shift I, so that
* The code before JMP computes the correct shift I, so that // r0 and (r1 << I) have the highest bit set in the same position.
* r0 and (r1 << I) have the highest bit set in the same position. // At the time of JMP, ip := .Ldiv0block - 12 * I.
* At the time of JMP, ip := .Ldiv0block - 12 * I. // This depends on the fixed instruction size of block.
* This depends on the fixed instruction size of block. // For ARM mode, this is 12 Bytes, for THUMB mode 14 Bytes.
* For ARM mode, this is 12 Bytes, for THUMB mode 14 Bytes. //
* // block(shift) implements the test-and-update-quotient core.
* block(shift) implements the test-and-update-quotient core. // It assumes (r0 << shift) can be computed without overflow and
* It assumes (r0 << shift) can be computed without overflow and // that (r0 << shift) < 2 * r1. The quotient is stored in r3.
* that (r0 << shift) < 2 * r1. The quotient is stored in r3.
*/
# if defined(__ARM_FEATURE_CLZ) # if defined(__ARM_FEATURE_CLZ)
clz ip, r0 clz ip, r0
clz r3, r1 clz r3, r1
/* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */ // r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3.
sub r3, r3, ip sub r3, r3, ip
# if defined(USE_THUMB_2) # if defined(USE_THUMB_2)
adr ip, LOCAL_LABEL(div0block) + 1 adr ip, LOCAL_LABEL(div0block) + 1
sub ip, ip, r3, lsl #1 sub ip, ip, r3, lsl #1
# else # else
adr ip, LOCAL_LABEL(div0block) adr ip, LOCAL_LABEL(div0block)
# endif # endif
sub ip, ip, r3, lsl #2 sub ip, ip, r3, lsl #2
sub ip, ip, r3, lsl #3 sub ip, ip, r3, lsl #3
mov r3, #0 mov r3, #0
bx ip bx ip
# else /* No CLZ Feature */ # else // No CLZ Feature
# if defined(USE_THUMB_2) # if defined(USE_THUMB_2)
# error THUMB mode requires CLZ or UDIV # error THUMB mode requires CLZ or UDIV
# endif # endif
# if defined(USE_THUMB_1) # if defined(USE_THUMB_1)
# define BLOCK_SIZE 10 # define BLOCK_SIZE 10
# else # else
# define BLOCK_SIZE 12 # define BLOCK_SIZE 12
# endif # endif
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines# if defined(USE_THUMB_1)
movs r2, r3 movs r2, r3
subs r0, r0, #(2 * BLOCK_SIZE) subs r0, r0, #(2 * BLOCK_SIZE)
LOCAL_LABEL(skip_2): LOCAL_LABEL(skip_2):
# else # else
movhs r2, r3 movhs r2, r3
subhs ip, ip, #(2 * BLOCK_SIZE) subhs ip, ip, #(2 * BLOCK_SIZE)
# endif # endif
/* Last block, no need to update r2 or r3. */ // Last block, no need to update r2 or r3.
# if defined(USE_THUMB_1) # if defined(USE_THUMB_1)
lsrs r3, r2, #1 lsrs r3, r2, #1
cmp r3, r1 cmp r3, r1
blo LOCAL_LABEL(skip_1) blo LOCAL_LABEL(skip_1)
subs r0, r0, #(1 * BLOCK_SIZE) subs r0, r0, #(1 * BLOCK_SIZE)
LOCAL_LABEL(skip_1): LOCAL_LABEL(skip_1):
movs r2, r0 movs r2, r0
mov r0, ip mov r0, ip
movs r3, #0 movs r3, #0
JMP (r2) JMP (r2)
# else # else
cmp r1, r2, lsr #1 cmp r1, r2, lsr #1
subls ip, ip, #(1 * BLOCK_SIZE) subls ip, ip, #(1 * BLOCK_SIZE)
movs r3, #0 movs r3, #0
JMP(ip) JMP(ip)
# endif # endif
# endif /* __ARM_FEATURE_CLZ */ # endif // __ARM_FEATURE_CLZ
#define IMM # #define IMM #
/* due to the range limit of branch in Thumb1, we have to place the // due to the range limit of branch in Thumb1, we have to place the
block closer */ // block closer
LOCAL_LABEL(divby0): LOCAL_LABEL(divby0):
movs r0, #0 movs r0, #0
# if defined(__ARM_EABI__) # if defined(__ARM_EABI__)
push {r7, lr} push {r7, lr}
bl __aeabi_idiv0 // due to relocation limit, can't use b. bl __aeabi_idiv0 // due to relocation limit, can't use b.
pop {r7, pc} pop {r7, pc}
# else # else
JMP(lr) JMP(lr)
# endif # endif
#if defined(USE_THUMB_1) #if defined(USE_THUMB_1)
#define block(shift) \ #define block(shift) \
lsls r2, r1, IMM shift; \ lsls r2, r1, IMM shift; \
cmp r0, r2; \ cmp r0, r2; \
blo LOCAL_LABEL(block_skip_##shift); \ blo LOCAL_LABEL(block_skip_##shift); \
subs r0, r0, r2; \ subs r0, r0, r2; \
LOCAL_LABEL(block_skip_##shift) :; \ LOCAL_LABEL(block_skip_##shift) :; \
adcs r3, r3 /* same as ((r3 << 1) | Carry). Carry is set if r0 >= r2. */ adcs r3, r3 // same as ((r3 << 1) | Carry). Carry is set if r0 >= r2.
/* TODO: if current location counter is not not word aligned, we don't // TODO: if current location counter is not not word aligned, we don't
need the .p2align and nop */ // need the .p2align and nop
/* Label div0block must be word-aligned. First align block 31 */ // Label div0block must be word-aligned. First align block 31
.p2align 2 .p2align 2
nop /* Padding to align div0block as 31 blocks = 310 bytes */ nop // Padding to align div0block as 31 blocks = 310 bytes
#else #else
#define block(shift) \ #define block(shift) \
cmp r0, r1, lsl IMM shift; \ cmp r0, r1, lsl IMM shift; \
ITT(hs); \ ITT(hs); \
WIDE(addhs) r3, r3, IMM (1 << shift); \ WIDE(addhs) r3, r3, IMM (1 << shift); \
WIDE(subhs) r0, r0, r1, lsl IMM shift WIDE(subhs) r0, r0, r1, lsl IMM shift
#endif #endif
Show All 29 Lines#endif
block(3) block(3)
block(2) block(2)
block(1) block(1)
LOCAL_LABEL(div0block): LOCAL_LABEL(div0block):
block(0) block(0)
mov r0, r3 mov r0, r3
JMP(lr) JMP(lr)
#endif /* __ARM_ARCH_EXT_IDIV__ */ #endif // __ARM_ARCH_EXT_IDIV__
END_COMPILERRT_FUNCTION(__udivsi3) END_COMPILERRT_FUNCTION(__udivsi3)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/umodsi3.S

/*===-- umodsi3.S - 32-bit unsigned integer modulus -----------------------===// //===-- umodsi3.S - 32-bit unsigned integer modulus -----------------------===//
* //
* 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 the __umodsi3 (32-bit unsigned integer modulus) // This file implements the __umodsi3 (32-bit unsigned integer modulus)
* function for the ARM 32-bit architecture. // function for the ARM 32-bit architecture.
* //
*===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
.syntax unified .syntax unified
.text .text
DEFINE_CODE_STATE DEFINE_CODE_STATE
@ unsigned int __umodsi3(unsigned int divident, unsigned int divisor) @ unsigned int __umodsi3(unsigned int divident, unsigned int divisor)
Show All 11 Lines#else
cmp r1, #1 cmp r1, #1
bcc LOCAL_LABEL(divby0) bcc LOCAL_LABEL(divby0)
ITT(eq) ITT(eq)
moveq r0, #0 moveq r0, #0
JMPc(lr, eq) JMPc(lr, eq)
cmp r0, r1 cmp r0, r1
IT(cc) IT(cc)
JMPc(lr, cc) JMPc(lr, cc)
/*
* Implement division using binary long division algorithm. // Implement division using binary long division algorithm.
* //
* r0 is the numerator, r1 the denominator. // r0 is the numerator, r1 the denominator.
* //
* The code before JMP computes the correct shift I, so that // The code before JMP computes the correct shift I, so that
* r0 and (r1 << I) have the highest bit set in the same position. // r0 and (r1 << I) have the highest bit set in the same position.
* At the time of JMP, ip := .Ldiv0block - 8 * I. // At the time of JMP, ip := .Ldiv0block - 8 * I.
* This depends on the fixed instruction size of block. // This depends on the fixed instruction size of block.
* For ARM mode, this is 8 Bytes, for THUMB mode 10 Bytes. // For ARM mode, this is 8 Bytes, for THUMB mode 10 Bytes.
* //
* block(shift) implements the test-and-update-quotient core. // block(shift) implements the test-and-update-quotient core.
* It assumes (r0 << shift) can be computed without overflow and // It assumes (r0 << shift) can be computed without overflow and
* that (r0 << shift) < 2 * r1. The quotient is stored in r3. // that (r0 << shift) < 2 * r1. The quotient is stored in r3.
*/
# ifdef __ARM_FEATURE_CLZ # ifdef __ARM_FEATURE_CLZ
clz ip, r0 clz ip, r0
clz r3, r1 clz r3, r1
/* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */ // r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3.
sub r3, r3, ip sub r3, r3, ip
# if defined(USE_THUMB_2) # if defined(USE_THUMB_2)
adr ip, LOCAL_LABEL(div0block) + 1 adr ip, LOCAL_LABEL(div0block) + 1
sub ip, ip, r3, lsl #1 sub ip, ip, r3, lsl #1
# else # else
adr ip, LOCAL_LABEL(div0block) adr ip, LOCAL_LABEL(div0block)
# endif # endif
sub ip, ip, r3, lsl #3 sub ip, ip, r3, lsl #3
Show All 20 Lines# endif
movhs r2, r3 movhs r2, r3
subhs ip, #(4 * 8) subhs ip, #(4 * 8)
lsr r3, r2, #2 lsr r3, r2, #2
cmp r3, r1 cmp r3, r1
movhs r2, r3 movhs r2, r3
subhs ip, ip, #(2 * 8) subhs ip, ip, #(2 * 8)
/* Last block, no need to update r2 or r3. */ // Last block, no need to update r2 or r3.
cmp r1, r2, lsr #1 cmp r1, r2, lsr #1
subls ip, ip, #(1 * 8) subls ip, ip, #(1 * 8)
JMP(ip) JMP(ip)
# endif # endif
#define IMM # #define IMM #
Show All 31 Lines#define block(shift) \
block(5) block(5)
block(4) block(4)
block(3) block(3)
block(2) block(2)
block(1) block(1)
LOCAL_LABEL(div0block): LOCAL_LABEL(div0block):
block(0) block(0)
JMP(lr) JMP(lr)
#endif /* __ARM_ARCH_EXT_IDIV__ */ #endif // __ARM_ARCH_EXT_IDIV__
LOCAL_LABEL(divby0): LOCAL_LABEL(divby0):
mov r0, #0 mov r0, #0
#ifdef __ARM_EABI__ #ifdef __ARM_EABI__
b __aeabi_idiv0 b __aeabi_idiv0
#else #else
JMP(lr) JMP(lr)
#endif #endif
END_COMPILERRT_FUNCTION(__umodsi3) END_COMPILERRT_FUNCTION(__umodsi3)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/arm/unorddf2vfp.S

//===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===// //===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __unorddf2vfp(double a, double b); // extern int __unorddf2vfp(double a, double b);
// //
// Returns one iff a or b is NaN // Returns one iff a or b is NaN
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passsed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp) DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

lib/builtins/arm/unordsf2vfp.S

//===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===// //===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===//
// //
// 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 "../assembly.h" #include "../assembly.h"
// //
// extern int __unordsf2vfp(float a, float b); // extern int __unordsf2vfp(float a, float b);
// //
// Returns one iff a or b is NaN // Returns one iff a or b is NaN
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passsed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp) DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

lib/builtins/ashldi3.c

/* ====-- ashldi3.c - Implement __ashldi3 -----------------------------------=== // ====-- ashldi3.c - Implement __ashldi3 ---------------------------------===//
* //
* 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 __ashldi3 for the compiler_rt library. // This file implements __ashldi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ashldi3(di_int a, si_int b) { COMPILER_RT_ABI di_int __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) AEABI_RTABI di_int __aeabi_llsl(di_int a, si_int b)
COMPILER_RT_ALIAS(__ashldi3); COMPILER_RT_ALIAS(__ashldi3);
#endif #endif

lib/builtins/ashlti3.c

/* ===-- ashlti3.c - Implement __ashlti3 -----------------------------------=== //===-- ashlti3.c - Implement __ashlti3 -----------------------------------===//
* //
* 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 __ashlti3 for the compiler_rt library. // This file implements __ashlti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ashlti3(ti_int a, si_int b) { COMPILER_RT_ABI ti_int __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

lib/builtins/ashrdi3.c

/*===-- ashrdi3.c - Implement __ashrdi3 -----------------------------------=== //===-- ashrdi3.c - Implement __ashrdi3 -----------------------------------===//
* //
* 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 __ashrdi3 for the compiler_rt library. // This file implements __ashrdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ashrdi3(di_int a, si_int b) { COMPILER_RT_ABI di_int __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) AEABI_RTABI di_int __aeabi_lasr(di_int a, si_int b)
COMPILER_RT_ALIAS(__ashrdi3); COMPILER_RT_ALIAS(__ashrdi3);
#endif #endif

lib/builtins/ashrti3.c

/* ===-- ashrti3.c - Implement __ashrti3 -----------------------------------=== //===-- ashrti3.c - Implement __ashrti3 -----------------------------------===//
* //
* 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 __ashrti3 for the compiler_rt library. // This file implements __ashrti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ashrti3(ti_int a, si_int b) { COMPILER_RT_ABI ti_int __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

lib/builtins/assembly.h

/* ===-- assembly.h - compiler-rt assembler support macros -----------------=== //===-- assembly.h - compiler-rt assembler support macros -----------------===//
* //
* 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 defines macros for use in compiler-rt assembler source. // This file defines macros for use in compiler-rt assembler source.
* This file is not part of the interface of this library. // This file is not part of the interface of this library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef COMPILERRT_ASSEMBLY_H #ifndef COMPILERRT_ASSEMBLY_H
#define COMPILERRT_ASSEMBLY_H #define COMPILERRT_ASSEMBLY_H
#if defined(__POWERPC__) || defined(__powerpc__) || defined(__ppc__) #if defined(__POWERPC__) || defined(__powerpc__) || defined(__ppc__)
#define SEPARATOR @ #define SEPARATOR @
#else #else
#define SEPARATOR ; #define SEPARATOR ;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
#define CONST_SECTION .section .rdata,"rd" #define CONST_SECTION .section .rdata,"rd"
#define NO_EXEC_STACK_DIRECTIVE #define NO_EXEC_STACK_DIRECTIVE
#endif #endif
#if defined(__arm__) #if defined(__arm__)
/* // Determine actual [ARM][THUMB[1][2]] ISA using compiler predefined macros:
* Determine actual [ARM][THUMB[1][2]] ISA using compiler predefined macros: // - for '-mthumb -march=armv6' compiler defines '__thumb__'
* - for '-mthumb -march=armv6' compiler defines '__thumb__' // - for '-mthumb -march=armv7' compiler defines '__thumb__' and '__thumb2__'
* - for '-mthumb -march=armv7' compiler defines '__thumb__' and '__thumb2__'
*/
#if defined(__thumb2__) || defined(__thumb__) #if defined(__thumb2__) || defined(__thumb__)
#define DEFINE_CODE_STATE .thumb SEPARATOR #define DEFINE_CODE_STATE .thumb SEPARATOR
#define DECLARE_FUNC_ENCODING .thumb_func SEPARATOR #define DECLARE_FUNC_ENCODING .thumb_func SEPARATOR
#if defined(__thumb2__) #if defined(__thumb2__)
#define USE_THUMB_2 #define USE_THUMB_2
#define IT(cond) it cond #define IT(cond) it cond
#define ITT(cond) itt cond #define ITT(cond) itt cond
#define ITE(cond) ite cond #define ITE(cond) ite cond
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
#ifdef __ELF__ #ifdef __ELF__
#define END_COMPILERRT_FUNCTION(name) \ #define END_COMPILERRT_FUNCTION(name) \
.size SYMBOL_NAME(name), . - SYMBOL_NAME(name) .size SYMBOL_NAME(name), . - SYMBOL_NAME(name)
#else #else
#define END_COMPILERRT_FUNCTION(name) #define END_COMPILERRT_FUNCTION(name)
#endif #endif
#endif /* COMPILERRT_ASSEMBLY_H */ #endif // COMPILERRT_ASSEMBLY_H

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.
▲ Show 20 Lines • Show All 310 Lines • Show Last 20 Lines

lib/builtins/atomic_flag_clear.c

/*===-- atomic_flag_clear.c -------------------------------------------------=== //===-- atomic_flag_clear.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 atomic_flag_clear from C11's stdatomic.h. // This file implements atomic_flag_clear from C11's stdatomic.h.
* //
*===------------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef __has_include #ifndef __has_include
#define __has_include(inc) 0 #define __has_include(inc) 0
#endif #endif
#if __has_include(<stdatomic.h>) #if __has_include(<stdatomic.h>)
#include <stdatomic.h> #include <stdatomic.h>
#undef atomic_flag_clear #undef atomic_flag_clear
void atomic_flag_clear(volatile atomic_flag *object) { void atomic_flag_clear(volatile atomic_flag *object) {
__c11_atomic_store(&(object)->_Value, 0, __ATOMIC_SEQ_CST); __c11_atomic_store(&(object)->_Value, 0, __ATOMIC_SEQ_CST);
} }
#endif #endif

lib/builtins/atomic_flag_clear_explicit.c

/*===-- atomic_flag_clear_explicit.c ----------------------------------------=== //===-- atomic_flag_clear_explicit.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 atomic_flag_clear_explicit from C11's stdatomic.h. // This file implements atomic_flag_clear_explicit from C11's stdatomic.h.
* //
*===------------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef __has_include #ifndef __has_include
#define __has_include(inc) 0 #define __has_include(inc) 0
#endif #endif
#if __has_include(<stdatomic.h>) #if __has_include(<stdatomic.h>)
#include <stdatomic.h> #include <stdatomic.h>
#undef atomic_flag_clear_explicit #undef atomic_flag_clear_explicit
void atomic_flag_clear_explicit(volatile atomic_flag *object, void atomic_flag_clear_explicit(volatile atomic_flag *object,
memory_order order) { memory_order order) {
__c11_atomic_store(&(object)->_Value, 0, order); __c11_atomic_store(&(object)->_Value, 0, order);
} }
#endif #endif

lib/builtins/atomic_flag_test_and_set.c

/*===-- atomic_flag_test_and_set.c ------------------------------------------=== //===-- atomic_flag_test_and_set.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 atomic_flag_test_and_set from C11's stdatomic.h. // This file implements atomic_flag_test_and_set from C11's stdatomic.h.
* //
*===------------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef __has_include #ifndef __has_include
#define __has_include(inc) 0 #define __has_include(inc) 0
#endif #endif
#if __has_include(<stdatomic.h>) #if __has_include(<stdatomic.h>)
#include <stdatomic.h> #include <stdatomic.h>
#undef atomic_flag_test_and_set #undef atomic_flag_test_and_set
_Bool atomic_flag_test_and_set(volatile atomic_flag *object) { _Bool atomic_flag_test_and_set(volatile atomic_flag *object) {
return __c11_atomic_exchange(&(object)->_Value, 1, __ATOMIC_SEQ_CST); return __c11_atomic_exchange(&(object)->_Value, 1, __ATOMIC_SEQ_CST);
} }
#endif #endif

lib/builtins/atomic_flag_test_and_set_explicit.c

/*===-- atomic_flag_test_and_set_explicit.c ---------------------------------=== //===-- atomic_flag_test_and_set_explicit.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 atomic_flag_test_and_set_explicit from C11's stdatomic.h // This file implements atomic_flag_test_and_set_explicit from C11's stdatomic.h
* //
*===------------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef __has_include #ifndef __has_include
#define __has_include(inc) 0 #define __has_include(inc) 0
#endif #endif
#if __has_include(<stdatomic.h>) #if __has_include(<stdatomic.h>)
#include <stdatomic.h> #include <stdatomic.h>
#undef atomic_flag_test_and_set_explicit #undef atomic_flag_test_and_set_explicit
_Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, _Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
memory_order order) { memory_order order) {
return __c11_atomic_exchange(&(object)->_Value, 1, order); return __c11_atomic_exchange(&(object)->_Value, 1, order);
} }
#endif #endif

lib/builtins/atomic_signal_fence.c

/*===-- atomic_signal_fence.c -----------------------------------------------=== //===-- atomic_signal_fence.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 atomic_signal_fence from C11's stdatomic.h. // This file implements atomic_signal_fence from C11's stdatomic.h.
* //
*===------------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef __has_include #ifndef __has_include
#define __has_include(inc) 0 #define __has_include(inc) 0
#endif #endif
#if __has_include(<stdatomic.h>) #if __has_include(<stdatomic.h>)
#include <stdatomic.h> #include <stdatomic.h>
#undef atomic_signal_fence #undef atomic_signal_fence
void atomic_signal_fence(memory_order order) { void atomic_signal_fence(memory_order order) {
__c11_atomic_signal_fence(order); __c11_atomic_signal_fence(order);
} }
#endif #endif

lib/builtins/atomic_thread_fence.c

/*===-- atomic_thread_fence.c -----------------------------------------------=== //===-- atomic_thread_fence.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 atomic_thread_fence from C11's stdatomic.h. // This file implements atomic_thread_fence from C11's stdatomic.h.
* //
*===------------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef __has_include #ifndef __has_include
#define __has_include(inc) 0 #define __has_include(inc) 0
#endif #endif
#if __has_include(<stdatomic.h>) #if __has_include(<stdatomic.h>)
#include <stdatomic.h> #include <stdatomic.h>
#undef atomic_thread_fence #undef atomic_thread_fence
void atomic_thread_fence(memory_order order) { void atomic_thread_fence(memory_order order) {
__c11_atomic_thread_fence(order); __c11_atomic_thread_fence(order);
} }
#endif #endif

lib/builtins/bswapdi2.c

/* ===-- bswapdi2.c - Implement __bswapdi2 ---------------------------------=== //===-- bswapdi2.c - Implement __bswapdi2 ---------------------------------===//
* //
* 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 __bswapdi2 for the compiler_rt library. // This file implements __bswapdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI uint64_t __bswapdi2(uint64_t u) { COMPILER_RT_ABI uint64_t __bswapdi2(uint64_t u) {
return ( return (
(((u)&0xff00000000000000ULL) >> 56) | (((u)&0xff00000000000000ULL) >> 56) |
(((u)&0x00ff000000000000ULL) >> 40) | (((u)&0x00ff000000000000ULL) >> 40) |
(((u)&0x0000ff0000000000ULL) >> 24) | (((u)&0x0000ff0000000000ULL) >> 24) |
(((u)&0x000000ff00000000ULL) >> 8) | (((u)&0x000000ff00000000ULL) >> 8) |
(((u)&0x00000000ff000000ULL) << 8) | (((u)&0x00000000ff000000ULL) << 8) |
(((u)&0x0000000000ff0000ULL) << 24) | (((u)&0x0000000000ff0000ULL) << 24) |
(((u)&0x000000000000ff00ULL) << 40) | (((u)&0x000000000000ff00ULL) << 40) |
(((u)&0x00000000000000ffULL) << 56)); (((u)&0x00000000000000ffULL) << 56));
} }

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 ((((u)&0xff000000) >> 24) | return ((((u)&0xff000000) >> 24) |
(((u)&0x00ff0000) >> 8) | (((u)&0x00ff0000) >> 8) |
(((u)&0x0000ff00) << 8) | (((u)&0x0000ff00) << 8) |
(((u)&0x000000ff) << 24)); (((u)&0x000000ff) << 24));
} }

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 <machine/sysarch.h> #include <machine/sysarch.h>
#include <sys/types.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 <machine/sysarch.h> #include <machine/sysarch.h>
#include <sys/types.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)::"at", "ra", "v0", "memory"); : [ Addr ] "+r"(Addr), [ Size ] "+r"(Size)::"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"(flags)); : "r"(syscall_nr), "r"(start_reg), "r"(end_reg), "r"(flags));
Show All 21 Lines#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;
Show All 12 Lines 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
} }

lib/builtins/clzdi2.c

/* ===-- clzdi2.c - Implement __clzdi2 -------------------------------------=== //===-- clzdi2.c - Implement __clzdi2 -------------------------------------===//
* //
* 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 __clzdi2 for the compiler_rt library. // This file implements __clzdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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(__mips64) || \ ((defined(__sparc__) && defined(__arch64__)) || 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 __clzdi2(di_int a) { COMPILER_RT_ABI si_int __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)));
} }

lib/builtins/clzsi2.c

/* ===-- clzsi2.c - Implement __clzsi2 -------------------------------------=== //===-- clzsi2.c - Implement __clzsi2 -------------------------------------===//
* //
* 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 __clzsi2 for the compiler_rt library. // This file implements __clzsi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __clzsi2(si_int a) { COMPILER_RT_ABI si_int __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));
} }

lib/builtins/clzti2.c

/* ===-- clzti2.c - Implement __clzti2 -------------------------------------=== //===-- clzti2.c - Implement __clzti2 -------------------------------------===//
* //
* 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 __clzti2 for the compiler_rt library. // This file implements __clzti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __clzti2(ti_int a) { COMPILER_RT_ABI si_int __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

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 __cmpdi2(di_int a, di_int b) { COMPILER_RT_ABI si_int __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 __aeabi_lcmp(di_int a, di_int b) { COMPILER_RT_ABI si_int __aeabi_lcmp(di_int a, di_int b) {
return __cmpdi2(a, b) - 1; return __cmpdi2(a, b) - 1;
} }
#endif #endif

lib/builtins/cmpti2.c

/* ===-- cmpti2.c - Implement __cmpti2 -------------------------------------=== //===-- cmpti2.c - Implement __cmpti2 -------------------------------------===//
* //
* 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 __cmpti2 for the compiler_rt library. // This file implements __cmpti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
#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 __cmpti2(ti_int a, ti_int b) { COMPILER_RT_ABI si_int __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

lib/builtins/cpu_model.c

Show All 25 Lines
#include <intrin.h> #include <intrin.h>
#endif #endif
#ifndef __has_attribute #ifndef __has_attribute
#define __has_attribute(attr) 0 #define __has_attribute(attr) 0
#endif #endif
enum VendorSignatures { enum VendorSignatures {
SIG_INTEL = 0x756e6547 /* Genu */, SIG_INTEL = 0x756e6547, // Genu
SIG_AMD = 0x68747541 /* Auth */ SIG_AMD = 0x68747541, // Auth
}; };
enum ProcessorVendors { enum ProcessorVendors {
VENDOR_INTEL = 1, VENDOR_INTEL = 1,
VENDOR_AMD, VENDOR_AMD,
VENDOR_OTHER, VENDOR_OTHER,
VENDOR_MAX VENDOR_MAX
}; };
▲ Show 20 Lines • Show All 563 Lines • ▼ Show 20 Linesstruct __processor_model {
unsigned int __cpu_features[1]; unsigned int __cpu_features[1];
} __cpu_model = {0, 0, 0, {0}}; } __cpu_model = {0, 0, 0, {0}};
#ifndef _WIN32 #ifndef _WIN32
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden")))
#endif #endif
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 __cpu_indicator_init(void) { int CONSTRUCTOR_ATTRIBUTE __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.
if (__cpu_model.__cpu_vendor) if (__cpu_model.__cpu_vendor)
return 0; return 0;
if (!isCpuIdSupported()) if (!isCpuIdSupported())
return -1; return -1;
/* Assume cpuid insn present. Run in level 0 to get vendor id. */ // Assume cpuid insn present. Run in level 0 to get vendor id.
if (getX86CpuIDAndInfo(0, &MaxLeaf, &Vendor, &ECX, &EDX) || MaxLeaf < 1) { if (getX86CpuIDAndInfo(0, &MaxLeaf, &Vendor, &ECX, &EDX) || MaxLeaf < 1) {
__cpu_model.__cpu_vendor = VENDOR_OTHER; __cpu_model.__cpu_vendor = VENDOR_OTHER;
return -1; return -1;
} }
getX86CpuIDAndInfo(1, &EAX, &EBX, &ECX, &EDX); getX86CpuIDAndInfo(1, &EAX, &EBX, &ECX, &EDX);
detectX86FamilyModel(EAX, &Family, &Model); detectX86FamilyModel(EAX, &Family, &Model);
Brand_id = EBX & 0xff; Brand_id = EBX & 0xff;
/* 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, &(__cpu_model.__cpu_type), Features2, &(__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;
} else } else
__cpu_model.__cpu_vendor = VENDOR_OTHER; __cpu_model.__cpu_vendor = VENDOR_OTHER;
assert(__cpu_model.__cpu_vendor < VENDOR_MAX); assert(__cpu_model.__cpu_vendor < VENDOR_MAX);
assert(__cpu_model.__cpu_type < CPU_TYPE_MAX); assert(__cpu_model.__cpu_type < CPU_TYPE_MAX);
assert(__cpu_model.__cpu_subtype < CPU_SUBTYPE_MAX); assert(__cpu_model.__cpu_subtype < CPU_SUBTYPE_MAX);
return 0; return 0;
} }
#endif #endif

lib/builtins/ctzdi2.c

/* ===-- ctzdi2.c - Implement __ctzdi2 -------------------------------------=== //===-- ctzdi2.c - Implement __ctzdi2 -------------------------------------===//
* //
* 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 __ctzdi2 for the compiler_rt library. // This file implements __ctzdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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(__mips64) || \ ((defined(__sparc__) && defined(__arch64__)) || 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 __ctzdi2(di_int a) { COMPILER_RT_ABI si_int __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)));
} }

lib/builtins/ctzsi2.c

/* ===-- ctzsi2.c - Implement __ctzsi2 -------------------------------------=== //===-- ctzsi2.c - Implement __ctzsi2 -------------------------------------===//
* //
* 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 __ctzsi2 for the compiler_rt library. // This file implements __ctzsi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ctzsi2(si_int a) { COMPILER_RT_ABI si_int __ctzsi2(si_int a) {
su_int x = (su_int)a; su_int x = (su_int)a;
si_int t = ((x & 0x0000FFFF) == 0) si_int t = ((x & 0x0000FFFF) == 0)
<< 4; /* if (x has no small bits) t = 16 else 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));
} }

lib/builtins/ctzti2.c

/* ===-- ctzti2.c - Implement __ctzti2 -------------------------------------=== //===-- ctzti2.c - Implement __ctzti2 -------------------------------------===//
* //
* 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 __ctzti2 for the compiler_rt library. // This file implements __ctzti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ctzti2(ti_int a) { COMPILER_RT_ABI si_int __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

lib/builtins/divdc3.c

/* ===-- divdc3.c - Implement __divdc3 -------------------------------------=== //===-- divdc3.c - Implement __divdc3 -------------------------------------===//
* //
* 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 __divdc3 for the compiler_rt library. // This file implements __divdc3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __divdc3(double __a, double __b, double __c, COMPILER_RT_ABI Dcomplex __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);
Show All 27 Lines

lib/builtins/divdi3.c

/* ===-- divdi3.c - Implement __divdi3 -------------------------------------=== //===-- divdi3.c - Implement __divdi3 -------------------------------------===//
* //
* 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 __divdi3 for the compiler_rt library. // This file implements __divdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ // Returns: a / b
COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b) { COMPILER_RT_ABI di_int __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) - return (__udivmoddi4(a, b, (du_int *)0) ^ s_a) - s_a; // negate if s_a == -1
s_a; /* negate if s_a == -1 */
} }

lib/builtins/divmoddi4.c

/*===-- divmoddi4.c - Implement __divmoddi4 --------------------------------=== //===-- divmoddi4.c - Implement __divmoddi4 -------------------------------===//
* //
* 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 __divmoddi4 for the compiler_rt library. // This file implements __divmoddi4 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __divmoddi4(di_int a, di_int b, di_int *rem) { COMPILER_RT_ABI di_int __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;
} }

lib/builtins/divmodsi4.c

/*===-- divmodsi4.c - Implement __divmodsi4 --------------------------------=== //===-- divmodsi4.c - Implement __divmodsi4
* //--------------------------------===//
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. //
* See https://llvm.org/LICENSE.txt for license information. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // See https://llvm.org/LICENSE.txt for license information.
* // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* ===----------------------------------------------------------------------=== //
* //===----------------------------------------------------------------------===//
* This file implements __divmodsi4 for the compiler_rt library. //
* // This file implements __divmodsi4 for the compiler_rt library.
* ===----------------------------------------------------------------------=== //
*/ //===----------------------------------------------------------------------===//
#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 __divmodsi4(si_int a, si_int b, si_int *rem) { COMPILER_RT_ABI si_int __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;
} }

lib/builtins/divsc3.c

/*===-- divsc3.c - Implement __divsc3 -------------------------------------=== //===-- divsc3.c - Implement __divsc3 -------------------------------------===//
* //
* 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 __divsc3 for the compiler_rt library. // This file implements __divsc3 for the compiler_rt library.
* //
*===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __divsc3(float __a, float __b, float __c, float __d) { COMPILER_RT_ABI Fcomplex __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);
Show All 27 Lines

lib/builtins/divsi3.c

/* ===-- divsi3.c - Implement __divsi3 -------------------------------------=== //===-- divsi3.c - Implement __divsi3 -------------------------------------===//
* //
* 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 __divsi3 for the compiler_rt library. // This file implements __divsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ // Returns: a / 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) {
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

lib/builtins/divtc3.c

/*===-- divtc3.c - Implement __divtc3 -------------------------------------=== //===-- divtc3.c - Implement __divtc3 -------------------------------------===//
* //
* 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 __divtc3 for the compiler_rt library. // This file implements __divtc3 for the compiler_rt library.
* //
*===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __divtc3(long double __a, long double __b, COMPILER_RT_ABI Lcomplex __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;
Show All 28 Lines

lib/builtins/divti3.c

/* ===-- divti3.c - Implement __divti3 -------------------------------------=== //===-- divti3.c - Implement __divti3 -------------------------------------===//
* //
* 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 __divti3 for the compiler_rt library. // This file implements __divti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __divti3(ti_int a, ti_int b) { COMPILER_RT_ABI ti_int __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) - return (__udivmodti4(a, b, (tu_int *)0) ^ s_a) - s_a; // negate if s_a == -1
s_a; /* negate if s_a == -1 */
} }
#endif /* CRT_HAS_128BIT */ #endif // CRT_HAS_128BIT

lib/builtins/divxc3.c

/* ===-- divxc3.c - Implement __divxc3 -------------------------------------=== //===-- divxc3.c - Implement __divxc3 -------------------------------------===//
* //
* 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 __divxc3 for the compiler_rt library. // This file implements __divxc3 for the compiler_rt library.
* //
*/ //===----------------------------------------------------------------------===//
#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 __divxc3(long double __a, long double __b, COMPILER_RT_ABI Lcomplex __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);
Show All 29 Lines

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"
#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)
Show All 10 Lines
#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() { pthread_mutex_lock(&emutls_mutex); } static __inline void emutls_lock() { pthread_mutex_lock(&emutls_mutex); }
static __inline void emutls_unlock() { pthread_mutex_unlock(&emutls_mutex); } static __inline void emutls_unlock() { pthread_mutex_unlock(&emutls_mutex); }
#else /* _WIN32 */ #else // _WIN32
#include <assert.h> #include <assert.h>
#include <malloc.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
#include <windows.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;
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Linesstatic __inline emutls_address_array *emutls_getspecific() {
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 *));
Show All 16 Linesvoid *__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"))) void __emutls_unregister_key(void) { __attribute__((visibility("hidden"))) 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

lib/builtins/enable_execute_stack.c

/* ===-- enable_execute_stack.c - Implement __enable_execute_stack ---------=== //===-- enable_execute_stack.c - Implement __enable_execute_stack ---------===//
* //
* 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"
#ifndef _WIN32 #ifndef _WIN32
#include <sys/mman.h> #include <sys/mman.h>
#endif #endif
/* #include "config.h" // #include "config.h"
* FIXME: CMake - include when cmake system is ready. // FIXME: CMake - include when cmake system is ready.
* Remove #define HAVE_SYSCONF 1 line. // Remove #define HAVE_SYSCONF 1 line.
*/
#define HAVE_SYSCONF 1 #define HAVE_SYSCONF 1
#ifdef _WIN32 #ifdef _WIN32
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
#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 __enable_execute_stack(void *addr) { COMPILER_RT_ABI void __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, VirtualProtect(mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE,
&mbi.Protect); &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 *endPage =
(unsigned char *)((p + TRAMPOLINE_SIZE + pageSize) & pageAlignMask); (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
} }

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();
} }

lib/builtins/extenddftf2.c

//===-- lib/extenddftf2.c - double -> quad conversion -------------*- C -*-===// //===-- lib/extenddftf2.c - double -> quad 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_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

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) {
Show All 12 Lines

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) { return __extendXfYf2__(a); } COMPILER_RT_ABI double __extendsfdf2(float 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) { return __extendsfdf2(a); } AEABI_RTABI double __aeabi_f2d(float 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

lib/builtins/extendsftf2.c

//===-- lib/extendsftf2.c - single -> quad conversion -------------*- C -*-===// //===-- lib/extendsftf2.c - single -> quad 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_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

lib/builtins/ffsdi2.c

/* ===-- ffsdi2.c - Implement __ffsdi2 -------------------------------------=== //===-- ffsdi2.c - Implement __ffsdi2 -------------------------------------===//
* //
* 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 __ffsdi2 for the compiler_rt library. // This file implements __ffsdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ffsdi2(di_int a) { COMPILER_RT_ABI si_int __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;
} }

lib/builtins/ffssi2.c

/* ===-- ffssi2.c - Implement __ffssi2 -------------------------------------=== //===-- ffssi2.c - Implement __ffssi2 -------------------------------------===//
* //
* 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 __ffssi2 for the compiler_rt library. // This file implements __ffssi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ffssi2(si_int a) { COMPILER_RT_ABI si_int __ffssi2(si_int a) {
if (a == 0) { if (a == 0) {
return 0; return 0;
} }
return __builtin_ctz(a) + 1; return __builtin_ctz(a) + 1;
} }

lib/builtins/ffsti2.c

/* ===-- ffsti2.c - Implement __ffsti2 -------------------------------------=== //===-- ffsti2.c - Implement __ffsti2 -------------------------------------===//
* //
* 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 __ffsti2 for the compiler_rt library. // This file implements __ffsti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __ffsti2(ti_int a) { COMPILER_RT_ABI si_int __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

lib/builtins/fixdfdi.c

/* ===-- fixdfdi.c - Implement __fixdfdi -----------------------------------=== //===-- fixdfdi.c - Implement __fixdfdi -----------------------------------===//
* //
* 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"
#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 __fixdfdi(double a) { COMPILER_RT_ABI di_int __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 __fixdfdi(fp_t a) { return __fixint(a); } COMPILER_RT_ABI di_int __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) { return __fixdfdi(a); } AEABI_RTABI di_int __aeabi_d2lz(fp_t 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

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 __fixdfsi(fp_t a) { return __fixint(a); } COMPILER_RT_ABI si_int __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) { return __fixdfsi(a); } AEABI_RTABI si_int __aeabi_d2iz(fp_t 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

lib/builtins/fixdfti.c

/* ===-- fixdfti.c - Implement __fixdfti -----------------------------------=== //===-- fixdfti.c - Implement __fixdfti -----------------------------------===//
* //
* 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"
#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 __fixdfti(fp_t a) { return __fixint(a); } COMPILER_RT_ABI ti_int __fixdfti(fp_t a) { return __fixint(a); }
#endif /* CRT_HAS_128BIT */ #endif // CRT_HAS_128BIT

lib/builtins/fixsfdi.c

/* ===-- fixsfdi.c - Implement __fixsfdi -----------------------------------=== //===-- fixsfdi.c - Implement __fixsfdi -----------------------------------===//
* //
* 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"
#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 __fixsfdi(float a) { COMPILER_RT_ABI di_int __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 __fixsfdi(fp_t a) { return __fixint(a); } COMPILER_RT_ABI di_int __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) { return __fixsfdi(a); } AEABI_RTABI di_int __aeabi_f2lz(fp_t 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

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 __fixsfsi(fp_t a) { return __fixint(a); } COMPILER_RT_ABI si_int __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) { return __fixsfsi(a); } AEABI_RTABI si_int __aeabi_f2iz(fp_t 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

lib/builtins/fixsfti.c

/* ===-- fixsfti.c - Implement __fixsfti -----------------------------------=== //===-- fixsfti.c - Implement __fixsfti -----------------------------------===//
* //
* 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"
#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 __fixsfti(fp_t a) { return __fixint(a); } COMPILER_RT_ABI ti_int __fixsfti(fp_t a) { return __fixint(a); }
#endif /* CRT_HAS_128BIT */ #endif // CRT_HAS_128BIT

lib/builtins/fixtfdi.c

/* ===-- fixtfdi.c - Implement __fixtfdi -----------------------------------=== //===-- fixtfdi.c - Implement __fixtfdi -----------------------------------===//
* //
* 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 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 __fixtfdi(fp_t a) { return __fixint(a); } COMPILER_RT_ABI di_int __fixtfdi(fp_t a) { return __fixint(a); }
#endif #endif

lib/builtins/fixtfsi.c

/* ===-- fixtfsi.c - Implement __fixtfsi -----------------------------------=== //===-- fixtfsi.c - Implement __fixtfsi -----------------------------------===//
* //
* 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 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 __fixtfsi(fp_t a) { return __fixint(a); } COMPILER_RT_ABI si_int __fixtfsi(fp_t a) { return __fixint(a); }
#endif #endif

lib/builtins/fixtfti.c

/* ===-- fixtfti.c - Implement __fixtfti -----------------------------------=== //===-- fixtfti.c - Implement __fixtfti -----------------------------------===//
* //
* 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 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 __fixtfti(fp_t a) { return __fixint(a); } COMPILER_RT_ABI ti_int __fixtfti(fp_t a) { return __fixint(a); }
#endif #endif

lib/builtins/fixunsdfdi.c

/* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------=== //===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===//
* //
* 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"
#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) {
if (a <= 0.0) if (a <= 0.0)
return 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 __fixunsdfdi(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI du_int __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) { return __fixunsdfdi(a); } AEABI_RTABI du_int __aeabi_d2ulz(fp_t 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

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 __fixunsdfsi(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI su_int __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) { return __fixunsdfsi(a); } AEABI_RTABI su_int __aeabi_d2uiz(fp_t 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

lib/builtins/fixunsdfti.c

/* ===-- fixunsdfti.c - Implement __fixunsdfti -----------------------------=== //===-- fixunsdfti.c - Implement __fixunsdfti -----------------------------===//
* //
* 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"
#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 __fixunsdfti(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI tu_int __fixunsdfti(fp_t a) { return __fixuint(a); }
#endif /* CRT_HAS_128BIT */ #endif // CRT_HAS_128BIT

lib/builtins/fixunssfdi.c

/* ===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------=== //===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------===//
* //
* 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"
#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) {
if (a <= 0.0f) if (a <= 0.0f)
return 0; 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 __fixunssfdi(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI du_int __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) { return __fixunssfdi(a); } AEABI_RTABI du_int __aeabi_f2ulz(fp_t 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

lib/builtins/fixunssfsi.c

/* ===-- fixunssfsi.c - Implement __fixunssfsi -----------------------------=== //===-- fixunssfsi.c - Implement __fixunssfsi -----------------------------===//
* //
* 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 __fixunssfsi for the compiler_rt library. // This file implements __fixunssfsi for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __fixunssfsi(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI su_int __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) { return __fixunssfsi(a); } AEABI_RTABI su_int __aeabi_f2uiz(fp_t 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

lib/builtins/fixunssfti.c

/* ===-- fixunssfti.c - Implement __fixunssfti -----------------------------=== //===-- fixunssfti.c - Implement __fixunssfti -----------------------------===//
* //
* 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 __fixunssfti for the compiler_rt library. // This file implements __fixunssfti for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __fixunssfti(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI tu_int __fixunssfti(fp_t a) { return __fixuint(a); }
#endif #endif

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 __fixunstfdi(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI du_int __fixunstfdi(fp_t a) { return __fixuint(a); }
#endif #endif

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 __fixunstfsi(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI su_int __fixunstfsi(fp_t a) { return __fixuint(a); }
#endif #endif

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 __fixunstfti(fp_t a) { return __fixuint(a); } COMPILER_RT_ABI tu_int __fixunstfti(fp_t a) { return __fixuint(a); }
#endif #endif

lib/builtins/fixunsxfdi.c

/* ===-- fixunsxfdi.c - Implement __fixunsxfdi -----------------------------=== //===-- fixunsxfdi.c - Implement __fixunsxfdi -----------------------------===//
* //
* 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 __fixunsxfdi for the compiler_rt library. // This file implements __fixunsxfdi for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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
/* Assumption: long double is an intel 80 bit floating point type padded with 6 // bytes du_int is a 64 bit integral type value in long double is representable
* bytes du_int is a 64 bit integral type value in long double is representable // in du_int or is negative (no range checking performed)
* in du_int or is negative (no range checking performed)
*/ // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
// eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // 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 __fixunsxfdi(long double a) { COMPILER_RT_ABI du_int __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

lib/builtins/fixunsxfsi.c

/* ===-- fixunsxfsi.c - Implement __fixunsxfsi -----------------------------=== //===-- fixunsxfsi.c - Implement __fixunsxfsi -----------------------------===//
* //
* 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 __fixunsxfsi for the compiler_rt library. // This file implements __fixunsxfsi for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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
/* Assumption: long double is an intel 80 bit floating point type padded with 6 // bytes su_int is a 32 bit integral type value in long double is representable
* bytes su_int is a 32 bit integral type 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 | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // 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 __fixunsxfsi(long double a) { COMPILER_RT_ABI su_int __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

lib/builtins/fixunsxfti.c

/* ===-- fixunsxfti.c - Implement __fixunsxfti -----------------------------=== //===-- fixunsxfti.c - Implement __fixunsxfti -----------------------------===//
* //
* 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 __fixunsxfti for the compiler_rt library. // This file implements __fixunsxfti for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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
/* Assumption: long double is an intel 80 bit floating point type padded with 6 // bytes tu_int is a 128 bit integral type value in long double is representable
* bytes tu_int is a 128 bit integral type 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 | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // 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 __fixunsxfti(long double a) { COMPILER_RT_ABI tu_int __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

lib/builtins/fixxfdi.c

/* ===-- fixxfdi.c - Implement __fixxfdi -----------------------------------=== //===-- fixxfdi.c - Implement __fixxfdi -----------------------------------===//
* //
* 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 __fixxfdi for the compiler_rt library. // This file implements __fixxfdi for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 // Assumption: long double is an intel 80 bit floating point type padded with 6
* bytes di_int is a 64 bit integral type value in long double is representable // bytes di_int is a 64 bit integral type 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
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // eeee | 1mmm 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
* mmmm mmmm mmmm
*/
COMPILER_RT_ABI di_int __fixxfdi(long double a) { COMPILER_RT_ABI di_int __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

lib/builtins/fixxfti.c

/* ===-- fixxfti.c - Implement __fixxfti -----------------------------------=== //===-- fixxfti.c - Implement __fixxfti -----------------------------------===//
* //
* 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 __fixxfti for the compiler_rt library. // This file implements __fixxfti for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 // Assumption: long double is an intel 80 bit floating point type padded with 6
* bytes ti_int is a 128 bit integral type value in long double is representable // bytes ti_int is a 128 bit integral type 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
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // eeee | 1mmm 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
* mmmm mmmm mmmm
*/
COMPILER_RT_ABI ti_int __fixxfti(long double a) { COMPILER_RT_ABI ti_int __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

lib/builtins/floatdidf.c

/*===-- floatdidf.c - Implement __floatdidf -------------------------------=== //===-- floatdidf.c - Implement __floatdidf -------------------------------===//
* //
* 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 __floatdidf for the compiler_rt library. // This file implements __floatdidf for the compiler_rt library.
* //
*===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 // seee eeee eeee mmmm 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 // Support for systems that have hardware floating-point; we'll set the inexact
* flag as a side-effect of this computation. // flag as a side-effect of this computation.
*/
COMPILER_RT_ABI double __floatdidf(di_int a) { COMPILER_RT_ABI double __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 { union {
int64_t x; int64_t x;
double d; double d;
} low = {.d = twop52}; } 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 // 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.
*/
COMPILER_RT_ABI double __floatdidf(di_int a) { COMPILER_RT_ABI double __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) { return __floatdidf(a); } AEABI_RTABI double __aeabi_l2d(di_int 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

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.*/
/* Assumption: float is a IEEE 32 bit floating point type
* di_int is a 64 bit integral type
*/
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */ // Returns: convert a to a float, rounding toward even.
// Assumption: float is a IEEE 32 bit floating point type
// di_int is a 64 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI float __floatdisf(di_int a) { COMPILER_RT_ABI float __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) { return __floatdisf(a); } AEABI_RTABI float __aeabi_l2f(di_int 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

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 // Assumption: long double is a IEEE 80 bit floating point type padded to 128
* bits 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
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // eeee | 1mmm 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
* mmmm mmmm mmmm
*/
COMPILER_RT_ABI long double __floatdixf(di_int a) { COMPILER_RT_ABI long double __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

lib/builtins/floattidf.c

/* ===-- floattidf.c - Implement __floattidf -------------------------------=== //===-- floattidf.c - Implement __floattidf -------------------------------===//
* //
* 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 __floattidf for the compiler_rt library. // This file implements __floattidf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
#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 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm */ // mmmm
COMPILER_RT_ABI double __floattidf(ti_int a) { COMPILER_RT_ABI double __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

lib/builtins/floattisf.c

/* ===-- floattisf.c - Implement __floattisf -------------------------------=== //===-- floattisf.c - Implement __floattisf -------------------------------===//
* //
* 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 __floattisf for the compiler_rt library. // This file implements __floattisf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __floattisf(ti_int a) { COMPILER_RT_ABI float __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

lib/builtins/floattitf.c

Show All 10 Lines
// mode. // mode.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#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
/* 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 mmmm
*/
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floattitf(ti_int a) { COMPILER_RT_ABI fp_t __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

lib/builtins/floattixf.c

/* ===-- floattixf.c - Implement __floattixf -------------------------------=== //===-- floattixf.c - Implement __floattixf -------------------------------===//
* //
* 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 __floattixf for the compiler_rt library. // This file implements __floattixf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 // Assumption: long double is a IEEE 80 bit floating point type padded to 128
* bits 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
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // eeee | 1mmm 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
* mmmm mmmm mmmm
*/
COMPILER_RT_ABI long double __floattixf(ti_int a) { COMPILER_RT_ABI long double __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

lib/builtins/floatundidf.c

/* ===-- floatundidf.c - Implement __floatundidf ---------------------------=== //===-- floatundidf.c - Implement __floatundidf ---------------------------===//
* //
* 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 __floatundidf for the compiler_rt library. // This file implements __floatundidf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
/* Returns: convert a to a double, rounding toward even. */
/* Assumption: double is a IEEE 64 bit floating point type
* du_int is a 64 bit integral type
*/
/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm // Returns: convert a to a double, rounding toward even.
* mmmm */
// Assumption: double is a IEEE 64 bit floating point 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
#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 // Support for systems that have hardware floating-point; we'll set the inexact
* flag as a side-effect of this computation. // flag as a side-effect of this computation.
*/
COMPILER_RT_ABI double __floatundidf(du_int a) { COMPILER_RT_ABI double __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 = static const double twop84_plus_twop52 =
19342813118337666422669312.0; // 0x1.00000001p84 19342813118337666422669312.0; // 0x1.00000001p84
union { union {
uint64_t x; uint64_t x;
double d; double d;
} high = {.d = twop84}; } high = {.d = twop84};
union { union {
uint64_t x; uint64_t x;
double d; double d;
} low = {.d = twop52}; } 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 // 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.
*/
COMPILER_RT_ABI double __floatundidf(du_int a) { COMPILER_RT_ABI double __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) { return __floatundidf(a); } AEABI_RTABI double __aeabi_ul2d(du_int 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

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. */
/* Assumption: float is a IEEE 32 bit floating point type
* du_int is a 64 bit integral type
*/
/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */ // Returns: convert a to a float, rounding toward even.
// Assumption: float is a IEEE 32 bit floating point type
// du_int is a 64 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI float __floatundisf(du_int a) { COMPILER_RT_ABI float __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) { return __floatundisf(a); } AEABI_RTABI float __aeabi_ul2f(du_int 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

lib/builtins/floatundixf.c

/* ===-- floatundixf.c - Implement __floatundixf ---------------------------=== //===-- floatundixf.c - Implement __floatundixf ---------------------------===//
* //
* 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 __floatundixf for the compiler_rt library. // This file implements __floatundixf 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 // Assumption: long double is a IEEE 80 bit floating point type padded to 128
* bits 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
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // eeee | 1mmm 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
* mmmm mmmm mmmm
*/
COMPILER_RT_ABI long double __floatundixf(du_int a) { COMPILER_RT_ABI long double __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

lib/builtins/floatuntidf.c

/* ===-- floatuntidf.c - Implement __floatuntidf ---------------------------=== //===-- floatuntidf.c - Implement __floatuntidf ---------------------------===//
* //
* 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 __floatuntidf for the compiler_rt library. // This file implements __floatuntidf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
#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 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
* mmmm */ // mmmm
COMPILER_RT_ABI double __floatuntidf(tu_int a) { COMPILER_RT_ABI double __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

lib/builtins/floatuntisf.c

/* ===-- floatuntisf.c - Implement __floatuntisf ---------------------------=== //===-- floatuntisf.c - Implement __floatuntisf ---------------------------===//
* //
* 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 __floatuntisf for the compiler_rt library. // This file implements __floatuntisf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __floatuntisf(tu_int a) { COMPILER_RT_ABI float __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

lib/builtins/floatuntitf.c

Show All 10 Lines
// mode. // mode.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#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
/* 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 mmmm
*/
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatuntitf(tu_int a) { COMPILER_RT_ABI fp_t __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

lib/builtins/floatuntixf.c

/* ===-- floatuntixf.c - Implement __floatuntixf ---------------------------=== //===-- floatuntixf.c - Implement __floatuntixf ---------------------------===//
* //
* 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 __floatuntixf for the compiler_rt library. // This file implements __floatuntixf for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 // Assumption: long double is a IEEE 80 bit floating point type padded to 128
* bits 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
/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee // eeee | 1mmm 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
* mmmm mmmm mmmm
*/
COMPILER_RT_ABI long double __floatuntixf(tu_int a) { COMPILER_RT_ABI long double __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

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__) && \ #if defined(__arm__) && !defined(__ARM_DWARF_EH__) && \
!defined(__USING_SJLJ_EXCEPTIONS__) !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;
Show All 18 Lines case DW_EH_PE_sdata4:
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 __gcc_personality_sj0( COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_sj0(
int version, _Unwind_Action actions, uint64_t exceptionClass, int version, _Unwind_Action actions, uint64_t exceptionClass,
struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context) struct _Unwind_Exception *exceptionObject, 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 __gcc_personality_v0( COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
int version, _Unwind_Action actions, uint64_t exceptionClass, int version, _Unwind_Action actions, uint64_t exceptionClass,
struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context) struct _Unwind_Exception *exceptionObject, 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);
} }

lib/builtins/hexagon/common_entry_exit_abi1.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/* Functions that implement common sequences in function prologues and epilogues // Functions that implement common sequences in function prologues and epilogues
used to save code size */ // used to save code size
.macro FUNCTION_BEGIN name .macro FUNCTION_BEGIN name
.text .text
.globl \name .globl \name
.type \name, @function .type \name, @function
.falign .falign
\name: \name:
.endm .endm
.macro FUNCTION_END name .macro FUNCTION_END name
.size \name, . - \name .size \name, . - \name
.endm .endm
.macro FALLTHROUGH_TAIL_CALL name0 name1 .macro FALLTHROUGH_TAIL_CALL name0 name1
.size \name0, . - \name0 .size \name0, . - \name0
.globl \name1 .globl \name1
.type \name1, @function .type \name1, @function
.falign .falign
\name1: \name1:
.endm .endm
/* Save r25:24 at fp+#-8 and r27:26 at fp+#-16. */ // Save r25:24 at fp+#-8 and r27:26 at fp+#-16.
/* The compiler knows that the __save_* functions clobber LR. No other // The compiler knows that the __save_* functions clobber LR. No other
registers should be used without informing the compiler. */ // registers should be used without informing the compiler.
/* Since we can only issue one store per packet, we don't hurt performance by // Since we can only issue one store per packet, we don't hurt performance by
simply jumping to the right point in this sequence of stores. */ // simply jumping to the right point in this sequence of stores.
FUNCTION_BEGIN __save_r24_through_r27 FUNCTION_BEGIN __save_r24_through_r27
memd(fp+#-16) = r27:26 memd(fp+#-16) = r27:26
FALLTHROUGH_TAIL_CALL __save_r24_through_r27 __save_r24_through_r25 FALLTHROUGH_TAIL_CALL __save_r24_through_r27 __save_r24_through_r25
{ {
memd(fp+#-8) = r25:24 memd(fp+#-8) = r25:24
jumpr lr jumpr lr
} }
FUNCTION_END __save_r24_through_r25 FUNCTION_END __save_r24_through_r25
/* For each of the *_before_tailcall functions, jumpr lr is executed in parallel // For each of the *_before_tailcall functions, jumpr lr is executed in parallel
with deallocframe. That way, the return gets the old value of lr, which is // with deallocframe. That way, the return gets the old value of lr, which is
where these functions need to return, and at the same time, lr gets the value // where these functions need to return, and at the same time, lr gets the value
it needs going into the tail call. */ // it needs going into the tail call.
FUNCTION_BEGIN __restore_r24_through_r27_and_deallocframe_before_tailcall FUNCTION_BEGIN __restore_r24_through_r27_and_deallocframe_before_tailcall
r27:26 = memd(fp+#-16) r27:26 = memd(fp+#-16)
FALLTHROUGH_TAIL_CALL __restore_r24_through_r27_and_deallocframe_before_tailcall __restore_r24_through_r25_and_deallocframe_before_tailcall FALLTHROUGH_TAIL_CALL __restore_r24_through_r27_and_deallocframe_before_tailcall __restore_r24_through_r25_and_deallocframe_before_tailcall
{ {
r25:24 = memd(fp+#-8) r25:24 = memd(fp+#-8)
deallocframe deallocframe
jumpr lr jumpr lr
} }
FUNCTION_END __restore_r24_through_r25_and_deallocframe_before_tailcall FUNCTION_END __restore_r24_through_r25_and_deallocframe_before_tailcall
/* Here we use the extra load bandwidth to restore LR early, allowing the return // Here we use the extra load bandwidth to restore LR early, allowing the return
to occur in parallel with the deallocframe. */ // to occur in parallel with the deallocframe.
FUNCTION_BEGIN __restore_r24_through_r27_and_deallocframe FUNCTION_BEGIN __restore_r24_through_r27_and_deallocframe
{ {
lr = memw(fp+#4) lr = memw(fp+#4)
r27:26 = memd(fp+#-16) r27:26 = memd(fp+#-16)
} }
{ {
r25:24 = memd(fp+#-8) r25:24 = memd(fp+#-8)
deallocframe deallocframe
jumpr lr jumpr lr
} }
FUNCTION_END __restore_r24_through_r27_and_deallocframe FUNCTION_END __restore_r24_through_r27_and_deallocframe
/* Here the load bandwidth is maximized. */ // Here the load bandwidth is maximized.
FUNCTION_BEGIN __restore_r24_through_r25_and_deallocframe FUNCTION_BEGIN __restore_r24_through_r25_and_deallocframe
{ {
r25:24 = memd(fp+#-8) r25:24 = memd(fp+#-8)
deallocframe deallocframe
} }
jumpr lr jumpr lr
FUNCTION_END __restore_r24_through_r25_and_deallocframe FUNCTION_END __restore_r24_through_r25_and_deallocframe

lib/builtins/hexagon/common_entry_exit_abi2.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/* Functions that implement common sequences in function prologues and epilogues // Functions that implement common sequences in function prologues and epilogues
used to save code size */ // used to save code size
.macro FUNCTION_BEGIN name .macro FUNCTION_BEGIN name
.p2align 2 .p2align 2
.section .text.\name,"ax",@progbits .section .text.\name,"ax",@progbits
.globl \name .globl \name
.type \name, @function .type \name, @function
\name: \name:
.endm .endm
.macro FUNCTION_END name .macro FUNCTION_END name
.size \name, . - \name .size \name, . - \name
.endm .endm
.macro FALLTHROUGH_TAIL_CALL name0 name1 .macro FALLTHROUGH_TAIL_CALL name0 name1
.p2align 2 .p2align 2
.size \name0, . - \name0 .size \name0, . - \name0
.globl \name1 .globl \name1
.type \name1, @function .type \name1, @function
\name1: \name1:
.endm .endm
/* Save r17:16 at fp+#-8, r19:18 at fp+#-16, r21:20 at fp+#-24, r23:22 at // Save r17:16 at fp+#-8, r19:18 at fp+#-16, r21:20 at fp+#-24, r23:22 at
fp+#-32, r25:24 at fp+#-40, and r27:26 at fp+#-48. // fp+#-32, r25:24 at fp+#-40, and r27:26 at fp+#-48.
The compiler knows that the __save_* functions clobber LR. No other // The compiler knows that the __save_* functions clobber LR. No other
registers should be used without informing the compiler. */ // registers should be used without informing the compiler.
FUNCTION_BEGIN __save_r16_through_r27 FUNCTION_BEGIN __save_r16_through_r27
{ {
memd(fp+#-48) = r27:26 memd(fp+#-48) = r27:26
memd(fp+#-40) = r25:24 memd(fp+#-40) = r25:24
} }
{ {
memd(fp+#-32) = r23:22 memd(fp+#-32) = r23:22
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
FUNCTION_BEGIN __save_r16_through_r17 FUNCTION_BEGIN __save_r16_through_r17
{ {
memd(fp+#-8) = r17:16 memd(fp+#-8) = r17:16
jumpr lr jumpr lr
} }
FUNCTION_END __save_r16_through_r17 FUNCTION_END __save_r16_through_r17
/* For each of the *_before_tailcall functions, jumpr lr is executed in parallel // For each of the *_before_tailcall functions, jumpr lr is executed in parallel
with deallocframe. That way, the return gets the old value of lr, which is // with deallocframe. That way, the return gets the old value of lr, which is
where these functions need to return, and at the same time, lr gets the value // where these functions need to return, and at the same time, lr gets the value
it needs going into the tail call. */ // it needs going into the tail call.
FUNCTION_BEGIN __restore_r16_through_r27_and_deallocframe_before_tailcall FUNCTION_BEGIN __restore_r16_through_r27_and_deallocframe_before_tailcall
r27:26 = memd(fp+#-48) r27:26 = memd(fp+#-48)
{ {
r25:24 = memd(fp+#-40) r25:24 = memd(fp+#-40)
r23:22 = memd(fp+#-32) r23:22 = memd(fp+#-32)
} }
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

lib/builtins/hexagon/common_entry_exit_legacy.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/* Functions that implement common sequences in function prologues and epilogues // Functions that implement common sequences in function prologues and epilogues
used to save code size */ // used to save code size
.macro FUNCTION_BEGIN name .macro FUNCTION_BEGIN name
.text .text
.globl \name .globl \name
.type \name, @function .type \name, @function
.falign .falign
\name: \name:
.endm .endm
.macro FUNCTION_END name .macro FUNCTION_END name
.size \name, . - \name .size \name, . - \name
.endm .endm
.macro FALLTHROUGH_TAIL_CALL name0 name1 .macro FALLTHROUGH_TAIL_CALL name0 name1
.size \name0, . - \name0 .size \name0, . - \name0
.globl \name1 .globl \name1
.type \name1, @function .type \name1, @function
.falign .falign
\name1: \name1:
.endm .endm
/* Save r27:26 at fp+#-8, r25:24 at fp+#-16, r23:22 at fp+#-24, r21:20 at // Save r27:26 at fp+#-8, r25:24 at fp+#-16, r23:22 at fp+#-24, r21:20 at
fp+#-32, r19:18 at fp+#-40, and r17:16 at fp+#-48. */ // fp+#-32, r19:18 at fp+#-40, and r17:16 at fp+#-48.
/* The compiler knows that the __save_* functions clobber LR. No other // The compiler knows that the __save_* functions clobber LR. No other
registers should be used without informing the compiler. */ // registers should be used without informing the compiler.
/* Since we can only issue one store per packet, we don't hurt performance by // Since we can only issue one store per packet, we don't hurt performance by
simply jumping to the right point in this sequence of stores. */ // simply jumping to the right point in this sequence of stores.
FUNCTION_BEGIN __save_r27_through_r16 FUNCTION_BEGIN __save_r27_through_r16
memd(fp+#-48) = r17:16 memd(fp+#-48) = r17:16
FALLTHROUGH_TAIL_CALL __save_r27_through_r16 __save_r27_through_r18 FALLTHROUGH_TAIL_CALL __save_r27_through_r16 __save_r27_through_r18
memd(fp+#-40) = r19:18 memd(fp+#-40) = r19:18
FALLTHROUGH_TAIL_CALL __save_r27_through_r18 __save_r27_through_r20 FALLTHROUGH_TAIL_CALL __save_r27_through_r18 __save_r27_through_r20
memd(fp+#-32) = r21:20 memd(fp+#-32) = r21:20
FALLTHROUGH_TAIL_CALL __save_r27_through_r20 __save_r27_through_r22 FALLTHROUGH_TAIL_CALL __save_r27_through_r20 __save_r27_through_r22
memd(fp+#-24) = r23:22 memd(fp+#-24) = r23:22
FALLTHROUGH_TAIL_CALL __save_r27_through_r22 __save_r27_through_r24 FALLTHROUGH_TAIL_CALL __save_r27_through_r22 __save_r27_through_r24
memd(fp+#-16) = r25:24 memd(fp+#-16) = r25:24
{ {
memd(fp+#-8) = r27:26 memd(fp+#-8) = r27:26
jumpr lr jumpr lr
} }
FUNCTION_END __save_r27_through_r24 FUNCTION_END __save_r27_through_r24
/* For each of the *_before_sibcall functions, jumpr lr is executed in parallel // For each of the *_before_sibcall functions, jumpr lr is executed in parallel
with deallocframe. That way, the return gets the old value of lr, which is // with deallocframe. That way, the return gets the old value of lr, which is
where these functions need to return, and at the same time, lr gets the value // where these functions need to return, and at the same time, lr gets the value
it needs going into the sibcall. */ // it needs going into the sibcall.
FUNCTION_BEGIN __restore_r27_through_r20_and_deallocframe_before_sibcall FUNCTION_BEGIN __restore_r27_through_r20_and_deallocframe_before_sibcall
{ {
r21:20 = memd(fp+#-32) r21:20 = memd(fp+#-32)
r23:22 = memd(fp+#-24) r23:22 = memd(fp+#-24)
} }
FALLTHROUGH_TAIL_CALL __restore_r27_through_r20_and_deallocframe_before_sibcall __restore_r27_through_r24_and_deallocframe_before_sibcall FALLTHROUGH_TAIL_CALL __restore_r27_through_r20_and_deallocframe_before_sibcall __restore_r27_through_r24_and_deallocframe_before_sibcall
{ {
Show All 23 LinesFALLTHROUGH_TAIL_CALL __restore_r27_through_r22_and_deallocframe_before_sibcall __restore_r27_through_r26_and_deallocframe_before_sibcall
deallocframe deallocframe
jumpr lr jumpr lr
} }
FUNCTION_END __restore_r27_through_r26_and_deallocframe_before_sibcall FUNCTION_END __restore_r27_through_r26_and_deallocframe_before_sibcall
/* Here we use the extra load bandwidth to restore LR early, allowing the return // Here we use the extra load bandwidth to restore LR early, allowing the return
to occur in parallel with the deallocframe. */ // to occur in parallel with the deallocframe.
FUNCTION_BEGIN __restore_r27_through_r16_and_deallocframe FUNCTION_BEGIN __restore_r27_through_r16_and_deallocframe
{ {
r17:16 = memd(fp+#-48) r17:16 = memd(fp+#-48)
r19:18 = memd(fp+#-40) r19:18 = memd(fp+#-40)
} }
FALLTHROUGH_TAIL_CALL __restore_r27_through_r16_and_deallocframe __restore_r27_through_r20_and_deallocframe FALLTHROUGH_TAIL_CALL __restore_r27_through_r16_and_deallocframe __restore_r27_through_r20_and_deallocframe
{ {
Show All 10 LinesFALLTHROUGH_TAIL_CALL __restore_r27_through_r20_and_deallocframe __restore_r27_through_r24_and_deallocframe
deallocframe deallocframe
jumpr lr jumpr lr
} }
FUNCTION_END __restore_r27_through_r24_and_deallocframe FUNCTION_END __restore_r27_through_r24_and_deallocframe
/* Here the load bandwidth is maximized for all three functions. */ // Here the load bandwidth is maximized for all three functions.
FUNCTION_BEGIN __restore_r27_through_r18_and_deallocframe FUNCTION_BEGIN __restore_r27_through_r18_and_deallocframe
{ {
r19:18 = memd(fp+#-40) r19:18 = memd(fp+#-40)
r21:20 = memd(fp+#-32) r21:20 = memd(fp+#-32)
} }
FALLTHROUGH_TAIL_CALL __restore_r27_through_r18_and_deallocframe __restore_r27_through_r22_and_deallocframe FALLTHROUGH_TAIL_CALL __restore_r27_through_r18_and_deallocframe __restore_r27_through_r22_and_deallocframe
{ {
Show All 10 Lines

lib/builtins/hexagon/dfaddsub.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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 Precision Multiply */ // Double Precision Multiply
#define A r1:0 #define A r1:0
#define AH r1 #define AH r1
#define AL r0 #define AL r0
#define B r3:2 #define B r3:2
#define BH r3 #define BH r3
#define BL r2 #define BL r2
▲ Show 20 Lines • Show All 155 Lines • ▼ Show 20 Lines // +0 unless round towards negative infinity
p0 = cmp.eq(TMP,#2) p0 = cmp.eq(TMP,#2)
if (p0.new) AH = xor(AH,BH) if (p0.new) AH = xor(AH,BH)
jumpr r31 jumpr r31
} }
.falign .falign
.Ladd_ovf_unf: .Ladd_ovf_unf:
// Overflow or Denormal is possible // Overflow or Denormal is possible
// Good news: Underflow flag is not possible! // Good news: Underflow flag is not possible!
/*
* ATMP has 2's complement value // ATMP has 2's complement value
* //
* EXPA has A's exponent, EXPB has EXPA-BIAS-60 // EXPA has A's exponent, EXPB has EXPA-BIAS-60
* //
* Convert, extract exponent, add adjustment. // Convert, extract exponent, add adjustment.
* If > 2046, overflow // If > 2046, overflow
* If <= 0, denormal // If <= 0, denormal
* //
* Note that we've not done our zero check yet, so do that too // Note that we've not done our zero check yet, so do that too
*
*/
{ {
A = convert_d2df(ATMP) A = convert_d2df(ATMP)
p0 = cmp.eq(ATMPH,#0) p0 = cmp.eq(ATMPH,#0)
p0 = cmp.eq(ATMPL,#0) p0 = cmp.eq(ATMPL,#0)
if (p0.new) jump:nt .Ladd_zero if (p0.new) jump:nt .Ladd_zero
} }
{ {
TMP = extractu(AH,#EXPBITS,#HI_MANTBITS) TMP = extractu(AH,#EXPBITS,#HI_MANTBITS)
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

lib/builtins/hexagon/dfdiv.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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 Precision Divide */ // Double Precision Divide
#define A r1:0 #define A r1:0
#define AH r1 #define AH r1
#define AL r0 #define AL r0
#define B r3:2 #define B r3:2
#define BH r3 #define BH r3
#define BL r2 #define BL r2
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines.Ldiv_ovf_unf:
{ {
P_TMP = cmp.gt(EXPA,##DF_BIAS+DF_BIAS) // overflow P_TMP = cmp.gt(EXPA,##DF_BIAS+DF_BIAS) // overflow
if (P_TMP.new) jump:nt .Ldiv_ovf if (P_TMP.new) jump:nt .Ldiv_ovf
} }
{ {
P_TMP = cmp.gt(EXPA,#0) P_TMP = cmp.gt(EXPA,#0)
if (P_TMP.new) jump:nt .Lpossible_unf // round up to normal possible... if (P_TMP.new) jump:nt .Lpossible_unf // round up to normal possible...
} }
/* Underflow */ // Underflow
/* We know what the infinite range exponent should be (EXPA) */ // We know what the infinite range exponent should be (EXPA)
/* Q is 2's complement, PROD is abs(Q) */ // Q is 2's complement, PROD is abs(Q)
/* Normalize Q, shift right, add a high bit, convert, change exponent */ // Normalize Q, shift right, add a high bit, convert, change exponent
#define FUDGE1 7 // how much to shift right #define FUDGE1 7 // how much to shift right
#define FUDGE2 4 // how many guard/round to keep at lsbs #define FUDGE2 4 // how many guard/round to keep at lsbs
{ {
EXPB = add(clb(PROD),#-1) // doesn't need to be added in since EXPB = add(clb(PROD),#-1) // doesn't need to be added in since
EXPA = sub(#FUDGE1,EXPA) // we extract post-converted exponent EXPA = sub(#FUDGE1,EXPA) // we extract post-converted exponent
TMP = USR TMP = USR
Show All 30 Lines#define FUDGE2 4 // how many guard/round to keep at lsbs
} }
{ {
AH += asl(TMP,#DF_MANTBITS-32) AH += asl(TMP,#DF_MANTBITS-32)
jumpr r31 jumpr r31
} }
.Lpossible_unf: .Lpossible_unf:
/* If upper parts of Q were all F's, but abs(A) == 0x00100000_00000000, we rounded up to min_normal */ // If upper parts of Q were all F's, but abs(A) == 0x00100000_00000000, we rounded up to min_normal
/* The answer is correct, but we need to raise Underflow */ // The answer is correct, but we need to raise Underflow
{ {
B = extractu(A,#63,#0) B = extractu(A,#63,#0)
TMPPAIR = combine(##0x00100000,#0) // min normal TMPPAIR = combine(##0x00100000,#0) // min normal
TMP = #0x7FFF TMP = #0x7FFF
} }
{ {
P_TMP = dfcmp.eq(TMPPAIR,B) // Is everything zero in the rounded value... P_TMP = dfcmp.eq(TMPPAIR,B) // Is everything zero in the rounded value...
P_TMP = bitsset(PRODHI,TMP) // but a bunch of bits set in the unrounded abs(quotient)? P_TMP = bitsset(PRODHI,TMP) // but a bunch of bits set in the unrounded abs(quotient)?
Show All 16 Lines#endif
USR = TMP USR = TMP
} }
{ {
p0 = dfcmp.eq(A,A) p0 = dfcmp.eq(A,A)
jumpr r31 jumpr r31
} }
.Ldiv_ovf: .Ldiv_ovf:
/*
* Raise Overflow, and choose the correct overflow value (saturated normal or infinity) // Raise Overflow, and choose the correct overflow value (saturated normal or infinity)
*/
{ {
TMP = USR TMP = USR
B = combine(##0x7fefffff,#-1) B = combine(##0x7fefffff,#-1)
AH = mux(Q_POSITIVE,#0,#-1) AH = mux(Q_POSITIVE,#0,#-1)
} }
{ {
PROD = combine(##0x7ff00000,#0) PROD = combine(##0x7ff00000,#0)
QH = extractu(TMP,#2,#SR_ROUND_OFF) QH = extractu(TMP,#2,#SR_ROUND_OFF)
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines.Ldiv_abnormal:
{ {
P_INF = dfclass(A,#DFCLASS_NONINFINITE) // non-infinite P_INF = dfclass(A,#DFCLASS_NONINFINITE) // non-infinite
P_INF = dfclass(B,#DFCLASS_NONZERO) // nonzero P_INF = dfclass(B,#DFCLASS_NONZERO) // nonzero
} }
{ {
if (!P_ZERO) jump .Ldiv_zero_result if (!P_ZERO) jump .Ldiv_zero_result
if (!P_INF) jump .Ldiv_inf_result if (!P_INF) jump .Ldiv_inf_result
} }
/* Now we've narrowed it down to (de)normal / (de)normal */ // Now we've narrowed it down to (de)normal / (de)normal
/* Set up A/EXPA B/EXPB and go back */ // Set up A/EXPA B/EXPB and go back
#undef P_ZERO #undef P_ZERO
#undef P_INF #undef P_INF
#define P_TMP2 p1 #define P_TMP2 p1
{ {
P_TMP = dfclass(A,#DFCLASS_NORMAL) P_TMP = dfclass(A,#DFCLASS_NORMAL)
P_TMP2 = dfclass(B,#DFCLASS_NORMAL) P_TMP2 = dfclass(B,#DFCLASS_NORMAL)
TMP = ##0x00100000 TMP = ##0x00100000
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lib/builtins/hexagon/dffma.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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 Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG #define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG
#define END(TAG) .size TAG,.-TAG #define END(TAG) .size TAG,.-TAG
/* Double Precision Multiply */ // Double Precision Multiply
#define A r1:0 #define A r1:0
#define AH r1 #define AH r1
#define AL r0 #define AL r0
#define B r3:2 #define B r3:2
#define BH r3 #define BH r3
#define BL r2 #define BL r2
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
#define FUDGE 7 #define FUDGE 7
#define FUDGE2 3 #define FUDGE2 3
#ifndef SR_ROUND_OFF #ifndef SR_ROUND_OFF
#define SR_ROUND_OFF 22 #define SR_ROUND_OFF 22
#endif #endif
/* // First, classify for normal values, and abort if abnormal
* First, classify for normal values, and abort if abnormal //
* // Next, unpack mantissa into 0x1000_0000_0000_0000 + mant<<8
* Next, unpack mantissa into 0x1000_0000_0000_0000 + mant<<8 //
* // Since we know that the 2 MSBs of the H registers is zero, we should never carry
* Since we know that the 2 MSBs of the H registers is zero, we should never carry // the partial products that involve the H registers
* the partial products that involve the H registers //
* // Try to buy X slots, at the expense of latency if needed
* Try to buy X slots, at the expense of latency if needed //
* // We will have PP_HH with the upper bits of the product, PP_LL with the lower
* We will have PP_HH with the upper bits of the product, PP_LL with the lower // PP_HH can have a maximum of 0x03FF_FFFF_FFFF_FFFF or thereabouts
* PP_HH can have a maximum of 0x03FF_FFFF_FFFF_FFFF or thereabouts // PP_HH can have a minimum of 0x0100_0000_0000_0000
* PP_HH can have a minimum of 0x0100_0000_0000_0000 //
* // 0x0100_0000_0000_0000 has EXP of EXPA+EXPB-BIAS
* 0x0100_0000_0000_0000 has EXP of EXPA+EXPB-BIAS //
* // We need to align CTMP.
* We need to align CTMP. // If CTMP >> PP, convert PP to 64 bit with sticky, align CTMP, and follow normal add
* If CTMP >> PP, convert PP to 64 bit with sticky, align CTMP, and follow normal add // If CTMP << PP align CTMP and add 128 bits. Then compute sticky
* If CTMP << PP align CTMP and add 128 bits. Then compute sticky // If CTMP ~= PP, align CTMP and add 128 bits. May have massive cancellation.
* If CTMP ~= PP, align CTMP and add 128 bits. May have massive cancellation. //
* // Convert partial product and CTMP to 2's complement prior to addition
* Convert partial product and CTMP to 2's complement prior to addition //
* // After we add, we need to normalize into upper 64 bits, then compute sticky.
* After we add, we need to normalize into upper 64 bits, then compute sticky.
*
*
*/
.text .text
.global __hexagon_fmadf4 .global __hexagon_fmadf4
.type __hexagon_fmadf4,@function .type __hexagon_fmadf4,@function
.global __hexagon_fmadf5 .global __hexagon_fmadf5
.type __hexagon_fmadf5,@function .type __hexagon_fmadf5,@function
.global fma .global fma
.type fma,@function .type fma,@function
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines#define LEFTSHIFT r12
EXPA = add(EXPA,EXPB) EXPA = add(EXPA,EXPB)
#undef EXPB #undef EXPB
#undef EXPBA #undef EXPBA
#define EXPC r19 #define EXPC r19
#define EXPCA r19:18 #define EXPCA r19:18
EXPC = extractu(CH,#EXPBITS,#HI_MANTBITS) EXPC = extractu(CH,#EXPBITS,#HI_MANTBITS)
} }
/* PP_HH:PP_LL now has product */ // PP_HH:PP_LL now has product
/* CTMP is negated */ // CTMP is negated
/* EXPA,B,C are extracted */ // EXPA,B,C are extracted
/* // We need to negate PP
* We need to negate PP // Since we will be adding with carry later, if we need to negate,
* Since we will be adding with carry later, if we need to negate, // just invert all bits now, which we can do conditionally and in parallel
* just invert all bits now, which we can do conditionally and in parallel
*/
#define PP_HH_TMP r15:14 #define PP_HH_TMP r15:14
#define PP_LL_TMP r7:6 #define PP_LL_TMP r7:6
{ {
EXPA = add(EXPA,#-BIAS+(ADJUST)) EXPA = add(EXPA,#-BIAS+(ADJUST))
PROD_NEG = !cmp.gt(TMP,#-1) PROD_NEG = !cmp.gt(TMP,#-1)
PP_LL_TMP = #0 PP_LL_TMP = #0
PP_HH_TMP = #0 PP_HH_TMP = #0
} }
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines#define S_ONE r14
} }
{ {
PP_LL = add(CTMP2,PP_LL,P_CARRY):carry // use the carry to add the sticky PP_LL = add(CTMP2,PP_LL,P_CARRY):carry // use the carry to add the sticky
} }
{ {
PP_HH = add(CTMP,PP_HH,P_CARRY):carry PP_HH = add(CTMP,PP_HH,P_CARRY):carry
TMP = #62 TMP = #62
} }
/* // PP_HH:PP_LL now holds the sum
* PP_HH:PP_LL now holds the sum // We may need to normalize left, up to ??? bits.
* We may need to normalize left, up to ??? bits. //
* // I think that if we have massive cancellation, the range we normalize by
* I think that if we have massive cancellation, the range we normalize by // is still limited
* is still limited
*/
{ {
LEFTSHIFT = add(clb(PP_HH),#-2) LEFTSHIFT = add(clb(PP_HH),#-2)
if (!cmp.eq(LEFTSHIFT.new,TMP)) jump:t 1f // all sign bits? if (!cmp.eq(LEFTSHIFT.new,TMP)) jump:t 1f // all sign bits?
} }
/* We had all sign bits, shift left by 62. */ // We had all sign bits, shift left by 62.
{ {
CTMP = extractu(PP_LL,#62,#2) CTMP = extractu(PP_LL,#62,#2)
PP_LL = asl(PP_LL,#62) PP_LL = asl(PP_LL,#62)
EXPA = add(EXPA,#-62) // And adjust exponent of result EXPA = add(EXPA,#-62) // And adjust exponent of result
} }
{ {
PP_HH = insert(CTMP,#62,#0) // Then shift 63 PP_HH = insert(CTMP,#62,#0) // Then shift 63
} }
Show All 28 Lines1:
PP_HH = memd(r29+#0) PP_HH = memd(r29+#0)
} }
{ {
AH += asl(EXPA,#HI_MANTBITS) AH += asl(EXPA,#HI_MANTBITS)
EXPCA = memd(r29+#8) EXPCA = memd(r29+#8)
if (!P_TMP) dealloc_return // not zero, return if (!P_TMP) dealloc_return // not zero, return
} }
.Ladd_yields_zero: .Ladd_yields_zero:
/* We had full cancellation. Return +/- zero (-0 when round-down) */ // We had full cancellation. Return +/- zero (-0 when round-down)
{ {
TMP = USR TMP = USR
A = #0 A = #0
} }
{ {
TMP = extractu(TMP,#2,#SR_ROUND_OFF) TMP = extractu(TMP,#2,#SR_ROUND_OFF)
PP_HH = memd(r29+#0) PP_HH = memd(r29+#0)
EXPCA = memd(r29+#8) EXPCA = memd(r29+#8)
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines#undef NEW_EXPA
{ {
// TMP has original EXPA. // TMP has original EXPA.
// ATMP is corresponding value // ATMP is corresponding value
// Normalize ATMP and shift right to correct location // Normalize ATMP and shift right to correct location
EXPB = add(clb(ATMP),#-2) // Amount to left shift to normalize EXPB = add(clb(ATMP),#-2) // Amount to left shift to normalize
EXPA = sub(#1+5,TMP) // Amount to right shift to denormalize EXPA = sub(#1+5,TMP) // Amount to right shift to denormalize
p3 = cmp.gt(CTMPH,#-1) p3 = cmp.gt(CTMPH,#-1)
} }
/* Underflow */ // Underflow
/* We know that the infinte range exponent should be EXPA */ // We know that the infinte range exponent should be EXPA
/* CTMP is 2's complement, ATMP is abs(CTMP) */ // CTMP is 2's complement, ATMP is abs(CTMP)
{ {
EXPA = add(EXPA,EXPB) // how much to shift back right EXPA = add(EXPA,EXPB) // how much to shift back right
ATMP = asl(ATMP,EXPB) // shift left ATMP = asl(ATMP,EXPB) // shift left
AH = USR AH = USR
TMP = #63 TMP = #63
} }
{ {
EXPB = min(EXPA,TMP) EXPB = min(EXPA,TMP)
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines.Lab_inf:
{ {
A ^= asl(B,#63) A ^= asl(B,#63)
if (p0) jump .Lnan if (p0) jump .Lnan
} }
{ {
p1 = dfclass(C,#0x08) p1 = dfclass(C,#0x08)
if (p1.new) jump:nt .Lfma_inf_plus_inf if (p1.new) jump:nt .Lfma_inf_plus_inf
} }
/* A*B is +/- inf, C is finite. Return A */ // A*B is +/- inf, C is finite. Return A
{ {
jumpr r31 jumpr r31
} }
.falign .falign
.Lfma_inf_plus_inf: .Lfma_inf_plus_inf:
{ // adding infinities of different signs is invalid { // adding infinities of different signs is invalid
p0 = dfcmp.eq(A,C) p0 = dfcmp.eq(A,C)
if (!p0.new) jump:nt .Linvalid if (!p0.new) jump:nt .Linvalid
Show All 39 Lines // B is zero, A is finite number
p0 = dfcmp.eq(B,C) // is C also zero? p0 = dfcmp.eq(B,C) // is C also zero?
AH = lsr(AH,#31) // get sign AH = lsr(AH,#31) // get sign
} }
{ {
BH ^= asl(AH,#31) // form correctly signed zero in B BH ^= asl(AH,#31) // form correctly signed zero in B
if (!p0) A = C // If C is not zero, return C if (!p0) A = C // If C is not zero, return C
if (!p0) jumpr r31 if (!p0) jumpr r31
} }
/* B has correctly signed zero, C is also zero */ // B has correctly signed zero, C is also zero
.Lzero_plus_zero: .Lzero_plus_zero:
{ {
p0 = cmp.eq(B,C) // yes, scalar equals. +0++0 or -0+-0 p0 = cmp.eq(B,C) // yes, scalar equals. +0++0 or -0+-0
if (p0.new) jumpr:t r31 if (p0.new) jumpr:t r31
A = B A = B
} }
{ {
TMP = USR TMP = USR
} }
{ {
TMP = extractu(TMP,#2,#SR_ROUND_OFF) TMP = extractu(TMP,#2,#SR_ROUND_OFF)
A = #0 A = #0
} }
{ {
p0 = cmp.eq(TMP,#2) p0 = cmp.eq(TMP,#2)
if (p0.new) AH = ##0x80000000 if (p0.new) AH = ##0x80000000
jumpr r31 jumpr r31
} }
#undef BTMP #undef BTMP
#undef BTMPH #undef BTMPH
#undef BTMPL #undef BTMPL
#define CTMP r11:10 #define CTMP r11:10
.falign .falign
.Lfma_abnormal_c: .Lfma_abnormal_c:
/* We know that AB is normal * normal */ // We know that AB is normal * normal
/* C is not normal: zero, subnormal, inf, or NaN. */ // C is not normal: zero, subnormal, inf, or NaN.
{ {
p0 = dfclass(C,#0x10) // is C NaN? p0 = dfclass(C,#0x10) // is C NaN?
if (p0.new) jump:nt .Lnan if (p0.new) jump:nt .Lnan
if (p0.new) A = C // move NaN to A if (p0.new) A = C // move NaN to A
deallocframe deallocframe
} }
{ {
p0 = dfclass(C,#0x08) // is C inf? p0 = dfclass(C,#0x08) // is C inf?
Show All 19 Lines

lib/builtins/hexagon/dfminmax.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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 A r1:0 #define A r1:0
#define B r3:2 #define B r3:2
#define ATMP r5:4 #define ATMP r5:4
#define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG #define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG
#define END(TAG) .size TAG,.-TAG #define END(TAG) .size TAG,.-TAG
/* // Min and Max return A if B is NaN, or B if A is NaN
* Min and Max return A if B is NaN, or B if A is NaN // Otherwise, they return the smaller or bigger value
* Otherwise, they return the smaller or bigger value //
* // If values are equal, we want to favor -0.0 for min and +0.0 for max.
* If values are equal, we want to favor -0.0 for min and +0.0 for max.
*/ // Compares always return false for NaN
// if (isnan(A)) A = B; if (A > B) A = B will only trigger at most one of those options.
/*
* Compares always return false for NaN
* if (isnan(A)) A = B; if (A > B) A = B will only trigger at most one of those options.
*/
.text .text
.global __hexagon_mindf3 .global __hexagon_mindf3
.global __hexagon_maxdf3 .global __hexagon_maxdf3
.global fmin .global fmin
.type fmin,@function .type fmin,@function
.global fmax .global fmax
.type fmax,@function .type fmax,@function
.type __hexagon_mindf3,@function .type __hexagon_mindf3,@function
Show All 9 Linesfmin:
ATMP = A ATMP = A
} }
{ {
if (p0) A = B // if A is NaN use B if (p0) A = B // if A is NaN use B
if (p1) A = B // gt is always false if either is NaN if (p1) A = B // gt is always false if either is NaN
p2 = dfcmp.eq(A,B) // if A == B p2 = dfcmp.eq(A,B) // if A == B
if (!p2.new) jumpr:t r31 if (!p2.new) jumpr:t r31
} }
/* A == B, return A|B to select -0.0 over 0.0 */ // A == B, return A|B to select -0.0 over 0.0
{ {
A = or(ATMP,B) A = or(ATMP,B)
jumpr r31 jumpr r31
} }
END(__hexagon_mindf3) END(__hexagon_mindf3)
.falign .falign
__hexagon_maxdf3: __hexagon_maxdf3:
fmax: fmax:
{ {
p0 = dfclass(A,#0x10) p0 = dfclass(A,#0x10)
p1 = dfcmp.gt(B,A) p1 = dfcmp.gt(B,A)
ATMP = A ATMP = A
} }
{ {
if (p0) A = B if (p0) A = B
if (p1) A = B if (p1) A = B
p2 = dfcmp.eq(A,B) p2 = dfcmp.eq(A,B)
if (!p2.new) jumpr:t r31 if (!p2.new) jumpr:t r31
} }
/* A == B, return A&B to select 0.0 over -0.0 */ // A == B, return A&B to select 0.0 over -0.0
{ {
A = and(ATMP,B) A = and(ATMP,B)
jumpr r31 jumpr r31
} }
END(__hexagon_maxdf3) END(__hexagon_maxdf3)

lib/builtins/hexagon/dfmul.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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 Precision Multiply */ // Double Precision Multiply
#define A r1:0 #define A r1:0
#define AH r1 #define AH r1
#define AL r0 #define AL r0
#define B r3:2 #define B r3:2
#define BH r3 #define BH r3
#define BL r2 #define BL r2
#define BTMP r5:4 #define BTMP r5:4
Show All 23 Lines
#define TMP r28 #define TMP r28
#define MANTBITS 52 #define MANTBITS 52
#define HI_MANTBITS 20 #define HI_MANTBITS 20
#define EXPBITS 11 #define EXPBITS 11
#define BIAS 1024 #define BIAS 1024
#define MANTISSA_TO_INT_BIAS 52 #define MANTISSA_TO_INT_BIAS 52
/* Some constant to adjust normalization amount in error code */ // Some constant to adjust normalization amount in error code
/* Amount to right shift the partial product to get to a denorm */ // Amount to right shift the partial product to get to a denorm
#define FUDGE 5 #define FUDGE 5
#define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG #define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG
#define FAST_ALIAS(TAG) .global __hexagon_fast_##TAG ; .set __hexagon_fast_##TAG, __hexagon_##TAG #define FAST_ALIAS(TAG) .global __hexagon_fast_##TAG ; .set __hexagon_fast_##TAG, __hexagon_##TAG
#define FAST2_ALIAS(TAG) .global __hexagon_fast2_##TAG ; .set __hexagon_fast2_##TAG, __hexagon_##TAG #define FAST2_ALIAS(TAG) .global __hexagon_fast2_##TAG ; .set __hexagon_fast2_##TAG, __hexagon_##TAG
#define END(TAG) .size TAG,.-TAG #define END(TAG) .size TAG,.-TAG
#define SR_ROUND_OFF 22 #define SR_ROUND_OFF 22
Show All 15 Lines__hexagon_muldf3:
BTMP = asl(B,#EXPBITS-1) BTMP = asl(B,#EXPBITS-1)
TMP = #-BIAS TMP = #-BIAS
ONE = #1 ONE = #1
} }
{ {
PP_ODD = mpyu(BTMPL,ATMPH) PP_ODD = mpyu(BTMPL,ATMPH)
BTMP = insert(ONE,#2,#62) BTMP = insert(ONE,#2,#62)
} }
/* since we know that the MSB of the H registers is zero, we should never carry */ // since we know that the MSB of the H registers is zero, we should never carry
/* H <= 2^31-1. L <= 2^32-1. Therefore, HL <= 2^63-2^32-2^31+1 */ // H <= 2^31-1. L <= 2^32-1. Therefore, HL <= 2^63-2^32-2^31+1
/* Adding 2 HLs, we get 2^64-3*2^32+2 maximum. */ // Adding 2 HLs, we get 2^64-3*2^32+2 maximum.
/* Therefore, we can add 3 2^32-1 values safely without carry. We only need one. */ // Therefore, we can add 3 2^32-1 values safely without carry. We only need one.
{ {
PP_LL = mpyu(ATMPL,BTMPL) PP_LL = mpyu(ATMPL,BTMPL)
PP_ODD += mpyu(ATMPL,BTMPH) PP_ODD += mpyu(ATMPL,BTMPH)
} }
{ {
PP_ODD += lsr(PP_LL,#32) PP_ODD += lsr(PP_LL,#32)
PP_HH = mpyu(ATMPH,BTMPH) PP_HH = mpyu(ATMPH,BTMPH)
BTMP = combine(##BIAS+BIAS-4,#0) BTMP = combine(##BIAS+BIAS-4,#0)
} }
{ {
PP_HH += lsr(PP_ODD,#32) PP_HH += lsr(PP_ODD,#32)
if (!p0) jump .Lmul_abnormal if (!p0) jump .Lmul_abnormal
p1 = cmp.eq(PP_LL_L,#0) // 64 lsb's 0? p1 = cmp.eq(PP_LL_L,#0) // 64 lsb's 0?
p1 = cmp.eq(PP_ODD_L,#0) // 64 lsb's 0? p1 = cmp.eq(PP_ODD_L,#0) // 64 lsb's 0?
} }
/*
* PP_HH can have a maximum of 0x3FFF_FFFF_FFFF_FFFF or thereabouts // PP_HH can have a maximum of 0x3FFF_FFFF_FFFF_FFFF or thereabouts
* PP_HH can have a minimum of 0x1000_0000_0000_0000 or so // PP_HH can have a minimum of 0x1000_0000_0000_0000 or so
*/
#undef PP_ODD #undef PP_ODD
#undef PP_ODD_H #undef PP_ODD_H
#undef PP_ODD_L #undef PP_ODD_L
#define EXP10 r7:6 #define EXP10 r7:6
#define EXP1 r7 #define EXP1 r7
#define EXP0 r6 #define EXP0 r6
{ {
if (!p1) PP_HH_L = or(PP_HH_L,S_ONE) if (!p1) PP_HH_L = or(PP_HH_L,S_ONE)
Show All 18 Lines#define EXP0 r6
} }
{ {
AH += asl(EXP0,#HI_MANTBITS) AH += asl(EXP0,#HI_MANTBITS)
jumpr r31 jumpr r31
} }
.falign .falign
.Lpossible_unf: .Lpossible_unf:
/* We end up with a positive exponent */ // We end up with a positive exponent
/* But we may have rounded up to an exponent of 1. */ // But we may have rounded up to an exponent of 1.
/* If the exponent is 1, if we rounded up to it // If the exponent is 1, if we rounded up to it
* we need to also raise underflow // we need to also raise underflow
* Fortunately, this is pretty easy to detect, we must have +/- 0x0010_0000_0000_0000 // Fortunately, this is pretty easy to detect, we must have +/- 0x0010_0000_0000_0000
* And the PP should also have more than one bit set // And the PP should also have more than one bit set
*/ //
/* Note: ATMP should have abs(PP_HH) */ // Note: ATMP should have abs(PP_HH)
/* Note: BTMPL should have 0x7FEFFFFF */ // Note: BTMPL should have 0x7FEFFFFF
{ {
p0 = cmp.eq(AL,#0) p0 = cmp.eq(AL,#0)
p0 = bitsclr(AH,BTMPL) p0 = bitsclr(AH,BTMPL)
if (!p0.new) jumpr:t r31 if (!p0.new) jumpr:t r31
BTMPH = #0x7fff BTMPH = #0x7fff
} }
{ {
p0 = bitsset(ATMPH,BTMPH) p0 = bitsset(ATMPH,BTMPH)
Show All 32 Lines.Lmul_ovf_unf:
if (p0.new) jump:nt .Lmul_ovf if (p0.new) jump:nt .Lmul_ovf
} }
{ {
p0 = cmp.gt(EXP1,#0) p0 = cmp.gt(EXP1,#0)
if (p0.new) jump:nt .Lpossible_unf if (p0.new) jump:nt .Lpossible_unf
BTMPH = sub(EXP0,BTMPH) BTMPH = sub(EXP0,BTMPH)
TMP = #63 // max amount to shift TMP = #63 // max amount to shift
} }
/* Underflow */ // Underflow
/* //
* PP_HH has the partial product with sticky LSB. // PP_HH has the partial product with sticky LSB.
* PP_HH can have a maximum of 0x3FFF_FFFF_FFFF_FFFF or thereabouts // PP_HH can have a maximum of 0x3FFF_FFFF_FFFF_FFFF or thereabouts
* PP_HH can have a minimum of 0x1000_0000_0000_0000 or so // PP_HH can have a minimum of 0x1000_0000_0000_0000 or so
* The exponent of PP_HH is in EXP1, which is non-positive (0 or negative) // The exponent of PP_HH is in EXP1, which is non-positive (0 or negative)
* That's the exponent that happens after the normalization // That's the exponent that happens after the normalization
* //
* EXP0 has the exponent that, when added to the normalized value, is out of range. // EXP0 has the exponent that, when added to the normalized value, is out of range.
* //
* Strategy: // Strategy:
* //
* * Shift down bits, with sticky bit, such that the bits are aligned according // * Shift down bits, with sticky bit, such that the bits are aligned according
* to the LZ count and appropriate exponent, but not all the way to mantissa // to the LZ count and appropriate exponent, but not all the way to mantissa
* field, keep around the last few bits. // field, keep around the last few bits.
* * Put a 1 near the MSB // * Put a 1 near the MSB
* * Check the LSBs for inexact; if inexact also set underflow // * Check the LSBs for inexact; if inexact also set underflow
* * Convert [u]d2df -- will correctly round according to rounding mode // * Convert [u]d2df -- will correctly round according to rounding mode
* * Replace exponent field with zero // * Replace exponent field with zero
*
*
*/
{ {
BTMPL = #0 // offset for extract BTMPL = #0 // offset for extract
BTMPH = sub(#FUDGE,BTMPH) // amount to right shift BTMPH = sub(#FUDGE,BTMPH) // amount to right shift
} }
{ {
p3 = cmp.gt(PP_HH_H,#-1) // is it positive? p3 = cmp.gt(PP_HH_H,#-1) // is it positive?
BTMPH = min(BTMPH,TMP) // Don't shift more than 63 BTMPH = min(BTMPH,TMP) // Don't shift more than 63
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

lib/builtins/hexagon/dfsqrt.S

//===----------------------Hexagon builtin routine ------------------------===// //===----------------------Hexagon builtin routine ------------------------===//
// //
// 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 Precision square root */ // Double Precision square root
#define EXP r28 #define EXP r28
#define A r1:0 #define A r1:0
#define AH r1 #define AH r1
#define AL r0 #define AL r0
#define SFSH r3:2 #define SFSH r3:2
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
#define LL r5:4 #define LL r5:4
#define HH r7:6 #define HH r7:6
#undef P_EXP1 #undef P_EXP1
#define P_CARRY0 p1 #define P_CARRY0 p1
#define P_CARRY1 p2 #define P_CARRY1 p2
#define P_CARRY2 p3 #define P_CARRY2 p3
/* Iteration 0 */ // Iteration 0
/* Maybe we can save a cycle by starting with ERROR=asl(fracrad), then as we multiply */ // Maybe we can save a cycle by starting with ERROR=asl(fracrad), then as we multiply
/* We can shift and subtract instead of shift and add? */ // We can shift and subtract instead of shift and add?
{ {
ERROR = asl(FRACRAD,#15) ERROR = asl(FRACRAD,#15)
PROD = mpyu(ROOTHI,ROOTHI) PROD = mpyu(ROOTHI,ROOTHI)
P_CARRY0 = cmp.eq(r0,r0) P_CARRY0 = cmp.eq(r0,r0)
} }
{ {
ERROR -= asl(PROD,#15) ERROR -= asl(PROD,#15)
PROD = mpyu(ROOTHI,ROOTLO) PROD = mpyu(ROOTHI,ROOTLO)
P_CARRY1 = cmp.eq(r0,r0) P_CARRY1 = cmp.eq(r0,r0)
} }
{ {
ERROR -= lsr(PROD,#16) ERROR -= lsr(PROD,#16)
P_CARRY2 = cmp.eq(r0,r0) P_CARRY2 = cmp.eq(r0,r0)
} }
{ {
ERROR = mpyu(ERRORHI,RECIPEST) ERROR = mpyu(ERRORHI,RECIPEST)
} }
{ {
ROOT += lsr(ERROR,SHIFTAMT) ROOT += lsr(ERROR,SHIFTAMT)
SHIFTAMT = add(SHIFTAMT,#16) SHIFTAMT = add(SHIFTAMT,#16)
ERROR = asl(FRACRAD,#31) // for next iter ERROR = asl(FRACRAD,#31) // for next iter
} }
/* Iteration 1 */ // Iteration 1
{ {
PROD = mpyu(ROOTHI,ROOTHI) PROD = mpyu(ROOTHI,ROOTHI)
ERROR -= mpyu(ROOTHI,ROOTLO) // amount is 31, no shift needed ERROR -= mpyu(ROOTHI,ROOTLO) // amount is 31, no shift needed
} }
{ {
ERROR -= asl(PROD,#31) ERROR -= asl(PROD,#31)
PROD = mpyu(ROOTLO,ROOTLO) PROD = mpyu(ROOTLO,ROOTLO)
} }
{ {
ERROR -= lsr(PROD,#33) ERROR -= lsr(PROD,#33)
} }
{ {
ERROR = mpyu(ERRORHI,RECIPEST) ERROR = mpyu(ERRORHI,RECIPEST)
} }
{ {
ROOT += lsr(ERROR,SHIFTAMT) ROOT += lsr(ERROR,SHIFTAMT)
SHIFTAMT = add(SHIFTAMT,#16) SHIFTAMT = add(SHIFTAMT,#16)
ERROR = asl(FRACRAD,#47) // for next iter ERROR = asl(FRACRAD,#47) // for next iter
} }
/* Iteration 2 */ // Iteration 2
{ {
PROD = mpyu(ROOTHI,ROOTHI) PROD = mpyu(ROOTHI,ROOTHI)
} }
{ {
ERROR -= asl(PROD,#47) ERROR -= asl(PROD,#47)
PROD = mpyu(ROOTHI,ROOTLO) PROD = mpyu(ROOTHI,ROOTLO)
} }
{ {
Show All 14 Lines
#undef PRODHI #undef PRODHI
#undef PRODLO #undef PRODLO
#define REM_HI r15:14 #define REM_HI r15:14
#define REM_HI_HI r15 #define REM_HI_HI r15
#define REM_LO r1:0 #define REM_LO r1:0
#undef RECIPEST #undef RECIPEST
#undef SHIFTAMT #undef SHIFTAMT
#define TWOROOT_LO r9:8 #define TWOROOT_LO r9:8
/* Adjust Root */ // Adjust Root
{ {
HL = mpyu(ROOTHI,ROOTLO) HL = mpyu(ROOTHI,ROOTLO)
LL = mpyu(ROOTLO,ROOTLO) LL = mpyu(ROOTLO,ROOTLO)
REM_HI = #0 REM_HI = #0
REM_LO = #0 REM_LO = #0
} }
{ {
HL += lsr(LL,#33) HL += lsr(LL,#33)
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

lib/builtins/i386/ashrdi3.S

Show All 17 Lines#ifndef TRUST_CALLERS_USE_64_BIT_STORES
movd 4(%esp), %xmm0 movd 4(%esp), %xmm0
movd 8(%esp), %xmm1 movd 8(%esp), %xmm1
punpckldq %xmm1, %xmm0 // Load input punpckldq %xmm1, %xmm0 // Load input
#else #else
movq 4(%esp), %xmm0 // Load input movq 4(%esp), %xmm0 // Load input
#endif #endif
psrlq %xmm2, %xmm0 // unsigned shift input by count psrlq %xmm2, %xmm0 // unsigned shift input by count
testl %eax, %eax // check the sign-bit of the input testl %eax, %eax // check the sign-bit of the input
jns 1f // early out for positive inputs jns 1f // early out for positive inputs
// If the input is negative, we need to construct the shifted sign bit // If the input is negative, we need to construct the shifted sign bit
// to or into the result, as xmm does not have a signed right shift. // to or into the result, as xmm does not have a signed right shift.
pcmpeqb %xmm1, %xmm1 // -1ULL pcmpeqb %xmm1, %xmm1 // -1ULL
psrlq $58, %xmm1 // 0x3f psrlq $58, %xmm1 // 0x3f
pandn %xmm1, %xmm2 // 63 - count pandn %xmm1, %xmm2 // 63 - count
pcmpeqb %xmm1, %xmm1 // -1ULL pcmpeqb %xmm1, %xmm1 // -1ULL
psubq %xmm1, %xmm2 // 64 - count psubq %xmm1, %xmm2 // 64 - count
psllq %xmm2, %xmm1 // -1 << (64 - count) = leading sign bits psllq %xmm2, %xmm1 // -1 << (64 - count) = leading sign bits
por %xmm1, %xmm0 por %xmm1, %xmm0
// Move the result back to the general purpose registers and return // Move the result back to the general purpose registers and return
1: movd %xmm0, %eax 1: movd %xmm0, %eax
psrlq $32, %xmm0 psrlq $32, %xmm0
movd %xmm0, %edx movd %xmm0, %edx
ret ret
END_COMPILERRT_FUNCTION(__ashrdi3) END_COMPILERRT_FUNCTION(__ashrdi3)
#else // Use GPRs instead of SSE2 instructions, if they aren't available. #else // Use GPRs instead of SSE2 instructions, if they aren't available.
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__ashrdi3) DEFINE_COMPILERRT_FUNCTION(__ashrdi3)
movl 12(%esp), %ecx // Load count movl 12(%esp), %ecx // Load count
movl 8(%esp), %edx // Load high movl 8(%esp), %edx // Load high
movl 4(%esp), %eax // Load low movl 4(%esp), %eax // Load low
testl $0x20, %ecx // If count >= 32 testl $0x20, %ecx // If count >= 32
jnz 1f // goto 1 jnz 1f // goto 1
shrdl %cl, %edx, %eax // right shift low by count shrdl %cl, %edx, %eax // right shift low by count
sarl %cl, %edx // right shift high by count sarl %cl, %edx // right shift high by count
ret ret
1: movl %edx, %eax // Move high to low 1: movl %edx, %eax // Move high to low
sarl $31, %edx // clear high sarl $31, %edx // clear high
sarl %cl, %eax // shift low by count - 32 sarl %cl, %eax // shift low by count - 32
ret ret
END_COMPILERRT_FUNCTION(__ashrdi3) END_COMPILERRT_FUNCTION(__ashrdi3)
#endif // __SSE2__ #endif // __SSE2__
#endif // __i386__ #endif // __i386__
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/i386/divdi3.S

Show All 17 Lines
// Stephen Canon, December 2008 // Stephen Canon, December 2008
#ifdef __i386__ #ifdef __i386__
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__divdi3) DEFINE_COMPILERRT_FUNCTION(__divdi3)
/* This is currently implemented by wrapping the unsigned divide up in an absolute // This is currently implemented by wrapping the unsigned divide up in an absolute
value, then restoring the correct sign at the end of the computation. This could // value, then restoring the correct sign at the end of the computation. This could
certainly be improved upon. */ // certainly be improved upon.
pushl %esi pushl %esi
movl 20(%esp), %edx // high word of b movl 20(%esp), %edx // high word of b
movl 16(%esp), %eax // low word of b movl 16(%esp), %eax // low word of b
movl %edx, %ecx movl %edx, %ecx
sarl $31, %ecx // (b < 0) ? -1 : 0 sarl $31, %ecx // (b < 0) ? -1 : 0
xorl %ecx, %eax xorl %ecx, %eax
xorl %ecx, %edx // EDX:EAX = (b < 0) ? not(b) : b xorl %ecx, %edx // EDX:EAX = (b < 0) ? not(b) : b
subl %ecx, %eax subl %ecx, %eax
sbbl %ecx, %edx // EDX:EAX = abs(b) sbbl %ecx, %edx // EDX:EAX = abs(b)
movl %edx, 20(%esp) movl %edx, 20(%esp)
movl %eax, 16(%esp) // store abs(b) back to stack movl %eax, 16(%esp) // store abs(b) back to stack
movl %ecx, %esi // set aside sign of b movl %ecx, %esi // set aside sign of b
movl 12(%esp), %edx // high word of b movl 12(%esp), %edx // high word of b
movl 8(%esp), %eax // low word of b movl 8(%esp), %eax // low word of b
movl %edx, %ecx movl %edx, %ecx
sarl $31, %ecx // (a < 0) ? -1 : 0 sarl $31, %ecx // (a < 0) ? -1 : 0
xorl %ecx, %eax xorl %ecx, %eax
xorl %ecx, %edx // EDX:EAX = (a < 0) ? not(a) : a xorl %ecx, %edx // EDX:EAX = (a < 0) ? not(a) : a
subl %ecx, %eax subl %ecx, %eax
sbbl %ecx, %edx // EDX:EAX = abs(a) sbbl %ecx, %edx // EDX:EAX = abs(a)
movl %edx, 12(%esp) movl %edx, 12(%esp)
movl %eax, 8(%esp) // store abs(a) back to stack movl %eax, 8(%esp) // store abs(a) back to stack
xorl %ecx, %esi // sign of result = (sign of a) ^ (sign of b) xorl %ecx, %esi // sign of result = (sign of a) ^ (sign of b)
pushl %ebx pushl %ebx
movl 24(%esp), %ebx // Find the index i of the leading bit in b. movl 24(%esp), %ebx // Find the index i of the leading bit in b.
bsrl %ebx, %ecx // If the high word of b is zero, jump to bsrl %ebx, %ecx // If the high word of b is zero, jump to
jz 9f // the code to handle that special case [9]. jz 9f // the code to handle that special case [9].
/* High word of b is known to be non-zero on this branch */ // High word of b is known to be non-zero on this branch
movl 20(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b movl 20(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b
shrl %cl, %eax // Practically, this means that bhi is given by: shrl %cl, %eax // Practically, this means that bhi is given by:
shrl %eax // shrl %eax //
notl %ecx // bhi = (high word of b) << (31 - i) | notl %ecx // bhi = (high word of b) << (31 - i) |
shll %cl, %ebx // (low word of b) >> (1 + i) shll %cl, %ebx // (low word of b) >> (1 + i)
orl %eax, %ebx // orl %eax, %ebx //
movl 16(%esp), %edx // Load the high and low words of a, and jump movl 16(%esp), %edx // Load the high and low words of a, and jump
movl 12(%esp), %eax // to [1] if the high word is larger than bhi movl 12(%esp), %eax // to [1] if the high word is larger than bhi
cmpl %ebx, %edx // to avoid overflowing the upcoming divide. cmpl %ebx, %edx // to avoid overflowing the upcoming divide.
jae 1f jae 1f
/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ // High word of a is greater than or equal to (b >> (1 + i)) on this branch
divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
pushl %edi pushl %edi
notl %ecx notl %ecx
shrl %eax shrl %eax
shrl %cl, %eax // q = qs >> (1 + i) shrl %cl, %eax // q = qs >> (1 + i)
movl %eax, %edi movl %eax, %edi
mull 24(%esp) // q*blo mull 24(%esp) // q*blo
movl 16(%esp), %ebx movl 16(%esp), %ebx
movl 20(%esp), %ecx // ECX:EBX = a movl 20(%esp), %ecx // ECX:EBX = a
subl %eax, %ebx subl %eax, %ebx
sbbl %edx, %ecx // ECX:EBX = a - q*blo sbbl %edx, %ecx // ECX:EBX = a - q*blo
movl 28(%esp), %eax movl 28(%esp), %eax
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
sbbl $0, %edi // decrement q if remainder is negative sbbl $0, %edi // decrement q if remainder is negative
xorl %edx, %edx xorl %edx, %edx
movl %edi, %eax movl %edi, %eax
addl %esi, %eax // Restore correct sign to result addl %esi, %eax // Restore correct sign to result
adcl %esi, %edx adcl %esi, %edx
xorl %esi, %eax xorl %esi, %eax
xorl %esi, %edx xorl %esi, %edx
popl %edi // Restore callee-save registers popl %edi // Restore callee-save registers
popl %ebx popl %ebx
popl %esi popl %esi
retl // Return retl // Return
1: /* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ 1: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
subl %ebx, %edx // subtract bhi from ahi so that divide will not subl %ebx, %edx // subtract bhi from ahi so that divide will not
divl %ebx // overflow, and find q and r such that divl %ebx // overflow, and find q and r such that
// //
// ahi:alo = (1:q)*bhi + r // ahi:alo = (1:q)*bhi + r
// //
// Note that q is a number in (31-i).(1+i) // Note that q is a number in (31-i).(1+i)
// fix point. // fix point.
Show All 9 Lines1: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
subl %eax, %ebx subl %eax, %ebx
sbbl %edx, %ecx // ECX:EBX = a - q*blo sbbl %edx, %ecx // ECX:EBX = a - q*blo
movl 28(%esp), %eax movl 28(%esp), %eax
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
sbbl $0, %edi // decrement q if remainder is negative sbbl $0, %edi // decrement q if remainder is negative
xorl %edx, %edx xorl %edx, %edx
movl %edi, %eax movl %edi, %eax
addl %esi, %eax // Restore correct sign to result addl %esi, %eax // Restore correct sign to result
adcl %esi, %edx adcl %esi, %edx
xorl %esi, %eax xorl %esi, %eax
xorl %esi, %edx xorl %esi, %edx
popl %edi // Restore callee-save registers popl %edi // Restore callee-save registers
popl %ebx popl %ebx
popl %esi popl %esi
retl // Return retl // Return
9: /* High word of b is zero on this branch */ 9: // High word of b is zero on this branch
movl 16(%esp), %eax // Find qhi and rhi such that movl 16(%esp), %eax // Find qhi and rhi such that
movl 20(%esp), %ecx // movl 20(%esp), %ecx //
xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b
divl %ecx // divl %ecx //
movl %eax, %ebx // movl %eax, %ebx //
movl 12(%esp), %eax // Find qlo such that movl 12(%esp), %eax // Find qlo such that
divl %ecx // divl %ecx //
movl %ebx, %edx // rhi:alo = qlo*b + rlo with 0 ≤ rlo < b movl %ebx, %edx // rhi:alo = qlo*b + rlo with 0 ≤ rlo < b
addl %esi, %eax // Restore correct sign to result addl %esi, %eax // Restore correct sign to result
adcl %esi, %edx adcl %esi, %edx
xorl %esi, %eax xorl %esi, %eax
xorl %esi, %edx xorl %esi, %edx
popl %ebx // Restore callee-save registers popl %ebx // Restore callee-save registers
popl %esi popl %esi
retl // Return retl // Return
END_COMPILERRT_FUNCTION(__divdi3) END_COMPILERRT_FUNCTION(__divdi3)
#endif // __i386__ #endif // __i386__
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/i386/floatundisf.S

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines0: popl %ecx
flds 4(%esp) flds 4(%esp)
ret ret
END_COMPILERRT_FUNCTION(__floatundisf) END_COMPILERRT_FUNCTION(__floatundisf)
#endif // __i386__ #endif // __i386__
*/ */
/* branch-free, x87-free implementation - faster at the expense of code size */ // branch-free, x87-free implementation - faster at the expense of code size
#ifdef __i386__ #ifdef __i386__
CONST_SECTION CONST_SECTION
.balign 16 .balign 16
twop52: twop52:
.quad 0x4330000000000000 .quad 0x4330000000000000
Show All 13 Lines
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__floatundisf) DEFINE_COMPILERRT_FUNCTION(__floatundisf)
movl 8(%esp), %eax movl 8(%esp), %eax
movd 8(%esp), %xmm1 movd 8(%esp), %xmm1
movd 4(%esp), %xmm0 movd 4(%esp), %xmm0
punpckldq %xmm1, %xmm0 punpckldq %xmm1, %xmm0
calll 0f calll 0f
0: popl %ecx 0: popl %ecx
shrl %eax // high 31 bits of input as sint32 shrl %eax // high 31 bits of input as sint32
addl $0x7ff80000, %eax addl $0x7ff80000, %eax
sarl $31, %eax // (big input) ? -1 : 0 sarl $31, %eax // (big input) ? -1 : 0
movsd STICKY, %xmm1 // (big input) ? 0xfff : 0 movsd STICKY, %xmm1 // (big input) ? 0xfff : 0
movl $12, %edx movl $12, %edx
andl %eax, %edx // (big input) ? 12 : 0 andl %eax, %edx // (big input) ? 12 : 0
Show All 19 Lines

lib/builtins/i386/lshrdi3.S

Show All 36 Lines
#else // Use GPRs instead of SSE2 instructions, if they aren't available. #else // Use GPRs instead of SSE2 instructions, if they aren't available.
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__lshrdi3) DEFINE_COMPILERRT_FUNCTION(__lshrdi3)
movl 12(%esp), %ecx // Load count movl 12(%esp), %ecx // Load count
movl 8(%esp), %edx // Load high movl 8(%esp), %edx // Load high
movl 4(%esp), %eax // Load low movl 4(%esp), %eax // Load low
testl $0x20, %ecx // If count >= 32 testl $0x20, %ecx // If count >= 32
jnz 1f // goto 1 jnz 1f // goto 1
shrdl %cl, %edx, %eax // right shift low by count shrdl %cl, %edx, %eax // right shift low by count
shrl %cl, %edx // right shift high by count shrl %cl, %edx // right shift high by count
ret ret
1: movl %edx, %eax // Move high to low 1: movl %edx, %eax // Move high to low
xorl %edx, %edx // clear high xorl %edx, %edx // clear high
shrl %cl, %eax // shift low by count - 32 shrl %cl, %eax // shift low by count - 32
ret ret
END_COMPILERRT_FUNCTION(__lshrdi3) END_COMPILERRT_FUNCTION(__lshrdi3)
#endif // __SSE2__ #endif // __SSE2__
#endif // __i386__ #endif // __i386__
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/i386/moddi3.S

Show All 18 Lines
// Stephen Canon, December 2008 // Stephen Canon, December 2008
#ifdef __i386__ #ifdef __i386__
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__moddi3) DEFINE_COMPILERRT_FUNCTION(__moddi3)
/* This is currently implemented by wrapping the unsigned modulus up in an absolute // This is currently implemented by wrapping the unsigned modulus up in an absolute
value. This could certainly be improved upon. */ // value. This could certainly be improved upon.
pushl %esi pushl %esi
movl 20(%esp), %edx // high word of b movl 20(%esp), %edx // high word of b
movl 16(%esp), %eax // low word of b movl 16(%esp), %eax // low word of b
movl %edx, %ecx movl %edx, %ecx
sarl $31, %ecx // (b < 0) ? -1 : 0 sarl $31, %ecx // (b < 0) ? -1 : 0
xorl %ecx, %eax xorl %ecx, %eax
xorl %ecx, %edx // EDX:EAX = (b < 0) ? not(b) : b xorl %ecx, %edx // EDX:EAX = (b < 0) ? not(b) : b
subl %ecx, %eax subl %ecx, %eax
sbbl %ecx, %edx // EDX:EAX = abs(b) sbbl %ecx, %edx // EDX:EAX = abs(b)
movl %edx, 20(%esp) movl %edx, 20(%esp)
movl %eax, 16(%esp) // store abs(b) back to stack movl %eax, 16(%esp) // store abs(b) back to stack
movl 12(%esp), %edx // high word of b movl 12(%esp), %edx // high word of b
movl 8(%esp), %eax // low word of b movl 8(%esp), %eax // low word of b
movl %edx, %ecx movl %edx, %ecx
sarl $31, %ecx // (a < 0) ? -1 : 0 sarl $31, %ecx // (a < 0) ? -1 : 0
xorl %ecx, %eax xorl %ecx, %eax
xorl %ecx, %edx // EDX:EAX = (a < 0) ? not(a) : a xorl %ecx, %edx // EDX:EAX = (a < 0) ? not(a) : a
subl %ecx, %eax subl %ecx, %eax
sbbl %ecx, %edx // EDX:EAX = abs(a) sbbl %ecx, %edx // EDX:EAX = abs(a)
movl %edx, 12(%esp) movl %edx, 12(%esp)
movl %eax, 8(%esp) // store abs(a) back to stack movl %eax, 8(%esp) // store abs(a) back to stack
movl %ecx, %esi // set aside sign of a movl %ecx, %esi // set aside sign of a
pushl %ebx pushl %ebx
movl 24(%esp), %ebx // Find the index i of the leading bit in b. movl 24(%esp), %ebx // Find the index i of the leading bit in b.
bsrl %ebx, %ecx // If the high word of b is zero, jump to bsrl %ebx, %ecx // If the high word of b is zero, jump to
jz 9f // the code to handle that special case [9]. jz 9f // the code to handle that special case [9].
/* High word of b is known to be non-zero on this branch */ // High word of b is known to be non-zero on this branch
movl 20(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b movl 20(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b
shrl %cl, %eax // Practically, this means that bhi is given by: shrl %cl, %eax // Practically, this means that bhi is given by:
shrl %eax // shrl %eax //
notl %ecx // bhi = (high word of b) << (31 - i) | notl %ecx // bhi = (high word of b) << (31 - i) |
shll %cl, %ebx // (low word of b) >> (1 + i) shll %cl, %ebx // (low word of b) >> (1 + i)
orl %eax, %ebx // orl %eax, %ebx //
movl 16(%esp), %edx // Load the high and low words of a, and jump movl 16(%esp), %edx // Load the high and low words of a, and jump
movl 12(%esp), %eax // to [2] if the high word is larger than bhi movl 12(%esp), %eax // to [2] if the high word is larger than bhi
cmpl %ebx, %edx // to avoid overflowing the upcoming divide. cmpl %ebx, %edx // to avoid overflowing the upcoming divide.
jae 2f jae 2f
/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ // High word of a is greater than or equal to (b >> (1 + i)) on this branch
divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
pushl %edi pushl %edi
notl %ecx notl %ecx
shrl %eax shrl %eax
shrl %cl, %eax // q = qs >> (1 + i) shrl %cl, %eax // q = qs >> (1 + i)
movl %eax, %edi movl %eax, %edi
mull 24(%esp) // q*blo mull 24(%esp) // q*blo
movl 16(%esp), %ebx movl 16(%esp), %ebx
movl 20(%esp), %ecx // ECX:EBX = a movl 20(%esp), %ecx // ECX:EBX = a
subl %eax, %ebx subl %eax, %ebx
sbbl %edx, %ecx // ECX:EBX = a - q*blo sbbl %edx, %ecx // ECX:EBX = a - q*blo
movl 28(%esp), %eax movl 28(%esp), %eax
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
jnc 1f // if positive, this is the result. jnc 1f // if positive, this is the result.
addl 24(%esp), %ebx // otherwise addl 24(%esp), %ebx // otherwise
adcl 28(%esp), %ecx // ECX:EBX = a - (q-1)*b = result adcl 28(%esp), %ecx // ECX:EBX = a - (q-1)*b = result
1: movl %ebx, %eax 1: movl %ebx, %eax
movl %ecx, %edx movl %ecx, %edx
addl %esi, %eax // Restore correct sign to result addl %esi, %eax // Restore correct sign to result
adcl %esi, %edx adcl %esi, %edx
xorl %esi, %eax xorl %esi, %eax
xorl %esi, %edx xorl %esi, %edx
popl %edi // Restore callee-save registers popl %edi // Restore callee-save registers
popl %ebx popl %ebx
popl %esi popl %esi
retl // Return retl // Return
2: /* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ 2: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
subl %ebx, %edx // subtract bhi from ahi so that divide will not subl %ebx, %edx // subtract bhi from ahi so that divide will not
divl %ebx // overflow, and find q and r such that divl %ebx // overflow, and find q and r such that
// //
// ahi:alo = (1:q)*bhi + r // ahi:alo = (1:q)*bhi + r
// //
// Note that q is a number in (31-i).(1+i) // Note that q is a number in (31-i).(1+i)
// fix point. // fix point.
Show All 12 Lines2: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
jnc 3f // if positive, this is the result. jnc 3f // if positive, this is the result.
addl 24(%esp), %ebx // otherwise addl 24(%esp), %ebx // otherwise
adcl 28(%esp), %ecx // ECX:EBX = a - (q-1)*b = result adcl 28(%esp), %ecx // ECX:EBX = a - (q-1)*b = result
3: movl %ebx, %eax 3: movl %ebx, %eax
movl %ecx, %edx movl %ecx, %edx
addl %esi, %eax // Restore correct sign to result addl %esi, %eax // Restore correct sign to result
adcl %esi, %edx adcl %esi, %edx
xorl %esi, %eax xorl %esi, %eax
xorl %esi, %edx xorl %esi, %edx
popl %edi // Restore callee-save registers popl %edi // Restore callee-save registers
popl %ebx popl %ebx
popl %esi popl %esi
retl // Return retl // Return
9: /* High word of b is zero on this branch */ 9: // High word of b is zero on this branch
movl 16(%esp), %eax // Find qhi and rhi such that movl 16(%esp), %eax // Find qhi and rhi such that
movl 20(%esp), %ecx // movl 20(%esp), %ecx //
xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b
divl %ecx // divl %ecx //
movl %eax, %ebx // movl %eax, %ebx //
movl 12(%esp), %eax // Find rlo such that movl 12(%esp), %eax // Find rlo such that
divl %ecx // divl %ecx //
Show All 16 Lines

lib/builtins/i386/muldi3.S

Show All 9 Lines
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__muldi3) DEFINE_COMPILERRT_FUNCTION(__muldi3)
pushl %ebx pushl %ebx
movl 16(%esp), %eax // b.lo movl 16(%esp), %eax // b.lo
movl 12(%esp), %ecx // a.hi movl 12(%esp), %ecx // a.hi
imull %eax, %ecx // b.lo * a.hi imull %eax, %ecx // b.lo * a.hi
movl 8(%esp), %edx // a.lo movl 8(%esp), %edx // a.lo
movl 20(%esp), %ebx // b.hi movl 20(%esp), %ebx // b.hi
imull %edx, %ebx // a.lo * b.hi imull %edx, %ebx // a.lo * b.hi
mull %edx // EDX:EAX = a.lo * b.lo mull %edx // EDX:EAX = a.lo * b.lo
addl %ecx, %ebx // EBX = (a.lo*b.hi + a.hi*b.lo) addl %ecx, %ebx // EBX = (a.lo*b.hi + a.hi*b.lo)
addl %ebx, %edx addl %ebx, %edx
popl %ebx popl %ebx
retl retl
END_COMPILERRT_FUNCTION(__muldi3) END_COMPILERRT_FUNCTION(__muldi3)
#endif // __i386__ #endif // __i386__
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/i386/udivdi3.S

Show All 21 Lines
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__udivdi3) DEFINE_COMPILERRT_FUNCTION(__udivdi3)
pushl %ebx pushl %ebx
movl 20(%esp), %ebx // Find the index i of the leading bit in b. movl 20(%esp), %ebx // Find the index i of the leading bit in b.
bsrl %ebx, %ecx // If the high word of b is zero, jump to bsrl %ebx, %ecx // If the high word of b is zero, jump to
jz 9f // the code to handle that special case [9]. jz 9f // the code to handle that special case [9].
/* High word of b is known to be non-zero on this branch */ // High word of b is known to be non-zero on this branch
movl 16(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b movl 16(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b
shrl %cl, %eax // Practically, this means that bhi is given by: shrl %cl, %eax // Practically, this means that bhi is given by:
shrl %eax // shrl %eax //
notl %ecx // bhi = (high word of b) << (31 - i) | notl %ecx // bhi = (high word of b) << (31 - i) |
shll %cl, %ebx // (low word of b) >> (1 + i) shll %cl, %ebx // (low word of b) >> (1 + i)
orl %eax, %ebx // orl %eax, %ebx //
movl 12(%esp), %edx // Load the high and low words of a, and jump movl 12(%esp), %edx // Load the high and low words of a, and jump
movl 8(%esp), %eax // to [1] if the high word is larger than bhi movl 8(%esp), %eax // to [1] if the high word is larger than bhi
cmpl %ebx, %edx // to avoid overflowing the upcoming divide. cmpl %ebx, %edx // to avoid overflowing the upcoming divide.
jae 1f jae 1f
/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ // High word of a is greater than or equal to (b >> (1 + i)) on this branch
divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
pushl %edi pushl %edi
notl %ecx notl %ecx
shrl %eax shrl %eax
shrl %cl, %eax // q = qs >> (1 + i) shrl %cl, %eax // q = qs >> (1 + i)
movl %eax, %edi movl %eax, %edi
mull 20(%esp) // q*blo mull 20(%esp) // q*blo
movl 12(%esp), %ebx movl 12(%esp), %ebx
movl 16(%esp), %ecx // ECX:EBX = a movl 16(%esp), %ecx // ECX:EBX = a
subl %eax, %ebx subl %eax, %ebx
sbbl %edx, %ecx // ECX:EBX = a - q*blo sbbl %edx, %ecx // ECX:EBX = a - q*blo
movl 24(%esp), %eax movl 24(%esp), %eax
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
sbbl $0, %edi // decrement q if remainder is negative sbbl $0, %edi // decrement q if remainder is negative
xorl %edx, %edx xorl %edx, %edx
movl %edi, %eax movl %edi, %eax
popl %edi popl %edi
popl %ebx popl %ebx
retl retl
1: /* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ 1: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
subl %ebx, %edx // subtract bhi from ahi so that divide will not subl %ebx, %edx // subtract bhi from ahi so that divide will not
divl %ebx // overflow, and find q and r such that divl %ebx // overflow, and find q and r such that
// //
// ahi:alo = (1:q)*bhi + r // ahi:alo = (1:q)*bhi + r
// //
// Note that q is a number in (31-i).(1+i) // Note that q is a number in (31-i).(1+i)
// fix point. // fix point.
Show All 13 Lines1: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
sbbl $0, %edi // decrement q if remainder is negative sbbl $0, %edi // decrement q if remainder is negative
xorl %edx, %edx xorl %edx, %edx
movl %edi, %eax movl %edi, %eax
popl %edi popl %edi
popl %ebx popl %ebx
retl retl
9: /* High word of b is zero on this branch */ 9: // High word of b is zero on this branch
movl 12(%esp), %eax // Find qhi and rhi such that movl 12(%esp), %eax // Find qhi and rhi such that
movl 16(%esp), %ecx // movl 16(%esp), %ecx //
xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b
divl %ecx // divl %ecx //
movl %eax, %ebx // movl %eax, %ebx //
movl 8(%esp), %eax // Find qlo such that movl 8(%esp), %eax // Find qlo such that
divl %ecx // divl %ecx //
Show All 9 Lines

lib/builtins/i386/umoddi3.S

Show All 22 Lines
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__umoddi3) DEFINE_COMPILERRT_FUNCTION(__umoddi3)
pushl %ebx pushl %ebx
movl 20(%esp), %ebx // Find the index i of the leading bit in b. movl 20(%esp), %ebx // Find the index i of the leading bit in b.
bsrl %ebx, %ecx // If the high word of b is zero, jump to bsrl %ebx, %ecx // If the high word of b is zero, jump to
jz 9f // the code to handle that special case [9]. jz 9f // the code to handle that special case [9].
/* High word of b is known to be non-zero on this branch */ // High word of b is known to be non-zero on this branch
movl 16(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b movl 16(%esp), %eax // Construct bhi, containing bits [1+i:32+i] of b
shrl %cl, %eax // Practically, this means that bhi is given by: shrl %cl, %eax // Practically, this means that bhi is given by:
shrl %eax // shrl %eax //
notl %ecx // bhi = (high word of b) << (31 - i) | notl %ecx // bhi = (high word of b) << (31 - i) |
shll %cl, %ebx // (low word of b) >> (1 + i) shll %cl, %ebx // (low word of b) >> (1 + i)
orl %eax, %ebx // orl %eax, %ebx //
movl 12(%esp), %edx // Load the high and low words of a, and jump movl 12(%esp), %edx // Load the high and low words of a, and jump
movl 8(%esp), %eax // to [2] if the high word is larger than bhi movl 8(%esp), %eax // to [2] if the high word is larger than bhi
cmpl %ebx, %edx // to avoid overflowing the upcoming divide. cmpl %ebx, %edx // to avoid overflowing the upcoming divide.
jae 2f jae 2f
/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ // High word of a is greater than or equal to (b >> (1 + i)) on this branch
divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r divl %ebx // eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
pushl %edi pushl %edi
notl %ecx notl %ecx
shrl %eax shrl %eax
shrl %cl, %eax // q = qs >> (1 + i) shrl %cl, %eax // q = qs >> (1 + i)
movl %eax, %edi movl %eax, %edi
mull 20(%esp) // q*blo mull 20(%esp) // q*blo
movl 12(%esp), %ebx movl 12(%esp), %ebx
movl 16(%esp), %ecx // ECX:EBX = a movl 16(%esp), %ecx // ECX:EBX = a
subl %eax, %ebx subl %eax, %ebx
sbbl %edx, %ecx // ECX:EBX = a - q*blo sbbl %edx, %ecx // ECX:EBX = a - q*blo
movl 24(%esp), %eax movl 24(%esp), %eax
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
jnc 1f // if positive, this is the result. jnc 1f // if positive, this is the result.
addl 20(%esp), %ebx // otherwise addl 20(%esp), %ebx // otherwise
adcl 24(%esp), %ecx // ECX:EBX = a - (q-1)*b = result adcl 24(%esp), %ecx // ECX:EBX = a - (q-1)*b = result
1: movl %ebx, %eax 1: movl %ebx, %eax
movl %ecx, %edx movl %ecx, %edx
popl %edi popl %edi
popl %ebx popl %ebx
retl retl
2: /* High word of a is greater than or equal to (b >> (1 + i)) on this branch */ 2: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
subl %ebx, %edx // subtract bhi from ahi so that divide will not subl %ebx, %edx // subtract bhi from ahi so that divide will not
divl %ebx // overflow, and find q and r such that divl %ebx // overflow, and find q and r such that
// //
// ahi:alo = (1:q)*bhi + r // ahi:alo = (1:q)*bhi + r
// //
// Note that q is a number in (31-i).(1+i) // Note that q is a number in (31-i).(1+i)
// fix point. // fix point.
Show All 12 Lines2: // High word of a is greater than or equal to (b >> (1 + i)) on this branch
imull %edi, %eax // q*bhi imull %edi, %eax // q*bhi
subl %eax, %ecx // ECX:EBX = a - q*b subl %eax, %ecx // ECX:EBX = a - q*b
jnc 3f // if positive, this is the result. jnc 3f // if positive, this is the result.
addl 20(%esp), %ebx // otherwise addl 20(%esp), %ebx // otherwise
adcl 24(%esp), %ecx // ECX:EBX = a - (q-1)*b = result adcl 24(%esp), %ecx // ECX:EBX = a - (q-1)*b = result
3: movl %ebx, %eax 3: movl %ebx, %eax
movl %ecx, %edx movl %ecx, %edx
popl %edi popl %edi
popl %ebx popl %ebx
retl retl
9: /* High word of b is zero on this branch */ 9: // High word of b is zero on this branch
movl 12(%esp), %eax // Find qhi and rhi such that movl 12(%esp), %eax // Find qhi and rhi such that
movl 16(%esp), %ecx // movl 16(%esp), %ecx //
xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b xorl %edx, %edx // ahi = qhi*b + rhi with 0 ≤ rhi < b
divl %ecx // divl %ecx //
movl %eax, %ebx // movl %eax, %ebx //
movl 8(%esp), %eax // Find rlo such that movl 8(%esp), %eax // Find rlo such that
divl %ecx // divl %ecx //
movl %edx, %eax // rhi:alo = qlo*b + rlo with 0 ≤ rlo < b movl %edx, %eax // rhi:alo = qlo*b + rlo with 0 ≤ rlo < b
popl %ebx // popl %ebx //
xorl %edx, %edx // and return 0:rlo xorl %edx, %edx // and return 0:rlo
retl // retl //
END_COMPILERRT_FUNCTION(__umoddi3) END_COMPILERRT_FUNCTION(__umoddi3)
#endif // __i386__ #endif // __i386__
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/int_endianness.h

/* ===-- int_endianness.h - configuration header for compiler-rt ------------=== //===-- int_endianness.h - configuration header for compiler-rt -----------===//
* //
* 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 a configuration header for compiler-rt. // This file is a configuration header for compiler-rt.
* 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

lib/builtins/int_lib.h

/* ===-- int_lib.h - configuration header for compiler-rt -----------------=== //===-- int_lib.h - configuration header for compiler-rt -----------------===//
* //
* 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 a configuration header for compiler-rt. // This file is a configuration header for compiler-rt.
* This file is not part of the interface of this library. // This file is not part of the interface of this library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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) \ #define FNALIAS(alias, name) \
_Pragma("GCC error(\"alias unsupported on this file format\")") _Pragma("GCC error(\"alias unsupported on this file format\")")
#define COMPILER_RT_ALIAS(aliasee) \ #define COMPILER_RT_ALIAS(aliasee) \
_Pragma("GCC error(\"alias unsupported on this file format\")") _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
Show All 10 Lines
#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 <float.h>
#include <limits.h> #include <limits.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.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;
if (_BitScanForward(&trailing_zero, value)) if (_BitScanForward(&trailing_zero, value))
return trailing_zero; return trailing_zero;
return 32; return 32;
Show All 21 Linesuint32_t __inline __builtin_clzll(uint64_t value) {
uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF); uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF);
if (msh != 0) if (msh != 0)
return __builtin_clz(msh); return __builtin_clz(msh);
return 32 + __builtin_clz(lsh); return 32 + __builtin_clz(lsh);
} }
#endif #endif
#define __builtin_clzl __builtin_clzll #define __builtin_clzl __builtin_clzll
#endif /* defined(_MSC_VER) && !defined(__clang__) */ #endif // defined(_MSC_VER) && !defined(__clang__)
#endif /* INT_LIB_H */ #endif // INT_LIB_H

lib/builtins/int_math.h

/* ===-- int_math.h - internal math inlines ---------------------------------=== //===-- int_math.h - internal math inlines --------------------------------===//
* //
* 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 not part of the interface of this library. // This file is not part of the interface of this library.
* //
* This file defines substitutes for the libm functions used in some of the // This file defines substitutes for the libm functions used in some of the
* compiler-rt implementations, defined in such a way that there is not a direct // compiler-rt implementations, defined in such a way that there is not a direct
* dependency on libm or math.h. Instead, we use the compiler builtin versions // dependency on libm or math.h. Instead, we use the compiler builtin versions
* where available. This reduces our dependencies on the system SDK by foisting // where available. This reduces our dependencies on the system SDK by foisting
* the responsibility onto the compiler. // the responsibility onto the compiler.
* //
* ===-----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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))
#define crt_copysignl(x, y) copysignl((x), (y)) #define crt_copysignl(x, y) copysignl((x), (y))
#else #else
#define crt_copysign(x, y) __builtin_copysign((x), (y)) #define crt_copysign(x, y) __builtin_copysign((x), (y))
#define crt_copysignf(x, y) __builtin_copysignf((x), (y)) #define crt_copysignf(x, y) __builtin_copysignf((x), (y))
Show All 31 Lines
#define crt_scalbnf(x, y) scalbnf((x), (y)) #define crt_scalbnf(x, y) scalbnf((x), (y))
#define crt_scalbnl(x, y) scalbnl((x), (y)) #define crt_scalbnl(x, y) scalbnl((x), (y))
#else #else
#define crt_scalbn(x, y) __builtin_scalbn((x), (y)) #define crt_scalbn(x, y) __builtin_scalbn((x), (y))
#define crt_scalbnf(x, y) __builtin_scalbnf((x), (y)) #define crt_scalbnf(x, y) __builtin_scalbnf((x), (y))
#define crt_scalbnl(x, y) __builtin_scalbnl((x), (y)) #define crt_scalbnl(x, y) __builtin_scalbnl((x), (y))
#endif #endif
#endif /* INT_MATH_H */ #endif // INT_MATH_H

lib/builtins/int_types.h

/* ===-- int_lib.h - configuration header for compiler-rt -----------------=== //===-- int_lib.h - configuration header for compiler-rt -----------------===//
* //
* 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 not part of the interface of this library. // This file is not part of the interface of this library.
* //
* This file defines various standard types, most importantly a number of unions // This file defines various standard types, most importantly a number of unions
* used to access parts of larger types. // used to access parts of larger types.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef INT_TYPES_H #ifndef INT_TYPES_H
#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 {
Show All 19 Lines
typedef struct { typedef struct {
long double real, imaginary; long double real, imaginary;
} Lcomplex; } 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

lib/builtins/int_util.h

/* ===-- int_util.h - internal utility functions ----------------------------=== //===-- int_util.h - internal utility functions ---------------------------===//
* //
* 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 not part of the interface of this library. // This file is not part of the interface of this library.
* //
* This file defines non-inline utilities which are available for use in the // This file defines non-inline utilities which are available for use in the
* library. The function definitions themselves are all contained in int_util.c // library. The function definitions themselves are all contained in int_util.c
* which will always be compiled into any compiler-rt library. // which will always be compiled into any compiler-rt library.
* //
* ===-----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifndef INT_UTIL_H #ifndef INT_UTIL_H
#define INT_UTIL_H #define INT_UTIL_H
/** \brief Trigger a program abort (or panic for kernel code). */ /// \brief Trigger a program abort (or panic for kernel code).
#define compilerrt_abort() __compilerrt_abort_impl(__FILE__, __LINE__, __func__) #define compilerrt_abort() __compilerrt_abort_impl(__FILE__, __LINE__, __func__)
NORETURN void __compilerrt_abort_impl(const char *file, int line, NORETURN void __compilerrt_abort_impl(const char *file, int line,
const char *function); const char *function);
#define COMPILE_TIME_ASSERT(expr) COMPILE_TIME_ASSERT1(expr, __COUNTER__) #define COMPILE_TIME_ASSERT(expr) COMPILE_TIME_ASSERT1(expr, __COUNTER__)
#define COMPILE_TIME_ASSERT1(expr, cnt) COMPILE_TIME_ASSERT2(expr, cnt) #define COMPILE_TIME_ASSERT1(expr, cnt) COMPILE_TIME_ASSERT2(expr, cnt)
#define COMPILE_TIME_ASSERT2(expr, cnt) \ #define COMPILE_TIME_ASSERT2(expr, cnt) \
typedef char ct_assert_##cnt[(expr) ? 1 : -1] UNUSED typedef char ct_assert_##cnt[(expr) ? 1 : -1] UNUSED
#endif /* INT_UTIL_H */ #endif // INT_UTIL_H

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"
/* 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
* packaged into a single library. // packaged into a single library.
*/
#ifdef KERNEL_USE #ifdef KERNEL_USE
NORETURN extern void panic(const char *, ...); NORETURN extern void panic(const char *, ...);
#ifndef _WIN32 #ifndef _WIN32
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden")))
#endif #endif
void __compilerrt_abort_impl(const char *file, int line, const char *function) { void __compilerrt_abort_impl(const char *file, int line, const char *function) {
panic("%s:%d: abort in %s", file, line, function); panic("%s:%d: abort in %s", file, line, function);
} }
#elif __APPLE__ #elif __APPLE__
/* from libSystem.dylib */ // from libSystem.dylib
NORETURN extern void __assert_rtn(const char *func, const char *file, int line, NORETURN extern void __assert_rtn(const char *func, const char *file, int line,
const char *message); const char *message);
#ifndef _WIN32 #ifndef _WIN32
__attribute__((weak)) __attribute__((weak))
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden")))
#endif #endif
void __compilerrt_abort_impl(const char *file, int line, const char *function) { void __compilerrt_abort_impl(const char *file, int line, const char *function) {
__assert_rtn(function, file, line, "libcompiler_rt abort"); __assert_rtn(function, file, line, "libcompiler_rt abort");
} }
#elif __Fuchsia__ #elif __Fuchsia__
#ifndef _WIN32 #ifndef _WIN32
__attribute__((weak)) __attribute__((weak))
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden")))
#endif #endif
void __compilerrt_abort_impl(const char *file, int line, const char *function) { void __compilerrt_abort_impl(const char *file, int line, const char *function) {
__builtin_trap(); __builtin_trap();
} }
#else #else
/* Get the system definition of abort() */ // Get the system definition of abort()
#include <stdlib.h> #include <stdlib.h>
#ifndef _WIN32 #ifndef _WIN32
__attribute__((weak)) __attribute__((weak))
__attribute__((visibility("hidden"))) __attribute__((visibility("hidden")))
#endif #endif
void __compilerrt_abort_impl(const char *file, int line, const char *function) { void __compilerrt_abort_impl(const char *file, int line, const char *function) {
abort(); abort();
} }
#endif #endif

lib/builtins/lshrdi3.c

/* ===-- lshrdi3.c - Implement __lshrdi3 -----------------------------------=== //===-- lshrdi3.c - Implement __lshrdi3 -----------------------------------===//
* //
* 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 __lshrdi3 for the compiler_rt library. // This file implements __lshrdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __lshrdi3(di_int a, si_int b) { COMPILER_RT_ABI di_int __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) AEABI_RTABI di_int __aeabi_llsr(di_int a, si_int b)
COMPILER_RT_ALIAS(__lshrdi3); COMPILER_RT_ALIAS(__lshrdi3);
#endif #endif

lib/builtins/lshrti3.c

/* ===-- lshrti3.c - Implement __lshrti3 -----------------------------------=== //===-- lshrti3.c - Implement __lshrti3 -----------------------------------===//
* //
* 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 __lshrti3 for the compiler_rt library. // This file implements __lshrti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __lshrti3(ti_int a, si_int b) { COMPILER_RT_ABI ti_int __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

lib/builtins/mingw_fixfloat.c

/* ===-- mingw_fixfloat.c - Wrap int/float conversions for arm/windows -----=== //===-- mingw_fixfloat.c - Wrap int/float conversions for arm/windows -----===//
* //
* 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"
COMPILER_RT_ABI di_int __fixdfdi(double a); COMPILER_RT_ABI di_int __fixdfdi(double a);
COMPILER_RT_ABI di_int __fixsfdi(float a); COMPILER_RT_ABI di_int __fixsfdi(float a);
COMPILER_RT_ABI du_int __fixunsdfdi(double a); COMPILER_RT_ABI du_int __fixunsdfdi(double a);
COMPILER_RT_ABI du_int __fixunssfdi(float a); COMPILER_RT_ABI du_int __fixunssfdi(float a);
COMPILER_RT_ABI double __floatdidf(di_int a); COMPILER_RT_ABI double __floatdidf(di_int a);
Show All 19 Lines

lib/builtins/moddi3.c

/*===-- moddi3.c - Implement __moddi3 -------------------------------------=== //===-- moddi3.c - Implement __moddi3 -------------------------------------===//
* //
* 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 __moddi3 for the compiler_rt library. // This file implements __moddi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ // Returns: a % b
COMPILER_RT_ABI di_int __moddi3(di_int a, di_int b) { COMPILER_RT_ABI di_int __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
} }

lib/builtins/modsi3.c

/* ===-- modsi3.c - Implement __modsi3 -------------------------------------=== //===-- modsi3.c - Implement __modsi3 -------------------------------------===//
* //
* 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 __modsi3 for the compiler_rt library. // This file implements __modsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ // Returns: a % b
COMPILER_RT_ABI si_int __modsi3(si_int a, si_int b) { COMPILER_RT_ABI si_int __modsi3(si_int a, si_int b) {
return a - __divsi3(a, b) * b; return a - __divsi3(a, b) * b;
} }

lib/builtins/modti3.c

/* ===-- modti3.c - Implement __modti3 -------------------------------------=== //===-- modti3.c - Implement __modti3 -------------------------------------===//
* //
* 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 __modti3 for the compiler_rt library. // This file implements __modti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __modti3(ti_int a, ti_int b) { COMPILER_RT_ABI ti_int __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

lib/builtins/muldc3.c

/* ===-- muldc3.c - Implement __muldc3 -------------------------------------=== //===-- muldc3.c - Implement __muldc3 -------------------------------------===//
* //
* 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 __muldc3 for the compiler_rt library. // This file implements __muldc3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __muldc3(double __a, double __b, double __c, COMPILER_RT_ABI Dcomplex __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;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lib/builtins/muldi3.c

/* ===-- muldi3.c - Implement __muldi3 -------------------------------------=== //===-- muldi3.c - Implement __muldi3 -------------------------------------===//
* //
* 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 __muldi3 for the compiler_rt library. // This file implements __muldi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a * b */ // Returns: a * b
static di_int __muldsi3(su_int a, su_int b) { static 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 __muldi3(di_int a, di_int b) { COMPILER_RT_ABI di_int __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

lib/builtins/mulodi4.c

/*===-- mulodi4.c - Implement __mulodi4 -----------------------------------=== //===-- mulodi4.c - Implement __mulodi4 -----------------------------------===//
* //
* 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 __mulodi4 for the compiler_rt library. // This file implements __mulodi4 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulodi4(di_int a, di_int b, int *overflow) { COMPILER_RT_ABI di_int __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) {
Show All 24 Lines

lib/builtins/mulosi4.c

/*===-- mulosi4.c - Implement __mulosi4 -----------------------------------=== //===-- mulosi4.c - Implement __mulosi4 -----------------------------------===//
* //
* 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 __mulosi4 for the compiler_rt library. // This file implements __mulosi4 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulosi4(si_int a, si_int b, int *overflow) { COMPILER_RT_ABI si_int __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) {
Show All 24 Lines

lib/builtins/muloti4.c

/*===-- muloti4.c - Implement __muloti4 -----------------------------------=== //===-- muloti4.c - Implement __muloti4 -----------------------------------===//
* //
* 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 __muloti4 for the compiler_rt library. // This file implements __muloti4 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __muloti4(ti_int a, ti_int b, int *overflow) { COMPILER_RT_ABI ti_int __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) {
Show All 17 Lines 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

lib/builtins/mulsc3.c

/* ===-- mulsc3.c - Implement __mulsc3 -------------------------------------=== //===-- mulsc3.c - Implement __mulsc3 -------------------------------------===//
* //
* 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 __mulsc3 for the compiler_rt library. // This file implements __mulsc3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulsc3(float __a, float __b, float __c, float __d) { COMPILER_RT_ABI Fcomplex __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;
Show All 40 Lines

lib/builtins/multc3.c

/* ===-- multc3.c - Implement __multc3 -------------------------------------=== //===-- multc3.c - Implement __multc3 -------------------------------------===//
* //
* 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 __multc3 for the compiler_rt library. // This file implements __multc3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __multc3(long double a, long double b, COMPILER_RT_ABI long double _Complex __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;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lib/builtins/multi3.c

/* ===-- multi3.c - Implement __multi3 -------------------------------------=== //===-- multi3.c - Implement __multi3 -------------------------------------===//
* //
* 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 __multi3 for the compiler_rt library. // This file implements __multi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
/* Returns: a * b */ // Returns: a * b
static ti_int __mulddi3(du_int a, du_int b) { static 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 __multi3(ti_int a, ti_int b) { COMPILER_RT_ABI ti_int __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

lib/builtins/mulvdi3.c

/*===-- mulvdi3.c - Implement __mulvdi3 -----------------------------------=== //===-- mulvdi3.c - Implement __mulvdi3 -----------------------------------===//
* //
* 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 __mulvdi3 for the compiler_rt library. // This file implements __mulvdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulvdi3(di_int a, di_int b) { COMPILER_RT_ABI di_int __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;
Show All 22 Lines

lib/builtins/mulvsi3.c

/* ===-- mulvsi3.c - Implement __mulvsi3 -----------------------------------=== //===-- mulvsi3.c - Implement __mulvsi3 -----------------------------------===//
* //
* 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 __mulvsi3 for the compiler_rt library. // This file implements __mulvsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulvsi3(si_int a, si_int b) { COMPILER_RT_ABI si_int __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;
Show All 22 Lines

lib/builtins/mulvti3.c

/* ===-- mulvti3.c - Implement __mulvti3 -----------------------------------=== //===-- mulvti3.c - Implement __mulvti3 -----------------------------------===//
* //
* 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 __mulvti3 for the compiler_rt library. // This file implements __mulvti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulvti3(ti_int a, ti_int b) { COMPILER_RT_ABI ti_int __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;
Show All 15 Lines 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

lib/builtins/mulxc3.c

/* ===-- mulxc3.c - Implement __mulxc3 -------------------------------------=== //===-- mulxc3.c - Implement __mulxc3 -------------------------------------===//
* //
* 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 __mulxc3 for the compiler_rt library. // This file implements __mulxc3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __mulxc3(long double __a, long double __b, COMPILER_RT_ABI Lcomplex __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;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lib/builtins/negdi2.c

/* ===-- negdi2.c - Implement __negdi2 -------------------------------------=== //===-- negdi2.c - Implement __negdi2 -------------------------------------===//
* //
* 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 __negdi2 for the compiler_rt library. // This file implements __negdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: -a */ // Returns: -a
COMPILER_RT_ABI di_int __negdi2(di_int a) { COMPILER_RT_ABI di_int __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;
} }

lib/builtins/negti2.c

/* ===-- negti2.c - Implement __negti2 -------------------------------------=== //===-- negti2.c - Implement __negti2 -------------------------------------===//
* //
* 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 __negti2 for the compiler_rt library. // This file implements __negti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __negti2(ti_int a) { COMPILER_RT_ABI ti_int __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

lib/builtins/negvdi2.c

/* ===-- negvdi2.c - Implement __negvdi2 -----------------------------------=== //===-- negvdi2.c - Implement __negvdi2 -----------------------------------===//
* //
* 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 __negvdi2 for the compiler_rt library. // This file implements __negvdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __negvdi2(di_int a) { COMPILER_RT_ABI di_int __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;
} }

lib/builtins/negvsi2.c

/* ===-- negvsi2.c - Implement __negvsi2 -----------------------------------=== //===-- negvsi2.c - Implement __negvsi2 -----------------------------------===//
* //
* 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 __negvsi2 for the compiler_rt library. // This file implements __negvsi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __negvsi2(si_int a) { COMPILER_RT_ABI si_int __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;
} }

lib/builtins/negvti2.c

/*===-- negvti2.c - Implement __negvti2 -----------------------------------=== //===-- negvti2.c - Implement __negvti2 -----------------------------------===//
* //
* 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 __negvti2 for the compiler_rt library. // This file implements __negvti2 for the compiler_rt library.
* //
*===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __negvti2(ti_int a) { COMPILER_RT_ABI ti_int __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

lib/builtins/os_version_check.c

/* ===-- os_version_check.c - OS version checking -------------------------=== //===-- os_version_check.c - OS version checking -------------------------===//
* //
* 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 the function __isOSVersionAtLeast, used by // This file implements the function __isOSVersionAtLeast, used by
* Objective-C's @available // Objective-C's @available
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#ifdef __APPLE__ #ifdef __APPLE__
#include <TargetConditionals.h> #include <TargetConditionals.h>
#include <dispatch/dispatch.h> #include <dispatch/dispatch.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
/* 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;
typedef signed long CFIndex; typedef signed long CFIndex;
#endif #endif
typedef unsigned char UInt8; typedef unsigned char UInt8;
typedef _Bool Boolean; typedef _Bool Boolean;
typedef CFIndex CFPropertyListFormat; typedef CFIndex CFPropertyListFormat;
typedef uint32_t CFStringEncoding; typedef uint32_t CFStringEncoding;
/* kCFStringEncodingASCII analog. */ // kCFStringEncodingASCII analog.
#define CF_STRING_ENCODING_ASCII 0x0600 #define CF_STRING_ENCODING_ASCII 0x0600
/* kCFStringEncodingUTF8 analog. */ // kCFStringEncodingUTF8 analog.
#define CF_STRING_ENCODING_UTF8 0x08000100 #define CF_STRING_ENCODING_UTF8 0x08000100
#define CF_PROPERTY_LIST_IMMUTABLE 0 #define CF_PROPERTY_LIST_IMMUTABLE 0
typedef CFDataRef (*CFDataCreateWithBytesNoCopyFuncTy)(CFAllocatorRef, typedef CFDataRef (*CFDataCreateWithBytesNoCopyFuncTy)(CFAllocatorRef,
const UInt8 *, CFIndex, const UInt8 *, CFIndex,
CFAllocatorRef); CFAllocatorRef);
typedef CFPropertyListRef (*CFPropertyListCreateWithDataFuncTy)( typedef CFPropertyListRef (*CFPropertyListCreateWithDataFuncTy)(
CFAllocatorRef, CFDataRef, CFOptionFlags, CFPropertyListFormat *, CFAllocatorRef, CFDataRef, CFOptionFlags, CFPropertyListFormat *,
CFErrorRef *); CFErrorRef *);
typedef CFPropertyListRef (*CFPropertyListCreateFromXMLDataFuncTy)( typedef CFPropertyListRef (*CFPropertyListCreateFromXMLDataFuncTy)(
CFAllocatorRef, CFDataRef, CFOptionFlags, CFStringRef *); CFAllocatorRef, CFDataRef, CFOptionFlags, CFStringRef *);
typedef CFStringRef (*CFStringCreateWithCStringNoCopyFuncTy)(CFAllocatorRef, typedef CFStringRef (*CFStringCreateWithCStringNoCopyFuncTy)(CFAllocatorRef,
const char *, const char *,
CFStringEncoding, CFStringEncoding,
CFAllocatorRef); CFAllocatorRef);
typedef const void *(*CFDictionaryGetValueFuncTy)(CFDictionaryRef, typedef const void *(*CFDictionaryGetValueFuncTy)(CFDictionaryRef,
const void *); const void *);
typedef CFTypeID (*CFGetTypeIDFuncTy)(CFTypeRef); typedef CFTypeID (*CFGetTypeIDFuncTy)(CFTypeRef);
typedef CFTypeID (*CFStringGetTypeIDFuncTy)(void); typedef CFTypeID (*CFStringGetTypeIDFuncTy)(void);
typedef Boolean (*CFStringGetCStringFuncTy)(CFStringRef, char *, CFIndex, typedef Boolean (*CFStringGetCStringFuncTy)(CFStringRef, char *, CFIndex,
CFStringEncoding); CFStringEncoding);
typedef void (*CFReleaseFuncTy)(CFTypeRef); typedef void (*CFReleaseFuncTy)(CFTypeRef);
/* Find and parse the SystemVersion.plist file. */ // Find and parse the SystemVersion.plist file.
static void parseSystemVersionPList(void *Unused) { static void parseSystemVersionPList(void *Unused) {
(void)Unused; (void)Unused;
/* Load CoreFoundation dynamically */ // Load CoreFoundation dynamically
const void *NullAllocator = dlsym(RTLD_DEFAULT, "kCFAllocatorNull"); const void *NullAllocator = dlsym(RTLD_DEFAULT, "kCFAllocatorNull");
if (!NullAllocator) 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(RTLD_DEFAULT, (CFPropertyListCreateWithDataFuncTy)dlsym(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
/* CFPropertyListCreateFromXMLDataFunc is deprecated in macOS 10.10, so it // CFPropertyListCreateFromXMLDataFunc is deprecated in macOS 10.10, so it
* might be NULL in future OS versions. */ // might be NULL in future OS versions.
if (!CFPropertyListCreateWithDataFunc && !CFPropertyListCreateFromXMLDataFunc) if (!CFPropertyListCreateWithDataFunc && !CFPropertyListCreateFromXMLDataFunc)
return; return;
CFStringCreateWithCStringNoCopyFuncTy CFStringCreateWithCStringNoCopyFunc = CFStringCreateWithCStringNoCopyFuncTy CFStringCreateWithCStringNoCopyFunc =
(CFStringCreateWithCStringNoCopyFuncTy)dlsym( (CFStringCreateWithCStringNoCopyFuncTy)dlsym(
RTLD_DEFAULT, "CFStringCreateWithCStringNoCopy"); RTLD_DEFAULT, "CFStringCreateWithCStringNoCopy");
if (!CFStringCreateWithCStringNoCopyFunc) if (!CFStringCreateWithCStringNoCopyFunc)
return; return;
CFDictionaryGetValueFuncTy CFDictionaryGetValueFunc = CFDictionaryGetValueFuncTy CFDictionaryGetValueFunc =
Show All 27 Lines#if TARGET_OS_SIMULATOR
strcpy(FullPath, PListPathPrefix); strcpy(FullPath, PListPathPrefix);
strcat(FullPath, PListPath); strcat(FullPath, PListPath);
PListPath = FullPath; PListPath = FullPath;
#endif #endif
FILE *PropertyList = fopen(PListPath, "r"); FILE *PropertyList = fopen(PListPath, "r");
if (!PropertyList) if (!PropertyList)
return; return;
/* Dynamically allocated stuff. */ // Dynamically allocated stuff.
CFDictionaryRef PListRef = NULL; CFDictionaryRef PListRef = NULL;
CFDataRef FileContentsRef = NULL; CFDataRef FileContentsRef = NULL;
UInt8 *PListBuf = NULL; UInt8 *PListBuf = NULL;
fseek(PropertyList, 0, SEEK_END); fseek(PropertyList, 0, SEEK_END);
long PListFileSize = ftell(PropertyList); long PListFileSize = ftell(PropertyList);
if (PListFileSize < 0) if (PListFileSize < 0)
goto Fail; goto Fail;
rewind(PropertyList); rewind(PropertyList);
PListBuf = malloc((size_t)PListFileSize); PListBuf = malloc((size_t)PListFileSize);
if (!PListBuf) if (!PListBuf)
goto Fail; goto Fail;
size_t NumRead = fread(PListBuf, 1, (size_t)PListFileSize, PropertyList); size_t NumRead = fread(PListBuf, 1, (size_t)PListFileSize, PropertyList);
if (NumRead != (size_t)PListFileSize) if (NumRead != (size_t)PListFileSize)
goto Fail; goto Fail;
/* Get the file buffer into CF's format. We pass in a null allocator here * // Get the file buffer into CF's format. We pass in a null allocator here *
* because we free PListBuf ourselves */ // because we free PListBuf ourselves
FileContentsRef = (*CFDataCreateWithBytesNoCopyFunc)( FileContentsRef = (*CFDataCreateWithBytesNoCopyFunc)(
NULL, PListBuf, (CFIndex)NumRead, AllocatorNull); NULL, PListBuf, (CFIndex)NumRead, AllocatorNull);
if (!FileContentsRef) if (!FileContentsRef)
goto Fail; goto Fail;
if (CFPropertyListCreateWithDataFunc) if (CFPropertyListCreateWithDataFunc)
PListRef = (*CFPropertyListCreateWithDataFunc)( PListRef = (*CFPropertyListCreateWithDataFunc)(
NULL, FileContentsRef, CF_PROPERTY_LIST_IMMUTABLE, NULL, NULL); NULL, FileContentsRef, CF_PROPERTY_LIST_IMMUTABLE, NULL, NULL);
Show All 24 Lines if (PListRef)
(*CFReleaseFunc)(PListRef); (*CFReleaseFunc)(PListRef);
if (FileContentsRef) if (FileContentsRef)
(*CFReleaseFunc)(FileContentsRef); (*CFReleaseFunc)(FileContentsRef);
free(PListBuf); free(PListBuf);
fclose(PropertyList); fclose(PropertyList);
} }
int32_t __isOSVersionAtLeast(int32_t Major, int32_t Minor, int32_t Subminor) { int32_t __isOSVersionAtLeast(int32_t Major, int32_t Minor, int32_t Subminor) {
/* Populate the global version variables, if they haven't already. */ // Populate the global version variables, if they haven't already.
dispatch_once_f(&DispatchOnceCounter, NULL, parseSystemVersionPList); dispatch_once_f(&DispatchOnceCounter, NULL, parseSystemVersionPList);
if (Major < GlobalMajor) if (Major < GlobalMajor)
return 1; return 1;
if (Major > GlobalMajor) if (Major > GlobalMajor)
return 0; return 0;
if (Minor < GlobalMinor) if (Minor < GlobalMinor)
return 1; return 1;
if (Minor > GlobalMinor) if (Minor > GlobalMinor)
return 0; return 0;
return Subminor <= GlobalSubminor; return Subminor <= GlobalSubminor;
} }
#else #else
/* Silence an empty translation unit warning. */ // Silence an empty translation unit warning.
typedef int unused; typedef int unused;
#endif #endif

lib/builtins/paritydi2.c

/* ===-- paritydi2.c - Implement __paritydi2 -------------------------------=== //===-- paritydi2.c - Implement __paritydi2 -------------------------------===//
* //
* 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 __paritydi2 for the compiler_rt library. // This file implements __paritydi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __paritydi2(di_int a) { COMPILER_RT_ABI si_int __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);
} }

lib/builtins/paritysi2.c

/* ===-- paritysi2.c - Implement __paritysi2 -------------------------------=== //===-- paritysi2.c - Implement __paritysi2 -------------------------------===//
* //
* 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 __paritysi2 for the compiler_rt library. // This file implements __paritysi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __paritysi2(si_int a) { COMPILER_RT_ABI si_int __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;
} }

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 __parityti2(ti_int a) { COMPILER_RT_ABI si_int __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

lib/builtins/popcountdi2.c

/* ===-- popcountdi2.c - Implement __popcountdi2 ----------------------------=== //===-- popcountdi2.c - Implement __popcountdi2 ---------------------------===//
* //
* 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 __popcountdi2 for the compiler_rt library. // This file implements __popcountdi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: count of 1 bits */ // Returns: count of 1 bits
COMPILER_RT_ABI si_int __popcountdi2(di_int a) { COMPILER_RT_ABI si_int __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)
} }

lib/builtins/popcountsi2.c

/* ===-- popcountsi2.c - Implement __popcountsi2 ---------------------------=== //===-- popcountsi2.c - Implement __popcountsi2 ---------------------------===//
* //
* 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 __popcountsi2 for the compiler_rt library. // This file implements __popcountsi2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: count of 1 bits */ // Returns: count of 1 bits
COMPILER_RT_ABI si_int __popcountsi2(si_int a) { COMPILER_RT_ABI si_int __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)
} }

lib/builtins/popcountti2.c

/* ===-- popcountti2.c - Implement __popcountti2 ----------------------------=== //===-- popcountti2.c - Implement __popcountti2
* //----------------------------===//
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. //
* See https://llvm.org/LICENSE.txt for license information. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // See https://llvm.org/LICENSE.txt for license information.
* // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* ===----------------------------------------------------------------------=== //
* //===----------------------------------------------------------------------===//
* This file implements __popcountti2 for the compiler_rt library. //
* // This file implements __popcountti2 for the compiler_rt library.
* ===----------------------------------------------------------------------=== //
*/ //===----------------------------------------------------------------------===//
#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 __popcountti2(ti_int a) { COMPILER_RT_ABI si_int __popcountti2(ti_int a) {
tu_int x3 = (tu_int)a; tu_int x3 = (tu_int)a;
x3 = x3 - ((x3 >> 1) & x3 = x3 - ((x3 >> 1) &
(((tu_int)0x5555555555555555uLL << 64) | 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) & x3 = ((x3 >> 2) &
(((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)) + (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)) +
(x3 & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)); (x3 & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL));
/* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (32) // Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (32)
*/
x3 = (x3 + (x3 >> 4)) & x3 = (x3 + (x3 >> 4)) &
(((tu_int)0x0F0F0F0F0F0F0F0FuLL << 64) | 0x0F0F0F0F0F0F0F0FuLL); (((tu_int)0x0F0F0F0F0F0F0F0FuLL << 64) | 0x0F0F0F0F0F0F0F0FuLL);
/* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (16) // 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

lib/builtins/powidf2.c

/* ===-- powidf2.cpp - Implement __powidf2 ---------------------------------=== //===-- powidf2.cpp - Implement __powidf2 ---------------------------------===//
* //
* 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 __powidf2 for the compiler_rt library. // This file implements __powidf2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a ^ b */ // Returns: a ^ b
COMPILER_RT_ABI double __powidf2(double a, si_int b) { COMPILER_RT_ABI double __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;
} }

lib/builtins/powisf2.c

/*===-- powisf2.cpp - Implement __powisf2 ---------------------------------=== //===-- powisf2.cpp - Implement __powisf2 ---------------------------------===//
* //
* 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 __powisf2 for the compiler_rt library. // This file implements __powisf2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a ^ b */ // Returns: a ^ b
COMPILER_RT_ABI float __powisf2(float a, si_int b) { COMPILER_RT_ABI float __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;
} }

lib/builtins/powitf2.c

/* ===-- powitf2.cpp - Implement __powitf2 ---------------------------------=== //===-- powitf2.cpp - Implement __powitf2 ---------------------------------===//
* //
* 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 __powitf2 for the compiler_rt library. // This file implements __powitf2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __powitf2(long double a, si_int b) { COMPILER_RT_ABI long double __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

lib/builtins/powixf2.c

/* ===-- powixf2.cpp - Implement __powixf2 ---------------------------------=== //===-- powixf2.cpp - Implement __powixf2 ---------------------------------===//
* //
* 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 __powixf2 for the compiler_rt library. // This file implements __powixf2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __powixf2(long double a, si_int b) { COMPILER_RT_ABI long double __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

lib/builtins/ppc/DD.h

Show All 36 Linesstatic __inline ALWAYS_INLINE int different_sign(double x, double y) {
return result; return result;
} }
long double __gcc_qadd(long double, long double); long double __gcc_qadd(long double, long double);
long double __gcc_qsub(long double, long double); long double __gcc_qsub(long double, long double);
long double __gcc_qmul(long double, long double); long double __gcc_qmul(long double, long double);
long double __gcc_qdiv(long double, long double); long double __gcc_qdiv(long double, long double);
#endif /* COMPILERRT_DD_HEADER */ #endif // COMPILERRT_DD_HEADER

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 "../int_math.h" #include "../int_math.h"
#include "DD.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 __divtc3(long double a, long double b, long double c, long double _Complex __divtc3(long double a, long double b, long double c,
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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 "../int_math.h" #include "../int_math.h"
#include "DD.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 = const uint32_t absHighWord =
(uint32_t)(hibits.x >> 32) & UINT32_C(0x7fffffff); (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 >>= tailMantissa >>=
(unbiasedHeadExponent - (biasedTailExponent - (1023 - 10))); (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. we'll need to figure out what it is. // INT64_MIN. 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;
} }

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 = const uint32_t highWordMinusOne =
(uint32_t)(hibits.x >> 32) - UINT32_C(0x3ff00000); (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 = uint64_t result = hibits.x & UINT64_C(0x000fffffffffffff); // mantissa(hi)
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 >>= tailMantissa >>=
(unbiasedHeadExponent - (biasedTailExponent - (1023 - 11))); (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;
} }

lib/builtins/ppc/fixunstfti.c

//===-- lib/builtins/ppc/fixunstfti.c - Convert long double->int128 *-C -*-===// //===-- lib/builtins/ppc/fixunstfti.c - Convert long double->int128 *-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 converting the 128bit IBM/PowerPC long double (double- // This file implements converting the 128bit IBM/PowerPC long double (double-
// double) data type to an unsigned 128 bit integer. // double) data type to an unsigned 128 bit integer.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../int_math.h" #include "../int_math.h"
#define BIAS 1023 #define BIAS 1023
/* Convert long double into an unsigned 128-bit integer. */ // Convert long double into an unsigned 128-bit integer.
__uint128_t __fixunstfti(long double input) { __uint128_t __fixunstfti(long double input) {
/* If we are trying to convert a NaN, return the NaN bit pattern. */ // If we are trying to convert a NaN, return the NaN bit pattern.
if (crt_isnan(input)) { if (crt_isnan(input)) {
return ((__uint128_t)0x7FF8000000000000ll) << 64 | return ((__uint128_t)0x7FF8000000000000ll) << 64 |
(__uint128_t)0x0000000000000000ll; (__uint128_t)0x0000000000000000ll;
} }
__uint128_t result, hiResult, loResult; __uint128_t result, hiResult, loResult;
int hiExponent, loExponent, shift; int hiExponent, loExponent, shift;
/* The long double representation, with the high and low portions of // The long double representation, with the high and low portions of
* the long double, and the corresponding bit patterns of each double. */ // the long double, and the corresponding bit patterns of each double.
union { union {
long double ld; long double ld;
double d[2]; /* [0] is the high double, [1] is the low double. */ double d[2]; // [0] is the high double, [1] is the low double.
unsigned long long ull[2]; /* High and low doubles as 64-bit integers. */ unsigned long long ull[2]; // High and low doubles as 64-bit integers.
} ldUnion; } ldUnion;
/* If the long double is less than 1.0 or negative, // If the long double is less than 1.0 or negative,
* return 0.0. */ // return 0.0.
if (input < 1.0) if (input < 1.0)
return 0.0; return 0.0;
/* Retrieve the 64-bit patterns of high and low doubles. // Retrieve the 64-bit patterns of high and low doubles.
* Compute the unbiased exponent of both high and low doubles by // Compute the unbiased exponent of both high and low doubles by
* removing the signs, isolating the exponent, and subtracting // removing the signs, isolating the exponent, and subtracting
* the bias from it. */ // the bias from it.
ldUnion.ld = input; ldUnion.ld = input;
hiExponent = ((ldUnion.ull[0] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS; hiExponent = ((ldUnion.ull[0] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
loExponent = ((ldUnion.ull[1] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS; loExponent = ((ldUnion.ull[1] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
/* Convert each double into int64; they will be added to the int128 result. // Convert each double into int64; they will be added to the int128 result.
* CASE 1: High or low double fits in int64 // CASE 1: High or low double fits in int64
* - Convert the each double normally into int64. // - Convert the each double normally into int64.
* //
* CASE 2: High or low double does not fit in int64 // CASE 2: High or low double does not fit in int64
* - Scale the double to fit within a 64-bit integer // - Scale the double to fit within a 64-bit integer
* - Calculate the shift (amount to scale the double by in the int128) // - Calculate the shift (amount to scale the double by in the int128)
* - Clear all the bits of the exponent (with 0x800FFFFFFFFFFFFF) // - Clear all the bits of the exponent (with 0x800FFFFFFFFFFFFF)
* - Add BIAS+53 (0x4350000000000000) to exponent to correct the value // - Add BIAS+53 (0x4350000000000000) to exponent to correct the value
* - Scale (move) the double to the correct place in the int128 // - Scale (move) the double to the correct place in the int128
* (Move it by 2^53 places) // (Move it by 2^53 places)
* //
* Note: If the high double is assumed to be positive, an unsigned conversion // Note: If the high double is assumed to be positive, an unsigned conversion
* from long double to 64-bit integer is needed. The low double can be either // from long double to 64-bit integer is needed. The low double can be either
* positive or negative, so a signed conversion is needed to retain the result // positive or negative, so a signed conversion is needed to retain the result
* of the low double and to ensure it does not simply get converted to 0. */ // of the low double and to ensure it does not simply get converted to 0.
/* CASE 1 - High double fits in int64. */ // CASE 1 - High double fits in int64.
if (hiExponent < 63) { if (hiExponent < 63) {
hiResult = (unsigned long long)ldUnion.d[0]; hiResult = (unsigned long long)ldUnion.d[0];
} else if (hiExponent < 128) { } else if (hiExponent < 128) {
/* CASE 2 - High double does not fit in int64, scale and convert it. */ // CASE 2 - High double does not fit in int64, scale and convert it.
shift = hiExponent - 54; shift = hiExponent - 54;
ldUnion.ull[0] &= 0x800FFFFFFFFFFFFFll; ldUnion.ull[0] &= 0x800FFFFFFFFFFFFFll;
ldUnion.ull[0] |= 0x4350000000000000ll; ldUnion.ull[0] |= 0x4350000000000000ll;
hiResult = (unsigned long long)ldUnion.d[0]; hiResult = (unsigned long long)ldUnion.d[0];
hiResult <<= shift; hiResult <<= shift;
} else { } else {
/* Detect cases for overflow. When the exponent of the high // Detect cases for overflow. When the exponent of the high
* double is greater than 128 bits and when the long double // double is greater than 128 bits and when the long double
* input is positive, return the max 128-bit integer. // input is positive, return the max 128-bit integer.
* For negative inputs with exponents > 128, return 1, like gcc. */ // For negative inputs with exponents > 128, return 1, like gcc.
if (ldUnion.d[0] > 0) { if (ldUnion.d[0] > 0) {
return ((__uint128_t)0xFFFFFFFFFFFFFFFFll) << 64 | return ((__uint128_t)0xFFFFFFFFFFFFFFFFll) << 64 |
(__uint128_t)0xFFFFFFFFFFFFFFFFll; (__uint128_t)0xFFFFFFFFFFFFFFFFll;
} else { } else {
return ((__uint128_t)0x0000000000000000ll) << 64 | return ((__uint128_t)0x0000000000000000ll) << 64 |
(__uint128_t)0x0000000000000001ll; (__uint128_t)0x0000000000000001ll;
} }
} }
/* CASE 1 - Low double fits in int64. */ // CASE 1 - Low double fits in int64.
if (loExponent < 63) { if (loExponent < 63) {
loResult = (long long)ldUnion.d[1]; loResult = (long long)ldUnion.d[1];
} else { } else {
/* CASE 2 - Low double does not fit in int64, scale and convert it. */ // CASE 2 - Low double does not fit in int64, scale and convert it.
shift = loExponent - 54; shift = loExponent - 54;
ldUnion.ull[1] &= 0x800FFFFFFFFFFFFFll; ldUnion.ull[1] &= 0x800FFFFFFFFFFFFFll;
ldUnion.ull[1] |= 0x4350000000000000ll; ldUnion.ull[1] |= 0x4350000000000000ll;
loResult = (long long)ldUnion.d[1]; loResult = (long long)ldUnion.d[1];
loResult <<= shift; loResult <<= shift;
} }
/* Add the high and low doublewords together to form a 128 bit integer. */ // Add the high and low doublewords together to form a 128 bit integer.
result = loResult + hiResult; result = loResult + hiResult;
return result; return result;
} }

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;
} }

lib/builtins/ppc/floattitf.c

//===-- lib/builtins/ppc/floattitf.c - Convert int128->long double -*-C -*-===// //===-- lib/builtins/ppc/floattitf.c - Convert int128->long double -*-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 converting a signed 128 bit integer to a 128bit IBM / // This file implements converting a signed 128 bit integer to a 128bit IBM /
// PowerPC long double (double-double) value. // PowerPC long double (double-double) value.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <stdint.h> #include <stdint.h>
/* Conversions from signed and unsigned 64-bit int to long double. */ // Conversions from signed and unsigned 64-bit int to long double.
long double __floatditf(int64_t); long double __floatditf(int64_t);
long double __floatunditf(uint64_t); long double __floatunditf(uint64_t);
/* Convert a signed 128-bit integer to long double. // Convert a signed 128-bit integer to long double.
* This uses the following property: Let hi and lo be 64-bits each, // This uses the following property: Let hi and lo be 64-bits each,
* and let signed_val_k() and unsigned_val_k() be the value of the // and let signed_val_k() and unsigned_val_k() be the value of the
* argument interpreted as a signed or unsigned k-bit integer. Then, // argument interpreted as a signed or unsigned k-bit integer. Then,
* //
* signed_val_128(hi,lo) = signed_val_64(hi) * 2^64 + unsigned_val_64(lo) // signed_val_128(hi,lo) = signed_val_64(hi) * 2^64 + unsigned_val_64(lo)
* = (long double)hi * 2^64 + (long double)lo, // = (long double)hi * 2^64 + (long double)lo,
* //
* where (long double)hi and (long double)lo are signed and // where (long double)hi and (long double)lo are signed and
* unsigned 64-bit integer to long double conversions, respectively. // unsigned 64-bit integer to long double conversions, respectively.
*/
long double __floattitf(__int128_t arg) { long double __floattitf(__int128_t arg) {
/* Split the int128 argument into 64-bit high and low int64 parts. */ // Split the int128 argument into 64-bit high and low int64 parts.
int64_t ArgHiPart = (int64_t)(arg >> 64); int64_t ArgHiPart = (int64_t)(arg >> 64);
uint64_t ArgLoPart = (uint64_t)arg; uint64_t ArgLoPart = (uint64_t)arg;
/* Convert each 64-bit part into long double. The high part // Convert each 64-bit part into long double. The high part
* must be a signed conversion and the low part an unsigned conversion // must be a signed conversion and the low part an unsigned conversion
* to ensure the correct result. */ // to ensure the correct result.
long double ConvertedHiPart = __floatditf(ArgHiPart); long double ConvertedHiPart = __floatditf(ArgHiPart);
long double ConvertedLoPart = __floatunditf(ArgLoPart); long double ConvertedLoPart = __floatunditf(ArgLoPart);
/* The low bit of ArgHiPart corresponds to the 2^64 bit in arg. // The low bit of ArgHiPart corresponds to the 2^64 bit in arg.
* Multiply the high part by 2^64 to undo the right shift by 64-bits // Multiply the high part by 2^64 to undo the right shift by 64-bits
* done in the splitting. Then, add to the low part to obtain the // done in the splitting. Then, add to the low part to obtain the
* final result. */ // final result.
return ((ConvertedHiPart * 0x1.0p64) + ConvertedLoPart); return ((ConvertedHiPart * 0x1.0p64) + ConvertedLoPart);
} }

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;
} }

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, B = src.s.hi, b = src.s.lo; register double A = dst.s.hi, a = dst.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 // This may be playing things a little bit fast and loose, but it will do for
* a start. */ // 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;
} }
Show All 29 Lines

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, y = src.s.hi, y1 = src.s.lo; register double x = dst.s.hi, x1 = dst.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) {
Show All 22 Lines

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, B = src.s.hi, b = src.s.lo; register double A = dst.s.hi, a = dst.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;
} }

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, B = -src.s.hi, b = -src.s.lo; register double A = dst.s.hi, a = dst.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 // This may be playing things a little bit fast and loose, but it will do for
* a start. */ // 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;
} }
Show All 29 Lines

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 "../int_math.h" #include "../int_math.h"
#include "DD.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; \
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lib/builtins/subvdi3.c

/* ===-- subvdi3.c - Implement __subvdi3 -----------------------------------=== //===-- subvdi3.c - Implement __subvdi3 -----------------------------------===//
* //
* 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 __subvdi3 for the compiler_rt library. // This file implements __subvdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __subvdi3(di_int a, di_int b) { COMPILER_RT_ABI di_int __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;
} }

lib/builtins/subvsi3.c

/* ===-- subvsi3.c - Implement __subvsi3 -----------------------------------=== //===-- subvsi3.c - Implement __subvsi3 -----------------------------------===//
* //
* 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 __subvsi3 for the compiler_rt library. // This file implements __subvsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __subvsi3(si_int a, si_int b) { COMPILER_RT_ABI si_int __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;
} }

lib/builtins/subvti3.c

/* ===-- subvti3.c - Implement __subvti3 -----------------------------------=== //===-- subvti3.c - Implement __subvti3 -----------------------------------===//
* //
* 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 __subvti3 for the compiler_rt library. // This file implements __subvti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __subvti3(ti_int a, ti_int b) { COMPILER_RT_ABI ti_int __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

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 __trampoline_setup(uint32_t *trampOnStack, COMPILER_RT_ABI void __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__)

lib/builtins/ucmpdi2.c

/* ===-- ucmpdi2.c - Implement __ucmpdi2 -----------------------------------=== //===-- ucmpdi2.c - Implement __ucmpdi2 -----------------------------------===//
* //
* 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 __ucmpdi2 for the compiler_rt library. // This file implements __ucmpdi2 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 __ucmpdi2(du_int a, du_int b) { COMPILER_RT_ABI si_int __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 __aeabi_ulcmp(di_int a, di_int b) { COMPILER_RT_ABI si_int __aeabi_ulcmp(di_int a, di_int b) {
return __ucmpdi2(a, b) - 1; return __ucmpdi2(a, b) - 1;
} }
#endif #endif

lib/builtins/ucmpti2.c

/* ===-- ucmpti2.c - Implement __ucmpti2 -----------------------------------=== //===-- ucmpti2.c - Implement __ucmpti2 -----------------------------------===//
* //
* 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 __ucmpti2 for the compiler_rt library. // This file implements __ucmpti2 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
#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 __ucmpti2(tu_int a, tu_int b) { COMPILER_RT_ABI si_int __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

lib/builtins/udivdi3.c

/* ===-- udivdi3.c - Implement __udivdi3 -----------------------------------=== //===-- udivdi3.c - Implement __udivdi3 -----------------------------------===//
* //
* 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 __udivdi3 for the compiler_rt library. // This file implements __udivdi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a / b */ // Returns: a / b
COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b) { COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b) {
return __udivmoddi4(a, b, 0); return __udivmoddi4(a, b, 0);
} }

lib/builtins/udivmoddi4.c

/* ===-- udivmoddi4.c - Implement __udivmoddi4 -----------------------------=== //===-- udivmoddi4.c - Implement __udivmoddi4 -----------------------------===//
* //
* 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 __udivmoddi4 for the compiler_rt library. // This file implements __udivmoddi4 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __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) {
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;
} }

lib/builtins/udivmodsi4.c

/*===-- udivmodsi4.c - Implement __udivmodsi4 ------------------------------=== //===-- udivmodsi4.c - Implement __udivmodsi4 -----------------------------===//
* //
* 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 __udivmodsi4 for the compiler_rt library. // This file implements __udivmodsi4 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __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) {
si_int d = __udivsi3(a, b); si_int d = __udivsi3(a, b);
*rem = a - (d * b); *rem = a - (d * b);
return d; return d;
} }

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 __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) {
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

lib/builtins/udivsi3.c

/* ===-- udivsi3.c - Implement __udivsi3 -----------------------------------=== //===-- udivsi3.c - Implement __udivsi3 -----------------------------------===//
* //
* 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 __udivsi3 for the compiler_rt library. // This file implements __udivsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __udivsi3(su_int n, su_int d) { COMPILER_RT_ABI su_int __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) AEABI_RTABI su_int __aeabi_uidiv(su_int n, su_int d)
COMPILER_RT_ALIAS(__udivsi3); COMPILER_RT_ALIAS(__udivsi3);
#endif #endif

lib/builtins/udivti3.c

/* ===-- udivti3.c - Implement __udivti3 -----------------------------------=== //===-- udivti3.c - Implement __udivti3 -----------------------------------===//
* //
* 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 __udivti3 for the compiler_rt library. // This file implements __udivti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __udivti3(tu_int a, tu_int b) { COMPILER_RT_ABI tu_int __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

lib/builtins/umoddi3.c

/* ===-- umoddi3.c - Implement __umoddi3 -----------------------------------=== //===-- umoddi3.c - Implement __umoddi3 -----------------------------------===//
* //
* 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 __umoddi3 for the compiler_rt library. // This file implements __umoddi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ // Returns: a % b
COMPILER_RT_ABI du_int __umoddi3(du_int a, du_int b) { COMPILER_RT_ABI du_int __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;
} }

lib/builtins/umodsi3.c

/* ===-- umodsi3.c - Implement __umodsi3 -----------------------------------=== //===-- umodsi3.c - Implement __umodsi3 -----------------------------------===//
* //
* 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 __umodsi3 for the compiler_rt library. // This file implements __umodsi3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#include "int_lib.h" #include "int_lib.h"
/* Returns: a % b */ // Returns: a % b
COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b) { COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b) {
return a - __udivsi3(a, b) * b; return a - __udivsi3(a, b) * b;
} }

lib/builtins/umodti3.c

/* ===-- umodti3.c - Implement __umodti3 -----------------------------------=== //===-- umodti3.c - Implement __umodti3 -----------------------------------===//
* //
* 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 __umodti3 for the compiler_rt library. // This file implements __umodti3 for the compiler_rt library.
* //
* ===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===//
*/
#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 __umodti3(tu_int a, tu_int b) { COMPILER_RT_ABI tu_int __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

lib/builtins/unwind-ehabi-helpers.h

/* ===-- arm-ehabi-helpers.h - Supplementary ARM EHABI declarations --------=== //===-- arm-ehabi-helpers.h - Supplementary ARM EHABI declarations --------===//
* //
* 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
* //
* ===--------------------------------------------------------------------=== */ //===--------------------------------------------------------------------===//
#ifndef UNWIND_EHABI_HELPERS_H #ifndef UNWIND_EHABI_HELPERS_H
#define UNWIND_EHABI_HELPERS_H #define UNWIND_EHABI_HELPERS_H
#include <stdint.h> #include <stdint.h>
/* NOTE: see reasoning for this inclusion below */ // NOTE: see reasoning for this inclusion below
#include <unwind.h> #include <unwind.h>
#if !defined(__ARM_EABI_UNWINDER__) #if !defined(__ARM_EABI_UNWINDER__)
/* // NOTE: _URC_OK, _URC_FAILURE must be present as preprocessor tokens. This
* NOTE: _URC_OK, _URC_FAILURE must be present as preprocessor tokens. This // allows for a substitution of a constant which can be cast into the
* allows for a substitution of a constant which can be cast into the // appropriate enumerated type. This header is expected to always be included
* appropriate enumerated type. This header is expected to always be included // AFTER unwind.h (which is why it is forcefully included above). This ensures
* AFTER unwind.h (which is why it is forcefully included above). This ensures // that we do not overwrite the token for the enumeration. Subsequent uses of
* that we do not overwrite the token for the enumeration. Subsequent uses of // the token would be clean to rewrite with constant values.
* the token would be clean to rewrite with constant values. //
* // The typedef redeclaration should be safe. Due to the protection granted to
* The typedef redeclaration should be safe. Due to the protection granted to // us by the `__ARM_EABI_UNWINDER__` above, we are guaranteed that we are in a
* us by the `__ARM_EABI_UNWINDER__` above, we are guaranteed that we are in a // header not vended by gcc. The HP unwinder (being an itanium unwinder) does
* header not vended by gcc. The HP unwinder (being an itanium unwinder) does // not support EHABI, and the GNU unwinder, derived from the HP unwinder, also
* not support EHABI, and the GNU unwinder, derived from the HP unwinder, also // 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)
Show All 9 Lines

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) { return (double)a; } double __floatdidf(int64_t a) { return (double)a; }
#endif /* __x86_64__ */ #endif // __x86_64__

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) { return (float)a; } float __floatdisf(int64_t a) { return (float)a; }
#endif /* __x86_64__ */ #endif // __x86_64__

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) { return (long double)a; } long double __floatdixf(int64_t a) { return (long double)a; }
#endif /* __i386__ */ #endif // __i386__

lib/builtins/x86_64/floatundisf.S

Show All 18 Lines
.text .text
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__floatundisf) DEFINE_COMPILERRT_FUNCTION(__floatundisf)
movq $1, %rsi movq $1, %rsi
testq %rdi, %rdi testq %rdi, %rdi
js 1f js 1f
cvtsi2ssq %rdi, %xmm0 cvtsi2ssq %rdi, %xmm0
ret ret
1: andq %rdi, %rsi 1: andq %rdi, %rsi
shrq %rdi shrq %rdi
orq %rsi, %rdi orq %rsi, %rdi
cvtsi2ssq %rdi, %xmm0 cvtsi2ssq %rdi, %xmm0
mulss REL_ADDR(two), %xmm0 mulss REL_ADDR(two), %xmm0
ret ret
END_COMPILERRT_FUNCTION(__floatundisf) END_COMPILERRT_FUNCTION(__floatundisf)
#endif // __x86_64__ #endif // __x86_64__
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

lib/builtins/x86_64/floatundixf.S

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
.balign 4 .balign 4
DEFINE_COMPILERRT_FUNCTION(__floatundixf) DEFINE_COMPILERRT_FUNCTION(__floatundixf)
movl %edi, %esi // low 32 bits of input movl %edi, %esi // low 32 bits of input
shrq $32, %rdi // hi 32 bits of input shrq $32, %rdi // hi 32 bits of input
orq REL_ADDR(twop84), %rdi // 2^84 + hi (as a double) orq REL_ADDR(twop84), %rdi // 2^84 + hi (as a double)
orq REL_ADDR(twop52), %rsi // 2^52 + lo (as a double) orq REL_ADDR(twop52), %rsi // 2^52 + lo (as a double)
movq %rdi, -8(%rsp) movq %rdi, -8(%rsp)
movq %rsi, -16(%rsp) movq %rsi, -16(%rsp)
fldl REL_ADDR(twop84_plus_twop52_neg) fldl REL_ADDR(twop84_plus_twop52_neg)
faddl -8(%rsp) // hi - 2^52 (as double extended, no rounding occurs) faddl -8(%rsp) // hi - 2^52 (as double extended, no rounding occurs)
faddl -16(%rsp) // hi + lo (as double extended) faddl -16(%rsp) // hi + lo (as double extended)
ret ret
END_COMPILERRT_FUNCTION(__floatundixf) END_COMPILERRT_FUNCTION(__floatundixf)
#endif // __x86_64__ #endif // __x86_64__
*/ */
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE