This is an archive of the discontinued LLVM Phabricator instance.

Differential D84636

[RFC] Make the default LibCall implementations from compiler-rt builtins library more customizable
Needs ReviewPublic

Authored by atrosinenko on Jul 27 2020, 4:50 AM.

Details

Reviewers
asl
howard.hinnant
samsonov
t.p.northover
compnerd
phosek
Summary

Background

  • builtins library from compiler-rt has portable default implementations written in C for all its LibCalls
  • those implementations can be replaced by potentially much efficient target-specific ones when appropriate
  • ideally, one should be able to start with all-default implementations ASAP when adding support for a new target, and then gradually improve it

Problem statement

  • some targets have special requirements on LibCalls:
    • name aliases (see existing ARM-specific aliases, MSP430 requires some as well)
    • seemingly arbitrarily chosen calling conventions (see Section 6.3 of MSP430 EABI document). While they are probably justified by implementation specifics, it is hard to deduce the required convention merely from the signature (harder than just "special iff is LibCall and has two 64-bit arguments")
    • the default implementation (that potentially is already quite elaborate) may perfectly fit all the requirements apart from those tiny configuration details
  • it is worth not to force target implementations to diverge from the upstream ones just to account for such tiny details
  • on the other hand, it is worth to not clobber the generic implementation with a bunch of target-specific defines
  • bonus point: still catching as much errors at compile-time as possible

This proposal

This RFC includes an example implementation.

  • + all adjustments listed above (calling conventions, name aliases) will be contained inside a single target specific header and a couple of lines in int_lib.h that conditionally #include that header
    • + the default LibCall implementations will have O(1) customization-related code per file irrespective of how many targets perform some customizations
  • - has large patch size
    • + is by design a one-time refactoring simplifying adding new targets in the future
    • + can already help factoring out the existing ARM-specific name aliases
    • most of the changes was performed automatically by sed, so they (and their corresponding scripts) can be reviewed separately while spending most of the time on manual changes
  • - has a shell script that may need re-running from time to time
    • it is not required to have bash on every system that will just compile LLVM since the resulting header is expected to be committed to the repository
    • there already exist some scripts under compiler-rt/utils that generate some headers for NetBSD
    • - there is a possibility that someday someone will forget to re-run it
    • + most probably, the only cases when running it is actually required are
      • adding some new LibCall
      • changing the set of parameters (now, there exist two: "calling convention" = "misc attributes" and "name aliases" = "misc footer")
    • + it seems to have much simpler requirements on how to run it than some of those NetBSD-related scripts :)
    • - more real-world mistake would probably be to make a simple change (such as adding one another generic source file) and updating the autogenerated header manually because it was so trivial change, so when the script will be eventually re-run, there would be some unexpected changes
      • + because the script has very weak assumptions on how it should be run, we can just have a test (that requires bash) that ensures that the committed script and the committed header match (something like checking code style by auto-formatting and checking that nothing changes)
  • + when something was made wrong, chances are high it would be caught early
    • declaring a new LibCall via DECLARE_LIBCALL macro without updating the script immediately triggers a compilation error
    • - on the target implementation side, there are no safety nets, so one can easily mistype a LibCall name in a statement like #define AUX_DECLS__ashldi3 ... that would be silently ignored in this approach
      • there is a chance this would be caught by target-specific tests and debugged and fixed early by the same person who is implementing that target's support (at least, when changing calling convention)
      • the most care should probably be taken when reviewing this particular initial implementation, as I have to "import" the existing ARM-specific aliases

Diff Detail

Event Timeline

atrosinenko created this revision.Jul 27 2020, 4:50 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 27 2020, 4:50 AM
Herald added subscribers: Restricted Project, kristof.beyls, krytarowski. · View Herald Transcript
atrosinenko edited the summary of this revision. (Show Details)Jul 27 2020, 4:53 AM
atrosinenko retitled this revision from [WIP] Create infrastructure for customizing the default LibCall implementations to [RFC] Make the default LibCall implementations from compiler-rt builtins library more customizable.
Herald added a subscriber: dberris. · View Herald TranscriptJul 27 2020, 4:54 AM
atrosinenko requested review of this revision.Jul 27 2020, 4:57 AM
atrosinenko added reviewers: compnerd, phosek.
Harbormaster failed remote builds in B65806: Diff 280855!Jul 27 2020, 5:55 AM
atrosinenko mentioned this in D84602: [MSP430] Expose msp430_builtin calling convention to C code.Jul 28 2020, 4:12 AM
atrosinenko edited the summary of this revision. (Show Details)Aug 5 2020, 9:10 AM
atrosinenko added a comment.Aug 5 2020, 9:18 AM

Ping.

aaron.ballman added a subscriber: aaron.ballman.Aug 10 2020, 6:06 AM
aaron.ballman added inline comments.
compiler-rt/lib/builtins/arm-libcall-overrides.h
8

It looks like you're missing a header guard, is that intentional?

atrosinenko added a comment.Aug 10 2020, 7:36 AM

Another note to myself: add AUX_DECLS(__LibCallName) to every generic implementation file. They were forgotten unintentionally.

compiler-rt/lib/builtins/arm-libcall-overrides.h
8

Thanks, there are files such as libcall-set-defaults.inc that is explicitly named .inc due to some specific requirements at which point it should be included. But this one definitely lacks a header guard. Another question is whether it lacks a guard to check whether we are really on ARM. But it would probably be better to have something like

#if !defined(__ARM_EABI__)
# error Do not include this header unless on ARM target.
#endif
atrosinenko mentioned this in D84605: [IR][MSP430] Expose the "msp430_builtin" calling convention to .ll.Aug 14 2020, 2:04 AM

Revision Contents

PathSize
compiler-rt/
lib/
builtins/
2 lines
2 lines
2 lines
10 lines
10 lines
2 lines
2 lines
2 lines
2 lines
102 lines
6 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
21 lines
21 lines
6 lines
2 lines
2 lines
2 lines
2 lines
10 lines
2 lines
2 lines
2 lines
2 lines
10 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
12 lines
10 lines
2 lines
2 lines
2 lines
2 lines
14 lines
10 lines
2 lines
14 lines
10 lines
2 lines
2 lines
2 lines
2 lines
12 lines
10 lines
2 lines
12 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
12 lines
10 lines
2 lines
2 lines
10 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
12 lines
10 lines
2 lines
2 lines
10 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
6 lines
33 lines
1060 lines
6 lines
2 lines
32 lines
2 lines
2 lines
2 lines
2 lines
10 lines
6 lines
2 lines
2 lines
2 lines
2 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
2 lines
10 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
2 lines
2 lines
10 lines
10 lines
4 lines
2 lines
2 lines
2 lines
2 lines
10 lines
10 lines
12 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
test/
builtins/
Unit/
2 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
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 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
2 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
2 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
2 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
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 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
2 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
2 lines
2 lines
2 lines
2 lines
utils/
228 lines

Diff 280855

compiler-rt/lib/builtins/absvdi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: absolute value // Returns: absolute value
// Effects: aborts if abs(x) < 0 // Effects: aborts if abs(x) < 0
COMPILER_RT_ABI di_int __absvdi2(di_int a) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/absvsi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: absolute value // Returns: absolute value
// Effects: aborts if abs(x) < 0 // Effects: aborts if abs(x) < 0
COMPILER_RT_ABI si_int __absvsi2(si_int a) { DECLARE_LIBCALL(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 == ((si_int)1 << (N - 1))) if (a == ((si_int)1 << (N - 1)))
compilerrt_abort(); compilerrt_abort();
const si_int t = a >> (N - 1); const si_int t = a >> (N - 1);
return (a ^ t) - t; return (a ^ t) - t;
} }

compiler-rt/lib/builtins/absvti2.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: absolute value // Returns: absolute value
// Effects: aborts if abs(x) < 0 // Effects: aborts if abs(x) < 0
COMPILER_RT_ABI ti_int __absvti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/adddf3.c

//===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===// //===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements double-precision soft-float addition. // This file implements double-precision soft-float addition.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_add_impl.inc" #include "fp_add_impl.inc"
COMPILER_RT_ABI double __adddf3(double a, double b) { return __addXf3__(a, b); } DECLARE_LIBCALL(double, __adddf3, double a, double b) { return __addXf3__(a, b); }
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(double, __adddf3, double a, double b) { return __addXf3__(a, b); }
+DECLARE_LIBCALL(double, __adddf3, double a, double b) {
+  return __addXf3__(a, b);
+}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(double, __adddf3, double a, double…
#if defined(__ARM_EABI__) AUX_DECLS(__adddf3)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_dadd(double a, double b) { return __adddf3(a, b); }
#else
COMPILER_RT_ALIAS(__adddf3, __aeabi_dadd)
#endif
#endif

compiler-rt/lib/builtins/addsf3.c

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

compiler-rt/lib/builtins/addtf3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
#include "fp_add_impl.inc" #include "fp_add_impl.inc"
COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __addtf3, fp_t a, fp_t b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(fp_t, __addtf3, fp_t a, fp_t b) {
-  return __addXf3__(a, b);
-}
+DECLARE_LIBCALL(fp_t, __addtf3, fp_t a, fp_t b) { return __addXf3__(a, b); }
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(fp_t, __addtf3, fp_t a, fp_t b) {…
return __addXf3__(a, b); return __addXf3__(a, b);
} }
#endif #endif

compiler-rt/lib/builtins/addvdi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a + b // Returns: a + b
// Effects: aborts if a + b overflows // Effects: aborts if a + b overflows
COMPILER_RT_ABI di_int __addvdi3(di_int a, di_int b) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/addvsi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a + b // Returns: a + b
// Effects: aborts if a + b overflows // Effects: aborts if a + b overflows
COMPILER_RT_ABI si_int __addvsi3(si_int a, si_int b) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/addvti3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a + b // Returns: a + b
// Effects: aborts if a + b overflows // Effects: aborts if a + b overflows
COMPILER_RT_ABI ti_int __addvti3(ti_int a, ti_int b) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/arm-libcall-overrides.h

  • This file was added.
//===-- arm-libcall-overrides.h - LibCall overrides for ARM targets -------===//
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: header is missing header guard [llvm-header-guard]
not useful

Lint: Pre-merge checks: clang-tidy: warning: header is missing header guard [llvm-header-guard] [[https://github.
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

It looks like you're missing a header guard, is that intentional?

aaron.ballman: It looks like you're missing a header guard, is that intentional?
atrosinenkoAuthorUnsubmitted
Not Done
ReplyInline Actions

Thanks, there are files such as libcall-set-defaults.inc that is explicitly named .inc due to some specific requirements at which point it should be included. But this one definitely lacks a header guard. Another question is whether it lacks a guard to check whether we are really on ARM. But it would probably be better to have something like

#if !defined(__ARM_EABI__)
# error Do not include this header unless on ARM target.
#endif
atrosinenko: Thanks, there are files such as `libcall-set-defaults.inc` that is explicitly named `.inc` due…
#define AEABI_RTABI __attribute__((__pcs__("aapcs")))
#define AUX_DECLS__ashldi3 COMPILER_RT_ALIAS(__ashldi3, __aeabi_llsl)
#define AUX_DECLS__ashrdi3 COMPILER_RT_ALIAS(__ashrdi3, __aeabi_lasr)
#define AUX_DECLS__lshrdi3 COMPILER_RT_ALIAS(__lshrdi3, __aeabi_llsr)
#define AUX_DECLS__divsi3 COMPILER_RT_ALIAS(__divsi3, __aeabi_idiv)
#define AUX_DECLS__muldi3 COMPILER_RT_ALIAS(__muldi3, __aeabi_lmul)
#define AUX_DECLS__udivsi3 COMPILER_RT_ALIAS(__udivsi3, __aeabi_uidiv)
#if defined(COMPILER_RT_ARMHF_TARGET)
#define COMPILER_RT_ABI
// grep -h 'AEABI_RTABI' *.c | sed -r 's/^(AEABI_RTABI [^ ]+ (__[^(]+).*)$/#define AUX_DECLS\2 \1/'
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-// grep -h 'AEABI_RTABI' *.c | sed -r 's/^(AEABI_RTABI [^ ]+ (__[^(]+).*)$/#define AUX_DECLS\2 \1/'
-#define AUX_DECLS__aeabi_dadd AEABI_RTABI double __aeabi_dadd(double a, double b) { return __adddf3(a, b); }
-#define AUX_DECLS__aeabi_fadd AEABI_RTABI float __aeabi_fadd(float a, float b) { return __addsf3(a, b); }
-#define AUX_DECLS__aeabi_dcmpun AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) { return __unorddf2(a, b); }
-#define AUX_DECLS__aeabi_fcmpun AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) { return __unordsf2(a, b); }
-#define AUX_DECLS__aeabi_ddiv AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) { return __divdf3(a, b); }
-#define AUX_DECLS__aeabi_fdiv AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) { return __divsf3(a, b); }
-#define AUX_DECLS__aeabi_h2f AEABI_RTABI float __aeabi_h2f(uint16_t a) { return __extendhfsf2(a); }
-#define AUX_DECLS__aeabi_f2d AEABI_RTABI double __aeabi_f2d(float a) { return __extendsfdf2(a); }
-#define AUX_DECLS__aeabi_d2lz AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { return __fixdfdi(a); }

92 diff lines are omitted. See full path.

Lint: Pre-merge checks: clang-format: please reformat the code ``` -// grep -h 'AEABI_RTABI' *.c | sed -r 's/^…
#define AUX_DECLS__aeabi_dadd AEABI_RTABI double __aeabi_dadd(double a, double b) { return __adddf3(a, b); }
#define AUX_DECLS__aeabi_fadd AEABI_RTABI float __aeabi_fadd(float a, float b) { return __addsf3(a, b); }
#define AUX_DECLS__aeabi_dcmpun AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) { return __unorddf2(a, b); }
#define AUX_DECLS__aeabi_fcmpun AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) { return __unordsf2(a, b); }
#define AUX_DECLS__aeabi_ddiv AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) { return __divdf3(a, b); }
#define AUX_DECLS__aeabi_fdiv AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) { return __divsf3(a, b); }
#define AUX_DECLS__aeabi_h2f AEABI_RTABI float __aeabi_h2f(uint16_t a) { return __extendhfsf2(a); }
#define AUX_DECLS__aeabi_f2d AEABI_RTABI double __aeabi_f2d(float a) { return __extendsfdf2(a); }
#define AUX_DECLS__aeabi_d2lz AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { return __fixdfdi(a); }
#define AUX_DECLS__aeabi_d2iz AEABI_RTABI si_int __aeabi_d2iz(fp_t a) { return __fixdfsi(a); }
#define AUX_DECLS__aeabi_f2lz AEABI_RTABI di_int __aeabi_f2lz(fp_t a) { return __fixsfdi(a); }
#define AUX_DECLS__aeabi_f2iz AEABI_RTABI si_int __aeabi_f2iz(fp_t a) { return __fixsfsi(a); }
#define AUX_DECLS__aeabi_d2ulz AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) { return __fixunsdfdi(a); }
#define AUX_DECLS__aeabi_d2uiz AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) { return __fixunsdfsi(a); }
#define AUX_DECLS__aeabi_f2ulz AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) { return __fixunssfdi(a); }
#define AUX_DECLS__aeabi_f2uiz AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) { return __fixunssfsi(a); }
#define AUX_DECLS__aeabi_l2d AEABI_RTABI double __aeabi_l2d(di_int a) { return __floatdidf(a); }
#define AUX_DECLS__aeabi_l2f AEABI_RTABI float __aeabi_l2f(di_int a) { return __floatdisf(a); }
#define AUX_DECLS__aeabi_i2d AEABI_RTABI fp_t __aeabi_i2d(si_int a) { return __floatsidf(a); }
#define AUX_DECLS__aeabi_i2f AEABI_RTABI fp_t __aeabi_i2f(int a) { return __floatsisf(a); }
#define AUX_DECLS__aeabi_ul2d AEABI_RTABI double __aeabi_ul2d(du_int a) { return __floatundidf(a); }
#define AUX_DECLS__aeabi_ul2f AEABI_RTABI float __aeabi_ul2f(du_int a) { return __floatundisf(a); }
#define AUX_DECLS__aeabi_ui2d AEABI_RTABI fp_t __aeabi_ui2d(su_int a) { return __floatunsidf(a); }
#define AUX_DECLS__aeabi_ui2f AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) { return __floatunsisf(a); }
#define AUX_DECLS__aeabi_dmul AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) { return __muldf3(a, b); }
#define AUX_DECLS__aeabi_fmul AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) { return __mulsf3(a, b); }
#define AUX_DECLS__aeabi_dneg AEABI_RTABI fp_t __aeabi_dneg(fp_t a) { return __negdf2(a); }
#define AUX_DECLS__aeabi_fneg AEABI_RTABI fp_t __aeabi_fneg(fp_t a) { return __negsf2(a); }
#define AUX_DECLS__aeabi_dsub AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) { return __subdf3(a, b); }
#define AUX_DECLS__aeabi_fsub AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) { return __subsf3(a, b); }
#define AUX_DECLS__aeabi_d2h AEABI_RTABI uint16_t __aeabi_d2h(double a) { return __truncdfhf2(a); }
#define AUX_DECLS__aeabi_d2f AEABI_RTABI float __aeabi_d2f(double a) { return __truncdfsf2(a); }
#define AUX_DECLS__aeabi_f2h AEABI_RTABI uint16_t __aeabi_f2h(float a) { return __truncsfhf2(a); }
#else // defined(COMPILER_RT_ARMHF_TARGET)
#define COMPILER_RT_ABI AEABI_RTABI
// grep -h 'COMPILER_RT_ALIAS.*eabi' *.c | sed -r 's/^(COMPILER_RT_ALIAS\((__[^,]+).*)$/#define AUX_DECLS\2 \1/'
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-// grep -h 'COMPILER_RT_ALIAS.*eabi' *.c | sed -r 's/^(COMPILER_RT_ALIAS\((__[^,]+).*)$/#define AUX_DECLS\2 \1/'
+// grep -h 'COMPILER_RT_ALIAS.*eabi' *.c | sed -r
+// 's/^(COMPILER_RT_ALIAS\((__[^,]+).*)$/#define AUX_DECLS\2 \1/'
Lint: Pre-merge checks: clang-format: please reformat the code ``` -// grep -h 'COMPILER_RT_ALIAS.*eabi' *.c | sed -r…
#define AUX_DECLS__adddf3 COMPILER_RT_ALIAS(__adddf3, __aeabi_dadd)
#define AUX_DECLS__addsf3 COMPILER_RT_ALIAS(__addsf3, __aeabi_fadd)
#define AUX_DECLS__ashldi3 COMPILER_RT_ALIAS(__ashldi3, __aeabi_llsl)
#define AUX_DECLS__ashrdi3 COMPILER_RT_ALIAS(__ashrdi3, __aeabi_lasr)
#define AUX_DECLS__unorddf2 COMPILER_RT_ALIAS(__unorddf2, __aeabi_dcmpun)
#define AUX_DECLS__unordsf2 COMPILER_RT_ALIAS(__unordsf2, __aeabi_fcmpun)
#define AUX_DECLS__divdf3 COMPILER_RT_ALIAS(__divdf3, __aeabi_ddiv)
#define AUX_DECLS__divsf3 COMPILER_RT_ALIAS(__divsf3, __aeabi_fdiv)
#define AUX_DECLS__divsi3 COMPILER_RT_ALIAS(__divsi3, __aeabi_idiv)
#define AUX_DECLS__extendhfsf2 COMPILER_RT_ALIAS(__extendhfsf2, __aeabi_h2f)
#define AUX_DECLS__extendsfdf2 COMPILER_RT_ALIAS(__extendsfdf2, __aeabi_f2d)
#define AUX_DECLS__fixdfdi COMPILER_RT_ALIAS(__fixdfdi, __aeabi_d2lz)
#define AUX_DECLS__fixdfsi COMPILER_RT_ALIAS(__fixdfsi, __aeabi_d2iz)
#define AUX_DECLS__fixsfdi COMPILER_RT_ALIAS(__fixsfdi, __aeabi_f2lz)
#define AUX_DECLS__fixsfsi COMPILER_RT_ALIAS(__fixsfsi, __aeabi_f2iz)
#define AUX_DECLS__fixunsdfdi COMPILER_RT_ALIAS(__fixunsdfdi, __aeabi_d2ulz)
#define AUX_DECLS__fixunsdfsi COMPILER_RT_ALIAS(__fixunsdfsi, __aeabi_d2uiz)
#define AUX_DECLS__fixunssfdi COMPILER_RT_ALIAS(__fixunssfdi, __aeabi_f2ulz)
#define AUX_DECLS__fixunssfsi COMPILER_RT_ALIAS(__fixunssfsi, __aeabi_f2uiz)
#define AUX_DECLS__floatdidf COMPILER_RT_ALIAS(__floatdidf, __aeabi_l2d)
#define AUX_DECLS__floatdisf COMPILER_RT_ALIAS(__floatdisf, __aeabi_l2f)
#define AUX_DECLS__floatsidf COMPILER_RT_ALIAS(__floatsidf, __aeabi_i2d)
#define AUX_DECLS__floatsisf COMPILER_RT_ALIAS(__floatsisf, __aeabi_i2f)
#define AUX_DECLS__floatundidf COMPILER_RT_ALIAS(__floatundidf, __aeabi_ul2d)
#define AUX_DECLS__floatundisf COMPILER_RT_ALIAS(__floatundisf, __aeabi_ul2f)
#define AUX_DECLS__floatunsidf COMPILER_RT_ALIAS(__floatunsidf, __aeabi_ui2d)
#define AUX_DECLS__floatunsisf COMPILER_RT_ALIAS(__floatunsisf, __aeabi_ui2f)
#define AUX_DECLS__lshrdi3 COMPILER_RT_ALIAS(__lshrdi3, __aeabi_llsr)
#define AUX_DECLS__muldf3 COMPILER_RT_ALIAS(__muldf3, __aeabi_dmul)
#define AUX_DECLS__muldi3 COMPILER_RT_ALIAS(__muldi3, __aeabi_lmul)
#define AUX_DECLS__mulsf3 COMPILER_RT_ALIAS(__mulsf3, __aeabi_fmul)
#define AUX_DECLS__negdf2 COMPILER_RT_ALIAS(__negdf2, __aeabi_dneg)
#define AUX_DECLS__negsf2 COMPILER_RT_ALIAS(__negsf2, __aeabi_fneg)
#define AUX_DECLS__subdf3 COMPILER_RT_ALIAS(__subdf3, __aeabi_dsub)
#define AUX_DECLS__subsf3 COMPILER_RT_ALIAS(__subsf3, __aeabi_fsub)
#define AUX_DECLS__truncdfhf2 COMPILER_RT_ALIAS(__truncdfhf2, __aeabi_d2h)
#define AUX_DECLS__truncdfsf2 COMPILER_RT_ALIAS(__truncdfsf2, __aeabi_d2f)
#define AUX_DECLS__truncsfhf2 COMPILER_RT_ALIAS(__truncsfhf2, __aeabi_f2h)
#define AUX_DECLS__udivsi3 COMPILER_RT_ALIAS(__udivsi3, __aeabi_uidiv)
#endif // defined(COMPILER_RT_ARMHF_TARGET)
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: ISO C requires a translation unit to contain at least one declaration [clang-diagnostic-empty-translation-unit]
not useful

Lint: Pre-merge checks: clang-tidy: warning: ISO C requires a translation unit to contain at least one declaration…

compiler-rt/lib/builtins/ashldi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a << b // Returns: a << b
// Precondition: 0 <= b < bits_in_dword // Precondition: 0 <= b < bits_in_dword
COMPILER_RT_ABI di_int __ashldi3(di_int a, int b) { DECLARE_LIBCALL(di_int, __ashldi3, di_int a, 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__) AUX_DECLS(__ashldi3)
COMPILER_RT_ALIAS(__ashldi3, __aeabi_llsl)
#endif

compiler-rt/lib/builtins/ashlti3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a << b // Returns: a << b
// Precondition: 0 <= b < bits_in_tword // Precondition: 0 <= b < bits_in_tword
COMPILER_RT_ABI ti_int __ashlti3(ti_int a, si_int b) { DECLARE_LIBCALL(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 */ {
Show All 9 Lines

compiler-rt/lib/builtins/ashrdi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: arithmetic a >> b // Returns: arithmetic a >> b
// Precondition: 0 <= b < bits_in_dword // Precondition: 0 <= b < bits_in_dword
COMPILER_RT_ABI di_int __ashrdi3(di_int a, int b) { DECLARE_LIBCALL(di_int, __ashrdi3, di_int a, 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__) AUX_DECLS(__ashrdi3)
COMPILER_RT_ALIAS(__ashrdi3, __aeabi_lasr)
#endif

compiler-rt/lib/builtins/ashrti3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: arithmetic a >> b // Returns: arithmetic a >> b
// Precondition: 0 <= b < bits_in_tword // Precondition: 0 <= b < bits_in_tword
COMPILER_RT_ABI ti_int __ashrti3(ti_int a, si_int b) { DECLARE_LIBCALL(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);
Show All 10 Lines

compiler-rt/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) { DECLARE_LIBCALL(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));
} }

compiler-rt/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) { DECLARE_LIBCALL(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));
} }

compiler-rt/lib/builtins/clzdi2.c

Show All 20 Lines
// 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 int __clzsi2(si_int); extern int __clzsi2(si_int);
#endif #endif
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __clzdi2(di_int a) { DECLARE_LIBCALL(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 clzsi((x.s.high & ~f) | (x.s.low & f)) + return clzsi((x.s.high & ~f) | (x.s.low & f)) +
(f & ((si_int)(sizeof(si_int) * CHAR_BIT))); (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
} }

compiler-rt/lib/builtins/clzsi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: the number of leading 0-bits // Returns: the number of leading 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __clzsi2(si_int a) { DECLARE_LIBCALL(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]
Show All 21 Lines

compiler-rt/lib/builtins/clzti2.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: the number of leading 0-bits // Returns: the number of leading 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __clzti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/cmpdi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: if (a < b) returns 0 // Returns: if (a < b) returns 0
// if (a == b) returns 1 // if (a == b) returns 1
// if (a > b) returns 2 // if (a > b) returns 2
COMPILER_RT_ABI si_int __cmpdi2(di_int a, di_int b) { DECLARE_LIBCALL(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) { DECLARE_LIBCALL(si_int, __aeabi_lcmp, di_int a, di_int b) {
return __cmpdi2(a, b) - 1; return __cmpdi2(a, b) - 1;
} }
#endif #endif

compiler-rt/lib/builtins/cmpti2.c

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

compiler-rt/lib/builtins/comparedf2.c

Show All 35 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 }; enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 };
COMPILER_RT_ABI enum LE_RESULT __ledf2(fp_t a, fp_t b) { DECLARE_LIBCALL(enum LE_RESULT, __ledf2, fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
// If either a or b is NaN, they are unordered. // If either a or b is NaN, they are unordered.
if (aAbs > infRep || bAbs > infRep) if (aAbs > infRep || bAbs > infRep)
Show All 38 Lines
enum GE_RESULT { enum GE_RESULT {
GE_LESS = -1, GE_LESS = -1,
GE_EQUAL = 0, GE_EQUAL = 0,
GE_GREATER = 1, GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED GE_UNORDERED = -1 // Note: different from LE_UNORDERED
}; };
COMPILER_RT_ABI enum GE_RESULT __gedf2(fp_t a, fp_t b) { DECLARE_LIBCALL(enum GE_RESULT, __gedf2, fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) if (aAbs > infRep || bAbs > infRep)
return GE_UNORDERED; return GE_UNORDERED;
Show All 13 Lines else if (aInt == bInt)
return GE_EQUAL; return GE_EQUAL;
else else
return GE_GREATER; return GE_GREATER;
} }
} }
COMPILER_RT_ALIAS(__gedf2, __gtdf2) COMPILER_RT_ALIAS(__gedf2, __gtdf2)
COMPILER_RT_ABI int DECLARE_LIBCALL(int, __unorddf2, fp_t a, fp_t b) {
__unorddf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'aAbs' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'aAbs' [readability-identifier-naming]…
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'bAbs' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'bAbs' [readability-identifier-naming]…
return aAbs > infRep || bAbs > infRep; return aAbs > infRep || bAbs > infRep;
} }
#if defined(__ARM_EABI__) AUX_DECLS(__unorddf2)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) { return __unorddf2(a, b); }
#else
COMPILER_RT_ALIAS(__unorddf2, __aeabi_dcmpun)
#endif
#endif
#if defined(_WIN32) && !defined(__MINGW32__) #if defined(_WIN32) && !defined(__MINGW32__)
// The alias mechanism doesn't work on Windows except for MinGW, so emit // The alias mechanism doesn't work on Windows except for MinGW, so emit
// wrapper functions. // wrapper functions.
int __eqdf2(fp_t a, fp_t b) { return __ledf2(a, b); } int __eqdf2(fp_t a, fp_t b) { return __ledf2(a, b); }
int __ltdf2(fp_t a, fp_t b) { return __ledf2(a, b); } int __ltdf2(fp_t a, fp_t b) { return __ledf2(a, b); }
int __nedf2(fp_t a, fp_t b) { return __ledf2(a, b); } int __nedf2(fp_t a, fp_t b) { return __ledf2(a, b); }
int __gtdf2(fp_t a, fp_t b) { return __gedf2(a, b); } int __gtdf2(fp_t a, fp_t b) { return __gedf2(a, b); }
#endif #endif

compiler-rt/lib/builtins/comparesf2.c

Show All 35 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 }; enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 };
COMPILER_RT_ABI enum LE_RESULT __lesf2(fp_t a, fp_t b) { DECLARE_LIBCALL(enum LE_RESULT, __lesf2, fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
// If either a or b is NaN, they are unordered. // If either a or b is NaN, they are unordered.
if (aAbs > infRep || bAbs > infRep) if (aAbs > infRep || bAbs > infRep)
Show All 38 Lines
enum GE_RESULT { enum GE_RESULT {
GE_LESS = -1, GE_LESS = -1,
GE_EQUAL = 0, GE_EQUAL = 0,
GE_GREATER = 1, GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED GE_UNORDERED = -1 // Note: different from LE_UNORDERED
}; };
COMPILER_RT_ABI enum GE_RESULT __gesf2(fp_t a, fp_t b) { DECLARE_LIBCALL(enum GE_RESULT, __gesf2, fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) if (aAbs > infRep || bAbs > infRep)
return GE_UNORDERED; return GE_UNORDERED;
Show All 13 Lines else if (aInt == bInt)
return GE_EQUAL; return GE_EQUAL;
else else
return GE_GREATER; return GE_GREATER;
} }
} }
COMPILER_RT_ALIAS(__gesf2, __gtsf2) COMPILER_RT_ALIAS(__gesf2, __gtsf2)
COMPILER_RT_ABI int DECLARE_LIBCALL(int, __unordsf2, fp_t a, fp_t b) {
__unordsf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'aAbs' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'aAbs' [readability-identifier-naming]…
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'bAbs' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'bAbs' [readability-identifier-naming]…
return aAbs > infRep || bAbs > infRep; return aAbs > infRep || bAbs > infRep;
} }
#if defined(__ARM_EABI__) AUX_DECLS(__unordsf2)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) { return __unordsf2(a, b); }
#else
COMPILER_RT_ALIAS(__unordsf2, __aeabi_fcmpun)
#endif
#endif
#if defined(_WIN32) && !defined(__MINGW32__) #if defined(_WIN32) && !defined(__MINGW32__)
// The alias mechanism doesn't work on Windows except for MinGW, so emit // The alias mechanism doesn't work on Windows except for MinGW, so emit
// wrapper functions. // wrapper functions.
int __eqsf2(fp_t a, fp_t b) { return __lesf2(a, b); } int __eqsf2(fp_t a, fp_t b) { return __lesf2(a, b); }
int __ltsf2(fp_t a, fp_t b) { return __lesf2(a, b); } int __ltsf2(fp_t a, fp_t b) { return __lesf2(a, b); }
int __nesf2(fp_t a, fp_t b) { return __lesf2(a, b); } int __nesf2(fp_t a, fp_t b) { return __lesf2(a, b); }
int __gtsf2(fp_t a, fp_t b) { return __gesf2(a, b); } int __gtsf2(fp_t a, fp_t b) { return __gesf2(a, b); }
#endif #endif

compiler-rt/lib/builtins/comparetf2.c

Show All 36 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 }; enum LE_RESULT { LE_LESS = -1, LE_EQUAL = 0, LE_GREATER = 1, LE_UNORDERED = 1 };
COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) { DECLARE_LIBCALL(enum LE_RESULT, __letf2, fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
// If either a or b is NaN, they are unordered. // If either a or b is NaN, they are unordered.
if (aAbs > infRep || bAbs > infRep) if (aAbs > infRep || bAbs > infRep)
Show All 36 Lines
enum GE_RESULT { enum GE_RESULT {
GE_LESS = -1, GE_LESS = -1,
GE_EQUAL = 0, GE_EQUAL = 0,
GE_GREATER = 1, GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED GE_UNORDERED = -1 // Note: different from LE_UNORDERED
}; };
COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) { DECLARE_LIBCALL(enum GE_RESULT, __getf2, fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b); const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask; const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask; const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) if (aAbs > infRep || bAbs > infRep)
return GE_UNORDERED; return GE_UNORDERED;
Show All 13 Lines else if (aInt == bInt)
return GE_EQUAL; return GE_EQUAL;
else else
return GE_GREATER; return GE_GREATER;
} }
} }
COMPILER_RT_ALIAS(__getf2, __gttf2) COMPILER_RT_ALIAS(__getf2, __gttf2)
COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) { DECLARE_LIBCALL(int, __unordtf2, fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask; const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask; const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep; return aAbs > infRep || bAbs > infRep;
} }
#endif #endif

compiler-rt/lib/builtins/ctzdi2.c

Show All 20 Lines
// 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 int __ctzsi2(si_int); extern int __ctzsi2(si_int);
#endif #endif
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __ctzdi2(di_int a) { DECLARE_LIBCALL(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 ctzsi((x.s.high & f) | (x.s.low & ~f)) + return ctzsi((x.s.high & f) | (x.s.low & ~f)) +
(f & ((si_int)(sizeof(si_int) * CHAR_BIT))); (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
} }

compiler-rt/lib/builtins/ctzsi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: the number of trailing 0-bits // Returns: the number of trailing 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __ctzsi2(si_int a) { DECLARE_LIBCALL(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
Show All 26 Lines

compiler-rt/lib/builtins/ctzti2.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: the number of trailing 0-bits // Returns: the number of trailing 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __ctzti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/divdc3.c

Show All 11 Lines
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
#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, DECLARE_LIBCALL(Dcomplex, __divdc3, double __a, double __b, double __c,
double __d) { double __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                  double __d) {
+                double __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - double __d) { +…
int __ilogbw = 0; int __ilogbw = 0;
double __logbw = __compiler_rt_logb(crt_fmax(crt_fabs(__c), crt_fabs(__d))); double __logbw = __compiler_rt_logb(crt_fmax(crt_fabs(__c), crt_fabs(__d)));
if (crt_isfinite(__logbw)) { if (crt_isfinite(__logbw)) {
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbn(__c, -__ilogbw); __c = crt_scalbn(__c, -__ilogbw);
__d = crt_scalbn(__d, -__ilogbw); __d = crt_scalbn(__d, -__ilogbw);
} }
double __denom = __c * __c + __d * __d; double __denom = __c * __c + __d * __d;
Show All 24 Lines

compiler-rt/lib/builtins/divdf3.c

Show All 12 Lines
// It should be a fairly straightforward exercise to implement gradual // It should be a fairly straightforward exercise to implement gradual
// underflow with correct rounding. // underflow with correct rounding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
COMPILER_RT_ABI fp_t __divdf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __divdf3, fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines else {
// Round. // Round.
absResult += round; absResult += round;
// Insert the sign and return. // Insert the sign and return.
const double result = fromRep(absResult | quotientSign); const double result = fromRep(absResult | quotientSign);
return result; return result;
} }
} }
#if defined(__ARM_EABI__) AUX_DECLS(__divdf3)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) { return __divdf3(a, b); }
#else
COMPILER_RT_ALIAS(__divdf3, __aeabi_ddiv)
#endif
#endif

compiler-rt/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) { DECLARE_LIBCALL(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) - s_a; // negate if s_a == -1 return (__udivmoddi4(a, b, (du_int *)0) ^ s_a) - s_a; // negate if s_a == -1
} }

compiler-rt/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) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/divmodsi4.c

Show All 9 Lines
// 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) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/divsc3.c

Show All 11 Lines
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
#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) { DECLARE_LIBCALL(Fcomplex, __divsc3, float __a, float __b, float __c, float __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(Fcomplex, __divsc3, float __a, float __b, float __c, float __d) {
+DECLARE_LIBCALL(Fcomplex, __divsc3, float __a, float __b, float __c,
+                float __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(Fcomplex, __divsc3, float __a…
int __ilogbw = 0; int __ilogbw = 0;
float __logbw = float __logbw =
__compiler_rt_logbf(crt_fmaxf(crt_fabsf(__c), crt_fabsf(__d))); __compiler_rt_logbf(crt_fmaxf(crt_fabsf(__c), crt_fabsf(__d)));
if (crt_isfinite(__logbw)) { if (crt_isfinite(__logbw)) {
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbnf(__c, -__ilogbw); __c = crt_scalbnf(__c, -__ilogbw);
__d = crt_scalbnf(__d, -__ilogbw); __d = crt_scalbnf(__d, -__ilogbw);
} }
Show All 25 Lines

compiler-rt/lib/builtins/divsf3.c

Show All 12 Lines
// It should be a fairly straightforward exercise to implement gradual // It should be a fairly straightforward exercise to implement gradual
// underflow with correct rounding. // underflow with correct rounding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
COMPILER_RT_ABI fp_t __divsf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __divsf3, fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines else {
absResult |= (rep_t)writtenExponent << significandBits; absResult |= (rep_t)writtenExponent << significandBits;
// Round. // Round.
absResult += round; absResult += round;
// Insert the sign and return. // Insert the sign and return.
return fromRep(absResult | quotientSign); return fromRep(absResult | quotientSign);
} }
} }
#if defined(__ARM_EABI__) AUX_DECLS(__divsf3)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) { return __divsf3(a, b); }
#else
COMPILER_RT_ALIAS(__divsf3, __aeabi_fdiv)
#endif
#endif

compiler-rt/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) { DECLARE_LIBCALL(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__) AUX_DECLS(__divsi3)
COMPILER_RT_ALIAS(__divsi3, __aeabi_idiv)
#endif

compiler-rt/lib/builtins/divtc3.c

Show All 11 Lines
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
// Returns: the quotient of (a + ib) / (c + id) // Returns: the quotient of (a + ib) / (c + id)
COMPILER_RT_ABI Lcomplex __divtc3(long double __a, long double __b, DECLARE_LIBCALL(Lcomplex, __divtc3, long double __a, long double __b,
long double __c, long double __d) { long double __c, long double __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                  long double __c, long double __d) {
+                long double __c, long double __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - long double __c…
int __ilogbw = 0; int __ilogbw = 0;
long double __logbw = long double __logbw =
__compiler_rt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d))); __compiler_rt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
if (crt_isfinite(__logbw)) { if (crt_isfinite(__logbw)) {
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbnl(__c, -__ilogbw); __c = crt_scalbnl(__c, -__ilogbw);
__d = crt_scalbnl(__d, -__ilogbw); __d = crt_scalbnl(__d, -__ilogbw);
} }
Show All 25 Lines

compiler-rt/lib/builtins/divtf3.c

Show All 13 Lines
// underflow with correct rounding. // underflow with correct rounding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __divtf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __divtf3, fp_t a, fp_t b) {
const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit; const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
rep_t aSignificand = toRep(a) & significandMask; rep_t aSignificand = toRep(a) & significandMask;
rep_t bSignificand = toRep(b) & significandMask; rep_t bSignificand = toRep(b) & significandMask;
int scale = 0; int scale = 0;
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

compiler-rt/lib/builtins/divti3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI ti_int __divti3(ti_int a, ti_int b) { DECLARE_LIBCALL(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) - s_a; // negate if s_a == -1 return (__udivmodti4(a, b, (tu_int *)0) ^ s_a) - s_a; // negate if s_a == -1
} }
#endif // CRT_HAS_128BIT #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/divxc3.c

Show All 11 Lines
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
// Returns: the quotient of (a + ib) / (c + id) // Returns: the quotient of (a + ib) / (c + id)
COMPILER_RT_ABI Lcomplex __divxc3(long double __a, long double __b, DECLARE_LIBCALL(Lcomplex, __divxc3, long double __a, long double __b,
long double __c, long double __d) { long double __c, long double __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                  long double __c, long double __d) {
+                long double __c, long double __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - long double __c…
int __ilogbw = 0; int __ilogbw = 0;
long double __logbw = crt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d))); long double __logbw = crt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
if (crt_isfinite(__logbw)) { if (crt_isfinite(__logbw)) {
__ilogbw = (int)__logbw; __ilogbw = (int)__logbw;
__c = crt_scalbnl(__c, -__ilogbw); __c = crt_scalbnl(__c, -__ilogbw);
__d = crt_scalbnl(__d, -__ilogbw); __d = crt_scalbnl(__d, -__ilogbw);
} }
long double __denom = __c * __c + __d * __d; long double __denom = __c * __c + __d * __d;
Show All 26 Lines

compiler-rt/lib/builtins/enable_execute_stack.c

Show All 32 Lines
#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) { DECLARE_LIBCALL(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
Show All 18 Lines

compiler-rt/lib/builtins/eprintf.c

Show All 12 Lines
// 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 DECLARE_LIBCALL(void, __eprintf,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(void, __eprintf,
-          const char *format, const char *assertion_expression,
-          const char *line, const char *file) {
+DECLARE_LIBCALL(void, __eprintf, const char *format,
+                const char *assertion_expression, const char *line,
+                const char *file) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(void, __eprintf, - const…
__eprintf(const char *format, const char *assertion_expression, const char *format, const char *assertion_expression,
const char *line, const char *file) { const char *line, const char *file) {
fprintf(stderr, format, assertion_expression, line, file); fprintf(stderr, format, assertion_expression, line, file);
fflush(stderr); fflush(stderr);
compilerrt_abort(); compilerrt_abort();
} }

compiler-rt/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 fp_t __extenddftf2(double a) { DECLARE_LIBCALL(fp_t, __extenddftf2, double a) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(fp_t, __extenddftf2, double a) {
-  return __extendXfYf2__(a);
-}
+DECLARE_LIBCALL(fp_t, __extenddftf2, double a) { return __extendXfYf2__(a); }
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(fp_t, __extenddftf2, double a) {…
return __extendXfYf2__(a); return __extendXfYf2__(a);
} }
#endif #endif

compiler-rt/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) { DECLARE_LIBCALL(NOINLINE float, __extendhfsf2, uint16_t a) {
return __extendXfYf2__(a); return __extendXfYf2__(a);
} }
COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) { return __extendhfsf2(a); } DECLARE_LIBCALL(float, __gnu_h2f_ieee, uint16_t a) { return __extendhfsf2(a); }
#if defined(__ARM_EABI__) AUX_DECLS(__extendhfsf2)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_h2f(uint16_t a) { return __extendhfsf2(a); }
#else
COMPILER_RT_ALIAS(__extendhfsf2, __aeabi_h2f)
#endif
#endif

compiler-rt/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); } DECLARE_LIBCALL(double, __extendsfdf2, float a) { return __extendXfYf2__(a); }
#if defined(__ARM_EABI__) AUX_DECLS(__extendsfdf2)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_f2d(float a) { return __extendsfdf2(a); }
#else
COMPILER_RT_ALIAS(__extendsfdf2, __aeabi_f2d)
#endif
#endif

compiler-rt/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 fp_t __extendsftf2(float a) { DECLARE_LIBCALL(fp_t, __extendsftf2, float a) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(fp_t, __extendsftf2, float a) {
-  return __extendXfYf2__(a);
-}
+DECLARE_LIBCALL(fp_t, __extendsftf2, float a) { return __extendXfYf2__(a); }
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(fp_t, __extendsftf2, float a) {…
return __extendXfYf2__(a); return __extendXfYf2__(a);
} }
#endif #endif

compiler-rt/lib/builtins/ffsdi2.c

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: the index of the least significant 1-bit in a, or // Returns: the index of the least significant 1-bit in a, or
// the value zero if a is zero. The least significant bit is index one. // the value zero if a is zero. The least significant bit is index one.
COMPILER_RT_ABI int __ffsdi2(di_int a) { DECLARE_LIBCALL(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 ctzsi(x.s.high) + (1 + sizeof(si_int) * CHAR_BIT); return ctzsi(x.s.high) + (1 + sizeof(si_int) * CHAR_BIT);
} }
return ctzsi(x.s.low) + 1; return ctzsi(x.s.low) + 1;
} }

compiler-rt/lib/builtins/ffssi2.c

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

compiler-rt/lib/builtins/ffsti2.c

Show All 11 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: the index of the least significant 1-bit in a, or // Returns: the index of the least significant 1-bit in a, or
// the value zero if a is zero. The least significant bit is index one. // the value zero if a is zero. The least significant bit is index one.
COMPILER_RT_ABI int __ffsti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/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); DECLARE_LIBCALL(du_int, __fixunsdfdi, double a);
COMPILER_RT_ABI di_int __fixdfdi(double a) { DECLARE_LIBCALL(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); } DECLARE_LIBCALL(di_int, __fixdfdi, fp_t a) { return __fixint(a); }
#endif #endif
#if defined(__ARM_EABI__) AUX_DECLS(__fixdfdi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { return __fixdfdi(a); }
#else
COMPILER_RT_ALIAS(__fixdfdi, __aeabi_d2lz)
#endif
#endif

compiler-rt/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); } DECLARE_LIBCALL(si_int, __fixdfsi, fp_t a) { return __fixint(a); }
#if defined(__ARM_EABI__) AUX_DECLS(__fixdfsi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI si_int __aeabi_d2iz(fp_t a) { return __fixdfsi(a); }
#else
COMPILER_RT_ALIAS(__fixdfsi, __aeabi_d2iz)
#endif
#endif

compiler-rt/lib/builtins/fixdfti.c

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

compiler-rt/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); DECLARE_LIBCALL(du_int, __fixunssfdi, float a);
COMPILER_RT_ABI di_int __fixsfdi(float a) { DECLARE_LIBCALL(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); } DECLARE_LIBCALL(di_int, __fixsfdi, fp_t a) { return __fixint(a); }
#endif #endif
#if defined(__ARM_EABI__) AUX_DECLS(__fixsfdi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI di_int __aeabi_f2lz(fp_t a) { return __fixsfdi(a); }
#else
COMPILER_RT_ALIAS(__fixsfdi, __aeabi_f2lz)
#endif
#endif

compiler-rt/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); } DECLARE_LIBCALL(si_int, __fixsfsi, fp_t a) { return __fixint(a); }
#if defined(__ARM_EABI__) AUX_DECLS(__fixsfsi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI si_int __aeabi_f2iz(fp_t a) { return __fixsfsi(a); }
#else
COMPILER_RT_ALIAS(__fixsfsi, __aeabi_f2iz)
#endif
#endif

compiler-rt/lib/builtins/fixsfti.c

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

compiler-rt/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); } DECLARE_LIBCALL(di_int, __fixtfdi, fp_t a) { return __fixint(a); }
#endif #endif

compiler-rt/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); } DECLARE_LIBCALL(si_int, __fixtfsi, fp_t a) { return __fixint(a); }
#endif #endif

compiler-rt/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); } DECLARE_LIBCALL(ti_int, __fixtfti, fp_t a) { return __fixint(a); }
#endif #endif

compiler-rt/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) { DECLARE_LIBCALL(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); } DECLARE_LIBCALL(du_int, __fixunsdfdi, fp_t a) { return __fixuint(a); }
#endif #endif
#if defined(__ARM_EABI__) AUX_DECLS(__fixunsdfdi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) { return __fixunsdfdi(a); }
#else
COMPILER_RT_ALIAS(__fixunsdfdi, __aeabi_d2ulz)
#endif
#endif

compiler-rt/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); } DECLARE_LIBCALL(su_int, __fixunsdfsi, fp_t a) { return __fixuint(a); }
#if defined(__ARM_EABI__) AUX_DECLS(__fixunsdfsi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) { return __fixunsdfsi(a); }
#else
COMPILER_RT_ALIAS(__fixunsdfsi, __aeabi_d2uiz)
#endif
#endif

compiler-rt/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); } DECLARE_LIBCALL(tu_int, __fixunsdfti, fp_t a) { return __fixuint(a); }
#endif // CRT_HAS_128BIT #endif // CRT_HAS_128BIT

compiler-rt/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) { DECLARE_LIBCALL(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); } DECLARE_LIBCALL(du_int, __fixunssfdi, fp_t a) { return __fixuint(a); }
#endif #endif
#if defined(__ARM_EABI__) AUX_DECLS(__fixunssfdi)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) { return __fixunssfdi(a); }
#else
COMPILER_RT_ALIAS(__fixunssfdi, __aeabi_f2ulz)
#endif
#endif

compiler-rt/lib/builtins/fixunssfsi.c

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

compiler-rt/lib/builtins/fixunssfti.c

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

compiler-rt/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); } DECLARE_LIBCALL(du_int, __fixunstfdi, fp_t a) { return __fixuint(a); }
#endif #endif

compiler-rt/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); } DECLARE_LIBCALL(su_int, __fixunstfsi, fp_t a) { return __fixuint(a); }
#endif #endif

compiler-rt/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); } DECLARE_LIBCALL(tu_int, __fixunstfti, fp_t a) { return __fixuint(a); }
#endif #endif

compiler-rt/lib/builtins/fixunsxfdi.c

Show All 26 Lines
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
// MSVC throws a warning about 'unitialized variable use' here, // MSVC throws a warning about 'unitialized variable use' here,
// disable it for builds that warn-as-error // disable it for builds that warn-as-error
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4700) #pragma warning(disable : 4700)
#endif #endif
COMPILER_RT_ABI du_int __fixunsxfdi(long double a) { DECLARE_LIBCALL(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);
} }
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop) #pragma warning(pop)
#endif #endif
#endif //!_ARCH_PPC #endif //!_ARCH_PPC

compiler-rt/lib/builtins/fixunsxfsi.c

Show All 26 Lines
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
// MSVC throws a warning about 'unitialized variable use' here, // MSVC throws a warning about 'unitialized variable use' here,
// disable it for builds that warn-as-error // disable it for builds that warn-as-error
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4700) #pragma warning(disable : 4700)
#endif #endif
COMPILER_RT_ABI su_int __fixunsxfsi(long double a) { DECLARE_LIBCALL(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);
} }
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop) #pragma warning(pop)
#endif #endif
#endif // !_ARCH_PPC #endif // !_ARCH_PPC

compiler-rt/lib/builtins/fixunsxfti.c

Show All 19 Lines
// 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 // 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 tu_int __fixunsxfti(long double a) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/fixxfdi.c

Show All 25 Lines
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
// MSVC throws a warning about 'unitialized variable use' here, // MSVC throws a warning about 'unitialized variable use' here,
// disable it for builds that warn-as-error // disable it for builds that warn-as-error
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4700) #pragma warning(disable : 4700)
#endif #endif
COMPILER_RT_ABI di_int __fixxfdi(long double a) { DECLARE_LIBCALL(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)
Show All 12 Lines

compiler-rt/lib/builtins/fixxfti.c

Show All 18 Lines
// 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) { DECLARE_LIBCALL(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);
Show All 11 Lines

compiler-rt/lib/builtins/floatdidf.c

Show All 18 Lines
// 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) { DECLARE_LIBCALL(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) { DECLARE_LIBCALL(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) {
Show All 32 LinesDECLARE_LIBCALL(double, __floatdidf, di_int a) {
fb.u.s.high = ((su_int)s & 0x80000000) | // sign fb.u.s.high = ((su_int)s & 0x80000000) | // sign
((su_int)(e + 1023) << 20) | // exponent ((su_int)(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__) AUX_DECLS(__floatdidf)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_l2d(di_int a) { return __floatdidf(a); }
#else
COMPILER_RT_ALIAS(__floatdidf, __aeabi_l2d)
#endif
#endif

compiler-rt/lib/builtins/floatdisf.c

Show All 13 Lines
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// di_int is a 64 bit integral type // di_int is a 64 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI float __floatdisf(di_int a) { DECLARE_LIBCALL(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
si_int e = sd - 1; // exponent si_int e = sd - 1; // exponent
if (sd > FLT_MANT_DIG) { if (sd > FLT_MANT_DIG) {
Show All 30 LinesDECLARE_LIBCALL(float, __floatdisf, di_int a) {
} }
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__) AUX_DECLS(__floatdisf)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_l2f(di_int a) { return __floatdisf(a); }
#else
COMPILER_RT_ALIAS(__floatdisf, __aeabi_l2f)
#endif
#endif

compiler-rt/lib/builtins/floatditf.c

Show All 10 Lines
// mode. // mode.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatditf(di_int a) { DECLARE_LIBCALL(fp_t, __floatditf, di_int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
Show All 22 Lines

compiler-rt/lib/builtins/floatdixf.c

Show All 17 Lines
// 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) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/floatsidf.c

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI fp_t __floatsidf(si_int a) { DECLARE_LIBCALL(fp_t, __floatsidf, si_int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
Show All 14 LinesDECLARE_LIBCALL(fp_t, __floatsidf, si_int a) {
result = (rep_t)(su_int)a << shift ^ implicitBit; result = (rep_t)(su_int)a << shift ^ implicitBit;
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
// Insert the sign bit and return // Insert the sign bit and return
return fromRep(result | sign); return fromRep(result | sign);
} }
#if defined(__ARM_EABI__) AUX_DECLS(__floatsidf)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_i2d(si_int a) { return __floatsidf(a); }
#else
COMPILER_RT_ALIAS(__floatsidf, __aeabi_i2d)
#endif
#endif

compiler-rt/lib/builtins/floatsisf.c

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI fp_t __floatsisf(int a) { DECLARE_LIBCALL(fp_t, __floatsisf, int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
Show All 22 LinesDECLARE_LIBCALL(fp_t, __floatsisf, int a) {
} }
// Insert the exponent // Insert the exponent
result += (rep_t)(exponent + exponentBias) << significandBits; result += (rep_t)(exponent + exponentBias) << significandBits;
// Insert the sign bit and return // Insert the sign bit and return
return fromRep(result | sign); return fromRep(result | sign);
} }
#if defined(__ARM_EABI__) AUX_DECLS(__floatsisf)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_i2f(int a) { return __floatsisf(a); }
#else
COMPILER_RT_ALIAS(__floatsisf, __aeabi_i2f)
#endif
#endif

compiler-rt/lib/builtins/floatsitf.c

Show All 10 Lines
// mode. // mode.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatsitf(int a) { DECLARE_LIBCALL(fp_t, __floatsitf, int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// All other cases begin by extracting the sign and absolute value of a // All other cases begin by extracting the sign and absolute value of a
Show All 22 Lines

compiler-rt/lib/builtins/floattidf.c

Show All 16 Lines
// Returns: convert a to a double, rounding toward even. // Returns: convert a to a double, rounding toward even.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// 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) { DECLARE_LIBCALL(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) {
Show All 40 Lines

compiler-rt/lib/builtins/floattisf.c

Show All 15 Lines
// 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) { DECLARE_LIBCALL(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) {
Show All 39 Lines

compiler-rt/lib/builtins/floattitf.c

Show All 20 Lines
// 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) { DECLARE_LIBCALL(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) {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

compiler-rt/lib/builtins/floattixf.c

Show All 17 Lines
// 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) { DECLARE_LIBCALL(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) {
Show All 39 Lines

compiler-rt/lib/builtins/floatundidf.c

Show All 18 Lines
// 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) { DECLARE_LIBCALL(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;
Show All 10 LinesDECLARE_LIBCALL(double, __floatundidf, du_int a) {
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) { DECLARE_LIBCALL(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
Show All 29 LinesDECLARE_LIBCALL(double, __floatundidf, du_int a) {
double_bits fb; double_bits fb;
fb.u.s.high = ((su_int)(e + 1023) << 20) | // exponent fb.u.s.high = ((su_int)(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__) AUX_DECLS(__floatundidf)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI double __aeabi_ul2d(du_int a) { return __floatundidf(a); }
#else
COMPILER_RT_ALIAS(__floatundidf, __aeabi_ul2d)
#endif
#endif

compiler-rt/lib/builtins/floatundisf.c

Show All 13 Lines
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
#include "int_lib.h" #include "int_lib.h"
COMPILER_RT_ABI float __floatundisf(du_int a) { DECLARE_LIBCALL(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
si_int e = sd - 1; // 8 exponent si_int e = sd - 1; // 8 exponent
if (sd > FLT_MANT_DIG) { if (sd > FLT_MANT_DIG) {
// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
Show All 27 Lines if (sd > FLT_MANT_DIG) {
// 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__) AUX_DECLS(__floatundisf)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI float __aeabi_ul2f(du_int a) { return __floatundisf(a); }
#else
COMPILER_RT_ALIAS(__floatundisf, __aeabi_ul2f)
#endif
#endif

compiler-rt/lib/builtins/floatunditf.c

Show All 10 Lines
// mode. // mode.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatunditf(du_int a) { DECLARE_LIBCALL(fp_t, __floatunditf, du_int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
Show All 13 Lines

compiler-rt/lib/builtins/floatundixf.c

Show All 16 Lines
// 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) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/floatunsidf.c

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

compiler-rt/lib/builtins/floatunsisf.c

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

compiler-rt/lib/builtins/floatunsitf.c

Show All 10 Lines
// mode. // mode.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __floatunsitf(unsigned int a) { DECLARE_LIBCALL(fp_t, __floatunsitf, unsigned int a) {
const int aWidth = sizeof a * CHAR_BIT; const int aWidth = sizeof a * CHAR_BIT;
// Handle zero as a special case to protect clz // Handle zero as a special case to protect clz
if (a == 0) if (a == 0)
return fromRep(0); return fromRep(0);
// Exponent of (fp_t)a is the width of abs(a). // Exponent of (fp_t)a is the width of abs(a).
Show All 13 Lines

compiler-rt/lib/builtins/floatuntidf.c

Show All 16 Lines
// Returns: convert a to a double, rounding toward even. // Returns: convert a to a double, rounding toward even.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// 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) { DECLARE_LIBCALL(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
Show All 37 Lines

compiler-rt/lib/builtins/floatuntisf.c

Show All 15 Lines
// 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) { DECLARE_LIBCALL(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
Show All 36 Lines

compiler-rt/lib/builtins/floatuntitf.c

Show All 20 Lines
// 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) { DECLARE_LIBCALL(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
Show All 38 Lines

compiler-rt/lib/builtins/floatuntixf.c

Show All 17 Lines
// 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) { DECLARE_LIBCALL(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
Show All 36 Lines

compiler-rt/lib/builtins/fp_lib.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
static __inline int rep_clz(rep_t a) { return clzsi(a); } static __inline int rep_clz(rep_t a) { return clzsi(a); }
// 32x32 --> 64 bit multiply // 32x32 --> 64 bit multiply
static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
const uint64_t product = (uint64_t)a * b; const uint64_t product = (uint64_t)a * b;
*hi = product >> 32; *hi = product >> 32;
*lo = product; *lo = product;
} }
COMPILER_RT_ABI fp_t __addsf3(fp_t a, fp_t b); DECLARE_LIBCALL(fp_t, __addsf3, fp_t a, fp_t b);
#elif defined DOUBLE_PRECISION #elif defined DOUBLE_PRECISION
typedef uint64_t rep_t; typedef uint64_t rep_t;
typedef int64_t srep_t; typedef int64_t srep_t;
typedef double fp_t; typedef double fp_t;
#define REP_C UINT64_C #define REP_C UINT64_C
#define significandBits 52 #define significandBits 52
Show All 26 Linesstatic __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
const uint64_t r1 = hiWord(plolo) + loWord(plohi) + loWord(philo); const uint64_t r1 = hiWord(plolo) + loWord(plohi) + loWord(philo);
*lo = r0 + (r1 << 32); *lo = r0 + (r1 << 32);
// Sum terms contributing to hi with the carry from lo // Sum terms contributing to hi with the carry from lo
*hi = hiWord(plohi) + hiWord(philo) + hiWord(r1) + phihi; *hi = hiWord(plohi) + hiWord(philo) + hiWord(r1) + phihi;
} }
#undef loWord #undef loWord
#undef hiWord #undef hiWord
COMPILER_RT_ABI fp_t __adddf3(fp_t a, fp_t b); DECLARE_LIBCALL(fp_t, __adddf3, fp_t a, fp_t b);
#elif defined QUAD_PRECISION #elif defined QUAD_PRECISION
#if __LDBL_MANT_DIG__ == 113 && defined(__SIZEOF_INT128__) #if __LDBL_MANT_DIG__ == 113 && defined(__SIZEOF_INT128__)
#define CRT_LDBL_128BIT #define CRT_LDBL_128BIT
typedef __uint128_t rep_t; typedef __uint128_t rep_t;
typedef __int128_t srep_t; typedef __int128_t srep_t;
typedef long double fp_t; typedef long double fp_t;
#define REP_C (__uint128_t) #define REP_C (__uint128_t)
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
#undef Word_2 #undef Word_2
#undef Word_3 #undef Word_3
#undef Word_4 #undef Word_4
#undef Word_HiMask #undef Word_HiMask
#undef Word_LoMask #undef Word_LoMask
#undef Word_FullMask #undef Word_FullMask
#endif // __LDBL_MANT_DIG__ == 113 && __SIZEOF_INT128__ #endif // __LDBL_MANT_DIG__ == 113 && __SIZEOF_INT128__
#else #else
#error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined. #error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined.
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined. [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined. [clang…
#endif #endif
#if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) || \ #if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) || \
defined(CRT_LDBL_128BIT) defined(CRT_LDBL_128BIT)
#define typeWidth (sizeof(rep_t) * CHAR_BIT) #define typeWidth (sizeof(rep_t) * CHAR_BIT)
#define exponentBits (typeWidth - significandBits - 1) #define exponentBits (typeWidth - significandBits - 1)
#define maxExponent ((1 << exponentBits) - 1) #define maxExponent ((1 << exponentBits) - 1)
#define exponentBias (maxExponent >> 1) #define exponentBias (maxExponent >> 1)
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

compiler-rt/lib/builtins/gcc_personality_v0.c

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
// 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( DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_sj0,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_sj0, 
-    int version, _Unwind_Action actions, uint64_t exceptionClass,
-    struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
+DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_sj0, int version,
+                _Unwind_Action actions, uint64_t exceptionClass,
+                struct _Unwind_Exception *exceptionObject,
+                struct _Unwind_Context *context)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(_Unwind_Reason_Code…
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( DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_v0,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_v0, 
-    _Unwind_State state, struct _Unwind_Exception *exceptionObject,
-    struct _Unwind_Context *context)
+DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_v0, _Unwind_State state,
+                struct _Unwind_Exception *exceptionObject,
+                struct _Unwind_Context *context)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(_Unwind_Reason_Code…
_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( DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_v0,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_v0, 
-    int version, _Unwind_Action actions, uint64_t exceptionClass,
-    struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
+DECLARE_LIBCALL(_Unwind_Reason_Code, __gcc_personality_v0, int version,
+                _Unwind_Action actions, uint64_t exceptionClass,
+                struct _Unwind_Exception *exceptionObject,
+                struct _Unwind_Context *context)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(_Unwind_Reason_Code…
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
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

compiler-rt/lib/builtins/int_lib.h

Show All 15 Lines
// 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).
// ABI macro definitions // ABI macro definitions
#if __ARM_EABI__ #if __ARM_EABI__
#ifdef COMPILER_RT_ARMHF_TARGET #include "arm-libcall-overrides.h"
#define COMPILER_RT_ABI
#else
#define COMPILER_RT_ABI __attribute__((__pcs__("aapcs")))
#endif #endif
#else
#ifndef COMPILER_RT_ABI
#define COMPILER_RT_ABI #define COMPILER_RT_ABI
#endif #endif
#define AEABI_RTABI __attribute__((__pcs__("aapcs"))) #include "libcall-set-defaults.inc"
#define DECLARE_LIBCALL(rettype, libcall_name, ...) \
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#define DECLARE_LIBCALL(rettype, libcall_name, ...) \
+#define DECLARE_LIBCALL(rettype, libcall_name, ...)                            \
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#define DECLARE_LIBCALL(rettype, libcall_name, ...)…
ATTR##libcall_name rettype libcall_name(__VA_ARGS__)
#define AUX_DECLS(libcall_name) AUX_DECLS##libcall_name
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
#define ALWAYS_INLINE __forceinline #define ALWAYS_INLINE __forceinline
#define NOINLINE __declspec(noinline) #define NOINLINE __declspec(noinline)
#define NORETURN __declspec(noreturn) #define NORETURN __declspec(noreturn)
#define UNUSED #define UNUSED
#else #else
#define ALWAYS_INLINE __attribute__((always_inline)) #define ALWAYS_INLINE __attribute__((always_inline))
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
#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 int __paritysi2(si_int a); DECLARE_LIBCALL(int, __paritysi2, si_int a);
COMPILER_RT_ABI int __paritydi2(di_int a); DECLARE_LIBCALL(int, __paritydi2, di_int a);
COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b); DECLARE_LIBCALL(di_int, __divdi3, di_int a, di_int b);
COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b); DECLARE_LIBCALL(si_int, __divsi3, si_int a, si_int b);
COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d); DECLARE_LIBCALL(su_int, __udivsi3, su_int n, su_int d);
COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int *rem); DECLARE_LIBCALL(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); DECLARE_LIBCALL(du_int, __udivmoddi4, du_int a, du_int b, du_int *rem);
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
COMPILER_RT_ABI int __clzti2(ti_int a); DECLARE_LIBCALL(int, __clzti2, ti_int a);
COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int *rem); DECLARE_LIBCALL(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>
int __inline __builtin_ctz(uint32_t value) { int __inline __builtin_ctz(uint32_t value) {
unsigned long trailing_zero = 0; unsigned long trailing_zero = 0;
Show All 35 Lines

compiler-rt/lib/builtins/libcall-set-defaults.inc

  • This file was added.
//===-- libcall-set-defaults.inc ------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file is not part of the interface of this library.
//
// The particular target implementation can define some macroses customizing
// target-specific aliases, calling conventions, etc. After that, this file
// sets the default values for everything not yet set.
//
// DO NOT EDIT! This file was auto-generated by:
//
// ../../utils/generate_builtins_macro.sh > libcall-set-defaults.inc
//
//===----------------------------------------------------------------------===//
#ifndef LIBCALL_DEFAULTS
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: header guard does not follow preferred style [llvm-header-guard]
not useful

Lint: Pre-merge checks: clang-tidy: warning: header guard does not follow preferred style [llvm-header-guard] [[https…
#define LIBCALL_DEFAULTS
// Special LibCall attributes, empty by default
#ifndef ATTR__absvdi2
#define ATTR__absvdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__absvsi2
#define ATTR__absvsi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__absvti2
#define ATTR__absvti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__adddf3
#define ATTR__adddf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__addsf3
#define ATTR__addsf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__addtf3
#define ATTR__addtf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__addvdi3
#define ATTR__addvdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__addvsi3
#define ATTR__addvsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__addvti3
#define ATTR__addvti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__aeabi_lcmp
#define ATTR__aeabi_lcmp COMPILER_RT_ABI
#endif
#ifndef ATTR__aeabi_ulcmp
#define ATTR__aeabi_ulcmp COMPILER_RT_ABI
#endif
#ifndef ATTR__ashldi3
#define ATTR__ashldi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__ashlti3
#define ATTR__ashlti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__ashrdi3
#define ATTR__ashrdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__ashrti3
#define ATTR__ashrti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__bswapdi2
#define ATTR__bswapdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__bswapsi2
#define ATTR__bswapsi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__clzdi2
#define ATTR__clzdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__clzsi2
#define ATTR__clzsi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__clzti2
#define ATTR__clzti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__cmpdi2
#define ATTR__cmpdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__cmpti2
#define ATTR__cmpti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ctzdi2
#define ATTR__ctzdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ctzsi2
#define ATTR__ctzsi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ctzti2
#define ATTR__ctzti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__divdc3
#define ATTR__divdc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divdf3
#define ATTR__divdf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divdi3
#define ATTR__divdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divmoddi4
#define ATTR__divmoddi4 COMPILER_RT_ABI
#endif
#ifndef ATTR__divmodsi4
#define ATTR__divmodsi4 COMPILER_RT_ABI
#endif
#ifndef ATTR__divsc3
#define ATTR__divsc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divsf3
#define ATTR__divsf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divsi3
#define ATTR__divsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divtc3
#define ATTR__divtc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divtf3
#define ATTR__divtf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divti3
#define ATTR__divti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__divxc3
#define ATTR__divxc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__dtoi64
#define ATTR__dtoi64 COMPILER_RT_ABI
#endif
#ifndef ATTR__dtou64
#define ATTR__dtou64 COMPILER_RT_ABI
#endif
#ifndef ATTR__enable_execute_stack
#define ATTR__enable_execute_stack COMPILER_RT_ABI
#endif
#ifndef ATTR__eprintf
#define ATTR__eprintf COMPILER_RT_ABI
#endif
#ifndef ATTR__extenddftf2
#define ATTR__extenddftf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__extendhfsf2
#define ATTR__extendhfsf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__extendsfdf2
#define ATTR__extendsfdf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__extendsftf2
#define ATTR__extendsftf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ffsdi2
#define ATTR__ffsdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ffssi2
#define ATTR__ffssi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ffsti2
#define ATTR__ffsti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__fixdfdi
#define ATTR__fixdfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixdfsi
#define ATTR__fixdfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixdfti
#define ATTR__fixdfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixsfdi
#define ATTR__fixsfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixsfsi
#define ATTR__fixsfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixsfti
#define ATTR__fixsfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixtfdi
#define ATTR__fixtfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixtfsi
#define ATTR__fixtfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixtfti
#define ATTR__fixtfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunsdfdi
#define ATTR__fixunsdfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunsdfsi
#define ATTR__fixunsdfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunsdfti
#define ATTR__fixunsdfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunssfdi
#define ATTR__fixunssfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunssfsi
#define ATTR__fixunssfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunssfti
#define ATTR__fixunssfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunstfdi
#define ATTR__fixunstfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunstfsi
#define ATTR__fixunstfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunstfti
#define ATTR__fixunstfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunsxfdi
#define ATTR__fixunsxfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunsxfsi
#define ATTR__fixunsxfsi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixunsxfti
#define ATTR__fixunsxfti COMPILER_RT_ABI
#endif
#ifndef ATTR__fixxfdi
#define ATTR__fixxfdi COMPILER_RT_ABI
#endif
#ifndef ATTR__fixxfti
#define ATTR__fixxfti COMPILER_RT_ABI
#endif
#ifndef ATTR__floatdidf
#define ATTR__floatdidf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatdisf
#define ATTR__floatdisf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatditf
#define ATTR__floatditf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatdixf
#define ATTR__floatdixf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatsidf
#define ATTR__floatsidf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatsisf
#define ATTR__floatsisf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatsitf
#define ATTR__floatsitf COMPILER_RT_ABI
#endif
#ifndef ATTR__floattidf
#define ATTR__floattidf COMPILER_RT_ABI
#endif
#ifndef ATTR__floattisf
#define ATTR__floattisf COMPILER_RT_ABI
#endif
#ifndef ATTR__floattitf
#define ATTR__floattitf COMPILER_RT_ABI
#endif
#ifndef ATTR__floattixf
#define ATTR__floattixf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatundidf
#define ATTR__floatundidf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatundisf
#define ATTR__floatundisf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatunditf
#define ATTR__floatunditf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatundixf
#define ATTR__floatundixf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatunsidf
#define ATTR__floatunsidf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatunsisf
#define ATTR__floatunsisf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatunsitf
#define ATTR__floatunsitf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatuntidf
#define ATTR__floatuntidf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatuntisf
#define ATTR__floatuntisf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatuntitf
#define ATTR__floatuntitf COMPILER_RT_ABI
#endif
#ifndef ATTR__floatuntixf
#define ATTR__floatuntixf COMPILER_RT_ABI
#endif
#ifndef ATTR__gcc_personality_sj0
#define ATTR__gcc_personality_sj0 COMPILER_RT_ABI
#endif
#ifndef ATTR__gcc_personality_v0
#define ATTR__gcc_personality_v0 COMPILER_RT_ABI
#endif
#ifndef ATTR__gedf2
#define ATTR__gedf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__gesf2
#define ATTR__gesf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__getf2
#define ATTR__getf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__gnu_f2h_ieee
#define ATTR__gnu_f2h_ieee COMPILER_RT_ABI
#endif
#ifndef ATTR__gnu_h2f_ieee
#define ATTR__gnu_h2f_ieee COMPILER_RT_ABI
#endif
#ifndef ATTR__i64tod
#define ATTR__i64tod COMPILER_RT_ABI
#endif
#ifndef ATTR__i64tos
#define ATTR__i64tos COMPILER_RT_ABI
#endif
#ifndef ATTR__ledf2
#define ATTR__ledf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__lesf2
#define ATTR__lesf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__letf2
#define ATTR__letf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__lshrdi3
#define ATTR__lshrdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__lshrti3
#define ATTR__lshrti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__moddi3
#define ATTR__moddi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__modsi3
#define ATTR__modsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__modti3
#define ATTR__modti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__muldc3
#define ATTR__muldc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__muldf3
#define ATTR__muldf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__muldi3
#define ATTR__muldi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulodi4
#define ATTR__mulodi4 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulosi4
#define ATTR__mulosi4 COMPILER_RT_ABI
#endif
#ifndef ATTR__muloti4
#define ATTR__muloti4 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulsc3
#define ATTR__mulsc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulsf3
#define ATTR__mulsf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__multc3
#define ATTR__multc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__multf3
#define ATTR__multf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__multi3
#define ATTR__multi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulvdi3
#define ATTR__mulvdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulvsi3
#define ATTR__mulvsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulvti3
#define ATTR__mulvti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__mulxc3
#define ATTR__mulxc3 COMPILER_RT_ABI
#endif
#ifndef ATTR__negdf2
#define ATTR__negdf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__negdi2
#define ATTR__negdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__negsf2
#define ATTR__negsf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__negti2
#define ATTR__negti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__negvdi2
#define ATTR__negvdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__negvsi2
#define ATTR__negvsi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__negvti2
#define ATTR__negvti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__paritydi2
#define ATTR__paritydi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__paritysi2
#define ATTR__paritysi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__parityti2
#define ATTR__parityti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__popcountdi2
#define ATTR__popcountdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__popcountsi2
#define ATTR__popcountsi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__popcountti2
#define ATTR__popcountti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__powidf2
#define ATTR__powidf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__powisf2
#define ATTR__powisf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__powitf2
#define ATTR__powitf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__powixf2
#define ATTR__powixf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__stoi64
#define ATTR__stoi64 COMPILER_RT_ABI
#endif
#ifndef ATTR__stou64
#define ATTR__stou64 COMPILER_RT_ABI
#endif
#ifndef ATTR__subdf3
#define ATTR__subdf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__subsf3
#define ATTR__subsf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__subtf3
#define ATTR__subtf3 COMPILER_RT_ABI
#endif
#ifndef ATTR__subvdi3
#define ATTR__subvdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__subvsi3
#define ATTR__subvsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__subvti3
#define ATTR__subvti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__trampoline_setup
#define ATTR__trampoline_setup COMPILER_RT_ABI
#endif
#ifndef ATTR__truncdfhf2
#define ATTR__truncdfhf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__truncdfsf2
#define ATTR__truncdfsf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__truncsfhf2
#define ATTR__truncsfhf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__trunctfdf2
#define ATTR__trunctfdf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__trunctfsf2
#define ATTR__trunctfsf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__u64tod
#define ATTR__u64tod COMPILER_RT_ABI
#endif
#ifndef ATTR__u64tos
#define ATTR__u64tos COMPILER_RT_ABI
#endif
#ifndef ATTR__ucmpdi2
#define ATTR__ucmpdi2 COMPILER_RT_ABI
#endif
#ifndef ATTR__ucmpti2
#define ATTR__ucmpti2 COMPILER_RT_ABI
#endif
#ifndef ATTR__udivdi3
#define ATTR__udivdi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__udivmoddi4
#define ATTR__udivmoddi4 COMPILER_RT_ABI
#endif
#ifndef ATTR__udivmodsi4
#define ATTR__udivmodsi4 COMPILER_RT_ABI
#endif
#ifndef ATTR__udivmodti4
#define ATTR__udivmodti4 COMPILER_RT_ABI
#endif
#ifndef ATTR__udivsi3
#define ATTR__udivsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__udivti3
#define ATTR__udivti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__umoddi3
#define ATTR__umoddi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__umodsi3
#define ATTR__umodsi3 COMPILER_RT_ABI
#endif
#ifndef ATTR__umodti3
#define ATTR__umodti3 COMPILER_RT_ABI
#endif
#ifndef ATTR__unordsf2
#define ATTR__unordsf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__unorddf2
#define ATTR__unorddf2 COMPILER_RT_ABI
#endif
#ifndef ATTR__unordtf2
#define ATTR__unordtf2 COMPILER_RT_ABI
#endif
// Misc auxiliary declarations to place at the end of source file
#ifndef AUX_DECLS__absvdi2
#define AUX_DECLS__absvdi2
#endif
#ifndef AUX_DECLS__absvsi2
#define AUX_DECLS__absvsi2
#endif
#ifndef AUX_DECLS__absvti2
#define AUX_DECLS__absvti2
#endif
#ifndef AUX_DECLS__adddf3
#define AUX_DECLS__adddf3
#endif
#ifndef AUX_DECLS__addsf3
#define AUX_DECLS__addsf3
#endif
#ifndef AUX_DECLS__addtf3
#define AUX_DECLS__addtf3
#endif
#ifndef AUX_DECLS__addvdi3
#define AUX_DECLS__addvdi3
#endif
#ifndef AUX_DECLS__addvsi3
#define AUX_DECLS__addvsi3
#endif
#ifndef AUX_DECLS__addvti3
#define AUX_DECLS__addvti3
#endif
#ifndef AUX_DECLS__aeabi_lcmp
#define AUX_DECLS__aeabi_lcmp
#endif
#ifndef AUX_DECLS__aeabi_ulcmp
#define AUX_DECLS__aeabi_ulcmp
#endif
#ifndef AUX_DECLS__ashldi3
#define AUX_DECLS__ashldi3
#endif
#ifndef AUX_DECLS__ashlti3
#define AUX_DECLS__ashlti3
#endif
#ifndef AUX_DECLS__ashrdi3
#define AUX_DECLS__ashrdi3
#endif
#ifndef AUX_DECLS__ashrti3
#define AUX_DECLS__ashrti3
#endif
#ifndef AUX_DECLS__bswapdi2
#define AUX_DECLS__bswapdi2
#endif
#ifndef AUX_DECLS__bswapsi2
#define AUX_DECLS__bswapsi2
#endif
#ifndef AUX_DECLS__clzdi2
#define AUX_DECLS__clzdi2
#endif
#ifndef AUX_DECLS__clzsi2
#define AUX_DECLS__clzsi2
#endif
#ifndef AUX_DECLS__clzti2
#define AUX_DECLS__clzti2
#endif
#ifndef AUX_DECLS__cmpdi2
#define AUX_DECLS__cmpdi2
#endif
#ifndef AUX_DECLS__cmpti2
#define AUX_DECLS__cmpti2
#endif
#ifndef AUX_DECLS__ctzdi2
#define AUX_DECLS__ctzdi2
#endif
#ifndef AUX_DECLS__ctzsi2
#define AUX_DECLS__ctzsi2
#endif
#ifndef AUX_DECLS__ctzti2
#define AUX_DECLS__ctzti2
#endif
#ifndef AUX_DECLS__divdc3
#define AUX_DECLS__divdc3
#endif
#ifndef AUX_DECLS__divdf3
#define AUX_DECLS__divdf3
#endif
#ifndef AUX_DECLS__divdi3
#define AUX_DECLS__divdi3
#endif
#ifndef AUX_DECLS__divmoddi4
#define AUX_DECLS__divmoddi4
#endif
#ifndef AUX_DECLS__divmodsi4
#define AUX_DECLS__divmodsi4
#endif
#ifndef AUX_DECLS__divsc3
#define AUX_DECLS__divsc3
#endif
#ifndef AUX_DECLS__divsf3
#define AUX_DECLS__divsf3
#endif
#ifndef AUX_DECLS__divsi3
#define AUX_DECLS__divsi3
#endif
#ifndef AUX_DECLS__divtc3
#define AUX_DECLS__divtc3
#endif
#ifndef AUX_DECLS__divtf3
#define AUX_DECLS__divtf3
#endif
#ifndef AUX_DECLS__divti3
#define AUX_DECLS__divti3
#endif
#ifndef AUX_DECLS__divxc3
#define AUX_DECLS__divxc3
#endif
#ifndef AUX_DECLS__dtoi64
#define AUX_DECLS__dtoi64
#endif
#ifndef AUX_DECLS__dtou64
#define AUX_DECLS__dtou64
#endif
#ifndef AUX_DECLS__enable_execute_stack
#define AUX_DECLS__enable_execute_stack
#endif
#ifndef AUX_DECLS__eprintf
#define AUX_DECLS__eprintf
#endif
#ifndef AUX_DECLS__extenddftf2
#define AUX_DECLS__extenddftf2
#endif
#ifndef AUX_DECLS__extendhfsf2
#define AUX_DECLS__extendhfsf2
#endif
#ifndef AUX_DECLS__extendsfdf2
#define AUX_DECLS__extendsfdf2
#endif
#ifndef AUX_DECLS__extendsftf2
#define AUX_DECLS__extendsftf2
#endif
#ifndef AUX_DECLS__ffsdi2
#define AUX_DECLS__ffsdi2
#endif
#ifndef AUX_DECLS__ffssi2
#define AUX_DECLS__ffssi2
#endif
#ifndef AUX_DECLS__ffsti2
#define AUX_DECLS__ffsti2
#endif
#ifndef AUX_DECLS__fixdfdi
#define AUX_DECLS__fixdfdi
#endif
#ifndef AUX_DECLS__fixdfsi
#define AUX_DECLS__fixdfsi
#endif
#ifndef AUX_DECLS__fixdfti
#define AUX_DECLS__fixdfti
#endif
#ifndef AUX_DECLS__fixsfdi
#define AUX_DECLS__fixsfdi
#endif
#ifndef AUX_DECLS__fixsfsi
#define AUX_DECLS__fixsfsi
#endif
#ifndef AUX_DECLS__fixsfti
#define AUX_DECLS__fixsfti
#endif
#ifndef AUX_DECLS__fixtfdi
#define AUX_DECLS__fixtfdi
#endif
#ifndef AUX_DECLS__fixtfsi
#define AUX_DECLS__fixtfsi
#endif
#ifndef AUX_DECLS__fixtfti
#define AUX_DECLS__fixtfti
#endif
#ifndef AUX_DECLS__fixunsdfdi
#define AUX_DECLS__fixunsdfdi
#endif
#ifndef AUX_DECLS__fixunsdfsi
#define AUX_DECLS__fixunsdfsi
#endif
#ifndef AUX_DECLS__fixunsdfti
#define AUX_DECLS__fixunsdfti
#endif
#ifndef AUX_DECLS__fixunssfdi
#define AUX_DECLS__fixunssfdi
#endif
#ifndef AUX_DECLS__fixunssfsi
#define AUX_DECLS__fixunssfsi
#endif
#ifndef AUX_DECLS__fixunssfti
#define AUX_DECLS__fixunssfti
#endif
#ifndef AUX_DECLS__fixunstfdi
#define AUX_DECLS__fixunstfdi
#endif
#ifndef AUX_DECLS__fixunstfsi
#define AUX_DECLS__fixunstfsi
#endif
#ifndef AUX_DECLS__fixunstfti
#define AUX_DECLS__fixunstfti
#endif
#ifndef AUX_DECLS__fixunsxfdi
#define AUX_DECLS__fixunsxfdi
#endif
#ifndef AUX_DECLS__fixunsxfsi
#define AUX_DECLS__fixunsxfsi
#endif
#ifndef AUX_DECLS__fixunsxfti
#define AUX_DECLS__fixunsxfti
#endif
#ifndef AUX_DECLS__fixxfdi
#define AUX_DECLS__fixxfdi
#endif
#ifndef AUX_DECLS__fixxfti
#define AUX_DECLS__fixxfti
#endif
#ifndef AUX_DECLS__floatdidf
#define AUX_DECLS__floatdidf
#endif
#ifndef AUX_DECLS__floatdisf
#define AUX_DECLS__floatdisf
#endif
#ifndef AUX_DECLS__floatditf
#define AUX_DECLS__floatditf
#endif
#ifndef AUX_DECLS__floatdixf
#define AUX_DECLS__floatdixf
#endif
#ifndef AUX_DECLS__floatsidf
#define AUX_DECLS__floatsidf
#endif
#ifndef AUX_DECLS__floatsisf
#define AUX_DECLS__floatsisf
#endif
#ifndef AUX_DECLS__floatsitf
#define AUX_DECLS__floatsitf
#endif
#ifndef AUX_DECLS__floattidf
#define AUX_DECLS__floattidf
#endif
#ifndef AUX_DECLS__floattisf
#define AUX_DECLS__floattisf
#endif
#ifndef AUX_DECLS__floattitf
#define AUX_DECLS__floattitf
#endif
#ifndef AUX_DECLS__floattixf
#define AUX_DECLS__floattixf
#endif
#ifndef AUX_DECLS__floatundidf
#define AUX_DECLS__floatundidf
#endif
#ifndef AUX_DECLS__floatundisf
#define AUX_DECLS__floatundisf
#endif
#ifndef AUX_DECLS__floatunditf
#define AUX_DECLS__floatunditf
#endif
#ifndef AUX_DECLS__floatundixf
#define AUX_DECLS__floatundixf
#endif
#ifndef AUX_DECLS__floatunsidf
#define AUX_DECLS__floatunsidf
#endif
#ifndef AUX_DECLS__floatunsisf
#define AUX_DECLS__floatunsisf
#endif
#ifndef AUX_DECLS__floatunsitf
#define AUX_DECLS__floatunsitf
#endif
#ifndef AUX_DECLS__floatuntidf
#define AUX_DECLS__floatuntidf
#endif
#ifndef AUX_DECLS__floatuntisf
#define AUX_DECLS__floatuntisf
#endif
#ifndef AUX_DECLS__floatuntitf
#define AUX_DECLS__floatuntitf
#endif
#ifndef AUX_DECLS__floatuntixf
#define AUX_DECLS__floatuntixf
#endif
#ifndef AUX_DECLS__gcc_personality_sj0
#define AUX_DECLS__gcc_personality_sj0
#endif
#ifndef AUX_DECLS__gcc_personality_v0
#define AUX_DECLS__gcc_personality_v0
#endif
#ifndef AUX_DECLS__gedf2
#define AUX_DECLS__gedf2
#endif
#ifndef AUX_DECLS__gesf2
#define AUX_DECLS__gesf2
#endif
#ifndef AUX_DECLS__getf2
#define AUX_DECLS__getf2
#endif
#ifndef AUX_DECLS__gnu_f2h_ieee
#define AUX_DECLS__gnu_f2h_ieee
#endif
#ifndef AUX_DECLS__gnu_h2f_ieee
#define AUX_DECLS__gnu_h2f_ieee
#endif
#ifndef AUX_DECLS__i64tod
#define AUX_DECLS__i64tod
#endif
#ifndef AUX_DECLS__i64tos
#define AUX_DECLS__i64tos
#endif
#ifndef AUX_DECLS__ledf2
#define AUX_DECLS__ledf2
#endif
#ifndef AUX_DECLS__lesf2
#define AUX_DECLS__lesf2
#endif
#ifndef AUX_DECLS__letf2
#define AUX_DECLS__letf2
#endif
#ifndef AUX_DECLS__lshrdi3
#define AUX_DECLS__lshrdi3
#endif
#ifndef AUX_DECLS__lshrti3
#define AUX_DECLS__lshrti3
#endif
#ifndef AUX_DECLS__moddi3
#define AUX_DECLS__moddi3
#endif
#ifndef AUX_DECLS__modsi3
#define AUX_DECLS__modsi3
#endif
#ifndef AUX_DECLS__modti3
#define AUX_DECLS__modti3
#endif
#ifndef AUX_DECLS__muldc3
#define AUX_DECLS__muldc3
#endif
#ifndef AUX_DECLS__muldf3
#define AUX_DECLS__muldf3
#endif
#ifndef AUX_DECLS__muldi3
#define AUX_DECLS__muldi3
#endif
#ifndef AUX_DECLS__mulodi4
#define AUX_DECLS__mulodi4
#endif
#ifndef AUX_DECLS__mulosi4
#define AUX_DECLS__mulosi4
#endif
#ifndef AUX_DECLS__muloti4
#define AUX_DECLS__muloti4
#endif
#ifndef AUX_DECLS__mulsc3
#define AUX_DECLS__mulsc3
#endif
#ifndef AUX_DECLS__mulsf3
#define AUX_DECLS__mulsf3
#endif
#ifndef AUX_DECLS__multc3
#define AUX_DECLS__multc3
#endif
#ifndef AUX_DECLS__multf3
#define AUX_DECLS__multf3
#endif
#ifndef AUX_DECLS__multi3
#define AUX_DECLS__multi3
#endif
#ifndef AUX_DECLS__mulvdi3
#define AUX_DECLS__mulvdi3
#endif
#ifndef AUX_DECLS__mulvsi3
#define AUX_DECLS__mulvsi3
#endif
#ifndef AUX_DECLS__mulvti3
#define AUX_DECLS__mulvti3
#endif
#ifndef AUX_DECLS__mulxc3
#define AUX_DECLS__mulxc3
#endif
#ifndef AUX_DECLS__negdf2
#define AUX_DECLS__negdf2
#endif
#ifndef AUX_DECLS__negdi2
#define AUX_DECLS__negdi2
#endif
#ifndef AUX_DECLS__negsf2
#define AUX_DECLS__negsf2
#endif
#ifndef AUX_DECLS__negti2
#define AUX_DECLS__negti2
#endif
#ifndef AUX_DECLS__negvdi2
#define AUX_DECLS__negvdi2
#endif
#ifndef AUX_DECLS__negvsi2
#define AUX_DECLS__negvsi2
#endif
#ifndef AUX_DECLS__negvti2
#define AUX_DECLS__negvti2
#endif
#ifndef AUX_DECLS__paritydi2
#define AUX_DECLS__paritydi2
#endif
#ifndef AUX_DECLS__paritysi2
#define AUX_DECLS__paritysi2
#endif
#ifndef AUX_DECLS__parityti2
#define AUX_DECLS__parityti2
#endif
#ifndef AUX_DECLS__popcountdi2
#define AUX_DECLS__popcountdi2
#endif
#ifndef AUX_DECLS__popcountsi2
#define AUX_DECLS__popcountsi2
#endif
#ifndef AUX_DECLS__popcountti2
#define AUX_DECLS__popcountti2
#endif
#ifndef AUX_DECLS__powidf2
#define AUX_DECLS__powidf2
#endif
#ifndef AUX_DECLS__powisf2
#define AUX_DECLS__powisf2
#endif
#ifndef AUX_DECLS__powitf2
#define AUX_DECLS__powitf2
#endif
#ifndef AUX_DECLS__powixf2
#define AUX_DECLS__powixf2
#endif
#ifndef AUX_DECLS__stoi64
#define AUX_DECLS__stoi64
#endif
#ifndef AUX_DECLS__stou64
#define AUX_DECLS__stou64
#endif
#ifndef AUX_DECLS__subdf3
#define AUX_DECLS__subdf3
#endif
#ifndef AUX_DECLS__subsf3
#define AUX_DECLS__subsf3
#endif
#ifndef AUX_DECLS__subtf3
#define AUX_DECLS__subtf3
#endif
#ifndef AUX_DECLS__subvdi3
#define AUX_DECLS__subvdi3
#endif
#ifndef AUX_DECLS__subvsi3
#define AUX_DECLS__subvsi3
#endif
#ifndef AUX_DECLS__subvti3
#define AUX_DECLS__subvti3
#endif
#ifndef AUX_DECLS__trampoline_setup
#define AUX_DECLS__trampoline_setup
#endif
#ifndef AUX_DECLS__truncdfhf2
#define AUX_DECLS__truncdfhf2
#endif
#ifndef AUX_DECLS__truncdfsf2
#define AUX_DECLS__truncdfsf2
#endif
#ifndef AUX_DECLS__truncsfhf2
#define AUX_DECLS__truncsfhf2
#endif
#ifndef AUX_DECLS__trunctfdf2
#define AUX_DECLS__trunctfdf2
#endif
#ifndef AUX_DECLS__trunctfsf2
#define AUX_DECLS__trunctfsf2
#endif
#ifndef AUX_DECLS__u64tod
#define AUX_DECLS__u64tod
#endif
#ifndef AUX_DECLS__u64tos
#define AUX_DECLS__u64tos
#endif
#ifndef AUX_DECLS__ucmpdi2
#define AUX_DECLS__ucmpdi2
#endif
#ifndef AUX_DECLS__ucmpti2
#define AUX_DECLS__ucmpti2
#endif
#ifndef AUX_DECLS__udivdi3
#define AUX_DECLS__udivdi3
#endif
#ifndef AUX_DECLS__udivmoddi4
#define AUX_DECLS__udivmoddi4
#endif
#ifndef AUX_DECLS__udivmodsi4
#define AUX_DECLS__udivmodsi4
#endif
#ifndef AUX_DECLS__udivmodti4
#define AUX_DECLS__udivmodti4
#endif
#ifndef AUX_DECLS__udivsi3
#define AUX_DECLS__udivsi3
#endif
#ifndef AUX_DECLS__udivti3
#define AUX_DECLS__udivti3
#endif
#ifndef AUX_DECLS__umoddi3
#define AUX_DECLS__umoddi3
#endif
#ifndef AUX_DECLS__umodsi3
#define AUX_DECLS__umodsi3
#endif
#ifndef AUX_DECLS__umodti3
#define AUX_DECLS__umodti3
#endif
#ifndef AUX_DECLS__unordsf2
#define AUX_DECLS__unordsf2
#endif
#ifndef AUX_DECLS__unorddf2
#define AUX_DECLS__unorddf2
#endif
#ifndef AUX_DECLS__unordtf2
#define AUX_DECLS__unordtf2
#endif
#endif // LIBCALL_DEFAULTS
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: ISO C requires a translation unit to contain at least one declaration [clang-diagnostic-empty-translation-unit]
not useful

Lint: Pre-merge checks: clang-tidy: warning: ISO C requires a translation unit to contain at least one declaration…

compiler-rt/lib/builtins/lshrdi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: logical a >> b // Returns: logical a >> b
// Precondition: 0 <= b < bits_in_dword // Precondition: 0 <= b < bits_in_dword
COMPILER_RT_ABI di_int __lshrdi3(di_int a, int b) { DECLARE_LIBCALL(di_int, __lshrdi3, di_int a, 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__) AUX_DECLS(__lshrdi3)
COMPILER_RT_ALIAS(__lshrdi3, __aeabi_llsr)
#endif

compiler-rt/lib/builtins/lshrti3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: logical a >> b // Returns: logical a >> b
// Precondition: 0 <= b < bits_in_tword // Precondition: 0 <= b < bits_in_tword
COMPILER_RT_ABI ti_int __lshrti3(ti_int a, si_int b) { DECLARE_LIBCALL(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 */ {
Show All 9 Lines

compiler-rt/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); DECLARE_LIBCALL(di_int, __fixdfdi, double a);
COMPILER_RT_ABI di_int __fixsfdi(float a); DECLARE_LIBCALL(di_int, __fixsfdi, float a);
COMPILER_RT_ABI du_int __fixunsdfdi(double a); DECLARE_LIBCALL(du_int, __fixunsdfdi, double a);
COMPILER_RT_ABI du_int __fixunssfdi(float a); DECLARE_LIBCALL(du_int, __fixunssfdi, float a);
COMPILER_RT_ABI double __floatdidf(di_int a); DECLARE_LIBCALL(double, __floatdidf, di_int a);
COMPILER_RT_ABI float __floatdisf(di_int a); DECLARE_LIBCALL(float, __floatdisf, di_int a);
COMPILER_RT_ABI double __floatundidf(du_int a); DECLARE_LIBCALL(double, __floatundidf, du_int a);
COMPILER_RT_ABI float __floatundisf(du_int a); DECLARE_LIBCALL(float, __floatundisf, du_int a);
COMPILER_RT_ABI di_int __dtoi64(double a) { return __fixdfdi(a); } DECLARE_LIBCALL(di_int, __dtoi64, double a) { return __fixdfdi(a); }
COMPILER_RT_ABI di_int __stoi64(float a) { return __fixsfdi(a); } DECLARE_LIBCALL(di_int, __stoi64, float a) { return __fixsfdi(a); }
COMPILER_RT_ABI du_int __dtou64(double a) { return __fixunsdfdi(a); } DECLARE_LIBCALL(du_int, __dtou64, double a) { return __fixunsdfdi(a); }
COMPILER_RT_ABI du_int __stou64(float a) { return __fixunssfdi(a); } DECLARE_LIBCALL(du_int, __stou64, float a) { return __fixunssfdi(a); }
COMPILER_RT_ABI double __i64tod(di_int a) { return __floatdidf(a); } DECLARE_LIBCALL(double, __i64tod, di_int a) { return __floatdidf(a); }
COMPILER_RT_ABI float __i64tos(di_int a) { return __floatdisf(a); } DECLARE_LIBCALL(float, __i64tos, di_int a) { return __floatdisf(a); }
COMPILER_RT_ABI double __u64tod(du_int a) { return __floatundidf(a); } DECLARE_LIBCALL(double, __u64tod, du_int a) { return __floatundidf(a); }
COMPILER_RT_ABI float __u64tos(du_int a) { return __floatundisf(a); } DECLARE_LIBCALL(float, __u64tos, du_int a) { return __floatundisf(a); }

compiler-rt/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) { DECLARE_LIBCALL(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
} }

compiler-rt/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) { DECLARE_LIBCALL(si_int, __modsi3, si_int a, si_int b) {
return a - __divsi3(a, b) * b; return a - __divsi3(a, b) * b;
} }

compiler-rt/lib/builtins/modti3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI ti_int __modti3(ti_int a, ti_int b) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/muldc3.c

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
// Returns: the product of a + ib and c + id // Returns: the product of a + ib and c + id
COMPILER_RT_ABI Dcomplex __muldc3(double __a, double __b, double __c, DECLARE_LIBCALL(Dcomplex, __muldc3, double __a, double __b, double __c,
double __d) { double __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                  double __d) {
+                double __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - double __d) { +…
double __ac = __a * __c; double __ac = __a * __c;
double __bd = __b * __d; double __bd = __b * __d;
double __ad = __a * __d; double __ad = __a * __d;
double __bc = __b * __c; double __bc = __b * __c;
Dcomplex z; Dcomplex z;
COMPLEX_REAL(z) = __ac - __bd; COMPLEX_REAL(z) = __ac - __bd;
COMPLEX_IMAGINARY(z) = __ad + __bc; COMPLEX_IMAGINARY(z) = __ad + __bc;
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) { if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
Show All 38 Lines

compiler-rt/lib/builtins/muldf3.c

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

compiler-rt/lib/builtins/muldi3.c

Show All 29 Linesstatic di_int __muldsi3(su_int a, su_int b) {
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) { DECLARE_LIBCALL(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__) AUX_DECLS(__muldi3)
COMPILER_RT_ALIAS(__muldi3, __aeabi_lmul)
#endif

compiler-rt/lib/builtins/mulodi4.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a * b // Returns: a * b
// Effects: sets *overflow to 1 if a * b overflows // Effects: sets *overflow to 1 if a * b overflows
COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int *overflow) { DECLARE_LIBCALL(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) {
if (b != 0 && b != 1) if (b != 0 && b != 1)
*overflow = 1; *overflow = 1;
Show All 22 Lines

compiler-rt/lib/builtins/mulosi4.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a * b // Returns: a * b
// Effects: sets *overflow to 1 if a * b overflows // Effects: sets *overflow to 1 if a * b overflows
COMPILER_RT_ABI si_int __mulosi4(si_int a, si_int b, int *overflow) { DECLARE_LIBCALL(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) {
if (b != 0 && b != 1) if (b != 0 && b != 1)
*overflow = 1; *overflow = 1;
Show All 22 Lines

compiler-rt/lib/builtins/muloti4.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a * b // Returns: a * b
// Effects: sets *overflow to 1 if a * b overflows // Effects: sets *overflow to 1 if a * b overflows
COMPILER_RT_ABI ti_int __muloti4(ti_int a, ti_int b, int *overflow) { DECLARE_LIBCALL(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) {
if (b != 0 && b != 1) if (b != 0 && b != 1)
*overflow = 1; *overflow = 1;
Show All 24 Lines

compiler-rt/lib/builtins/mulsc3.c

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
// Returns: the product of a + ib and c + id // Returns: the product of a + ib and c + id
COMPILER_RT_ABI Fcomplex __mulsc3(float __a, float __b, float __c, float __d) { DECLARE_LIBCALL(Fcomplex, __mulsc3, float __a, float __b, float __c, float __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-DECLARE_LIBCALL(Fcomplex, __mulsc3, float __a, float __b, float __c, float __d) {
+DECLARE_LIBCALL(Fcomplex, __mulsc3, float __a, float __b, float __c,
+                float __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(Fcomplex, __mulsc3, float __a…
float __ac = __a * __c; float __ac = __a * __c;
float __bd = __b * __d; float __bd = __b * __d;
float __ad = __a * __d; float __ad = __a * __d;
float __bc = __b * __c; float __bc = __b * __c;
Fcomplex z; Fcomplex z;
COMPLEX_REAL(z) = __ac - __bd; COMPLEX_REAL(z) = __ac - __bd;
COMPLEX_IMAGINARY(z) = __ad + __bc; COMPLEX_IMAGINARY(z) = __ad + __bc;
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) { if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
Show All 38 Lines

compiler-rt/lib/builtins/mulsf3.c

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

compiler-rt/lib/builtins/multc3.c

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
// Returns: the product of a + ib and c + id // Returns: the product of a + ib and c + id
COMPILER_RT_ABI long double _Complex __multc3(long double a, long double b, DECLARE_LIBCALL(long double _Complex, __multc3, long double a, long double b,
long double c, long double d) { long double c, long double d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                              long double c, long double d) {
+                long double c, long double d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - long…
long double ac = a * c; long double ac = a * c;
long double bd = b * d; long double bd = b * d;
long double ad = a * d; long double ad = a * d;
long double bc = b * c; long double bc = b * c;
long double _Complex z; long double _Complex z;
__real__ z = ac - bd; __real__ z = ac - bd;
__imag__ z = ad + bc; __imag__ z = ad + bc;
if (crt_isnan(__real__ z) && crt_isnan(__imag__ z)) { if (crt_isnan(__real__ z) && crt_isnan(__imag__ z)) {
Show All 38 Lines

compiler-rt/lib/builtins/multf3.c

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

compiler-rt/lib/builtins/multi3.c

Show All 31 Linesstatic ti_int __mulddi3(du_int a, du_int b) {
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) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/mulvdi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a * b // Returns: a * b
// Effects: aborts if a * b overflows // Effects: aborts if a * b overflows
COMPILER_RT_ABI di_int __mulvdi3(di_int a, di_int b) { DECLARE_LIBCALL(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;
compilerrt_abort(); compilerrt_abort();
} }
Show All 20 Lines

compiler-rt/lib/builtins/mulvsi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a * b // Returns: a * b
// Effects: aborts if a * b overflows // Effects: aborts if a * b overflows
COMPILER_RT_ABI si_int __mulvsi3(si_int a, si_int b) { DECLARE_LIBCALL(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;
compilerrt_abort(); compilerrt_abort();
} }
Show All 20 Lines

compiler-rt/lib/builtins/mulvti3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a * b // Returns: a * b
// Effects: aborts if a * b overflows // Effects: aborts if a * b overflows
COMPILER_RT_ABI ti_int __mulvti3(ti_int a, ti_int b) { DECLARE_LIBCALL(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;
compilerrt_abort(); compilerrt_abort();
} }
Show All 22 Lines

compiler-rt/lib/builtins/mulxc3.c

Show All 11 Lines
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
#include "int_math.h" #include "int_math.h"
// Returns: the 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, DECLARE_LIBCALL(Lcomplex, __mulxc3, long double __a, long double __b,
long double __c, long double __d) { long double __c, long double __d) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                  long double __c, long double __d) {
+                long double __c, long double __d) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - long double __c…
long double __ac = __a * __c; long double __ac = __a * __c;
long double __bd = __b * __d; long double __bd = __b * __d;
long double __ad = __a * __d; long double __ad = __a * __d;
long double __bc = __b * __c; long double __bc = __b * __c;
Lcomplex z; Lcomplex z;
COMPLEX_REAL(z) = __ac - __bd; COMPLEX_REAL(z) = __ac - __bd;
COMPLEX_IMAGINARY(z) = __ad + __bc; COMPLEX_IMAGINARY(z) = __ad + __bc;
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) { if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z))) {
Show All 40 Lines

compiler-rt/lib/builtins/negdf2.c

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

compiler-rt/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) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/negsf2.c

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

compiler-rt/lib/builtins/negti2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: -a // Returns: -a
COMPILER_RT_ABI ti_int __negti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/negvdi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: -a // Returns: -a
// Effects: aborts if -a overflows // Effects: aborts if -a overflows
COMPILER_RT_ABI di_int __negvdi2(di_int a) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/negvsi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: -a // Returns: -a
// Effects: aborts if -a overflows // Effects: aborts if -a overflows
COMPILER_RT_ABI si_int __negvsi2(si_int a) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/negvti2.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: -a // Returns: -a
// Effects: aborts if -a overflows // Effects: aborts if -a overflows
COMPILER_RT_ABI ti_int __negvti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/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 int __paritydi2(di_int a) { DECLARE_LIBCALL(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);
} }

compiler-rt/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 int __paritysi2(si_int a) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/parityti2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 int __parityti2(ti_int a) { DECLARE_LIBCALL(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

compiler-rt/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 int __popcountdi2(di_int a) { DECLARE_LIBCALL(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)
} }

compiler-rt/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 int __popcountsi2(si_int a) { DECLARE_LIBCALL(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)
} }

compiler-rt/lib/builtins/popcountti2.c

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: count of 1 bits // Returns: count of 1 bits
COMPILER_RT_ABI int __popcountti2(ti_int a) { DECLARE_LIBCALL(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)
Show All 15 Lines

compiler-rt/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, int b) { DECLARE_LIBCALL(double, __powidf2, double a, int b) {
const int recip = b < 0; const int recip = b < 0;
double r = 1; double r = 1;
while (1) { while (1) {
if (b & 1) if (b & 1)
r *= a; r *= a;
b /= 2; b /= 2;
if (b == 0) if (b == 0)
break; break;
a *= a; a *= a;
} }
return recip ? 1 / r : r; return recip ? 1 / r : r;
} }

compiler-rt/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, int b) { DECLARE_LIBCALL(float, __powisf2, float a, int b) {
const int recip = b < 0; const int recip = b < 0;
float r = 1; float r = 1;
while (1) { while (1) {
if (b & 1) if (b & 1)
r *= a; r *= a;
b /= 2; b /= 2;
if (b == 0) if (b == 0)
break; break;
a *= a; a *= a;
} }
return recip ? 1 / r : r; return recip ? 1 / r : r;
} }

compiler-rt/lib/builtins/powitf2.c

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

compiler-rt/lib/builtins/powixf2.c

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

compiler-rt/lib/builtins/subdf3.c

//===-- lib/adddf3.c - Double-precision subtraction ---------------*- C -*-===// //===-- lib/adddf3.c - Double-precision subtraction ---------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements double-precision soft-float subtraction. // This file implements double-precision soft-float subtraction.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
// Subtraction; flip the sign bit of b and add. // Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t __subdf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __subdf3, fp_t a, fp_t b) {
return __adddf3(a, fromRep(toRep(b) ^ signBit)); return __adddf3(a, fromRep(toRep(b) ^ signBit));
} }
#if defined(__ARM_EABI__) AUX_DECLS(__subdf3)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) { return __subdf3(a, b); }
#else
COMPILER_RT_ALIAS(__subdf3, __aeabi_dsub)
#endif
#endif

compiler-rt/lib/builtins/subsf3.c

//===-- lib/subsf3.c - Single-precision subtraction ---------------*- C -*-===// //===-- lib/subsf3.c - Single-precision subtraction ---------------*- C -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements single-precision soft-float subtraction. // This file implements single-precision soft-float subtraction.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
// Subtraction; flip the sign bit of b and add. // Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t __subsf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __subsf3, fp_t a, fp_t b) {
return __addsf3(a, fromRep(toRep(b) ^ signBit)); return __addsf3(a, fromRep(toRep(b) ^ signBit));
} }
#if defined(__ARM_EABI__) AUX_DECLS(__subsf3)
#if defined(COMPILER_RT_ARMHF_TARGET)
AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) { return __subsf3(a, b); }
#else
COMPILER_RT_ALIAS(__subsf3, __aeabi_fsub)
#endif
#endif

compiler-rt/lib/builtins/subtf3.c

//===-- lib/subtf3.c - Quad-precision subtraction -----------------*- C -*-===// //===-- lib/subtf3.c - Quad-precision subtraction -----------------*- 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 quad-precision soft-float subtraction. // This file implements quad-precision soft-float subtraction.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define QUAD_PRECISION #define QUAD_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b); DECLARE_LIBCALL(fp_t, __addtf3, fp_t a, fp_t b);
// Subtraction; flip the sign bit of b and add. // Subtraction; flip the sign bit of b and add.
COMPILER_RT_ABI fp_t __subtf3(fp_t a, fp_t b) { DECLARE_LIBCALL(fp_t, __subtf3, fp_t a, fp_t b) {
return __addtf3(a, fromRep(toRep(b) ^ signBit)); return __addtf3(a, fromRep(toRep(b) ^ signBit));
} }
#endif #endif

compiler-rt/lib/builtins/subvdi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a - b // Returns: a - b
// Effects: aborts if a - b overflows // Effects: aborts if a - b overflows
COMPILER_RT_ABI di_int __subvdi3(di_int a, di_int b) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/subvsi3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: a - b // Returns: a - b
// Effects: aborts if a - b overflows // Effects: aborts if a - b overflows
COMPILER_RT_ABI si_int __subvsi3(si_int a, si_int b) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/subvti3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a - b // Returns: a - b
// Effects: aborts if a - b overflows // Effects: aborts if a - b overflows
COMPILER_RT_ABI ti_int __subvti3(ti_int a, ti_int b) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/trampoline_setup.c

Show All 11 Lines
// 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, DECLARE_LIBCALL(void, __trampoline_setup, uint32_t *trampOnStack,
int trampSizeAllocated, int trampSizeAllocated,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                                        int trampSizeAllocated,
-                                        const void *realFunc, void *localsPtr) {
+                int trampSizeAllocated, const void *realFunc, void *localsPtr) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - int…
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
Show All 14 Lines

compiler-rt/lib/builtins/truncdfhf2.c

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

compiler-rt/lib/builtins/truncdfsf2.c

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

compiler-rt/lib/builtins/truncsfhf2.c

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

compiler-rt/lib/builtins/trunctfdf2.c

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

clang-format: please reformat the code

-DECLARE_LIBCALL(double, __trunctfdf2, long double a) { return __truncXfYf2__(a); }
+DECLARE_LIBCALL(double, __trunctfdf2, long double a) {
+  return __truncXfYf2__(a);
+}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(double, __trunctfdf2, long double…
#endif #endif

compiler-rt/lib/builtins/trunctfsf2.c

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

clang-format: please reformat the code

-DECLARE_LIBCALL(float, __trunctfsf2, long double a) { return __truncXfYf2__(a); }
+DECLARE_LIBCALL(float, __trunctfsf2, long double a) {
+  return __truncXfYf2__(a);
+}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -DECLARE_LIBCALL(float, __trunctfsf2, long double a)…
#endif #endif

compiler-rt/lib/builtins/ucmpdi2.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
// Returns: if (a < b) returns 0 // Returns: if (a < b) returns 0
// if (a == b) returns 1 // if (a == b) returns 1
// if (a > b) returns 2 // if (a > b) returns 2
COMPILER_RT_ABI si_int __ucmpdi2(du_int a, du_int b) { DECLARE_LIBCALL(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) { DECLARE_LIBCALL(si_int, __aeabi_ulcmp, di_int a, di_int b) {
return __ucmpdi2(a, b) - 1; return __ucmpdi2(a, b) - 1;
} }
#endif #endif

compiler-rt/lib/builtins/ucmpti2.c

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

compiler-rt/lib/builtins/udivdi3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
typedef du_int fixuint_t; typedef du_int fixuint_t;
typedef di_int fixint_t; typedef di_int fixint_t;
#include "int_div_impl.inc" #include "int_div_impl.inc"
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b) { DECLARE_LIBCALL(du_int, __udivdi3, du_int a, du_int b) {
return __udivXi3(a, b); return __udivXi3(a, b);
} }

compiler-rt/lib/builtins/udivmoddi4.c

Show All 18 Lines
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
// MSVC throws a warning about mod 0 here, disable it for builds that // MSVC throws a warning about mod 0 here, disable it for builds that
// warn-as-error // warn-as-error
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4724) #pragma warning(disable : 4724)
#endif #endif
COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int *rem) { DECLARE_LIBCALL(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;
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

compiler-rt/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) { DECLARE_LIBCALL(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;
} }

compiler-rt/lib/builtins/udivmodti4.c

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
#else #else
return udiv128by64to64default(u1, u0, v, r); return udiv128by64to64default(u1, u0, v, r);
#endif #endif
} }
// Effects: if rem != 0, *rem = a % b // Effects: if rem != 0, *rem = a % b
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int *rem) { DECLARE_LIBCALL(tu_int, __udivmodti4, tu_int a, tu_int b, tu_int *rem) {
const unsigned n_utword_bits = sizeof(tu_int) * CHAR_BIT; const unsigned n_utword_bits = sizeof(tu_int) * CHAR_BIT;
utwords dividend; utwords dividend;
dividend.all = a; dividend.all = a;
utwords divisor; utwords divisor;
divisor.all = b; divisor.all = b;
utwords quotient; utwords quotient;
utwords remainder; utwords remainder;
if (divisor.all > dividend.all) { if (divisor.all > dividend.all) {
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

compiler-rt/lib/builtins/udivsi3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
typedef su_int fixuint_t; typedef su_int fixuint_t;
typedef si_int fixint_t; typedef si_int fixint_t;
#include "int_div_impl.inc" #include "int_div_impl.inc"
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI su_int __udivsi3(su_int a, su_int b) { DECLARE_LIBCALL(su_int, __udivsi3, su_int a, su_int b) {
return __udivXi3(a, b); return __udivXi3(a, b);
} }
#if defined(__ARM_EABI__) AUX_DECLS(__udivsi3)
COMPILER_RT_ALIAS(__udivsi3, __aeabi_uidiv)
#endif

compiler-rt/lib/builtins/udivti3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI tu_int __udivti3(tu_int a, tu_int b) { DECLARE_LIBCALL(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

compiler-rt/lib/builtins/umoddi3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
typedef du_int fixuint_t; typedef du_int fixuint_t;
typedef di_int fixint_t; typedef di_int fixint_t;
#include "int_div_impl.inc" #include "int_div_impl.inc"
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI du_int __umoddi3(du_int a, du_int b) { DECLARE_LIBCALL(du_int, __umoddi3, du_int a, du_int b) {
return __umodXi3(a, b); return __umodXi3(a, b);
} }

compiler-rt/lib/builtins/umodsi3.c

Show All 12 Lines
#include "int_lib.h" #include "int_lib.h"
typedef su_int fixuint_t; typedef su_int fixuint_t;
typedef si_int fixint_t; typedef si_int fixint_t;
#include "int_div_impl.inc" #include "int_div_impl.inc"
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b) { DECLARE_LIBCALL(su_int, __umodsi3, su_int a, su_int b) {
return __umodXi3(a, b); return __umodXi3(a, b);
} }

compiler-rt/lib/builtins/umodti3.c

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI tu_int __umodti3(tu_int a, tu_int b) { DECLARE_LIBCALL(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

compiler-rt/test/builtins/Unit/absvdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_absvdi2 // REQUIRES: librt_has_absvdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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); DECLARE_LIBCALL(di_int, __absvdi2, di_int a);
int test__absvdi2(di_int a) int test__absvdi2(di_int a)
{ {
di_int x = __absvdi2(a); di_int x = __absvdi2(a);
di_int expected = a; di_int expected = a;
if (expected < 0) if (expected < 0)
expected = -expected; expected = -expected;
if (x != expected || expected < 0) if (x != expected || expected < 0)
Show All 35 Lines

compiler-rt/test/builtins/Unit/absvsi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_absvsi2 // REQUIRES: librt_has_absvsi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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); DECLARE_LIBCALL(si_int, __absvsi2, si_int a);
int test__absvsi2(si_int a) int test__absvsi2(si_int a)
{ {
si_int x = __absvsi2(a); si_int x = __absvsi2(a);
si_int expected = a; si_int expected = a;
if (expected < 0) if (expected < 0)
expected = -expected; expected = -expected;
if (x != expected || expected < 0) if (x != expected || expected < 0)
Show All 35 Lines

compiler-rt/test/builtins/Unit/absvti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_absvti2 // REQUIRES: librt_has_absvti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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); DECLARE_LIBCALL(ti_int, __absvti2, ti_int a);
int test__absvti2(ti_int a) int test__absvti2(ti_int a)
{ {
ti_int x = __absvti2(a); ti_int x = __absvti2(a);
ti_int expected = a; ti_int expected = a;
if (expected < 0) if (expected < 0)
expected = -expected; expected = -expected;
if (x != expected || expected < 0) if (x != expected || expected < 0)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/adddf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_adddf3vfp // REQUIRES: librt_has_adddf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
extern COMPILER_RT_ABI double __adddf3vfp(double a, double b); extern DECLARE_LIBCALL(double, __adddf3vfp, double a, double b);
int test__adddf3vfp(double a, double b) int test__adddf3vfp(double a, double b)
{ {
double actual = __adddf3vfp(a, b); double actual = __adddf3vfp(a, b);
double expected = a + b; double expected = a + b;
if (actual != expected) if (actual != expected)
printf("error in test__adddf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__adddf3vfp(%f, %f) = %f, expected %f\n",
a, b, actual, expected); a, b, actual, expected);
Show All 20 Lines

compiler-rt/test/builtins/Unit/addsf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_addsf3vfp // REQUIRES: librt_has_addsf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __addsf3vfp(float a, float b); extern DECLARE_LIBCALL(float, __addsf3vfp, float a, float b);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__addsf3vfp(float a, float b) int test__addsf3vfp(float a, float b)
{ {
float actual = __addsf3vfp(a, b); float actual = __addsf3vfp(a, b);
float expected = a + b; float expected = a + b;
if (actual != expected) if (actual != expected)
printf("error in test__addsf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__addsf3vfp(%f, %f) = %f, expected %f\n",
Show All 21 Lines

compiler-rt/test/builtins/Unit/addtf3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_addtf3 // REQUIRES: librt_has_addtf3
#include <fenv.h> #include <fenv.h>
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "int_lib.h" #include "int_lib.h"
#include "fp_test.h" #include "fp_test.h"
// Returns: a + b // Returns: a + b
COMPILER_RT_ABI long double __addtf3(long double a, long double b); DECLARE_LIBCALL(long double, __addtf3, long double a, long double b);
int test__addtf3(long double a, long double b, int test__addtf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo) uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __addtf3(a, b); long double x = __addtf3(a, b);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret){ if (ret){
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/addvdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_addvdi3 // REQUIRES: librt_has_addvdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(di_int, __addvdi3, di_int a, di_int b);
int test__addvdi3(di_int a, di_int b) int test__addvdi3(di_int a, di_int b)
{ {
di_int x = __addvdi3(a, b); di_int x = __addvdi3(a, b);
di_int expected = a + b; di_int expected = a + b;
if (x != expected) if (x != expected)
printf("error in test__addvdi3(0x%llX, 0x%llX) = %lld, expected %lld\n", printf("error in test__addvdi3(0x%llX, 0x%llX) = %lld, expected %lld\n",
a, b, x, expected); a, b, x, expected);
Show All 29 Lines

compiler-rt/test/builtins/Unit/addvsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_addvsi3 // REQUIRES: librt_has_addvsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(si_int, __addvsi3, si_int a, si_int b);
int test__addvsi3(si_int a, si_int b) int test__addvsi3(si_int a, si_int b)
{ {
si_int x = __addvsi3(a, b); si_int x = __addvsi3(a, b);
si_int expected = a + b; si_int expected = a + b;
if (x != expected) if (x != expected)
printf("error in test__addvsi3(0x%X, 0x%X) = %d, expected %d\n", printf("error in test__addvsi3(0x%X, 0x%X) = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
Show All 29 Lines

compiler-rt/test/builtins/Unit/addvti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_addvti3 // REQUIRES: librt_has_addvti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __addvti3, ti_int a, ti_int b);
int test__addvti3(ti_int a, ti_int b) int test__addvti3(ti_int a, ti_int b)
{ {
ti_int x = __addvti3(a, b); ti_int x = __addvti3(a, b);
ti_int expected = a + b; ti_int expected = a + b;
if (x != expected) if (x != expected)
{ {
twords at; twords at;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ashldi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ashldi3 // REQUIRES: librt_has_ashldi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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, int b); DECLARE_LIBCALL(di_int, __ashldi3, di_int a, int b);
int test__ashldi3(di_int a, int b, di_int expected) int test__ashldi3(di_int a, int b, di_int expected)
{ {
di_int x = __ashldi3(a, b); di_int x = __ashldi3(a, b);
if (x != expected) if (x != expected)
printf("error in __ashldi3: %llX << %d = %llX, expected %llX\n", printf("error in __ashldi3: %llX << %d = %llX, expected %llX\n",
a, b, __ashldi3(a, b), expected); a, b, __ashldi3(a, b), expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ashlti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ashlti3 // REQUIRES: librt_has_ashlti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __ashlti3, ti_int a, si_int b);
int test__ashlti3(ti_int a, si_int b, ti_int expected) int test__ashlti3(ti_int a, si_int b, ti_int expected)
{ {
ti_int x = __ashlti3(a, b); ti_int x = __ashlti3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ashrdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ashrdi3 // REQUIRES: librt_has_ashrdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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, int b); DECLARE_LIBCALL(di_int, __ashrdi3, di_int a, int b);
int test__ashrdi3(di_int a, int b, di_int expected) int test__ashrdi3(di_int a, int b, di_int expected)
{ {
di_int x = __ashrdi3(a, b); di_int x = __ashrdi3(a, b);
if (x != expected) if (x != expected)
printf("error in __ashrdi3: %llX >> %d = %llX, expected %llX\n", printf("error in __ashrdi3: %llX >> %d = %llX, expected %llX\n",
a, b, __ashrdi3(a, b), expected); a, b, __ashrdi3(a, b), expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ashrti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ashrti3 // REQUIRES: librt_has_ashrti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __ashrti3, ti_int a, si_int b);
int test__ashrti3(ti_int a, si_int b, ti_int expected) int test__ashrti3(ti_int a, si_int b, ti_int expected)
{ {
ti_int x = __ashrti3(a, b); ti_int x = __ashrti3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/clzdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_clzdi2 // REQUIRES: librt_has_clzdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: the number of leading 0-bits // Returns: the number of leading 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __clzdi2(di_int a); DECLARE_LIBCALL(int, __clzdi2, di_int a);
int test__clzdi2(di_int a, int expected) int test__clzdi2(di_int a, int expected)
{ {
int x = __clzdi2(a); int x = __clzdi2(a);
if (x != expected) if (x != expected)
printf("error in __clzdi2(0x%llX) = %d, expected %d\n", a, x, expected); printf("error in __clzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
} }
Show All 39 Lines

compiler-rt/test/builtins/Unit/clzsi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_clzsi2 // REQUIRES: librt_has_clzsi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: the number of leading 0-bits // Returns: the number of leading 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __clzsi2(si_int a); DECLARE_LIBCALL(int, __clzsi2, si_int a);
int test__clzsi2(si_int a, int expected) int test__clzsi2(si_int a, int expected)
{ {
int x = __clzsi2(a); int x = __clzsi2(a);
if (x != expected) if (x != expected)
printf("error in __clzsi2(0x%X) = %d, expected %d\n", a, x, expected); printf("error in __clzsi2(0x%X) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 570 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/clzti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_clzti2 // REQUIRES: librt_has_clzti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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 int __clzti2(ti_int a); DECLARE_LIBCALL(int, __clzti2, ti_int a);
int test__clzti2(ti_int a, int expected) int test__clzti2(ti_int a, int expected)
{ {
int x = __clzti2(a); int x = __clzti2(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/cmpdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_cmpdi2 // REQUIRES: librt_has_cmpdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(si_int, __cmpdi2, di_int a, di_int b);
int test__cmpdi2(di_int a, di_int b, si_int expected) int test__cmpdi2(di_int a, di_int b, si_int expected)
{ {
si_int x = __cmpdi2(a, b); si_int x = __cmpdi2(a, b);
if (x != expected) if (x != expected)
printf("error in __cmpdi2(0x%llX, 0x%llX) = %d, expected %d\n", printf("error in __cmpdi2(0x%llX, 0x%llX) = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/cmpti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_cmpti2 // REQUIRES: librt_has_cmpti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(si_int, __cmpti2, ti_int a, ti_int b);
int test__cmpti2(ti_int a, ti_int b, si_int expected) int test__cmpti2(ti_int a, ti_int b, si_int expected)
{ {
si_int x = __cmpti2(a, b); si_int x = __cmpti2(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ctzdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ctzdi2 // REQUIRES: librt_has_ctzdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: the number of trailing 0-bits // Returns: the number of trailing 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __ctzdi2(di_int a); DECLARE_LIBCALL(int, __ctzdi2, di_int a);
int test__ctzdi2(di_int a, int expected) int test__ctzdi2(di_int a, int expected)
{ {
int x = __ctzdi2(a); int x = __ctzdi2(a);
if (x != expected) if (x != expected)
printf("error in __ctzdi2(0x%llX) = %d, expected %d\n", a, x, expected); printf("error in __ctzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
} }
Show All 38 Lines

compiler-rt/test/builtins/Unit/ctzsi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ctzsi2 // REQUIRES: librt_has_ctzsi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: the number of trailing 0-bits // Returns: the number of trailing 0-bits
// Precondition: a != 0 // Precondition: a != 0
COMPILER_RT_ABI int __ctzsi2(si_int a); DECLARE_LIBCALL(int, __ctzsi2, si_int a);
int test__ctzsi2(si_int a, int expected) int test__ctzsi2(si_int a, int expected)
{ {
int x = __ctzsi2(a); int x = __ctzsi2(a);
if (x != expected) if (x != expected)
printf("error in __ctzsi2(0x%X) = %d, expected %d\n", a, x, expected); printf("error in __ctzsi2(0x%X) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 540 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ctzti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ctzti2 // REQUIRES: librt_has_ctzti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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 int __ctzti2(ti_int a); DECLARE_LIBCALL(int, __ctzti2, ti_int a);
int test__ctzti2(ti_int a, int expected) int test__ctzti2(ti_int a, int expected)
{ {
int x = __ctzti2(a); int x = __ctzti2(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divdc3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divdc3 // REQUIRES: librt_has_divdc3
// REQUIRES: c99-complex // REQUIRES: c99-complex
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
// Returns: the quotient of (a + ib) / (c + id) // Returns: the quotient of (a + ib) / (c + id)
COMPILER_RT_ABI double _Complex DECLARE_LIBCALL(double _Complex, __divdc3,
__divdc3(double __a, double __b, double __c, double __d); double __a, double __b, double __c, double __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(double _Complex x) classify(double _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divdf3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divdf3 // REQUIRES: librt_has_divdf3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include "fp_test.h" #include "fp_test.h"
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI double __divdf3(double a, double b); DECLARE_LIBCALL(double, __divdf3, double a, double b);
int test__divdf3(double a, double b, uint64_t expected) int test__divdf3(double a, double b, uint64_t expected)
{ {
double x = __divdf3(a, b); double x = __divdf3(a, b);
int ret = compareResultD(x, expected); int ret = compareResultD(x, expected);
if (ret){ if (ret){
printf("error in test__divdf3(%.20e, %.20e) = %.20e, " printf("error in test__divdf3(%.20e, %.20e) = %.20e, "
Show All 17 Lines

compiler-rt/test/builtins/Unit/divdf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divdf3vfp // REQUIRES: librt_has_divdf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
extern COMPILER_RT_ABI double __divdf3vfp(double a, double b); extern DECLARE_LIBCALL(double, __divdf3vfp, double a, double b);
int test__divdf3vfp(double a, double b) int test__divdf3vfp(double a, double b)
{ {
double actual = __divdf3vfp(a, b); double actual = __divdf3vfp(a, b);
double expected = a / b; double expected = a / b;
if (actual != expected) if (actual != expected)
printf("error in test__divdf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__divdf3vfp(%f, %f) = %f, expected %f\n",
a, b, actual, expected); a, b, actual, expected);
Show All 20 Lines

compiler-rt/test/builtins/Unit/divdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divdi3 // REQUIRES: librt_has_divdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b); DECLARE_LIBCALL(di_int, __divdi3, di_int a, di_int b);
int test__divdi3(di_int a, di_int b, di_int expected) int test__divdi3(di_int a, di_int b, di_int expected)
{ {
di_int x = __divdi3(a, b); di_int x = __divdi3(a, b);
if (x != expected) if (x != expected)
printf("error in __divdi3: %lld / %lld = %lld, expected %lld\n", printf("error in __divdi3: %lld / %lld = %lld, expected %lld\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
Show All 31 Lines

compiler-rt/test/builtins/Unit/divmodsi4_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divmodsi4 // REQUIRES: librt_has_divmodsi4
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a / b // Returns: a / b
extern COMPILER_RT_ABI si_int __divmodsi4(si_int a, si_int b, si_int* rem); extern DECLARE_LIBCALL(si_int, __divmodsi4, si_int a, si_int b, si_int* rem);
int test__divmodsi4(si_int a, si_int b, int test__divmodsi4(si_int a, si_int b,
si_int expected_result, si_int expected_rem) si_int expected_result, si_int expected_rem)
{ {
si_int rem; si_int rem;
si_int result = __divmodsi4(a, b, &rem); si_int result = __divmodsi4(a, b, &rem);
if (result != expected_result) { if (result != expected_result) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divsc3_test.c

// RUN: %clang_builtins %s %librt -lm -o %t && %run %t // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
// REQUIRES: librt_has_divsc3 // REQUIRES: librt_has_divsc3
// REQUIRES: c99-complex // REQUIRES: c99-complex
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
// Returns: the quotient of (a + ib) / (c + id) // Returns: the quotient of (a + ib) / (c + id)
COMPILER_RT_ABI float _Complex DECLARE_LIBCALL(float _Complex, __divsc3,
__divsc3(float __a, float __b, float __c, float __d); float __a, float __b, float __c, float __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(float _Complex x) classify(float _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divsf3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divsf3 // REQUIRES: librt_has_divsf3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include "fp_test.h" #include "fp_test.h"
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI float __divsf3(float a, float b); DECLARE_LIBCALL(float, __divsf3, float a, float b);
int test__divsf3(float a, float b, uint32_t expected) int test__divsf3(float a, float b, uint32_t expected)
{ {
float x = __divsf3(a, b); float x = __divsf3(a, b);
int ret = compareResultF(x, expected); int ret = compareResultF(x, expected);
if (ret){ if (ret){
printf("error in test__divsf3(%.20e, %.20e) = %.20e, " printf("error in test__divsf3(%.20e, %.20e) = %.20e, "
Show All 17 Lines

compiler-rt/test/builtins/Unit/divsf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divsf3vfp // REQUIRES: librt_has_divsf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __divsf3vfp(float a, float b); extern DECLARE_LIBCALL(float, __divsf3vfp, float a, float b);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__divsf3vfp(float a, float b) int test__divsf3vfp(float a, float b)
{ {
float actual = __divsf3vfp(a, b); float actual = __divsf3vfp(a, b);
float expected = a / b; float expected = a / b;
if (actual != expected) if (actual != expected)
printf("error in test__divsf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__divsf3vfp(%f, %f) = %f, expected %f\n",
Show All 21 Lines

compiler-rt/test/builtins/Unit/divsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divsi3 // REQUIRES: librt_has_divsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b); DECLARE_LIBCALL(si_int, __divsi3, si_int a, si_int b);
int test__divsi3(si_int a, si_int b, si_int expected) int test__divsi3(si_int a, si_int b, si_int expected)
{ {
si_int x = __divsi3(a, b); si_int x = __divsi3(a, b);
if (x != expected) if (x != expected)
printf("error in __divsi3: %d / %d = %d, expected %d\n", printf("error in __divsi3: %d / %d = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
Show All 29 Lines

compiler-rt/test/builtins/Unit/divtc3_test.c

Show All 9 Lines
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
// Returns: the quotient of (a + ib) / (c + id) // Returns: the quotient of (a + ib) / (c + id)
COMPILER_RT_ABI long double _Complex DECLARE_LIBCALL(long double _Complex, __divtc3,
__divtc3(long double __a, long double __b, long double __c, long double __d); long double __a, long double __b, long double __c, long double __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(long double _Complex x) classify(long double _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divtf3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divtf3 // REQUIRES: librt_has_divtf3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI long double __divtf3(long double a, long double b); DECLARE_LIBCALL(long double, __divtf3, long double a, long double b);
int test__divtf3(long double a, long double b, int test__divtf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo) uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __divtf3(a, b); long double x = __divtf3(a, b);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret){ if (ret){
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_divti3 // REQUIRES: librt_has_divti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __divti3, ti_int a, ti_int b);
int test__divti3(ti_int a, ti_int b, ti_int expected) int test__divti3(ti_int a, ti_int b, ti_int expected)
{ {
ti_int x = __divti3(a, b); ti_int x = __divti3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/divxc3_test.c

Show All 9 Lines
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
// Returns: the quotient of (a + ib) / (c + id) // Returns: the quotient of (a + ib) / (c + id)
COMPILER_RT_ABI long double _Complex DECLARE_LIBCALL(long double _Complex, __divxc3,
__divxc3(long double __a, long double __b, long double __c, long double __d); long double __a, long double __b, long double __c, long double __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(long double _Complex x) classify(long double _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 347 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/extenddftf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_extenddftf2 // REQUIRES: librt_has_extenddftf2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
COMPILER_RT_ABI long double __extenddftf2(double a); DECLARE_LIBCALL(long double, __extenddftf2, double a);
int test__extenddftf2(double a, uint64_t expectedHi, uint64_t expectedLo) int test__extenddftf2(double a, uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __extenddftf2(a); long double x = __extenddftf2(a);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret){ if (ret){
printf("error in test__extenddftf2(%f) = %.20Lf, " printf("error in test__extenddftf2(%f) = %.20Lf, "
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/extendsfdf2vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_extendsfdf2vfp // REQUIRES: librt_has_extendsfdf2vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI double __extendsfdf2vfp(float a); extern DECLARE_LIBCALL(double, __extendsfdf2vfp, float a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__extendsfdf2vfp(float a) int test__extendsfdf2vfp(float a)
{ {
double actual = __extendsfdf2vfp(a); double actual = __extendsfdf2vfp(a);
double expected = a; double expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__extendsfdf2vfp(%f) = %f, expected %f\n", printf("error in test__extendsfdf2vfp(%f) = %f, expected %f\n",
Show All 21 Lines

compiler-rt/test/builtins/Unit/extendsftf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_extendsftf2 // REQUIRES: librt_has_extendsftf2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
COMPILER_RT_ABI long double __extendsftf2(float a); DECLARE_LIBCALL(long double, __extendsftf2, float a);
int test__extendsftf2(float a, uint64_t expectedHi, uint64_t expectedLo) int test__extendsftf2(float a, uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __extendsftf2(a); long double x = __extendsftf2(a);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret) if (ret)
{ {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ffsdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ffsdi2 // REQUIRES: librt_has_ffsdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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 int __ffsdi2(di_int a); DECLARE_LIBCALL(int, __ffsdi2, di_int a);
int test__ffsdi2(di_int a, int expected) int test__ffsdi2(di_int a, int expected)
{ {
int x = __ffsdi2(a); int x = __ffsdi2(a);
if (x != expected) if (x != expected)
printf("error in __ffsdi2(0x%llX) = %d, expected %d\n", a, x, expected); printf("error in __ffsdi2(0x%llX) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
} }
Show All 38 Lines

compiler-rt/test/builtins/Unit/ffssi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ffssi2 // REQUIRES: librt_has_ffssi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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 int __ffssi2(si_int a); DECLARE_LIBCALL(int, __ffssi2, si_int a);
int test__ffssi2(si_int a, int expected) int test__ffssi2(si_int a, int expected)
{ {
int x = __ffssi2(a); int x = __ffssi2(a);
if (x != expected) if (x != expected)
printf("error in __ffssi2(0x%X) = %d, expected %d\n", a, x, expected); printf("error in __ffssi2(0x%X) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
} }
Show All 28 Lines

compiler-rt/test/builtins/Unit/ffsti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ffsti2 // REQUIRES: librt_has_ffsti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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 int __ffsti2(ti_int a); DECLARE_LIBCALL(int, __ffsti2, ti_int a);
int test__ffsti2(ti_int a, int expected) int test__ffsti2(ti_int a, int expected)
{ {
int x = __ffsti2(a); int x = __ffsti2(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixdfdi_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixdfdi // REQUIRES: librt_has_fixdfdi
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: convert a to a signed long long, rounding toward zero. // Returns: convert a to a signed long long, rounding toward zero.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in double is representable in di_int (no range checking performed) // value in double is representable in di_int (no range checking performed)
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI di_int __fixdfdi(double a); DECLARE_LIBCALL(di_int, __fixdfdi, double a);
int test__fixdfdi(double a, di_int expected) int test__fixdfdi(double a, di_int expected)
{ {
di_int x = __fixdfdi(a); di_int x = __fixdfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixdfdi(%A) = %llX, expected %llX\n", a, x, expected); printf("error in __fixdfdi(%A) = %llX, expected %llX\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixdfti_test.c

Show All 9 Lines
// Returns: convert a to a signed long long, rounding toward zero. // Returns: convert a to a signed long long, rounding toward zero.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in double is representable in ti_int (no range checking performed) // value in double is representable in ti_int (no range checking performed)
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI ti_int __fixdfti(double a); DECLARE_LIBCALL(ti_int, __fixdfti, double a);
int test__fixdfti(double a, ti_int expected) int test__fixdfti(double a, ti_int expected)
{ {
ti_int x = __fixdfti(a); ti_int x = __fixdfti(a);
if (x != expected) if (x != expected)
{ {
twords xt; twords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixsfdi_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixsfdi // REQUIRES: librt_has_fixsfdi
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: convert a to a signed long long, rounding toward zero. // Returns: convert a to a signed long long, rounding toward zero.
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in float is representable in di_int (no range checking performed) // value in float is representable in di_int (no range checking performed)
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI di_int __fixsfdi(float a); DECLARE_LIBCALL(di_int, __fixsfdi, float a);
int test__fixsfdi(float a, di_int expected) int test__fixsfdi(float a, di_int expected)
{ {
di_int x = __fixsfdi(a); di_int x = __fixsfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixsfdi(%A) = %llX, expected %llX\n", a, x, expected); printf("error in __fixsfdi(%A) = %llX, expected %llX\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixsfti_test.c

Show All 9 Lines
// Returns: convert a to a signed long long, rounding toward zero. // Returns: convert a to a signed long long, rounding toward zero.
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in float is representable in ti_int (no range checking performed) // value in float is representable in ti_int (no range checking performed)
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI ti_int __fixsfti(float a); DECLARE_LIBCALL(ti_int, __fixsfti, float a);
int test__fixsfti(float a, ti_int expected) int test__fixsfti(float a, ti_int expected)
{ {
ti_int x = __fixsfti(a); ti_int x = __fixsfti(a);
if (x != expected) if (x != expected)
{ {
twords xt; twords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsdfdi_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixunsdfdi // REQUIRES: librt_has_fixunsdfdi
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// value in double is representable in du_int or is negative // value in double is representable in du_int or is negative
// (no range checking performed) // (no range checking performed)
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI du_int __fixunsdfdi(double a); DECLARE_LIBCALL(du_int, __fixunsdfdi, double a);
int test__fixunsdfdi(double a, du_int expected) int test__fixunsdfdi(double a, du_int expected)
{ {
du_int x = __fixunsdfdi(a); du_int x = __fixunsdfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixunsdfdi(%A) = %llX, expected %llX\n", a, x, expected); printf("error in __fixunsdfdi(%A) = %llX, expected %llX\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsdfsi_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixunsdfsi // REQUIRES: librt_has_fixunsdfsi
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in double is representable in su_int or is negative // value in double is representable in su_int or is negative
// (no range checking performed) // (no range checking performed)
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI su_int __fixunsdfsi(double a); DECLARE_LIBCALL(su_int, __fixunsdfsi, double a);
int test__fixunsdfsi(double a, su_int expected) int test__fixunsdfsi(double a, su_int expected)
{ {
su_int x = __fixunsdfsi(a); su_int x = __fixunsdfsi(a);
if (x != expected) if (x != expected)
printf("error in __fixunsdfsi(%A) = %X, expected %X\n", a, x, expected); printf("error in __fixunsdfsi(%A) = %X, expected %X\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsdfsivfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixunsdfsivfp // REQUIRES: librt_has_fixunsdfsivfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI unsigned int __fixunsdfsivfp(double a); extern DECLARE_LIBCALL(unsigned int, __fixunsdfsivfp, double a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__fixunsdfsivfp(double a) int test__fixunsdfsivfp(double a)
{ {
unsigned int actual = __fixunsdfsivfp(a); unsigned int actual = __fixunsdfsivfp(a);
unsigned int expected = a; unsigned int expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__fixunsdfsivfp(%f) = %u, expected %u\n", printf("error in test__fixunsdfsivfp(%f) = %u, expected %u\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/fixunsdfti_test.c

Show All 11 Lines
// tu_int is a 64 bit integral type // tu_int is a 64 bit integral type
// value in double is representable in tu_int or is negative // value in double is representable in tu_int or is negative
// (no range checking performed) // (no range checking performed)
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
COMPILER_RT_ABI tu_int __fixunsdfti(double a); DECLARE_LIBCALL(tu_int, __fixunsdfti, double a);
int test__fixunsdfti(double a, tu_int expected) int test__fixunsdfti(double a, tu_int expected)
{ {
tu_int x = __fixunsdfti(a); tu_int x = __fixunsdfti(a);
if (x != expected) if (x != expected)
{ {
utwords xt; utwords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunssfdi_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixunssfdi // REQUIRES: librt_has_fixunssfdi
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// value in float is representable in du_int or is negative // value in float is representable in du_int or is negative
// (no range checking performed) // (no range checking performed)
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI du_int __fixunssfdi(float a); DECLARE_LIBCALL(du_int, __fixunssfdi, float a);
int test__fixunssfdi(float a, du_int expected) int test__fixunssfdi(float a, du_int expected)
{ {
du_int x = __fixunssfdi(a); du_int x = __fixunssfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixunssfdi(%A) = %llX, expected %llX\n", printf("error in __fixunssfdi(%A) = %llX, expected %llX\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunssfsi_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_fixunssfsi // REQUIRES: librt_has_fixunssfsi
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in float is representable in su_int or is negative // value in float is representable in su_int or is negative
// (no range checking performed) // (no range checking performed)
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI su_int __fixunssfsi(float a); DECLARE_LIBCALL(su_int, __fixunssfsi, float a);
int test__fixunssfsi(float a, su_int expected) int test__fixunssfsi(float a, su_int expected)
{ {
su_int x = __fixunssfsi(a); su_int x = __fixunssfsi(a);
if (x != expected) if (x != expected)
printf("error in __fixunssfsi(%A) = %X, expected %X\n", a, x, expected); printf("error in __fixunssfsi(%A) = %X, expected %X\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunssfti_test.c

Show All 11 Lines
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// tu_int is a 64 bit integral type // tu_int is a 64 bit integral type
// value in float is representable in tu_int or is negative // value in float is representable in tu_int or is negative
// (no range checking performed) // (no range checking performed)
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI tu_int __fixunssfti(float a); DECLARE_LIBCALL(tu_int, __fixunssfti, float a);
int test__fixunssfti(float a, tu_int expected) int test__fixunssfti(float a, tu_int expected)
{ {
tu_int x = __fixunssfti(a); tu_int x = __fixunssfti(a);
if (x != expected) if (x != expected)
{ {
utwords xt; utwords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunstfdi_test.c

Show All 9 Lines
// 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 a 128 bit floating point type // Assumption: long double is a 128 bit floating point type
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// value in long double is representable in du_int or is negative // value in long double is representable in du_int or is negative
// (no range checking performed) // (no range checking performed)
COMPILER_RT_ABI du_int __fixunstfdi(long double a); DECLARE_LIBCALL(du_int, __fixunstfdi, long double a);
int test__fixunstfdi(long double a, du_int expected) int test__fixunstfdi(long double a, du_int expected)
{ {
du_int x = __fixunstfdi(a); du_int x = __fixunstfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixunstfdi(%LA) = %llX, expected %llX\n", printf("error in __fixunstfdi(%LA) = %llX, expected %llX\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunstfti_test.c

Show All 12 Lines
// 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 a 128 bit floating point type // Assumption: long double is a 128 bit floating point type
// tu_int is a 128 bit integral type // tu_int is a 128 bit integral type
// value in long double is representable in tu_int or is negative // value in long double is representable in tu_int or is negative
// (no range checking performed) // (no range checking performed)
COMPILER_RT_ABI tu_int __fixunstfti(long double a); DECLARE_LIBCALL(tu_int, __fixunstfti, long double a);
int test__fixunstfti(long double a, tu_int expected) int test__fixunstfti(long double a, tu_int expected)
{ {
tu_int x = __fixunstfti(a); tu_int x = __fixunstfti(a);
if (x != expected) if (x != expected)
{ {
twords xt; twords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsxfdi_test.c

Show All 12 Lines
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// value in long double is representable in du_int or is negative // value in long double is representable in du_int or is negative
// (no range checking performed) // (no range checking performed)
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 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); DECLARE_LIBCALL(du_int, __fixunsxfdi, long double a);
int test__fixunsxfdi(long double a, du_int expected) int test__fixunsxfdi(long double a, du_int expected)
{ {
du_int x = __fixunsxfdi(a); du_int x = __fixunsxfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixunsxfdi(%LA) = %llX, expected %llX\n", printf("error in __fixunsxfdi(%LA) = %llX, expected %llX\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsxfsi_test.c

Show All 10 Lines
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in long double is representable in su_int or is negative // value in long double is representable in su_int or is negative
// (no range checking performed) // (no range checking performed)
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 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); DECLARE_LIBCALL(su_int, __fixunsxfsi, long double a);
int test__fixunsxfsi(long double a, su_int expected) int test__fixunsxfsi(long double a, su_int expected)
{ {
su_int x = __fixunsxfsi(a); su_int x = __fixunsxfsi(a);
if (x != expected) if (x != expected)
printf("error in __fixunsxfsi(%LA) = %X, expected %X\n", a, x, expected); printf("error in __fixunsxfsi(%LA) = %X, expected %X\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsxfti_test.c

Show All 12 Lines
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// tu_int is a 64 bit integral type // tu_int is a 64 bit integral type
// value in long double is representable in tu_int or is negative // value in long double is representable in tu_int or is negative
// (no range checking performed) // (no range checking performed)
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 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); DECLARE_LIBCALL(tu_int, __fixunsxfti, long double a);
int test__fixunsxfti(long double a, tu_int expected) int test__fixunsxfti(long double a, tu_int expected)
{ {
tu_int x = __fixunsxfti(a); tu_int x = __fixunsxfti(a);
if (x != expected) if (x != expected)
{ {
utwords xt; utwords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixxfdi_test.c

Show All 9 Lines
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in long double is representable in di_int (no range checking performed) // value in long double is representable in di_int (no range checking performed)
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI di_int __fixxfdi(long double a); DECLARE_LIBCALL(di_int, __fixxfdi, long double a);
int test__fixxfdi(long double a, di_int expected) int test__fixxfdi(long double a, di_int expected)
{ {
di_int x = __fixxfdi(a); di_int x = __fixxfdi(a);
if (x != expected) if (x != expected)
printf("error in __fixxfdi(%LA) = %llX, expected %llX\n", printf("error in __fixxfdi(%LA) = %llX, expected %llX\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixxfti_test.c

Show All 10 Lines
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in long double is representable in ti_int (no range checking performed) // value in long double is representable in ti_int (no range checking performed)
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI ti_int __fixxfti(long double a); DECLARE_LIBCALL(ti_int, __fixxfti, long double a);
int test__fixxfti(long double a, ti_int expected) int test__fixxfti(long double a, ti_int expected)
{ {
ti_int x = __fixxfti(a); ti_int x = __fixxfti(a);
if (x != expected) if (x != expected)
{ {
utwords xt; utwords xt;
xt.all = x; xt.all = x;
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatdidf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatdidf // REQUIRES: librt_has_floatdidf
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
// Returns: convert a to a double, rounding toward even. // Returns: convert a to a double, rounding toward even.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// di_int is a 64 bit integral type // di_int is a 64 bit integral type
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI double __floatdidf(di_int a); DECLARE_LIBCALL(double, __floatdidf, di_int a);
int test__floatdidf(di_int a, double expected) int test__floatdidf(di_int a, double expected)
{ {
double x = __floatdidf(a); double x = __floatdidf(a);
if (x != expected) if (x != expected)
printf("error in __floatdidf(%llX) = %a, expected %a\n", a, x, expected); printf("error in __floatdidf(%llX) = %a, expected %a\n", a, x, expected);
return x != expected; return x != expected;
} }
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatdisf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatdisf // REQUIRES: librt_has_floatdisf
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
// Returns: convert a to a float, rounding toward even. // Returns: convert a to a float, rounding toward even.
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// di_int is a 64 bit integral type // di_int is a 64 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI float __floatdisf(di_int a); DECLARE_LIBCALL(float, __floatdisf, di_int a);
int test__floatdisf(di_int a, float expected) int test__floatdisf(di_int a, float expected)
{ {
float x = __floatdisf(a); float x = __floatdisf(a);
if (x != expected) if (x != expected)
printf("error in __floatdisf(%llX) = %a, expected %a\n", printf("error in __floatdisf(%llX) = %a, expected %a\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatditf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatditf // REQUIRES: librt_has_floatditf
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
// Returns: long integer converted to long double // Returns: long integer converted to long double
COMPILER_RT_ABI long double __floatditf(long long a); DECLARE_LIBCALL(long double, __floatditf, long long a);
int test__floatditf(long long a, uint64_t expectedHi, uint64_t expectedLo) int test__floatditf(long long a, uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __floatditf(a); long double x = __floatditf(a);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret) if (ret)
printf("error in __floatditf(%Ld) = %.20Lf, " printf("error in __floatditf(%Ld) = %.20Lf, "
Show All 36 Lines

compiler-rt/test/builtins/Unit/floatdixf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatdixf // REQUIRES: librt_has_floatdixf
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if HAS_80_BIT_LONG_DOUBLE #if HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a long double, rounding toward even. // Returns: convert a to a long double, rounding toward even.
// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
// di_int is a 64 bit integral type // di_int is a 64 bit integral type
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
long COMPILER_RT_ABI double __floatdixf(di_int a); long DECLARE_LIBCALL(double, __floatdixf, di_int a);
int test__floatdixf(di_int a, long double expected) int test__floatdixf(di_int a, long double expected)
{ {
long double x = __floatdixf(a); long double x = __floatdixf(a);
if (x != expected) if (x != expected)
printf("error in __floatdixf(%llX) = %LA, expected %LA\n", printf("error in __floatdixf(%llX) = %LA, expected %LA\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatsidfvfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatsidfvfp // REQUIRES: librt_has_floatsidfvfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI double __floatsidfvfp(int a); extern DECLARE_LIBCALL(double, __floatsidfvfp, int a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__floatsidfvfp(int a) int test__floatsidfvfp(int a)
{ {
double actual = __floatsidfvfp(a); double actual = __floatsidfvfp(a);
double expected = a; double expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__ floatsidfvfp(%d) = %f, expected %f\n", printf("error in test__ floatsidfvfp(%d) = %f, expected %f\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/floatsisfvfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatsisfvfp // REQUIRES: librt_has_floatsisfvfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __floatsisfvfp(int a); extern DECLARE_LIBCALL(float, __floatsisfvfp, int a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__floatsisfvfp(int a) int test__floatsisfvfp(int a)
{ {
float actual = __floatsisfvfp(a); float actual = __floatsisfvfp(a);
float expected = a; float expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__floatsisfvfp(%d) = %f, expected %f\n", printf("error in test__floatsisfvfp(%d) = %f, expected %f\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/floatsitf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatsitf // REQUIRES: librt_has_floatsitf
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
long COMPILER_RT_ABI double __floatsitf(int a); long DECLARE_LIBCALL(double, __floatsitf, int a);
int test__floatsitf(int a, uint64_t expectedHi, uint64_t expectedLo) int test__floatsitf(int a, uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __floatsitf(a); long double x = __floatsitf(a);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret) if (ret)
{ {
Show All 32 Lines

compiler-rt/test/builtins/Unit/floattidf_test.c

Show All 9 Lines
// Returns: convert a to a double, rounding toward even. // Returns: convert a to a double, rounding toward even.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// ti_int is a 64 bit integral type // ti_int is a 64 bit integral type
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI double __floattidf(ti_int a); DECLARE_LIBCALL(double, __floattidf, ti_int a);
int test__floattidf(ti_int a, double expected) int test__floattidf(ti_int a, double expected)
{ {
double x = __floattidf(a); double x = __floattidf(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floattisf_test.c

Show All 9 Lines
// 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 64 bit integral type // ti_int is a 64 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); DECLARE_LIBCALL(float, __floattisf, ti_int a);
int test__floattisf(ti_int a, float expected) int test__floattisf(ti_int a, float expected)
{ {
float x = __floattisf(a); float x = __floattisf(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floattitf_test.c

Show All 13 Lines
/* Assumption: fp_t is a IEEE 128 bit floating point type /* Assumption: fp_t is a IEEE 128 bit floating point type
* ti_int is a 128 bit integral type * ti_int is a 128 bit integral type
*/ */
/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | /* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
* mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI fp_t __floattitf(ti_int a); DECLARE_LIBCALL(fp_t, __floattitf, ti_int a);
int test__floattitf(ti_int a, fp_t expected) { int test__floattitf(ti_int a, fp_t expected) {
fp_t x = __floattitf(a); fp_t x = __floattitf(a);
if (x != expected) { if (x != expected) {
twords at; twords at;
at.all = a; at.all = a;
printf("error in __floattitf(0x%.16llX%.16llX) = %LA, expected %LA\n", printf("error in __floattitf(0x%.16llX%.16llX) = %LA, expected %LA\n",
at.s.high, at.s.low, x, expected); at.s.high, at.s.low, x, expected);
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floattixf_test.c

Show All 10 Lines
// Returns: convert a to a long double, rounding toward even. // Returns: convert a to a long double, rounding toward even.
// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
// ti_int is a 128 bit integral type // ti_int is a 128 bit integral type
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI long double __floattixf(ti_int a); DECLARE_LIBCALL(long double, __floattixf, ti_int a);
int test__floattixf(ti_int a, long double expected) int test__floattixf(ti_int a, long double expected)
{ {
long double x = __floattixf(a); long double x = __floattixf(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatundidf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatundidf // REQUIRES: librt_has_floatundidf
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.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
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI double __floatundidf(du_int a); DECLARE_LIBCALL(double, __floatundidf, du_int a);
int test__floatundidf(di_int a, double expected) int test__floatundidf(di_int a, double expected)
{ {
double x = __floatundidf(a); double x = __floatundidf(a);
if (x != expected) if (x != expected)
printf("error in __floatundidf(%llX) = %a, expected %a\n", printf("error in __floatundidf(%llX) = %a, expected %a\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatundisf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatundisf // REQUIRES: librt_has_floatundisf
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
// Returns: convert a to a float, rounding toward even. // Returns: convert a to a float, rounding toward even.
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI float __floatundisf(du_int a); DECLARE_LIBCALL(float, __floatundisf, du_int a);
int test__floatundisf(du_int a, float expected) int test__floatundisf(du_int a, float expected)
{ {
float x = __floatundisf(a); float x = __floatundisf(a);
if (x != expected) if (x != expected)
printf("error in __floatundisf(%llX) = %a, expected %a\n", printf("error in __floatundisf(%llX) = %a, expected %a\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatunditf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatunditf // REQUIRES: librt_has_floatunditf
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
// Returns: long integer converted to long double // Returns: long integer converted to long double
COMPILER_RT_ABI long double __floatunditf(unsigned long long a); DECLARE_LIBCALL(long double, __floatunditf, unsigned long long a);
int test__floatunditf(unsigned long long a, uint64_t expectedHi, uint64_t expectedLo) int test__floatunditf(unsigned long long a, uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __floatunditf(a); long double x = __floatunditf(a);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret) if (ret)
printf("error in __floatunditf(%Lu) = %.20Lf, " printf("error in __floatunditf(%Lu) = %.20Lf, "
Show All 34 Lines

compiler-rt/test/builtins/Unit/floatundixf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatundixf // REQUIRES: librt_has_floatundixf
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if HAS_80_BIT_LONG_DOUBLE #if HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a long double, rounding toward even. // Returns: convert a to a long double, rounding toward even.
// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
// du_int is a 64 bit integral type // du_int is a 64 bit integral type
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI long double __floatundixf(du_int a); DECLARE_LIBCALL(long double, __floatundixf, du_int a);
int test__floatundixf(du_int a, long double expected) int test__floatundixf(du_int a, long double expected)
{ {
long double x = __floatundixf(a); long double x = __floatundixf(a);
if (x != expected) if (x != expected)
printf("error in __floatundixf(%llX) = %LA, expected %LA\n", printf("error in __floatundixf(%llX) = %LA, expected %LA\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatunsitf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatunsitf // REQUIRES: librt_has_floatunsitf
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
COMPILER_RT_ABI long double __floatunsitf(unsigned int a); DECLARE_LIBCALL(long double, __floatunsitf, unsigned int a);
int test__floatunsitf(unsigned int a, uint64_t expectedHi, uint64_t expectedLo) int test__floatunsitf(unsigned int a, uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __floatunsitf(a); long double x = __floatunsitf(a);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret){ if (ret){
printf("error in test__floatunsitf(%u) = %.20Lf, " printf("error in test__floatunsitf(%u) = %.20Lf, "
Show All 27 Lines

compiler-rt/test/builtins/Unit/floatunssidfvfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatunssidfvfp // REQUIRES: librt_has_floatunssidfvfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI double __floatunssidfvfp(unsigned int a); extern DECLARE_LIBCALL(double, __floatunssidfvfp, unsigned int a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__floatunssidfvfp(unsigned int a) int test__floatunssidfvfp(unsigned int a)
{ {
double actual = __floatunssidfvfp(a); double actual = __floatunssidfvfp(a);
double expected = a; double expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__floatunssidfvfp(%u) = %f, expected %f\n", printf("error in test__floatunssidfvfp(%u) = %f, expected %f\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/floatunssisfvfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatunssisfvfp // REQUIRES: librt_has_floatunssisfvfp
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#include "int_lib.h" #include "int_lib.h"
extern COMPILER_RT_ABI float __floatunssisfvfp(unsigned int a); extern DECLARE_LIBCALL(float, __floatunssisfvfp, unsigned int a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__floatunssisfvfp(unsigned int a) int test__floatunssisfvfp(unsigned int a)
{ {
float actual = __floatunssisfvfp(a); float actual = __floatunssisfvfp(a);
float expected = a; float expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__floatunssisfvfp(%u) = %f, expected %f\n", printf("error in test__floatunssisfvfp(%u) = %f, expected %f\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/floatuntidf_test.c

Show All 9 Lines
// Returns: convert a to a double, rounding toward even. // Returns: convert a to a double, rounding toward even.
// Assumption: double is a IEEE 64 bit floating point type // Assumption: double is a IEEE 64 bit floating point type
// tu_int is a 64 bit integral type // tu_int is a 64 bit integral type
// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI double __floatuntidf(tu_int a); DECLARE_LIBCALL(double, __floatuntidf, tu_int a);
int test__floatuntidf(tu_int a, double expected) int test__floatuntidf(tu_int a, double expected)
{ {
double x = __floatuntidf(a); double x = __floatuntidf(a);
if (x != expected) if (x != expected)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatuntisf_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_floatuntisf // REQUIRES: librt_has_floatuntisf
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
#if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
// 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); DECLARE_LIBCALL(float, __floatuntisf, tu_int a);
int test__floatuntisf(tu_int a, float expected) int test__floatuntisf(tu_int a, float expected)
{ {
float x = __floatuntisf(a); float x = __floatuntisf(a);
if (x != expected) if (x != expected)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatuntitf_test.c

Show All 13 Lines
/* Assumption: fp_t is a IEEE 128 bit floating point type /* Assumption: fp_t is a IEEE 128 bit floating point type
* tu_int is a 128 bit integral type * tu_int is a 128 bit integral type
*/ */
/* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | /* seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm |
* mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm * mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
*/ */
COMPILER_RT_ABI fp_t __floatuntitf(tu_int a); DECLARE_LIBCALL(fp_t, __floatuntitf, tu_int a);
int test__floatuntitf(tu_int a, fp_t expected) { int test__floatuntitf(tu_int a, fp_t expected) {
fp_t x = __floatuntitf(a); fp_t x = __floatuntitf(a);
if (x != expected) { if (x != expected) {
utwords at; utwords at;
at.all = a; at.all = a;
printf("error in __floatuntitf(0x%.16llX%.16llX) = %LA, expected %LA\n", printf("error in __floatuntitf(0x%.16llX%.16llX) = %LA, expected %LA\n",
at.s.high, at.s.low, x, expected); at.s.high, at.s.low, x, expected);
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatuntixf_test.c

Show All 10 Lines
// Returns: convert a to a long double, rounding toward even. // Returns: convert a to a long double, rounding toward even.
// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
// tu_int is a 128 bit integral type // tu_int is a 128 bit integral type
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI long double __floatuntixf(tu_int a); DECLARE_LIBCALL(long double, __floatuntixf, tu_int a);
int test__floatuntixf(tu_int a, long double expected) int test__floatuntixf(tu_int a, long double expected)
{ {
long double x = __floatuntixf(a); long double x = __floatuntixf(a);
if (x != expected) if (x != expected)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/lshrdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_lshrdi3 // REQUIRES: librt_has_lshrdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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, int b); DECLARE_LIBCALL(di_int, __lshrdi3, di_int a, int b);
int test__lshrdi3(di_int a, int b, di_int expected) int test__lshrdi3(di_int a, int b, di_int expected)
{ {
di_int x = __lshrdi3(a, b); di_int x = __lshrdi3(a, b);
if (x != expected) if (x != expected)
printf("error in __lshrdi3: %llX >> %d = %llX, expected %llX\n", printf("error in __lshrdi3: %llX >> %d = %llX, expected %llX\n",
a, b, __lshrdi3(a, b), expected); a, b, __lshrdi3(a, b), expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/lshrti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_lshrti3 // REQUIRES: librt_has_lshrti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: logical a >> b // Returns: logical a >> b
// Precondition: 0 <= b < bits_in_dword // Precondition: 0 <= b < bits_in_dword
COMPILER_RT_ABI ti_int __lshrti3(ti_int a, si_int b); DECLARE_LIBCALL(ti_int, __lshrti3, ti_int a, si_int b);
int test__lshrti3(ti_int a, si_int b, ti_int expected) int test__lshrti3(ti_int a, si_int b, ti_int expected)
{ {
ti_int x = __lshrti3(a, b); ti_int x = __lshrti3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/moddi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_moddi3 // REQUIRES: librt_has_moddi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI di_int __moddi3(di_int a, di_int b); DECLARE_LIBCALL(di_int, __moddi3, di_int a, di_int b);
int test__moddi3(di_int a, di_int b, di_int expected) int test__moddi3(di_int a, di_int b, di_int expected)
{ {
di_int x = __moddi3(a, b); di_int x = __moddi3(a, b);
if (x != expected) if (x != expected)
printf("error in __moddi3: %lld %% %lld = %lld, expected %lld\n", printf("error in __moddi3: %lld %% %lld = %lld, expected %lld\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
Show All 35 Lines

compiler-rt/test/builtins/Unit/modsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_modsi3 // REQUIRES: librt_has_modsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
/* Returns: a % b */ /* Returns: a % b */
COMPILER_RT_ABI si_int __modsi3(si_int a, si_int b); DECLARE_LIBCALL(si_int, __modsi3, si_int a, si_int b);
int test__modsi3(si_int a, si_int b, si_int expected) { int test__modsi3(si_int a, si_int b, si_int expected) {
si_int x = __modsi3(a, b); si_int x = __modsi3(a, b);
if (x != expected) if (x != expected)
fprintf(stderr, "error in __modsi3: %d %% %d = %d, expected %d\n", fprintf(stderr, "error in __modsi3: %d %% %d = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
} }
Show All 29 Lines

compiler-rt/test/builtins/Unit/modti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_modti3 // REQUIRES: librt_has_modti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __modti3, ti_int a, ti_int b);
int test__modti3(ti_int a, ti_int b, ti_int expected) int test__modti3(ti_int a, ti_int b, ti_int expected)
{ {
ti_int x = __modti3(a, b); ti_int x = __modti3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/muldc3_test.c

// RUN: %clang_builtins %s -ffp-contract=off %librt -lm -o %t && %run %t // RUN: %clang_builtins %s -ffp-contract=off %librt -lm -o %t && %run %t
// REQUIRES: librt_has_muldc3 // REQUIRES: librt_has_muldc3
// REQUIRES: c99-complex // REQUIRES: c99-complex
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
// Returns: the product of a + ib and c + id // Returns: the product of a + ib and c + id
COMPILER_RT_ABI double _Complex DECLARE_LIBCALL(double _Complex, __muldc3,
__muldc3(double __a, double __b, double __c, double __d); double __a, double __b, double __c, double __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(double _Complex x) classify(double _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 337 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/muldf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_muldf3vfp // REQUIRES: librt_has_muldf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
extern COMPILER_RT_ABI double __muldf3vfp(double a, double b); extern DECLARE_LIBCALL(double, __muldf3vfp, double a, double b);
int test__muldf3vfp(double a, double b) int test__muldf3vfp(double a, double b)
{ {
double actual = __muldf3vfp(a, b); double actual = __muldf3vfp(a, b);
double expected = a * b; double expected = a * b;
if (actual != expected) if (actual != expected)
printf("error in test__muldf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__muldf3vfp(%f, %f) = %f, expected %f\n",
a, b, actual, expected); a, b, actual, expected);
Show All 22 Lines

compiler-rt/test/builtins/Unit/muldi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_muldi3 // REQUIRES: librt_has_muldi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
COMPILER_RT_ABI di_int __muldi3(di_int a, di_int b); DECLARE_LIBCALL(di_int, __muldi3, di_int a, di_int b);
int test__muldi3(di_int a, di_int b, di_int expected) int test__muldi3(di_int a, di_int b, di_int expected)
{ {
di_int x = __muldi3(a, b); di_int x = __muldi3(a, b);
if (x != expected) if (x != expected)
printf("error in __muldi3: %lld * %lld = %lld, expected %lld\n", printf("error in __muldi3: %lld * %lld = %lld, expected %lld\n",
a, b, __muldi3(a, b), expected); a, b, __muldi3(a, b), expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulodi4_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_mulodi4 // REQUIRES: librt_has_mulodi4
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
extern COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int* overflow); extern DECLARE_LIBCALL(di_int, __mulodi4, di_int a, di_int b, int* overflow);
int test__mulodi4(di_int a, di_int b, di_int expected, int expected_overflow) int test__mulodi4(di_int a, di_int b, di_int expected, int expected_overflow)
{ {
int ov; int ov;
di_int x = __mulodi4(a, b, &ov); di_int x = __mulodi4(a, b, &ov);
if (ov != expected_overflow) if (ov != expected_overflow)
printf("error in __mulodi4: overflow=%d expected=%d\n", printf("error in __mulodi4: overflow=%d expected=%d\n",
ov, expected_overflow); ov, expected_overflow);
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulosi4_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_mulosi4 // REQUIRES: librt_has_mulosi4
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a * b // Returns: a * b
// Effects: aborts if a * b overflows // Effects: aborts if a * b overflows
COMPILER_RT_ABI si_int __mulosi4(si_int a, si_int b, int *overflow); DECLARE_LIBCALL(si_int, __mulosi4, si_int a, si_int b, int *overflow);
int test__mulosi4(si_int a, si_int b, si_int expected, int expected_overflow) int test__mulosi4(si_int a, si_int b, si_int expected, int expected_overflow)
{ {
int ov; int ov;
si_int x = __mulosi4(a, b, &ov); si_int x = __mulosi4(a, b, &ov);
if (ov != expected_overflow) if (ov != expected_overflow)
printf("error in __mulosi4: overflow=%d expected=%d\n", printf("error in __mulosi4: overflow=%d expected=%d\n",
ov, expected_overflow); ov, expected_overflow);
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/muloti4_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_muloti4 // REQUIRES: librt_has_muloti4
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: a * b // Returns: a * b
// Effects: sets overflow if a * b overflows // Effects: sets overflow if a * b overflows
COMPILER_RT_ABI ti_int __muloti4(ti_int a, ti_int b, int *overflow); DECLARE_LIBCALL(ti_int, __muloti4, ti_int a, ti_int b, int *overflow);
int test__muloti4(ti_int a, ti_int b, ti_int expected, int expected_overflow) int test__muloti4(ti_int a, ti_int b, ti_int expected, int expected_overflow)
{ {
int ov; int ov;
ti_int x = __muloti4(a, b, &ov); ti_int x = __muloti4(a, b, &ov);
if (ov != expected_overflow) { if (ov != expected_overflow) {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulsc3_test.c

// RUN: %clang_builtins %s %librt -lm -o %t && %run %t // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
// REQUIRES: librt_has_mulsc3 // REQUIRES: librt_has_mulsc3
// REQUIRES: c99-complex // REQUIRES: c99-complex
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.h>
// Returns: the product of a + ib and c + id // Returns: the product of a + ib and c + id
COMPILER_RT_ABI float _Complex DECLARE_LIBCALL(float _Complex, __mulsc3,
__mulsc3(float __a, float __b, float __c, float __d); float __a, float __b, float __c, float __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(float _Complex x) classify(float _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulsf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_mulsf3vfp // REQUIRES: librt_has_mulsf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __mulsf3vfp(float a, float b); extern DECLARE_LIBCALL(float, __mulsf3vfp, float a, float b);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__mulsf3vfp(float a, float b) int test__mulsf3vfp(float a, float b)
{ {
float actual = __mulsf3vfp(a, b); float actual = __mulsf3vfp(a, b);
float expected = a * b; float expected = a * b;
if (actual != expected) if (actual != expected)
printf("error in test__mulsf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__mulsf3vfp(%f, %f) = %f, expected %f\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/multc3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_multc3 // REQUIRES: librt_has_multc3
#include <stdio.h> #include <stdio.h>
#if _ARCH_PPC || __aarch64__ #if _ARCH_PPC || __aarch64__
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.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 DECLARE_LIBCALL(long double _Complex, __multc3,
__multc3(long double __a, long double __b, long double __c, long double __d); long double __a, long double __b, long double __c, long double __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(long double _Complex x) classify(long double _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 342 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/multf3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_multf3 // REQUIRES: librt_has_multf3
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "int_lib.h" #include "int_lib.h"
#include "fp_test.h" #include "fp_test.h"
// Returns: a * b // Returns: a * b
COMPILER_RT_ABI long double __multf3(long double a, long double b); DECLARE_LIBCALL(long double, __multf3, long double a, long double b);
int test__multf3(long double a, long double b, int test__multf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo) uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __multf3(a, b); long double x = __multf3(a, b);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret){ if (ret){
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/multi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_multi3 // REQUIRES: librt_has_multi3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
COMPILER_RT_ABI ti_int __multi3(ti_int a, ti_int b); DECLARE_LIBCALL(ti_int, __multi3, ti_int a, ti_int b);
int test__multi3(ti_int a, ti_int b, ti_int expected) int test__multi3(ti_int a, ti_int b, ti_int expected)
{ {
ti_int x = __multi3(a, b); ti_int x = __multi3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulvdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_mulvdi3 // REQUIRES: librt_has_mulvdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(di_int, __mulvdi3, di_int a, di_int b);
int test__mulvdi3(di_int a, di_int b, di_int expected) int test__mulvdi3(di_int a, di_int b, di_int expected)
{ {
di_int x = __mulvdi3(a, b); di_int x = __mulvdi3(a, b);
if (x != expected) if (x != expected)
printf("error in __mulvdi3: %lld * %lld = %lld, expected %lld\n", printf("error in __mulvdi3: %lld * %lld = %lld, expected %lld\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulvsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_mulvsi3 // REQUIRES: librt_has_mulvsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(si_int, __mulvsi3, si_int a, si_int b);
int test__mulvsi3(si_int a, si_int b, si_int expected) int test__mulvsi3(si_int a, si_int b, si_int expected)
{ {
si_int x = __mulvsi3(a, b); si_int x = __mulvsi3(a, b);
if (x != expected) if (x != expected)
printf("error in __mulvsi3: %d * %d = %d, expected %d\n", printf("error in __mulvsi3: %d * %d = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulvti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_mulvti3 // REQUIRES: librt_has_mulvti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __mulvti3, ti_int a, ti_int b);
int test__mulvti3(ti_int a, ti_int b, ti_int expected) int test__mulvti3(ti_int a, ti_int b, ti_int expected)
{ {
ti_int x = __mulvti3(a, b); ti_int x = __mulvti3(a, b);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/mulxc3_test.c

Show All 9 Lines
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <stdio.h> #include <stdio.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 DECLARE_LIBCALL(long double _Complex, __mulxc3,
__mulxc3(long double __a, long double __b, long double __c, long double __d); long double __a, long double __b, long double __c, long double __d);
enum {zero, non_zero, inf, NaN, non_zero_nan}; enum {zero, non_zero, inf, NaN, non_zero_nan};
int int
classify(long double _Complex x) classify(long double _Complex x)
{ {
if (x == 0) if (x == 0)
return zero; return zero;
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/negdf2vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negdf2vfp // REQUIRES: librt_has_negdf2vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
extern COMPILER_RT_ABI double __negdf2vfp(double a); extern DECLARE_LIBCALL(double, __negdf2vfp, double a);
int test__negdf2vfp(double a) int test__negdf2vfp(double a)
{ {
double actual = __negdf2vfp(a); double actual = __negdf2vfp(a);
double expected = -a; double expected = -a;
if (actual != expected) if (actual != expected)
printf("error in test__negdf2vfp(%f) = %f, expected %f\n", printf("error in test__negdf2vfp(%f) = %f, expected %f\n",
a, actual, expected); a, actual, expected);
Show All 20 Lines

compiler-rt/test/builtins/Unit/negdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negdi2 // REQUIRES: librt_has_negdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: -a // Returns: -a
COMPILER_RT_ABI di_int __negdi2(di_int a); DECLARE_LIBCALL(di_int, __negdi2, di_int a);
int test__negdi2(di_int a, di_int expected) int test__negdi2(di_int a, di_int expected)
{ {
di_int x = __negdi2(a); di_int x = __negdi2(a);
if (x != expected) if (x != expected)
printf("error in __negdi2: -0x%llX = 0x%llX, expected 0x%llX\n", printf("error in __negdi2: -0x%llX = 0x%llX, expected 0x%llX\n",
a, x, expected); a, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/negsf2vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negsf2vfp // REQUIRES: librt_has_negsf2vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __negsf2vfp(float a); extern DECLARE_LIBCALL(float, __negsf2vfp, float a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__negsf2vfp(float a) int test__negsf2vfp(float a)
{ {
float actual = __negsf2vfp(a); float actual = __negsf2vfp(a);
float expected = -a; float expected = -a;
if (actual != expected) if (actual != expected)
printf("error in test__negsf2vfp(%f) = %f, expected %f\n", printf("error in test__negsf2vfp(%f) = %f, expected %f\n",
Show All 21 Lines

compiler-rt/test/builtins/Unit/negti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negti2 // REQUIRES: librt_has_negti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: -a // Returns: -a
COMPILER_RT_ABI ti_int __negti2(ti_int a); DECLARE_LIBCALL(ti_int, __negti2, ti_int a);
int test__negti2(ti_int a, ti_int expected) int test__negti2(ti_int a, ti_int expected)
{ {
ti_int x = __negti2(a); ti_int x = __negti2(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/negvdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negvdi2 // REQUIRES: librt_has_negvdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: -a // Returns: -a
// Effects: aborts if -a overflows // Effects: aborts if -a overflows
COMPILER_RT_ABI di_int __negvdi2(di_int a); DECLARE_LIBCALL(di_int, __negvdi2, di_int a);
int test__negvdi2(di_int a) int test__negvdi2(di_int a)
{ {
di_int x = __negvdi2(a); di_int x = __negvdi2(a);
di_int expected = -a; di_int expected = -a;
if (x != expected) if (x != expected)
printf("error in __negvdi2(0x%llX) = %lld, expected %lld\n", printf("error in __negvdi2(0x%llX) = %lld, expected %lld\n",
a, x, expected); a, x, expected);
Show All 28 Lines

compiler-rt/test/builtins/Unit/negvsi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negvsi2 // REQUIRES: librt_has_negvsi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: -a // Returns: -a
// Effects: aborts if -a overflows // Effects: aborts if -a overflows
COMPILER_RT_ABI si_int __negvsi2(si_int a); DECLARE_LIBCALL(si_int, __negvsi2, si_int a);
int test__negvsi2(si_int a) int test__negvsi2(si_int a)
{ {
si_int x = __negvsi2(a); si_int x = __negvsi2(a);
si_int expected = -a; si_int expected = -a;
if (x != expected) if (x != expected)
printf("error in __negvsi2(0x%X) = %d, expected %d\n", a, x, expected); printf("error in __negvsi2(0x%X) = %d, expected %d\n", a, x, expected);
return x != expected; return x != expected;
Show All 27 Lines

compiler-rt/test/builtins/Unit/negvti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_negvti2 // REQUIRES: librt_has_negvti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(ti_int, __negvti2, ti_int a);
COMPILER_RT_ABI ti_int __negti2(ti_int a); DECLARE_LIBCALL(ti_int, __negti2, ti_int a);
int test__negvti2(ti_int a) int test__negvti2(ti_int a)
{ {
ti_int x = __negvti2(a); ti_int x = __negvti2(a);
ti_int expected = __negti2(a); ti_int expected = __negti2(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/paritydi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_paritydi2 // REQUIRES: librt_has_paritydi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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 int __paritydi2(di_int a); DECLARE_LIBCALL(int, __paritydi2, di_int a);
int naive_parity(di_int a) int naive_parity(di_int a)
{ {
int r = 0; int r = 0;
for (; a; a = a & (a - 1)) for (; a; a = a & (a - 1))
r = ~r; r = ~r;
return r & 1; return r & 1;
} }
Show All 23 Lines

compiler-rt/test/builtins/Unit/paritysi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_paritysi2 // REQUIRES: librt_has_paritysi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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 int __paritysi2(si_int a); DECLARE_LIBCALL(int, __paritysi2, si_int a);
int naive_parity(si_int a) int naive_parity(si_int a)
{ {
int r = 0; int r = 0;
for (; a; a = a & (a - 1)) for (; a; a = a & (a - 1))
r = ~r; r = ~r;
return r & 1; return r & 1;
} }
Show All 22 Lines

compiler-rt/test/builtins/Unit/parityti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_parityti2 // REQUIRES: librt_has_parityti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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 int __parityti2(ti_int a); DECLARE_LIBCALL(int, __parityti2, ti_int a);
int naive_parity(ti_int a) int naive_parity(ti_int a)
{ {
int r = 0; int r = 0;
for (; a; a = a & (a - 1)) for (; a; a = a & (a - 1))
r = ~r; r = ~r;
return r & 1; return r & 1;
} }
Show All 34 Lines

compiler-rt/test/builtins/Unit/popcountdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_popcountdi2 // REQUIRES: librt_has_popcountdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
// Returns: count of 1 bits // Returns: count of 1 bits
COMPILER_RT_ABI int __popcountdi2(di_int a); DECLARE_LIBCALL(int, __popcountdi2, di_int a);
int naive_popcount(di_int a) int naive_popcount(di_int a)
{ {
int r = 0; int r = 0;
for (; a; a = (du_int)a >> 1) for (; a; a = (du_int)a >> 1)
r += a & 1; r += a & 1;
return r; return r;
} }
Show All 35 Lines

compiler-rt/test/builtins/Unit/popcountsi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_popcountsi2 // REQUIRES: librt_has_popcountsi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
// Returns: count of 1 bits // Returns: count of 1 bits
COMPILER_RT_ABI int __popcountsi2(si_int a); DECLARE_LIBCALL(int, __popcountsi2, si_int a);
int naive_popcount(si_int a) int naive_popcount(si_int a)
{ {
int r = 0; int r = 0;
for (; a; a = (su_int)a >> 1) for (; a; a = (su_int)a >> 1)
r += a & 1; r += a & 1;
return r; return r;
} }
Show All 34 Lines

compiler-rt/test/builtins/Unit/popcountti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_popcountti2 // REQUIRES: librt_has_popcountti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
// Returns: count of 1 bits // Returns: count of 1 bits
COMPILER_RT_ABI int __popcountti2(ti_int a); DECLARE_LIBCALL(int, __popcountti2, ti_int a);
int naive_popcount(ti_int a) int naive_popcount(ti_int a)
{ {
int r = 0; int r = 0;
for (; a; a = (tu_int)a >> 1) for (; a; a = (tu_int)a >> 1)
r += a & 1; r += a & 1;
return r; return r;
} }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/powidf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_powidf2 // REQUIRES: librt_has_powidf2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
// Returns: a ^ b // Returns: a ^ b
COMPILER_RT_ABI double __powidf2(double a, int b); DECLARE_LIBCALL(double, __powidf2, double a, int b);
int test__powidf2(double a, int b, double expected) int test__powidf2(double a, int b, double expected)
{ {
double x = __powidf2(a, b); double x = __powidf2(a, b);
int correct = (x == expected) && (signbit(x) == signbit(expected)); int correct = (x == expected) && (signbit(x) == signbit(expected));
if (!correct) if (!correct)
printf("error in __powidf2(%f, %d) = %f, expected %f\n", printf("error in __powidf2(%f, %d) = %f, expected %f\n",
a, b, x, expected); a, b, x, expected);
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/powisf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_powisf2 // REQUIRES: librt_has_powisf2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
// Returns: a ^ b // Returns: a ^ b
COMPILER_RT_ABI float __powisf2(float a, int b); DECLARE_LIBCALL(float, __powisf2, float a, int b);
int test__powisf2(float a, int b, float expected) int test__powisf2(float a, int b, float expected)
{ {
float x = __powisf2(a, b); float x = __powisf2(a, b);
int correct = (x == expected) && (signbit(x) == signbit(expected)); int correct = (x == expected) && (signbit(x) == signbit(expected));
if (!correct) if (!correct)
printf("error in __powisf2(%f, %d) = %f, expected %f\n", printf("error in __powisf2(%f, %d) = %f, expected %f\n",
a, b, x, expected); a, b, x, expected);
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/powitf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_powitf2 // REQUIRES: librt_has_powitf2
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "int_lib.h" #include "int_lib.h"
#include <math.h> #include <math.h>
// Returns: a ^ b // Returns: a ^ b
COMPILER_RT_ABI long double __powitf2(long double a, int b); DECLARE_LIBCALL(long double, __powitf2, long double a, int b);
int test__powitf2(long double a, int b, long double expected) int test__powitf2(long double a, int b, long double expected)
{ {
long double x = __powitf2(a, b); long double x = __powitf2(a, b);
int correct = (x == expected) && (signbit(x) == signbit(expected)); int correct = (x == expected) && (signbit(x) == signbit(expected));
if (!correct) if (!correct)
printf("error in __powitf2(%Lf, %d) = %Lf, expected %Lf\n", printf("error in __powitf2(%Lf, %d) = %Lf, expected %Lf\n",
a, b, x, expected); a, b, x, expected);
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/powixf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_powixf2 // REQUIRES: librt_has_powixf2
// UNSUPPORTED: powerpc64 // UNSUPPORTED: powerpc64
// REQUIRES: x86-target-arch // REQUIRES: x86-target-arch
#if !_ARCH_PPC #if !_ARCH_PPC
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
// Returns: a ^ b // Returns: a ^ b
COMPILER_RT_ABI long double __powixf2(long double a, int b); DECLARE_LIBCALL(long double, __powixf2, long double a, int b);
int test__powixf2(long double a, int b, long double expected) int test__powixf2(long double a, int b, long double expected)
{ {
long double x = __powixf2(a, b); long double x = __powixf2(a, b);
int correct = (x == expected) && (signbit(x) == signbit(expected)); int correct = (x == expected) && (signbit(x) == signbit(expected));
if (!correct) if (!correct)
printf("error in __powixf2(%Lf, %d) = %Lf, expected %Lf\n", printf("error in __powixf2(%Lf, %d) = %Lf, expected %Lf\n",
a, b, x, expected); a, b, x, expected);
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/subdf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_subdf3vfp // REQUIRES: librt_has_subdf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
extern COMPILER_RT_ABI double __subdf3vfp(double a, double b); extern DECLARE_LIBCALL(double, __subdf3vfp, double a, double b);
int test__subdf3vfp(double a, double b) int test__subdf3vfp(double a, double b)
{ {
double actual = __subdf3vfp(a, b); double actual = __subdf3vfp(a, b);
double expected = a - b; double expected = a - b;
if (actual != expected) if (actual != expected)
printf("error in test__subdf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__subdf3vfp(%f, %f) = %f, expected %f\n",
a, b, actual, expected); a, b, actual, expected);
Show All 20 Lines

compiler-rt/test/builtins/Unit/subsf3vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_subsf3vfp // REQUIRES: librt_has_subsf3vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __subsf3vfp(float a, float b); extern DECLARE_LIBCALL(float, __subsf3vfp, float a, float b);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__subsf3vfp(float a, float b) int test__subsf3vfp(float a, float b)
{ {
float actual = __subsf3vfp(a, b); float actual = __subsf3vfp(a, b);
float expected = a - b; float expected = a - b;
if (actual != expected) if (actual != expected)
printf("error in test__subsf3vfp(%f, %f) = %f, expected %f\n", printf("error in test__subsf3vfp(%f, %f) = %f, expected %f\n",
Show All 21 Lines

compiler-rt/test/builtins/Unit/subtf3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_subtf3 // REQUIRES: librt_has_subtf3
#include <fenv.h> #include <fenv.h>
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "int_lib.h" #include "int_lib.h"
#include "fp_test.h" #include "fp_test.h"
// Returns: a - b // Returns: a - b
COMPILER_RT_ABI long double __subtf3(long double a, long double b); DECLARE_LIBCALL(long double, __subtf3, long double a, long double b);
int test__subtf3(long double a, long double b, int test__subtf3(long double a, long double b,
uint64_t expectedHi, uint64_t expectedLo) uint64_t expectedHi, uint64_t expectedLo)
{ {
long double x = __subtf3(a, b); long double x = __subtf3(a, b);
int ret = compareResultLD(x, expectedHi, expectedLo); int ret = compareResultLD(x, expectedHi, expectedLo);
if (ret){ if (ret){
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/subvdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_subvdi3 // REQUIRES: librt_has_subvdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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); DECLARE_LIBCALL(di_int, __subvdi3, di_int a, di_int b);
int test__subvdi3(di_int a, di_int b) int test__subvdi3(di_int a, di_int b)
{ {
di_int x = __subvdi3(a, b); di_int x = __subvdi3(a, b);
di_int expected = a - b; di_int expected = a - b;
if (x != expected) if (x != expected)
printf("error in test__subvsi3(0x%llX, 0x%llX) = %lld, expected %lld\n", printf("error in test__subvsi3(0x%llX, 0x%llX) = %lld, expected %lld\n",
a, b, x, expected); a, b, x, expected);
Show All 30 Lines

compiler-rt/test/builtins/Unit/subvsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_subvsi3 // REQUIRES: librt_has_subvsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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); DECLARE_LIBCALL(si_int, __subvsi3, si_int a, si_int b);
int test__subvsi3(si_int a, si_int b) int test__subvsi3(si_int a, si_int b)
{ {
si_int x = __subvsi3(a, b); si_int x = __subvsi3(a, b);
si_int expected = a - b; si_int expected = a - b;
if (x != expected) if (x != expected)
printf("error in test__subvsi3(0x%X, 0x%X) = %d, expected %d\n", printf("error in test__subvsi3(0x%X, 0x%X) = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
Show All 30 Lines

compiler-rt/test/builtins/Unit/subvti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_subvti3 // REQUIRES: librt_has_subvti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.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); DECLARE_LIBCALL(ti_int, __subvti3, ti_int a, ti_int b);
int test__subvti3(ti_int a, ti_int b) int test__subvti3(ti_int a, ti_int b)
{ {
ti_int x = __subvti3(a, b); ti_int x = __subvti3(a, b);
ti_int expected = a - b; ti_int expected = a - b;
if (x != expected) if (x != expected)
{ {
twords at; twords at;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/truncdfsf2vfp_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_truncdfsf2vfp // REQUIRES: librt_has_truncdfsf2vfp
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
extern COMPILER_RT_ABI float __truncdfsf2vfp(double a); extern DECLARE_LIBCALL(float, __truncdfsf2vfp, double a);
#if __arm__ && __VFP_FP__ #if __arm__ && __VFP_FP__
int test__truncdfsf2vfp(double a) int test__truncdfsf2vfp(double a)
{ {
float actual = __truncdfsf2vfp(a); float actual = __truncdfsf2vfp(a);
float expected = a; float expected = a;
if (actual != expected) if (actual != expected)
printf("error in test__truncdfsf2vfp(%f) = %f, expected %f\n", printf("error in test__truncdfsf2vfp(%f) = %f, expected %f\n",
Show All 23 Lines

compiler-rt/test/builtins/Unit/trunctfdf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_trunctfdf2 // REQUIRES: librt_has_trunctfdf2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
COMPILER_RT_ABI double __trunctfdf2(long double a); DECLARE_LIBCALL(double, __trunctfdf2, long double a);
int test__trunctfdf2(long double a, uint64_t expected) int test__trunctfdf2(long double a, uint64_t expected)
{ {
double x = __trunctfdf2(a); double x = __trunctfdf2(a);
int ret = compareResultD(x, expected); int ret = compareResultD(x, expected);
if (ret) if (ret)
{ {
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/trunctfsf2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_trunctfsf2 // REQUIRES: librt_has_trunctfsf2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#if __LDBL_MANT_DIG__ == 113 #if __LDBL_MANT_DIG__ == 113
#include "fp_test.h" #include "fp_test.h"
COMPILER_RT_ABI float __trunctfsf2(long double a); DECLARE_LIBCALL(float, __trunctfsf2, long double a);
int test__trunctfsf2(long double a, uint32_t expected) int test__trunctfsf2(long double a, uint32_t expected)
{ {
float x = __trunctfsf2(a); float x = __trunctfsf2(a);
int ret = compareResultF(x, expected); int ret = compareResultF(x, expected);
if (ret){ if (ret){
printf("error in test__trunctfsf2(%.20Lf) = %f, " printf("error in test__trunctfsf2(%.20Lf) = %f, "
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ucmpdi2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ucmpdi2 // REQUIRES: librt_has_ucmpdi2
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(si_int, __ucmpdi2, du_int a, du_int b);
int test__ucmpdi2(du_int a, du_int b, si_int expected) int test__ucmpdi2(du_int a, du_int b, si_int expected)
{ {
si_int x = __ucmpdi2(a, b); si_int x = __ucmpdi2(a, b);
if (x != expected) if (x != expected)
printf("error in __ucmpdi2(0x%llX, 0x%llX) = %d, expected %d\n", printf("error in __ucmpdi2(0x%llX, 0x%llX) = %d, expected %d\n",
a, b, x, expected); a, b, x, expected);
return x != expected; return x != expected;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/ucmpti2_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_ucmpti2 // REQUIRES: librt_has_ucmpti2
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(si_int, __ucmpti2, tu_int a, tu_int b);
int test__ucmpti2(tu_int a, tu_int b, si_int expected) int test__ucmpti2(tu_int a, tu_int b, si_int expected)
{ {
si_int x = __ucmpti2(a, b); si_int x = __ucmpti2(a, b);
if (x != expected) if (x != expected)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/udivdi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_udivdi3 // REQUIRES: librt_has_udivdi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b); DECLARE_LIBCALL(du_int, __udivdi3, du_int a, du_int b);
int test__udivdi3(du_int a, du_int b, du_int expected_q) int test__udivdi3(du_int a, du_int b, du_int expected_q)
{ {
du_int q = __udivdi3(a, b); du_int q = __udivdi3(a, b);
if (q != expected_q) if (q != expected_q)
printf("error in __udivdi3: %lld / %lld = %lld, expected %lld\n", printf("error in __udivdi3: %lld / %lld = %lld, expected %lld\n",
a, b, q, expected_q); a, b, q, expected_q);
return q != expected_q; return q != expected_q;
Show All 17 Lines

compiler-rt/test/builtins/Unit/udivmoddi4_test.c

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_udivmoddi4 // REQUIRES: librt_has_udivmoddi4
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Effects: if rem != 0, *rem = a % b // Effects: if rem != 0, *rem = a % b
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem); DECLARE_LIBCALL(du_int, __udivmoddi4, du_int a, du_int b, du_int* rem);
int test__udivmoddi4(du_int a, du_int b, du_int expected_q, du_int expected_r) int test__udivmoddi4(du_int a, du_int b, du_int expected_q, du_int expected_r)
{ {
du_int r; du_int r;
du_int q = __udivmoddi4(a, b, &r); du_int q = __udivmoddi4(a, b, &r);
if (q != expected_q || r != expected_r) if (q != expected_q || r != expected_r)
printf("error in __udivmoddi4: %llX / %llX = %llX, R = %llX, expected %llX, %llX\n", printf("error in __udivmoddi4: %llX / %llX = %llX, R = %llX, expected %llX, %llX\n",
a, b, q, r, expected_q, expected_r); a, b, q, r, expected_q, expected_r);
▲ Show 20 Lines • Show All 20,611 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/udivmodsi4_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_udivmodsi4 // REQUIRES: librt_has_udivmodsi4
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a / b // Returns: a / b
extern COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int* rem); extern DECLARE_LIBCALL(su_int, __udivmodsi4, su_int a, su_int b, su_int* rem);
int test__udivmodsi4(su_int a, su_int b, int test__udivmodsi4(su_int a, su_int b,
su_int expected_result, su_int expected_rem) su_int expected_result, su_int expected_rem)
{ {
su_int rem; su_int rem;
su_int result = __udivmodsi4(a, b, &rem); su_int result = __udivmodsi4(a, b, &rem);
if (result != expected_result) { if (result != expected_result) {
printf("error in __udivmodsi4: %u / %u = %u, expected %u\n", printf("error in __udivmodsi4: %u / %u = %u, expected %u\n",
Show All 32 Lines

compiler-rt/test/builtins/Unit/udivsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_udivsi3 // REQUIRES: librt_has_udivsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a / b // Returns: a / b
COMPILER_RT_ABI su_int __udivsi3(su_int a, su_int b); DECLARE_LIBCALL(su_int, __udivsi3, su_int a, su_int b);
int test__udivsi3(su_int a, su_int b, su_int expected_q) int test__udivsi3(su_int a, su_int b, su_int expected_q)
{ {
su_int q = __udivsi3(a, b); su_int q = __udivsi3(a, b);
if (q != expected_q) if (q != expected_q)
printf("error in __udivsi3: %X / %X = %X, expected %X\n", printf("error in __udivsi3: %X / %X = %X, expected %X\n",
a, b, q, expected_q); a, b, q, expected_q);
return q != expected_q; return q != expected_q;
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/udivti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_udivti3 // REQUIRES: librt_has_udivti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(tu_int, __udivti3, tu_int a, tu_int b);
int test__udivti3(tu_int a, tu_int b, tu_int expected_q) int test__udivti3(tu_int a, tu_int b, tu_int expected_q)
{ {
tu_int q = __udivti3(a, b); tu_int q = __udivti3(a, b);
if (q != expected_q) if (q != expected_q)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
Show All 38 Lines

compiler-rt/test/builtins/Unit/umoddi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_umoddi3 // REQUIRES: librt_has_umoddi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI du_int __umoddi3(du_int a, du_int b); DECLARE_LIBCALL(du_int, __umoddi3, du_int a, du_int b);
int test__umoddi3(du_int a, du_int b, du_int expected_r) int test__umoddi3(du_int a, du_int b, du_int expected_r)
{ {
du_int r = __umoddi3(a, b); du_int r = __umoddi3(a, b);
if (r != expected_r) if (r != expected_r)
printf("error in __umoddi3: %lld %% %lld = %lld, expected %lld\n", printf("error in __umoddi3: %lld %% %lld = %lld, expected %lld\n",
a, b, r, expected_r); a, b, r, expected_r);
return r != expected_r; return r != expected_r;
Show All 17 Lines

compiler-rt/test/builtins/Unit/umodsi3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_umodsi3 // REQUIRES: librt_has_umodsi3
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
// Returns: a % b // Returns: a % b
COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b); DECLARE_LIBCALL(su_int, __umodsi3, su_int a, su_int b);
int test__umodsi3(su_int a, su_int b, su_int expected_r) int test__umodsi3(su_int a, su_int b, su_int expected_r)
{ {
su_int r = __umodsi3(a, b); su_int r = __umodsi3(a, b);
if (r != expected_r) if (r != expected_r)
printf("error in __umodsi3: %X %% %X = %X, expected %X\n", printf("error in __umodsi3: %X %% %X = %X, expected %X\n",
a, b, r, expected_r); a, b, r, expected_r);
return r != expected_r; return r != expected_r;
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/umodti3_test.c

// RUN: %clang_builtins %s %librt -o %t && %run %t // RUN: %clang_builtins %s %librt -o %t && %run %t
// REQUIRES: librt_has_umodti3 // REQUIRES: librt_has_umodti3
// REQUIRES: int128 // REQUIRES: int128
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.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); DECLARE_LIBCALL(tu_int, __umodti3, tu_int a, tu_int b);
int test__umodti3(tu_int a, tu_int b, tu_int expected_r) int test__umodti3(tu_int a, tu_int b, tu_int expected_r)
{ {
tu_int r = __umodti3(a, b); tu_int r = __umodti3(a, b);
if (r != expected_r) if (r != expected_r)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
Show All 36 Lines

compiler-rt/utils/generate_builtins_macro.sh

  • This file was added.
PropertyOld ValueNew Value
File Modenull100755
#!/bin/sh -e
generate_header() {
echo "//===-- libcall-set-defaults.inc ------------------------------------------===//"
echo "//"
echo "// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions."
echo "// See https://llvm.org/LICENSE.txt for license information."
echo "// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception"
echo "//"
echo "//===----------------------------------------------------------------------===//"
echo "//"
echo "// This file is not part of the interface of this library."
echo "//"
echo "// The particular target implementation can define some macroses customizing"
echo "// target-specific aliases, calling conventions, etc. After that, this file"
echo "// sets the default values for everything not yet set."
echo "//"
echo "// DO NOT EDIT! This file was auto-generated by:"
echo "//"
echo "// ../../utils/generate_builtins_macro.sh > libcall-set-defaults.inc"
echo "//"
echo "//===----------------------------------------------------------------------===//"
echo
}
generate_macroses() {
prefix=$1
default_value=$2
shift 2
for libcall in $*
do
echo "#ifndef ${prefix}${libcall}"
echo "#define ${prefix}${libcall}${default_value}"
echo "#endif"
done
}
generate_file() {
generate_header
echo "#ifndef LIBCALL_DEFAULTS"
echo "#define LIBCALL_DEFAULTS"
echo
echo "// Special LibCall attributes, empty by default"
generate_macroses "ATTR" " COMPILER_RT_ABI" "$*"
echo
echo "// Misc auxiliary declarations to place at the end of source file"
generate_macroses "AUX_DECLS" "" "$*"
echo
echo "#endif // LIBCALL_DEFAULTS"
}
libcalls="
__absvdi2
__absvsi2
__absvti2
__adddf3
__addsf3
__addtf3
__addvdi3
__addvsi3
__addvti3
__aeabi_lcmp
__aeabi_ulcmp
__ashldi3
__ashlti3
__ashrdi3
__ashrti3
__bswapdi2
__bswapsi2
__clzdi2
__clzsi2
__clzti2
__cmpdi2
__cmpti2
__ctzdi2
__ctzsi2
__ctzti2
__divdc3
__divdf3
__divdi3
__divmoddi4
__divmodsi4
__divsc3
__divsf3
__divsi3
__divtc3
__divtf3
__divti3
__divxc3
__dtoi64
__dtou64
__enable_execute_stack
__eprintf
__extenddftf2
__extendhfsf2
__extendsfdf2
__extendsftf2
__ffsdi2
__ffssi2
__ffsti2
__fixdfdi
__fixdfsi
__fixdfti
__fixsfdi
__fixsfsi
__fixsfti
__fixtfdi
__fixtfsi
__fixtfti
__fixunsdfdi
__fixunsdfsi
__fixunsdfti
__fixunssfdi
__fixunssfsi
__fixunssfti
__fixunstfdi
__fixunstfsi
__fixunstfti
__fixunsxfdi
__fixunsxfsi
__fixunsxfti
__fixxfdi
__fixxfti
__floatdidf
__floatdisf
__floatditf
__floatdixf
__floatsidf
__floatsisf
__floatsitf
__floattidf
__floattisf
__floattitf
__floattixf
__floatundidf
__floatundisf
__floatunditf
__floatundixf
__floatunsidf
__floatunsisf
__floatunsitf
__floatuntidf
__floatuntisf
__floatuntitf
__floatuntixf
__gcc_personality_sj0
__gcc_personality_v0
__gedf2
__gesf2
__getf2
__gnu_f2h_ieee
__gnu_h2f_ieee
__i64tod
__i64tos
__ledf2
__lesf2
__letf2
__lshrdi3
__lshrti3
__moddi3
__modsi3
__modti3
__muldc3
__muldf3
__muldi3
__mulodi4
__mulosi4
__muloti4
__mulsc3
__mulsf3
__multc3
__multf3
__multi3
__mulvdi3
__mulvsi3
__mulvti3
__mulxc3
__negdf2
__negdi2
__negsf2
__negti2
__negvdi2
__negvsi2
__negvti2
__paritydi2
__paritysi2
__parityti2
__popcountdi2
__popcountsi2
__popcountti2
__powidf2
__powisf2
__powitf2
__powixf2
__stoi64
__stou64
__subdf3
__subsf3
__subtf3
__subvdi3
__subvsi3
__subvti3
__trampoline_setup
__truncdfhf2
__truncdfsf2
__truncsfhf2
__trunctfdf2
__trunctfsf2
__u64tod
__u64tos
__ucmpdi2
__ucmpti2
__udivdi3
__udivmoddi4
__udivmodsi4
__udivmodti4
__udivsi3
__udivti3
__umoddi3
__umodsi3
__umodti3
__unordsf2
__unorddf2
__unordtf2
"
generate_file $libcalls