maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGen/complex-libcalls.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

206 lines
12 KiB
C
Raw Normal View History

[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -w -S -o - -emit-llvm %s | FileCheck %s -check-prefix=NO__ERRNO
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -w -S -o - -emit-llvm -fmath-errno %s | FileCheck %s -check-prefix=HAS_ERRNO
// Test attributes and builtin codegen of complex library calls.
void foo(float f) {
cabs(f); cabsf(f); cabsl(f);
// NO__ERRNO: declare double @cabs(double, double) [[READNONE:#[0-9]+]]
// NO__ERRNO: declare float @cabsf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare x86_fp80 @cabsl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE:#[0-9]+]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare double @cabs(double, double) [[NOT_READNONE:#[0-9]+]]
// HAS_ERRNO: declare float @cabsf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare x86_fp80 @cabsl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
cacos(f); cacosf(f); cacosl(f);
// NO__ERRNO: declare { double, double } @cacos(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @cacosf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @cacosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @cacos(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @cacosf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @cacosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
cacosh(f); cacoshf(f); cacoshl(f);
// NO__ERRNO: declare { double, double } @cacosh(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @cacoshf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @cacoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @cacosh(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @cacoshf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @cacoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
carg(f); cargf(f); cargl(f);
// NO__ERRNO: declare double @carg(double, double) [[READNONE]]
// NO__ERRNO: declare float @cargf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare x86_fp80 @cargl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare double @carg(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare float @cargf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare x86_fp80 @cargl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
casin(f); casinf(f); casinl(f);
// NO__ERRNO: declare { double, double } @casin(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @casinf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @casinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @casin(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @casinf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @casinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
casinh(f); casinhf(f); casinhl(f);
// NO__ERRNO: declare { double, double } @casinh(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @casinhf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @casinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @casinh(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @casinhf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @casinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
catan(f); catanf(f); catanl(f);
// NO__ERRNO: declare { double, double } @catan(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @catanf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @catanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @catan(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @catanf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @catanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
catanh(f); catanhf(f); catanhl(f);
// NO__ERRNO: declare { double, double } @catanh(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @catanhf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @catanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @catanh(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @catanhf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @catanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
ccos(f); ccosf(f); ccosl(f);
// NO__ERRNO: declare { double, double } @ccos(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @ccosf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @ccosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @ccos(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @ccosf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @ccosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
ccosh(f); ccoshf(f); ccoshl(f);
// NO__ERRNO: declare { double, double } @ccosh(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @ccoshf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @ccoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @ccosh(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @ccoshf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @ccoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
cexp(f); cexpf(f); cexpl(f);
// NO__ERRNO: declare { double, double } @cexp(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @cexpf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @cexp(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @cexpf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
cimag(f); cimagf(f); cimagl(f);
// NO__ERRNO-NOT: .cimag
// NO__ERRNO-NOT: @cimag
// HAS_ERRNO-NOT: .cimag
// HAS_ERRNO-NOT: @cimag
conj(f); conjf(f); conjl(f);
[CodeGen] Emit conj/conjf/confjl libcalls as fneg instructions if possible. We already recognize the __builtin versions of these, might as well recognize the libcall version. Differential Revision: https://reviews.llvm.org/D72028
2020-01-01 02:33:30 +08:00
// NO__ERRNO-NOT: .conj
// NO__ERRNO-NOT: @conj
// HAS_ERRNO-NOT: .conj
// HAS_ERRNO-NOT: @conj
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
clog(f); clogf(f); clogl(f);
// NO__ERRNO: declare { double, double } @clog(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @clogf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @clogl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @clog(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @clogf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @clogl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
cproj(f); cprojf(f); cprojl(f);
// NO__ERRNO: declare { double, double } @cproj(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @cprojf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @cprojl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] Emit conj/conjf/confjl libcalls as fneg instructions if possible. We already recognize the __builtin versions of these, might as well recognize the libcall version. Differential Revision: https://reviews.llvm.org/D72028
2020-01-01 02:33:30 +08:00
// HAS_ERRNO: declare { double, double } @cproj(double, double) [[READNONE:#[0-9]+]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
// HAS_ERRNO: declare <2 x float> @cprojf(<2 x float>) [[READNONE]]
[clang] functions with the 'const' or 'pure' attribute must always return. As described in * https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-pure-function-attribute * https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-const-function-attribute An `__attribute__((pure))` function must always return, as well as an `__attribute__((const))` function. Reviewed By: jdoerfert Differential Revision: https://reviews.llvm.org/D96960
2021-02-19 00:29:46 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @cprojl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[WILLRETURN_NOT_READNONE:#[0-9]+]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
cpow(f,f); cpowf(f,f); cpowl(f,f);
// NO__ERRNO: declare { double, double } @cpow(double, double, double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @cpowf(<2 x float>, <2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @cpow(double, double, double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @cpowf(<2 x float>, <2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
creal(f); crealf(f); creall(f);
// NO__ERRNO-NOT: .creal
// NO__ERRNO-NOT: @creal
// HAS_ERRNO-NOT: .creal
// HAS_ERRNO-NOT: @creal
csin(f); csinf(f); csinl(f);
// NO__ERRNO: declare { double, double } @csin(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @csinf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @csinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @csin(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @csinf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @csinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
csinh(f); csinhf(f); csinhl(f);
// NO__ERRNO: declare { double, double } @csinh(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @csinhf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @csinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @csinh(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @csinhf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @csinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
csqrt(f); csqrtf(f); csqrtl(f);
// NO__ERRNO: declare { double, double } @csqrt(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @csqrtf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @csqrt(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @csqrtf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
ctan(f); ctanf(f); ctanl(f);
// NO__ERRNO: declare { double, double } @ctan(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @ctanf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @ctanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @ctan(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @ctanf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @ctanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
ctanh(f); ctanhf(f); ctanhl(f);
// NO__ERRNO: declare { double, double } @ctanh(double, double) [[READNONE]]
// NO__ERRNO: declare <2 x float> @ctanhf(<2 x float>) [[READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// NO__ERRNO: declare { x86_fp80, x86_fp80 } @ctanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: declare { double, double } @ctanh(double, double) [[NOT_READNONE]]
// HAS_ERRNO: declare <2 x float> @ctanhf(<2 x float>) [[NOT_READNONE]]
LLVM IR: Generate new-style byval-with-Type from Clang LLVM IR recently added a Type parameter to the byval Attribute, so that when pointers become opaque and no longer have an element type the information will still be present in IR. For now the Type parameter is optional (which is why Clang didn't need this change at the time), but it will become mandatory soon. llvm-svn: 362652
2019-06-06 05:12:14 +08:00
// HAS_ERRNO: declare { x86_fp80, x86_fp80 } @ctanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16) [[NOT_READNONE]]
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
};
// NO__ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
[clang][codegen] Annotate `correctly-rounded-divide-sqrt-fp-math` fn-attr for OpenCL only. - `-cl-fp32-correctly-rounded-divide-sqrt` is an OpenCL-specific option and `correctly-rounded-divide-sqrt-fp-math` should be added for OpenCL at most. Differential revision: https://reviews.llvm.org/D88303
2020-09-28 22:51:17 +08:00
// NO__ERRNO: attributes [[NOT_READNONE]] = { nounwind {{.*}} }
[CodeGen] split math and complex tests into separate files; NFCI The files are already large, and we may need to add even more RUNs to distinguish differences based on OS, environment, or other platform things. llvm-svn: 317583
2017-11-07 23:13:22 +08:00
[clang][codegen] Annotate `correctly-rounded-divide-sqrt-fp-math` fn-attr for OpenCL only. - `-cl-fp32-correctly-rounded-divide-sqrt` is an OpenCL-specific option and `correctly-rounded-divide-sqrt-fp-math` should be added for OpenCL at most. Differential revision: https://reviews.llvm.org/D88303
2020-09-28 22:51:17 +08:00
// HAS_ERRNO: attributes [[NOT_READNONE]] = { nounwind {{.*}} }
[CodeGen] change const-ness of complex calls After clarification about the C standard, POSIX, and implementations: The C standard allows errno-setting, and it's (unfortunately for optimization) even more clearly stated in the newer additions to the standards. We can leave these functions as always constant ('c') because they don't actually do any math and therefore won't set errno: cimag ( http://en.cppreference.com/w/c/numeric/complex/cimag ) creal ( http://en.cppreference.com/w/c/numeric/complex/creal ) cproj ( http://en.cppreference.com/w/c/numeric/complex/cproj ) conj (http://en.cppreference.com/w/c/numeric/complex/conj ) Differential Revision: https://reviews.llvm.org/D39611 llvm-svn: 318598
2017-11-19 03:31:57 +08:00
// HAS_ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
[clang] functions with the 'const' or 'pure' attribute must always return. As described in * https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-pure-function-attribute * https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-const-function-attribute An `__attribute__((pure))` function must always return, as well as an `__attribute__((const))` function. Reviewed By: jdoerfert Differential Revision: https://reviews.llvm.org/D96960
2021-02-19 00:29:46 +08:00
// HAS_ERRNO: attributes [[WILLRETURN_NOT_READNONE]] = { nounwind willreturn {{.*}} }