maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/include/clang/Basic/Builtins.def

1369 lines
60 KiB
Modula-2
Raw Normal View History

Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
//===--- Builtins.def - Builtin function info database ----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
remove attributions from .def files. llvm-svn: 45413
2007-12-30 04:03:32 +08:00
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
//
//===----------------------------------------------------------------------===//
//
// This file defines the standard builtin function database. Users of this file
// must define the BUILTIN macro to make use of this information.
//
//===----------------------------------------------------------------------===//
// FIXME: This should really be a .td file, but that requires modifying tblgen.
// Perhaps tblgen should have plugins.
// The first value provided to the macro specifies the function name of the
// builtin, and results in a clang::builtin::BIXX enum value for XX.
// The second value provided to the macro specifies the type of the function
// (result value, then each argument) as follows:
// v -> void
Make llvm memory barrier available as an intrinsic llvm-svn: 57751
2008-10-18 10:49:28 +08:00
// b -> boolean
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
// c -> char
// s -> short
// i -> int
[Mips][msa] Add support for half Add support for half (a.k.a. __fp16) in builtin descriptions. The second argument to BUILTIN() now accepts 'h' to represent half. Patch by Daniel Sanders llvm-svn: 188464
2013-08-15 23:16:57 +08:00
// h -> half
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
// f -> float
// d -> double
Add prototype info for __builtin_memcpy, reducing #diagnostics from 37 to 34 on PR1750 llvm-svn: 43435
2007-10-29 12:18:06 +08:00
// z -> size_t
Add initial support for constant CFStrings. llvm-svn: 41136
2007-08-17 13:31:46 +08:00
// F -> constant CFString
Restore patch reversed in r118475. Fixes // rdar://8632525 llvm-svn: 118634
2010-11-10 05:38:20 +08:00
// G -> id
// H -> SEL
Fix up various builtin declaration of objc_msgSend families to match those foung in objc.h an avoid spurious warnings. // rdar://12489098 llvm-svn: 171492
2013-01-05 02:45:40 +08:00
// M -> struct objc_super
Add builtin type signature support for vector types. Add correct type signatures for a bunch of MMX builtins. We now parse all the intrinsics in mmintrin.h llvm-svn: 44357
2007-11-27 15:22:09 +08:00
// a -> __builtin_va_list
Fix for PR3350: add special-casing for "references" to va_lists in builtins. Also, a minor tweak to va_copy for consistency. llvm-svn: 62574
2009-01-20 15:46:22 +08:00
// A -> "reference" to __builtin_va_list
Add ext_vector type code for builtins, from John Garvin! llvm-svn: 158156
2012-06-08 02:08:25 +08:00
// V -> Vector, followed by the number of elements and the base type.
// E -> ext_vector, followed by the number of elements and the base type.
Add all of the C99 complex builtins prefixed with __builtin_ llvm-svn: 83020
2009-09-29 05:45:01 +08:00
// X -> _Complex, followed by the base type.
objc - fix up the builtin type for objc_assign_ivar. // rdar://9362887. llvm-svn: 138412
2011-08-24 07:33:09 +08:00
// Y -> ptrdiff_t
Make it possible for builtins to expression FILE* arguments, so that we can define builtins such as fprintf, vfprintf, and __builtin___fprintf_chk. Give a nice error message when we need to implicitly declare a function like fprintf. llvm-svn: 64526
2009-02-14 09:52:53 +08:00
// P -> FILE
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
// J -> jmp_buf
// SJ -> sigjmp_buf
Fix the signature of the getcontext builtin. Patch by Dimitry Andric. llvm-svn: 144505
2011-11-14 05:51:09 +08:00
// K -> ucontext_t
Fix the definition of the vfork() builtin on Haiku. PR14378. llvm-svn: 168674
2012-11-27 10:58:24 +08:00
// p -> pid_t
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
// . -> "...". This may only occur at the end of the function list.
//
Various builtins a require an integer constant. Not providing one results in an obscure error from the backend that doesn't make sense. Capture this information in the .def files for builtins with a new "I" modifier letter indicating the an argument needs to be an ICE. Nothing uses this yet, but sema will eventually enforce this (eliminating some special cases from semachecking.cpp) and codegen will use this to force an ICE value, preventing backend error messages. llvm-svn: 115302
2010-10-01 15:13:18 +08:00
// Types may be prefixed with the following modifiers:
reimplement __sync_* builtins to be variadic and to follow the same semantic rules that gcc and icc use. This implements the variadic and concrete versions as builtins and has sema do the disambiguation. There are probably a bunch of details to finish up but this seems like a large monotonic step forward :) llvm-svn: 71212
2009-05-08 14:58:22 +08:00
// L -> long (e.g. Li for 'long int')
// LL -> long long
// LLL -> __int128_t (e.g. LLLi)
[AArch64] Change int64_t from 'long long int' to 'long int' for AArch64 target. Most 64-bit targets define int64_t as long int, and AArch64 should make same definition to follow LP64 model. In GNU tool chain, int64_t is defined as long int for 64-bit target. So to get consistent with GNU, it's better Changing int64_t from 'long long int' to 'long int', otherwise clang will get different name mangling suffix compared with g++. llvm-svn: 202004
2014-02-24 10:45:03 +08:00
// W -> int64_t
reimplement __sync_* builtins to be variadic and to follow the same semantic rules that gcc and icc use. This implements the variadic and concrete versions as builtins and has sema do the disambiguation. There are probably a bunch of details to finish up but this seems like a large monotonic step forward :) llvm-svn: 71212
2009-05-08 14:58:22 +08:00
// S -> signed
// U -> unsigned
Various builtins a require an integer constant. Not providing one results in an obscure error from the backend that doesn't make sense. Capture this information in the .def files for builtins with a new "I" modifier letter indicating the an argument needs to be an ICE. Nothing uses this yet, but sema will eventually enforce this (eliminating some special cases from semachecking.cpp) and codegen will use this to force an ICE value, preventing backend error messages. llvm-svn: 115302
2010-10-01 15:13:18 +08:00
// I -> Required to constant fold to an integer constant expression.
Add initial support for constant CFStrings. llvm-svn: 41136
2007-08-17 13:31:46 +08:00
//
// Types may be postfixed with the following modifiers:
Sema: Accept pointers to any address space for builtin functions As long as they don't have an address space explicitly defined. This allows builtins with pointer arguments to be used with OpenCL. llvm-svn: 233706
2015-04-01 00:39:02 +08:00
// * -> pointer (optionally followed by an address space number, if no address
// space is specified than any address space will be accepted)
Extend the builtin syntax to allow address-space qualifiers on pointers and references. Based on a patch by Arnaud de Grandmaison! llvm-svn: 98327
2010-03-12 12:21:28 +08:00
// & -> reference (optionally followed by an address space number)
Add initial support for constant CFStrings. llvm-svn: 41136
2007-08-17 13:31:46 +08:00
// C -> const
Patch to add 'volatile' to first argument of all sync compare_and_swap to match them with gcc. It also fixes a few incorrect argument defitions. (fixes radar 7540291). llvm-svn: 94607
2010-01-27 06:48:42 +08:00
// D -> volatile
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
// The third value provided to the macro specifies information about attributes
add some accessors for querying attributes of builtins. Add the new 'F' attribute. llvm-svn: 41631
2007-08-31 11:44:20 +08:00
// of the function. These must be kept in sync with the predicates in the
// Builtin::Context class. Currently we have:
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
// n -> nothrow
Add noreturn for exit. llvm-svn: 77237
2009-07-28 03:14:18 +08:00
// r -> noreturn
Add the Pure attribute to C99 builtin functions from ctype.h. This is a corrected version of r266199 with test case fixes. Patch by Taewook Oh. llvm-svn: 268553
2016-05-05 05:08:13 +08:00
// U -> pure
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
// c -> const
Provide a bit saying that a builtin undergoes custom type-checking, then don't let calls to such functions go down the normal type-checking path. Test this out with __builtin_classify_type and __builtin_constant_p. llvm-svn: 126539
2011-02-26 13:39:39 +08:00
// t -> signature is meaningless, use custom typechecking
add some accessors for querying attributes of builtins. Add the new 'F' attribute. llvm-svn: 41631
2007-08-31 11:44:20 +08:00
// F -> this is a libc/libm function with a '__builtin_' prefix added.
Implicitly declare certain C library functions (malloc, strcpy, memmove, etc.) when we perform name lookup on them. This ensures that we produce the correct signature for these functions, which has two practical impacts: 1) When we're supporting the "implicit function declaration" feature of C99, these functions will be implicitly declared with the right signature rather than as a function returning "int" with no prototype. See PR3541 for the reason why this is important (hint: GCC always predeclares these functions). 2) If users attempt to redeclare one of these library functions with an incompatible signature, we produce a hard error. This patch does a little bit of work to give reasonable error messages. For example, when we hit case #1 we complain that we're implicitly declaring this function with a specific signature, and then we give a note that asks the user to include the appropriate header (e.g., "please include <stdlib.h> or explicitly declare 'malloc'"). In case #2, we show the type of the implicit builtin that was incorrectly declared, so the user can see the problem. We could do better here: for example, when displaying this latter error message we say something like: 'strcpy' was implicitly declared here with type 'char *(char *, char const *)' but we should really print out a fake code line showing the declaration, like this: 'strcpy' was implicitly declared here as: char *strcpy(char *, char const *) This would also be good for printing built-in candidates with C++ operator overloading. The set of C library functions supported by this patch includes all functions from the C99 specification's <stdlib.h> and <string.h> that (a) are predefined by GCC and (b) have signatures that could cause codegen issues if they are treated as functions with no prototype returning and int. Future work could extend this set of functions to other C library functions that we know about. llvm-svn: 64504
2009-02-14 07:20:09 +08:00
// f -> this is a libc/libm function without the '__builtin_' prefix. It can
Extend builtin "attribute" syntax to include a notation for printf-like functions, both builtin functions and those in the C library. The function-call checker now queries this attribute do determine if we have a printf-like function, rather than scanning through the list of "known functions IDs". However, there are 5 functions they are not yet "builtins", so the function-call checker handles them specifically still: - fprintf and vfprintf: the builtins mechanism cannot (yet) express FILE* arguments, so these can't be encoded. - NSLog: the builtins mechanism cannot (yet) express NSString* arguments, so this (and NSLogv) can't be encoded. - asprintf and vasprintf: these aren't part of the C99 standard library, so we really shouldn't be defining them as builtins in the general case (and we don't seem to have the machinery to make them builtins only on certain targets and depending on whether extensions are enabled). llvm-svn: 64512
2009-02-14 08:32:47 +08:00
// be followed by ':headername:' to state which header this function
// comes from.
Add some MS aliases for existing intrinsics Reviewers: thakis, compnerd, majnemer, rsmith, rnk Subscribers: alexshap, cfe-commits Differential Revision: https://reviews.llvm.org/D24330 llvm-svn: 281540
2016-09-15 05:19:43 +08:00
// h -> this function requires a specific header or an explicit declaration.
Allow clang to build __clear_cache on ARM. __clear_cache is special. It needs no signature, but is a real function in compiler_rt or libgcc. Patch by Andrew Turner. llvm-svn: 183926
2013-06-14 02:34:17 +08:00
// i -> this is a runtime library implemented function without the
Add __builtin_operator_new and __builtin_operator_delete, which act like calls to the normal non-placement ::operator new and ::operator delete, but allow optimizations like new-expressions and delete-expressions do. llvm-svn: 210137
2014-06-04 07:27:44 +08:00
// '__builtin_' prefix. It will be implemented in compiler-rt or libgcc.
Add a bunch of math builtins, #include <cmath> passes now. llvm-svn: 82126
2009-09-17 13:45:52 +08:00
// p:N: -> this is a printf-like function whose Nth argument is the format
Extend builtin "attribute" syntax to include a notation for printf-like functions, both builtin functions and those in the C library. The function-call checker now queries this attribute do determine if we have a printf-like function, rather than scanning through the list of "known functions IDs". However, there are 5 functions they are not yet "builtins", so the function-call checker handles them specifically still: - fprintf and vfprintf: the builtins mechanism cannot (yet) express FILE* arguments, so these can't be encoded. - NSLog: the builtins mechanism cannot (yet) express NSString* arguments, so this (and NSLogv) can't be encoded. - asprintf and vasprintf: these aren't part of the C99 standard library, so we really shouldn't be defining them as builtins in the general case (and we don't seem to have the machinery to make them builtins only on certain targets and depending on whether extensions are enabled). llvm-svn: 64512
2009-02-14 08:32:47 +08:00
// string.
// P:N: -> similar to the p:N: attribute, but the function is like vprintf
Add a bunch of math builtins, #include <cmath> passes now. llvm-svn: 82126
2009-09-17 13:45:52 +08:00
// in that it accepts its arguments as a va_list rather than
Extend builtin "attribute" syntax to include a notation for printf-like functions, both builtin functions and those in the C library. The function-call checker now queries this attribute do determine if we have a printf-like function, rather than scanning through the list of "known functions IDs". However, there are 5 functions they are not yet "builtins", so the function-call checker handles them specifically still: - fprintf and vfprintf: the builtins mechanism cannot (yet) express FILE* arguments, so these can't be encoded. - NSLog: the builtins mechanism cannot (yet) express NSString* arguments, so this (and NSLogv) can't be encoded. - asprintf and vasprintf: these aren't part of the C99 standard library, so we really shouldn't be defining them as builtins in the general case (and we don't seem to have the machinery to make them builtins only on certain targets and depending on whether extensions are enabled). llvm-svn: 64512
2009-02-14 08:32:47 +08:00
// through an ellipsis
Add builtin definition for scanf, including extending the builtin encoding to represent builtins that have the "scanf" attribution (via the format attribute) just like we do with printf functions. Follow-up work is needed to add similar support for fscanf et al. This is to support format-string checking for scanf functions. llvm-svn: 108499
2010-07-16 10:11:15 +08:00
// s:N: -> this is a scanf-like function whose Nth argument is the format
// string.
// S:N: -> similar to the s:N: attribute, but the function is like vscanf
// in that it accepts its arguments as a va_list rather than
// through an ellipsis
Support IRgen of sqrt -> llvm.sqrt, pow -> llvm.pow. - Define pow[lf]?, sqrt[lf]? as builtins. - Add -fmath-errno option which binds to LangOptions.MathErrno - Add new builtin flag Builtin::Context::isConstWithoutErrno for functions which can be marked as const if errno isn't respected for math functions. Sema automatically marks these functions as const when they are defined, if MathErrno=0. - IRgen uses const attribute on sqrt and pow library functions to decide if it can use the llvm intrinsic. llvm-svn: 64689
2009-02-17 06:43:43 +08:00
// e -> const, but only when -fmath-errno=0
Add returns_twice to functions that are known to return twice. This implements the same behavior of gcc by keeping the attribute out of the function type. llvm-svn: 141803
2011-10-13 03:51:18 +08:00
// j -> returns_twice (like setjmp)
Some builtins do not evaluate their arguments. Teach EvaluatedExprVisitor not to visit them. llvm-svn: 172769
2013-01-18 07:46:04 +08:00
// u -> arguments are not evaluated for their side-effects
Round out object size checking builtins (fprintf ones disabled as we have no mapping to FILE*). We are also missing printf format attributes for the printf style ones. llvm-svn: 56168
2008-09-13 02:39:42 +08:00
// FIXME: gcc has nonnull
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
Add -ffreestanding to suppress the implicit declaration of library builtins like printf and malloc. Fixes PR3586 llvm-svn: 64566
2009-02-15 04:49:29 +08:00
#if defined(BUILTIN) && !defined(LIBBUILTIN)
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
# define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
Add -ffreestanding to suppress the implicit declaration of library builtins like printf and malloc. Fixes PR3586 llvm-svn: 64566
2009-02-15 04:49:29 +08:00
#endif
Only provide MS builtins when -fms-extensions is on We already have builtins that are only available in GNU mode, so this mirrors that. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2128 llvm-svn: 194615
2013-11-14 06:47:22 +08:00
#if defined(BUILTIN) && !defined(LANGBUILTIN)
# define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
#endif
register clz and ctz builtins. llvm-svn: 44500
2007-12-02 09:20:23 +08:00
// Standard libc/libm functions:
Some small Builtins.def improvements. llvm-svn: 91758
2009-12-19 13:23:20 +08:00
BUILTIN(__builtin_atan2 , "ddd" , "Fnc")
BUILTIN(__builtin_atan2f, "fff" , "Fnc")
BUILTIN(__builtin_atan2l, "LdLdLd", "Fnc")
Add a bunch of math builtins, #include <cmath> passes now. llvm-svn: 82126
2009-09-17 13:45:52 +08:00
BUILTIN(__builtin_abs , "ii" , "ncF")
BUILTIN(__builtin_copysign, "ddd", "ncF")
BUILTIN(__builtin_copysignf, "fff", "ncF")
BUILTIN(__builtin_copysignl, "LdLdLd", "ncF")
BUILTIN(__builtin_fabs , "dd" , "ncF")
BUILTIN(__builtin_fabsf, "ff" , "ncF")
BUILTIN(__builtin_fabsl, "LdLd", "ncF")
Some small Builtins.def improvements. llvm-svn: 91758
2009-12-19 13:23:20 +08:00
BUILTIN(__builtin_fmod , "ddd" , "Fnc")
BUILTIN(__builtin_fmodf, "fff" , "Fnc")
BUILTIN(__builtin_fmodl, "LdLdLd", "Fnc")
The frexp, modf, and remquo builtins are not 'const'. These functions return a second value by writing to a pointer argument, so they cannot be marked 'readnone' which implies that they don't access memory. <rdar://problem/10070234> llvm-svn: 139319
2011-09-09 05:18:03 +08:00
BUILTIN(__builtin_frexp , "ddi*" , "Fn")
BUILTIN(__builtin_frexpf, "ffi*" , "Fn")
BUILTIN(__builtin_frexpl, "LdLdi*", "Fn")
Remove the 'C' / isConstantExpr flag on builtins. Code should never depend on the value of this flag, it should depend on whether tryEvaluate is able to *actually* fold a builtin. llvm-svn: 57160
2008-10-06 14:51:12 +08:00
BUILTIN(__builtin_huge_val, "d", "nc")
BUILTIN(__builtin_huge_valf, "f", "nc")
BUILTIN(__builtin_huge_vall, "Ld", "nc")
BUILTIN(__builtin_inf , "d" , "nc")
BUILTIN(__builtin_inff , "f" , "nc")
BUILTIN(__builtin_infl , "Ld" , "nc")
Add __builtin_labs and __builtin_llabs, to complete the set of __builtin_*abs. Patch by Ruben Van Boxem. llvm-svn: 148340
2012-01-18 06:11:30 +08:00
BUILTIN(__builtin_labs , "LiLi" , "Fnc")
BUILTIN(__builtin_llabs, "LLiLLi", "Fnc")
Some small Builtins.def improvements. llvm-svn: 91758
2009-12-19 13:23:20 +08:00
BUILTIN(__builtin_ldexp , "ddi" , "Fnc")
BUILTIN(__builtin_ldexpf, "ffi" , "Fnc")
BUILTIN(__builtin_ldexpl, "LdLdi", "Fnc")
The frexp, modf, and remquo builtins are not 'const'. These functions return a second value by writing to a pointer argument, so they cannot be marked 'readnone' which implies that they don't access memory. <rdar://problem/10070234> llvm-svn: 139319
2011-09-09 05:18:03 +08:00
BUILTIN(__builtin_modf , "ddd*" , "Fn")
BUILTIN(__builtin_modff, "fff*" , "Fn")
BUILTIN(__builtin_modfl, "LdLdLd*", "Fn")
Make a few related changes: 1) add a new ASTContext::getFloatTypeSemantics method. 2) Use it from SemaExpr.cpp, CodeGenTypes.cpp and other places. 3) Change the TargetInfo.h get*Format methods to return their fltSemantics byref instead of by pointer. 4) Change CodeGenFunction::EmitBuiltinExpr to allow builtins which sometimes expand specially and othertimes fall back to libm. 5) Add support for __builtin_nan("") to codegen, cases that don't pass in an empty string are currently lowered to libm calls. 6) Fix codegen of __builtin_infl. llvm-svn: 52914
2008-07-01 02:32:54 +08:00
BUILTIN(__builtin_nan, "dcC*" , "ncF")
BUILTIN(__builtin_nanf, "fcC*" , "ncF")
BUILTIN(__builtin_nanl, "LdcC*", "ncF")
Implement nans, prefetch, and trap builtins. This closes <rdar://problem/6080720>, support for __builtin_constant_p has been filed separately. llvm-svn: 53885
2008-07-22 06:59:13 +08:00
BUILTIN(__builtin_nans, "dcC*" , "ncF")
BUILTIN(__builtin_nansf, "fcC*" , "ncF")
BUILTIN(__builtin_nansl, "LdcC*", "ncF")
Some small Builtins.def improvements. llvm-svn: 91758
2009-12-19 13:23:20 +08:00
BUILTIN(__builtin_powi , "ddi" , "Fnc")
BUILTIN(__builtin_powif, "ffi" , "Fnc")
BUILTIN(__builtin_powil, "LdLdi", "Fnc")
BUILTIN(__builtin_pow , "ddd" , "Fnc")
BUILTIN(__builtin_powf, "fff" , "Fnc")
BUILTIN(__builtin_powl, "LdLdLd", "Fnc")
Add a bunch of math builtins, #include <cmath> passes now. llvm-svn: 82126
2009-09-17 13:45:52 +08:00
// Standard unary libc/libm functions with double/float/long double variants:
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_acos , "dd" , "Fnc")
BUILTIN(__builtin_acosf, "ff" , "Fnc")
BUILTIN(__builtin_acosl, "LdLd", "Fnc")
add some missing builtins. llvm-svn: 124981
2011-02-06 20:45:51 +08:00
BUILTIN(__builtin_acosh , "dd" , "Fnc")
BUILTIN(__builtin_acoshf, "ff" , "Fnc")
BUILTIN(__builtin_acoshl, "LdLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_asin , "dd" , "Fnc")
BUILTIN(__builtin_asinf, "ff" , "Fnc")
BUILTIN(__builtin_asinl, "LdLd", "Fnc")
add some missing builtins. llvm-svn: 124981
2011-02-06 20:45:51 +08:00
BUILTIN(__builtin_asinh , "dd" , "Fnc")
BUILTIN(__builtin_asinhf, "ff" , "Fnc")
BUILTIN(__builtin_asinhl, "LdLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_atan , "dd" , "Fnc")
BUILTIN(__builtin_atanf, "ff" , "Fnc")
BUILTIN(__builtin_atanl, "LdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_atanh , "dd", "Fnc")
BUILTIN(__builtin_atanhf, "ff", "Fnc")
BUILTIN(__builtin_atanhl, "LdLd", "Fnc")
BUILTIN(__builtin_cbrt , "dd", "Fnc")
BUILTIN(__builtin_cbrtf, "ff", "Fnc")
BUILTIN(__builtin_cbrtl, "LdLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_ceil , "dd" , "Fnc")
BUILTIN(__builtin_ceilf, "ff" , "Fnc")
BUILTIN(__builtin_ceill, "LdLd", "Fnc")
BUILTIN(__builtin_cos , "dd" , "Fnc")
BUILTIN(__builtin_cosf, "ff" , "Fnc")
BUILTIN(__builtin_cosh , "dd" , "Fnc")
BUILTIN(__builtin_coshf, "ff" , "Fnc")
BUILTIN(__builtin_coshl, "LdLd", "Fnc")
BUILTIN(__builtin_cosl, "LdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_erf , "dd", "Fnc")
BUILTIN(__builtin_erff, "ff", "Fnc")
BUILTIN(__builtin_erfl, "LdLd", "Fnc")
BUILTIN(__builtin_erfc , "dd", "Fnc")
BUILTIN(__builtin_erfcf, "ff", "Fnc")
BUILTIN(__builtin_erfcl, "LdLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_exp , "dd" , "Fnc")
BUILTIN(__builtin_expf, "ff" , "Fnc")
BUILTIN(__builtin_expl, "LdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_exp2 , "dd" , "Fnc")
BUILTIN(__builtin_exp2f, "ff" , "Fnc")
BUILTIN(__builtin_exp2l, "LdLd", "Fnc")
BUILTIN(__builtin_expm1 , "dd", "Fnc")
BUILTIN(__builtin_expm1f, "ff", "Fnc")
BUILTIN(__builtin_expm1l, "LdLd", "Fnc")
Basic: Add f{dim,ma,max,min}[lf]? builtins. llvm-svn: 114068
2010-09-16 13:20:04 +08:00
BUILTIN(__builtin_fdim, "ddd", "Fnc")
BUILTIN(__builtin_fdimf, "fff", "Fnc")
BUILTIN(__builtin_fdiml, "LdLdLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_floor , "dd" , "Fnc")
BUILTIN(__builtin_floorf, "ff" , "Fnc")
BUILTIN(__builtin_floorl, "LdLd", "Fnc")
Basic: Add f{dim,ma,max,min}[lf]? builtins. llvm-svn: 114068
2010-09-16 13:20:04 +08:00
BUILTIN(__builtin_fma, "dddd", "Fnc")
BUILTIN(__builtin_fmaf, "ffff", "Fnc")
BUILTIN(__builtin_fmal, "LdLdLdLd", "Fnc")
BUILTIN(__builtin_fmax, "ddd", "Fnc")
BUILTIN(__builtin_fmaxf, "fff", "Fnc")
BUILTIN(__builtin_fmaxl, "LdLdLd", "Fnc")
BUILTIN(__builtin_fmin, "ddd", "Fnc")
BUILTIN(__builtin_fminf, "fff", "Fnc")
BUILTIN(__builtin_fminl, "LdLdLd", "Fnc")
Some small Builtins.def improvements. llvm-svn: 91758
2009-12-19 13:23:20 +08:00
BUILTIN(__builtin_hypot , "ddd" , "Fnc")
BUILTIN(__builtin_hypotf, "fff" , "Fnc")
BUILTIN(__builtin_hypotl, "LdLdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_ilogb , "id", "Fnc")
BUILTIN(__builtin_ilogbf, "if", "Fnc")
BUILTIN(__builtin_ilogbl, "iLd", "Fnc")
BUILTIN(__builtin_lgamma , "dd", "Fnc")
BUILTIN(__builtin_lgammaf, "ff", "Fnc")
BUILTIN(__builtin_lgammal, "LdLd", "Fnc")
BUILTIN(__builtin_llrint, "LLid", "Fnc")
BUILTIN(__builtin_llrintf, "LLif", "Fnc")
BUILTIN(__builtin_llrintl, "LLiLd", "Fnc")
BUILTIN(__builtin_llround , "LLid", "Fnc")
BUILTIN(__builtin_llroundf, "LLif", "Fnc")
BUILTIN(__builtin_llroundl, "LLiLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_log , "dd" , "Fnc")
BUILTIN(__builtin_log10 , "dd" , "Fnc")
BUILTIN(__builtin_log10f, "ff" , "Fnc")
BUILTIN(__builtin_log10l, "LdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_log1p , "dd" , "Fnc")
BUILTIN(__builtin_log1pf, "ff" , "Fnc")
BUILTIN(__builtin_log1pl, "LdLd", "Fnc")
Basic: add log2{,f,l}, round{,f,l} builtins llvm-svn: 120136
2010-11-25 09:15:00 +08:00
BUILTIN(__builtin_log2, "dd" , "Fnc")
BUILTIN(__builtin_log2f, "ff" , "Fnc")
BUILTIN(__builtin_log2l, "LdLd" , "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_logb , "dd", "Fnc")
BUILTIN(__builtin_logbf, "ff", "Fnc")
BUILTIN(__builtin_logbl, "LdLd", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_logf, "ff" , "Fnc")
BUILTIN(__builtin_logl, "LdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_lrint , "Lid", "Fnc")
BUILTIN(__builtin_lrintf, "Lif", "Fnc")
BUILTIN(__builtin_lrintl, "LiLd", "Fnc")
BUILTIN(__builtin_lround , "Lid", "Fnc")
BUILTIN(__builtin_lroundf, "Lif", "Fnc")
BUILTIN(__builtin_lroundl, "LiLd", "Fnc")
BUILTIN(__builtin_nearbyint , "dd", "Fnc")
BUILTIN(__builtin_nearbyintf, "ff", "Fnc")
BUILTIN(__builtin_nearbyintl, "LdLd", "Fnc")
BUILTIN(__builtin_nextafter , "ddd", "Fnc")
BUILTIN(__builtin_nextafterf, "fff", "Fnc")
BUILTIN(__builtin_nextafterl, "LdLdLd", "Fnc")
The second parameter of nexttoward is always long double. llvm-svn: 191623
2013-09-29 01:41:03 +08:00
BUILTIN(__builtin_nexttoward , "ddLd", "Fnc")
BUILTIN(__builtin_nexttowardf, "ffLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_nexttowardl, "LdLdLd", "Fnc")
BUILTIN(__builtin_remainder , "ddd", "Fnc")
BUILTIN(__builtin_remainderf, "fff", "Fnc")
BUILTIN(__builtin_remainderl, "LdLdLd", "Fnc")
The frexp, modf, and remquo builtins are not 'const'. These functions return a second value by writing to a pointer argument, so they cannot be marked 'readnone' which implies that they don't access memory. <rdar://problem/10070234> llvm-svn: 139319
2011-09-09 05:18:03 +08:00
BUILTIN(__builtin_remquo , "dddi*", "Fn")
BUILTIN(__builtin_remquof, "fffi*", "Fn")
BUILTIN(__builtin_remquol, "LdLdLdi*", "Fn")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_rint , "dd", "Fnc")
BUILTIN(__builtin_rintf, "ff", "Fnc")
BUILTIN(__builtin_rintl, "LdLd", "Fnc")
Basic: add log2{,f,l}, round{,f,l} builtins llvm-svn: 120136
2010-11-25 09:15:00 +08:00
BUILTIN(__builtin_round, "dd" , "Fnc")
BUILTIN(__builtin_roundf, "ff" , "Fnc")
BUILTIN(__builtin_roundl, "LdLd" , "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_scalbln , "ddLi", "Fnc")
BUILTIN(__builtin_scalblnf, "ffLi", "Fnc")
BUILTIN(__builtin_scalblnl, "LdLdLi", "Fnc")
BUILTIN(__builtin_scalbn , "ddi", "Fnc")
BUILTIN(__builtin_scalbnf, "ffi", "Fnc")
BUILTIN(__builtin_scalbnl, "LdLdi", "Fnc")
add 'F' to a bunch of libm builtins so that codegen doesn't die on them, pointed out by Charles Davis. llvm-svn: 90736
2009-12-07 10:09:14 +08:00
BUILTIN(__builtin_sin , "dd" , "Fnc")
BUILTIN(__builtin_sinf, "ff" , "Fnc")
BUILTIN(__builtin_sinh , "dd" , "Fnc")
BUILTIN(__builtin_sinhf, "ff" , "Fnc")
BUILTIN(__builtin_sinhl, "LdLd", "Fnc")
BUILTIN(__builtin_sinl, "LdLd", "Fnc")
BUILTIN(__builtin_sqrt , "dd" , "Fnc")
BUILTIN(__builtin_sqrtf, "ff" , "Fnc")
BUILTIN(__builtin_sqrtl, "LdLd", "Fnc")
BUILTIN(__builtin_tan , "dd" , "Fnc")
BUILTIN(__builtin_tanf, "ff" , "Fnc")
BUILTIN(__builtin_tanh , "dd" , "Fnc")
BUILTIN(__builtin_tanhf, "ff" , "Fnc")
BUILTIN(__builtin_tanhl, "LdLd", "Fnc")
BUILTIN(__builtin_tanl, "LdLd", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_tgamma , "dd", "Fnc")
BUILTIN(__builtin_tgammaf, "ff", "Fnc")
BUILTIN(__builtin_tgammal, "LdLd", "Fnc")
BUILTIN(__builtin_trunc , "dd", "Fnc")
BUILTIN(__builtin_truncf, "ff", "Fnc")
BUILTIN(__builtin_truncl, "LdLd", "Fnc")
Add a bunch of math builtins, #include <cmath> passes now. llvm-svn: 82126
2009-09-17 13:45:52 +08:00
Add all of the C99 complex builtins prefixed with __builtin_ llvm-svn: 83020
2009-09-29 05:45:01 +08:00
// C99 complex builtins
BUILTIN(__builtin_cabs, "dXd", "Fnc")
BUILTIN(__builtin_cabsf, "fXf", "Fnc")
BUILTIN(__builtin_cabsl, "LdXLd", "Fnc")
BUILTIN(__builtin_cacos, "XdXd", "Fnc")
BUILTIN(__builtin_cacosf, "XfXf", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_cacosh, "XdXd", "Fnc")
BUILTIN(__builtin_cacoshf, "XfXf", "Fnc")
BUILTIN(__builtin_cacoshl, "XLdXLd", "Fnc")
Add all of the C99 complex builtins prefixed with __builtin_ llvm-svn: 83020
2009-09-29 05:45:01 +08:00
BUILTIN(__builtin_cacosl, "XLdXLd", "Fnc")
BUILTIN(__builtin_carg, "dXd", "Fnc")
BUILTIN(__builtin_cargf, "fXf", "Fnc")
BUILTIN(__builtin_cargl, "LdXLd", "Fnc")
BUILTIN(__builtin_casin, "XdXd", "Fnc")
BUILTIN(__builtin_casinf, "XfXf", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_casinh, "XdXd", "Fnc")
BUILTIN(__builtin_casinhf, "XfXf", "Fnc")
BUILTIN(__builtin_casinhl, "XLdXLd", "Fnc")
Add all of the C99 complex builtins prefixed with __builtin_ llvm-svn: 83020
2009-09-29 05:45:01 +08:00
BUILTIN(__builtin_casinl, "XLdXLd", "Fnc")
BUILTIN(__builtin_catan, "XdXd", "Fnc")
BUILTIN(__builtin_catanf, "XfXf", "Fnc")
Add support for the builtins used in gcc 4.4's <cmath> and <complex> headers in C++0x mode. Fixes PR9138. Patch by John Bytheway! llvm-svn: 125492
2011-02-15 01:02:48 +08:00
BUILTIN(__builtin_catanh, "XdXd", "Fnc")
BUILTIN(__builtin_catanhf, "XfXf", "Fnc")
BUILTIN(__builtin_catanhl, "XLdXLd", "Fnc")
Add all of the C99 complex builtins prefixed with __builtin_ llvm-svn: 83020
2009-09-29 05:45:01 +08:00
BUILTIN(__builtin_catanl, "XLdXLd", "Fnc")
BUILTIN(__builtin_ccos, "XdXd", "Fnc")
BUILTIN(__builtin_ccosf, "XfXf", "Fnc")
BUILTIN(__builtin_ccosl, "XLdXLd", "Fnc")
BUILTIN(__builtin_ccosh, "XdXd", "Fnc")
BUILTIN(__builtin_ccoshf, "XfXf", "Fnc")
BUILTIN(__builtin_ccoshl, "XLdXLd", "Fnc")
BUILTIN(__builtin_cexp, "XdXd", "Fnc")
BUILTIN(__builtin_cexpf, "XfXf", "Fnc")
BUILTIN(__builtin_cexpl, "XLdXLd", "Fnc")
BUILTIN(__builtin_cimag, "dXd", "Fnc")
BUILTIN(__builtin_cimagf, "fXf", "Fnc")
BUILTIN(__builtin_cimagl, "LdXLd", "Fnc")
Fixed typo in conj, conjf, conjl signature. llvm-svn: 111134
2010-08-16 23:57:05 +08:00
BUILTIN(__builtin_conj, "XdXd", "Fnc")
BUILTIN(__builtin_conjf, "XfXf", "Fnc")
BUILTIN(__builtin_conjl, "XLdXLd", "Fnc")
Add all of the C99 complex builtins prefixed with __builtin_ llvm-svn: 83020
2009-09-29 05:45:01 +08:00
BUILTIN(__builtin_clog, "XdXd", "Fnc")
BUILTIN(__builtin_clogf, "XfXf", "Fnc")
BUILTIN(__builtin_clogl, "XLdXLd", "Fnc")
BUILTIN(__builtin_cproj, "XdXd", "Fnc")
BUILTIN(__builtin_cprojf, "XfXf", "Fnc")
BUILTIN(__builtin_cprojl, "XLdXLd", "Fnc")
BUILTIN(__builtin_cpow, "XdXdXd", "Fnc")
BUILTIN(__builtin_cpowf, "XfXfXf", "Fnc")
BUILTIN(__builtin_cpowl, "XLdXLdXLd", "Fnc")
BUILTIN(__builtin_creal, "dXd", "Fnc")
BUILTIN(__builtin_crealf, "fXf", "Fnc")
BUILTIN(__builtin_creall, "LdXLd", "Fnc")
BUILTIN(__builtin_csin, "XdXd", "Fnc")
BUILTIN(__builtin_csinf, "XfXf", "Fnc")
BUILTIN(__builtin_csinl, "XLdXLd", "Fnc")
BUILTIN(__builtin_csinh, "XdXd", "Fnc")
BUILTIN(__builtin_csinhf, "XfXf", "Fnc")
BUILTIN(__builtin_csinhl, "XLdXLd", "Fnc")
BUILTIN(__builtin_csqrt, "XdXd", "Fnc")
BUILTIN(__builtin_csqrtf, "XfXf", "Fnc")
BUILTIN(__builtin_csqrtl, "XLdXLd", "Fnc")
BUILTIN(__builtin_ctan, "XdXd", "Fnc")
BUILTIN(__builtin_ctanf, "XfXf", "Fnc")
BUILTIN(__builtin_ctanl, "XLdXLd", "Fnc")
BUILTIN(__builtin_ctanh, "XdXd", "Fnc")
BUILTIN(__builtin_ctanhf, "XfXf", "Fnc")
BUILTIN(__builtin_ctanhl, "XLdXLd", "Fnc")
register clz and ctz builtins. llvm-svn: 44500
2007-12-02 09:20:23 +08:00
add some builtins. llvm-svn: 44995
2007-12-13 15:41:58 +08:00
// FP Comparisons.
Add some missing 'F' flags to libm/libc builtins. More discussion available in http://reviews.llvm.org/D9913 llvm-svn: 242675
2015-07-20 22:36:59 +08:00
BUILTIN(__builtin_isgreater , "i.", "Fnc")
BUILTIN(__builtin_isgreaterequal, "i.", "Fnc")
BUILTIN(__builtin_isless , "i.", "Fnc")
BUILTIN(__builtin_islessequal , "i.", "Fnc")
BUILTIN(__builtin_islessgreater , "i.", "Fnc")
BUILTIN(__builtin_isunordered , "i.", "Fnc")
add some builtins. llvm-svn: 44995
2007-12-13 15:41:58 +08:00
PR4836, part 1: add Sema support for __builtin_isnan and friends; they are apparently used by Solaris libc despite the fact that clang claims to be compatible with gcc 4.2, which doesn't support them. llvm-svn: 80610
2009-09-01 04:06:00 +08:00
// Unary FP classification
Add some missing 'F' flags to libm/libc builtins. More discussion available in http://reviews.llvm.org/D9913 llvm-svn: 242675
2015-07-20 22:36:59 +08:00
BUILTIN(__builtin_fpclassify, "iiiii.", "Fnc")
BUILTIN(__builtin_isfinite, "i.", "Fnc")
BUILTIN(__builtin_isinf, "i.", "Fnc")
BUILTIN(__builtin_isinf_sign, "i.", "Fnc")
BUILTIN(__builtin_isnan, "i.", "Fnc")
BUILTIN(__builtin_isnormal, "i.", "Fnc")
PR4836, part 1: add Sema support for __builtin_isnan and friends; they are apparently used by Solaris libc despite the fact that clang claims to be compatible with gcc 4.2, which doesn't support them. llvm-svn: 80610
2009-09-01 04:06:00 +08:00
PR6515: Implement __builtin_signbit and friends. I'm reasonably sure my implementation is correct, but it would be nice if someone could double-check. llvm-svn: 97864
2010-03-06 10:17:52 +08:00
// FP signbit builtins
Add some missing 'F' flags to libm/libc builtins. More discussion available in http://reviews.llvm.org/D9913 llvm-svn: 242675
2015-07-20 22:36:59 +08:00
BUILTIN(__builtin_signbit, "i.", "Fnc")
BUILTIN(__builtin_signbitf, "if", "Fnc")
BUILTIN(__builtin_signbitl, "iLd", "Fnc")
PR6515: Implement __builtin_signbit and friends. I'm reasonably sure my implementation is correct, but it would be nice if someone could double-check. llvm-svn: 97864
2010-03-06 10:17:52 +08:00
Add __builtin_canonicalize llvm-svn: 262122
2016-02-27 17:06:18 +08:00
// Special FP builtins.
BUILTIN(__builtin_canonicalize, "dd", "nc")
BUILTIN(__builtin_canonicalizef, "ff", "nc")
BUILTIN(__builtin_canonicalizel, "LdLd", "nc")
register clz and ctz builtins. llvm-svn: 44500
2007-12-02 09:20:23 +08:00
// Builtins for arithmetic.
Make the __builtin_c[lt]zs builtins target independent. There is really no reason to have these only available on x86. It's just __builtin_c[tl]z for shorts. Modernize the test while at it. llvm-svn: 149183
2012-01-29 02:42:57 +08:00
BUILTIN(__builtin_clzs , "iUs" , "nc")
register clz and ctz builtins. llvm-svn: 44500
2007-12-02 09:20:23 +08:00
BUILTIN(__builtin_clz , "iUi" , "nc")
BUILTIN(__builtin_clzl , "iULi" , "nc")
BUILTIN(__builtin_clzll, "iULLi", "nc")
add a fixme llvm-svn: 44523
2007-12-03 07:05:46 +08:00
// TODO: int clzimax(uintmax_t)
Make the __builtin_c[lt]zs builtins target independent. There is really no reason to have these only available on x86. It's just __builtin_c[tl]z for shorts. Modernize the test while at it. llvm-svn: 149183
2012-01-29 02:42:57 +08:00
BUILTIN(__builtin_ctzs , "iUs" , "nc")
register clz and ctz builtins. llvm-svn: 44500
2007-12-02 09:20:23 +08:00
BUILTIN(__builtin_ctz , "iUi" , "nc")
BUILTIN(__builtin_ctzl , "iULi" , "nc")
BUILTIN(__builtin_ctzll, "iULLi", "nc")
add a fixme llvm-svn: 44523
2007-12-03 07:05:46 +08:00
// TODO: int ctzimax(uintmax_t)
Add some missing 'F' flags to libm/libc builtins. More discussion available in http://reviews.llvm.org/D9913 llvm-svn: 242675
2015-07-20 22:36:59 +08:00
BUILTIN(__builtin_ffs , "ii" , "Fnc")
BUILTIN(__builtin_ffsl , "iLi" , "Fnc")
BUILTIN(__builtin_ffsll, "iLLi", "Fnc")
Implement ffs, parity, and popcount builtins. + test case llvm-svn: 53851
2008-07-22 01:19:41 +08:00
BUILTIN(__builtin_parity , "iUi" , "nc")
BUILTIN(__builtin_parityl , "iULi" , "nc")
BUILTIN(__builtin_parityll, "iULLi", "nc")
BUILTIN(__builtin_popcount , "iUi" , "nc")
BUILTIN(__builtin_popcountl , "iULi" , "nc")
BUILTIN(__builtin_popcountll, "iULLi", "nc")
register clz and ctz builtins. llvm-svn: 44500
2007-12-02 09:20:23 +08:00
add a fixme llvm-svn: 44523
2007-12-03 07:05:46 +08:00
// FIXME: These type signatures are not correct for targets with int != 32-bits
// or with ULL != 64-bits.
Expose __builtin_bswap16. GCC has always supported this on PowerPC and 4.8 supports it on all platforms, so it's a good idea to expose it in clang too. LLVM supports this on all targets. llvm-svn: 165362
2012-10-06 22:42:22 +08:00
BUILTIN(__builtin_bswap16, "UsUs", "nc")
Implement __builtin_bswap32 and __builtin_bswap64. llvm-svn: 44521
2007-12-03 05:58:10 +08:00
BUILTIN(__builtin_bswap32, "UiUi", "nc")
BUILTIN(__builtin_bswap64, "ULLiULLi", "nc")
add a fixme llvm-svn: 44523
2007-12-03 07:05:46 +08:00
Add missing __builtin_bitreverse8 Also add documentation for bitreverse builtins llvm-svn: 264203
2016-03-24 06:14:43 +08:00
BUILTIN(__builtin_bitreverse8, "UcUc", "nc")
Add builtins for bitreverse intrinsic Follow the naming convention that bswap uses since it's a similar sort of operation. llvm-svn: 259671
2016-02-04 01:49:38 +08:00
BUILTIN(__builtin_bitreverse16, "UsUs", "nc")
BUILTIN(__builtin_bitreverse32, "UiUi", "nc")
BUILTIN(__builtin_bitreverse64, "ULLiULLi", "nc")
add a fixme llvm-svn: 44523
2007-12-03 07:05:46 +08:00
// Random GCC builtins
Some builtins do not evaluate their arguments. Teach EvaluatedExprVisitor not to visit them. llvm-svn: 172769
2013-01-18 07:46:04 +08:00
BUILTIN(__builtin_constant_p, "i.", "nctu")
BUILTIN(__builtin_classify_type, "i.", "nctu")
Remove the 'C' / isConstantExpr flag on builtins. Code should never depend on the value of this flag, it should depend on whether tryEvaluate is able to *actually* fold a builtin. llvm-svn: 57160
2008-10-06 14:51:12 +08:00
BUILTIN(__builtin___CFStringMakeConstantString, "FC*cC*", "nc")
Created __builtin___NSStringMakeConstantString() builtin, which generates constant Objective-C strings. llvm-svn: 94274
2010-01-23 10:40:42 +08:00
BUILTIN(__builtin___NSStringMakeConstantString, "FC*cC*", "nc")
The lvalue-to-rvalue on structs in C++ is actually part of default argument promotion and needs to happen unconditionally. This is particularly semantically important in C++0x. llvm-svn: 138691
2011-08-27 09:09:30 +08:00
BUILTIN(__builtin_va_start, "vA.", "nt")
Fix for PR3350: add special-casing for "references" to va_lists in builtins. Also, a minor tweak to va_copy for consistency. llvm-svn: 62574
2009-01-20 15:46:22 +08:00
BUILTIN(__builtin_va_end, "vA", "n")
BUILTIN(__builtin_va_copy, "vAA", "n")
BUILTIN(__builtin_stdarg_start, "vA.", "n")
Add __builtin_assume and __builtin_assume_aligned using @llvm.assume. This makes use of the recently-added @llvm.assume intrinsic to implement a __builtin_assume(bool) intrinsic (to provide additional information to the optimizer). This hooks up __assume in MS-compatibility mode to mirror __builtin_assume (the semantics have been intentionally kept compatible), and implements GCC's __builtin_assume_aligned as assume((p - o) & mask == 0). LLVM now contains special logic to deal with assumptions of this form. llvm-svn: 217349
2014-09-08 06:58:14 +08:00
BUILTIN(__builtin_assume_aligned, "v*vC*z.", "nc")
Add some missing 'F' flags to libm/libc builtins. More discussion available in http://reviews.llvm.org/D9913 llvm-svn: 242675
2015-07-20 22:36:59 +08:00
BUILTIN(__builtin_bcmp, "iv*v*z", "Fn")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_bcopy, "vv*v*z", "n")
Add bzero builtin; this should help codegen quality for code using this function. llvm-svn: 94320
2010-01-24 03:00:10 +08:00
BUILTIN(__builtin_bzero, "vv*z", "nF")
Implement __builtin_printf, __builtin_fprintf. Fixes <rdar://problem/8336581>. llvm-svn: 112049
2010-08-25 23:47:31 +08:00
BUILTIN(__builtin_fprintf, "iP*cC*.", "Fp:1:")
Add __builtin_memchr (used by GNU libstdc++). llvm-svn: 80288
2009-08-28 06:00:18 +08:00
BUILTIN(__builtin_memchr, "v*vC*iz", "nF")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_memcmp, "ivC*vC*z", "nF")
BUILTIN(__builtin_memcpy, "v*v*vC*z", "nF")
BUILTIN(__builtin_memmove, "v*v*vC*z", "nF")
BUILTIN(__builtin_mempcpy, "v*v*vC*z", "nF")
BUILTIN(__builtin_memset, "v*v*iz", "nF")
Implement __builtin_printf, __builtin_fprintf. Fixes <rdar://problem/8336581>. llvm-svn: 112049
2010-08-25 23:47:31 +08:00
BUILTIN(__builtin_printf, "icC*.", "Fp:0:")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_stpcpy, "c*c*cC*", "nF")
BUILTIN(__builtin_stpncpy, "c*c*cC*z", "nF")
BUILTIN(__builtin_strcasecmp, "icC*cC*", "nF")
Add some stdlib builtins llvm-svn: 65115
2009-02-20 14:36:40 +08:00
BUILTIN(__builtin_strcat, "c*c*cC*", "nF")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_strchr, "c*cC*i", "nF")
BUILTIN(__builtin_strcmp, "icC*cC*", "nF")
Add some stdlib builtins llvm-svn: 65115
2009-02-20 14:36:40 +08:00
BUILTIN(__builtin_strcpy, "c*c*cC*", "nF")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_strcspn, "zcC*cC*", "nF")
BUILTIN(__builtin_strdup, "c*cC*", "nF")
BUILTIN(__builtin_strlen, "zcC*", "nF")
BUILTIN(__builtin_strncasecmp, "icC*cC*z", "nF")
BUILTIN(__builtin_strncat, "c*c*cC*z", "nF")
BUILTIN(__builtin_strncmp, "icC*cC*z", "nF")
Add some stdlib builtins llvm-svn: 65115
2009-02-20 14:36:40 +08:00
BUILTIN(__builtin_strncpy, "c*c*cC*z", "nF")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_strndup, "c*cC*z", "nF")
BUILTIN(__builtin_strpbrk, "c*cC*cC*", "nF")
Add some stdlib builtins llvm-svn: 65115
2009-02-20 14:36:40 +08:00
BUILTIN(__builtin_strrchr, "c*cC*i", "nF")
Add more builtin definitions, including strcmp. - PR3964. llvm-svn: 68710
2009-04-10 00:42:50 +08:00
BUILTIN(__builtin_strspn, "zcC*cC*", "nF")
BUILTIN(__builtin_strstr, "c*cC*cC*", "nF")
move imperative code to declarative definitions. llvm-svn: 115381
2010-10-02 07:35:58 +08:00
BUILTIN(__builtin_return_address, "v*IUi", "n")
PR4134: Implement __builtin_extract_return_addr. llvm-svn: 70794
2009-05-04 03:23:23 +08:00
BUILTIN(__builtin_extract_return_addr, "v*v*", "n")
move imperative code to declarative definitions. llvm-svn: 115381
2010-10-02 07:35:58 +08:00
BUILTIN(__builtin_frame_address, "v*IUi", "n")
Add support for __builtin___clear_cache in Clang Adding the mapping between __builtin___clear_cache into @llvm.clear_cache llvm-svn: 204820
2014-03-26 23:36:05 +08:00
BUILTIN(__builtin___clear_cache, "vc*c*", "n")
Add __builtin_flt_rounds llvm-svn: 61443
2008-12-27 00:43:35 +08:00
BUILTIN(__builtin_flt_rounds, "i", "nc")
Adjust the changes from r230255 to bail out if the backend can't lower __builtin_setjmp/__builtin_longjmp and don't fall back to the libc functions. llvm-svn: 231245
2015-03-04 22:25:35 +08:00
BUILTIN(__builtin_setjmp, "iv**", "j")
BUILTIN(__builtin_longjmp, "vv**i", "r")
Missing file for __builtin_unwind_init support. llvm-svn: 72728
2009-06-02 17:39:16 +08:00
BUILTIN(__builtin_unwind_init, "v", "")
move imperative code to declarative definitions. llvm-svn: 115381
2010-10-02 07:35:58 +08:00
BUILTIN(__builtin_eh_return_data_regno, "iIi", "nc")
Add __builtin_snprintf. llvm-svn: 108290
2010-07-14 06:35:05 +08:00
BUILTIN(__builtin_snprintf, "ic*zcC*.", "nFp:2:")
add builtin for __builtin_vsprintf, patch by Paul Davey llvm-svn: 101224
2010-04-14 12:25:45 +08:00
BUILTIN(__builtin_vsprintf, "ic*cC*a", "nFP:1:")
Add __builtin_vsnprintf. Thanks to Anders Johnsen llvm-svn: 82998
2009-09-29 02:08:57 +08:00
BUILTIN(__builtin_vsnprintf, "ic*zcC*a", "nFP:2:")
[Builtin] Make __builtin_thread_pointer target-independent. This is now supported for ARM, AArch64, PowerPC, SystemZ, SPARC, Mips. Differential Revision: http://reviews.llvm.org/D19589 llvm-svn: 272893
2016-06-16 21:41:54 +08:00
BUILTIN(__builtin_thread_pointer, "v*", "nc")
Add __builtin_flt_rounds llvm-svn: 61443
2008-12-27 00:43:35 +08:00
Add builtins from PR5255. Implementations coming soon. llvm-svn: 95894
2010-02-12 03:02:42 +08:00
// GCC exception builtins
Mark __builtin_eh_return as noreturn. Patch by Dimitry Andric. llvm-svn: 109452
2010-07-27 06:04:15 +08:00
BUILTIN(__builtin_eh_return, "vzv*", "r") // FIXME: Takes intptr_t, not size_t!
Add builtins from PR5255. Implementations coming soon. llvm-svn: 95894
2010-02-12 03:02:42 +08:00
BUILTIN(__builtin_frob_return_addr, "v*v*", "n")
BUILTIN(__builtin_dwarf_cfa, "v*", "n")
BUILTIN(__builtin_init_dwarf_reg_size_table, "vv*", "n")
BUILTIN(__builtin_dwarf_sp_column, "Ui", "n")
Inspired by seeing "MIPS" go by in the commits, I've gone ahead and implemented a (codegen) target hook for __builtin_extend_pointer. I'm also making it return a uint64_t instead of an unsigned word; this comports with typical usage (i.e. the one use I know of). I don't know if any of the existing targets requires this hook to be set (other than x86 and x86_64, which I know do not). llvm-svn: 97547
2010-03-02 11:50:12 +08:00
BUILTIN(__builtin_extend_pointer, "ULLiv*", "n") // _Unwind_Word == uint64_t
Add builtins from PR5255. Implementations coming soon. llvm-svn: 95894
2010-02-12 03:02:42 +08:00
Add some of GCC's object checking builtin's. llvm-svn: 51133
2008-05-15 06:12:15 +08:00
// GCC Object size checking builtins
Some builtins do not evaluate their arguments. Teach EvaluatedExprVisitor not to visit them. llvm-svn: 172769
2013-01-18 07:46:04 +08:00
BUILTIN(__builtin_object_size, "zvC*i", "nu")
Modify object size checking builtins to lower to libc calls. llvm-svn: 55721
2008-09-04 04:28:50 +08:00
BUILTIN(__builtin___memcpy_chk, "v*v*vC*zz", "nF")
Add an expected parameter for the size of the destination. <rdar://problem/12622659> llvm-svn: 170392
2012-12-18 08:34:49 +08:00
BUILTIN(__builtin___memccpy_chk, "v*v*vC*izz", "nF")
Modify object size checking builtins to lower to libc calls. llvm-svn: 55721
2008-09-04 04:28:50 +08:00
BUILTIN(__builtin___memmove_chk, "v*v*vC*zz", "nF")
BUILTIN(__builtin___mempcpy_chk, "v*v*vC*zz", "nF")
Round out object size checking builtins (fprintf ones disabled as we have no mapping to FILE*). We are also missing printf format attributes for the printf style ones. llvm-svn: 56168
2008-09-13 02:39:42 +08:00
BUILTIN(__builtin___memset_chk, "v*v*izz", "nF")
BUILTIN(__builtin___stpcpy_chk, "c*c*cC*z", "nF")
Modify object size checking builtins to lower to libc calls. llvm-svn: 55721
2008-09-04 04:28:50 +08:00
BUILTIN(__builtin___strcat_chk, "c*c*cC*z", "nF")
Round out object size checking builtins (fprintf ones disabled as we have no mapping to FILE*). We are also missing printf format attributes for the printf style ones. llvm-svn: 56168
2008-09-13 02:39:42 +08:00
BUILTIN(__builtin___strcpy_chk, "c*c*cC*z", "nF")
Use the correct return type (size_t) for these builtins. <rdar://problem/12646344> llvm-svn: 170393
2012-12-18 08:37:10 +08:00
BUILTIN(__builtin___strlcat_chk, "zc*cC*zz", "nF")
BUILTIN(__builtin___strlcpy_chk, "zc*cC*zz", "nF")
Round out object size checking builtins (fprintf ones disabled as we have no mapping to FILE*). We are also missing printf format attributes for the printf style ones. llvm-svn: 56168
2008-09-13 02:39:42 +08:00
BUILTIN(__builtin___strncat_chk, "c*c*cC*zz", "nF")
BUILTIN(__builtin___strncpy_chk, "c*c*cC*zz", "nF")
Add support for stpncpy_chk. llvm-svn: 100711
2010-04-08 07:00:44 +08:00
BUILTIN(__builtin___stpncpy_chk, "c*c*cC*zz", "nF")
Extend builtin "attribute" syntax to include a notation for printf-like functions, both builtin functions and those in the C library. The function-call checker now queries this attribute do determine if we have a printf-like function, rather than scanning through the list of "known functions IDs". However, there are 5 functions they are not yet "builtins", so the function-call checker handles them specifically still: - fprintf and vfprintf: the builtins mechanism cannot (yet) express FILE* arguments, so these can't be encoded. - NSLog: the builtins mechanism cannot (yet) express NSString* arguments, so this (and NSLogv) can't be encoded. - asprintf and vasprintf: these aren't part of the C99 standard library, so we really shouldn't be defining them as builtins in the general case (and we don't seem to have the machinery to make them builtins only on certain targets and depending on whether extensions are enabled). llvm-svn: 64512
2009-02-14 08:32:47 +08:00
BUILTIN(__builtin___snprintf_chk, "ic*zizcC*.", "Fp:4:")
BUILTIN(__builtin___sprintf_chk, "ic*izcC*.", "Fp:3:")
BUILTIN(__builtin___vsnprintf_chk, "ic*zizcC*a", "FP:4:")
BUILTIN(__builtin___vsprintf_chk, "ic*izcC*a", "FP:3:")
Make it possible for builtins to expression FILE* arguments, so that we can define builtins such as fprintf, vfprintf, and __builtin___fprintf_chk. Give a nice error message when we need to implicitly declare a function like fprintf. llvm-svn: 64526
2009-02-14 09:52:53 +08:00
BUILTIN(__builtin___fprintf_chk, "iP*icC*.", "Fp:2:")
BUILTIN(__builtin___printf_chk, "iicC*.", "Fp:1:")
BUILTIN(__builtin___vfprintf_chk, "iP*icC*a", "FP:2:")
BUILTIN(__builtin___vprintf_chk, "iicC*a", "FP:1:")
Round out object size checking builtins (fprintf ones disabled as we have no mapping to FILE*). We are also missing printf format attributes for the printf style ones. llvm-svn: 56168
2008-09-13 02:39:42 +08:00
add __builtin_unpredictable and convert to metadata This patch depends on r246688 (D12341). The goal is to make LLVM generate different code for these functions for a target that has cheap branches (see PR23827 for more details): int foo(); int normal(int x, int y, int z) { if (x != 0 && y != 0) return foo(); return 1; } int crazy(int x, int y) { if (__builtin_unpredictable(x != 0 && y != 0)) return foo(); return 1; } Differential Revision: http://reviews.llvm.org/D12458 llvm-svn: 246699
2015-09-03 04:01:30 +08:00
BUILTIN(__builtin_unpredictable, "LiLi" , "nc")
Fix the type of __builtin_expect, from Ed Schouten! llvm-svn: 85666
2009-11-01 00:04:14 +08:00
BUILTIN(__builtin_expect, "LiLiLi" , "nc")
fix a bogus "I" that I added to the per-function attribute list. llvm-svn: 115333
2010-10-02 03:47:04 +08:00
BUILTIN(__builtin_prefetch, "vvC*.", "nc")
Add __builtin_readcyclecounter() to produce the @llvm.readcyclecounter() intrinsic. llvm-svn: 161310
2012-08-06 06:03:08 +08:00
BUILTIN(__builtin_readcyclecounter, "ULLi", "n")
builtin_trap should be noreturn, this fixes PR5062, patch by Roman Divacky! llvm-svn: 82876
2009-09-27 05:16:00 +08:00
BUILTIN(__builtin_trap, "v", "nr")
remove noreturn attribute from __builtin_debugtrap llvm-svn: 166345
2012-10-20 06:21:42 +08:00
BUILTIN(__builtin_debugtrap, "v", "n")
Implement __builtin_unreachable(), a GCC 4.5 extension. llvm-svn: 82433
2009-09-21 11:09:59 +08:00
BUILTIN(__builtin_unreachable, "v", "nr")
Implementation of __builtin_shufflevector, a portable builtin capable of expressing the full flexibility of the LLVM shufflevector instruction. The expected immediate usage is in *mmintrin.h, so that they don't depend on the mess of gcc-inherited (and not completely implemented) shuffle builtins. llvm-svn: 51113
2008-05-15 03:38:39 +08:00
BUILTIN(__builtin_shufflevector, "v." , "nc")
Add the intrinsic __builtin_convertvector LLVM supports applying conversion instructions to vectors of the same number of elements (fptrunc, fptosi, etc.) but there had been no way for a Clang user to cause such instructions to be generated when using builtin vector types. C-style casting on vectors is already defined in terms of bitcasts, and so cannot be used for these conversions as well (without leading to a very confusing set of semantics). As a result, this adds a __builtin_convertvector intrinsic (patterned after the OpenCL __builtin_astype intrinsic). This is intended to aid the creation of vector intrinsic headers that create generic IR instead of target-dependent intrinsics (in other words, this is a generic _mm_cvtepi32_ps). As noted in the documentation, the action of __builtin_convertvector is defined in terms of the action of a C-style cast on each vector element. llvm-svn: 190915
2013-09-18 11:29:45 +08:00
BUILTIN(__builtin_convertvector, "v." , "nct")
Add some missing 'F' flags to libm/libc builtins. More discussion available in http://reviews.llvm.org/D9913 llvm-svn: 242675
2015-07-20 22:36:59 +08:00
BUILTIN(__builtin_alloca, "v*z" , "Fn")
Implement the __builtin_call_with_static_chain GNU extension. The extension has the following syntax: __builtin_call_with_static_chain(Call, Chain) where Call must be a function call expression and Chain must be of pointer type This extension performs a function call Call with a static chain pointer Chain passed to the callee in a designated register. This is useful for calling foreign language functions whose ABI uses static chain pointers (e.g. to implement closures). Differential Revision: http://reviews.llvm.org/D6332 llvm-svn: 224167
2014-12-13 07:41:25 +08:00
BUILTIN(__builtin_call_with_static_chain, "v.", "nt")
Teach clang the prototype for __builtin_alloca. llvm-svn: 44504
2007-12-02 13:42:36 +08:00
reimplement __sync_* builtins to be variadic and to follow the same semantic rules that gcc and icc use. This implements the variadic and concrete versions as builtins and has sema do the disambiguation. There are probably a bunch of details to finish up but this seems like a large monotonic step forward :) llvm-svn: 71212
2009-05-08 14:58:22 +08:00
// "Overloaded" Atomic operator builtins. These are overloaded to support data
// types of i8, i16, i32, i64, and i128. The front-end sees calls to the
// non-suffixed version of these (which has a bogus type) and transforms them to
// the right overloaded version in Sema (plus casts).
Implement __sync_{add,sub,and,or,xor}_and_fetch and __sync_bool_compare_and_swap. - <rdar://problem/6762223> [sema/irgen] support __sync_bool_compare_and_swap and __sync_add_and_fetch llvm-svn: 68482
2009-04-07 08:55:51 +08:00
reimplement __sync_* builtins to be variadic and to follow the same semantic rules that gcc and icc use. This implements the variadic and concrete versions as builtins and has sema do the disambiguation. There are probably a bunch of details to finish up but this seems like a large monotonic step forward :) llvm-svn: 71212
2009-05-08 14:58:22 +08:00
// FIXME: These assume that char -> i8, short -> i16, int -> i32,
// long long -> i64.
remove some incorrect and unimplemented atomic builtins (e.g. __sync_umin_and_fetch), add some missing atomic builtins (e.g. __sync_fetch_and_nand) and reorder the list to match the GCC documentation. The builtins still need work and codegen implementation, more patches coming. llvm-svn: 70985
2009-05-06 01:48:42 +08:00
Mark the overloaded atomic builtins as having custom type checking, which they do. This avoids all of the default argument promotions that we (1) don't want, and (2) undo during that custom type checking, and makes sure that we don't run into trouble during template instantiation. Fixes PR11320. llvm-svn: 144110
2011-11-09 03:45:38 +08:00
BUILTIN(__sync_fetch_and_add, "v.", "t")
BUILTIN(__sync_fetch_and_add_1, "ccD*c.", "nt")
BUILTIN(__sync_fetch_and_add_2, "ssD*s.", "nt")
BUILTIN(__sync_fetch_and_add_4, "iiD*i.", "nt")
BUILTIN(__sync_fetch_and_add_8, "LLiLLiD*LLi.", "nt")
BUILTIN(__sync_fetch_and_add_16, "LLLiLLLiD*LLLi.", "nt")
BUILTIN(__sync_fetch_and_sub, "v.", "t")
BUILTIN(__sync_fetch_and_sub_1, "ccD*c.", "nt")
BUILTIN(__sync_fetch_and_sub_2, "ssD*s.", "nt")
BUILTIN(__sync_fetch_and_sub_4, "iiD*i.", "nt")
BUILTIN(__sync_fetch_and_sub_8, "LLiLLiD*LLi.", "nt")
BUILTIN(__sync_fetch_and_sub_16, "LLLiLLLiD*LLLi.", "nt")
BUILTIN(__sync_fetch_and_or, "v.", "t")
BUILTIN(__sync_fetch_and_or_1, "ccD*c.", "nt")
BUILTIN(__sync_fetch_and_or_2, "ssD*s.", "nt")
BUILTIN(__sync_fetch_and_or_4, "iiD*i.", "nt")
BUILTIN(__sync_fetch_and_or_8, "LLiLLiD*LLi.", "nt")
BUILTIN(__sync_fetch_and_or_16, "LLLiLLLiD*LLLi.", "nt")
BUILTIN(__sync_fetch_and_and, "v.", "t")
BUILTIN(__sync_fetch_and_and_1, "ccD*c.", "tn")
BUILTIN(__sync_fetch_and_and_2, "ssD*s.", "tn")
BUILTIN(__sync_fetch_and_and_4, "iiD*i.", "tn")
BUILTIN(__sync_fetch_and_and_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_fetch_and_and_16, "LLLiLLLiD*LLLi.", "tn")
BUILTIN(__sync_fetch_and_xor, "v.", "t")
BUILTIN(__sync_fetch_and_xor_1, "ccD*c.", "tn")
BUILTIN(__sync_fetch_and_xor_2, "ssD*s.", "tn")
BUILTIN(__sync_fetch_and_xor_4, "iiD*i.", "tn")
BUILTIN(__sync_fetch_and_xor_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_fetch_and_xor_16, "LLLiLLLiD*LLLi.", "tn")
Add __sync_fetch_and_nand (again) Prior to GCC 4.4, __sync_fetch_and_nand was implemented as: { tmp = *ptr; *ptr = ~tmp & value; return tmp; } but this was changed in GCC 4.4 to be: { tmp = *ptr; *ptr = ~(tmp & value); return tmp; } in response to this change, support for sync_fetch_and_nand (and sync_nand_and_fetch) was removed in r99522 in order to avoid miscompiling code depending on the old semantics. However, at this point: 1. Many years have passed, and the amount of code relying on the old semantics is likely smaller. 2. Through the work of many contributors, all LLVM backends have been updated such that "atomicrmw nand" provides the newer GCC 4.4+ semantics (this process was complete July of 2014 (added to the release notes in r212635). 3. The lack of this intrinsic is now a needless impediment to porting codes from GCC to Clang (I've now seen several examples of this). It is true, however, that we still set GNUC_MINOR to 2 (corresponding to GCC 4.2). To compensate for this, and to address the original concern regarding code relying on the old semantics, I've added a warning that specifically details the fact that the semantics have changed and that we provide the newer semantics. Fixes PR8842. llvm-svn: 218905
2014-10-03 04:53:50 +08:00
BUILTIN(__sync_fetch_and_nand, "v.", "t")
BUILTIN(__sync_fetch_and_nand_1, "ccD*c.", "tn")
BUILTIN(__sync_fetch_and_nand_2, "ssD*s.", "tn")
BUILTIN(__sync_fetch_and_nand_4, "iiD*i.", "tn")
BUILTIN(__sync_fetch_and_nand_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_fetch_and_nand_16, "LLLiLLLiD*LLLi.", "tn")
Mark the overloaded atomic builtins as having custom type checking, which they do. This avoids all of the default argument promotions that we (1) don't want, and (2) undo during that custom type checking, and makes sure that we don't run into trouble during template instantiation. Fixes PR11320. llvm-svn: 144110
2011-11-09 03:45:38 +08:00
BUILTIN(__sync_add_and_fetch, "v.", "t")
BUILTIN(__sync_add_and_fetch_1, "ccD*c.", "tn")
BUILTIN(__sync_add_and_fetch_2, "ssD*s.", "tn")
BUILTIN(__sync_add_and_fetch_4, "iiD*i.", "tn")
BUILTIN(__sync_add_and_fetch_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_add_and_fetch_16, "LLLiLLLiD*LLLi.", "tn")
BUILTIN(__sync_sub_and_fetch, "v.", "t")
BUILTIN(__sync_sub_and_fetch_1, "ccD*c.", "tn")
BUILTIN(__sync_sub_and_fetch_2, "ssD*s.", "tn")
BUILTIN(__sync_sub_and_fetch_4, "iiD*i.", "tn")
BUILTIN(__sync_sub_and_fetch_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_sub_and_fetch_16, "LLLiLLLiD*LLLi.", "tn")
BUILTIN(__sync_or_and_fetch, "v.", "t")
BUILTIN(__sync_or_and_fetch_1, "ccD*c.", "tn")
BUILTIN(__sync_or_and_fetch_2, "ssD*s.", "tn")
BUILTIN(__sync_or_and_fetch_4, "iiD*i.", "tn")
BUILTIN(__sync_or_and_fetch_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_or_and_fetch_16, "LLLiLLLiD*LLLi.", "tn")
BUILTIN(__sync_and_and_fetch, "v.", "t")
BUILTIN(__sync_and_and_fetch_1, "ccD*c.", "tn")
BUILTIN(__sync_and_and_fetch_2, "ssD*s.", "tn")
BUILTIN(__sync_and_and_fetch_4, "iiD*i.", "tn")
BUILTIN(__sync_and_and_fetch_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_and_and_fetch_16, "LLLiLLLiD*LLLi.", "tn")
BUILTIN(__sync_xor_and_fetch, "v.", "t")
BUILTIN(__sync_xor_and_fetch_1, "ccD*c.", "tn")
BUILTIN(__sync_xor_and_fetch_2, "ssD*s.", "tn")
BUILTIN(__sync_xor_and_fetch_4, "iiD*i.", "tn")
BUILTIN(__sync_xor_and_fetch_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_xor_and_fetch_16, "LLLiLLLiD*LLLi.", "tn")
Add __sync_fetch_and_nand (again) Prior to GCC 4.4, __sync_fetch_and_nand was implemented as: { tmp = *ptr; *ptr = ~tmp & value; return tmp; } but this was changed in GCC 4.4 to be: { tmp = *ptr; *ptr = ~(tmp & value); return tmp; } in response to this change, support for sync_fetch_and_nand (and sync_nand_and_fetch) was removed in r99522 in order to avoid miscompiling code depending on the old semantics. However, at this point: 1. Many years have passed, and the amount of code relying on the old semantics is likely smaller. 2. Through the work of many contributors, all LLVM backends have been updated such that "atomicrmw nand" provides the newer GCC 4.4+ semantics (this process was complete July of 2014 (added to the release notes in r212635). 3. The lack of this intrinsic is now a needless impediment to porting codes from GCC to Clang (I've now seen several examples of this). It is true, however, that we still set GNUC_MINOR to 2 (corresponding to GCC 4.2). To compensate for this, and to address the original concern regarding code relying on the old semantics, I've added a warning that specifically details the fact that the semantics have changed and that we provide the newer semantics. Fixes PR8842. llvm-svn: 218905
2014-10-03 04:53:50 +08:00
BUILTIN(__sync_nand_and_fetch, "v.", "t")
BUILTIN(__sync_nand_and_fetch_1, "ccD*c.", "tn")
BUILTIN(__sync_nand_and_fetch_2, "ssD*s.", "tn")
BUILTIN(__sync_nand_and_fetch_4, "iiD*i.", "tn")
BUILTIN(__sync_nand_and_fetch_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_nand_and_fetch_16, "LLLiLLLiD*LLLi.", "tn")
Mark the overloaded atomic builtins as having custom type checking, which they do. This avoids all of the default argument promotions that we (1) don't want, and (2) undo during that custom type checking, and makes sure that we don't run into trouble during template instantiation. Fixes PR11320. llvm-svn: 144110
2011-11-09 03:45:38 +08:00
BUILTIN(__sync_bool_compare_and_swap, "v.", "t")
BUILTIN(__sync_bool_compare_and_swap_1, "bcD*cc.", "tn")
BUILTIN(__sync_bool_compare_and_swap_2, "bsD*ss.", "tn")
BUILTIN(__sync_bool_compare_and_swap_4, "biD*ii.", "tn")
BUILTIN(__sync_bool_compare_and_swap_8, "bLLiD*LLiLLi.", "tn")
BUILTIN(__sync_bool_compare_and_swap_16, "bLLLiD*LLLiLLLi.", "tn")
BUILTIN(__sync_val_compare_and_swap, "v.", "t")
BUILTIN(__sync_val_compare_and_swap_1, "ccD*cc.", "tn")
BUILTIN(__sync_val_compare_and_swap_2, "ssD*ss.", "tn")
BUILTIN(__sync_val_compare_and_swap_4, "iiD*ii.", "tn")
BUILTIN(__sync_val_compare_and_swap_8, "LLiLLiD*LLiLLi.", "tn")
BUILTIN(__sync_val_compare_and_swap_16, "LLLiLLLiD*LLLiLLLi.", "tn")
BUILTIN(__sync_lock_test_and_set, "v.", "t")
BUILTIN(__sync_lock_test_and_set_1, "ccD*c.", "tn")
BUILTIN(__sync_lock_test_and_set_2, "ssD*s.", "tn")
BUILTIN(__sync_lock_test_and_set_4, "iiD*i.", "tn")
BUILTIN(__sync_lock_test_and_set_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_lock_test_and_set_16, "LLLiLLLiD*LLLi.", "tn")
BUILTIN(__sync_lock_release, "v.", "t")
BUILTIN(__sync_lock_release_1, "vcD*.", "tn")
BUILTIN(__sync_lock_release_2, "vsD*.", "tn")
BUILTIN(__sync_lock_release_4, "viD*.", "tn")
BUILTIN(__sync_lock_release_8, "vLLiD*.", "tn")
BUILTIN(__sync_lock_release_16, "vLLLiD*.", "tn")
BUILTIN(__sync_swap, "v.", "t")
BUILTIN(__sync_swap_1, "ccD*c.", "tn")
BUILTIN(__sync_swap_2, "ssD*s.", "tn")
BUILTIN(__sync_swap_4, "iiD*i.", "tn")
BUILTIN(__sync_swap_8, "LLiLLiD*LLi.", "tn")
BUILTIN(__sync_swap_16, "LLLiLLLiD*LLLi.", "tn")
add a __sync_swap builtin to fill out the rest of the __sync builtins. Patch by Dave Zarzycki! llvm-svn: 129189
2011-04-09 11:57:26 +08:00
Implement support for 18 of the GNU-compatible __atomic builtins. This is not quite sufficient for libstdc++'s <atomic>: we still need __atomic_test_and_set and __atomic_clear, and may need a more complete __atomic_is_lock_free implementation. We are also missing an implementation of __atomic_always_lock_free, __atomic_nand_fetch, and __atomic_fetch_nand, but those aren't needed for libstdc++. llvm-svn: 154579
2012-04-12 13:08:17 +08:00
// Some of our atomics builtins are handled by AtomicExpr rather than
// as normal builtin CallExprs. This macro is used for such builtins.
#ifndef ATOMIC_BUILTIN
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) BUILTIN(ID, TYPE, ATTRS)
#endif
Provide, and document, a set of __c11_atomic_* intrinsics to implement C11's <stdatomic.h> header. In passing, fix LanguageExtensions to note that C11 and C++11 are no longer "upcoming standards" but are now actually standardized. llvm-svn: 154513
2012-04-12 01:55:32 +08:00
// C11 _Atomic operations for <stdatomic.h>.
Implement support for 18 of the GNU-compatible __atomic builtins. This is not quite sufficient for libstdc++'s <atomic>: we still need __atomic_test_and_set and __atomic_clear, and may need a more complete __atomic_is_lock_free implementation. We are also missing an implementation of __atomic_always_lock_free, __atomic_nand_fetch, and __atomic_fetch_nand, but those aren't needed for libstdc++. llvm-svn: 154579
2012-04-12 13:08:17 +08:00
ATOMIC_BUILTIN(__c11_atomic_init, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_load, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_store, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_exchange, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_compare_exchange_strong, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_compare_exchange_weak, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_fetch_add, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_fetch_sub, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_fetch_and, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_fetch_or, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_fetch_xor, "v.", "t")
Provide, and document, a set of __c11_atomic_* intrinsics to implement C11's <stdatomic.h> header. In passing, fix LanguageExtensions to note that C11 and C++11 are no longer "upcoming standards" but are now actually standardized. llvm-svn: 154513
2012-04-12 01:55:32 +08:00
BUILTIN(__c11_atomic_thread_fence, "vi", "n")
BUILTIN(__c11_atomic_signal_fence, "vi", "n")
BUILTIN(__c11_atomic_is_lock_free, "iz", "n")
Implement support for 18 of the GNU-compatible __atomic builtins. This is not quite sufficient for libstdc++'s <atomic>: we still need __atomic_test_and_set and __atomic_clear, and may need a more complete __atomic_is_lock_free implementation. We are also missing an implementation of __atomic_always_lock_free, __atomic_nand_fetch, and __atomic_fetch_nand, but those aren't needed for libstdc++. llvm-svn: 154579
2012-04-12 13:08:17 +08:00
// GNU atomic builtins.
ATOMIC_BUILTIN(__atomic_load, "v.", "t")
ATOMIC_BUILTIN(__atomic_load_n, "v.", "t")
ATOMIC_BUILTIN(__atomic_store, "v.", "t")
ATOMIC_BUILTIN(__atomic_store_n, "v.", "t")
ATOMIC_BUILTIN(__atomic_exchange, "v.", "t")
ATOMIC_BUILTIN(__atomic_exchange_n, "v.", "t")
ATOMIC_BUILTIN(__atomic_compare_exchange, "v.", "t")
ATOMIC_BUILTIN(__atomic_compare_exchange_n, "v.", "t")
ATOMIC_BUILTIN(__atomic_fetch_add, "v.", "t")
ATOMIC_BUILTIN(__atomic_fetch_sub, "v.", "t")
ATOMIC_BUILTIN(__atomic_fetch_and, "v.", "t")
ATOMIC_BUILTIN(__atomic_fetch_or, "v.", "t")
ATOMIC_BUILTIN(__atomic_fetch_xor, "v.", "t")
Implement __atomic_fetch_nand and __atomic_nand_fetch to complete our set of GNU __atomic builtins. llvm-svn: 154659
2012-04-13 14:31:38 +08:00
ATOMIC_BUILTIN(__atomic_fetch_nand, "v.", "t")
Implement support for 18 of the GNU-compatible __atomic builtins. This is not quite sufficient for libstdc++'s <atomic>: we still need __atomic_test_and_set and __atomic_clear, and may need a more complete __atomic_is_lock_free implementation. We are also missing an implementation of __atomic_always_lock_free, __atomic_nand_fetch, and __atomic_fetch_nand, but those aren't needed for libstdc++. llvm-svn: 154579
2012-04-12 13:08:17 +08:00
ATOMIC_BUILTIN(__atomic_add_fetch, "v.", "t")
ATOMIC_BUILTIN(__atomic_sub_fetch, "v.", "t")
ATOMIC_BUILTIN(__atomic_and_fetch, "v.", "t")
ATOMIC_BUILTIN(__atomic_or_fetch, "v.", "t")
ATOMIC_BUILTIN(__atomic_xor_fetch, "v.", "t")
Implement __atomic_fetch_nand and __atomic_nand_fetch to complete our set of GNU __atomic builtins. llvm-svn: 154659
2012-04-13 14:31:38 +08:00
ATOMIC_BUILTIN(__atomic_nand_fetch, "v.", "t")
Implement the missing pieces needed to support libstdc++4.7's <atomic>: __atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_* predefined macros. Implement library fallback for __atomic_is_lock_free and __c11_atomic_is_lock_free, and implement __atomic_always_lock_free. Contrary to their documentation, GCC's __atomic_fetch_add family don't multiply the operand by sizeof(T) when operating on a pointer type. libstdc++ relies on this quirk. Remove this handling for all but the __c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins. Contrary to their documentation, __atomic_test_and_set and __atomic_clear take a first argument of type 'volatile void *', not 'void *' or 'bool *', and __atomic_is_lock_free and __atomic_always_lock_free have an argument of type 'const volatile void *', not 'void *'. With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite, except for a couple of libstdc++ bugs and some cases where libc++'s test suite tests for properties which implementations have latitude to vary. llvm-svn: 154640
2012-04-13 08:45:38 +08:00
BUILTIN(__atomic_test_and_set, "bvD*i", "n")
BUILTIN(__atomic_clear, "vvD*i", "n")
Misc fixes for atomics. Biggest fix is doing alignment correctly for _Atomic types. llvm-svn: 142002
2011-10-15 04:59:01 +08:00
BUILTIN(__atomic_thread_fence, "vi", "n")
BUILTIN(__atomic_signal_fence, "vi", "n")
Implement the missing pieces needed to support libstdc++4.7's <atomic>: __atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_* predefined macros. Implement library fallback for __atomic_is_lock_free and __c11_atomic_is_lock_free, and implement __atomic_always_lock_free. Contrary to their documentation, GCC's __atomic_fetch_add family don't multiply the operand by sizeof(T) when operating on a pointer type. libstdc++ relies on this quirk. Remove this handling for all but the __c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins. Contrary to their documentation, __atomic_test_and_set and __atomic_clear take a first argument of type 'volatile void *', not 'void *' or 'bool *', and __atomic_is_lock_free and __atomic_always_lock_free have an argument of type 'const volatile void *', not 'void *'. With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite, except for a couple of libstdc++ bugs and some cases where libc++'s test suite tests for properties which implementations have latitude to vary. llvm-svn: 154640
2012-04-13 08:45:38 +08:00
BUILTIN(__atomic_always_lock_free, "izvCD*", "n")
BUILTIN(__atomic_is_lock_free, "izvCD*", "n")
Implement support for 18 of the GNU-compatible __atomic builtins. This is not quite sufficient for libstdc++'s <atomic>: we still need __atomic_test_and_set and __atomic_clear, and may need a more complete __atomic_is_lock_free implementation. We are also missing an implementation of __atomic_always_lock_free, __atomic_nand_fetch, and __atomic_fetch_nand, but those aren't needed for libstdc++. llvm-svn: 154579
2012-04-12 13:08:17 +08:00
#undef ATOMIC_BUILTIN
reimplement __sync_* builtins to be variadic and to follow the same semantic rules that gcc and icc use. This implements the variadic and concrete versions as builtins and has sema do the disambiguation. There are probably a bunch of details to finish up but this seems like a large monotonic step forward :) llvm-svn: 71212
2009-05-08 14:58:22 +08:00
// Non-overloaded atomic builtins.
BUILTIN(__sync_synchronize, "v.", "n")
// GCC does not support these, they are a Clang extension.
Make the pointer arguments to the __sync_* builtins pointers to volatile-qualified types. Fixes <rdar://problem/8228293>. llvm-svn: 109618
2010-07-29 02:42:27 +08:00
BUILTIN(__sync_fetch_and_min, "iiD*i", "n")
BUILTIN(__sync_fetch_and_max, "iiD*i", "n")
BUILTIN(__sync_fetch_and_umin, "UiUiD*Ui", "n")
BUILTIN(__sync_fetch_and_umax, "UiUiD*Ui", "n")
Make llvm memory barrier available as an intrinsic llvm-svn: 57751
2008-10-18 10:49:28 +08:00
add __builtin_[r]index. Perhaps all LIBBUILTIN's should get these or something? llvm-svn: 101858
2010-04-20 09:31:15 +08:00
// Random libc builtins.
BUILTIN(__builtin_abort, "v", "Fnr")
BUILTIN(__builtin_index, "c*cC*i", "Fn")
BUILTIN(__builtin_rindex, "c*cC*i", "Fn")
Only provide MS builtins when -fms-extensions is on We already have builtins that are only available in GNU mode, so this mirrors that. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2128 llvm-svn: 194615
2013-11-14 06:47:22 +08:00
// Microsoft builtins. These are only active with -fms-extensions.
Initial support for Win64 SEH IR emission The lowering looks a lot like normal EH lowering, with the exception that the exceptions are caught by executing filter expression code instead of matching typeinfo globals. The filter expressions are outlined into functions which are used in landingpad clauses where typeinfo would normally go. Major aspects that still need work: - Non-call exceptions in __try bodies won't work yet. The plan is to outline the __try block in the frontend to keep things simple. - Filter expressions cannot use local variables until capturing is implemented. - __finally blocks will not run after exceptions. Fixing this requires work in the LLVM SEH preparation pass. The IR lowering looks like this: // C code: bool safe_div(int n, int d, int *r) { __try { *r = normal_div(n, d); } __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) { return false; } return true; } ; LLVM IR: define i32 @filter(i8* %e, i8* %fp) { %ehptrs = bitcast i8* %e to i32** %ehrec = load i32** %ehptrs %code = load i32* %ehrec %matches = icmp eq i32 %code, i32 u0xC0000094 %matches.i32 = zext i1 %matches to i32 ret i32 %matches.i32 } define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) { %rr = invoke i32 @normal_div(i32 %n, i32 %d) to label %normal unwind to label %lpad normal: store i32 %rr, i32* %r ret i1 1 lpad: %ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*) %ehptr = extractvalue {i8*, i32} %ehvals, i32 0 %sel = extractvalue {i8*, i32} %ehvals, i32 1 %filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*)) %matches = icmp eq i32 %sel, %filter_sel br i1 %matches, label %eh.except, label %eh.resume eh.except: ret i1 false eh.resume: resume } Reviewers: rjmccall, rsmith, majnemer Differential Revision: http://reviews.llvm.org/D5607 llvm-svn: 226760
2015-01-22 09:36:17 +08:00
LANGBUILTIN(_alloca, "v*z", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(__assume, "vb", "n", ALL_MS_LANGUAGES)
Add some MS aliases for existing intrinsics Reviewers: thakis, compnerd, majnemer, rsmith, rnk Subscribers: alexshap, cfe-commits Differential Revision: https://reviews.llvm.org/D24330 llvm-svn: 281540
2016-09-15 05:19:43 +08:00
LIBBUILTIN(_byteswap_ushort, "UsUs", "fnc", "stdlib.h", ALL_MS_LANGUAGES)
LIBBUILTIN(_byteswap_ulong, "ULiULi", "fnc", "stdlib.h", ALL_MS_LANGUAGES)
LIBBUILTIN(_byteswap_uint64, "ULLiULLi", "fnc", "stdlib.h", ALL_MS_LANGUAGES)
Basic: Re-sort these builtins No functional change, it just makes it a little easier to find what you are looking for. llvm-svn: 227425
2015-01-29 17:29:17 +08:00
LANGBUILTIN(__debugbreak, "v", "n", ALL_MS_LANGUAGES)
Initial support for Win64 SEH IR emission The lowering looks a lot like normal EH lowering, with the exception that the exceptions are caught by executing filter expression code instead of matching typeinfo globals. The filter expressions are outlined into functions which are used in landingpad clauses where typeinfo would normally go. Major aspects that still need work: - Non-call exceptions in __try bodies won't work yet. The plan is to outline the __try block in the frontend to keep things simple. - Filter expressions cannot use local variables until capturing is implemented. - __finally blocks will not run after exceptions. Fixing this requires work in the LLVM SEH preparation pass. The IR lowering looks like this: // C code: bool safe_div(int n, int d, int *r) { __try { *r = normal_div(n, d); } __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) { return false; } return true; } ; LLVM IR: define i32 @filter(i8* %e, i8* %fp) { %ehptrs = bitcast i8* %e to i32** %ehrec = load i32** %ehptrs %code = load i32* %ehrec %matches = icmp eq i32 %code, i32 u0xC0000094 %matches.i32 = zext i1 %matches to i32 ret i32 %matches.i32 } define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) { %rr = invoke i32 @normal_div(i32 %n, i32 %d) to label %normal unwind to label %lpad normal: store i32 %rr, i32* %r ret i1 1 lpad: %ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*) %ehptr = extractvalue {i8*, i32} %ehvals, i32 0 %sel = extractvalue {i8*, i32} %ehvals, i32 1 %filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*)) %matches = icmp eq i32 %sel, %filter_sel br i1 %matches, label %eh.except, label %eh.resume eh.except: ret i1 false eh.resume: resume } Reviewers: rjmccall, rsmith, majnemer Differential Revision: http://reviews.llvm.org/D5607 llvm-svn: 226760
2015-01-22 09:36:17 +08:00
LANGBUILTIN(__exception_code, "ULi", "n", ALL_MS_LANGUAGES)
Basic: Re-sort these builtins No functional change, it just makes it a little easier to find what you are looking for. llvm-svn: 227425
2015-01-29 17:29:17 +08:00
LANGBUILTIN(_exception_code, "ULi", "n", ALL_MS_LANGUAGES)
Initial support for Win64 SEH IR emission The lowering looks a lot like normal EH lowering, with the exception that the exceptions are caught by executing filter expression code instead of matching typeinfo globals. The filter expressions are outlined into functions which are used in landingpad clauses where typeinfo would normally go. Major aspects that still need work: - Non-call exceptions in __try bodies won't work yet. The plan is to outline the __try block in the frontend to keep things simple. - Filter expressions cannot use local variables until capturing is implemented. - __finally blocks will not run after exceptions. Fixing this requires work in the LLVM SEH preparation pass. The IR lowering looks like this: // C code: bool safe_div(int n, int d, int *r) { __try { *r = normal_div(n, d); } __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) { return false; } return true; } ; LLVM IR: define i32 @filter(i8* %e, i8* %fp) { %ehptrs = bitcast i8* %e to i32** %ehrec = load i32** %ehptrs %code = load i32* %ehrec %matches = icmp eq i32 %code, i32 u0xC0000094 %matches.i32 = zext i1 %matches to i32 ret i32 %matches.i32 } define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) { %rr = invoke i32 @normal_div(i32 %n, i32 %d) to label %normal unwind to label %lpad normal: store i32 %rr, i32* %r ret i1 1 lpad: %ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*) %ehptr = extractvalue {i8*, i32} %ehvals, i32 0 %sel = extractvalue {i8*, i32} %ehvals, i32 1 %filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*)) %matches = icmp eq i32 %sel, %filter_sel br i1 %matches, label %eh.except, label %eh.resume eh.except: ret i1 false eh.resume: resume } Reviewers: rjmccall, rsmith, majnemer Differential Revision: http://reviews.llvm.org/D5607 llvm-svn: 226760
2015-01-22 09:36:17 +08:00
LANGBUILTIN(__exception_info, "v*", "n", ALL_MS_LANGUAGES)
Basic: Re-sort these builtins No functional change, it just makes it a little easier to find what you are looking for. llvm-svn: 227425
2015-01-29 17:29:17 +08:00
LANGBUILTIN(_exception_info, "v*", "n", ALL_MS_LANGUAGES)
Implement IRGen for SEH __finally and AbnormalTermination Previously we would simply double-emit the body of the __finally block, but that doesn't work when it contains any kind of Decl, which we can't double emit. This fixes that by emitting the block once and branching into a shared code region and then branching back out. llvm-svn: 228222
2015-02-05 06:37:07 +08:00
LANGBUILTIN(__abnormal_termination, "i", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_abnormal_termination, "i", "n", ALL_MS_LANGUAGES)
MS ABI: Implement __GetExceptionInfo for std::make_exception_ptr std::make_exception_ptr calls std::__GetExceptionInfo in order to figure out how to properly copy the exception object. Differential Revision: http://reviews.llvm.org/D8280 llvm-svn: 232188
2015-03-14 02:26:17 +08:00
LANGBUILTIN(__GetExceptionInfo, "v*.", "ntu", ALL_MS_LANGUAGES)
Add bunch of _Interlocked builtins Reviewers: compnerd, thakis, Prazek, majnemer, rnk Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D24153 llvm-svn: 281378
2016-09-14 03:43:33 +08:00
LANGBUILTIN(_InterlockedAnd8, "ccD*c", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedAnd16, "ssD*s", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedAnd, "LiLiD*Li", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedCompareExchange8, "ccD*cc", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedCompareExchange16, "ssD*ss", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedCompareExchange, "LiLiD*LiLi", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedCompareExchange64, "LLiLLiD*LLiLLi", "n", ALL_MS_LANGUAGES)
CodeGen: improve ms instrincics support Add support for _InterlockedCompareExchangePointer, _InterlockExchangePointer, _InterlockExchange. These are available as a compiler intrinsic on ARM and x86. These are used directly by the Windows SDK headers without use of the intrin header. llvm-svn: 211216
2014-06-19 04:51:10 +08:00
LANGBUILTIN(_InterlockedCompareExchangePointer, "v*v*D*v*v*", "n", ALL_MS_LANGUAGES)
Add bunch of _Interlocked builtins Reviewers: compnerd, thakis, Prazek, majnemer, rnk Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D24153 llvm-svn: 281378
2016-09-14 03:43:33 +08:00
LANGBUILTIN(_InterlockedDecrement16, "ssD*", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedDecrement, "LiLiD*", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchange, "LiLiD*Li", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchange8, "ccD*c", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchange16, "ssD*s", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangeAdd8, "ccD*c", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangeAdd16, "ssD*s", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangeAdd, "LiLiD*Li", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangePointer, "v*v*D*v*", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangeSub8, "ccD*c", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangeSub16, "ssD*s", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedExchangeSub, "LiLiD*Li", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedIncrement16, "ssD*", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedIncrement, "LiLiD*", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedOr8, "ccD*c", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedOr16, "ssD*s", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedOr, "LiLiD*Li", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedXor8, "ccD*c", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedXor16, "ssD*s", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_InterlockedXor, "LiLiD*Li", "n", ALL_MS_LANGUAGES)
Basic: Re-sort these builtins No functional change, it just makes it a little easier to find what you are looking for. llvm-svn: 227425
2015-01-29 17:29:17 +08:00
LANGBUILTIN(__noop, "i.", "n", ALL_MS_LANGUAGES)
Add some MS aliases for existing intrinsics Reviewers: thakis, compnerd, majnemer, rsmith, rnk Subscribers: alexshap, cfe-commits Differential Revision: https://reviews.llvm.org/D24330 llvm-svn: 281540
2016-09-15 05:19:43 +08:00
LANGBUILTIN(__popcnt16, "UsUs", "nc", ALL_MS_LANGUAGES)
LANGBUILTIN(__popcnt, "UiUi", "nc", ALL_MS_LANGUAGES)
LANGBUILTIN(__popcnt64, "ULLiULLi", "nc", ALL_MS_LANGUAGES)
Basic: Re-sort these builtins No functional change, it just makes it a little easier to find what you are looking for. llvm-svn: 227425
2015-01-29 17:29:17 +08:00
LANGBUILTIN(__readfsdword, "ULiULi", "n", ALL_MS_LANGUAGES)
Implement MS _rot intrinsics Reviewers: thakis, Prazek, compnerd, rnk Subscribers: majnemer, cfe-commits Differential Revision: https://reviews.llvm.org/D24311 llvm-svn: 280997
2016-09-09 06:32:19 +08:00
LANGBUILTIN(_rotl8, "UcUcUc", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotl16, "UsUsUc", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotl, "UiUii", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_lrotl, "ULiULii", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotl64, "ULLiULLii", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotr8, "UcUcUc", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotr16, "UsUsUc", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotr, "UiUii", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_lrotr, "ULiULii", "n", ALL_MS_LANGUAGES)
LANGBUILTIN(_rotr64, "ULLiULLii", "n", ALL_MS_LANGUAGES)
Basic: Re-sort these builtins No functional change, it just makes it a little easier to find what you are looking for. llvm-svn: 227425
2015-01-29 17:29:17 +08:00
LANGBUILTIN(__va_start, "vc**.", "nt", ALL_MS_LANGUAGES)
add __builtin_[r]index. Perhaps all LIBBUILTIN's should get these or something? llvm-svn: 101858
2010-04-20 09:31:15 +08:00
MS ABI: Implement proper support for setjmp On targets which use the MSVCRT, setjmp is a macro which expands to _setjmp or _setjmpex. _setjmp and _setjmpex have a secret, hidden argument which is not listed in the function prototype on X64 and WoA. This hidden argument always seems to be the frame pointer. _setjmpex isn't used on X86, _setjmp is magically replaced with a call to _setjmp3. The second argument is zero for 'normal' setjmp/longjmp pairs, otherwise it is a count of additional variadic arguments. This is used when setjmp appears inside of a try or __try. It is not safe to use a pointer to setjmp because _setjmp, _setjmpex and _setmp3 are not compatible with setjmp. llvm-svn: 227426
2015-01-29 17:29:21 +08:00
// Microsoft library builtins.
LIBBUILTIN(_setjmpex, "iJ", "fj", "setjmpex.h", ALL_MS_LANGUAGES)
Clean up builtin lists, add a few new builtins. (I re-sorted the string.h builtins to be in the same order as the list in the C99 standard.) llvm-svn: 72882
2009-06-05 03:35:30 +08:00
// C99 library functions
// C99 stdlib.h
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(abort, "v", "fr", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(calloc, "v*zz", "f", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(exit, "vi", "fr", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(_Exit, "vi", "fr", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(malloc, "v*z", "f", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(realloc, "v*v*z", "f", "stdlib.h", ALL_LANGUAGES)
Clean up builtin lists, add a few new builtins. (I re-sorted the string.h builtins to be in the same order as the list in the C99 standard.) llvm-svn: 72882
2009-06-05 03:35:30 +08:00
// C99 string.h
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(memcpy, "v*v*vC*z", "f", "string.h", ALL_LANGUAGES)
Use Builtin ID as the return value for FunctionDecl::getMemoryFunctionKind(). This is a follow up on the Chris's review for r148142: We don't want to pollute FunctionDecl with an extra enum. (To make this work, added memcmp and family to the library builtins.) llvm-svn: 148267
2012-01-17 08:37:07 +08:00
LIBBUILTIN(memcmp, "ivC*vC*z", "f", "string.h", ALL_LANGUAGES)
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(memmove, "v*v*vC*z", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strcpy, "c*c*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strncpy, "c*c*cC*z", "f", "string.h", ALL_LANGUAGES)
Use Builtin ID as the return value for FunctionDecl::getMemoryFunctionKind(). This is a follow up on the Chris's review for r148142: We don't want to pollute FunctionDecl with an extra enum. (To make this work, added memcmp and family to the library builtins.) llvm-svn: 148267
2012-01-17 08:37:07 +08:00
LIBBUILTIN(strcmp, "icC*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strncmp, "icC*cC*z", "f", "string.h", ALL_LANGUAGES)
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(strcat, "c*c*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strncat, "c*c*cC*z", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strxfrm, "zc*cC*z", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(memchr, "v*vC*iz", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strchr, "c*cC*i", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strcspn, "zcC*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strpbrk, "c*cC*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strrchr, "c*cC*i", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strspn, "zcC*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strstr, "c*cC*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strtok, "c*c*cC*", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(memset, "v*v*iz", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strerror, "c*i", "f", "string.h", ALL_LANGUAGES)
LIBBUILTIN(strlen, "zcC*", "f", "string.h", ALL_LANGUAGES)
Clean up builtin lists, add a few new builtins. (I re-sorted the string.h builtins to be in the same order as the list in the C99 standard.) llvm-svn: 72882
2009-06-05 03:35:30 +08:00
// C99 stdio.h
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(printf, "icC*.", "fp:0:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(fprintf, "iP*cC*.", "fp:1:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(snprintf, "ic*zcC*.", "fp:2:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(sprintf, "ic*cC*.", "fp:1:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vprintf, "icC*a", "fP:0:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vfprintf, "i.", "fP:1:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vsnprintf, "ic*zcC*a", "fP:2:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vsprintf, "ic*cC*a", "fP:1:", "stdio.h", ALL_LANGUAGES)
Add ability to specifiy 'restrict' on parameters of builtins, and correct this oversight for scanf functions. llvm-svn: 148573
2012-01-21 05:40:12 +08:00
LIBBUILTIN(scanf, "icC*R.", "fs:0:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(fscanf, "iP*RcC*R.", "fs:1:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(sscanf, "icC*RcC*R.", "fs:1:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vscanf, "icC*Ra", "fS:0:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vfscanf, "iP*RcC*Ra", "fS:1:", "stdio.h", ALL_LANGUAGES)
LIBBUILTIN(vsscanf, "icC*RcC*Ra", "fS:1:", "stdio.h", ALL_LANGUAGES)
Add the Pure attribute to C99 builtin functions from ctype.h. This is a corrected version of r266199 with test case fixes. Patch by Taewook Oh. llvm-svn: 268553
2016-05-05 05:08:13 +08:00
// C99 ctype.h
LIBBUILTIN(isalnum, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isalpha, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isblank, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(iscntrl, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isdigit, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isgraph, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(islower, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isprint, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(ispunct, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isspace, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isupper, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(isxdigit, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(tolower, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
LIBBUILTIN(toupper, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
// C99
Move comment back to being next to the thing it's describing. llvm-svn: 206320
2014-04-16 04:27:15 +08:00
// In some systems setjmp is a macro that expands to _setjmp. We undefine
// it here to avoid having two identical LIBBUILTIN entries.
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
#undef setjmp
LIBBUILTIN(setjmp, "iJ", "fj", "setjmp.h", ALL_LANGUAGES)
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(longjmp, "vJi", "fr", "setjmp.h", ALL_LANGUAGES)
Extend builtin "attribute" syntax to include a notation for printf-like functions, both builtin functions and those in the C library. The function-call checker now queries this attribute do determine if we have a printf-like function, rather than scanning through the list of "known functions IDs". However, there are 5 functions they are not yet "builtins", so the function-call checker handles them specifically still: - fprintf and vfprintf: the builtins mechanism cannot (yet) express FILE* arguments, so these can't be encoded. - NSLog: the builtins mechanism cannot (yet) express NSString* arguments, so this (and NSLogv) can't be encoded. - asprintf and vasprintf: these aren't part of the C99 standard library, so we really shouldn't be defining them as builtins in the general case (and we don't seem to have the machinery to make them builtins only on certain targets and depending on whether extensions are enabled). llvm-svn: 64512
2009-02-14 08:32:47 +08:00
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
// Non-C library functions, active in GNU mode only.
Re-enable several builtins in non-gnu modes. This is a partial revert of 183015. By not recognizing things like _setjmp we lose (returns_twice) attribute on them, which leads to incorrect code generation. Fixes PR16138. llvm-svn: 206362
2014-04-16 16:06:33 +08:00
// Functions with (returns_twice) attribute (marked as "j") are still active in
// all languages, because losing this attribute would result in miscompilation
// when these functions are used in non-GNU mode. PR16138.
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(alloca, "v*z", "f", "stdlib.h", ALL_GNU_LANGUAGES)
PR3443: Add stpcpy builtin (plus a few other related builtins). Yes, we're still missing a mechanism to disable these in strict mode, but that's not a new issue. llvm-svn: 72936
2009-06-05 16:20:10 +08:00
// POSIX string.h
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(stpcpy, "c*c*cC*", "f", "string.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(stpncpy, "c*c*cC*z", "f", "string.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(strdup, "c*cC*", "f", "string.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(strndup, "c*cC*z", "f", "string.h", ALL_GNU_LANGUAGES)
Clean up builtin lists, add a few new builtins. (I re-sorted the string.h builtins to be in the same order as the list in the C99 standard.) llvm-svn: 72882
2009-06-05 03:35:30 +08:00
// POSIX strings.h
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(index, "c*cC*i", "f", "strings.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(rindex, "c*cC*i", "f", "strings.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(bzero, "vv*z", "f", "strings.h", ALL_GNU_LANGUAGES)
Fix compilation with mingw-w64. llvm-svn: 155904
2012-05-01 16:38:19 +08:00
// In some systems str[n]casejmp is a macro that expands to _str[n]icmp.
// We undefine then here to avoid wrong name.
#undef strcasecmp
#undef strncasecmp
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(strcasecmp, "icC*cC*", "f", "strings.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(strncasecmp, "icC*cC*z", "f", "strings.h", ALL_GNU_LANGUAGES)
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
// POSIX unistd.h
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(_exit, "vi", "fr", "unistd.h", ALL_GNU_LANGUAGES)
Re-enable several builtins in non-gnu modes. This is a partial revert of 183015. By not recognizing things like _setjmp we lose (returns_twice) attribute on them, which leads to incorrect code generation. Fixes PR16138. llvm-svn: 206362
2014-04-16 16:06:33 +08:00
LIBBUILTIN(vfork, "p", "fj", "unistd.h", ALL_LANGUAGES)
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
// POSIX setjmp.h
Add returns_twice to functions that are known to return twice. This implements the same behavior of gcc by keeping the attribute out of the function type. llvm-svn: 141803
2011-10-13 03:51:18 +08:00
Re-enable several builtins in non-gnu modes. This is a partial revert of 183015. By not recognizing things like _setjmp we lose (returns_twice) attribute on them, which leads to incorrect code generation. Fixes PR16138. llvm-svn: 206362
2014-04-16 16:06:33 +08:00
LIBBUILTIN(_setjmp, "iJ", "fj", "setjmp.h", ALL_LANGUAGES)
LIBBUILTIN(__sigsetjmp, "iSJi", "fj", "setjmp.h", ALL_LANGUAGES)
LIBBUILTIN(sigsetjmp, "iSJi", "fj", "setjmp.h", ALL_LANGUAGES)
LIBBUILTIN(setjmp_syscall, "iJ", "fj", "setjmp.h", ALL_LANGUAGES)
LIBBUILTIN(savectx, "iJ", "fj", "setjmp.h", ALL_LANGUAGES)
LIBBUILTIN(qsetjmp, "iJ", "fj", "setjmp.h", ALL_LANGUAGES)
LIBBUILTIN(getcontext, "iK*", "fj", "setjmp.h", ALL_LANGUAGES)
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(_longjmp, "vJi", "fr", "setjmp.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(siglongjmp, "vSJi", "fr", "setjmp.h", ALL_GNU_LANGUAGES)
Reapply r137903, but fix the definition of size_t in the test case to use __SIZE_TYPE__ (and hence be portable). Also, change the warning to -Wstrl-incorrect-size. llvm-svn: 137980
2011-08-19 04:55:45 +08:00
// non-standard but very common
Disable non-standard library builtins in non-gnu language modes. Fixes PR16138. llvm-svn: 183015
2013-06-01 00:29:28 +08:00
LIBBUILTIN(strlcpy, "zc*cC*z", "f", "string.h", ALL_GNU_LANGUAGES)
LIBBUILTIN(strlcat, "zc*cC*z", "f", "string.h", ALL_GNU_LANGUAGES)
Restore patch reversed in r118475. Fixes // rdar://8632525 llvm-svn: 118634
2010-11-10 05:38:20 +08:00
// id objc_msgSend(id, SEL, ...)
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(objc_msgSend, "GGH.", "f", "objc/message.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// long double objc_msgSend_fpret(id self, SEL op, ...)
LIBBUILTIN(objc_msgSend_fpret, "LdGH.", "f", "objc/message.h", OBJC_LANG)
In x86_64, when calling an Objective-C method that returns a _Complex long double, make sure to use the objc_msgSend_fp2ret function which ensures that the return value will be {0, 0} if the receiver is nil. llvm-svn: 143350
2011-11-01 00:27:11 +08:00
// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
LIBBUILTIN(objc_msgSend_fp2ret, "XLdGH.", "f", "objc/message.h", OBJC_LANG)
Fix up various builtin declaration of objc_msgSend families to match those foung in objc.h an avoid spurious warnings. // rdar://12489098 llvm-svn: 171492
2013-01-05 02:45:40 +08:00
// void objc_msgSend_stret (id, SEL, ...)
LIBBUILTIN(objc_msgSend_stret, "vGH.", "f", "objc/message.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
Fix up various builtin declaration of objc_msgSend families to match those foung in objc.h an avoid spurious warnings. // rdar://12489098 llvm-svn: 171492
2013-01-05 02:45:40 +08:00
LIBBUILTIN(objc_msgSendSuper, "GM*H.", "f", "objc/message.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// void objc_msgSendSuper_stret(struct objc_super *super, SEL op, ...)
Fix up various builtin declaration of objc_msgSend families to match those foung in objc.h an avoid spurious warnings. // rdar://12489098 llvm-svn: 171492
2013-01-05 02:45:40 +08:00
LIBBUILTIN(objc_msgSendSuper_stret, "vM*H.", "f", "objc/message.h", OBJC_LANG)
Add objc_getClass as an objc builtin function (// rdar://8592641). Also rename LANGUAGEID to LanguageID. llvm-svn: 120437
2010-12-01 02:25:34 +08:00
// id objc_getClass(const char *name)
LIBBUILTIN(objc_getClass, "GcC*", "f", "objc/runtime.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_getMetaClass(const char *name)
LIBBUILTIN(objc_getMetaClass, "GcC*", "f", "objc/runtime.h", OBJC_LANG)
// void objc_enumerationMutation(id)
LIBBUILTIN(objc_enumerationMutation, "vG", "f", "objc/runtime.h", OBJC_LANG)
// id objc_read_weak(id *location)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_read_weak, "GG*", "f", "objc/objc-auto.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_assign_weak(id value, id *location)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_assign_weak, "GGG*", "f", "objc/objc-auto.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_assign_ivar(id value, id dest, ptrdiff_t offset)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_assign_ivar, "GGGY", "f", "objc/objc-auto.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_assign_global(id val, id *dest)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_assign_global, "GGG*", "f", "objc/objc-auto.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_assign_strongCast(id val, id *dest
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_assign_strongCast, "GGG*", "f", "objc/objc-auto.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// id objc_exception_extract(void *localExceptionData)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_exception_extract, "Gv*", "f", "objc/objc-exception.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// void objc_exception_try_enter(void *localExceptionData)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_exception_try_enter, "vv*", "f", "objc/objc-exception.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// void objc_exception_try_exit(void *localExceptionData)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_exception_try_exit, "vv*", "f", "objc/objc-exception.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// int objc_exception_match(Class exceptionClass, id exception)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_exception_match, "iGG", "f", "objc/objc-exception.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// void objc_exception_throw(id exception)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_exception_throw, "vG", "f", "objc/objc-exception.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// int objc_sync_enter(id obj)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_sync_enter, "iG", "f", "objc/objc-sync.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
// int objc_sync_exit(id obj)
Remove trailing slash in front of header name of ObjC builtins. llvm-svn: 148872
2012-01-25 06:29:27 +08:00
LIBBUILTIN(objc_sync_exit, "iG", "f", "objc/objc-sync.h", OBJC_LANG)
Added remaining objective-c library builtins (as in gcc) to clang. // rdar://8735023 llvm-svn: 121441
2010-12-10 08:39:16 +08:00
Fixed conflict between objc_memmove_collectable builtin decl. and one ddefined in darwin header file. llvm-svn: 106107
2010-06-17 00:22:04 +08:00
BUILTIN(__builtin_objc_memmove_collectable, "v*v*vC*z", "nF")
Add implicit definition of objc_msgSend. - As with malloc and friends, this is important where the return type on a 64-bit platform would otherwise end up discarding the upper 32-bits. llvm-svn: 69874
2009-04-23 15:00:09 +08:00
Replace a hack to handle NSLog/NSLogv in sema by declaring them as Library Builtins. llvm-svn: 148873
2012-01-25 06:32:46 +08:00
// void NSLog(NSString *fmt, ...)
LIBBUILTIN(NSLog, "vG.", "fp:0:", "Foundation/NSObjCRuntime.h", OBJC_LANG)
// void NSLogv(NSString *fmt, va_list args)
LIBBUILTIN(NSLogv, "vGa", "fP:0:", "Foundation/NSObjCRuntime.h", OBJC_LANG)
Support IRgen of sqrt -> llvm.sqrt, pow -> llvm.pow. - Define pow[lf]?, sqrt[lf]? as builtins. - Add -fmath-errno option which binds to LangOptions.MathErrno - Add new builtin flag Builtin::Context::isConstWithoutErrno for functions which can be marked as const if errno isn't respected for math functions. Sema automatically marks these functions as const when they are defined, if MathErrno=0. - IRgen uses const attribute on sqrt and pow library functions to decide if it can use the llvm intrinsic. llvm-svn: 64689
2009-02-17 06:43:43 +08:00
// Builtin math library functions
Reorder libm LIBBUILTIN definition groups The groups of libm LIBBUILTIN definitions are reordered to match the order of the corresponding __builtin_* definitions (which occur earlier in the Builtins.def file). No functionality change intended. llvm-svn: 190222
2013-09-07 07:45:10 +08:00
LIBBUILTIN(atan2, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(atan2f, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(atan2l, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(abs, "ii", "fnc", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(labs, "LiLi", "fnc", "stdlib.h", ALL_LANGUAGES)
LIBBUILTIN(llabs, "LLiLLi", "fnc", "stdlib.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definition groups The groups of libm LIBBUILTIN definitions are reordered to match the order of the corresponding __builtin_* definitions (which occur earlier in the Builtins.def file). No functionality change intended. llvm-svn: 190222
2013-09-07 07:45:10 +08:00
LIBBUILTIN(copysign, "ddd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(copysignf, "fff", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(copysignl, "LdLdLd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fabs, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fabsf, "ff", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fabsl, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Convert finite to builtin Summary: This patch converts finite/__finite to builtin functions so that it will be inlined by compiler. Reviewers: hfinkel, davidxl, efriedma Subscribers: efriedma, llvm-commits Differential Revision: https://reviews.llvm.org/D24483 llvm-svn: 281509
2016-09-15 01:34:14 +08:00
LIBBUILTIN(finite, "id", "fnc", "math.h", GNU_LANG)
LIBBUILTIN(finitef, "if", "fnc", "math.h", GNU_LANG)
LIBBUILTIN(finitel, "iLd", "fnc", "math.h", GNU_LANG)
// glibc's math.h generates calls to __finite
LIBBUILTIN(__finite, "id", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__finitef, "if", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__finitel, "iLd", "fnc", "math.h", ALL_LANGUAGES)
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(fmod, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmodf, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmodl, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(frexp, "ddi*", "fn", "math.h", ALL_LANGUAGES)
LIBBUILTIN(frexpf, "ffi*", "fn", "math.h", ALL_LANGUAGES)
LIBBUILTIN(frexpl, "LdLdi*", "fn", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ldexp, "ddi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ldexpf, "ffi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ldexpl, "LdLdi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(modf, "ddd*", "fn", "math.h", ALL_LANGUAGES)
LIBBUILTIN(modff, "fff*", "fn", "math.h", ALL_LANGUAGES)
LIBBUILTIN(modfl, "LdLdLd*", "fn", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nan, "dcC*", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nanf, "fcC*", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nanl, "LdcC*", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definition groups The groups of libm LIBBUILTIN definitions are reordered to match the order of the corresponding __builtin_* definitions (which occur earlier in the Builtins.def file). No functionality change intended. llvm-svn: 190222
2013-09-07 07:45:10 +08:00
LIBBUILTIN(pow, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(powf, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(powl, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(acos, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(acosf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(acosl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(acosh, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(acoshf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(acoshl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(asin, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(asinf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(asinl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(asinh, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(asinhf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(asinhl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(atan, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(atanf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(atanl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add atan, atan2, exp, and log to the builtin math library functions. With -fno-math-errno (the default for Darwin) or -ffast-math these library function can be marked readnone enabling more opportunities for CSE and other optimizations. rdar://11251464 llvm-svn: 155498
2012-04-25 06:40:01 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(atanh, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(atanhf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(atanhl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(cbrt, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(cbrtf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(cbrtl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(ceil, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ceilf, "ff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(ceill, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(cos, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(cosf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(cosl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Alphabetize the builtin math library functions. No functional change intended. llvm-svn: 155492
2012-04-25 05:45:50 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(cosh, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(coshf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(coshl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(erf, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(erff, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(erfl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(erfc, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(erfcf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(erfcl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(exp, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(expf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(expl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add atan, atan2, exp, and log to the builtin math library functions. With -fno-math-errno (the default for Darwin) or -ffast-math these library function can be marked readnone enabling more opportunities for CSE and other optimizations. rdar://11251464 llvm-svn: 155498
2012-04-25 06:40:01 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(exp2, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(exp2f, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(exp2l, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Math builtin definition tweaks. There were missed optimizations when the system headers didn't have attributes in place, specifically: - Add copysign, exp2, log2, nearbyint, rint and trunc to the list. These are functions that get inlined by LLVM's optimizer, but only when they have the right attributes. - Mark copysign, fabs, fmax, fmin and trunc const unconditionally. Previously these were only const with -fno-math-errno, but they never set errno per POSIX. For ceil/floor/nearbyint/round I'm not aware of any implementation that sets errno, but POSIX says it may signal overflow so I left them alone for now. llvm-svn: 162375
2012-08-23 02:16:02 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(expm1, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(expm1f, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(expm1l, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fdim, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fdimf, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fdiml, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(floor, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(floorf, "ff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(floorl, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(fma, "dddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmaf, "ffff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmal, "LdLdLdLd", "fne", "math.h", ALL_LANGUAGES)
Alphabetize the builtin math library functions. No functional change intended. llvm-svn: 155492
2012-04-25 05:45:50 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(fmax, "ddd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmaxf, "fff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(fmaxl, "LdLdLd", "fnc", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(fmin, "ddd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fminf, "fff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(fminl, "LdLdLd", "fnc", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(hypot, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(hypotf, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(hypotl, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ilogb, "id", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ilogbf, "if", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(ilogbl, "iLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lgamma, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lgammaf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lgammal, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(llrint, "LLid", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(llrintf, "LLif", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(llrintl, "LLiLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(llround, "LLid", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(llroundf, "LLif", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(llroundl, "LLiLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(log, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(logf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(logl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add atan, atan2, exp, and log to the builtin math library functions. With -fno-math-errno (the default for Darwin) or -ffast-math these library function can be marked readnone enabling more opportunities for CSE and other optimizations. rdar://11251464 llvm-svn: 155498
2012-04-25 06:40:01 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(log10, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(log10f, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(log10l, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(log1p, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(log1pf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(log1pl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(log2, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(log2f, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(log2l, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Math builtin definition tweaks. There were missed optimizations when the system headers didn't have attributes in place, specifically: - Add copysign, exp2, log2, nearbyint, rint and trunc to the list. These are functions that get inlined by LLVM's optimizer, but only when they have the right attributes. - Mark copysign, fabs, fmax, fmin and trunc const unconditionally. Previously these were only const with -fno-math-errno, but they never set errno per POSIX. For ceil/floor/nearbyint/round I'm not aware of any implementation that sets errno, but POSIX says it may signal overflow so I left them alone for now. llvm-svn: 162375
2012-08-23 02:16:02 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(logb, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(logbf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(logbl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lrint, "Lid", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lrintf, "Lif", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lrintl, "LiLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lround, "Lid", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lroundf, "Lif", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(lroundl, "LiLd", "fne", "math.h", ALL_LANGUAGES)
Add lrint to the list of math builtins. It never sets errno so we can mark it as readnone. llvm-svn: 188065
2013-08-09 18:12:30 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(nearbyint, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nearbyintf, "ff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(nearbyintl, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Math builtin definition tweaks. There were missed optimizations when the system headers didn't have attributes in place, specifically: - Add copysign, exp2, log2, nearbyint, rint and trunc to the list. These are functions that get inlined by LLVM's optimizer, but only when they have the right attributes. - Mark copysign, fabs, fmax, fmin and trunc const unconditionally. Previously these were only const with -fno-math-errno, but they never set errno per POSIX. For ceil/floor/nearbyint/round I'm not aware of any implementation that sets errno, but POSIX says it may signal overflow so I left them alone for now. llvm-svn: 162375
2012-08-23 02:16:02 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(nextafter, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nextafterf, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nextafterl, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
The second parameter of nexttoward is always long double. llvm-svn: 191623
2013-09-29 01:41:03 +08:00
LIBBUILTIN(nexttoward, "ddLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(nexttowardf, "ffLd", "fne", "math.h", ALL_LANGUAGES)
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(nexttowardl, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(remainder, "ddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(remainderf, "fff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(remainderl, "LdLdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(rint, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(rintf, "ff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(rintl, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Math builtin definition tweaks. There were missed optimizations when the system headers didn't have attributes in place, specifically: - Add copysign, exp2, log2, nearbyint, rint and trunc to the list. These are functions that get inlined by LLVM's optimizer, but only when they have the right attributes. - Mark copysign, fabs, fmax, fmin and trunc const unconditionally. Previously these were only const with -fno-math-errno, but they never set errno per POSIX. For ceil/floor/nearbyint/round I'm not aware of any implementation that sets errno, but POSIX says it may signal overflow so I left them alone for now. llvm-svn: 162375
2012-08-23 02:16:02 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(round, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(roundf, "ff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(roundl, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(scalbln, "ddLi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(scalblnf, "ffLi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(scalblnl, "LdLdLi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(scalbn, "ddi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(scalbnf, "ffi", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(scalbnl, "LdLdi", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(sin, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(sinf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(sinl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add builtin declarations for the variants of sin and cos. llvm-svn: 72718
2009-06-02 15:06:02 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(sinh, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(sinhf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(sinhl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(sqrt, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(sqrtf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(sqrtl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add codegen support for the fma/fmal/fmaf builtins. llvm-svn: 134743
2011-07-09 05:39:34 +08:00
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(tan, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(tanf, "ff", "fne", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(tanl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add acos, asin, ceil, fabs, floor, fmax, fmin, round, and tan to the builtin math library functions. rdar://11251464 llvm-svn: 155502
2012-04-25 07:06:26 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(tanh, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(tanhf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(tanhl, "LdLd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(tgamma, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(tgammaf, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(tgammal, "LdLd", "fne", "math.h", ALL_LANGUAGES)
Add the missing "n" to libm LIBBUILTIN definitions The libm math functions should be marked with the "n" (nothrow) flag so that the corresponding IR function declarations are tagged with the nounwind attribute (this has been true in C mode, but not in C++ mode). The test case has been updated to run in C++ mode in addition to in C mode. llvm-svn: 190217
2013-09-07 07:23:32 +08:00
LIBBUILTIN(trunc, "dd", "fnc", "math.h", ALL_LANGUAGES)
LIBBUILTIN(truncf, "ff", "fnc", "math.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definitions The libm LIBBUILTIN definitions are reordered to the canonical (and alphabetical) double (''), float ('f'), long double ('l') ordering. No functionality change intended. llvm-svn: 190218
2013-09-07 07:23:53 +08:00
LIBBUILTIN(truncl, "LdLd", "fnc", "math.h", ALL_LANGUAGES)
Math builtin definition tweaks. There were missed optimizations when the system headers didn't have attributes in place, specifically: - Add copysign, exp2, log2, nearbyint, rint and trunc to the list. These are functions that get inlined by LLVM's optimizer, but only when they have the right attributes. - Mark copysign, fabs, fmax, fmin and trunc const unconditionally. Previously these were only const with -fno-math-errno, but they never set errno per POSIX. For ceil/floor/nearbyint/round I'm not aware of any implementation that sets errno, but POSIX says it may signal overflow so I left them alone for now. llvm-svn: 162375
2012-08-23 02:16:02 +08:00
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(cabs, "dXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cabsf, "fXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cabsl, "LdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cacos, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cacosf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cacosl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cacosh, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cacoshf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cacoshl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(carg, "dXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cargf, "fXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cargl, "LdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(casin, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(casinf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(casinl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(casinh, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(casinhf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(casinhl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(catan, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(catanf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(catanl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(catanh, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(catanhf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(catanhl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ccos, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ccosf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ccosl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ccosh, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ccoshf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ccoshl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cexp, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cexpf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cexpl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definition groups The groups of libm LIBBUILTIN definitions are reordered to match the order of the corresponding __builtin_* definitions (which occur earlier in the Builtins.def file). No functionality change intended. llvm-svn: 190222
2013-09-07 07:45:10 +08:00
LIBBUILTIN(cimag, "dXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cimagf, "fXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cimagl, "LdXLd", "fnc", "complex.h", ALL_LANGUAGES)
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(conj, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(conjf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(conjl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(clog, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(clogf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(clogl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cproj, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cprojf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cprojl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cpow, "XdXdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cpowf, "XfXfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(cpowl, "XLdXLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
Reorder libm LIBBUILTIN definition groups The groups of libm LIBBUILTIN definitions are reordered to match the order of the corresponding __builtin_* definitions (which occur earlier in the Builtins.def file). No functionality change intended. llvm-svn: 190222
2013-09-07 07:45:10 +08:00
LIBBUILTIN(creal, "dXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(crealf, "fXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(creall, "LdXLd", "fnc", "complex.h", ALL_LANGUAGES)
Add new libm LIBBUILTIN definitions, synchronizing with __builtin_* For all libm __builtin_* functions that are defined, this adds the corresponding LIBBUILTIN definitions (tagged, as necessary, with "e" instead of "c" when the function may set errno). Note that this changes the current definitions for lrint and fma (unfortunately). The Linux man page documents that these don't set errno, but the POSIX standard says that they should. llvm-svn: 190922
2013-09-18 14:19:40 +08:00
LIBBUILTIN(csin, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csinf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csinl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csinh, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csinhf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csinhl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csqrt, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csqrtf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(csqrtl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ctan, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ctanf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ctanl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ctanh, "XdXd", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ctanhf, "XfXf", "fnc", "complex.h", ALL_LANGUAGES)
LIBBUILTIN(ctanhl, "XLdXLd", "fnc", "complex.h", ALL_LANGUAGES)
Darwin: add __sinpi (etc) and __exp10 libbuiltins These functions have the same constness properties of the normal libm functions, which allows LLVM to optimise code better in general. There are also a couple of specific optimisations that only trigger when these are properly marked. rdar://problem/13729466 llvm-svn: 199249
2014-01-15 03:26:03 +08:00
// __sinpi and friends are OS X specific library functions, but otherwise much
// like the standard (non-complex) sin (etc).
LIBBUILTIN(__sinpi, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__sinpif, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__cospi, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__cospif, "ff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__tanpi, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__tanpif, "ff", "fne", "math.h", ALL_LANGUAGES)
// Similarly, __exp10 is OS X only
LIBBUILTIN(__exp10, "dd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(__exp10f, "ff", "fne", "math.h", ALL_LANGUAGES)
IRgen: Support user defined attributes on block runtime functions. - This issue here is that /usr/include/Blocks.h wants to define some of the block runtime globals as weak, depending on the target. This doesn't work in Clang because we aren't using the AST decl for these globals. - The fix is a pretty gross hack which just watches all the decls for the specific blocks globals we need to know about; if we see one we use it, otherwise we use the hand coded type. In time, I would like to clean this up by changing IRgen to ask Sema/AST for the decl, which would then be lazily loaded from the builtin table if necessary. This could be used in a whole host of places in IRgen and would get rid of a lot of grotty hand coding of LLVM IR; however, we need some extra Sema support for this as well as support for builtin global variables. llvm-svn: 108482
2010-07-16 08:00:19 +08:00
// Blocks runtime Builtin math library functions
Such function decls,as objc's objc_msgSend, builtins in a specific language. We are adding such language info. by extensing Builtins.def and via a language flag added to LIBBUILTIN/BUILTIN and check for that when deciding a name is builtin or not. Implements //rdar://8689273. llvm-svn: 120429
2010-12-01 01:35:24 +08:00
LIBBUILTIN(_Block_object_assign, "vv*vC*iC", "f", "Blocks.h", ALL_LANGUAGES)
LIBBUILTIN(_Block_object_dispose, "vvC*iC", "f", "Blocks.h", ALL_LANGUAGES)
IRgen: Support user defined attributes on block runtime functions. - This issue here is that /usr/include/Blocks.h wants to define some of the block runtime globals as weak, depending on the target. This doesn't work in Clang because we aren't using the AST decl for these globals. - The fix is a pretty gross hack which just watches all the decls for the specific blocks globals we need to know about; if we see one we use it, otherwise we use the hand coded type. In time, I would like to clean this up by changing IRgen to ask Sema/AST for the decl, which would then be lazily loaded from the builtin table if necessary. This could be used in a whole host of places in IRgen and would get rid of a lot of grotty hand coding of LLVM IR; however, we need some extra Sema support for this as well as support for builtin global variables. llvm-svn: 108482
2010-07-16 08:00:19 +08:00
// FIXME: Also declare NSConcreteGlobalBlock and NSConcreteStackBlock.
Bring llvm.annotation* intrinsics support back to where it was in llvm-gcc: can annotate global, local variables, struct fields, or arbitrary statements (using the __builtin_annotation), rdar://8037476. llvm-svn: 139423
2011-09-10 06:41:49 +08:00
// Annotation function
Currently __builtin_annotation() only annotates an i32. i32 __builtin_annotation(i32, string); Applying it to i64 (e.g., long long) generates the following IR. trunc i64 {{.*}} to i32 call i32 @llvm.annotation.i32 zext i32 {{.*}} to i64 The redundant truncation and extension make the result difficult to use. This patch makes __builtin_annotation() generic. type __builtin_annotation(type, string); For the i64 example, it simplifies the generated IR to: call i64 @llvm.annotation.i64 Patch by Xi Wang! llvm-svn: 155764
2012-04-29 01:39:16 +08:00
BUILTIN(__builtin_annotation, "v.", "tn")
Bring llvm.annotation* intrinsics support back to where it was in llvm-gcc: can annotate global, local variables, struct fields, or arbitrary statements (using the __builtin_annotation), rdar://8037476. llvm-svn: 139423
2011-09-10 06:41:49 +08:00
Add __builtin_assume and __builtin_assume_aligned using @llvm.assume. This makes use of the recently-added @llvm.assume intrinsic to implement a __builtin_assume(bool) intrinsic (to provide additional information to the optimizer). This hooks up __assume in MS-compatibility mode to mirror __builtin_assume (the semantics have been intentionally kept compatible), and implements GCC's __builtin_assume_aligned as assume((p - o) & mask == 0). LLVM now contains special logic to deal with assumptions of this form. llvm-svn: 217349
2014-09-08 06:58:14 +08:00
// Invariants
BUILTIN(__builtin_assume, "vb", "n")
Added builtins for multiprecision adds. We lower all of these intrinsics into a 2x chained usage of uadd.with.overflow. llvm-svn: 172341
2013-01-13 10:22:39 +08:00
// Multiprecision Arithmetic Builtins.
[multiprecision-builtins] Added missing builtin __builtin_{add,sub}cb for {add,sub} with carry for bytes. I have had several people ask me about why this builtin was not available in clang (since it seems like a logical conclusion). This patch implements said builtins. Relevant tests are included as well. I also updated the Clang language extension reference. rdar://14192664. llvm-svn: 184227
2013-06-19 04:40:40 +08:00
BUILTIN(__builtin_addcb, "UcUcCUcCUcCUc*", "n")
Added builtins for multiprecision adds. We lower all of these intrinsics into a 2x chained usage of uadd.with.overflow. llvm-svn: 172341
2013-01-13 10:22:39 +08:00
BUILTIN(__builtin_addcs, "UsUsCUsCUsCUs*", "n")
BUILTIN(__builtin_addc, "UiUiCUiCUiCUi*", "n")
BUILTIN(__builtin_addcl, "ULiULiCULiCULiCULi*", "n")
BUILTIN(__builtin_addcll, "ULLiULLiCULLiCULLiCULLi*", "n")
[multiprecision-builtins] Added missing builtin __builtin_{add,sub}cb for {add,sub} with carry for bytes. I have had several people ask me about why this builtin was not available in clang (since it seems like a logical conclusion). This patch implements said builtins. Relevant tests are included as well. I also updated the Clang language extension reference. rdar://14192664. llvm-svn: 184227
2013-06-19 04:40:40 +08:00
BUILTIN(__builtin_subcb, "UcUcCUcCUcCUc*", "n")
Multiprecision subtraction builtins. We lower these into 2x chained usub.with.overflow intrinsics. llvm-svn: 172476
2013-01-15 05:44:30 +08:00
BUILTIN(__builtin_subcs, "UsUsCUsCUsCUs*", "n")
BUILTIN(__builtin_subc, "UiUiCUiCUiCUi*", "n")
BUILTIN(__builtin_subcl, "ULiULiCULiCULiCULi*", "n")
BUILTIN(__builtin_subcll, "ULLiULLiCULLiCULLiCULLi*", "n")
Added builtins for multiprecision adds. We lower all of these intrinsics into a 2x chained usage of uadd.with.overflow. llvm-svn: 172341
2013-01-13 10:22:39 +08:00
[checked-arithmetic builtins] Added builtins to enable users to perform checked-arithmetic in c. This will enable users in security critical applications to perform checked-arithmetic in a fast safe manner that is amenable to c. Tests/an update to Language Extensions is included as well. rdar://13421498. llvm-svn: 184497
2013-06-21 07:28:10 +08:00
// Checked Arithmetic Builtins for Security.
Add support for __builtin_{add,sub,mul}_overflow. Patch by David Grayson! llvm-svn: 251651
2015-10-30 04:48:01 +08:00
BUILTIN(__builtin_add_overflow, "v.", "nt")
BUILTIN(__builtin_sub_overflow, "v.", "nt")
BUILTIN(__builtin_mul_overflow, "v.", "nt")
[checked-arithmetic builtins] Added builtins to enable users to perform checked-arithmetic in c. This will enable users in security critical applications to perform checked-arithmetic in a fast safe manner that is amenable to c. Tests/an update to Language Extensions is included as well. rdar://13421498. llvm-svn: 184497
2013-06-21 07:28:10 +08:00
BUILTIN(__builtin_uadd_overflow, "bUiCUiCUi*", "n")
BUILTIN(__builtin_uaddl_overflow, "bULiCULiCULi*", "n")
BUILTIN(__builtin_uaddll_overflow, "bULLiCULLiCULLi*", "n")
BUILTIN(__builtin_usub_overflow, "bUiCUiCUi*", "n")
BUILTIN(__builtin_usubl_overflow, "bULiCULiCULi*", "n")
BUILTIN(__builtin_usubll_overflow, "bULLiCULLiCULLi*", "n")
BUILTIN(__builtin_umul_overflow, "bUiCUiCUi*", "n")
BUILTIN(__builtin_umull_overflow, "bULiCULiCULi*", "n")
BUILTIN(__builtin_umulll_overflow, "bULLiCULLiCULLi*", "n")
BUILTIN(__builtin_sadd_overflow, "bSiCSiCSi*", "n")
BUILTIN(__builtin_saddl_overflow, "bSLiCSLiCSLi*", "n")
BUILTIN(__builtin_saddll_overflow, "bSLLiCSLLiCSLLi*", "n")
BUILTIN(__builtin_ssub_overflow, "bSiCSiCSi*", "n")
BUILTIN(__builtin_ssubl_overflow, "bSLiCSLiCSLi*", "n")
BUILTIN(__builtin_ssubll_overflow, "bSLLiCSLLiCSLLi*", "n")
BUILTIN(__builtin_smul_overflow, "bSiCSiCSi*", "n")
BUILTIN(__builtin_smull_overflow, "bSLiCSLiCSLi*", "n")
BUILTIN(__builtin_smulll_overflow, "bSLLiCSLLiCSLLi*", "n")
Add a __builtin_addressof that performs the same functionality as the built-in & operator (ignoring any overloaded operator& for the type). The purpose of this builtin is for use in std::addressof, to allow it to be made constexpr; the existing implementation technique (reinterpret_cast to some reference type, take address, reinterpert_cast back) does not permit this because reinterpret_cast between reference types is not permitted in a constant expression in C++11 onwards. llvm-svn: 186053
2013-07-11 10:27:57 +08:00
// Clang builtins (not available in GCC).
BUILTIN(__builtin_addressof, "v*v&", "nct")
Add __builtin_operator_new and __builtin_operator_delete, which act like calls to the normal non-placement ::operator new and ::operator delete, but allow optimizations like new-expressions and delete-expressions do. llvm-svn: 210137
2014-06-04 07:27:44 +08:00
BUILTIN(__builtin_operator_new, "v*z", "c")
BUILTIN(__builtin_operator_delete, "vv*", "n")
Add a __builtin_addressof that performs the same functionality as the built-in & operator (ignoring any overloaded operator& for the type). The purpose of this builtin is for use in std::addressof, to allow it to be made constexpr; the existing implementation technique (reinterpret_cast to some reference type, take address, reinterpert_cast back) does not permit this because reinterpret_cast between reference types is not permitted in a constant expression in C++11 onwards. llvm-svn: 186053
2013-07-11 10:27:57 +08:00
Protection against stack-based memory corruption errors using SafeStack: Clang command line option and function attribute This patch adds the -fsanitize=safe-stack command line argument for clang, which enables the Safe Stack protection (see http://reviews.llvm.org/D6094 for the detailed description of the Safe Stack). This patch is our implementation of the safe stack on top of Clang. The patches make the following changes: - Add -fsanitize=safe-stack and -fno-sanitize=safe-stack options to clang to control safe stack usage (the safe stack is disabled by default). - Add __attribute__((no_sanitize("safe-stack"))) attribute to clang that can be used to disable the safe stack for individual functions even when enabled globally. Original patch by Volodymyr Kuznetsov and others at the Dependable Systems Lab at EPFL; updates and upstreaming by myself. Differential Revision: http://reviews.llvm.org/D6095 llvm-svn: 239762
2015-06-16 05:08:13 +08:00
// Safestack builtins
BUILTIN(__builtin___get_unsafe_stack_start, "v*", "Fn")
BUILTIN(__builtin___get_unsafe_stack_ptr, "v*", "Fn")
Introduce __builtin_nontemporal_store and __builtin_nontemporal_load. Summary: Currently clang provides no general way to generate nontemporal loads/stores. There are some architecture specific builtins for doing so (e.g. in x86), but there is no way to generate non-temporal store on, e.g. AArch64. This patch adds generic builtins which are expanded to a simple store with '!nontemporal' attribute in IR. Differential Revision: http://reviews.llvm.org/D12313 llvm-svn: 247104
2015-09-09 07:52:33 +08:00
// Nontemporal loads/stores builtins
BUILTIN(__builtin_nontemporal_store, "v.", "t")
BUILTIN(__builtin_nontemporal_load, "v.", "t")
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
// OpenCL v2.0 s6.13.16, s9.17.3.5 - Pipe functions.
// We need the generic prototype, since the packet type could be anything.
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(read_pipe, "i.", "tn", OCLC20_LANG)
LANGBUILTIN(write_pipe, "i.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(reserve_read_pipe, "i.", "tn", OCLC20_LANG)
LANGBUILTIN(reserve_write_pipe, "i.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(commit_write_pipe, "v.", "tn", OCLC20_LANG)
LANGBUILTIN(commit_read_pipe, "v.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG)
LANGBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCLC20_LANG)
LANGBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG)
LANGBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCLC20_LANG)
LANGBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCLC20_LANG)
LANGBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCLC20_LANG)
Recommit: R258773 [OpenCL] Pipe builtin functions Fix arc patch fuzz error. Summary: Support for the pipe built-in functions for OpenCL 2.0. The pipe builtin functions may have infinite kinds of element types, one approach would be to just generate calls that would always use generic types such as void*. This patch is based on bader's opencl support patch on SPIR-V branch. Reviewers: Anastasia, pekka.jaaskelainen Subscribers: keryell, bader, cfe-commits Differential Revision: http://reviews.llvm.org/D15914 llvm-svn: 258782
2016-01-26 12:03:48 +08:00
[OpenCL] An implementation of device side enqueue (DSE) from OpenCL v2.0 s6.13.17. - Added new Builtins: enqueue_kernel, get_kernel_work_group_size and get_kernel_preferred_work_group_size_multiple. These Builtins use custom check to diagnose parameters of the passed Blocks i. e. variable number of 'local void*' type params, and check different overloads specified in Table 6.31 of OpenCL v2.0. - IR is generated as an internal library call for each OpenCL Builtin, reusing ObjC Block implementation. Review: http://reviews.llvm.org/D20249 llvm-svn: 274540
2016-07-05 19:31:24 +08:00
// OpenCL v2.0 s6.13.17 - Enqueue kernel functions.
// Custom builtin check allows to perform special check of passed block arguments.
LANGBUILTIN(enqueue_kernel, "i.", "tn", OCLC20_LANG)
LANGBUILTIN(get_kernel_work_group_size, "i.", "tn", OCLC20_LANG)
LANGBUILTIN(get_kernel_preferred_work_group_size_multiple, "i.", "tn", OCLC20_LANG)
[OpenCL] Add to_{global|local|private} builtin functions. OpenCL builtin functions to_{global|local|private} accepts argument of pointer type to arbitrary pointee type, and return a pointer to the same pointee type in different addr space, i.e. global gentype *to_global(gentype *p); It is not desirable to declare it as global void *to_global(void *); in opencl header file since it misses diagnostics. This patch implements these builtin functions as Clang builtin functions. In the builtin def file they are defined to have signature void*(void*). When handling call expressions, their declarations are re-written to have correct parameter type and return type corresponding to the call argument. In codegen call to addr void *to_addr(void*) is generated with addrcasts or bitcasts to facilitate implementation in builtin library. Differential Revision: http://reviews.llvm.org/D19932 llvm-svn: 270261
2016-05-21 03:54:38 +08:00
// OpenCL v2.0 s6.13.9 - Address space qualifier functions.
[OpenCL] Make OpenCL Builtins added according to the right version. Currently we only have OpenCL 2.0 Builtins i.e. pipes or address space conversions. They have to be added only in the version 2.0 compilation mode to make the identifiers available for use in the other versions. Review: http://reviews.llvm.org/D20249 llvm-svn: 274509
2016-07-05 00:07:18 +08:00
LANGBUILTIN(to_global, "v*v*", "tn", OCLC20_LANG)
LANGBUILTIN(to_local, "v*v*", "tn", OCLC20_LANG)
LANGBUILTIN(to_private, "v*v*", "tn", OCLC20_LANG)
[OpenCL] Add to_{global|local|private} builtin functions. OpenCL builtin functions to_{global|local|private} accepts argument of pointer type to arbitrary pointee type, and return a pointer to the same pointee type in different addr space, i.e. global gentype *to_global(gentype *p); It is not desirable to declare it as global void *to_global(void *); in opencl header file since it misses diagnostics. This patch implements these builtin functions as Clang builtin functions. In the builtin def file they are defined to have signature void*(void*). When handling call expressions, their declarations are re-written to have correct parameter type and return type corresponding to the call argument. In codegen call to addr void *to_addr(void*) is generated with addrcasts or bitcasts to facilitate implementation in builtin library. Differential Revision: http://reviews.llvm.org/D19932 llvm-svn: 270261
2016-05-21 03:54:38 +08:00
Add support for target-independent builtin functions (like __builtin_abs), whose decl objects are lazily created the first time they are referenced. Builtin functions are described by the clang/AST/Builtins.def file, which makes it easy to add new ones. This is missing two important pieces: 1. Support for the rest of the gcc builtins. 2. Support for target-specific builtins (e.g. __builtin_ia32_emms). Just adding this builtins reduces the number of implicit function definitions by 6, reducing the # diagnostics from 550 to 544 when parsing carbon.h. I need to add all the i386-specific ones to eliminate several hundred more. ugh. llvm-svn: 39327
2007-01-28 16:20:04 +08:00
#undef BUILTIN
Add -ffreestanding to suppress the implicit declaration of library builtins like printf and malloc. Fixes PR3586 llvm-svn: 64566
2009-02-15 04:49:29 +08:00
#undef LIBBUILTIN
Only provide MS builtins when -fms-extensions is on We already have builtins that are only available in GNU mode, so this mirrors that. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2128 llvm-svn: 194615
2013-11-14 06:47:22 +08:00
#undef LANGBUILTIN