2009-12-16 04:14:24 +08:00
|
|
|
// RUN: %clang_cc1 -emit-llvm -o %t %s
|
2008-09-04 05:17:21 +08:00
|
|
|
// RUN: not grep __builtin %t
|
2010-02-28 21:00:19 +08:00
|
|
|
// RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple | FileCheck %s
|
2008-09-04 05:17:21 +08:00
|
|
|
|
2009-11-17 16:57:36 +08:00
|
|
|
int printf(const char *, ...);
|
2008-09-04 05:17:21 +08:00
|
|
|
|
|
|
|
|
void p(char *str, int x) {
|
|
|
|
|
printf("%s: %d\n", str, x);
|
|
|
|
|
}
|
|
|
|
|
void q(char *str, double x) {
|
|
|
|
|
printf("%s: %f\n", str, x);
|
|
|
|
|
}
|
2010-02-28 21:00:19 +08:00
|
|
|
void r(char *str, void *ptr) {
|
|
|
|
|
printf("%s: %p\n", str, ptr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int random(void);
|
2008-09-04 05:17:21 +08:00
|
|
|
|
|
|
|
|
int main() {
|
|
|
|
|
int N = random();
|
|
|
|
|
#define P(n,args) p(#n #args, __builtin_##n args)
|
|
|
|
|
#define Q(n,args) q(#n #args, __builtin_##n args)
|
2010-02-28 21:00:19 +08:00
|
|
|
#define R(n,args) r(#n #args, __builtin_##n args)
|
2008-09-04 05:17:21 +08:00
|
|
|
#define V(n,args) p(#n #args, (__builtin_##n args, 0))
|
|
|
|
|
P(types_compatible_p, (int, float));
|
|
|
|
|
P(choose_expr, (0, 10, 20));
|
|
|
|
|
P(constant_p, (sizeof(10)));
|
|
|
|
|
P(expect, (N == 12, 0));
|
|
|
|
|
V(prefetch, (&N));
|
|
|
|
|
V(prefetch, (&N, 1));
|
|
|
|
|
V(prefetch, (&N, 1, 0));
|
|
|
|
|
|
|
|
|
|
// Numeric Constants
|
|
|
|
|
|
|
|
|
|
Q(huge_val, ());
|
|
|
|
|
Q(huge_valf, ());
|
|
|
|
|
Q(huge_vall, ());
|
|
|
|
|
Q(inf, ());
|
|
|
|
|
Q(inff, ());
|
|
|
|
|
Q(infl, ());
|
|
|
|
|
|
2010-06-14 18:41:45 +08:00
|
|
|
P(fpclassify, (0, 1, 2, 3, 4, 1.0));
|
|
|
|
|
P(fpclassify, (0, 1, 2, 3, 4, 1.0f));
|
|
|
|
|
P(fpclassify, (0, 1, 2, 3, 4, 1.0l));
|
2008-09-04 05:17:21 +08:00
|
|
|
|
2008-10-05 14:34:45 +08:00
|
|
|
Q(nan, (""));
|
|
|
|
|
Q(nanf, (""));
|
|
|
|
|
Q(nanl, (""));
|
|
|
|
|
Q(nans, (""));
|
|
|
|
|
Q(nan, ("10"));
|
|
|
|
|
Q(nanf, ("10"));
|
|
|
|
|
Q(nanl, ("10"));
|
|
|
|
|
Q(nans, ("10"));
|
|
|
|
|
|
|
|
|
|
P(isgreater, (1., 2.));
|
|
|
|
|
P(isgreaterequal, (1., 2.));
|
|
|
|
|
P(isless, (1., 2.));
|
|
|
|
|
P(islessequal, (1., 2.));
|
|
|
|
|
P(islessgreater, (1., 2.));
|
|
|
|
|
P(isunordered, (1., 2.));
|
2008-09-04 05:17:21 +08:00
|
|
|
|
[Modules] Implement __builtin_isinf_sign in Clang.
Somehow, we never managed to implement this fully. We could constant
fold it like crazy, including constant folding complex arguments, etc.
But if you actually needed to generate code for it, error.
I've implemented it using the somewhat obvious lowering. Happy for
suggestions on a more clever way to lower this.
Now, what you might ask does this have to do with modules? Fun story. So
it turns out that libstdc++ actually uses __builtin_isinf_sign to
implement std::isinf when in C++98 mode, but only inside of a template.
So if we're lucky, and we never instantiate that, everything is good.
But once we try to instantiate that template function, we need this
builtin. All of my customers at least are using C++11 and so they never
hit this code path.
But what does that have to do with modules? Fun story. So it turns out
that with modules we actually observe a bunch of bugs in libstdc++ where
their <cmath> header clobbers things exposed by <math.h>. To fix these,
we have to provide global function definitions to replace the macros
that C99 would have used. And it turns out that ::isinf needs to be
implemented using the exact semantics used by the C++98 variant of
std::isinf. And so I started to fix this bug in libstdc++ and ceased to
be able to compile libstdc++ with Clang.
The yaks are legion.
llvm-svn: 232778
2015-03-20 06:39:51 +08:00
|
|
|
P(isinf, (1.));
|
|
|
|
|
P(isinf_sign, (1.));
|
2009-09-01 12:19:44 +08:00
|
|
|
P(isnan, (1.));
|
|
|
|
|
|
2008-09-04 05:17:21 +08:00
|
|
|
// Bitwise & Numeric Functions
|
|
|
|
|
|
2008-10-05 14:34:45 +08:00
|
|
|
P(abs, (N));
|
|
|
|
|
|
2008-09-04 05:17:21 +08:00
|
|
|
P(clz, (N));
|
|
|
|
|
P(clzl, (N));
|
|
|
|
|
P(clzll, (N));
|
|
|
|
|
P(ctz, (N));
|
|
|
|
|
P(ctzl, (N));
|
|
|
|
|
P(ctzll, (N));
|
|
|
|
|
P(ffs, (N));
|
|
|
|
|
P(ffsl, (N));
|
|
|
|
|
P(ffsll, (N));
|
|
|
|
|
P(parity, (N));
|
|
|
|
|
P(parityl, (N));
|
|
|
|
|
P(parityll, (N));
|
|
|
|
|
P(popcount, (N));
|
|
|
|
|
P(popcountl, (N));
|
|
|
|
|
P(popcountll, (N));
|
|
|
|
|
Q(powi, (1.2f, N));
|
|
|
|
|
Q(powif, (1.2f, N));
|
|
|
|
|
Q(powil, (1.2f, N));
|
|
|
|
|
|
2009-02-20 14:36:40 +08:00
|
|
|
// Lib functions
|
2008-09-04 05:17:21 +08:00
|
|
|
int a, b, n = random(); // Avoid optimizing out.
|
|
|
|
|
char s0[10], s1[] = "Hello";
|
2009-02-20 14:36:40 +08:00
|
|
|
V(strcat, (s0, s1));
|
2009-04-10 00:42:50 +08:00
|
|
|
V(strcmp, (s0, s1));
|
2009-02-20 14:36:40 +08:00
|
|
|
V(strncat, (s0, s1, n));
|
|
|
|
|
V(strchr, (s0, s1[0]));
|
|
|
|
|
V(strrchr, (s0, s1[0]));
|
|
|
|
|
V(strcpy, (s0, s1));
|
|
|
|
|
V(strncpy, (s0, s1, n));
|
|
|
|
|
|
|
|
|
|
// Object size checking
|
2008-09-04 05:17:21 +08:00
|
|
|
V(__memset_chk, (s0, 0, sizeof s0, n));
|
|
|
|
|
V(__memcpy_chk, (s0, s1, sizeof s0, n));
|
|
|
|
|
V(__memmove_chk, (s0, s1, sizeof s0, n));
|
|
|
|
|
V(__mempcpy_chk, (s0, s1, sizeof s0, n));
|
|
|
|
|
V(__strncpy_chk, (s0, s1, sizeof s0, n));
|
|
|
|
|
V(__strcpy_chk, (s0, s1, n));
|
|
|
|
|
s0[0] = 0;
|
|
|
|
|
V(__strcat_chk, (s0, s1, n));
|
|
|
|
|
P(object_size, (s0, 0));
|
|
|
|
|
P(object_size, (s0, 1));
|
|
|
|
|
P(object_size, (s0, 2));
|
|
|
|
|
P(object_size, (s0, 3));
|
|
|
|
|
|
|
|
|
|
// Whatever
|
|
|
|
|
|
2012-10-06 22:42:22 +08:00
|
|
|
P(bswap16, (N));
|
2008-09-04 05:17:21 +08:00
|
|
|
P(bswap32, (N));
|
|
|
|
|
P(bswap64, (N));
|
2016-02-04 01:49:38 +08:00
|
|
|
|
2016-03-24 06:14:43 +08:00
|
|
|
// CHECK: @llvm.bitreverse.i8
|
2016-02-04 01:49:38 +08:00
|
|
|
// CHECK: @llvm.bitreverse.i16
|
|
|
|
|
// CHECK: @llvm.bitreverse.i32
|
|
|
|
|
// CHECK: @llvm.bitreverse.i64
|
2016-03-24 06:14:43 +08:00
|
|
|
P(bitreverse8, (N));
|
2016-02-04 01:49:38 +08:00
|
|
|
P(bitreverse16, (N));
|
|
|
|
|
P(bitreverse32, (N));
|
|
|
|
|
P(bitreverse64, (N));
|
|
|
|
|
|
2008-09-04 05:17:21 +08:00
|
|
|
// FIXME
|
|
|
|
|
// V(clear_cache, (&N, &N+1));
|
|
|
|
|
V(trap, ());
|
2010-02-28 21:00:19 +08:00
|
|
|
R(extract_return_addr, (&N));
|
2010-03-06 10:17:52 +08:00
|
|
|
P(signbit, (1.0));
|
2008-09-04 05:17:21 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-23 05:56:56 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
void foo() {
|
|
|
|
|
__builtin_strcat(0, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-15 14:47:53 +08:00
|
|
|
// CHECK-LABEL: define void @bar(
|
2010-02-28 21:00:19 +08:00
|
|
|
void bar() {
|
|
|
|
|
float f;
|
|
|
|
|
double d;
|
|
|
|
|
long double ld;
|
|
|
|
|
|
|
|
|
|
// LLVM's hex representation of float constants is really unfortunate;
|
|
|
|
|
// basically it does a float-to-double "conversion" and then prints the
|
2011-04-15 13:22:18 +08:00
|
|
|
// hex form of that. That gives us weird artifacts like exponents
|
2010-02-28 21:00:19 +08:00
|
|
|
// that aren't numerically similar to the original exponent and
|
|
|
|
|
// significand bit-patterns that are offset by three bits (because
|
|
|
|
|
// the exponent was expanded from 8 bits to 11).
|
|
|
|
|
//
|
|
|
|
|
// 0xAE98 == 1010111010011000
|
|
|
|
|
// 0x15D3 == 1010111010011
|
|
|
|
|
|
|
|
|
|
f = __builtin_huge_valf(); // CHECK: float 0x7FF0000000000000
|
|
|
|
|
d = __builtin_huge_val(); // CHECK: double 0x7FF0000000000000
|
|
|
|
|
ld = __builtin_huge_vall(); // CHECK: x86_fp80 0xK7FFF8000000000000000
|
|
|
|
|
f = __builtin_nanf(""); // CHECK: float 0x7FF8000000000000
|
|
|
|
|
d = __builtin_nan(""); // CHECK: double 0x7FF8000000000000
|
|
|
|
|
ld = __builtin_nanl(""); // CHECK: x86_fp80 0xK7FFFC000000000000000
|
|
|
|
|
f = __builtin_nanf("0xAE98"); // CHECK: float 0x7FF815D300000000
|
|
|
|
|
d = __builtin_nan("0xAE98"); // CHECK: double 0x7FF800000000AE98
|
|
|
|
|
ld = __builtin_nanl("0xAE98"); // CHECK: x86_fp80 0xK7FFFC00000000000AE98
|
|
|
|
|
f = __builtin_nansf(""); // CHECK: float 0x7FF4000000000000
|
|
|
|
|
d = __builtin_nans(""); // CHECK: double 0x7FF4000000000000
|
|
|
|
|
ld = __builtin_nansl(""); // CHECK: x86_fp80 0xK7FFFA000000000000000
|
|
|
|
|
f = __builtin_nansf("0xAE98"); // CHECK: float 0x7FF015D300000000
|
|
|
|
|
d = __builtin_nans("0xAE98"); // CHECK: double 0x7FF000000000AE98
|
|
|
|
|
ld = __builtin_nansl("0xAE98");// CHECK: x86_fp80 0xK7FFF800000000000AE98
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
// CHECK: }
|
2010-05-06 13:50:07 +08:00
|
|
|
|
|
|
|
|
|
2013-08-15 14:47:53 +08:00
|
|
|
// CHECK-LABEL: define void @test_float_builtins
|
2010-05-06 14:04:13 +08:00
|
|
|
void test_float_builtins(float F, double D, long double LD) {
|
2010-05-06 13:50:07 +08:00
|
|
|
volatile int res;
|
|
|
|
|
res = __builtin_isinf(F);
|
2014-09-03 23:24:29 +08:00
|
|
|
// CHECK: call float @llvm.fabs.f32(float
|
2010-05-06 13:50:07 +08:00
|
|
|
// CHECK: fcmp oeq float {{.*}}, 0x7FF0000000000000
|
|
|
|
|
|
|
|
|
|
res = __builtin_isinf(D);
|
2014-09-03 23:24:29 +08:00
|
|
|
// CHECK: call double @llvm.fabs.f64(double
|
2010-05-06 13:50:07 +08:00
|
|
|
// CHECK: fcmp oeq double {{.*}}, 0x7FF0000000000000
|
[Modules] Implement __builtin_isinf_sign in Clang.
Somehow, we never managed to implement this fully. We could constant
fold it like crazy, including constant folding complex arguments, etc.
But if you actually needed to generate code for it, error.
I've implemented it using the somewhat obvious lowering. Happy for
suggestions on a more clever way to lower this.
Now, what you might ask does this have to do with modules? Fun story. So
it turns out that libstdc++ actually uses __builtin_isinf_sign to
implement std::isinf when in C++98 mode, but only inside of a template.
So if we're lucky, and we never instantiate that, everything is good.
But once we try to instantiate that template function, we need this
builtin. All of my customers at least are using C++11 and so they never
hit this code path.
But what does that have to do with modules? Fun story. So it turns out
that with modules we actually observe a bunch of bugs in libstdc++ where
their <cmath> header clobbers things exposed by <math.h>. To fix these,
we have to provide global function definitions to replace the macros
that C99 would have used. And it turns out that ::isinf needs to be
implemented using the exact semantics used by the C++98 variant of
std::isinf. And so I started to fix this bug in libstdc++ and ceased to
be able to compile libstdc++ with Clang.
The yaks are legion.
llvm-svn: 232778
2015-03-20 06:39:51 +08:00
|
|
|
|
2010-05-06 13:50:07 +08:00
|
|
|
res = __builtin_isinf(LD);
|
2014-09-03 23:24:29 +08:00
|
|
|
// CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80
|
2010-05-06 13:50:07 +08:00
|
|
|
// CHECK: fcmp oeq x86_fp80 {{.*}}, 0xK7FFF8000000000000000
|
[Modules] Implement __builtin_isinf_sign in Clang.
Somehow, we never managed to implement this fully. We could constant
fold it like crazy, including constant folding complex arguments, etc.
But if you actually needed to generate code for it, error.
I've implemented it using the somewhat obvious lowering. Happy for
suggestions on a more clever way to lower this.
Now, what you might ask does this have to do with modules? Fun story. So
it turns out that libstdc++ actually uses __builtin_isinf_sign to
implement std::isinf when in C++98 mode, but only inside of a template.
So if we're lucky, and we never instantiate that, everything is good.
But once we try to instantiate that template function, we need this
builtin. All of my customers at least are using C++11 and so they never
hit this code path.
But what does that have to do with modules? Fun story. So it turns out
that with modules we actually observe a bunch of bugs in libstdc++ where
their <cmath> header clobbers things exposed by <math.h>. To fix these,
we have to provide global function definitions to replace the macros
that C99 would have used. And it turns out that ::isinf needs to be
implemented using the exact semantics used by the C++98 variant of
std::isinf. And so I started to fix this bug in libstdc++ and ceased to
be able to compile libstdc++ with Clang.
The yaks are legion.
llvm-svn: 232778
2015-03-20 06:39:51 +08:00
|
|
|
|
|
|
|
|
res = __builtin_isinf_sign(F);
|
|
|
|
|
// CHECK: %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]])
|
|
|
|
|
// CHECK: %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000
|
|
|
|
|
// CHECK: %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32
|
|
|
|
|
// CHECK: %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0
|
|
|
|
|
// CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
|
|
|
|
|
// CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0
|
|
|
|
|
|
|
|
|
|
res = __builtin_isinf_sign(D);
|
|
|
|
|
// CHECK: %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]])
|
|
|
|
|
// CHECK: %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000
|
|
|
|
|
// CHECK: %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64
|
|
|
|
|
// CHECK: %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0
|
|
|
|
|
// CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
|
|
|
|
|
// CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0
|
|
|
|
|
|
|
|
|
|
res = __builtin_isinf_sign(LD);
|
|
|
|
|
// CHECK: %[[ABS:.*]] = call x86_fp80 @llvm.fabs.f80(x86_fp80 %[[ARG:.*]])
|
|
|
|
|
// CHECK: %[[ISINF:.*]] = fcmp oeq x86_fp80 %[[ABS]], 0xK7FFF8000000000000000
|
|
|
|
|
// CHECK: %[[BITCAST:.*]] = bitcast x86_fp80 %[[ARG]] to i80
|
|
|
|
|
// CHECK: %[[ISNEG:.*]] = icmp slt i80 %[[BITCAST]], 0
|
|
|
|
|
// CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
|
|
|
|
|
// CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0
|
|
|
|
|
|
2010-05-06 14:04:13 +08:00
|
|
|
res = __builtin_isfinite(F);
|
2014-09-03 23:24:29 +08:00
|
|
|
// CHECK: call float @llvm.fabs.f32(float
|
2016-04-07 22:29:05 +08:00
|
|
|
// CHECK: fcmp one float {{.*}}, 0x7FF0000000000000
|
2010-05-19 19:24:26 +08:00
|
|
|
|
2016-09-15 01:34:14 +08:00
|
|
|
res = finite(D);
|
|
|
|
|
// CHECK: call double @llvm.fabs.f64(double
|
|
|
|
|
// CHECK: fcmp one double {{.*}}, 0x7FF0000000000000
|
|
|
|
|
|
2010-05-19 19:24:26 +08:00
|
|
|
res = __builtin_isnormal(F);
|
|
|
|
|
// CHECK: fcmp oeq float
|
2014-09-03 23:24:29 +08:00
|
|
|
// CHECK: call float @llvm.fabs.f32(float
|
2010-05-19 19:24:26 +08:00
|
|
|
// CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000
|
|
|
|
|
// CHECK: fcmp uge float {{.*}}, 0x3810000000000000
|
|
|
|
|
// CHECK: and i1
|
|
|
|
|
// CHECK: and i1
|
2010-05-06 13:50:07 +08:00
|
|
|
}
|
|
|
|
|
|
2014-09-26 09:19:41 +08:00
|
|
|
// CHECK-LABEL: define void @test_float_builtin_ops
|
|
|
|
|
void test_float_builtin_ops(float F, double D, long double LD) {
|
|
|
|
|
volatile float resf;
|
|
|
|
|
volatile double resd;
|
|
|
|
|
volatile long double resld;
|
|
|
|
|
|
|
|
|
|
resf = __builtin_fmodf(F,F);
|
|
|
|
|
// CHECK: frem float
|
|
|
|
|
|
|
|
|
|
resd = __builtin_fmod(D,D);
|
|
|
|
|
// CHECK: frem double
|
|
|
|
|
|
|
|
|
|
resld = __builtin_fmodl(LD,LD);
|
|
|
|
|
// CHECK: frem x86_fp80
|
2014-11-04 07:52:09 +08:00
|
|
|
|
|
|
|
|
resf = __builtin_fabsf(F);
|
|
|
|
|
resd = __builtin_fabs(D);
|
|
|
|
|
resld = __builtin_fabsl(LD);
|
|
|
|
|
// CHECK: call float @llvm.fabs.f32(float
|
|
|
|
|
// CHECK: call double @llvm.fabs.f64(double
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80
|
2016-02-27 17:06:18 +08:00
|
|
|
|
|
|
|
|
resf = __builtin_canonicalizef(F);
|
|
|
|
|
resd = __builtin_canonicalize(D);
|
|
|
|
|
resld = __builtin_canonicalizel(LD);
|
|
|
|
|
// CHECK: call float @llvm.canonicalize.f32(float
|
|
|
|
|
// CHECK: call double @llvm.canonicalize.f64(double
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.canonicalize.f80(x86_fp80
|
2016-07-02 01:38:14 +08:00
|
|
|
|
|
|
|
|
resf = __builtin_fminf(F, F);
|
|
|
|
|
// CHECK: call float @llvm.minnum.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_fmin(D, D);
|
|
|
|
|
// CHECK: call double @llvm.minnum.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_fminl(LD, LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.minnum.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_fmaxf(F, F);
|
|
|
|
|
// CHECK: call float @llvm.maxnum.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_fmax(D, D);
|
|
|
|
|
// CHECK: call double @llvm.maxnum.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_fmaxl(LD, LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.maxnum.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_fabsf(F);
|
|
|
|
|
// CHECK: call float @llvm.fabs.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_fabs(D);
|
|
|
|
|
// CHECK: call double @llvm.fabs.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_fabsl(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.fabs.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_copysignf(F, F);
|
|
|
|
|
// CHECK: call float @llvm.copysign.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_copysign(D, D);
|
|
|
|
|
// CHECK: call double @llvm.copysign.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_copysignl(LD, LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.copysign.f80
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
resf = __builtin_ceilf(F);
|
|
|
|
|
// CHECK: call float @llvm.ceil.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_ceil(D);
|
|
|
|
|
// CHECK: call double @llvm.ceil.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_ceill(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.ceil.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_floorf(F);
|
|
|
|
|
// CHECK: call float @llvm.floor.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_floor(D);
|
|
|
|
|
// CHECK: call double @llvm.floor.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_floorl(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.floor.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_truncf(F);
|
|
|
|
|
// CHECK: call float @llvm.trunc.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_trunc(D);
|
|
|
|
|
// CHECK: call double @llvm.trunc.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_truncl(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.trunc.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_rintf(F);
|
|
|
|
|
// CHECK: call float @llvm.rint.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_rint(D);
|
|
|
|
|
// CHECK: call double @llvm.rint.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_rintl(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.rint.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_nearbyintf(F);
|
|
|
|
|
// CHECK: call float @llvm.nearbyint.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_nearbyint(D);
|
|
|
|
|
// CHECK: call double @llvm.nearbyint.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_nearbyintl(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.nearbyint.f80
|
|
|
|
|
|
|
|
|
|
resf = __builtin_roundf(F);
|
|
|
|
|
// CHECK: call float @llvm.round.f32
|
|
|
|
|
|
|
|
|
|
resd = __builtin_round(D);
|
|
|
|
|
// CHECK: call double @llvm.round.f64
|
|
|
|
|
|
|
|
|
|
resld = __builtin_roundl(LD);
|
|
|
|
|
// CHECK: call x86_fp80 @llvm.round.f80
|
|
|
|
|
|
2014-09-26 09:19:41 +08:00
|
|
|
}
|
|
|
|
|
|
2016-10-25 07:38:24 +08:00
|
|
|
// __builtin_longjmp isn't supported on all platforms, so only test it on X86.
|
|
|
|
|
#ifdef __x86_64__
|
|
|
|
|
|
2013-08-15 14:47:53 +08:00
|
|
|
// CHECK-LABEL: define void @test_builtin_longjmp
|
2010-05-28 02:47:06 +08:00
|
|
|
void test_builtin_longjmp(void **buffer) {
|
|
|
|
|
// CHECK: [[BITCAST:%.*]] = bitcast
|
|
|
|
|
// CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]])
|
|
|
|
|
__builtin_longjmp(buffer, 1);
|
|
|
|
|
// CHECK-NEXT: unreachable
|
|
|
|
|
}
|
2012-08-06 06:03:08 +08:00
|
|
|
|
2016-10-25 07:38:24 +08:00
|
|
|
#endif
|
|
|
|
|
|
2013-08-15 14:47:53 +08:00
|
|
|
// CHECK-LABEL: define i64 @test_builtin_readcyclecounter
|
2012-08-06 06:03:08 +08:00
|
|
|
long long test_builtin_readcyclecounter() {
|
|
|
|
|
// CHECK: call i64 @llvm.readcyclecounter()
|
|
|
|
|
return __builtin_readcyclecounter();
|
|
|
|
|
}
|
2016-10-25 04:39:34 +08:00
|
|
|
|
2016-10-25 05:22:01 +08:00
|
|
|
// Behavior of __builtin_os_log differs between platforms, so only test on X86
|
|
|
|
|
#ifdef __x86_64__
|
|
|
|
|
|
2016-10-25 04:39:34 +08:00
|
|
|
// CHECK-LABEL: define void @test_builtin_os_log
|
|
|
|
|
// CHECK: (i8* [[BUF:%.*]], i32 [[I:%.*]], i8* [[DATA:%.*]])
|
|
|
|
|
void test_builtin_os_log(void *buf, int i, const char *data) {
|
|
|
|
|
volatile int len;
|
|
|
|
|
// CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8
|
|
|
|
|
// CHECK: store i32 [[I]], i32* [[I_ADDR:%.*]], align 4
|
|
|
|
|
// CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8
|
|
|
|
|
|
|
|
|
|
// CHECK: store volatile i32 34
|
|
|
|
|
len = __builtin_os_log_format_buffer_size("%d %{public}s %{private}.16P", i, data, data);
|
|
|
|
|
|
|
|
|
|
// CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]]
|
|
|
|
|
// CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0
|
|
|
|
|
// CHECK: store i8 3, i8* [[SUMMARY]]
|
|
|
|
|
// CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1
|
|
|
|
|
// CHECK: store i8 4, i8* [[NUM_ARGS]]
|
|
|
|
|
//
|
|
|
|
|
// CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2
|
|
|
|
|
// CHECK: store i8 0, i8* [[ARG1_DESC]]
|
|
|
|
|
// CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3
|
|
|
|
|
// CHECK: store i8 4, i8* [[ARG1_SIZE]]
|
|
|
|
|
// CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4
|
|
|
|
|
// CHECK: [[ARG1_INT:%.*]] = bitcast i8* [[ARG1]] to i32*
|
|
|
|
|
// CHECK: [[I2:%.*]] = load i32, i32* [[I_ADDR]]
|
|
|
|
|
// CHECK: store i32 [[I2]], i32* [[ARG1_INT]]
|
|
|
|
|
|
|
|
|
|
// CHECK: [[ARG2_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 8
|
|
|
|
|
// CHECK: store i8 34, i8* [[ARG2_DESC]]
|
|
|
|
|
// CHECK: [[ARG2_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 9
|
|
|
|
|
// CHECK: store i8 8, i8* [[ARG2_SIZE]]
|
|
|
|
|
// CHECK: [[ARG2:%.*]] = getelementptr i8, i8* [[BUF2]], i64 10
|
|
|
|
|
// CHECK: [[ARG2_PTR:%.*]] = bitcast i8* [[ARG2]] to i8**
|
|
|
|
|
// CHECK: [[DATA2:%.*]] = load i8*, i8** [[DATA_ADDR]]
|
|
|
|
|
// CHECK: store i8* [[DATA2]], i8** [[ARG2_PTR]]
|
|
|
|
|
|
|
|
|
|
// CHECK: [[ARG3_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 18
|
|
|
|
|
// CHECK: store i8 17, i8* [[ARG3_DESC]]
|
|
|
|
|
// CHECK: [[ARG3_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 19
|
|
|
|
|
// CHECK: store i8 4, i8* [[ARG3_SIZE]]
|
|
|
|
|
// CHECK: [[ARG3:%.*]] = getelementptr i8, i8* [[BUF2]], i64 20
|
|
|
|
|
// CHECK: [[ARG3_INT:%.*]] = bitcast i8* [[ARG3]] to i32*
|
|
|
|
|
// CHECK: store i32 16, i32* [[ARG3_INT]]
|
|
|
|
|
|
|
|
|
|
// CHECK: [[ARG4_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 24
|
|
|
|
|
// CHECK: store i8 49, i8* [[ARG4_DESC]]
|
|
|
|
|
// CHECK: [[ARG4_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 25
|
|
|
|
|
// CHECK: store i8 8, i8* [[ARG4_SIZE]]
|
|
|
|
|
// CHECK: [[ARG4:%.*]] = getelementptr i8, i8* [[BUF2]], i64 26
|
|
|
|
|
// CHECK: [[ARG4_PTR:%.*]] = bitcast i8* [[ARG4]] to i8**
|
|
|
|
|
// CHECK: [[DATA3:%.*]] = load i8*, i8** [[DATA_ADDR]]
|
|
|
|
|
// CHECK: store i8* [[DATA3]], i8** [[ARG4_PTR]]
|
|
|
|
|
|
|
|
|
|
__builtin_os_log_format(buf, "%d %{public}s %{private}.16P", i, data, data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// CHECK-LABEL: define void @test_builtin_os_log_errno
|
|
|
|
|
// CHECK: (i8* [[BUF:%.*]], i8* [[DATA:%.*]])
|
|
|
|
|
void test_builtin_os_log_errno(void *buf, const char *data) {
|
|
|
|
|
volatile int len;
|
|
|
|
|
// CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8
|
|
|
|
|
// CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8
|
|
|
|
|
|
|
|
|
|
// CHECK: store volatile i32 2
|
|
|
|
|
len = __builtin_os_log_format_buffer_size("%S");
|
|
|
|
|
|
|
|
|
|
// CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]]
|
|
|
|
|
// CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0
|
|
|
|
|
// CHECK: store i8 2, i8* [[SUMMARY]]
|
|
|
|
|
// CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1
|
|
|
|
|
// CHECK: store i8 1, i8* [[NUM_ARGS]]
|
|
|
|
|
|
|
|
|
|
// CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2
|
|
|
|
|
// CHECK: store i8 96, i8* [[ARG1_DESC]]
|
|
|
|
|
// CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3
|
|
|
|
|
// CHECK: store i8 0, i8* [[ARG1_SIZE]]
|
|
|
|
|
// CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4
|
|
|
|
|
// CHECK: [[ARG1_INT:%.*]] = bitcast i8* [[ARG1]] to i32*
|
|
|
|
|
// CHECK: store i32 0, i32* [[ARG1_INT]]
|
|
|
|
|
|
|
|
|
|
__builtin_os_log_format(buf, "%m");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// CHECK-LABEL: define void @test_builtin_os_log_wide
|
|
|
|
|
// CHECK: (i8* [[BUF:%.*]], i8* [[DATA:%.*]], i32* [[STR:%.*]])
|
|
|
|
|
typedef int wchar_t;
|
|
|
|
|
void test_builtin_os_log_wide(void *buf, const char *data, wchar_t *str) {
|
|
|
|
|
volatile int len;
|
|
|
|
|
// CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8
|
|
|
|
|
// CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8
|
|
|
|
|
// CHECK: store i32* [[STR]], i32** [[STR_ADDR:%.*]],
|
|
|
|
|
|
|
|
|
|
// CHECK: store volatile i32 12
|
|
|
|
|
len = __builtin_os_log_format_buffer_size("%S", str);
|
|
|
|
|
|
|
|
|
|
// CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]]
|
|
|
|
|
// CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0
|
|
|
|
|
// CHECK: store i8 2, i8* [[SUMMARY]]
|
|
|
|
|
// CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1
|
|
|
|
|
// CHECK: store i8 1, i8* [[NUM_ARGS]]
|
|
|
|
|
|
|
|
|
|
// CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2
|
|
|
|
|
// CHECK: store i8 80, i8* [[ARG1_DESC]]
|
|
|
|
|
// CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3
|
|
|
|
|
// CHECK: store i8 8, i8* [[ARG1_SIZE]]
|
|
|
|
|
// CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4
|
|
|
|
|
// CHECK: [[ARG1_PTR:%.*]] = bitcast i8* [[ARG1]] to i32**
|
|
|
|
|
// CHECK: [[STR2:%.*]] = load i32*, i32** [[STR_ADDR]]
|
|
|
|
|
// CHECK: store i32* [[STR2]], i32** [[ARG1_PTR]]
|
|
|
|
|
|
|
|
|
|
__builtin_os_log_format(buf, "%S", str);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// CHECK-LABEL: define void @test_builtin_os_log_percent
|
2016-10-25 08:48:48 +08:00
|
|
|
// CHECK: (i8* [[BUF:%.*]], i8* [[DATA1:%.*]], i8* [[DATA2:%.*]])
|
2016-10-25 04:39:34 +08:00
|
|
|
// Check that the %% which does not consume any argument is correctly handled
|
2016-10-25 08:48:48 +08:00
|
|
|
void test_builtin_os_log_percent(void *buf, const char *data1, const char *data2) {
|
2016-10-25 04:39:34 +08:00
|
|
|
volatile int len;
|
|
|
|
|
// CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8
|
2016-10-25 08:48:48 +08:00
|
|
|
// CHECK: store i8* [[DATA1]], i8** [[DATA1_ADDR:%.*]], align 8
|
|
|
|
|
// CHECK: store i8* [[DATA2]], i8** [[DATA2_ADDR:%.*]], align 8
|
|
|
|
|
// CHECK: store volatile i32 22
|
|
|
|
|
len = __builtin_os_log_format_buffer_size("%s %% %s", data1, data2);
|
2016-10-25 04:39:34 +08:00
|
|
|
|
|
|
|
|
// CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]]
|
|
|
|
|
// CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0
|
|
|
|
|
// CHECK: store i8 2, i8* [[SUMMARY]]
|
|
|
|
|
// CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1
|
2016-10-25 08:48:48 +08:00
|
|
|
// CHECK: store i8 2, i8* [[NUM_ARGS]]
|
2016-10-25 04:39:34 +08:00
|
|
|
//
|
|
|
|
|
// CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2
|
|
|
|
|
// CHECK: store i8 32, i8* [[ARG1_DESC]]
|
|
|
|
|
// CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3
|
|
|
|
|
// CHECK: store i8 8, i8* [[ARG1_SIZE]]
|
|
|
|
|
// CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4
|
|
|
|
|
// CHECK: [[ARG1_PTR:%.*]] = bitcast i8* [[ARG1]] to i8**
|
2016-10-25 08:48:48 +08:00
|
|
|
// CHECK: [[DATA1:%.*]] = load i8*, i8** [[DATA1_ADDR]]
|
|
|
|
|
// CHECK: store i8* [[DATA1]], i8** [[ARG1_PTR]]
|
|
|
|
|
//
|
|
|
|
|
// CHECK: [[ARG2_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 12
|
|
|
|
|
// CHECK: store i8 32, i8* [[ARG2_DESC]]
|
|
|
|
|
// CHECK: [[ARG2_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 13
|
|
|
|
|
// CHECK: store i8 8, i8* [[ARG2_SIZE]]
|
|
|
|
|
// CHECK: [[ARG2:%.*]] = getelementptr i8, i8* [[BUF2]], i64 14
|
|
|
|
|
// CHECK: [[ARG2_PTR:%.*]] = bitcast i8* [[ARG2]] to i8**
|
|
|
|
|
// CHECK: [[DATA2:%.*]] = load i8*, i8** [[DATA2_ADDR]]
|
|
|
|
|
// CHECK: store i8* [[DATA2]], i8** [[ARG2_PTR]]
|
|
|
|
|
__builtin_os_log_format(buf, "%s %% %s", data1, data2);
|
2016-10-25 04:39:34 +08:00
|
|
|
}
|
2016-10-25 05:22:01 +08:00
|
|
|
|
|
|
|
|
#endif
|