[llvm] [clang] [clang-tools-extra] [clang] Refactor Builtins.def to be a tablegen file (PR #68324)
Nikolas Klauser via cfe-commits
cfe-commits at lists.llvm.org
Wed Jan 17 21:22:56 PST 2024
https://github.com/philnik777 updated https://github.com/llvm/llvm-project/pull/68324
>From e2c94d99f108840e16c1509bd58549e6936cc157 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Fri, 15 Sep 2023 09:01:21 +0200
Subject: [PATCH 1/2] [clang] Refactor Builtins.def to be a tablegen file
---
clang/include/clang/AST/Expr.h | 21 +-
clang/include/clang/Basic/Builtins.def | 1672 +------
clang/include/clang/Basic/Builtins.h | 2 +-
clang/include/clang/Basic/Builtins.td | 4370 +++++++++++++++++
clang/include/clang/Basic/BuiltinsBPF.def | 33 -
clang/include/clang/Basic/BuiltinsBPF.td | 37 +
clang/include/clang/Basic/BuiltinsBase.td | 121 +
clang/include/clang/Basic/CMakeLists.txt | 8 +
clang/include/clang/Basic/TargetBuiltins.h | 2 +-
clang/include/module.modulemap | 2 -
clang/lib/AST/Expr.cpp | 1 +
clang/lib/AST/StmtPrinter.cpp | 2 +-
clang/lib/Basic/Builtins.cpp | 2 +-
clang/lib/Basic/Targets/BPF.cpp | 2 +-
clang/lib/Sema/OpenCLBuiltins.td | 12 +-
clang/lib/Sema/SemaChecking.cpp | 20 +-
clang/lib/Sema/SemaExpr.cpp | 2 +-
clang/test/Analysis/bstring.c | 12 +-
clang/test/CodeGen/callback_pthread_create.c | 2 +-
clang/utils/TableGen/CMakeLists.txt | 1 +
clang/utils/TableGen/ClangBuiltinsEmitter.cpp | 332 ++
clang/utils/TableGen/MveEmitter.cpp | 2 +-
clang/utils/TableGen/TableGen.cpp | 6 +
clang/utils/TableGen/TableGenBackends.h | 2 +
24 files changed, 4921 insertions(+), 1745 deletions(-)
create mode 100644 clang/include/clang/Basic/Builtins.td
delete mode 100644 clang/include/clang/Basic/BuiltinsBPF.def
create mode 100644 clang/include/clang/Basic/BuiltinsBPF.td
create mode 100644 clang/include/clang/Basic/BuiltinsBase.td
create mode 100644 clang/utils/TableGen/ClangBuiltinsEmitter.cpp
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index fe20a84216d1f11..ec013dd0a2d2123 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -6420,7 +6420,7 @@ class AtomicExpr : public Expr {
enum AtomicOp {
#define BUILTIN(ID, TYPE, ATTRS)
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) AO ## ID,
-#include "clang/Basic/Builtins.def"
+#include "clang/Basic/Builtins.inc"
// Avoid trailing comma
BI_First = 0
};
@@ -6486,7 +6486,7 @@ class AtomicExpr : public Expr {
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
case AO##ID: \
return #ID;
-#include "clang/Basic/Builtins.def"
+#include "clang/Basic/Builtins.inc"
}
llvm_unreachable("not an atomic operator?");
}
@@ -6513,8 +6513,8 @@ class AtomicExpr : public Expr {
}
bool isOpenCL() const {
- return getOp() >= AO__opencl_atomic_init &&
- getOp() <= AO__opencl_atomic_fetch_max;
+ return getOp() >= AO__opencl_atomic_compare_exchange_strong &&
+ getOp() <= AO__opencl_atomic_store;
}
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
@@ -6539,12 +6539,13 @@ class AtomicExpr : public Expr {
/// \return empty atomic scope model if the atomic op code does not have
/// scope operand.
static std::unique_ptr<AtomicScopeModel> getScopeModel(AtomicOp Op) {
- auto Kind =
- (Op >= AO__opencl_atomic_load && Op <= AO__opencl_atomic_fetch_max)
- ? AtomicScopeModelKind::OpenCL
- : (Op >= AO__hip_atomic_load && Op <= AO__hip_atomic_fetch_max)
- ? AtomicScopeModelKind::HIP
- : AtomicScopeModelKind::None;
+ auto Kind = (Op >= AO__opencl_atomic_compare_exchange_strong &&
+ Op <= AO__opencl_atomic_store)
+ ? AtomicScopeModelKind::OpenCL
+ : (Op >= AO__hip_atomic_compare_exchange_strong &&
+ Op <= AO__hip_atomic_store)
+ ? AtomicScopeModelKind::HIP
+ : AtomicScopeModelKind::None;
return AtomicScopeModel::create(Kind);
}
diff --git a/clang/include/clang/Basic/Builtins.def b/clang/include/clang/Basic/Builtins.def
index 586dcf05170eb58..f356f881d5ef9bc 100644
--- a/clang/include/clang/Basic/Builtins.def
+++ b/clang/include/clang/Basic/Builtins.def
@@ -5,17 +5,9 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
-//
-// 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.
+// This is only documentation for the database layout. This will be removed once
+// all builtin databases are converted to tablegen files
// The second value provided to the macro specifies the type of the function
// (result value, then each argument) as follows:
@@ -108,1663 +100,3 @@
// M_0, ..., M_k as payload
// z -> this is a function in (possibly-versioned) namespace std
// E -> this function can be constant evaluated by Clang frontend
-// FIXME: gcc has nonnull
-
-#if defined(BUILTIN) && !defined(LIBBUILTIN)
-# define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-#if defined(BUILTIN) && !defined(LANGBUILTIN)
-# define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-// Standard libc/libm functions:
-BUILTIN(__builtin_atan2 , "ddd" , "Fne")
-BUILTIN(__builtin_atan2f, "fff" , "Fne")
-BUILTIN(__builtin_atan2l, "LdLdLd", "Fne")
-BUILTIN(__builtin_atan2f128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_abs , "ii" , "ncF")
-BUILTIN(__builtin_copysign, "ddd", "ncFE")
-BUILTIN(__builtin_copysignf, "fff", "ncFE")
-BUILTIN(__builtin_copysignf16, "hhh", "ncF")
-BUILTIN(__builtin_copysignl, "LdLdLd", "ncFE")
-BUILTIN(__builtin_copysignf128, "LLdLLdLLd", "ncFE")
-BUILTIN(__builtin_fabs , "dd" , "ncFE")
-BUILTIN(__builtin_fabsf, "ff" , "ncFE")
-BUILTIN(__builtin_fabsl, "LdLd", "ncFE")
-BUILTIN(__builtin_fabsf16, "hh" , "ncF")
-BUILTIN(__builtin_fabsf128, "LLdLLd", "ncFE")
-BUILTIN(__builtin_fmod , "ddd" , "Fne")
-BUILTIN(__builtin_fmodf, "fff" , "Fne")
-BUILTIN(__builtin_fmodf16, "hhh" , "Fne")
-BUILTIN(__builtin_fmodl, "LdLdLd", "Fne")
-BUILTIN(__builtin_fmodf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_frexp , "ddi*" , "Fn")
-BUILTIN(__builtin_frexpf, "ffi*" , "Fn")
-BUILTIN(__builtin_frexpl, "LdLdi*", "Fn")
-BUILTIN(__builtin_frexpf128, "LLdLLdi*", "Fn")
-BUILTIN(__builtin_frexpf16, "hhi*" , "Fn")
-BUILTIN(__builtin_huge_val, "d", "ncE")
-BUILTIN(__builtin_huge_valf, "f", "ncE")
-BUILTIN(__builtin_huge_vall, "Ld", "ncE")
-BUILTIN(__builtin_huge_valf16, "x", "ncE")
-BUILTIN(__builtin_huge_valf128, "LLd", "ncE")
-BUILTIN(__builtin_inf , "d" , "ncE")
-BUILTIN(__builtin_inff , "f" , "ncE")
-BUILTIN(__builtin_infl , "Ld" , "ncE")
-BUILTIN(__builtin_inff16 , "x" , "ncE")
-BUILTIN(__builtin_inff128 , "LLd" , "ncE")
-BUILTIN(__builtin_labs , "LiLi" , "Fnc")
-BUILTIN(__builtin_llabs, "LLiLLi", "Fnc")
-BUILTIN(__builtin_ldexp , "ddi" , "Fne")
-BUILTIN(__builtin_ldexpf, "ffi" , "Fne")
-BUILTIN(__builtin_ldexpl, "LdLdi", "Fne")
-BUILTIN(__builtin_ldexpf128, "LLdLLdi", "Fne")
-BUILTIN(__builtin_ldexpf16, "hhi", "Fne")
-BUILTIN(__builtin_modf , "ddd*" , "Fn")
-BUILTIN(__builtin_modff, "fff*" , "Fn")
-BUILTIN(__builtin_modfl, "LdLdLd*", "Fn")
-BUILTIN(__builtin_modff128, "LLdLLdLLd*", "Fn")
-BUILTIN(__builtin_nan, "dcC*" , "FnUE")
-BUILTIN(__builtin_nanf, "fcC*" , "FnUE")
-BUILTIN(__builtin_nanl, "LdcC*", "FnUE")
-BUILTIN(__builtin_nanf16, "xcC*", "FnUE")
-BUILTIN(__builtin_nanf128, "LLdcC*", "FnUE")
-BUILTIN(__builtin_nans, "dcC*" , "FnUE")
-BUILTIN(__builtin_nansf, "fcC*" , "FnUE")
-BUILTIN(__builtin_nansl, "LdcC*", "FnUE")
-BUILTIN(__builtin_nansf16, "xcC*", "FnUE")
-BUILTIN(__builtin_nansf128, "LLdcC*", "FnUE")
-BUILTIN(__builtin_powi , "ddi" , "Fnc")
-BUILTIN(__builtin_powif, "ffi" , "Fnc")
-BUILTIN(__builtin_powil, "LdLdi", "Fnc")
-BUILTIN(__builtin_pow , "ddd" , "Fne")
-BUILTIN(__builtin_powf, "fff" , "Fne")
-BUILTIN(__builtin_powf16, "hhh" , "Fne")
-BUILTIN(__builtin_powl, "LdLdLd", "Fne")
-BUILTIN(__builtin_powf128, "LLdLLdLLd", "Fne")
-
-// Standard unary libc/libm functions with double/float/long double variants:
-BUILTIN(__builtin_acos , "dd" , "Fne")
-BUILTIN(__builtin_acosf, "ff" , "Fne")
-BUILTIN(__builtin_acosl, "LdLd", "Fne")
-BUILTIN(__builtin_acosf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_acosh , "dd" , "Fne")
-BUILTIN(__builtin_acoshf, "ff" , "Fne")
-BUILTIN(__builtin_acoshl, "LdLd", "Fne")
-BUILTIN(__builtin_acoshf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_asin , "dd" , "Fne")
-BUILTIN(__builtin_asinf, "ff" , "Fne")
-BUILTIN(__builtin_asinl, "LdLd", "Fne")
-BUILTIN(__builtin_asinf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_asinh , "dd" , "Fne")
-BUILTIN(__builtin_asinhf, "ff" , "Fne")
-BUILTIN(__builtin_asinhl, "LdLd", "Fne")
-BUILTIN(__builtin_asinhf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_atan , "dd" , "Fne")
-BUILTIN(__builtin_atanf, "ff" , "Fne")
-BUILTIN(__builtin_atanl, "LdLd", "Fne")
-BUILTIN(__builtin_atanf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_atanh , "dd", "Fne")
-BUILTIN(__builtin_atanhf, "ff", "Fne")
-BUILTIN(__builtin_atanhl, "LdLd", "Fne")
-BUILTIN(__builtin_atanhf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_cbrt , "dd", "Fnc")
-BUILTIN(__builtin_cbrtf, "ff", "Fnc")
-BUILTIN(__builtin_cbrtl, "LdLd", "Fnc")
-BUILTIN(__builtin_cbrtf128, "LLdLLd", "Fnc")
-BUILTIN(__builtin_ceil , "dd" , "Fnc")
-BUILTIN(__builtin_ceilf, "ff" , "Fnc")
-BUILTIN(__builtin_ceilf16, "hh" , "Fnc")
-BUILTIN(__builtin_ceill, "LdLd", "Fnc")
-BUILTIN(__builtin_ceilf128, "LLdLLd", "Fnc")
-BUILTIN(__builtin_cos , "dd" , "Fne")
-BUILTIN(__builtin_cosf, "ff" , "Fne")
-BUILTIN(__builtin_cosf16, "hh" , "Fne")
-BUILTIN(__builtin_cosh , "dd" , "Fne")
-BUILTIN(__builtin_coshf, "ff" , "Fne")
-BUILTIN(__builtin_coshl, "LdLd", "Fne")
-BUILTIN(__builtin_coshf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_cosl, "LdLd", "Fne")
-BUILTIN(__builtin_cosf128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_erf , "dd", "Fne")
-BUILTIN(__builtin_erff, "ff", "Fne")
-BUILTIN(__builtin_erfl, "LdLd", "Fne")
-BUILTIN(__builtin_erff128, "LLdLLd", "Fne")
-BUILTIN(__builtin_erfc , "dd", "Fne")
-BUILTIN(__builtin_erfcf, "ff", "Fne")
-BUILTIN(__builtin_erfcl, "LdLd", "Fne")
-BUILTIN(__builtin_erfcf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_exp , "dd" , "Fne")
-BUILTIN(__builtin_expf, "ff" , "Fne")
-BUILTIN(__builtin_expf16, "hh" , "Fne")
-BUILTIN(__builtin_expl, "LdLd", "Fne")
-BUILTIN(__builtin_expf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_exp2 , "dd" , "Fne")
-BUILTIN(__builtin_exp2f, "ff" , "Fne")
-BUILTIN(__builtin_exp2f16, "hh" , "Fne")
-BUILTIN(__builtin_exp2l, "LdLd", "Fne")
-BUILTIN(__builtin_exp2f128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_exp10 , "dd" , "Fne")
-BUILTIN(__builtin_exp10f, "ff" , "Fne")
-BUILTIN(__builtin_exp10f16, "hh" , "Fne")
-BUILTIN(__builtin_exp10l, "LdLd", "Fne")
-BUILTIN(__builtin_exp10f128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_expm1 , "dd", "Fne")
-BUILTIN(__builtin_expm1f, "ff", "Fne")
-BUILTIN(__builtin_expm1l, "LdLd", "Fne")
-BUILTIN(__builtin_expm1f128, "LLdLLd", "Fne")
-BUILTIN(__builtin_fdim, "ddd", "Fne")
-BUILTIN(__builtin_fdimf, "fff", "Fne")
-BUILTIN(__builtin_fdiml, "LdLdLd", "Fne")
-BUILTIN(__builtin_fdimf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_floor , "dd" , "Fnc")
-BUILTIN(__builtin_floorf, "ff" , "Fnc")
-BUILTIN(__builtin_floorf16, "hh" , "Fnc")
-BUILTIN(__builtin_floorl, "LdLd", "Fnc")
-BUILTIN(__builtin_floorf128, "LLdLLd", "Fnc")
-BUILTIN(__builtin_fma, "dddd", "Fne")
-BUILTIN(__builtin_fmaf, "ffff", "Fne")
-BUILTIN(__builtin_fmaf16, "hhhh", "Fne")
-BUILTIN(__builtin_fmal, "LdLdLdLd", "Fne")
-BUILTIN(__builtin_fmaf128, "LLdLLdLLdLLd", "Fne")
-BUILTIN(__builtin_fmax, "ddd", "FncE")
-BUILTIN(__builtin_fmaxf, "fff", "FncE")
-BUILTIN(__builtin_fmaxf16, "hhh", "FncE")
-BUILTIN(__builtin_fmaxl, "LdLdLd", "FncE")
-BUILTIN(__builtin_fmaxf128, "LLdLLdLLd", "FncE")
-BUILTIN(__builtin_fmin, "ddd", "FncE")
-BUILTIN(__builtin_fminf, "fff", "FncE")
-BUILTIN(__builtin_fminf16, "hhh", "FncE")
-BUILTIN(__builtin_fminl, "LdLdLd", "FncE")
-BUILTIN(__builtin_fminf128, "LLdLLdLLd", "FncE")
-BUILTIN(__builtin_hypot , "ddd" , "Fne")
-BUILTIN(__builtin_hypotf, "fff" , "Fne")
-BUILTIN(__builtin_hypotl, "LdLdLd", "Fne")
-BUILTIN(__builtin_hypotf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_ilogb , "id", "Fne")
-BUILTIN(__builtin_ilogbf, "if", "Fne")
-BUILTIN(__builtin_ilogbl, "iLd", "Fne")
-BUILTIN(__builtin_ilogbf128, "iLLd", "Fne")
-BUILTIN(__builtin_lgamma , "dd", "Fn")
-BUILTIN(__builtin_lgammaf, "ff", "Fn")
-BUILTIN(__builtin_lgammal, "LdLd", "Fn")
-BUILTIN(__builtin_lgammaf128, "LLdLLd", "Fn")
-BUILTIN(__builtin_llrint, "LLid", "Fne")
-BUILTIN(__builtin_llrintf, "LLif", "Fne")
-BUILTIN(__builtin_llrintl, "LLiLd", "Fne")
-BUILTIN(__builtin_llrintf128, "LLiLLd", "Fne")
-BUILTIN(__builtin_llround , "LLid", "Fne")
-BUILTIN(__builtin_llroundf, "LLif", "Fne")
-BUILTIN(__builtin_llroundl, "LLiLd", "Fne")
-BUILTIN(__builtin_llroundf128, "LLiLLd", "Fne")
-BUILTIN(__builtin_log , "dd" , "Fne")
-BUILTIN(__builtin_log10 , "dd" , "Fne")
-BUILTIN(__builtin_log10f, "ff" , "Fne")
-BUILTIN(__builtin_log10f16, "hh" , "Fne")
-BUILTIN(__builtin_log10l, "LdLd", "Fne")
-BUILTIN(__builtin_log10f128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_log1p , "dd" , "Fne")
-BUILTIN(__builtin_log1pf, "ff" , "Fne")
-BUILTIN(__builtin_log1pl, "LdLd", "Fne")
-BUILTIN(__builtin_log1pf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_log2, "dd" , "Fne")
-BUILTIN(__builtin_log2f, "ff" , "Fne")
-BUILTIN(__builtin_log2f16, "hh" , "Fne")
-BUILTIN(__builtin_log2l, "LdLd" , "Fne")
-BUILTIN(__builtin_log2f128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_logb , "dd", "Fne")
-BUILTIN(__builtin_logbf, "ff", "Fne")
-BUILTIN(__builtin_logbl, "LdLd", "Fne")
-BUILTIN(__builtin_logbf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_logf, "ff" , "Fne")
-BUILTIN(__builtin_logf16, "hh" , "Fne")
-BUILTIN(__builtin_logl, "LdLd", "Fne")
-BUILTIN(__builtin_logf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_lrint , "Lid", "Fne")
-BUILTIN(__builtin_lrintf, "Lif", "Fne")
-BUILTIN(__builtin_lrintl, "LiLd", "Fne")
-BUILTIN(__builtin_lrintf128, "LiLLd", "Fne")
-BUILTIN(__builtin_lround , "Lid", "Fne")
-BUILTIN(__builtin_lroundf, "Lif", "Fne")
-BUILTIN(__builtin_lroundl, "LiLd", "Fne")
-BUILTIN(__builtin_lroundf128, "LiLLd", "Fne")
-BUILTIN(__builtin_nearbyint , "dd", "Fnc")
-BUILTIN(__builtin_nearbyintf, "ff", "Fnc")
-BUILTIN(__builtin_nearbyintl, "LdLd", "Fnc")
-BUILTIN(__builtin_nearbyintf128, "LLdLLd", "Fnc")
-BUILTIN(__builtin_nextafter , "ddd", "Fne")
-BUILTIN(__builtin_nextafterf, "fff", "Fne")
-BUILTIN(__builtin_nextafterl, "LdLdLd", "Fne")
-BUILTIN(__builtin_nextafterf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_nexttoward , "ddLd", "Fne")
-BUILTIN(__builtin_nexttowardf, "ffLd", "Fne")
-BUILTIN(__builtin_nexttowardl, "LdLdLd", "Fne")
-BUILTIN(__builtin_nexttowardf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_remainder , "ddd", "Fne")
-BUILTIN(__builtin_remainderf, "fff", "Fne")
-BUILTIN(__builtin_remainderl, "LdLdLd", "Fne")
-BUILTIN(__builtin_remainderf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_remquo , "dddi*", "Fn")
-BUILTIN(__builtin_remquof, "fffi*", "Fn")
-BUILTIN(__builtin_remquol, "LdLdLdi*", "Fn")
-BUILTIN(__builtin_remquof128, "LLdLLdLLdi*", "Fn")
-BUILTIN(__builtin_rint , "dd", "Fnc")
-BUILTIN(__builtin_rintf, "ff", "Fnc")
-BUILTIN(__builtin_rintf16, "hh", "Fnc")
-BUILTIN(__builtin_rintl, "LdLd", "Fnc")
-BUILTIN(__builtin_rintf128, "LLdLLd", "Fnc")
-BUILTIN(__builtin_round, "dd" , "Fnc")
-BUILTIN(__builtin_roundf, "ff" , "Fnc")
-BUILTIN(__builtin_roundf16, "hh" , "Fnc")
-BUILTIN(__builtin_roundl, "LdLd" , "Fnc")
-BUILTIN(__builtin_roundf128, "LLdLLd" , "Fnc")
-BUILTIN(__builtin_roundeven, "dd" , "Fnc")
-BUILTIN(__builtin_roundevenf, "ff" , "Fnc")
-BUILTIN(__builtin_roundevenf16, "hh" , "Fnc")
-BUILTIN(__builtin_roundevenl, "LdLd" , "Fnc")
-BUILTIN(__builtin_roundevenf128, "LLdLLd" , "Fnc")
-BUILTIN(__builtin_scalbln , "ddLi", "Fne")
-BUILTIN(__builtin_scalblnf, "ffLi", "Fne")
-BUILTIN(__builtin_scalblnl, "LdLdLi", "Fne")
-BUILTIN(__builtin_scalblnf128, "LLdLLdLi", "Fne")
-BUILTIN(__builtin_scalbn , "ddi", "Fne")
-BUILTIN(__builtin_scalbnf, "ffi", "Fne")
-BUILTIN(__builtin_scalbnl, "LdLdi", "Fne")
-BUILTIN(__builtin_scalbnf128, "LLdLLdi", "Fne")
-BUILTIN(__builtin_sin , "dd" , "Fne")
-BUILTIN(__builtin_sinf, "ff" , "Fne")
-BUILTIN(__builtin_sinf16, "hh" , "Fne")
-BUILTIN(__builtin_sinh , "dd" , "Fne")
-BUILTIN(__builtin_sinhf, "ff" , "Fne")
-BUILTIN(__builtin_sinhl, "LdLd", "Fne")
-BUILTIN(__builtin_sinhf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_sinl, "LdLd", "Fne")
-BUILTIN(__builtin_sinf128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_sqrt , "dd" , "Fne")
-BUILTIN(__builtin_sqrtf, "ff" , "Fne")
-BUILTIN(__builtin_sqrtf16, "hh" , "Fne")
-BUILTIN(__builtin_sqrtl, "LdLd", "Fne")
-BUILTIN(__builtin_sqrtf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_tan , "dd" , "Fne")
-BUILTIN(__builtin_tanf, "ff" , "Fne")
-BUILTIN(__builtin_tanh , "dd" , "Fne")
-BUILTIN(__builtin_tanhf, "ff" , "Fne")
-BUILTIN(__builtin_tanhl, "LdLd", "Fne")
-BUILTIN(__builtin_tanhf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_tanl, "LdLd", "Fne")
-BUILTIN(__builtin_tanf128, "LLdLLd" , "Fne")
-BUILTIN(__builtin_tgamma , "dd", "Fne")
-BUILTIN(__builtin_tgammaf, "ff", "Fne")
-BUILTIN(__builtin_tgammal, "LdLd", "Fne")
-BUILTIN(__builtin_tgammaf128, "LLdLLd", "Fne")
-BUILTIN(__builtin_trunc , "dd", "Fnc")
-BUILTIN(__builtin_truncf, "ff", "Fnc")
-BUILTIN(__builtin_truncl, "LdLd", "Fnc")
-BUILTIN(__builtin_truncf128, "LLdLLd", "Fnc")
-BUILTIN(__builtin_truncf16, "hh", "Fnc")
-
-// Access to floating point environment
-BUILTIN(__builtin_flt_rounds, "i", "n")
-BUILTIN(__builtin_set_flt_rounds, "vi", "n")
-
-// C99 complex builtins
-BUILTIN(__builtin_cabs, "dXd", "Fne")
-BUILTIN(__builtin_cabsf, "fXf", "Fne")
-BUILTIN(__builtin_cabsl, "LdXLd", "Fne")
-BUILTIN(__builtin_cacos, "XdXd", "Fne")
-BUILTIN(__builtin_cacosf, "XfXf", "Fne")
-BUILTIN(__builtin_cacosh, "XdXd", "Fne")
-BUILTIN(__builtin_cacoshf, "XfXf", "Fne")
-BUILTIN(__builtin_cacoshl, "XLdXLd", "Fne")
-BUILTIN(__builtin_cacosl, "XLdXLd", "Fne")
-BUILTIN(__builtin_carg, "dXd", "Fne")
-BUILTIN(__builtin_cargf, "fXf", "Fne")
-BUILTIN(__builtin_cargl, "LdXLd", "Fne")
-BUILTIN(__builtin_casin, "XdXd", "Fne")
-BUILTIN(__builtin_casinf, "XfXf", "Fne")
-BUILTIN(__builtin_casinh, "XdXd", "Fne")
-BUILTIN(__builtin_casinhf, "XfXf", "Fne")
-BUILTIN(__builtin_casinhl, "XLdXLd", "Fne")
-BUILTIN(__builtin_casinl, "XLdXLd", "Fne")
-BUILTIN(__builtin_catan, "XdXd", "Fne")
-BUILTIN(__builtin_catanf, "XfXf", "Fne")
-BUILTIN(__builtin_catanh, "XdXd", "Fne")
-BUILTIN(__builtin_catanhf, "XfXf", "Fne")
-BUILTIN(__builtin_catanhl, "XLdXLd", "Fne")
-BUILTIN(__builtin_catanl, "XLdXLd", "Fne")
-BUILTIN(__builtin_ccos, "XdXd", "Fne")
-BUILTIN(__builtin_ccosf, "XfXf", "Fne")
-BUILTIN(__builtin_ccosl, "XLdXLd", "Fne")
-BUILTIN(__builtin_ccosh, "XdXd", "Fne")
-BUILTIN(__builtin_ccoshf, "XfXf", "Fne")
-BUILTIN(__builtin_ccoshl, "XLdXLd", "Fne")
-BUILTIN(__builtin_cexp, "XdXd", "Fne")
-BUILTIN(__builtin_cexpf, "XfXf", "Fne")
-BUILTIN(__builtin_cexpl, "XLdXLd", "Fne")
-BUILTIN(__builtin_cimag, "dXd", "Fnc")
-BUILTIN(__builtin_cimagf, "fXf", "Fnc")
-BUILTIN(__builtin_cimagl, "LdXLd", "Fnc")
-BUILTIN(__builtin_conj, "XdXd", "Fnc")
-BUILTIN(__builtin_conjf, "XfXf", "Fnc")
-BUILTIN(__builtin_conjl, "XLdXLd", "Fnc")
-BUILTIN(__builtin_clog, "XdXd", "Fne")
-BUILTIN(__builtin_clogf, "XfXf", "Fne")
-BUILTIN(__builtin_clogl, "XLdXLd", "Fne")
-BUILTIN(__builtin_cproj, "XdXd", "Fnc")
-BUILTIN(__builtin_cprojf, "XfXf", "Fnc")
-BUILTIN(__builtin_cprojl, "XLdXLd", "Fnc")
-BUILTIN(__builtin_cpow, "XdXdXd", "Fne")
-BUILTIN(__builtin_cpowf, "XfXfXf", "Fne")
-BUILTIN(__builtin_cpowl, "XLdXLdXLd", "Fne")
-BUILTIN(__builtin_creal, "dXd", "Fnc")
-BUILTIN(__builtin_crealf, "fXf", "Fnc")
-BUILTIN(__builtin_creall, "LdXLd", "Fnc")
-BUILTIN(__builtin_csin, "XdXd", "Fne")
-BUILTIN(__builtin_csinf, "XfXf", "Fne")
-BUILTIN(__builtin_csinl, "XLdXLd", "Fne")
-BUILTIN(__builtin_csinh, "XdXd", "Fne")
-BUILTIN(__builtin_csinhf, "XfXf", "Fne")
-BUILTIN(__builtin_csinhl, "XLdXLd", "Fne")
-BUILTIN(__builtin_csqrt, "XdXd", "Fne")
-BUILTIN(__builtin_csqrtf, "XfXf", "Fne")
-BUILTIN(__builtin_csqrtl, "XLdXLd", "Fne")
-BUILTIN(__builtin_ctan, "XdXd", "Fne")
-BUILTIN(__builtin_ctanf, "XfXf", "Fne")
-BUILTIN(__builtin_ctanl, "XLdXLd", "Fne")
-BUILTIN(__builtin_ctanh, "XdXd", "Fne")
-BUILTIN(__builtin_ctanhf, "XfXf", "Fne")
-BUILTIN(__builtin_ctanhl, "XLdXLd", "Fne")
-
-// GCC-compatible C99 CMPLX implementation.
-BUILTIN(__builtin_complex, "v.", "nctE")
-
-// FP Comparisons.
-BUILTIN(__builtin_isgreater , "i.", "Fnct")
-BUILTIN(__builtin_isgreaterequal, "i.", "Fnct")
-BUILTIN(__builtin_isless , "i.", "Fnct")
-BUILTIN(__builtin_islessequal , "i.", "Fnct")
-BUILTIN(__builtin_islessgreater , "i.", "Fnct")
-BUILTIN(__builtin_isunordered , "i.", "Fnct")
-
-// Unary FP classification
-BUILTIN(__builtin_fpclassify, "iiiiii.", "FnctE")
-BUILTIN(__builtin_isfinite, "i.", "FnctE")
-BUILTIN(__builtin_isinf, "i.", "FnctE")
-BUILTIN(__builtin_isinf_sign, "i.", "FnctE")
-BUILTIN(__builtin_isnan, "i.", "FnctE")
-BUILTIN(__builtin_isnormal, "i.", "FnctE")
-BUILTIN(__builtin_isfpclass, "i.", "nctE")
-
-// FP signbit builtins
-BUILTIN(__builtin_signbit, "i.", "Fnct")
-BUILTIN(__builtin_signbitf, "if", "Fnc")
-BUILTIN(__builtin_signbitl, "iLd", "Fnc")
-
-// Special FP builtins.
-BUILTIN(__builtin_canonicalize, "dd", "nc")
-BUILTIN(__builtin_canonicalizef, "ff", "nc")
-BUILTIN(__builtin_canonicalizef16, "hh", "nc")
-BUILTIN(__builtin_canonicalizel, "LdLd", "nc")
-
-// Builtins for arithmetic.
-BUILTIN(__builtin_clzs , "iUs" , "ncE")
-BUILTIN(__builtin_clz , "iUi" , "ncE")
-BUILTIN(__builtin_clzl , "iULi" , "ncE")
-BUILTIN(__builtin_clzll, "iULLi", "ncE")
-// TODO: int clzimax(uintmax_t)
-BUILTIN(__builtin_ctzs , "iUs" , "ncE")
-BUILTIN(__builtin_ctz , "iUi" , "ncE")
-BUILTIN(__builtin_ctzl , "iULi" , "ncE")
-BUILTIN(__builtin_ctzll, "iULLi", "ncE")
-// TODO: int ctzimax(uintmax_t)
-BUILTIN(__builtin_ffs , "ii" , "FncE")
-BUILTIN(__builtin_ffsl , "iLi" , "FncE")
-BUILTIN(__builtin_ffsll, "iLLi", "FncE")
-BUILTIN(__builtin_parity , "iUi" , "ncE")
-BUILTIN(__builtin_parityl , "iULi" , "ncE")
-BUILTIN(__builtin_parityll, "iULLi", "ncE")
-BUILTIN(__builtin_popcount , "iUi" , "ncE")
-BUILTIN(__builtin_popcountl , "iULi" , "ncE")
-BUILTIN(__builtin_popcountll, "iULLi", "ncE")
-BUILTIN(__builtin_clrsb , "ii" , "ncE")
-BUILTIN(__builtin_clrsbl , "iLi" , "ncE")
-BUILTIN(__builtin_clrsbll, "iLLi", "ncE")
-
-// The following builtins rely on that char == 8 bits, short == 16 bits and that
-// there exists native types on the target that are 32- and 64-bits wide, unless
-// these conditions are fulfilled these builtins will operate on a not intended
-// bitwidth.
-BUILTIN(__builtin_bswap16, "UsUs", "ncE")
-BUILTIN(__builtin_bswap32, "UZiUZi", "ncE")
-BUILTIN(__builtin_bswap64, "UWiUWi", "ncE")
-
-BUILTIN(__builtin_bitreverse8, "UcUc", "ncE")
-BUILTIN(__builtin_bitreverse16, "UsUs", "ncE")
-BUILTIN(__builtin_bitreverse32, "UZiUZi", "ncE")
-BUILTIN(__builtin_bitreverse64, "UWiUWi", "ncE")
-
-BUILTIN(__builtin_rotateleft8, "UcUcUc", "ncE")
-BUILTIN(__builtin_rotateleft16, "UsUsUs", "ncE")
-BUILTIN(__builtin_rotateleft32, "UZiUZiUZi", "ncE")
-BUILTIN(__builtin_rotateleft64, "UWiUWiUWi", "ncE")
-BUILTIN(__builtin_rotateright8, "UcUcUc", "ncE")
-BUILTIN(__builtin_rotateright16, "UsUsUs", "ncE")
-BUILTIN(__builtin_rotateright32, "UZiUZiUZi", "ncE")
-BUILTIN(__builtin_rotateright64, "UWiUWiUWi", "ncE")
-
-// Random GCC builtins
-BUILTIN(__builtin_calloc, "v*zz", "nF")
-BUILTIN(__builtin_constant_p, "i.", "nctuE")
-BUILTIN(__builtin_classify_type, "i.", "nctuE")
-BUILTIN(__builtin___CFStringMakeConstantString, "FC*cC*", "ncE")
-BUILTIN(__builtin___NSStringMakeConstantString, "FC*cC*", "ncE")
-BUILTIN(__builtin_va_start, "vA.", "nt")
-BUILTIN(__builtin_va_end, "vA", "n")
-BUILTIN(__builtin_va_copy, "vAA", "n")
-BUILTIN(__builtin_stdarg_start, "vA.", "nt")
-BUILTIN(__builtin_assume_aligned, "v*vC*z.", "nctE")
-BUILTIN(__builtin_bcmp, "ivC*vC*z", "FnE")
-BUILTIN(__builtin_bcopy, "vv*v*z", "n")
-BUILTIN(__builtin_bzero, "vv*z", "nF")
-BUILTIN(__builtin_free, "vv*", "nF")
-BUILTIN(__builtin_malloc, "v*z", "nF")
-BUILTIN(__builtin_memchr, "v*vC*iz", "nFE")
-BUILTIN(__builtin_memcmp, "ivC*vC*z", "nFE")
-BUILTIN(__builtin_memcpy, "v*v*vC*z", "nFE")
-BUILTIN(__builtin_memcpy_inline, "vv*vC*Iz", "n")
-BUILTIN(__builtin_memmove, "v*v*vC*z", "nFE")
-BUILTIN(__builtin_mempcpy, "v*v*vC*z", "nF")
-BUILTIN(__builtin_memset, "v*v*iz", "nF")
-BUILTIN(__builtin_memset_inline, "vv*iIz", "n")
-BUILTIN(__builtin_stpcpy, "c*c*cC*", "nF")
-BUILTIN(__builtin_stpncpy, "c*c*cC*z", "nF")
-BUILTIN(__builtin_strcasecmp, "icC*cC*", "nF")
-BUILTIN(__builtin_strcat, "c*c*cC*", "nF")
-BUILTIN(__builtin_strchr, "c*cC*i", "nFE")
-BUILTIN(__builtin_strcmp, "icC*cC*", "nFE")
-BUILTIN(__builtin_strcpy, "c*c*cC*", "nF")
-BUILTIN(__builtin_strcspn, "zcC*cC*", "nF")
-BUILTIN(__builtin_strdup, "c*cC*", "nF")
-BUILTIN(__builtin_strlen, "zcC*", "nFE")
-BUILTIN(__builtin_strncasecmp, "icC*cC*z", "nF")
-BUILTIN(__builtin_strncat, "c*c*cC*z", "nF")
-BUILTIN(__builtin_strncmp, "icC*cC*z", "nFE")
-BUILTIN(__builtin_strncpy, "c*c*cC*z", "nF")
-BUILTIN(__builtin_strndup, "c*cC*z", "nF")
-BUILTIN(__builtin_strpbrk, "c*cC*cC*", "nF")
-BUILTIN(__builtin_strrchr, "c*cC*i", "nF")
-BUILTIN(__builtin_strspn, "zcC*cC*", "nF")
-BUILTIN(__builtin_strstr, "c*cC*cC*", "nF")
-BUILTIN(__builtin_wcschr, "w*wC*w", "nFE")
-BUILTIN(__builtin_wcscmp, "iwC*wC*", "nFE")
-BUILTIN(__builtin_wcslen, "zwC*", "nFE")
-BUILTIN(__builtin_wcsncmp, "iwC*wC*z", "nFE")
-BUILTIN(__builtin_wmemchr, "w*wC*wz", "nFE")
-BUILTIN(__builtin_wmemcmp, "iwC*wC*z", "nFE")
-BUILTIN(__builtin_wmemcpy, "w*w*wC*z", "nFE")
-BUILTIN(__builtin_wmemmove, "w*w*wC*z", "nFE")
-BUILTIN(__builtin_realloc, "v*v*z", "nF")
-BUILTIN(__builtin_return_address, "v*IUi", "n")
-BUILTIN(__builtin_extract_return_addr, "v*v*", "n")
-BUILTIN(__builtin_frame_address, "v*IUi", "n")
-BUILTIN(__builtin___clear_cache, "vc*c*", "n")
-BUILTIN(__builtin_setjmp, "iv**", "j")
-BUILTIN(__builtin_longjmp, "vv**i", "r")
-BUILTIN(__builtin_unwind_init, "v", "")
-BUILTIN(__builtin_eh_return_data_regno, "iIi", "ncE")
-BUILTIN(__builtin_fprintf, "iP*RcC*R.", "nFp:1:")
-BUILTIN(__builtin_printf, "icC*R.", "nFp:0:")
-BUILTIN(__builtin_sprintf, "ic*RcC*R.", "nFp:1:")
-BUILTIN(__builtin_snprintf, "ic*RzcC*R.", "nFp:2:")
-BUILTIN(__builtin_vprintf, "icC*Ra", "nFP:0:")
-BUILTIN(__builtin_vfprintf, "iP*RcC*Ra", "nFP:1:")
-BUILTIN(__builtin_vsprintf, "ic*RcC*Ra", "nFP:1:")
-BUILTIN(__builtin_vsnprintf, "ic*RzcC*Ra", "nFP:2:")
-BUILTIN(__builtin_fscanf, "iP*RcC*R.", "Fs:1:")
-BUILTIN(__builtin_scanf, "icC*R.", "Fs:0:")
-BUILTIN(__builtin_sscanf, "icC*RcC*R.", "Fs:1:")
-BUILTIN(__builtin_vfscanf, "iP*RcC*Ra", "FS:1:")
-BUILTIN(__builtin_vscanf, "icC*Ra", "FS:0:")
-BUILTIN(__builtin_vsscanf, "icC*RcC*Ra", "FS:1:")
-BUILTIN(__builtin_thread_pointer, "v*", "nc")
-BUILTIN(__builtin_launder, "v*v*", "ntE")
-LANGBUILTIN(__builtin_is_constant_evaluated, "b", "nE", CXX_LANG)
-
-// GCC exception builtins
-BUILTIN(__builtin_eh_return, "vzv*", "r") // FIXME: Takes intptr_t, not size_t!
-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")
-BUILTIN(__builtin_extend_pointer, "ULLiv*", "n") // _Unwind_Word == uint64_t
-
-// GCC Object size checking builtins
-BUILTIN(__builtin_object_size, "zvC*i", "nuE")
-BUILTIN(__builtin_dynamic_object_size, "zvC*i", "nuE") // Clang only.
-BUILTIN(__builtin___memcpy_chk, "v*v*vC*zz", "nF")
-BUILTIN(__builtin___memccpy_chk, "v*v*vC*izz", "nF")
-BUILTIN(__builtin___memmove_chk, "v*v*vC*zz", "nF")
-BUILTIN(__builtin___mempcpy_chk, "v*v*vC*zz", "nF")
-BUILTIN(__builtin___memset_chk, "v*v*izz", "nF")
-BUILTIN(__builtin___stpcpy_chk, "c*c*cC*z", "nF")
-BUILTIN(__builtin___strcat_chk, "c*c*cC*z", "nF")
-BUILTIN(__builtin___strcpy_chk, "c*c*cC*z", "nF")
-BUILTIN(__builtin___strlcat_chk, "zc*cC*zz", "nF")
-BUILTIN(__builtin___strlcpy_chk, "zc*cC*zz", "nF")
-BUILTIN(__builtin___strncat_chk, "c*c*cC*zz", "nF")
-BUILTIN(__builtin___strncpy_chk, "c*c*cC*zz", "nF")
-BUILTIN(__builtin___stpncpy_chk, "c*c*cC*zz", "nF")
-BUILTIN(__builtin___snprintf_chk, "ic*RzizcC*R.", "Fp:4:")
-BUILTIN(__builtin___sprintf_chk, "ic*RizcC*R.", "Fp:3:")
-BUILTIN(__builtin___vsnprintf_chk, "ic*RzizcC*Ra", "FP:4:")
-BUILTIN(__builtin___vsprintf_chk, "ic*RizcC*Ra", "FP:3:")
-BUILTIN(__builtin___fprintf_chk, "iP*RicC*R.", "Fp:2:")
-BUILTIN(__builtin___printf_chk, "iicC*R.", "Fp:1:")
-BUILTIN(__builtin___vfprintf_chk, "iP*RicC*Ra", "FP:2:")
-BUILTIN(__builtin___vprintf_chk, "iicC*Ra", "FP:1:")
-
-BUILTIN(__builtin_unpredictable, "LiLi" , "nc")
-BUILTIN(__builtin_expect, "LiLiLi" , "ncE")
-BUILTIN(__builtin_expect_with_probability, "LiLiLid", "ncE")
-BUILTIN(__builtin_prefetch, "vvC*.", "nc")
-BUILTIN(__builtin_readcyclecounter, "ULLi", "n")
-BUILTIN(__builtin_trap, "v", "nr")
-BUILTIN(__builtin_debugtrap, "v", "n")
-BUILTIN(__builtin_unreachable, "v", "nr")
-BUILTIN(__builtin_shufflevector, "v." , "nct")
-BUILTIN(__builtin_convertvector, "v." , "nct")
-BUILTIN(__builtin_alloca, "v*z" , "Fn")
-BUILTIN(__builtin_alloca_uninitialized, "v*z", "Fn")
-BUILTIN(__builtin_alloca_with_align, "v*zIz", "Fn")
-BUILTIN(__builtin_alloca_with_align_uninitialized, "v*zIz", "Fn")
-BUILTIN(__builtin_call_with_static_chain, "v.", "nt")
-BUILTIN(__builtin_nondeterministic_value, "v.", "nt")
-
-BUILTIN(__builtin_elementwise_abs, "v.", "nct")
-BUILTIN(__builtin_elementwise_bitreverse, "v.", "nct")
-BUILTIN(__builtin_elementwise_max, "v.", "nct")
-BUILTIN(__builtin_elementwise_min, "v.", "nct")
-BUILTIN(__builtin_elementwise_ceil, "v.", "nct")
-BUILTIN(__builtin_elementwise_cos, "v.", "nct")
-BUILTIN(__builtin_elementwise_exp, "v.", "nct")
-BUILTIN(__builtin_elementwise_exp2, "v.", "nct")
-BUILTIN(__builtin_elementwise_floor, "v.", "nct")
-BUILTIN(__builtin_elementwise_log, "v.", "nct")
-BUILTIN(__builtin_elementwise_log2, "v.", "nct")
-BUILTIN(__builtin_elementwise_log10, "v.", "nct")
-BUILTIN(__builtin_elementwise_pow, "v.", "nct")
-BUILTIN(__builtin_elementwise_roundeven, "v.", "nct")
-BUILTIN(__builtin_elementwise_round, "v.", "nct")
-BUILTIN(__builtin_elementwise_rint, "v.", "nct")
-BUILTIN(__builtin_elementwise_nearbyint, "v.", "nct")
-BUILTIN(__builtin_elementwise_sin, "v.", "nct")
-BUILTIN(__builtin_elementwise_sqrt, "v.", "nct")
-BUILTIN(__builtin_elementwise_trunc, "v.", "nct")
-BUILTIN(__builtin_elementwise_canonicalize, "v.", "nct")
-BUILTIN(__builtin_elementwise_copysign, "v.", "nct")
-BUILTIN(__builtin_elementwise_fma, "v.", "nct")
-BUILTIN(__builtin_elementwise_add_sat, "v.", "nct")
-BUILTIN(__builtin_elementwise_sub_sat, "v.", "nct")
-BUILTIN(__builtin_reduce_max, "v.", "nct")
-BUILTIN(__builtin_reduce_min, "v.", "nct")
-BUILTIN(__builtin_reduce_xor, "v.", "nct")
-BUILTIN(__builtin_reduce_or, "v.", "nct")
-BUILTIN(__builtin_reduce_and, "v.", "nct")
-BUILTIN(__builtin_reduce_add, "v.", "nct")
-BUILTIN(__builtin_reduce_mul, "v.", "nct")
-
-BUILTIN(__builtin_matrix_transpose, "v.", "nFt")
-BUILTIN(__builtin_matrix_column_major_load, "v.", "nFt")
-BUILTIN(__builtin_matrix_column_major_store, "v.", "nFt")
-
-// "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).
-
-// FIXME: These assume that char -> i8, short -> i16, int -> i32,
-// long long -> i64.
-
-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")
-
-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")
-
-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")
-
-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")
-
-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")
-
-// 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
-
-// C11 _Atomic operations for <stdatomic.h>.
-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")
-ATOMIC_BUILTIN(__c11_atomic_fetch_nand, "v.", "t")
-ATOMIC_BUILTIN(__c11_atomic_fetch_max, "v.", "t")
-ATOMIC_BUILTIN(__c11_atomic_fetch_min, "v.", "t")
-BUILTIN(__c11_atomic_thread_fence, "vi", "n")
-BUILTIN(__c11_atomic_signal_fence, "vi", "n")
-BUILTIN(__c11_atomic_is_lock_free, "bz", "nE")
-
-// 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")
-ATOMIC_BUILTIN(__atomic_fetch_nand, "v.", "t")
-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")
-ATOMIC_BUILTIN(__atomic_max_fetch, "v.", "t")
-ATOMIC_BUILTIN(__atomic_min_fetch, "v.", "t")
-ATOMIC_BUILTIN(__atomic_nand_fetch, "v.", "t")
-BUILTIN(__atomic_test_and_set, "bvD*i", "n")
-BUILTIN(__atomic_clear, "vvD*i", "n")
-BUILTIN(__atomic_thread_fence, "vi", "n")
-BUILTIN(__atomic_signal_fence, "vi", "n")
-BUILTIN(__atomic_always_lock_free, "bzvCD*", "nE")
-BUILTIN(__atomic_is_lock_free, "bzvCD*", "nE")
-
-// OpenCL 2.0 atomic builtins.
-ATOMIC_BUILTIN(__opencl_atomic_init, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_load, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_store, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_exchange, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_compare_exchange_strong, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_compare_exchange_weak, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_add, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_sub, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_and, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_or, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_xor, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_min, "v.", "t")
-ATOMIC_BUILTIN(__opencl_atomic_fetch_max, "v.", "t")
-
-// GCC does not support these, they are a Clang extension.
-ATOMIC_BUILTIN(__atomic_fetch_min, "v.", "t")
-ATOMIC_BUILTIN(__atomic_fetch_max, "v.", "t")
-
-// HIP atomic builtins.
-ATOMIC_BUILTIN(__hip_atomic_load, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_store, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_compare_exchange_weak, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_compare_exchange_strong, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_exchange, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_add, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_sub, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_and, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_or, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_xor, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_min, "v.", "t")
-ATOMIC_BUILTIN(__hip_atomic_fetch_max, "v.", "t")
-
-#undef ATOMIC_BUILTIN
-
-// Non-overloaded atomic builtins.
-BUILTIN(__sync_synchronize, "v", "n")
-// GCC does not support these, they are a Clang extension.
-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")
-
-// Random libc builtins.
-BUILTIN(__builtin_abort, "v", "Fnr")
-BUILTIN(__builtin_index, "c*cC*i", "Fn")
-BUILTIN(__builtin_rindex, "c*cC*i", "Fn")
-
-// ignored glibc builtin, see https://sourceware.org/bugzilla/show_bug.cgi?id=25399
-BUILTIN(__warn_memset_zero_len, "v", "nU")
-
-// Microsoft builtins. These are only active with -fms-extensions.
-LANGBUILTIN(_alloca, "v*z", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__annotation, "wC*.","n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__assume, "vb", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittest, "UcNiC*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittestandcomplement, "UcNi*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittestandreset, "UcNi*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittestandset, "UcNi*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittest64, "UcWiC*Wi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittestandcomplement64, "UcWi*Wi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittestandreset64, "UcWi*Wi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_bittestandset64, "UcWi*Wi", "n", ALL_MS_LANGUAGES)
-LIBBUILTIN(_byteswap_ushort, "UsUs", "fnc", STDLIB_H, ALL_MS_LANGUAGES)
-LIBBUILTIN(_byteswap_ulong, "UNiUNi", "fnc", STDLIB_H, ALL_MS_LANGUAGES)
-LIBBUILTIN(_byteswap_uint64, "ULLiULLi", "fnc", STDLIB_H, ALL_MS_LANGUAGES)
-LANGBUILTIN(__debugbreak, "v", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__exception_code, "UNi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_exception_code, "UNi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__exception_info, "v*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_exception_info, "v*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__abnormal_termination, "i", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_abnormal_termination, "i", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__GetExceptionInfo, "v*.", "zntu", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedAnd8, "ccD*c", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedAnd16, "ssD*s", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedAnd, "NiNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedCompareExchange8, "ccD*cc", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedCompareExchange16, "ssD*ss", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedCompareExchange, "NiNiD*NiNi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedCompareExchange64, "LLiLLiD*LLiLLi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedCompareExchangePointer, "v*v*D*v*v*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedCompareExchangePointer_nf, "v*v*D*v*v*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedDecrement16, "ssD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedDecrement, "NiNiD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedExchange, "NiNiD*Ni", "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, "NiNiD*Ni", "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, "NiNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedIncrement16, "ssD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedIncrement, "NiNiD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedOr8, "ccD*c", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedOr16, "ssD*s", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedOr, "NiNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedXor8, "ccD*c", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedXor16, "ssD*s", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_InterlockedXor, "NiNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandreset, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandreset64, "UcWiD*Wi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandreset_acq, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandreset_nf, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandreset_rel, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandset, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandset64, "UcWiD*Wi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandset_acq, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandset_nf, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_interlockedbittestandset_rel, "UcNiD*Ni", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_load8, "ccCD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_load16, "ssCD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_load32, "iiCD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_load64, "LLiLLiCD*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_store8, "vcD*c", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_store16, "vsD*s", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_store32, "viD*i", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__iso_volatile_store64, "vLLiD*LLi", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__noop, "i.", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__lzcnt16, "UsUs", "ncE", ALL_MS_LANGUAGES)
-LANGBUILTIN(__lzcnt, "UiUi", "ncE", ALL_MS_LANGUAGES)
-LANGBUILTIN(__lzcnt64, "UWiUWi", "ncE", ALL_MS_LANGUAGES)
-LANGBUILTIN(__popcnt16, "UsUs", "ncE", ALL_MS_LANGUAGES)
-LANGBUILTIN(__popcnt, "UiUi", "ncE", ALL_MS_LANGUAGES)
-LANGBUILTIN(__popcnt64, "UWiUWi", "ncE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_ReturnAddress, "v*", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotl8, "UcUcUc", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotl16, "UsUsUc", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotl, "UiUii", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_lrotl, "ULiULii", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotl64, "UWiUWii", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotr8, "UcUcUc", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotr16, "UsUsUc", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotr, "UiUii", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_lrotr, "ULiULii", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(_rotr64, "UWiUWii", "nE", ALL_MS_LANGUAGES)
-LANGBUILTIN(__va_start, "vc**.", "nt", ALL_MS_LANGUAGES)
-LANGBUILTIN(__fastfail, "vUi", "nr", ALL_MS_LANGUAGES)
-
-// Microsoft library builtins.
-LIBBUILTIN(_setjmpex, "iJ", "fjT", SETJMPEX_H, ALL_MS_LANGUAGES)
-
-// C99 library functions
-// C99 stdarg.h
-LIBBUILTIN(va_start, "vA.", "fn", STDARG_H, ALL_LANGUAGES)
-LIBBUILTIN(va_end, "vA", "fn", STDARG_H, ALL_LANGUAGES)
-LIBBUILTIN(va_copy, "vAA", "fn", STDARG_H, ALL_LANGUAGES)
-// C99 stdlib.h
-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)
-LIBBUILTIN(free, "vv*", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtod, "dcC*c**", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtof, "fcC*c**", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtold, "LdcC*c**", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtol, "LicC*c**i", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtoll, "LLicC*c**i", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtoul, "ULicC*c**i", "f", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(strtoull, "ULLicC*c**i", "f", STDLIB_H, ALL_LANGUAGES)
-// C11 stdlib.h
-LIBBUILTIN(aligned_alloc, "v*zz", "f", STDLIB_H, ALL_LANGUAGES)
-// C99 string.h
-LIBBUILTIN(memcpy, "v*v*vC*z", "fE", STRING_H, ALL_LANGUAGES)
-LIBBUILTIN(memcmp, "ivC*vC*z", "fE", STRING_H, ALL_LANGUAGES)
-LIBBUILTIN(memmove, "v*v*vC*z", "fE", 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)
-LIBBUILTIN(strcmp, "icC*cC*", "fE", STRING_H, ALL_LANGUAGES)
-LIBBUILTIN(strncmp, "icC*cC*z", "fE", STRING_H, ALL_LANGUAGES)
-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", "fE", STRING_H, ALL_LANGUAGES)
-LIBBUILTIN(strchr, "c*cC*i", "fE", 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*", "fE", STRING_H, ALL_LANGUAGES)
-// C99 stdio.h
-// FIXME: This list is incomplete.
-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, "iP*cC*a", "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)
-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)
-LIBBUILTIN(fopen, "P*cC*cC*", "f", STDIO_H, ALL_LANGUAGES)
-LIBBUILTIN(fread, "zv*zzP*", "f", STDIO_H, ALL_LANGUAGES)
-LIBBUILTIN(fwrite, "zvC*zzP*", "f", STDIO_H, ALL_LANGUAGES)
-
-// 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)
-// C99 wchar.h
-// FIXME: This list is incomplete. We should cover at least the functions that
-// take format strings.
-LIBBUILTIN(wcschr, "w*wC*w", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wcscmp, "iwC*wC*", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wcslen, "zwC*", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wcsncmp, "iwC*wC*z", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wmemchr, "w*wC*wz", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wmemcmp, "iwC*wC*z", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wmemcpy, "w*w*wC*z", "fE", WCHAR_H, ALL_LANGUAGES)
-LIBBUILTIN(wmemmove,"w*w*wC*z", "fE", WCHAR_H, ALL_LANGUAGES)
-
-// C99
-// In some systems setjmp is a macro that expands to _setjmp. We undefine
-// it here to avoid having two identical LIBBUILTIN entries.
-#undef setjmp
-LIBBUILTIN(setjmp, "iJ", "fjT", SETJMP_H, ALL_LANGUAGES)
-LIBBUILTIN(longjmp, "vJi", "frT", SETJMP_H, ALL_LANGUAGES)
-
-// Non-C library functions, active in GNU mode only.
-// 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.
-LIBBUILTIN(alloca, "v*z", "f", STDLIB_H, ALL_GNU_LANGUAGES)
-// POSIX malloc.h
-LIBBUILTIN(memalign, "v*zz", "f", MALLOC_H, ALL_GNU_LANGUAGES)
-// POSIX string.h
-LIBBUILTIN(memccpy, "v*v*vC*iz", "f", STRING_H, ALL_GNU_LANGUAGES)
-LIBBUILTIN(mempcpy, "v*v*vC*z", "f", STRING_H, ALL_GNU_LANGUAGES)
-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)
-// POSIX strings.h
-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)
-LIBBUILTIN(bcmp, "ivC*vC*z", "fE", STRINGS_H, ALL_GNU_LANGUAGES)
-// 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
-LIBBUILTIN(strcasecmp, "icC*cC*", "f", STRINGS_H, ALL_GNU_LANGUAGES)
-LIBBUILTIN(strncasecmp, "icC*cC*z", "f", STRINGS_H, ALL_GNU_LANGUAGES)
-// POSIX unistd.h
-LIBBUILTIN(_exit, "vi", "fr", UNISTD_H, ALL_GNU_LANGUAGES)
-LIBBUILTIN(vfork, "p", "fjT", UNISTD_H, ALL_LANGUAGES)
-// POSIX pthread.h
-// FIXME: Should specify argument types.
-LIBBUILTIN(pthread_create, "", "fC<2,3>", PTHREAD_H, ALL_GNU_LANGUAGES)
-
-// POSIX setjmp.h
-
-// FIXME: MinGW _setjmp has an additional void* parameter.
-LIBBUILTIN(_setjmp, "iJ", "fjT", SETJMP_H, ALL_LANGUAGES)
-LIBBUILTIN(__sigsetjmp, "iSJi", "fjT", SETJMP_H, ALL_LANGUAGES)
-LIBBUILTIN(sigsetjmp, "iSJi", "fjT", SETJMP_H, ALL_LANGUAGES)
-LIBBUILTIN(savectx, "iJ", "fjT", SETJMP_H, ALL_LANGUAGES)
-LIBBUILTIN(getcontext, "iK*", "fjT", SETJMP_H, ALL_LANGUAGES)
-
-LIBBUILTIN(_longjmp, "vJi", "frT", SETJMP_H, ALL_GNU_LANGUAGES)
-LIBBUILTIN(siglongjmp, "vSJi", "frT", SETJMP_H, ALL_GNU_LANGUAGES)
-// non-standard but very common
-LIBBUILTIN(strlcpy, "zc*cC*z", "f", STRING_H, ALL_GNU_LANGUAGES)
-LIBBUILTIN(strlcat, "zc*cC*z", "f", STRING_H, ALL_GNU_LANGUAGES)
-// id objc_msgSend(id, SEL, ...)
-LIBBUILTIN(objc_msgSend, "GGH.", "f", OBJC_MESSAGE_H, OBJC_LANG)
-// long double objc_msgSend_fpret(id self, SEL op, ...)
-LIBBUILTIN(objc_msgSend_fpret, "LdGH.", "f", OBJC_MESSAGE_H, OBJC_LANG)
-// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
-LIBBUILTIN(objc_msgSend_fp2ret, "XLdGH.", "f", OBJC_MESSAGE_H, OBJC_LANG)
-// void objc_msgSend_stret (id, SEL, ...)
-LIBBUILTIN(objc_msgSend_stret, "vGH.", "f", OBJC_MESSAGE_H, OBJC_LANG)
-// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
-LIBBUILTIN(objc_msgSendSuper, "GM*H.", "f", OBJC_MESSAGE_H, OBJC_LANG)
-// void objc_msgSendSuper_stret(struct objc_super *super, SEL op, ...)
-LIBBUILTIN(objc_msgSendSuper_stret, "vM*H.", "f", OBJC_MESSAGE_H, OBJC_LANG)
-// id objc_getClass(const char *name)
-LIBBUILTIN(objc_getClass, "GcC*", "f", OBJC_RUNTIME_H, OBJC_LANG)
-// 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)
-LIBBUILTIN(objc_read_weak, "GG*", "f", OBJC_OBJC_AUTO_H, OBJC_LANG)
-// id objc_assign_weak(id value, id *location)
-LIBBUILTIN(objc_assign_weak, "GGG*", "f", OBJC_OBJC_AUTO_H, OBJC_LANG)
-// id objc_assign_ivar(id value, id dest, ptrdiff_t offset)
-LIBBUILTIN(objc_assign_ivar, "GGGY", "f", OBJC_OBJC_AUTO_H, OBJC_LANG)
-// id objc_assign_global(id val, id *dest)
-LIBBUILTIN(objc_assign_global, "GGG*", "f", OBJC_OBJC_AUTO_H, OBJC_LANG)
-// id objc_assign_strongCast(id val, id *dest
-LIBBUILTIN(objc_assign_strongCast, "GGG*", "f", OBJC_OBJC_AUTO_H, OBJC_LANG)
-
-// id objc_exception_extract(void *localExceptionData)
-LIBBUILTIN(objc_exception_extract, "Gv*", "f", OBJC_OBJC_EXCEPTION_H, OBJC_LANG)
-// void objc_exception_try_enter(void *localExceptionData)
-LIBBUILTIN(objc_exception_try_enter, "vv*", "f", OBJC_OBJC_EXCEPTION_H, OBJC_LANG)
-// void objc_exception_try_exit(void *localExceptionData)
-LIBBUILTIN(objc_exception_try_exit, "vv*", "f", OBJC_OBJC_EXCEPTION_H, OBJC_LANG)
-// int objc_exception_match(Class exceptionClass, id exception)
-LIBBUILTIN(objc_exception_match, "iGG", "f", OBJC_OBJC_EXCEPTION_H, OBJC_LANG)
-// void objc_exception_throw(id exception)
-LIBBUILTIN(objc_exception_throw, "vG", "f", OBJC_OBJC_EXCEPTION_H, OBJC_LANG)
-
-// int objc_sync_enter(id obj)
-LIBBUILTIN(objc_sync_enter, "iG", "f", OBJC_OBJC_SYNC_H, OBJC_LANG)
-// int objc_sync_exit(id obj)
-LIBBUILTIN(objc_sync_exit, "iG", "f", OBJC_OBJC_SYNC_H, OBJC_LANG)
-
-BUILTIN(__builtin_objc_memmove_collectable, "v*v*vC*z", "nF")
-
-// 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)
-
-// Builtin math library functions
-LIBBUILTIN(atan2, "ddd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(atan2f, "fff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(atan2l, "LdLdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(abs, "ii", "fnc", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(labs, "LiLi", "fnc", STDLIB_H, ALL_LANGUAGES)
-LIBBUILTIN(llabs, "LLiLLi", "fnc", STDLIB_H, ALL_LANGUAGES)
-
-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)
-
-// Some systems define finitef as alias of _finitef.
-#if defined (finitef)
-#undef finitef
-#endif
-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)
-
-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*", "fUn", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nanf, "fcC*", "fUn", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nanl, "LdcC*", "fUn", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(pow, "ddd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(powf, "fff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(powl, "LdLdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(acos, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(acosf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(acosl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(acosh, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(acoshf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(acoshl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(asin, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(asinf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(asinl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(asinh, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(asinhf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(asinhl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(atan, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(atanf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(atanl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-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", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(cbrtf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(cbrtl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(ceil, "dd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(ceilf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(ceill, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(cos, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(cosf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(cosl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-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)
-
-LIBBUILTIN(exp, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(expf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(expl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(exp2, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(exp2f, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(exp2l, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-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)
-
-LIBBUILTIN(floor, "dd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(floorf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(floorl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(fma, "dddd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(fmaf, "ffff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(fmal, "LdLdLdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(fmax, "ddd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(fmaxf, "fff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(fmaxl, "LdLdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(fmin, "ddd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(fminf, "fff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(fminl, "LdLdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-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)
-
-// POSIX math.h declares a global, signgam, that lgamma writes to, so these
-// shouldn't have "e", "c" or "g" attributes
-LIBBUILTIN(lgamma, "dd", "fn", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(lgammaf, "ff", "fn", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(lgammal, "LdLd", "fn", 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)
-
-LIBBUILTIN(log, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(logf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(logl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-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)
-
-LIBBUILTIN(log2, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(log2f, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(log2l, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-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)
-
-LIBBUILTIN(nearbyint, "dd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nearbyintf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nearbyintl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(nextafter, "ddd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nextafterf, "fff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nextafterl, "LdLdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(nexttoward, "ddLd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(nexttowardf, "ffLd", "fne", MATH_H, ALL_LANGUAGES)
-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)
-
-LIBBUILTIN(remquo, "dddi*", "fn", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(remquof, "fffi*", "fn", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(remquol, "LdLdLdi*", "fn", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(rint, "dd", "fng", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(rintf, "ff", "fng", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(rintl, "LdLd", "fng", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(round, "dd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(roundf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(roundl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(roundeven, "dd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(roundevenf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(roundevenl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-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)
-
-LIBBUILTIN(sin, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(sinf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(sinl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(sinh, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(sinhf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(sinhl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(sqrt, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(sqrtf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(sqrtl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(tan, "dd", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(tanf, "ff", "fne", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(tanl, "LdLd", "fne", MATH_H, ALL_LANGUAGES)
-
-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)
-
-LIBBUILTIN(trunc, "dd", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(truncf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
-LIBBUILTIN(truncl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
-
-LIBBUILTIN(cabs, "dXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cabsf, "fXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cabsl, "LdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(cacos, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cacosf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cacosl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(cacosh, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cacoshf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cacoshl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(carg, "dXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cargf, "fXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cargl, "LdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(casin, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(casinf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(casinl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(casinh, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(casinhf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(casinhl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(catan, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(catanf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(catanl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(catanh, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(catanhf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(catanhl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(ccos, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ccosf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ccosl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(ccosh, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ccoshf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ccoshl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(cexp, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cexpf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cexpl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(cimag, "dXd", "fnc", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cimagf, "fXf", "fnc", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cimagl, "LdXLd", "fnc", COMPLEX_H, ALL_LANGUAGES)
-
-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", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(clogf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(clogl, "XLdXLd", "fne", 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", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cpowf, "XfXfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(cpowl, "XLdXLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(creal, "dXd", "fnc", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(crealf, "fXf", "fnc", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(creall, "LdXLd", "fnc", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(csin, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(csinf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(csinl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(csinh, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(csinhf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(csinhl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(csqrt, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(csqrtf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(csqrtl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(ctan, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ctanf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ctanl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-LIBBUILTIN(ctanh, "XdXd", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ctanhf, "XfXf", "fne", COMPLEX_H, ALL_LANGUAGES)
-LIBBUILTIN(ctanhl, "XLdXLd", "fne", COMPLEX_H, ALL_LANGUAGES)
-
-// __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)
-
-// Blocks runtime Builtin math library functions
-LIBBUILTIN(_Block_object_assign, "vv*vC*iC", "f", BLOCKS_H, ALL_LANGUAGES)
-LIBBUILTIN(_Block_object_dispose, "vvC*iC", "f", BLOCKS_H, ALL_LANGUAGES)
-// FIXME: Also declare NSConcreteGlobalBlock and NSConcreteStackBlock.
-
-// C++ standard library builtins in namespace 'std'.
-LIBBUILTIN(addressof, "v*v&", "zfncThE", MEMORY, CXX_LANG)
-// Synonym for addressof used internally by libstdc++.
-LANGBUILTIN(__addressof, "v*v&", "zfncTE", CXX_LANG)
-LIBBUILTIN(as_const, "v&v&", "zfncThE", UTILITY, CXX_LANG)
-LIBBUILTIN(forward, "v&v&", "zfncThE", UTILITY, CXX_LANG)
-LIBBUILTIN(forward_like, "v&v&", "zfncThE", UTILITY, CXX_LANG)
-LIBBUILTIN(move, "v&v&", "zfncThE", UTILITY, CXX_LANG)
-LIBBUILTIN(move_if_noexcept, "v&v&", "zfncThE", UTILITY, CXX_LANG)
-
-// Annotation function
-BUILTIN(__builtin_annotation, "v.", "tn")
-
-// Invariants
-BUILTIN(__builtin_assume, "vb", "nE")
-BUILTIN(__builtin_assume_separate_storage, "vvCD*vCD*", "nE")
-
-// Multiprecision Arithmetic Builtins.
-BUILTIN(__builtin_addcb, "UcUcCUcCUcCUc*", "n")
-BUILTIN(__builtin_addcs, "UsUsCUsCUsCUs*", "n")
-BUILTIN(__builtin_addc, "UiUiCUiCUiCUi*", "n")
-BUILTIN(__builtin_addcl, "ULiULiCULiCULiCULi*", "n")
-BUILTIN(__builtin_addcll, "ULLiULLiCULLiCULLiCULLi*", "n")
-BUILTIN(__builtin_subcb, "UcUcCUcCUcCUc*", "n")
-BUILTIN(__builtin_subcs, "UsUsCUsCUsCUs*", "n")
-BUILTIN(__builtin_subc, "UiUiCUiCUiCUi*", "n")
-BUILTIN(__builtin_subcl, "ULiULiCULiCULiCULi*", "n")
-BUILTIN(__builtin_subcll, "ULLiULLiCULLiCULLiCULLi*", "n")
-
-// Checked Arithmetic Builtins for Security.
-BUILTIN(__builtin_add_overflow, "b.", "ntE")
-BUILTIN(__builtin_sub_overflow, "b.", "ntE")
-BUILTIN(__builtin_mul_overflow, "b.", "ntE")
-BUILTIN(__builtin_uadd_overflow, "bUiCUiCUi*", "nE")
-BUILTIN(__builtin_uaddl_overflow, "bULiCULiCULi*", "nE")
-BUILTIN(__builtin_uaddll_overflow, "bULLiCULLiCULLi*", "nE")
-BUILTIN(__builtin_usub_overflow, "bUiCUiCUi*", "nE")
-BUILTIN(__builtin_usubl_overflow, "bULiCULiCULi*", "nE")
-BUILTIN(__builtin_usubll_overflow, "bULLiCULLiCULLi*", "nE")
-BUILTIN(__builtin_umul_overflow, "bUiCUiCUi*", "nE")
-BUILTIN(__builtin_umull_overflow, "bULiCULiCULi*", "nE")
-BUILTIN(__builtin_umulll_overflow, "bULLiCULLiCULLi*", "nE")
-BUILTIN(__builtin_sadd_overflow, "bSiCSiCSi*", "nE")
-BUILTIN(__builtin_saddl_overflow, "bSLiCSLiCSLi*", "nE")
-BUILTIN(__builtin_saddll_overflow, "bSLLiCSLLiCSLLi*", "nE")
-BUILTIN(__builtin_ssub_overflow, "bSiCSiCSi*", "nE")
-BUILTIN(__builtin_ssubl_overflow, "bSLiCSLiCSLi*", "nE")
-BUILTIN(__builtin_ssubll_overflow, "bSLLiCSLLiCSLLi*", "nE")
-BUILTIN(__builtin_smul_overflow, "bSiCSiCSi*", "nE")
-BUILTIN(__builtin_smull_overflow, "bSLiCSLiCSLi*", "nE")
-BUILTIN(__builtin_smulll_overflow, "bSLLiCSLLiCSLLi*", "nE")
-
-// Clang builtins (not available in GCC).
-BUILTIN(__builtin_addressof, "v*v&", "nctE")
-BUILTIN(__builtin_function_start, "v*v&", "nctE")
-BUILTIN(__builtin_operator_new, "v*z", "tcE")
-BUILTIN(__builtin_operator_delete, "vv*", "tnE")
-BUILTIN(__builtin_char_memchr, "c*cC*iz", "nE")
-BUILTIN(__builtin_dump_struct, "v.", "t")
-BUILTIN(__builtin_preserve_access_index, "v.", "t")
-
-// Alignment builtins (uses custom parsing to support pointers and integers)
-BUILTIN(__builtin_is_aligned, "bvC*z", "nctE")
-BUILTIN(__builtin_align_up, "v*vC*z", "nctE")
-BUILTIN(__builtin_align_down, "v*vC*z", "nctE")
-
-// Safestack builtins
-BUILTIN(__builtin___get_unsafe_stack_start, "v*", "Fn")
-BUILTIN(__builtin___get_unsafe_stack_bottom, "v*", "Fn")
-BUILTIN(__builtin___get_unsafe_stack_top, "v*", "Fn")
-BUILTIN(__builtin___get_unsafe_stack_ptr, "v*", "Fn")
-
-// Nontemporal loads/stores builtins
-BUILTIN(__builtin_nontemporal_store, "v.", "t")
-BUILTIN(__builtin_nontemporal_load, "v.", "t")
-
-// Coroutine intrinsics.
-LANGBUILTIN(__builtin_coro_resume, "vv*", "", COR_LANG)
-LANGBUILTIN(__builtin_coro_destroy, "vv*", "", COR_LANG)
-LANGBUILTIN(__builtin_coro_done, "bv*", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_promise, "v*v*IiIb", "n", COR_LANG)
-
-LANGBUILTIN(__builtin_coro_size, "z", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_align, "z", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_frame, "v*", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_noop, "v*", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_free, "v*v*", "n", COR_LANG)
-
-LANGBUILTIN(__builtin_coro_id, "v*Iiv*v*v*", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_alloc, "b", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_begin, "v*v*", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_end, "bv*Ib", "n", COR_LANG)
-LANGBUILTIN(__builtin_coro_suspend, "cIb", "n", COR_LANG)
-
-// OpenCL v2.0 s6.13.16, s9.17.3.5 - Pipe functions.
-// We need the generic prototype, since the packet type could be anything.
-LANGBUILTIN(read_pipe, "i.", "tn", OCL_PIPE)
-LANGBUILTIN(write_pipe, "i.", "tn", OCL_PIPE)
-
-LANGBUILTIN(reserve_read_pipe, "i.", "tn", OCL_PIPE)
-LANGBUILTIN(reserve_write_pipe, "i.", "tn", OCL_PIPE)
-
-LANGBUILTIN(commit_write_pipe, "v.", "tn", OCL_PIPE)
-LANGBUILTIN(commit_read_pipe, "v.", "tn", OCL_PIPE)
-
-LANGBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCL_PIPE)
-LANGBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCL_PIPE)
-
-LANGBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCL_PIPE)
-LANGBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCL_PIPE)
-
-LANGBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCL_PIPE)
-LANGBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCL_PIPE)
-
-LANGBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCL_PIPE)
-LANGBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCL_PIPE)
-
-LANGBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCL_PIPE)
-LANGBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCL_PIPE)
-
-// 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", OCL_DSE)
-LANGBUILTIN(get_kernel_work_group_size, "Ui.", "tn", OCL_DSE)
-LANGBUILTIN(get_kernel_preferred_work_group_size_multiple, "Ui.", "tn", OCL_DSE)
-LANGBUILTIN(get_kernel_max_sub_group_size_for_ndrange, "Ui.", "tn", OCL_DSE)
-LANGBUILTIN(get_kernel_sub_group_count_for_ndrange, "Ui.", "tn", OCL_DSE)
-
-// OpenCL v2.0 s6.13.9 - Address space qualifier functions.
-// FIXME: Pointer parameters of OpenCL builtins should have their address space
-// requirement defined.
-LANGBUILTIN(to_global, "v*v*", "tn", OCL_GAS)
-LANGBUILTIN(to_local, "v*v*", "tn", OCL_GAS)
-LANGBUILTIN(to_private, "v*v*", "tn", OCL_GAS)
-
-// OpenCL half load/store builtin
-LANGBUILTIN(__builtin_store_half, "vdh*", "n", ALL_OCL_LANGUAGES)
-LANGBUILTIN(__builtin_store_halff, "vfh*", "n", ALL_OCL_LANGUAGES)
-LANGBUILTIN(__builtin_load_half, "dhC*", "nc", ALL_OCL_LANGUAGES)
-LANGBUILTIN(__builtin_load_halff, "fhC*", "nc", ALL_OCL_LANGUAGES)
-
-// Builtins for os_log/os_trace
-BUILTIN(__builtin_os_log_format_buffer_size, "zcC*.", "p:0:nutE")
-BUILTIN(__builtin_os_log_format, "v*v*cC*.", "p:0:nt")
-
-// CUDA/HIP
-LANGBUILTIN(__builtin_get_device_side_mangled_name, "cC*.", "ncT", CUDA_LANG)
-
-// HLSL
-LANGBUILTIN(__builtin_hlsl_wave_active_count_bits, "Uib", "nc", HLSL_LANG)
-LANGBUILTIN(__builtin_hlsl_create_handle, "v*Uc", "nc", HLSL_LANG)
-
-// Builtins for XRay
-BUILTIN(__xray_customevent, "vcC*z", "")
-BUILTIN(__xray_typedevent, "vzcC*z", "")
-
-// Win64-compatible va_list functions
-BUILTIN(__builtin_ms_va_start, "vc*&.", "nt")
-BUILTIN(__builtin_ms_va_end, "vc*&", "n")
-BUILTIN(__builtin_ms_va_copy, "vc*&c*&", "n")
-
-// Arithmetic Fence: to prevent FP reordering and reassociation optimizations
-LANGBUILTIN(__arithmetic_fence, "v.", "tE", ALL_LANGUAGES)
-
-#undef BUILTIN
-#undef LIBBUILTIN
-#undef LANGBUILTIN
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
index 3fd5b02b5aa5882..f955d21169556a0 100644
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -64,7 +64,7 @@ namespace Builtin {
enum ID {
NotBuiltin = 0, // This is not a builtin function.
#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
-#include "clang/Basic/Builtins.def"
+#include "clang/Basic/Builtins.inc"
FirstTSBuiltin
};
diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td
new file mode 100644
index 000000000000000..0a3faf156bbd9f1
--- /dev/null
+++ b/clang/include/clang/Basic/Builtins.td
@@ -0,0 +1,4370 @@
+//===--- Builtins.td - Builtins function info database-----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+include "clang/Basic/BuiltinsBase.td"
+
+class FPMathTemplate : Template<["float", "double", "long double"],
+ ["f", "", "l"]>;
+
+class FPMathWithF16Template :
+ Template<["float", "double", "long double", "__fp16", "__float128"],
+ ["f", "", "l", "f16", "f128"]>;
+
+class FPMathWithF16F128Template :
+ Template<["float", "double", "long double", "__fp16", "__float128"],
+ ["f", "", "l", "f16", "f128"]>;
+
+class F16F128MathTemplate : Template<["__fp16", "__float128"],
+ ["f16", "f128"]>;
+
+class IntMathTemplate : Template<["int", "long int", "long long int"],
+ ["", "l", "ll"], /*AsPrefix=*/1>;
+
+class MSInt8_16_32Template : Template<["char", "short", "msint32_t"],
+ ["8", "16", ""]>;
+
+class Int8_16_32_64Template
+ : Template<["char", "short", "int", "long long int"],
+ ["8", "16", "32", "64"]>;
+
+class MSInt8_16_32_64Template
+ : Template<["char", "short", "msint32_t", "long long int"],
+ ["8", "16", "", "64"]>;
+
+class MSInt16_32Template : Template<["short", "msint32_t"],
+ ["16", ""]>;
+
+class MSUInt16_32_64Template :
+ Template<["unsigned short", "unsigned int", "uint64_t"],
+ ["16", "", "64"]>;
+
+class MSInt32_64Template : Template<["msint32_t", "int64_t"],
+ ["", "64"]>;
+
+class FloatDoubleTemplate : Template<["float", "double"],
+ ["f", ""]>;
+
+// FIXME: These assume that char -> i8, short -> i16, int -> i32,
+// long long -> i64.
+class SyncBuiltinsTemplate :
+ Template<["char", "short", "int", "long long int", "__int128_t"],
+ ["1", "2", "4", "8", "16"]>;
+
+class BitInt8_16_32_64BuiltinsTemplate :
+ Template<["unsigned char", "unsigned short", "uint32_t", "uint64_t"],
+ ["8", "16", "32", "64"]>;
+
+class BitShort_Int_Long_LongLongTemplate :
+ Template<["short", "int", "long int", "long long int"],
+ ["s", "", "l", "ll"]>;
+
+class BitInt_Long_LongLongTemplate :
+ Template<["int", "long int", "long long int"],
+ ["", "l", "ll"]>;
+
+// Most of the types used in the prototypes are types from C, C++ or ObjC. There
+// are a few builtin-specific types and qualifiers.
+//
+// builtin-specific types:
+// - __builtin_va_list: This is the internal representation for va_lists
+// - __builtin_va_list_ref: A reference-like type to __builtin_va_list
+// - msint32_t: 'int' size if target is LP64, 'L' otherwise.
+//
+// builtin-specific qualifiers:
+// - _Constant: Argument has to constant-fold to an integer constant expression
+
+// __fp16 and __float128 builtin variants of libc/libm functions.
+def AcosF128 : Builtin {
+ let Spellings = ["__builtin_acosf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def AcoshF128 : Builtin {
+ let Spellings = ["__builtin_acoshf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def AsinF128 : Builtin {
+ let Spellings = ["__builtin_asinf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def AsinhF128 : Builtin {
+ let Spellings = ["__builtin_asinhf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def AtanF128 : Builtin {
+ let Spellings = ["__builtin_atanf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def AtanhF128 : Builtin {
+ let Spellings = ["__builtin_atanhf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def CbrtF128 : Builtin {
+ let Spellings = ["__builtin_cbrtf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "__float128(__float128)";
+}
+
+def CeilF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_ceil"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+def CosF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_cos"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def CoshF128 : Builtin {
+ let Spellings = ["__builtin_coshf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def ErfF128 : Builtin {
+ let Spellings = ["__builtin_erff128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def ErfcF128 : Builtin {
+ let Spellings = ["__builtin_erfcf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def ExpF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_exp"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Exp2F16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_exp2"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Exp10F16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_exp10"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Expm1F128 : Builtin {
+ let Spellings = ["__builtin_expm1f128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def FdimF128 : Builtin {
+ let Spellings = ["__builtin_fdimf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def FloorF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_floor"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+def FmaF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_fma"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T, T)";
+}
+
+def FmaxF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_fmax"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
+ let Prototype = "T(T, T)";
+}
+
+def FminF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_fmin"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
+ let Prototype = "T(T, T)";
+}
+
+def Atan2F128 : Builtin {
+ let Spellings = ["__builtin_atan2f128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def CopysignF16 : Builtin {
+ let Spellings = ["__builtin_copysignf16"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "__fp16(__fp16, __fp16)";
+}
+
+def CopysignF128 : Builtin {
+ let Spellings = ["__builtin_copysignf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def FabsF16 : Builtin {
+ let Spellings = ["__builtin_fabsf16"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "__fp16(__fp16)";
+}
+
+def FabsF128 : Builtin {
+ let Spellings = ["__builtin_fabsf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
+ let Prototype = "__float128(__float128)";
+}
+
+def FmodF16F128 : F16F128MathTemplate, Builtin {
+ let Spellings = ["__builtin_fmod"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+}
+
+def FrexpF16F128 : F16F128MathTemplate, Builtin {
+ let Spellings = ["__builtin_frexp"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "T(T, int*)";
+}
+
+def HugeVal : Builtin, FPMathWithF16F128Template {
+ let Spellings = ["__builtin_huge_val"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T()";
+}
+
+def Inf : Builtin, FPMathWithF16F128Template {
+ let Spellings = ["__builtin_inf"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T()";
+}
+
+def LdexpF16F128 : F16F128MathTemplate, Builtin {
+ let Spellings = ["__builtin_ldexp"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, int)";
+}
+
+def ModfF128 : Builtin {
+ let Spellings = ["__builtin_modff128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "__float128(__float128, __float128*)";
+}
+
+// This isn't a FPMathWithF16F128Template because the f16
+// version takes a _Float16 for some reason.
+def NanF16 : Builtin {
+ let Spellings = ["__builtin_nanf16"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Pure, Constexpr];
+ let Prototype = "_Float16(char const*)";
+}
+
+def NanF128 : Builtin {
+ let Spellings = ["__builtin_nanf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Pure, Constexpr];
+ let Prototype = "__float128(char const*)";
+}
+
+def Nans : Builtin,
+ Template<["float", "double", "long double", "_Float16", "__float128"],
+ ["f", "", "l", "f16", "f128"]> {
+ let Spellings = ["__builtin_nans"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Pure, Constexpr];
+ let Prototype = "T(char const*)";
+}
+
+def PowI : Builtin, FPMathTemplate {
+ let Spellings = ["__builtin_powi"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T, int)";
+}
+
+def PowF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_pow"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+}
+
+def HypotF128 : Builtin {
+ let Spellings = ["__builtin_hypotf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def ILogbF128 : Builtin {
+ let Spellings = ["__builtin_ilogbf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "int(__float128)";
+}
+
+def LgammaF128 : Builtin {
+ let Spellings = ["__builtin_lgammaf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "__float128(__float128)";
+}
+
+def LLrintF128 : Builtin {
+ let Spellings = ["__builtin_llrintf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long long int(__float128)";
+}
+
+def LLroundF128 : Builtin {
+ let Spellings = ["__builtin_llroundf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long long int(__float128)";
+}
+
+def Log10F16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_log10"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Log1pF128 : Builtin {
+ let Spellings = ["__builtin_log1pf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def Log2F16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_log2"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def LogbF128 : Builtin {
+ let Spellings = ["__builtin_logbf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def LogF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_log"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def LrintF128 : Builtin {
+ let Spellings = ["__builtin_lrintf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long int(__float128)";
+}
+
+def LroundF128 : Builtin {
+ let Spellings = ["__builtin_lroundf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long int(__float128)";
+}
+
+def NearbyintF128 : Builtin {
+ let Spellings = ["__builtin_nearbyintf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "__float128(__float128)";
+}
+
+def NextafterF128 : Builtin {
+ let Spellings = ["__builtin_nextafterf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def NexttowardF128 : Builtin {
+ let Spellings = ["__builtin_nexttowardf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def RemainderF128 : Builtin {
+ let Spellings = ["__builtin_remainderf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, __float128)";
+}
+
+def RemquoF128 : Builtin {
+ let Spellings = ["__builtin_remquof128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "__float128(__float128, __float128, int*)";
+}
+
+def RintF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_rint"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+def RoundF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_round"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+def RoundevenF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_roundeven"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+def ScanlblnF128 : Builtin {
+ let Spellings = ["__builtin_scalblnf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, long int)";
+}
+
+def ScanlbnF128 : Builtin {
+ let Spellings = ["__builtin_scalbnf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128, int)";
+}
+
+def SinF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_sin"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def SinhF128 : Builtin {
+ let Spellings = ["__builtin_sinhf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def SqrtF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_sqrt"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def TanF128 : Builtin {
+ let Spellings = ["__builtin_tanf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def TanhF128 : Builtin {
+ let Spellings = ["__builtin_tanhf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def TgammaF128 : Builtin {
+ let Spellings = ["__builtin_tgammaf128"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "__float128(__float128)";
+}
+
+def TruncF16F128 : Builtin, F16F128MathTemplate {
+ let Spellings = ["__builtin_trunc"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+// Access to floating point environment.
+def BuiltinFltRounds : Builtin {
+ let Spellings = ["__builtin_flt_rounds"];
+ let Attributes = [NoThrow];
+ let Prototype = "int()";
+}
+
+def BuiltinSetFltRounds : Builtin {
+ let Spellings = ["__builtin_set_flt_rounds"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(int)";
+}
+
+// GCC-compatible C99 CMPLX implementation.
+def BuiltinComplex : Builtin {
+ let Spellings = ["__builtin_complex"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void(...)";
+}
+
+// FP Comparison functions.
+def IsGreater : Builtin {
+ let Spellings = ["__builtin_isgreater"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+def IsGreaterEqual : Builtin {
+ let Spellings = ["__builtin_isgreaterequal"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+def IsLess : Builtin {
+ let Spellings = ["__builtin_isless"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+def IsLessEqual : Builtin {
+ let Spellings = ["__builtin_islessequal"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+def IsLessGreater : Builtin {
+ let Spellings = ["__builtin_islessgreater"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+def IsUnordered : Builtin {
+ let Spellings = ["__builtin_isunordered"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+// Unary FP classification.
+def FPClassify : Builtin {
+ let Spellings = ["__builtin_fpclassify"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(int, int, int, int, int, ...)";
+}
+
+def IsFinite : Builtin {
+ let Spellings = ["__builtin_isfinite"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsInf : Builtin {
+ let Spellings = ["__builtin_isinf"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsInfSign : Builtin {
+ let Spellings = ["__builtin_isinf_sign"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsNan : Builtin {
+ let Spellings = ["__builtin_isnan"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsNormal : Builtin {
+ let Spellings = ["__builtin_isnormal"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsFPClass : Builtin {
+ let Spellings = ["__builtin_isfpclass"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+// FP signbit builtins.
+def Signbit : Builtin {
+ let Spellings = ["__builtin_signbit"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking];
+ let Prototype = "int(...)";
+}
+
+def SignbitF : Builtin {
+ let Spellings = ["__builtin_signbitf"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "int(float)";
+}
+
+def SignbitL : Builtin {
+ let Spellings = ["__builtin_signbitl"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const];
+ let Prototype = "int(long double)";
+}
+
+// Special FP builtins.
+def Canonicalize : Builtin, FPMathWithF16Template {
+ let Spellings = ["__builtin_canonicalize"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+// Builtins for arithmetic.
+def Clz : Builtin, BitShort_Int_Long_LongLongTemplate {
+ let Spellings = ["__builtin_clz"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "int(unsigned T)";
+}
+
+// FIXME: Add int clzimax(uintmax_t)
+
+def Ctz : Builtin, BitShort_Int_Long_LongLongTemplate {
+ let Spellings = ["__builtin_ctz"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "int(unsigned T)";
+}
+
+// FIXME: Add int ctzimax(uintmax_t)
+
+def FFS : Builtin, BitInt_Long_LongLongTemplate {
+ let Spellings = ["__builtin_ffs"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
+ let Prototype = "int(T)";
+}
+
+def Parity : Builtin, BitInt_Long_LongLongTemplate {
+ let Spellings = ["__builtin_parity"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "int(unsigned T)";
+}
+
+def Popcount : Builtin, BitInt_Long_LongLongTemplate {
+ let Spellings = ["__builtin_popcount"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "int(unsigned T)";
+}
+
+def Clrsb : Builtin, BitInt_Long_LongLongTemplate {
+ let Spellings = ["__builtin_clrsb"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "int(T)";
+}
+
+// The following builtins rely on that char == 8 bits, short == 16 bits and that
+// there exists native types on the target that are 32- and 64-bits wide, unless
+// these conditions are fulfilled these builtins will operate on a not intended
+// bitwidth.
+def BSwap : Builtin, Template<["unsigned short", "uint32_t", "uint64_t"],
+ ["16", "32", "64"]> {
+ let Spellings = ["__builtin_bswap"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T(T)";
+}
+
+def Bitreverse : BitInt8_16_32_64BuiltinsTemplate, Builtin {
+ let Spellings = ["__builtin_bitreverse"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T(T)";
+}
+
+def RotateLeft : BitInt8_16_32_64BuiltinsTemplate, Builtin {
+ let Spellings = ["__builtin_rotateleft"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T(T, T)";
+}
+
+def RotateRight : BitInt8_16_32_64BuiltinsTemplate, Builtin {
+ let Spellings = ["__builtin_rotateright"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T(T, T)";
+}
+
+// Random GCC builtins
+// FIXME: The builtins marked FunctionWithBuiltinPrefix below should be
+// merged with the library definitions. They are currently not because
+// the attributes are different.
+def BuiltinCalloc : Builtin {
+ let Spellings = ["__builtin_calloc"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(size_t, size_t)";
+}
+
+def BuiltinConstantP : Builtin {
+ let Spellings = ["__builtin_constant_p"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, UnevaluatedArguments, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def BuiltinClassifyType : Builtin {
+ let Spellings = ["__builtin_classify_type"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, UnevaluatedArguments, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def BuiltinCFStringMakeConstantString : Builtin {
+ let Spellings = ["__builtin___CFStringMakeConstantString"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "constant_CFString const*(char const*)";
+}
+
+def BuiltinNSStringMakeConstantString : Builtin {
+ let Spellings = ["__builtin___NSStringMakeConstantString"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "constant_CFString const*(char const*)";
+}
+
+def BuiltinVaStart : Builtin {
+ let Spellings = ["__builtin_va_start"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(__builtin_va_list_ref, ...)";
+}
+
+def BuiltinStdargStart : Builtin {
+ let Spellings = ["__builtin_stdarg_start"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(__builtin_va_list_ref, ...)";
+}
+
+def BuiltinAssumeAligned : Builtin {
+ let Spellings = ["__builtin_assume_aligned"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(void const*, size_t, ...)";
+}
+
+def BuiltinBcopy : Builtin {
+ let Spellings = ["__builtin_bcopy"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void*, void*, size_t)";
+}
+
+def BuiltinFree : Builtin {
+ let Spellings = ["__builtin_free"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void(void*)";
+}
+
+def BuiltinMalloc : Builtin {
+ let Spellings = ["__builtin_malloc"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(size_t)";
+}
+
+def BuiltinMemcpyInline : Builtin {
+ let Spellings = ["__builtin_memcpy_inline"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void*, void const*, _Constant size_t)";
+}
+
+def BuiltinMempcpy : Builtin {
+ let Spellings = ["__builtin_mempcpy"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, void const*, size_t)";
+}
+
+def BuiltinMemsetInline : Builtin {
+ let Spellings = ["__builtin_memset_inline"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void*, int, _Constant size_t)";
+}
+
+def BuiltinStrcspn : Builtin {
+ let Spellings = ["__builtin_strcspn"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "size_t(char const*, char const*)";
+}
+
+def BuiltinRealloc : Builtin {
+ let Spellings = ["__builtin_realloc"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, size_t)";
+}
+
+def BuiltinReturnAddress : Builtin {
+ let Spellings = ["__builtin_return_address"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(_Constant unsigned int)";
+}
+
+def ExtractReturnAddr : Builtin {
+ let Spellings = ["__builtin_extract_return_addr"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+def FrameAddress : Builtin {
+ let Spellings = ["__builtin_frame_address"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(_Constant unsigned int)";
+}
+
+def ClearCache : Builtin {
+ let Spellings = ["__builtin___clear_cache"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(char*, char*)";
+}
+
+def BuiltinSetjmp : Builtin {
+ let Spellings = ["__builtin_setjmp"];
+ let Attributes = [ReturnsTwice];
+ let Prototype = "int(void**)";
+}
+
+def BuiltinLongjmp : Builtin {
+ let Spellings = ["__builtin_longjmp"];
+ let Attributes = [NoReturn];
+ let Prototype = "void(void**, int)";
+}
+
+def UnwindInit : Builtin {
+ let Spellings = ["__builtin_unwind_init"];
+ let Prototype = "void()";
+}
+
+def EHReturnDataRegNo : Builtin {
+ let Spellings = ["__builtin_eh_return_data_regno"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "int(_Constant int)";
+}
+
+def ThreadPointer : Builtin {
+ let Spellings = ["__builtin_thread_pointer"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "void*()";
+}
+
+def Launder : Builtin {
+ let Spellings = ["__builtin_launder"];
+ let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(void*)";
+}
+
+def IsConstantEvaluated : LangBuiltin<"CXX_LANG"> {
+ let Spellings = ["__builtin_is_constant_evaluated"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool()";
+}
+
+// GCC exception builtins
+def EHReturn : Builtin {
+ let Spellings = ["__builtin_eh_return"];
+ let Attributes = [NoReturn];
+ // FIXME: Takes intptr_t, not size_t!
+ let Prototype = "void(size_t, void*)";
+}
+
+def FrobReturnAddr : Builtin {
+ let Spellings = ["__builtin_frob_return_addr"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+def DWARF_CFA : Builtin {
+ let Spellings = ["__builtin_dwarf_cfa"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*()";
+}
+
+def InitDWARFRegSizeTable : Builtin {
+ let Spellings = ["__builtin_init_dwarf_reg_size_table"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void*)";
+}
+
+def DWARFSpColumn : Builtin {
+ let Spellings = ["__builtin_dwarf_sp_column"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned int()";
+}
+
+def ExtendPointer : Builtin {
+ let Spellings = ["__builtin_extend_pointer"];
+ let Attributes = [NoThrow];
+ // _Unwind_Word == uint64_t
+ let Prototype = "unsigned long long int(void*)";
+}
+
+// GCC Object size checking builtins.
+def ObjectSize : Builtin {
+ let Spellings = ["__builtin_object_size"];
+ let Attributes = [NoThrow, UnevaluatedArguments, Constexpr];
+ let Prototype = "size_t(void const*, int)";
+}
+
+def DynamicObjectSize : Builtin { // Clang only
+ let Spellings = ["__builtin_dynamic_object_size"];
+ let Attributes = [NoThrow, UnevaluatedArguments, Constexpr];
+ let Prototype = "size_t(void const*, int)";
+}
+
+def MemcpyChk : Builtin {
+ let Spellings = ["__builtin___memcpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, void const*, size_t, size_t)";
+}
+
+def MemccpyChk : Builtin {
+ let Spellings = ["__builtin___memccpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, void const*, int, size_t, size_t)";
+}
+
+def MemmoveChk : Builtin {
+ let Spellings = ["__builtin___memmove_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, void const*, size_t, size_t)";
+}
+
+def MempcpyChk : Builtin {
+ let Spellings = ["__builtin___mempcpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, void const*, size_t, size_t)";
+}
+
+def MemsetChk : Builtin {
+ let Spellings = ["__builtin___memset_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(void*, int, size_t, size_t)";
+}
+
+def StpcpyChk : Builtin {
+ let Spellings = ["__builtin___stpcpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "char*(char*, char const*, size_t)";
+}
+
+def StrcatChk : Builtin {
+ let Spellings = ["__builtin___strcat_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "char*(char*, char const*, size_t)";
+}
+
+def StrcpyChk : Builtin {
+ let Spellings = ["__builtin___strcpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "char*(char*, char const*, size_t)";
+}
+
+def StrlcatChk : Builtin {
+ let Spellings = ["__builtin___strlcat_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "size_t(char*, char const*, size_t, size_t)";
+}
+
+def StrlcpyChk : Builtin {
+ let Spellings = ["__builtin___strlcpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "size_t(char*, char const*, size_t, size_t)";
+}
+
+def StrncatChk : Builtin {
+ let Spellings = ["__builtin___strncat_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "char*(char*, char const*, size_t, size_t)";
+}
+
+def StrncpyChk : Builtin {
+ let Spellings = ["__builtin___strncpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "char*(char*, char const*, size_t, size_t)";
+}
+
+def StpncpyChk : Builtin {
+ let Spellings = ["__builtin___stpncpy_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "int(char*, char*, char const*, size_t, size_t)";
+}
+
+def SNPrintfChk : Builtin {
+ let Spellings = ["__builtin___snprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, PrintfFormat<4>];
+ let Prototype = "int(char* restrict, size_t, int, size_t, char const* restrict, ...)";
+}
+
+def SPrintfChk : Builtin {
+ let Spellings = ["__builtin___sprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, PrintfFormat<3>];
+ let Prototype = "int(char* restrict, int, size_t, char const* restrict, ...)";
+}
+
+def VSNPrintfChk : Builtin {
+ let Spellings = ["__builtin___vsnprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, VPrintfFormat<4>];
+ let Prototype = "int(char* restrict, size_t, int, size_t, char const* restrict, __builtin_va_list)";
+}
+
+def VSPrintfChk : Builtin {
+ let Spellings = ["__builtin___vsprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, VPrintfFormat<3>];
+ let Prototype = "int(char* restrict, int, size_t, char const* restrict, __builtin_va_list)";
+}
+
+def FPrintfChk : Builtin {
+ let Spellings = ["__builtin___fprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, PrintfFormat<2>];
+ let Prototype = "int(FILE* restrict, int, char const* restrict, ...)";
+}
+
+def PrintfChk : Builtin {
+ let Spellings = ["__builtin___printf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, PrintfFormat<1>];
+ let Prototype = "int(int, int, char const* restrict, ...)";
+}
+
+def VFPrintfChk : Builtin {
+ let Spellings = ["__builtin___vfprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, VPrintfFormat<2>];
+ let Prototype = "int(FILE* restrict, int, char const* restrict, __builtin_va_list)";
+}
+
+def VPrintfChk : Builtin {
+ let Spellings = ["__builtin___vprintf_chk"];
+ let Attributes = [FunctionWithBuiltinPrefix, VPrintfFormat<1>];
+ let Prototype = "int(int, char const* restrict, __builtin_va_list)";
+}
+
+def Unpredictable : Builtin {
+ let Spellings = ["__builtin_unpredictable"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "long int(long int)";
+}
+
+def Expect : Builtin {
+ let Spellings = ["__builtin_expect"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "long int(long int, long int)";
+}
+
+def ExpectWithProbability : Builtin {
+ let Spellings = ["__builtin_expect_with_probability"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "long int(long int, long int, double)";
+}
+
+def Prefetch : Builtin {
+ let Spellings = ["__builtin_prefetch"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "void(void const*, ...)";
+}
+
+def ReadCycleCounter : Builtin {
+ let Spellings = ["__builtin_readcyclecounter"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned long long int()";
+}
+
+def Trap : Builtin {
+ let Spellings = ["__builtin_trap"];
+ let Attributes = [NoThrow, NoReturn];
+ let Prototype = "void()";
+}
+
+def Debugtrap : Builtin {
+ let Spellings = ["__builtin_debugtrap"];
+ let Attributes = [NoThrow];
+ let Prototype = "void()";
+}
+
+def Unreachable : Builtin {
+ let Spellings = ["__builtin_unreachable"];
+ let Attributes = [NoThrow, NoReturn];
+ let Prototype = "void()";
+}
+
+def ShuffleVector : Builtin {
+ let Spellings = ["__builtin_shufflevector"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ConvertVector : Builtin {
+ let Spellings = ["__builtin_convertvector"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AllocaUninitialized : Builtin {
+ let Spellings = ["__builtin_alloca_uninitialized"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(size_t)";
+}
+
+def AllocaWithAlign : Builtin {
+ let Spellings = ["__builtin_alloca_with_align"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(size_t, _Constant size_t)";
+}
+
+def AllocaWithAlignUninitialized : Builtin {
+ let Spellings = ["__builtin_alloca_with_align_uninitialized"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
+ let Prototype = "void*(size_t, _Constant size_t)";
+}
+
+def CallWithStaticChain : Builtin {
+ let Spellings = ["__builtin_call_with_static_chain"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def NondetermenisticValue : Builtin {
+ let Spellings = ["__builtin_nondeterministic_value"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseAbs : Builtin {
+ let Spellings = ["__builtin_elementwise_abs"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseBitreverse : Builtin {
+ let Spellings = ["__builtin_elementwise_bitreverse"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseMax : Builtin {
+ let Spellings = ["__builtin_elementwise_max"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseMin : Builtin {
+ let Spellings = ["__builtin_elementwise_min"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseCeil : Builtin {
+ let Spellings = ["__builtin_elementwise_ceil"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseCos : Builtin {
+ let Spellings = ["__builtin_elementwise_cos"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseExp : Builtin {
+ let Spellings = ["__builtin_elementwise_exp"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseExp2 : Builtin {
+ let Spellings = ["__builtin_elementwise_exp2"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseFloor : Builtin {
+ let Spellings = ["__builtin_elementwise_floor"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseLog : Builtin {
+ let Spellings = ["__builtin_elementwise_log"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseLog2 : Builtin {
+ let Spellings = ["__builtin_elementwise_log2"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseLog10 : Builtin {
+ let Spellings = ["__builtin_elementwise_log10"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwisePow : Builtin {
+ let Spellings = ["__builtin_elementwise_pow"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseRoundEven : Builtin {
+ let Spellings = ["__builtin_elementwise_roundeven"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseRound : Builtin {
+ let Spellings = ["__builtin_elementwise_round"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseRint : Builtin {
+ let Spellings = ["__builtin_elementwise_rint"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseNearbyInt : Builtin {
+ let Spellings = ["__builtin_elementwise_nearbyint"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseSin : Builtin {
+ let Spellings = ["__builtin_elementwise_sin"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseSqrt : Builtin {
+ let Spellings = ["__builtin_elementwise_sqrt"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseTrunc : Builtin {
+ let Spellings = ["__builtin_elementwise_trunc"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseCanonicalize : Builtin {
+ let Spellings = ["__builtin_elementwise_canonicalize"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseCopysign : Builtin {
+ let Spellings = ["__builtin_elementwise_copysign"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseFma : Builtin {
+ let Spellings = ["__builtin_elementwise_fma"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseAddSat : Builtin {
+ let Spellings = ["__builtin_elementwise_add_sat"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ElementwiseSubSat : Builtin {
+ let Spellings = ["__builtin_elementwise_sub_sat"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceMax : Builtin {
+ let Spellings = ["__builtin_reduce_max"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceMin : Builtin {
+ let Spellings = ["__builtin_reduce_min"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceXor : Builtin {
+ let Spellings = ["__builtin_reduce_xor"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceOr : Builtin {
+ let Spellings = ["__builtin_reduce_or"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceAnd : Builtin {
+ let Spellings = ["__builtin_reduce_and"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceAdd : Builtin {
+ let Spellings = ["__builtin_reduce_add"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ReduceMul : Builtin {
+ let Spellings = ["__builtin_reduce_mul"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def MatrixTranspose : Builtin {
+ let Spellings = ["__builtin_matrix_transpose"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def MatrixColumnMajorLoad : Builtin {
+ let Spellings = ["__builtin_matrix_column_major_load"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def MatrixColumnMajorStore : Builtin {
+ let Spellings = ["__builtin_matrix_column_major_store"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+// "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).
+
+def SyncFetchAndAdd : Builtin {
+ let Spellings = ["__sync_fetch_and_add"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncFetchAndAddN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_fetch_and_add_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncFetchAndSub : Builtin {
+ let Spellings = ["__sync_fetch_and_sub"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncFetchAndSubN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_fetch_and_sub_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncFetchAndOr : Builtin {
+ let Spellings = ["__sync_fetch_and_or"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncFetchAndOrN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_fetch_and_or_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncFetchAndAnd : Builtin {
+ let Spellings = ["__sync_fetch_and_and"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncFetchAndAndN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_fetch_and_and_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncFetchAndXor : Builtin {
+ let Spellings = ["__sync_fetch_and_xor"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncFetchAndXorN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_fetch_and_xor_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncFetchAndNand : Builtin {
+ let Spellings = ["__sync_fetch_and_nand"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncFetchAndNandN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_fetch_and_nand_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncAddAndFetch : Builtin {
+ let Spellings = ["__sync_add_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncAddAndFetchN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_add_and_fetch_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncSubAndFetch : Builtin {
+ let Spellings = ["__sync_sub_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncSubAndFetchN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_sub_and_fetch_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncOrAndFetch : Builtin {
+ let Spellings = ["__sync_or_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncOrAndFetchN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_or_and_fetch_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncAndAndFetch : Builtin {
+ let Spellings = ["__sync_and_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncAndAndFetchN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_and_and_fetch_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncXorAndFetch : Builtin {
+ let Spellings = ["__sync_xor_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncXorAndFetchN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_xor_and_fetch_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncNandAndFetch : Builtin {
+ let Spellings = ["__sync_nand_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncNandAndFetchN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_nand_and_fetch_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncBoolCompareAndSwap : Builtin {
+ let Spellings = ["__sync_bool_compare_and_swap"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncBoolCompareAndSwapN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_bool_compare_and_swap_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncValCompareAndSwap : Builtin {
+ let Spellings = ["__sync_val_compare_and_swap"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SynLockValCompareAndSwapN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_val_compare_and_swap_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncLockTestAndSet : Builtin {
+ let Spellings = ["__sync_lock_test_and_set"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SynLockLockTestAndSetN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_lock_test_and_set_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncLockReleaseN : Builtin {
+ let Spellings = ["__sync_lock_release"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SynLockReleaseN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_lock_release_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+def SyncSwap : Builtin {
+ let Spellings = ["__sync_swap"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def SyncSwapN : Builtin, SyncBuiltinsTemplate {
+ let Spellings = ["__sync_swap_"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "T(T volatile*, T, ...)";
+}
+
+// C11 _Atomic operations for <stdatomic.h>.
+def C11AtomicInit : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_init"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicLoad : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_load"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicStore : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_store"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicExchange : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicCompareExchangeStrong : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_compare_exchange_strong"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicCompareExchangeWeak : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_compare_exchange_weak"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchAdd : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_add"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchSub : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_sub"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchAnd : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_and"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchOr : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_or"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchXor : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_xor"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchNand : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_nand"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchMax : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_max"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicFetchMin : AtomicBuiltin {
+ let Spellings = ["__c11_atomic_fetch_min"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def C11AtomicThreadFence : Builtin {
+ let Spellings = ["__c11_atomic_thread_fence"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(int)";
+}
+
+def C11AtomicSignalFence : Builtin {
+ let Spellings = ["__c11_atomic_signal_fence"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(int)";
+}
+
+def C11AtomicIsLockFree : Builtin {
+ let Spellings = ["__c11_atomic_is_lock_free"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(size_t)";
+}
+
+// GNU atomic builtins.
+def AtomicLoad : AtomicBuiltin {
+ let Spellings = ["__atomic_load"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicLoadN : AtomicBuiltin {
+ let Spellings = ["__atomic_load_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicStore : AtomicBuiltin {
+ let Spellings = ["__atomic_store"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicStoreN : AtomicBuiltin {
+ let Spellings = ["__atomic_store_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicExchange : AtomicBuiltin {
+ let Spellings = ["__atomic_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicExchangeN : AtomicBuiltin {
+ let Spellings = ["__atomic_exchange_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicCompareExchange : AtomicBuiltin {
+ let Spellings = ["__atomic_compare_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicCompareExchangeN : AtomicBuiltin {
+ let Spellings = ["__atomic_compare_exchange_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchAdd : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_add"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchSub : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_sub"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchAnd : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_and"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchOr : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_or"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchXor : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_xor"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchNand : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_nand"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicAddFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_add_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicSubFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_sub_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicAndFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicOrFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_or_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicXorFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_xor_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicMaxFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_max_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicMinFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_min_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicNandFetch : AtomicBuiltin {
+ let Spellings = ["__atomic_nand_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicTestAndSet : Builtin {
+ let Spellings = ["__atomic_test_and_set"];
+ let Attributes = [NoThrow];
+ let Prototype = "bool(void volatile*, int)";
+}
+
+def AtomicClear : Builtin {
+ let Spellings = ["__atomic_clear"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void volatile*, int)";
+}
+
+def AtomicThreadFence : Builtin {
+ let Spellings = ["__atomic_thread_fence"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(int)";
+}
+
+def AtomicSignalFence : Builtin {
+ let Spellings = ["__atomic_signal_fence"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(int)";
+}
+
+def AtomicAlwaysLockFree : Builtin {
+ let Spellings = ["__atomic_always_lock_free"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(size_t, void const volatile*)";
+}
+
+def AtomicIsLockFree : Builtin {
+ let Spellings = ["__atomic_is_lock_free"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(size_t, void const volatile*)";
+}
+
+// OpenCL 2.0 atomic builtins.
+def OpenCLAtomicInit : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_init"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicLoad : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_load"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicStore : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_store"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicCompareExchangeWeak : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_compare_exchange_weak"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicCompareExchangeStrong : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_compare_exchange_strong"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicExchange : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchAdd : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_add"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchSub : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_sub"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchAnd : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_and"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchOr : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_or"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchXor : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_xor"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchMin : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_min"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def OpenCLAtomicFetchMax : AtomicBuiltin {
+ let Spellings = ["__opencl_atomic_fetch_max"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+// GCC does not support these, they are a Clang extension.
+def AtomicFetchMax : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_max"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def AtomicFetchMin : AtomicBuiltin {
+ let Spellings = ["__atomic_fetch_min"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+// HIP atomic builtins.
+def HipAtomicLoad : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_load"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicStore : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_store"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicCompareExchangeWeak : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_compare_exchange_weak"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicCompareExchangeStrong : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_compare_exchange_strong"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicExchange : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchAdd : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_add"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchSub : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_sub"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchAnd : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_and"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchOr : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_or"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchXor : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_xor"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchMin : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_min"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def HipAtomicFetchMax : AtomicBuiltin {
+ let Spellings = ["__hip_atomic_fetch_max"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+// Non-overloaded atomic builtins.
+def SyncSynchronize : Builtin {
+ let Spellings = ["__sync_synchronize"];
+ let Attributes = [NoThrow];
+ let Prototype = "void()";
+}
+
+// GCC does not support these, they are a Clang extension.
+def SyncFetchAndMin : Builtin {
+ let Spellings = ["__sync_fetch_and_min"];
+ let Attributes = [NoThrow];
+ let Prototype = "int(int volatile*, int)";
+}
+
+def SyncFetchAndMax : Builtin {
+ let Spellings = ["__sync_fetch_and_max"];
+ let Attributes = [NoThrow];
+ let Prototype = "int(int volatile*, int)";
+}
+
+def SyncFetchAndUMin : Builtin {
+ let Spellings = ["__sync_fetch_and_umin"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned int(unsigned int volatile*, unsigned int)";
+}
+
+def SyncFetchAndUMax : Builtin {
+ let Spellings = ["__sync_fetch_and_umax"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned int(unsigned int volatile*, unsigned int)";
+}
+
+// ignored glibc builtin, see https://sourceware.org/bugzilla/show_bug.cgi?id=25399
+def WarnMemsetZeroLen : Builtin {
+ let Spellings = ["__warn_memset_zero_len"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "void()";
+}
+
+// Microsoft builtins. These are only active with -fms-extensions.
+def Alloca : MSLangBuiltin {
+ let Spellings = ["_alloca"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(size_t)";
+}
+
+def MSAnnotation : MSLangBuiltin {
+ let Spellings = ["__annotation"];
+ let Attributes = [NoThrow];
+ let Prototype = "wchar_t const*(...)";
+}
+
+def MSAssume : MSLangBuiltin {
+ let Spellings = ["__assume"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "void(bool)";
+}
+
+def Bittest : MSLangBuiltin, MSInt32_64Template {
+ let Spellings = ["_bittest"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(T const*, T)";
+}
+
+def BittestAndComplement : MSLangBuiltin, MSInt32_64Template {
+ let Spellings = ["_bittestandcomplement"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(T*, T)";
+}
+
+def BittestAndReset : MSLangBuiltin, MSInt32_64Template {
+ let Spellings = ["_bittestandreset"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(T*, T)";
+}
+
+def BittestAndSet : MSLangBuiltin, MSInt32_64Template {
+ let Spellings = ["_bittestandset"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(T*, T)";
+}
+
+def MSByteswap : MSLibBuiltin<"stdlib.h">,
+ Template<["unsigned short", "msuint32_t", "unsigned long long int"],
+ ["_ushort", "_ulong", "_uint64"]> {
+ let Spellings = ["_byteswap"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+}
+
+def Debugbreak : MSLangBuiltin {
+ let Spellings = ["__debugbreak"];
+ let Attributes = [NoThrow];
+ let Prototype = "void()";
+}
+
+def ExceptionCode : MSLangBuiltin {
+ let Spellings = ["__exception_code", "_exception_code"];
+ let Attributes = [NoThrow];
+ let Prototype = "msuint32_t()";
+}
+
+def ExceptionInfo : MSLangBuiltin {
+ let Spellings = ["__exception_info", "_exception_info"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*()";
+}
+
+def AbnormalTermination : MSLangBuiltin {
+ let Spellings = ["__abnormal_termination", "_abnormal_termination"];
+ let Attributes = [NoThrow];
+ let Prototype = "int()";
+}
+
+def GetExceptionInfo : MSLangBuiltin {
+ let Spellings = ["__GetExceptionInfo"];
+ let Attributes = [NoThrow, CustomTypeChecking, UnevaluatedArguments];
+ let Prototype = "void*(...)";
+ let Namespace = "std";
+}
+
+def InterlockedAnd : MSLangBuiltin, MSInt8_16_32Template {
+ let Spellings = ["_InterlockedAnd"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T)";
+}
+
+def InterlockedCompareExchange : MSLangBuiltin, MSInt8_16_32_64Template {
+ let Spellings = ["_InterlockedCompareExchange"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T, T)";
+}
+
+def InterlockedCompareExchangePointer : MSLangBuiltin {
+ let Spellings = ["_InterlockedCompareExchangePointer"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void* volatile*, void*, void*)";
+}
+
+def InterlockedCompareExchangePointer_nf : MSLangBuiltin {
+ let Spellings = ["_InterlockedCompareExchangePointer_nf"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void* volatile*, void*, void*)";
+}
+
+def InterlockedDecrement : MSLangBuiltin, MSInt16_32Template {
+ let Spellings = ["_InterlockedDecrement"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*)";
+}
+
+def InterlockedExchange : MSLangBuiltin, MSInt8_16_32Template {
+ let Spellings = ["_InterlockedExchange"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T)";
+}
+
+def InterlockedExchangeAdd : MSLangBuiltin, MSInt8_16_32Template {
+ let Spellings = ["_InterlockedExchangeAdd"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T)";
+}
+
+def InterlockedExchangePointer : MSLangBuiltin {
+ let Spellings = ["_InterlockedExchangePointer"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void* volatile*, void*)";
+}
+
+def InterlockedExchangeSub : MSLangBuiltin, MSInt8_16_32Template {
+ let Spellings = ["_InterlockedExchangeSub"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T)";
+}
+
+def InterlockedIncrement : MSLangBuiltin, MSInt16_32Template {
+ let Spellings = ["_InterlockedIncrement"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*)";
+}
+
+def InterlockedOr : MSLangBuiltin, MSInt8_16_32Template {
+ let Spellings = ["_InterlockedOr"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T)";
+}
+
+def InterlockedXor : MSLangBuiltin, MSInt8_16_32Template {
+ let Spellings = ["_InterlockedXor"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T volatile*, T)";
+}
+
+def InterlockedBittestAndReset : MSLangBuiltin, MSInt32_64Template {
+ let Spellings = ["_interlockedbittestandreset"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(T volatile*, T)";
+}
+
+def InterlockedBittestAndReset_acq : MSLangBuiltin {
+ let Spellings = ["_interlockedbittestandreset_acq"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(msint32_t volatile*, msint32_t)";
+}
+
+def InterlockedBittestAndReset_nf : MSLangBuiltin {
+ let Spellings = ["_interlockedbittestandreset_nf"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(msint32_t volatile*, msint32_t)";
+}
+
+def InterlockedBittestAndReset_rel : MSLangBuiltin {
+ let Spellings = ["_interlockedbittestandreset_rel"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(msint32_t volatile*, msint32_t)";
+}
+
+def InterlockedBittestAndSet : MSLangBuiltin, MSInt32_64Template {
+ let Spellings = ["_interlockedbittestandset"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(T volatile*, T)";
+}
+
+def InterlockedBittestAndSet_acq : MSLangBuiltin {
+ let Spellings = ["_interlockedbittestandset_acq"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(msint32_t volatile*, msint32_t)";
+}
+
+def InterlockedBittestAndSet_nf : MSLangBuiltin {
+ let Spellings = ["_interlockedbittestandset_nf"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(msint32_t volatile*, msint32_t)";
+}
+
+def InterlockedBittestAndSet_rel : MSLangBuiltin {
+ let Spellings = ["_interlockedbittestandset_rel"];
+ let Attributes = [NoThrow];
+ let Prototype = "unsigned char(msint32_t volatile*, msint32_t)";
+}
+
+def IsoVolatileLoad : MSLangBuiltin, Int8_16_32_64Template {
+ let Spellings = ["__iso_volatile_load"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T const volatile*)";
+}
+
+def IsoVolatileStore : MSLangBuiltin, Int8_16_32_64Template {
+ let Spellings = ["__iso_volatile_store"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(T volatile*, T)";
+}
+
+def Noop : MSLangBuiltin {
+ let Spellings = ["__noop"];
+ let Attributes = [NoThrow];
+ let Prototype = "int(...)";
+}
+
+def MSCountLeadingZeroes : MSLangBuiltin, MSUInt16_32_64Template {
+ let Spellings = ["__lzcnt"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T(T)";
+}
+
+def MSPopCount : MSLangBuiltin, MSUInt16_32_64Template {
+ let Spellings = ["__popcnt"];
+ let Attributes = [NoThrow, Const, Constexpr];
+ let Prototype = "T(T)";
+}
+
+def MSReturnAddress : MSLangBuiltin {
+ let Spellings = ["_ReturnAddress"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*()";
+}
+
+def Rotl8 : MSLangBuiltin {
+ let Spellings = ["_rotl8"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned char(unsigned char, unsigned char)";
+}
+
+def Rotl16 : MSLangBuiltin {
+ let Spellings = ["_rotl16"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned short(unsigned short, unsigned char)";
+}
+
+def Rotl : MSLangBuiltin {
+ let Spellings = ["_rotl"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned int(unsigned int, int)";
+}
+
+def Lrotl : MSLangBuiltin {
+ let Spellings = ["_lrotl"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned long int(unsigned long int, int)";
+}
+
+def Rotl64 : MSLangBuiltin {
+ let Spellings = ["_rotl64"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "uint64_t(uint64_t, int)";
+}
+
+def Rotr8 : MSLangBuiltin {
+ let Spellings = ["_rotr8"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned char(unsigned char, unsigned char)";
+}
+
+def Rotr16 : MSLangBuiltin {
+ let Spellings = ["_rotr16"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned short(unsigned short, unsigned char)";
+}
+
+def Rotr : MSLangBuiltin {
+ let Spellings = ["_rotr"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned int(unsigned int, int)";
+}
+
+def Lrotr : MSLangBuiltin {
+ let Spellings = ["_lrotr"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "unsigned long int(unsigned long int, int)";
+}
+
+def Rotr64 : MSLangBuiltin {
+ let Spellings = ["_rotr64"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "uint64_t(uint64_t, int)";
+}
+
+def MSva_start : MSLangBuiltin {
+ let Spellings = ["__va_start"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(char**, ...)";
+}
+
+def FastFail : MSLangBuiltin {
+ let Spellings = ["__fastfail"];
+ let Attributes = [NoThrow, NoReturn];
+ let Prototype = "void(unsigned int)";
+}
+
+// Microsoft library builtins.
+def SetJmpEx : MSLibBuiltin<"setjmpex.h"> {
+ let Spellings = ["_setjmpex"];
+ let Attributes = [IgnoreSignature, ReturnsTwice];
+ let Prototype = "int(jmp_buf)";
+}
+
+// C99 library functions
+// C99 stdarg.h
+def VaStart : LibBuiltin<"stdarg.h"> {
+ let Spellings = ["va_start"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(__builtin_va_list_ref, ...)";
+}
+
+def VaEnd : LibBuiltin<"stdarg.h"> {
+ let Spellings = ["va_end"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(__builtin_va_list_ref)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VaCopy : LibBuiltin<"stdarg.h"> {
+ let Spellings = ["va_copy"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(__builtin_va_list_ref, __builtin_va_list_ref)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// C99 stdlib.h
+def Abort : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["abort"];
+ let Attributes = [NoThrow, NoReturn];
+ let Prototype = "void()";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Calloc : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["calloc"];
+ let Prototype = "void*(size_t, size_t)";
+}
+
+def Exit : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["exit", "_Exit"];
+ let Attributes = [NoReturn];
+ let Prototype = "void(int)";
+}
+
+def Malloc : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["malloc"];
+ let Prototype = "void*(size_t)";
+}
+
+def Realloc : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["realloc"];
+ let Prototype = "void*(void*, size_t)";
+}
+
+def Free : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["free"];
+ let Prototype = "void(void*)";
+}
+
+def StrToD : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtod"];
+ let Prototype = "double(char const*, char**)";
+}
+
+def StrToF : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtof"];
+ let Prototype = "float(char const*, char**)";
+}
+
+def StrToLd : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtold"];
+ let Prototype = "long double(char const*, char**)";
+}
+
+def StrToL : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtol"];
+ let Prototype = "long int(char const*, char**, int)";
+}
+
+def StrToLL : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtoll"];
+ let Prototype = "long long int(char const*, char**, int)";
+}
+
+def StrToUL : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtoul"];
+ let Prototype = "unsigned long int(char const*, char**, int)";
+}
+
+def StrToULL : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["strtoull"];
+ let Prototype = "unsigned long long int(char const*, char**, int)";
+}
+
+// C11 stdlib.h
+def AlignedAlloc : LibBuiltin<"stdlib.h"> {
+ let Spellings = ["aligned_alloc"];
+ let Prototype = "void*(size_t, size_t)";
+}
+
+// C99 string.h
+def MemCpy : LibBuiltin<"string.h"> {
+ let Spellings = ["memcpy"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "void*(void*, void const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def BuiltinMemCmp : Builtin {
+ let Spellings = ["__builtin_memcmp"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Constexpr];
+ let Prototype = "int(void const*, void const*, size_t)";
+}
+
+def MemCmp : LibBuiltin<"string.h"> {
+ let Spellings = ["memcmp"];
+ let Attributes = [Constexpr];
+ let Prototype = "int(void const*, void const*, size_t)";
+}
+
+def MemMove : LibBuiltin<"string.h"> {
+ let Spellings = ["memmove"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "void*(void*, void const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrCpy : LibBuiltin<"string.h"> {
+ let Spellings = ["strcpy"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrNCpy : LibBuiltin<"string.h"> {
+ let Spellings = ["strncpy"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char*, char const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrCmp : LibBuiltin<"string.h"> {
+ let Spellings = ["strcmp"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "int(char const*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrNCmp : LibBuiltin<"string.h"> {
+ let Spellings = ["strncmp"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "int(char const*, char const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrCat : LibBuiltin<"string.h"> {
+ let Spellings = ["strcat"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrNCat : LibBuiltin<"string.h"> {
+ let Spellings = ["strncat"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char*, char const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrxFrm : LibBuiltin<"string.h"> {
+ let Spellings = ["strxfrm"];
+ let Prototype = "size_t(char*, char const*, size_t)";
+}
+
+def MemChr : LibBuiltin<"string.h"> {
+ let Spellings = ["memchr"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "void*(void const*, int, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrChr : LibBuiltin<"string.h"> {
+ let Spellings = ["strchr"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "char*(char const*, int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrcSpn : LibBuiltin<"string.h"> {
+ let Spellings = ["strcspn"];
+ let Prototype = "size_t(char const*, char const*)";
+}
+
+def StrpBrk : LibBuiltin<"string.h"> {
+ let Spellings = ["strpbrk"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrrChr : LibBuiltin<"string.h"> {
+ let Spellings = ["strrchr"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*, int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrSpn : LibBuiltin<"string.h"> {
+ let Spellings = ["strspn"];
+ let Attributes = [NoThrow];
+ let Prototype = "size_t(char const*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrStr : LibBuiltin<"string.h"> {
+ let Spellings = ["strstr"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrTok : LibBuiltin<"string.h"> {
+ let Spellings = ["strtok"];
+ let Prototype = "char*(char*, char const*)";
+}
+
+def MemSet : LibBuiltin<"string.h"> {
+ let Spellings = ["memset"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void*, int, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrError : LibBuiltin<"string.h"> {
+ let Spellings = ["strerror"];
+ let Prototype = "char*(int)";
+}
+
+def StrLen : LibBuiltin<"string.h"> {
+ let Spellings = ["strlen"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "size_t(char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// C99 stdio.h
+// FIXME: This list is incomplete.
+def Printf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["printf"];
+ let Attributes = [PrintfFormat<0>];
+ let Prototype = "int(char const*, ...)";
+}
+
+// FIXME: The builtin and library function should have the same signature.
+def BuiltinPrintf : Builtin {
+ let Spellings = ["__builtin_printf"];
+ let Attributes = [NoThrow, PrintfFormat<0>, FunctionWithBuiltinPrefix];
+ let Prototype = "int(char const* restrict, ...)";
+}
+
+def FPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["fprintf"];
+ let Attributes = [NoThrow, PrintfFormat<1>];
+ let Prototype = "int(FILE* restrict, char const* restrict, ...)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def SnPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["snprintf"];
+ let Attributes = [NoThrow, PrintfFormat<2>];
+ let Prototype = "int(char* restrict, size_t, char const* restrict, ...)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def SPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["sprintf"];
+ let Attributes = [NoThrow, PrintfFormat<1>];
+ let Prototype = "int(char* restrict, char const* restrict, ...)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vprintf"];
+ let Attributes = [NoThrow, VPrintfFormat<0>];
+ let Prototype = "int(char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VfPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vfprintf"];
+ let Attributes = [NoThrow, VPrintfFormat<1>];
+ let Prototype = "int(FILE* restrict, char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VsnPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vsnprintf"];
+ let Attributes = [NoThrow, VPrintfFormat<2>];
+ let Prototype = "int(char* restrict, size_t, char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VsPrintf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vsprintf"];
+ let Attributes = [NoThrow, VPrintfFormat<1>];
+ let Prototype = "int(char* restrict, char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Scanf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["scanf"];
+ let Attributes = [ScanfFormat<0>];
+ let Prototype = "int(char const* restrict, ...)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def FScanf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["fscanf"];
+ let Attributes = [ScanfFormat<1>];
+ let Prototype = "int(FILE* restrict, char const* restrict, ...)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def SScanf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["sscanf"];
+ let Attributes = [ScanfFormat<1>];
+ let Prototype = "int(char const* restrict, char const* restrict, ...)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VScanf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vscanf"];
+ let Attributes = [VScanfFormat<0>];
+ let Prototype = "int(char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VFScanf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vfscanf"];
+ let Attributes = [VScanfFormat<1>];
+ let Prototype = "int(FILE* restrict, char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def VSScanf : LibBuiltin<"stdio.h"> {
+ let Spellings = ["vsscanf"];
+ let Attributes = [VScanfFormat<1>];
+ let Prototype = "int(char const* restrict, char const* restrict, __builtin_va_list)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Fopen : LibBuiltin<"stdio.h"> {
+ let Spellings = ["fopen"];
+ let Prototype = "FILE*(char const*, char const*)";
+}
+
+def Fread : LibBuiltin<"stdio.h"> {
+ let Spellings = ["fread"];
+ let Prototype = "size_t(void*, size_t, size_t, FILE*)";
+}
+
+def Fwrite : LibBuiltin<"stdio.h"> {
+ let Spellings = ["fwrite"];
+ let Prototype = "size_t(void const*, size_t, size_t, FILE*)";
+}
+
+// C99 ctype.h
+
+def IsAlNum : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isalnum"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsAlpha : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isalpha"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsBlank : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isblank"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsCntrl : LibBuiltin<"ctype.h"> {
+ let Spellings = ["iscntrl"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsDigit : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isdigit"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsGraph : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isgraph"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsLower : LibBuiltin<"ctype.h"> {
+ let Spellings = ["islower"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsPrint : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isprint"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsPunct : LibBuiltin<"ctype.h"> {
+ let Spellings = ["ispunct"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsSpace : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isspace"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsUpper : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isupper"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def IsXDigit : LibBuiltin<"ctype.h"> {
+ let Spellings = ["isxdigit"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def ToLower : LibBuiltin<"ctype.h"> {
+ let Spellings = ["tolower"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+def ToUpper : LibBuiltin<"ctype.h"> {
+ let Spellings = ["toupper"];
+ let Attributes = [NoThrow, Pure];
+ let Prototype = "int(int)";
+}
+
+// C99 wchar.h
+// FIXME: This list is incomplete. We should cover at least the functions that
+// take format strings.
+
+def WcsChr : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wcschr"];
+ let Attributes = [NoThrow, Pure, Constexpr];
+ let Prototype = "wchar_t*(wchar_t const*, wchar_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WcsCmp : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wcscmp"];
+ let Attributes = [NoThrow, Pure, Constexpr];
+ let Prototype = "int(wchar_t const*, wchar_t const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WcsLen : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wcslen"];
+ let Attributes = [NoThrow, Pure, Constexpr];
+ let Prototype = "size_t(wchar_t const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WcsnCmp : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wcsncmp"];
+ let Attributes = [NoThrow, Pure, Constexpr];
+ let Prototype = "int(wchar_t const*, wchar_t const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WMemChr : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wmemchr"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "wchar_t*(wchar_t const*, wchar_t, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WMemCmp : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wmemcmp"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "int(wchar_t const*, wchar_t const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WMemCpy : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wmemcpy"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "wchar_t*(wchar_t*, wchar_t const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def WMemMove : LibBuiltin<"wchar.h"> {
+ let Spellings = ["wmemmove"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "wchar_t*(wchar_t*, wchar_t const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// C99
+
+// FIXME: MinGW _setjmp has an additional void* parameter.
+def SetJmp : LibBuiltin<"setjmp.h"> {
+ let Spellings = ["setjmp", "_setjmp"];
+ let Attributes = [ReturnsTwice, IgnoreSignature];
+ let Prototype = "int(jmp_buf)";
+ let RequiresUndef = 1;
+}
+
+def LongJmp : LibBuiltin<"setjmp.h"> {
+ let Spellings = ["longjmp"];
+ let Attributes = [NoReturn, IgnoreSignature];
+ let Prototype = "void(jmp_buf, int)";
+}
+
+// Non-C library functions, active in GNU mode only.
+// Functions with [[gnu::returns_twice]] attribute are still active in
+// all languages, because losing this attribute would result in miscompilation
+// when these functions are used in non-GNU mode. PR16138.
+
+def AllocA : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["alloca"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// POSIX malloc.h
+
+def MemAlign : GNULibBuiltin<"malloc.h"> {
+ let Spellings = ["memalign"];
+ let Prototype = "void*(size_t, size_t)";
+}
+
+// POSIX string.h
+
+def MemcCpy : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["memccpy"];
+ let Prototype = "void*(void*, void const*, int, size_t)";
+}
+
+def MempCpy : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["mempcpy"];
+ let Prototype = "void*(void*, void const*, size_t)";
+}
+
+def StpCpy : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["stpcpy"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StpnCpy : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["stpncpy"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char*, char const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrDup : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["strdup"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def StrnDup : GNULibBuiltin<"stdlib.h"> {
+ let Spellings = ["strndup"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// POSIX strings.h
+
+def Index : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["index"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*, int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Rindex : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["rindex"];
+ let Attributes = [NoThrow];
+ let Prototype = "char*(char const*, int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def BZero : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["bzero"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// FIXME: This should be part of BCmp.
+def BuiltinBCmp : Builtin {
+ let Spellings = ["__builtin_bcmp"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Constexpr];
+ let Prototype = "int(void const*, void const*, size_t)";
+}
+
+def BCmp : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["bcmp"];
+ let Attributes = [Constexpr];
+ let Prototype = "int(void const*, void const*, size_t)";
+}
+
+def StrCaseCmp : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["strcasecmp"];
+ let Prototype = "int(char const*, char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+ let RequiresUndef = 1;
+}
+
+def StrnCaseCmp : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["strncasecmp"];
+ let Prototype = "int(char const*, char const*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+ let RequiresUndef = 1;
+}
+
+def GNU_Exit : GNULibBuiltin<"unistd.h"> {
+ let Spellings = ["_exit"];
+ let Attributes = [NoReturn];
+ let Prototype = "void(int)";
+}
+
+def VFork : LibBuiltin<"unistd.h"> {
+ let Spellings = ["vfork"];
+ let Attributes = [ReturnsTwice, IgnoreSignature];
+ let Prototype = "pid_t()";
+}
+
+// POSIX pthread.h
+// FIXME: This should be a GNULibBuiltin, but it's currently missing the prototype.
+
+def PthreadCreate : CustomEntry {
+ let Entry = "LIBBUILTIN(pthread_create, \"\", \"fC<2,3>\", PTHREAD_H, ALL_GNU_LANGUAGES)";
+}
+
+def SigSetJmp : LibBuiltin<"setjmp.h"> {
+ let Spellings = ["sigsetjmp", "__sigsetjmp"];
+ let Attributes = [ReturnsTwice, IgnoreSignature];
+ let Prototype = "int(sigjmp_buf, int)";
+}
+
+def SaveCtx : LibBuiltin<"setjmp.h"> {
+ let Spellings = ["savectx"];
+ let Attributes = [ReturnsTwice, IgnoreSignature];
+ let Prototype = "int(sigjmp_buf)";
+}
+
+def GetContext : LibBuiltin<"setjmp.h"> {
+ let Spellings = ["getcontext"];
+ let Attributes = [ReturnsTwice, IgnoreSignature];
+ let Prototype = "int(ucontext_t*)";
+}
+
+def GNU_LongJmp : GNULibBuiltin<"setjmp.h"> {
+ let Spellings = ["_longjmp"];
+ let Attributes = [NoReturn, IgnoreSignature];
+ let Prototype = "void(jmp_buf, int)";
+}
+
+def SigLongJmp : GNULibBuiltin<"setjmp.h"> {
+ let Spellings = ["siglongjmp"];
+ let Attributes = [NoReturn, IgnoreSignature];
+ let Prototype = "void(sigjmp_buf, int)";
+}
+
+// non-standard but very common
+
+def StrlCpy : GNULibBuiltin<"string.h"> {
+ let Spellings = ["strlcpy"];
+ let Prototype = "size_t(char*, char const*, size_t)";
+}
+
+def StrlCat : GNULibBuiltin<"string.h"> {
+ let Spellings = ["strlcat"];
+ let Prototype = "size_t(char*, char const*, size_t)";
+}
+
+def ObjcMsgSend : ObjCLibBuiltin<"objc_message.h"> {
+ let Spellings = ["objc_msgSend"];
+ let Prototype = "id(id, SEL, ...)";
+}
+
+def ObjcMsgSendFpret : ObjCLibBuiltin<"objc_message.h"> {
+ let Spellings = ["objc_msgSend_fpret"];
+ let Prototype = "long double(id, SEL, ...)";
+}
+
+def ObjcMsgSendFp2ret : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_msgSend_fp2ret"];
+ let Prototype = "_Complex long double(id, SEL, ...)";
+}
+
+def ObjcMsgSendStret : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_msgSend_stret"];
+ let Prototype = "void(id, SEL, ...)";
+}
+
+def ObjcMsgSendSuper : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_msgSendSuper"];
+ let Prototype = "id(objc_super*, SEL, ...)";
+}
+
+def ObjcMsgSendSuperStret : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_msgSendSuper_stret"];
+ let Prototype = "void(objc_super*, SEL, ...)";
+}
+
+def ObjcGetClass : ObjCLibBuiltin<"objc/runtime.h"> {
+ let Spellings = ["objc_getClass"];
+ let Prototype = "id(char const*)";
+}
+
+def ObjcGetMetaClass : ObjCLibBuiltin<"objc/runtime.h"> {
+ let Spellings = ["objc_getMetaClass"];
+ let Prototype = "id(char const*)";
+}
+
+def ObjcEnumerationMutation : ObjCLibBuiltin<"objc/runtime.h"> {
+ let Spellings = ["objc_enumerationMutation"];
+ let Prototype = "void(id)";
+}
+
+def ObjcReadWeak : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_read_weak"];
+ let Prototype = "id(id*)";
+}
+
+def ObjcAssignWeak : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_assign_weak"];
+ let Prototype = "id(id, id*)";
+}
+
+def ObjcAssignIvar : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_assign_ivar"];
+ let Prototype = "id(id, id, ptrdiff_t)";
+}
+
+def ObjcAssignGlobal : ObjCLibBuiltin<"objc/message.h"> {
+ let Spellings = ["objc_assign_global"];
+ let Prototype = "id(id, id*)";
+}
+
+def ObjcAssignStrongCast : ObjCLibBuiltin<"objc/objc-auto.h"> {
+ let Spellings = ["objc_assign_strongCast"];
+ let Prototype = "id(id, id*)";
+}
+
+def ObjcExceptionExtract : ObjCLibBuiltin<"objc/objc_exception.h"> {
+ let Spellings = ["objc_exception_extract"];
+ let Prototype = "id(void*)";
+}
+
+def ObjcExceptionTryEnter : ObjCLibBuiltin<"objc/objc_exception.h"> {
+ let Spellings = ["objc_exception_try_enter"];
+ let Prototype = "void(void*)";
+}
+
+def ObjcExceptionTryExit : ObjCLibBuiltin<"objc/objc_exception.h"> {
+ let Spellings = ["objc_exception_try_exit"];
+ let Prototype = "void(void*)";
+}
+
+def ObjcExceptionMatch : ObjCLibBuiltin<"objc/objc_exception.h"> {
+ let Spellings = ["objc_exception_match"];
+ let Prototype = "int(id, id)";
+}
+
+def ObjcExceptionThrow : ObjCLibBuiltin<"objc/objc_exception.h"> {
+ let Spellings = ["objc_exception_throw"];
+ let Prototype = "void(id)";
+}
+
+def ObjcSyncEnter : ObjCLibBuiltin<"objc_objc_sync.h"> {
+ let Spellings = ["objc_sync_enter"];
+ let Prototype = "int(id)";
+}
+
+def ObjcSyncExit : ObjCLibBuiltin<"objc_objc_sync.h"> {
+ let Spellings = ["objc_sync_exit"];
+ let Prototype = "int(id)";
+}
+
+def ObjcMemmoveCollectable : Builtin {
+ let Spellings = ["__builtin_objc_memmove_collectable"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix];
+ let Prototype = "void*(void*, void const*, size_t)";
+}
+
+def NSLog : ObjCLibBuiltin<"foundation_nsobjcruntime.h"> {
+ let Spellings = ["NSLog"];
+ let Attributes = [PrintfFormat<0>];
+ let Prototype = "void(id, ...)";
+}
+
+def NSLogv : ObjCLibBuiltin<"foundation_nsobjcruntime.h"> {
+ let Spellings = ["NSLogv"];
+ let Attributes = [VPrintfFormat<0>];
+ let Prototype = "void(id, __builtin_va_list)";
+}
+
+def Atan2 : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["atan2"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Abs : IntMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["abs"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Copysign : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["copysign"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+ let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
+}
+
+def Fabs : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["fabs"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+ let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
+}
+
+def Finite : FPMathTemplate, GNULibBuiltin<"math.h"> {
+ let Spellings = ["finite"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "int(T)";
+ let RequiresUndef = 1;
+}
+
+def OSXFinite : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["__finite"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "int(T)";
+}
+
+def Fmod : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["fmod"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Frexp : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["frexp"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T, int*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ldexp : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["ldexp"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Modf : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["modf"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T, T*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Nan : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["nan"];
+ let Attributes = [Pure, NoThrow];
+ let Prototype = "T(char const*)";
+ let AddBuiltinPrefixedAlias = 1;
+ let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
+}
+
+def Pow : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["pow"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Acos : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["acos"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Acosh : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["acosh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Asin : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["asin"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Asinh : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["asinh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Atan : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["atan"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Atanh : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["atanh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cbrt : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["cbrt"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ceil : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["ceil"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cos : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["cos"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cosh : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["cosh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Erf : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["erf"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Erfc : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["erfc"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Exp : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["exp"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Exp2 : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["exp2"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// FIXME: Why is there no builtin without the prefix?
+def Exp10 : FPMathTemplate, Builtin {
+ let Spellings = ["__builtin_exp10"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow,
+ ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Expm1 : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["expm1"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Fdim : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["fdim"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Floor : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["floor"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Fma : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["fma"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Fmax : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["fmax"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+ let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
+}
+
+def Fmin : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["fmin"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+ let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
+}
+
+def Hypot : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["hypot"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ilogb : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["ilogb"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "int(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Lgamma : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["lgamma"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Llrint : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["llrint"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long long int(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Llround : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["llround"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long long int(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Log : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["log"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Log10 : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["log10"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Log1p : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["log1p"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Log2 : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["log2"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Logb : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["logb"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Lrint : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["lrint"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long int(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Lround : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["lround"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "long int(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Nearbyint : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["nearbyint"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Nextafter : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["nextafter"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Nexttoward : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["nexttoward"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, long double)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Remainder : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["remainder"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Remquo : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["remquo"];
+ let Attributes = [NoThrow];
+ let Prototype = "T(T, T, int*)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Rint : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["rint"];
+ let Attributes = [NoThrow, ConstIgnoringExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Round : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["round"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def RoundEven : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["roundeven"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Scalbln : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["scalbln"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, long int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Scalbn : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["scalbn"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T, int)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Sin : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["sin"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Sinh : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["sinh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Sqrt : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["sqrt"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Tan : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["tan"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Tanh : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["tanh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Tgamma : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["tgamma"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Trunc : FPMathTemplate, LibBuiltin<"math.h"> {
+ let Spellings = ["trunc"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cabs : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cabs"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cacos : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cacos"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cacosh : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cacosh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Carg : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["carg"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Casin : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["casin"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Casinh : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["casinh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Catan : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["catan"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Catanh : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["catanh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ccos : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["ccos"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ccosh : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["ccosh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cexp : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cexp"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cimag : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cimag"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Conj : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["conj"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Clog : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["clog"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cproj : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cproj"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Cpow : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["cpow"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T, _Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Creal : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["creal"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Csin : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["csin"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Csinh : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["csinh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Csqrt : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["csqrt"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ctan : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["ctan"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+def Ctanh : FPMathTemplate, LibBuiltin<"complex.h"> {
+ let Spellings = ["ctanh"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "_Complex T(_Complex T)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
+// __sinpi and friends are OS X specific library functions, but otherwise much
+// like the standard (non-complex) sin (etc).
+def Sinpi : LibBuiltin<"math.h">, FloatDoubleTemplate {
+ let Spellings = ["__sinpi"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Cospi : LibBuiltin<"math.h">, FloatDoubleTemplate {
+ let Spellings = ["__cospi"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+def Tanpi : LibBuiltin<"math.h">, FloatDoubleTemplate {
+ let Spellings = ["__tanpi"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+// Similarly, __exp10 is OS X only
+def OSXExp10 : LibBuiltin<"math.h">, FloatDoubleTemplate {
+ let Spellings = ["__exp10"];
+ let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];
+ let Prototype = "T(T)";
+}
+
+// Blocks runtime Builtin math library functions.
+def BlockObjectAssign : LibBuiltin<"blocks.h"> {
+ let Spellings = ["_Block_object_assign"];
+ let Prototype = "void(void*, void const*, int const)";
+}
+
+def BlockObjectDispose : LibBuiltin<"blocks.h"> {
+ let Spellings = ["_Block_object_dispose"];
+ let Prototype = "void(void const*, int const)";
+}
+// FIXME: Also declare NSConcreteGlobalBlock and NSConcreteStackBlock.
+
+def Addressof : CxxLibBuiltin<"memory"> {
+ let Spellings = ["addressof", "__addressof"];
+ let Attributes = [NoThrow, Const, IgnoreSignature, RequireDeclaration,
+ Constexpr];
+ let Prototype = "void*(void&)";
+ let Namespace = "std";
+}
+
+def AsConst : CxxLibBuiltin<"utility"> {
+ let Spellings = ["as_const"];
+ let Attributes = [NoThrow, Const, IgnoreSignature, RequireDeclaration,
+ Constexpr];
+ let Prototype = "void&(void&)";
+ let Namespace = "std";
+}
+
+def Forward : CxxLibBuiltin<"utility"> {
+ let Spellings = ["forward"];
+ let Attributes = [NoThrow, Const, IgnoreSignature, RequireDeclaration,
+ Constexpr];
+ let Prototype = "void&(void&)";
+ let Namespace = "std";
+}
+
+def ForwardLike : CxxLibBuiltin<"utility"> {
+ let Spellings = ["forward_like"];
+ let Attributes = [NoThrow, Const, IgnoreSignature, RequireDeclaration,
+ Constexpr];
+ let Prototype = "void&(void&)";
+ let Namespace = "std";
+}
+
+def Move : CxxLibBuiltin<"utility"> {
+ let Spellings = ["move"];
+ let Attributes = [NoThrow, Const, IgnoreSignature, RequireDeclaration,
+ Constexpr];
+ let Prototype = "void&(void&)";
+ let Namespace = "std";
+}
+
+def MoveIfNsoexcept : CxxLibBuiltin<"memory"> {
+ let Spellings = ["move_if_noexcept"];
+ let Attributes = [NoThrow, Const, IgnoreSignature, RequireDeclaration,
+ Constexpr];
+ let Prototype = "void&(void&)";
+ let Namespace = "std";
+}
+
+def Annotation : Builtin {
+ let Spellings = ["__builtin_annotation"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+// Invariants
+def Assume : Builtin {
+ let Spellings = ["__builtin_assume"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "void(bool)";
+}
+
+def AssumeSeparateStorage : Builtin {
+ let Spellings = ["__builtin_assume_separate_storage"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "void(void const volatile*, void const volatile*)";
+}
+
+// Multiprecision Arithmetic Builtins.
+
+class MPATemplate : Template<
+ ["unsigned char", "unsigned short", "unsigned int",
+ "unsigned long int", "unsigned long long int"],
+ ["b", "s", "",
+ "l", "ll"]>;
+
+def Addc : Builtin, MPATemplate {
+ let Spellings = ["__builtin_addc"];
+ let Attributes = [NoThrow];
+ // FIXME: Why are these argumentes marked const?
+ let Prototype = "T(T const, T const, T const, T*)";
+}
+
+def Subc : Builtin, MPATemplate {
+ let Spellings = ["__builtin_subc"];
+ let Attributes = [NoThrow];
+ // FIXME: Why are these argumentes marked const?
+ let Prototype = "T(T const, T const, T const, T*)";
+}
+
+// Checked Arithmetic Builtins for Security.
+def AddOverflow : Builtin {
+ let Spellings = ["__builtin_add_overflow"];
+ let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
+ let Prototype = "bool(...)";
+}
+
+def SubOverflow : Builtin {
+ let Spellings = ["__builtin_sub_overflow"];
+ let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
+ let Prototype = "bool(...)";
+}
+
+def MulOverflow : Builtin {
+ let Spellings = ["__builtin_mul_overflow"];
+ let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
+ let Prototype = "bool(...)";
+}
+
+class UOverflowTemplate :
+ Template<["unsigned int", "unsigned long int", "unsigned long long int"],
+ ["_overflow", "l_overflow", "ll_overflow"]>;
+
+def UaddOverflow : Builtin, UOverflowTemplate {
+ let Spellings = ["__builtin_uadd"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(T const, T const, T*)";
+}
+
+def UsubOverflow : Builtin, UOverflowTemplate {
+ let Spellings = ["__builtin_usub"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(T const, T const, T*)";
+}
+
+def UmulOverflow : Builtin, UOverflowTemplate {
+ let Spellings = ["__builtin_umul"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(T const, T const, T*)";
+}
+
+class SOverflowTemplate :
+ Template<["int", "long int", "long long int"],
+ ["_overflow", "l_overflow", "ll_overflow"]>;
+
+def SaddOverflow : Builtin, UOverflowTemplate {
+ let Spellings = ["__builtin_sadd"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(T const, T const, T*)";
+}
+
+def SsubOverflow : Builtin, UOverflowTemplate {
+ let Spellings = ["__builtin_ssub"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(T const, T const, T*)";
+}
+
+def SmulOverflow : Builtin, UOverflowTemplate {
+ let Spellings = ["__builtin_smul"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "bool(T const, T const, T*)";
+}
+
+// Clang builtins (not available in GCC).
+def BuiltinAddressof : Builtin {
+ let Spellings = ["__builtin_addressof"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(void&)";
+}
+
+def BuiltinFunctionStart : Builtin {
+ let Spellings = ["__builtin_function_start"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(void&)";
+}
+
+def BuiltinOperatorNew : Builtin {
+ let Spellings = ["__builtin_operator_new"];
+ let Attributes = [Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(size_t)";
+}
+
+def BuiltinOperatorDelete : Builtin {
+ let Spellings = ["__builtin_operator_delete"];
+ let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
+ let Prototype = "void(void*)";
+}
+
+def BuiltinCharMemchr : Builtin {
+ let Spellings = ["__builtin_char_memchr"];
+ let Attributes = [NoThrow, Constexpr];
+ let Prototype = "char*(char const*, int, size_t)";
+}
+
+def BuiltinDumpStruct : Builtin {
+ let Spellings = ["__builtin_dump_struct"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def BuiltinPreserveAccessIndex : Builtin {
+ let Spellings = ["__builtin_preserve_access_index"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def IsAligned : Builtin {
+ let Spellings = ["__builtin_is_aligned"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "bool(void const*, size_t)";
+}
+
+def AlignUp : Builtin {
+ let Spellings = ["__builtin_align_up"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(void const*, size_t)";
+}
+
+def AlignDown : Builtin {
+ let Spellings = ["__builtin_align_down"];
+ let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+ let Prototype = "void*(void const*, size_t)";
+}
+
+// Safestack builtins.
+def GetUnsafeStackStart : Builtin {
+ let Spellings = ["__builtin___get_unsafe_stack_start"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix];
+ let Prototype = "void*()";
+}
+
+def GetUnsafeStackBottom : Builtin {
+ let Spellings = ["__builtin___get_unsafe_stack_bottom"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix];
+ let Prototype = "void*()";
+}
+
+def GetUnsafeStackTop : Builtin {
+ let Spellings = ["__builtin___get_unsafe_stack_top"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix];
+ let Prototype = "void*()";
+}
+
+def GetUnsafeStackPtr : Builtin {
+ let Spellings = ["__builtin___get_unsafe_stack_ptr"];
+ let Attributes = [NoThrow, FunctionWithBuiltinPrefix];
+ let Prototype = "void*()";
+}
+
+// Nontemporal loads/stores builtins.
+def NontemporalStore : Builtin {
+ let Spellings = ["__builtin_nontemporal_store"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def NontemporalLoad : Builtin {
+ let Spellings = ["__builtin_nontemporal_load"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+// Coroutine intrinsics
+def CoroResume : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_resume"];
+ let Prototype = "void(void*)";
+}
+
+def CoroDestroy : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_destroy"];
+ let Prototype = "void(void*)";
+}
+
+def CoroDone : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_done"];
+ let Attributes = [NoThrow];
+ let Prototype = "bool(void*)";
+}
+
+def CoroPromise : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_promise"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void*, _Constant int, _Constant bool)";
+}
+
+def CoroSize : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_size"];
+ let Attributes = [NoThrow];
+ let Prototype = "size_t()";
+}
+
+def CoroAlign : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_align"];
+ let Attributes = [NoThrow];
+ let Prototype = "size_t()";
+}
+
+def CoroFrame : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_frame"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*()";
+}
+
+def CoroNoop : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_noop"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*()";
+}
+
+def CoroFree : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_free"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+def CoroId : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_id"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(_Constant int, void*, void*, void*)";
+}
+
+def CoroAlloc : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_alloc"];
+ let Attributes = [NoThrow];
+ let Prototype = "bool()";
+}
+
+def CoroBegin : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_begin"];
+ let Attributes = [NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+def CoroEnd : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_end"];
+ let Attributes = [NoThrow];
+ let Prototype = "bool(void*, _Constant bool)";
+}
+
+def CoroSuspend : CoroLangBuiltin {
+ let Spellings = ["__builtin_coro_suspend"];
+ let Attributes = [NoThrow];
+ let Prototype = "char(_Constant bool)";
+}
+
+// OpenCL v2.0 s6.13.16, s9.17.3.5 - Pipe functions.
+// We need the generic prototype, since the packet type could be anything.
+def ReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def WritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def ReserveReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["reserve_read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def ReserveWritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["reserve_write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def CommitWritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["commit_write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void(...)";
+}
+
+def CommitReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["commit_read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void(...)";
+}
+
+def SubGroupReserveReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["sub_group_reserve_read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def SubGroupReserveWritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["sub_group_reserve_write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def SubGroupCommitWritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["sub_group_commit_write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void(...)";
+}
+
+def SubGroupCommitReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["sub_group_commit_read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void(...)";
+}
+
+def WorkGroupReserveReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["work_group_reserve_read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def WorkGroupReserveWritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["work_group_reserve_write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def WorkGroupCommitWritePipe : OCLPipeLangBuiltin {
+ let Spellings = ["work_group_commit_write_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void(...)";
+}
+
+def WorkGroupCommitReadPipe : OCLPipeLangBuiltin {
+ let Spellings = ["work_group_commit_read_pipe"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void(...)";
+}
+
+def GetPipeNumPackets : OCLPipeLangBuiltin {
+ let Spellings = ["get_pipe_num_packets"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "unsigned int(...)";
+}
+
+def GetPipeMaxPackets : OCLPipeLangBuiltin {
+ let Spellings = ["get_pipe_max_packets"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "unsigned int(...)";
+}
+
+// OpenCL v2.0 s6.13.17 - Enqueue kernel functions.
+// Custom builtin check allows to perform special check of passed block arguments.
+def EnqueueKernel : OCL_DSELangBuiltin {
+ let Spellings = ["enqueue_kernel"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "int(...)";
+}
+
+def GetKernelWorkGroupSize : OCL_DSELangBuiltin {
+ let Spellings = ["get_kernel_work_group_size"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "unsigned int(...)";
+}
+
+def GetKernelPreferredWorkGroupSizeMultiple : OCL_DSELangBuiltin {
+ let Spellings = ["get_kernel_preferred_work_group_size_multiple"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "unsigned int(...)";
+}
+
+def GetKernelMaxSubGroupSizeForNDRange : OCL_DSELangBuiltin {
+ let Spellings = ["get_kernel_max_sub_group_size_for_ndrange"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "unsigned int(...)";
+}
+
+def GetKernelSubGroupCountForNDRange : OCL_DSELangBuiltin {
+ let Spellings = ["get_kernel_sub_group_count_for_ndrange"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "unsigned int(...)";
+}
+
+// OpenCL v2.0 s6.13.9 - Address space qualifier functions.
+// FIXME: Pointer parameters of OpenCL builtins should have their address space
+// requirement defined.
+def ToGlobal : OCL_GASLangBuiltin {
+ let Spellings = ["to_global"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+def ToLocal : OCL_GASLangBuiltin {
+ let Spellings = ["to_local"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+def ToPrivate : OCL_GASLangBuiltin {
+ let Spellings = ["to_private"];
+ let Attributes = [CustomTypeChecking, NoThrow];
+ let Prototype = "void*(void*)";
+}
+
+// OpenCL half load/store builtin.
+def StoreHalf : OCLLangBuiltin, FloatDoubleTemplate {
+ let Spellings = ["__builtin_store_half"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(T, __fp16*)";
+}
+
+def LoadHalf : OCLLangBuiltin, FloatDoubleTemplate {
+ let Spellings = ["__builtin_load_half"];
+ // FIXME: Is this actually Const? This looks like it shoud be Pure.
+ let Attributes = [NoThrow, Const];
+ let Prototype = "T(__fp16 const*)";
+}
+
+// Builtins for os_log/os_trace.
+def OSLogFormatBufferSize : Builtin {
+ let Spellings = ["__builtin_os_log_format_buffer_size"];
+ let Attributes = [PrintfFormat<0>, NoThrow, UnevaluatedArguments,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "size_t(char const*, ...)";
+}
+
+def OSLogFormat : Builtin {
+ let Spellings = ["__builtin_os_log_format"];
+ // FIXME: The printf attribute looks suspiciously like it should be argument #1.
+ let Attributes = [PrintfFormat<0>, NoThrow, CustomTypeChecking];
+ let Prototype = "void*(void*, char const*, ...)";
+}
+
+// CUDA/HIP
+def GetDeviceSideMangledName : LangBuiltin<"CUDA_LANG"> {
+ let Spellings = ["__builtin_get_device_side_mangled_name"];
+ let Attributes = [NoThrow, Const, IgnoreSignature];
+ let Prototype = "char const*(...)";
+}
+
+// HLSL
+def HLSLWaveActiveCountBits : LangBuiltin<"HLSL_LANG"> {
+ let Spellings = ["__builtin_hlsl_wave_active_count_bits"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "unsigned int(bool)";
+}
+
+def HLSLCreateHandle : LangBuiltin<"HLSL_LANG"> {
+ let Spellings = ["__builtin_hlsl_create_handle"];
+ let Attributes = [NoThrow, Const];
+ let Prototype = "void*(unsigned char)";
+}
+
+// Builtins for XRay.
+def XRayCustomEvent : Builtin {
+ let Spellings = ["__xray_customevent"];
+ let Prototype = "void(char const*, size_t)";
+}
+
+def XRayTypedEvent : Builtin {
+ let Spellings = ["__xray_typedevent"];
+ let Prototype = "void(size_t, char const*, size_t)";
+}
+
+// Win64-compatible va_list functions.
+def MSVaStart : Builtin {
+ let Spellings = ["__builtin_ms_va_start"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(char*&, ...)";
+}
+
+def MSVaEnd : Builtin {
+ let Spellings = ["__builtin_ms_va_end"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(char*&)";
+}
+
+def MSVaCopy : Builtin {
+ let Spellings = ["__builtin_ms_va_copy"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(char*&, char*&)";
+}
+
+// Arithmetic Fence: to prevent FP reordering and reassociation optimizations
+// FIXME: Should this just be a Builtin?
+def ArithmeticFence : LangBuiltin<"ALL_LANGUAGES"> {
+ let Spellings = ["__arithmetic_fence"];
+ let Attributes = [CustomTypeChecking, Constexpr];
+ let Prototype = "void(...)";
+}
diff --git a/clang/include/clang/Basic/BuiltinsBPF.def b/clang/include/clang/Basic/BuiltinsBPF.def
deleted file mode 100644
index 190062645ec4d16..000000000000000
--- a/clang/include/clang/Basic/BuiltinsBPF.def
+++ /dev/null
@@ -1,33 +0,0 @@
-//===--- BuiltinsBPF.def - BPF Builtin function database --------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the BPF-specific builtin function database. Users of
-// this file must define the BUILTIN macro to make use of this information.
-//
-//===----------------------------------------------------------------------===//
-
-// The format of this database matches clang/Basic/Builtins.def.
-
-#if defined(BUILTIN) && !defined(TARGET_BUILTIN)
-# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-// Get record field information.
-TARGET_BUILTIN(__builtin_preserve_field_info, "Ui.", "t", "")
-
-// Get BTF type id.
-TARGET_BUILTIN(__builtin_btf_type_id, "LUi.", "t", "")
-
-// Get type information.
-TARGET_BUILTIN(__builtin_preserve_type_info, "Ui.", "t", "")
-
-// Preserve enum value.
-TARGET_BUILTIN(__builtin_preserve_enum_value, "Li.", "t", "")
-
-#undef BUILTIN
-#undef TARGET_BUILTIN
diff --git a/clang/include/clang/Basic/BuiltinsBPF.td b/clang/include/clang/Basic/BuiltinsBPF.td
new file mode 100644
index 000000000000000..169d05c87099844
--- /dev/null
+++ b/clang/include/clang/Basic/BuiltinsBPF.td
@@ -0,0 +1,37 @@
+//===--- BuiltinsBPF.td - BPF Builtin function database ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+include "clang/Basic/BuiltinsBase.td"
+
+// Get record field information
+def PreserveFieldInfo : TargetBuiltin {
+ let Spellings = ["__builtin_preserve_field_info"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "unsigned int(...)";
+}
+
+// Get BTF type id
+def BtfTypeID : TargetBuiltin {
+ let Spellings = ["__builtin_btf_type_id"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "long unsigned int(...)";
+}
+
+// Get type information
+def PreserveTypeInfo : TargetBuiltin {
+ let Spellings = ["__builtin_preserve_type_info"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "long unsigned int(...)";
+}
+
+// Preserve enum value
+def PreserveEnumValue : TargetBuiltin {
+ let Spellings = ["__builtin_preserve_enum_value"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "long int(...)";
+}
diff --git a/clang/include/clang/Basic/BuiltinsBase.td b/clang/include/clang/Basic/BuiltinsBase.td
new file mode 100644
index 000000000000000..b65b41be0326556
--- /dev/null
+++ b/clang/include/clang/Basic/BuiltinsBase.td
@@ -0,0 +1,121 @@
+//===--- BuiltinsBase.td - common structured used by builtins ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Attributes
+// ==========
+
+class Attribute<string mangling> {
+ string Mangling = mangling;
+}
+
+class IndexedAttribute<string baseMangling, int I> : Attribute<baseMangling> {
+ int Index = I;
+}
+
+// Standard Attributes
+// -------------------
+def NoReturn : Attribute<"r">;
+
+// Attributes from the gnu:: namespace
+// -----------------------------------
+def Const : Attribute<"c">;
+def NoThrow : Attribute<"n">;
+def Pure : Attribute<"U">;
+def ReturnsTwice : Attribute<"j">;
+// FIXME: gcc has nonnull
+
+// builtin-specific attributes
+// ---------------------------
+
+// Signature is meaningless, use custom typechecking.
+def CustomTypeChecking : Attribute<"t">;
+
+// Type is not important to semantic analysis and codegen; recognize as builtin
+// even if type doesn't match signature, and don't warn if we can't be sure the
+// type is right.
+def IgnoreSignature : Attribute<"T">;
+
+// Arguments are not evaluated for their side-effects.
+def UnevaluatedArguments : Attribute<"u">;
+
+// FIXME: This is misused in a lot of the places it is used currently.
+// This function is equivalent to a library function without the __builtin_
+// prefix. This is relevant for CodeGen; it should not be used if custom CodeGen
+// is required for a builtin.
+def FunctionWithBuiltinPrefix : Attribute<"F">;
+
+// const, but only when -fno-math-errno and FP exceptions are ignored.
+def ConstIgnoringErrnoAndExceptions : Attribute<"e">;
+
+// const when FP exceptions are ignored.
+def ConstIgnoringExceptions : Attribute<"g">;
+
+// This function requires a specific header or an explicit declaration.
+def RequireDeclaration : Attribute<"h">;
+
+class PrintfFormat<int I> : IndexedAttribute<"p", I>;
+class VPrintfFormat<int I> : IndexedAttribute<"P", I>;
+class ScanfFormat<int I> : IndexedAttribute<"s", I>;
+class VScanfFormat<int I> : IndexedAttribute<"S", I>;
+
+// Other Attributes
+// ----------------
+
+// Builtin can be constant evaluated
+def Constexpr : Attribute<"E">;
+
+// Builtin kinds
+// =============
+
+class Builtin {
+ list<string> Spellings;
+ list<Attribute> Attributes = [];
+ string Prototype;
+ string Namespace;
+ // On some platforms, some functions are actually macros. In that case we need
+ // to #undef them.
+ bit RequiresUndef = 0;
+}
+
+class CustomEntry {
+ string Entry;
+}
+
+class AtomicBuiltin : Builtin;
+class TargetBuiltin : Builtin;
+
+class LibBuiltin<string header, string languages = "ALL_LANGUAGES"> : Builtin {
+ string Header = header;
+ string Languages = languages;
+ bit AddBuiltinPrefixedAlias = 0;
+ bit OnlyBuiltinPrefixedAliasIsConstexpr = 0;
+}
+
+class MSLibBuiltin<string header> : LibBuiltin<header, "ALL_MS_LANGUAGES">;
+class GNULibBuiltin<string header> : LibBuiltin<header, "ALL_GNU_LANGUAGES">;
+class ObjCLibBuiltin<string header> : LibBuiltin<header, "OBJC_LANG">;
+class CxxLibBuiltin<string header> : LibBuiltin<header, "CXX_LANG">;
+
+class LangBuiltin<string languages> : Builtin {
+ string Languages = languages;
+}
+
+class MSLangBuiltin : LangBuiltin<"ALL_MS_LANGUAGES">;
+class CoroLangBuiltin : LangBuiltin<"COR_LANG">;
+class OCLPipeLangBuiltin : LangBuiltin<"OCL_PIPE">;
+class OCL_DSELangBuiltin : LangBuiltin<"OCL_DSE">;
+class OCL_GASLangBuiltin : LangBuiltin<"OCL_GAS">;
+class OCLLangBuiltin : LangBuiltin<"ALL_OCL_LANGUAGES">;
+
+class Template<list<string> substitutions,
+ list<string> affixes,
+ bit as_prefix = 0> {
+ list<string> Substitutions = substitutions;
+ list<string> Affixes = affixes;
+ bit AsPrefix = as_prefix;
+}
diff --git a/clang/include/clang/Basic/CMakeLists.txt b/clang/include/clang/Basic/CMakeLists.txt
index 085e316fcc671df..36edef3d7a4c6d1 100644
--- a/clang/include/clang/Basic/CMakeLists.txt
+++ b/clang/include/clang/Basic/CMakeLists.txt
@@ -57,6 +57,14 @@ clang_tablegen(AttrHasAttributeImpl.inc -gen-clang-attr-has-attribute-impl
TARGET ClangAttrHasAttributeImpl
)
+clang_tablegen(Builtins.inc -gen-clang-builtins
+ SOURCE Builtins.td
+ TARGET ClangBuiltins)
+
+clang_tablegen(BuiltinsBPF.inc -gen-clang-builtins
+ SOURCE BuiltinsBPF.td
+ TARGET ClangBuiltinsBPF)
+
# ARM NEON and MVE
clang_tablegen(arm_neon.inc -gen-arm-neon-sema
SOURCE arm_neon.td
diff --git a/clang/include/clang/Basic/TargetBuiltins.h b/clang/include/clang/Basic/TargetBuiltins.h
index 8f7881abf26f7f4..d5de5a286f7f628 100644
--- a/clang/include/clang/Basic/TargetBuiltins.h
+++ b/clang/include/clang/Basic/TargetBuiltins.h
@@ -84,7 +84,7 @@ namespace clang {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
- #include "clang/Basic/BuiltinsBPF.def"
+ #include "clang/Basic/BuiltinsBPF.inc"
LastTSBuiltin
};
}
diff --git a/clang/include/module.modulemap b/clang/include/module.modulemap
index 6ea613c70306fa1..88596a0675dd132 100644
--- a/clang/include/module.modulemap
+++ b/clang/include/module.modulemap
@@ -42,8 +42,6 @@ module Clang_Basic {
textual header "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
textual header "clang/Basic/BuiltinsAArch64NeonSVEBridge_cg.def"
textual header "clang/Basic/BuiltinsARM.def"
- textual header "clang/Basic/BuiltinsBPF.def"
- textual header "clang/Basic/Builtins.def"
textual header "clang/Basic/BuiltinHeaders.def"
textual header "clang/Basic/BuiltinsHexagon.def"
textual header "clang/Basic/BuiltinsHexagonDep.def"
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index af82ca0784af413..65fa1c69cef412c 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -4923,6 +4923,7 @@ AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr *> args, QualType t,
AtomicOp op, SourceLocation RP)
: Expr(AtomicExprClass, t, VK_PRValue, OK_Ordinary),
NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
+ assert(op != AO__opencl_atomic_init || args.size() == 3);
assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
for (unsigned i = 0; i != args.size(); i++)
SubExprs[i] = args[i];
diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp
index a31aa0cfeeed8de..b53145cb4ea048f 100644
--- a/clang/lib/AST/StmtPrinter.cpp
+++ b/clang/lib/AST/StmtPrinter.cpp
@@ -1833,7 +1833,7 @@ void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
case AtomicExpr::AO ## ID: \
Name = #ID "("; \
break;
-#include "clang/Basic/Builtins.def"
+#include "clang/Basic/Builtins.inc"
}
OS << Name;
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
index d366989bafc560d..3467847ac1672ed 100644
--- a/clang/lib/Basic/Builtins.cpp
+++ b/clang/lib/Basic/Builtins.cpp
@@ -38,7 +38,7 @@ static constexpr Builtin::Info BuiltinInfo[] = {
{#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANGS},
#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS) \
{#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, LANGS},
-#include "clang/Basic/Builtins.def"
+#include "clang/Basic/Builtins.inc"
};
const Builtin::Info &Builtin::Context::getRecord(unsigned ID) const {
diff --git a/clang/lib/Basic/Targets/BPF.cpp b/clang/lib/Basic/Targets/BPF.cpp
index d6288d2e0d0e176..8f4da5cefa8d8c9 100644
--- a/clang/lib/Basic/Targets/BPF.cpp
+++ b/clang/lib/Basic/Targets/BPF.cpp
@@ -22,7 +22,7 @@ using namespace clang::targets;
static constexpr Builtin::Info BuiltinInfo[] = {
#define BUILTIN(ID, TYPE, ATTRS) \
{#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#include "clang/Basic/BuiltinsBPF.def"
+#include "clang/Basic/BuiltinsBPF.inc"
};
void BPFTargetInfo::getTargetDefines(const LangOptions &Opts,
diff --git a/clang/lib/Sema/OpenCLBuiltins.td b/clang/lib/Sema/OpenCLBuiltins.td
index 9db450281912d2f..3d163d723b62fb1 100644
--- a/clang/lib/Sema/OpenCLBuiltins.td
+++ b/clang/lib/Sema/OpenCLBuiltins.td
@@ -939,7 +939,7 @@ def : Builtin<"read_mem_fence", [Void, MemFenceFlags]>;
def : Builtin<"write_mem_fence", [Void, MemFenceFlags]>;
// OpenCL v3.0 s6.15.10 - Address Space Qualifier Functions.
-// to_global, to_local, to_private are declared in Builtins.def.
+// to_global, to_local, to_private are declared in Builtins.td.
let Extension = FuncExtOpenCLCGenericAddressSpace in {
// The OpenCL 3.0 specification defines these with a "gentype" argument indicating any builtin
@@ -1451,25 +1451,25 @@ let Extension = FuncExtOpenCLCWGCollectiveFunctions in {
//--------------------------------------------------------------------
// OpenCL2.0 : 6.13.16 : Pipe Functions
// --- Table 27 ---
-// Defined in Builtins.def
+// Defined in Builtins.td
// --- Table 28 ---
-// Builtins taking pipe arguments are defined in Builtins.def
+// Builtins taking pipe arguments are defined in Builtins.td
let Extension = FuncExtOpenCLCPipes in {
def : Builtin<"is_valid_reserve_id", [Bool, ReserveId]>;
}
// --- Table 29 ---
-// Defined in Builtins.def
+// Defined in Builtins.td
//--------------------------------------------------------------------
// OpenCL2.0 : 6.13.17 : Enqueuing Kernels
// --- Table 30 ---
-// Defined in Builtins.def
+// Defined in Builtins.td
// --- Table 32 ---
-// Defined in Builtins.def
+// Defined in Builtins.td
// --- Table 33 ---
let Extension = FuncExtOpenCLCDeviceEnqueue in {
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index b867d55c174e68b..183f389b791f93f 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -2417,7 +2417,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
case Builtin::BI##ID: \
return SemaAtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
-#include "clang/Basic/Builtins.def"
+#include "clang/Basic/Builtins.inc"
case Builtin::BI__annotation:
if (SemaBuiltinMSVCAnnotation(*this, TheCall))
return ExprError();
@@ -7143,16 +7143,16 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
static_assert(sizeof(NumArgs)/sizeof(NumArgs[0]) == NumForm
&& sizeof(NumVals)/sizeof(NumVals[0]) == NumForm,
"need to update code for modified forms");
- static_assert(AtomicExpr::AO__c11_atomic_init == 0 &&
- AtomicExpr::AO__c11_atomic_fetch_min + 1 ==
- AtomicExpr::AO__atomic_load,
+ static_assert(AtomicExpr::AO__atomic_add_fetch == 0 &&
+ AtomicExpr::AO__atomic_xor_fetch + 1 ==
+ AtomicExpr::AO__c11_atomic_compare_exchange_strong,
"need to update code for modified C11 atomics");
- bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_init &&
- Op <= AtomicExpr::AO__opencl_atomic_fetch_max;
- bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_load &&
- Op <= AtomicExpr::AO__hip_atomic_fetch_max;
- bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_init &&
- Op <= AtomicExpr::AO__c11_atomic_fetch_min) ||
+ bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&
+ Op <= AtomicExpr::AO__opencl_atomic_store;
+ bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
+ Op <= AtomicExpr::AO__hip_atomic_store;
+ bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
+ Op <= AtomicExpr::AO__c11_atomic_store) ||
IsOpenCL;
bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
Op == AtomicExpr::AO__atomic_store_n ||
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 92496b03ecabe54..9cbf6c5aae9a4ab 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -7447,7 +7447,7 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
// Extract the return type from the (builtin) function pointer type.
// FIXME Several builtins still have setType in
// Sema::CheckBuiltinFunctionCall. One should review their definitions in
- // Builtins.def to ensure they are correct before removing setType calls.
+ // Builtins.td to ensure they are correct before removing setType calls.
QualType FnPtrTy = Context.getPointerType(FDecl->getType());
Result = ImpCastExprToType(Fn, FnPtrTy, CK_BuiltinFnToFnPtr).get();
ResultTy = FDecl->getCallResultType();
diff --git a/clang/test/Analysis/bstring.c b/clang/test/Analysis/bstring.c
index a7c7bdb23683e76..07b9645f20d854d 100644
--- a/clang/test/Analysis/bstring.c
+++ b/clang/test/Analysis/bstring.c
@@ -4,7 +4,7 @@
// RUN: -analyzer-checker=alpha.unix.cstring \
// RUN: -analyzer-disable-checker=alpha.unix.cstring.UninitializedRead \
// RUN: -analyzer-checker=debug.ExprInspection \
-// RUN: -analyzer-config eagerly-assume=false
+// RUN: -analyzer-config eagerly-assume=false
//
// RUN: %clang_analyze_cc1 -verify %s -DUSE_BUILTINS \
// RUN: -analyzer-checker=core \
@@ -131,7 +131,7 @@ void memcpy5(void) {
void memcpy6(void) {
int a[4] = {0};
- memcpy(a, a, 8); // expected-warning{{overlapping}}
+ memcpy(a, a, 8); // expected-warning{{overlapping}}
}
void memcpy7(void) {
@@ -257,7 +257,7 @@ void mempcpy5(void) {
void mempcpy6(void) {
int a[4] = {0};
- mempcpy(a, a, 8); // expected-warning{{overlapping}}
+ mempcpy(a, a, 8); // expected-warning{{overlapping}}
}
void mempcpy7(void) {
@@ -319,7 +319,7 @@ void mempcpy15(void) {
p1 = (&s2) + 1;
p2 = mempcpy(&s2, &s1, sizeof(struct st));
-
+
clang_analyzer_eval(p1 == p2); // expected-warning{{TRUE}}
}
@@ -405,7 +405,7 @@ void memmove2 (void) {
#define bcmp BUILTIN(bcmp)
int bcmp(const void *s1, const void *s2, size_t n);
#define memcmp bcmp
-//
+//
#else /* VARIANT */
#define memcmp BUILTIN(memcmp)
@@ -483,7 +483,7 @@ int memcmp8(char *a, size_t n) {
//===----------------------------------------------------------------------===
#define bcopy BUILTIN(bcopy)
-// __builtin_bcopy is not defined with const in Builtins.def.
+// __builtin_bcopy is not defined with const in Builtins.td.
void bcopy(/*const*/ void *s1, void *s2, size_t n);
diff --git a/clang/test/CodeGen/callback_pthread_create.c b/clang/test/CodeGen/callback_pthread_create.c
index 80457cb3ade3bbf..31bc2e9098f45c5 100644
--- a/clang/test/CodeGen/callback_pthread_create.c
+++ b/clang/test/CodeGen/callback_pthread_create.c
@@ -1,4 +1,4 @@
-// FIXME: pthread_create() definition in Builtins.def doesn't match the real one, so it doesn't get recognized as a builtin and attributes aren't added.
+// FIXME: pthread_create() definition in Builtins.td doesn't match the real one, so it doesn't get recognized as a builtin and attributes aren't added.
// RUN: false
// XFAIL: *
diff --git a/clang/utils/TableGen/CMakeLists.txt b/clang/utils/TableGen/CMakeLists.txt
index f136cbfee5fa181..2ca4a96cadb670c 100644
--- a/clang/utils/TableGen/CMakeLists.txt
+++ b/clang/utils/TableGen/CMakeLists.txt
@@ -7,6 +7,7 @@ add_tablegen(clang-tblgen CLANG
ClangASTNodesEmitter.cpp
ClangASTPropertiesEmitter.cpp
ClangAttrEmitter.cpp
+ ClangBuiltinsEmitter.cpp
ClangCommentCommandInfoEmitter.cpp
ClangCommentHTMLNamedCharacterReferenceEmitter.cpp
ClangCommentHTMLTagsEmitter.cpp
diff --git a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
new file mode 100644
index 000000000000000..ac2dbc936c93f4b
--- /dev/null
+++ b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
@@ -0,0 +1,332 @@
+//=- ClangBuiltinsEmitter.cpp - Generate Clang builtins tables -*- C++ -*-====//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This tablegen backend emits Clang's builtins tables.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TableGenBackends.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+using namespace llvm;
+
+namespace {
+enum class BuiltinType {
+ Builtin,
+ AtomicBuiltin,
+ LibBuiltin,
+ LangBuiltin,
+ TargetBuiltin,
+};
+
+class PrototypeParser {
+public:
+ PrototypeParser(StringRef Substitution, const Record *Builtin)
+ : Loc(Builtin->getFieldLoc("Prototype")), Substitution(Substitution) {
+ ParsePrototype(Builtin->getValueAsString("Prototype"));
+ }
+
+private:
+ void ParsePrototype(StringRef Prototype) {
+ Prototype = Prototype.trim();
+ ParseTypes(Prototype);
+ }
+
+ void ParseTypes(StringRef &Prototype) {
+ auto ReturnType = Prototype.take_until([](char c) { return c == '('; });
+ ParseType(ReturnType);
+ Prototype = Prototype.drop_front(ReturnType.size() + 1);
+ if (!Prototype.ends_with(")"))
+ PrintFatalError(Loc, "Expected closing brace at end of prototype");
+ Prototype = Prototype.drop_back();
+ for (auto T = Prototype.split(','); !T.first.empty();
+ Prototype = T.second, T = Prototype.split(','))
+ ParseType(T.first);
+ }
+
+ void ParseType(StringRef T) {
+ T = T.trim();
+ if (T.consume_back("*")) {
+ ParseType(T);
+ Type += "*";
+ } else if (T.consume_back("const")) {
+ ParseType(T);
+ Type += "C";
+ } else if (T.consume_back("volatile")) {
+ ParseType(T);
+ Type += "D";
+ } else if (T.consume_back("restrict")) {
+ ParseType(T);
+ Type += "R";
+ } else if (T.consume_back("&")) {
+ ParseType(T);
+ Type += "&";
+ } else if (T.consume_front("long")) {
+ Type += "L";
+ ParseType(T);
+ } else if (T.consume_front("unsigned")) {
+ Type += "U";
+ ParseType(T);
+ } else if (T.consume_front("_Complex")) {
+ Type += "X";
+ ParseType(T);
+ } else if (T.consume_front("_Constant")) {
+ Type += "I";
+ ParseType(T);
+ } else if (T.consume_front("T")) {
+ if (Substitution.empty())
+ PrintFatalError(Loc, "Not a template");
+ ParseType(Substitution);
+ } else {
+ auto ReturnTypeVal = StringSwitch<std::string>(T)
+ .Case("__builtin_va_list_ref", "A")
+ .Case("__builtin_va_list", "a")
+ .Case("__float128", "LLd")
+ .Case("__fp16", "h")
+ .Case("__int128_t", "LLLi")
+ .Case("_Float16", "x")
+ .Case("bool", "b")
+ .Case("char", "c")
+ .Case("constant_CFString", "F")
+ .Case("double", "d")
+ .Case("FILE", "P")
+ .Case("float", "f")
+ .Case("id", "G")
+ .Case("int", "i")
+ .Case("int32_t", "Zi")
+ .Case("int64_t", "Wi")
+ .Case("jmp_buf", "J")
+ .Case("msint32_t", "Ni")
+ .Case("msuint32_t", "UNi")
+ .Case("objc_super", "M")
+ .Case("pid_t", "p")
+ .Case("ptrdiff_t", "Y")
+ .Case("SEL", "H")
+ .Case("short", "s")
+ .Case("sigjmp_buf", "SJ")
+ .Case("size_t", "z")
+ .Case("ucontext_t", "K")
+ .Case("uint32_t", "UZi")
+ .Case("uint64_t", "UWi")
+ .Case("void", "v")
+ .Case("wchar_t", "w")
+ .Case("...", ".")
+ .Default("error");
+ if (ReturnTypeVal == "error")
+ PrintFatalError(Loc, "Unknown Type: " + T);
+ Type += ReturnTypeVal;
+ }
+ }
+
+public:
+ void Print(llvm::raw_ostream &OS) const { OS << ", \"" << Type << '\"'; }
+
+private:
+ SMLoc Loc;
+ StringRef Substitution;
+ std::string Type;
+};
+
+class HeaderNameParser {
+public:
+ HeaderNameParser(const Record *Builtin) {
+ for (char c : Builtin->getValueAsString("Header")) {
+ if (std::islower(c))
+ HeaderName += static_cast<char>(std::toupper(c));
+ else if (c == '.' || c == '_' || c == '/' || c == '-')
+ HeaderName += '_';
+ else
+ PrintFatalError(Builtin->getLoc(), "Unexpected header name");
+ }
+ }
+
+ void Print(llvm::raw_ostream &OS) const { OS << HeaderName; }
+
+private:
+ std::string HeaderName;
+};
+
+void PrintAttributes(const Record *Builtin, BuiltinType BT,
+ llvm::raw_ostream &OS) {
+ OS << '\"';
+ if (Builtin->isSubClassOf("LibBuiltin")) {
+ if (BT == BuiltinType::LibBuiltin) {
+ OS << 'f';
+ } else {
+ OS << 'F';
+ if (Builtin->getValueAsBit("OnlyBuiltinPrefixedAliasIsConstexpr"))
+ OS << 'E';
+ }
+ }
+
+ if (auto NS = Builtin->getValueAsOptionalString("Namespace")) {
+ if (NS != "std")
+ PrintFatalError(Builtin->getFieldLoc("Namespace"), "Unknown namespace: ");
+ OS << "z";
+ }
+
+ for (const auto *Attr : Builtin->getValueAsListOfDefs("Attributes")) {
+ OS << Attr->getValueAsString("Mangling");
+ if (Attr->isSubClassOf("IndexedAttribute"))
+ OS << ':' << Attr->getValueAsInt("Index") << ':';
+ }
+ OS << '\"';
+}
+
+void EmitBuiltinDef(llvm::raw_ostream &OS, StringRef Substitution,
+ const Record *Builtin, Twine Spelling, BuiltinType BT) {
+ switch (BT) {
+ case BuiltinType::LibBuiltin:
+ OS << "LIBBUILTIN";
+ break;
+ case BuiltinType::LangBuiltin:
+ OS << "LANGBUILTIN";
+ break;
+ case BuiltinType::Builtin:
+ OS << "BUILTIN";
+ break;
+ case BuiltinType::AtomicBuiltin:
+ OS << "ATOMIC_BUILTIN";
+ break;
+ case BuiltinType::TargetBuiltin:
+ OS << "TARGET_BUILTIN";
+ break;
+ }
+
+ OS << "(" << Spelling;
+ PrototypeParser{Substitution, Builtin}.Print(OS);
+ OS << ", ";
+ PrintAttributes(Builtin, BT, OS);
+
+ switch (BT) {
+ case BuiltinType::LibBuiltin: {
+ OS << ", ";
+ HeaderNameParser{Builtin}.Print(OS);
+ [[fallthrough]];
+ }
+ case BuiltinType::LangBuiltin: {
+ OS << ", " << Builtin->getValueAsString("Languages");
+ break;
+ }
+ case BuiltinType::TargetBuiltin:
+ OS << ", \"\"";
+ break;
+ case BuiltinType::AtomicBuiltin:
+ case BuiltinType::Builtin:
+ break;
+ }
+ OS << ")\n";
+}
+
+struct TemplateInsts {
+ std::vector<std::string> Substitution;
+ std::vector<std::string> Affix;
+ bool IsPrefix;
+};
+
+TemplateInsts getTemplateInsts(const Record *R) {
+ TemplateInsts temp;
+ auto Substitutions = R->getValueAsListOfStrings("Substitutions");
+ auto Affixes = R->getValueAsListOfStrings("Affixes");
+ temp.IsPrefix = R->getValueAsBit("AsPrefix");
+
+ if (Substitutions.size() != Affixes.size())
+ PrintFatalError(R->getLoc(), "Substitutions and affixes "
+ "don't have the same lengths");
+
+ for (auto [Affix, Substitution] : llvm::zip(Affixes, Substitutions)) {
+ temp.Substitution.emplace_back(Substitution);
+ temp.Affix.emplace_back(Affix);
+ }
+ return temp;
+}
+
+void EmitBuiltin(llvm::raw_ostream &OS, const Record *Builtin) {
+ TemplateInsts Templates = {};
+ if (Builtin->isSubClassOf("Template")) {
+ Templates = getTemplateInsts(Builtin);
+ } else {
+ Templates.Affix.emplace_back();
+ Templates.Substitution.emplace_back();
+ }
+
+ for (auto [Substitution, Affix] :
+ llvm::zip(Templates.Substitution, Templates.Affix)) {
+ for (StringRef Spelling : Builtin->getValueAsListOfStrings("Spellings")) {
+ auto FullSpelling =
+ (Templates.IsPrefix ? Affix + Spelling : Spelling + Affix).str();
+ BuiltinType BT = BuiltinType::Builtin;
+ if (Builtin->isSubClassOf("AtomicBuiltin")) {
+ BT = BuiltinType::AtomicBuiltin;
+ } else if (Builtin->isSubClassOf("LangBuiltin")) {
+ BT = BuiltinType::LangBuiltin;
+ } else if (Builtin->isSubClassOf("TargetBuiltin")) {
+ BT = BuiltinType::TargetBuiltin;
+ } else if (Builtin->isSubClassOf("LibBuiltin")) {
+ BT = BuiltinType::LibBuiltin;
+ if (Builtin->getValueAsBit("AddBuiltinPrefixedAlias"))
+ EmitBuiltinDef(OS, Substitution, Builtin,
+ std::string("__builtin_") + FullSpelling,
+ BuiltinType::Builtin);
+ }
+ EmitBuiltinDef(OS, Substitution, Builtin, FullSpelling, BT);
+ }
+ }
+}
+} // namespace
+
+void clang::EmitClangBuiltins(llvm::RecordKeeper &Records,
+ llvm::raw_ostream &OS) {
+ emitSourceFileHeader("List of builtins that Clang recognizes", OS);
+
+ OS << R"c++(
+#if defined(BUILTIN) && !defined(LIBBUILTIN)
+# define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
+#endif
+
+#if defined(BUILTIN) && !defined(LANGBUILTIN)
+# define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
+#endif
+
+// 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
+
+#if defined(BUILTIN) && !defined(TARGET_BUILTIN)
+# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
+#endif
+)c++";
+
+ // AtomicBuiltins are order dependent
+ // emit them first to make manual checking easier
+ for (const auto *Builtin : Records.getAllDerivedDefinitions("AtomicBuiltin"))
+ EmitBuiltin(OS, Builtin);
+
+ for (const auto *Builtin : Records.getAllDerivedDefinitions("Builtin")) {
+ if (Builtin->isSubClassOf("AtomicBuiltin"))
+ continue;
+ EmitBuiltin(OS, Builtin);
+ }
+
+ for (const auto *Entry : Records.getAllDerivedDefinitions("CustomEntry")) {
+ OS << Entry->getValueAsString("Entry") << '\n';
+ }
+
+ OS << R"c++(
+#undef ATOMIC_BUILTIN
+#undef BUILTIN
+#undef LIBBUILTIN
+#undef LANGBUILTIN
+#undef TARGET_BUILTIN
+)c++";
+}
diff --git a/clang/utils/TableGen/MveEmitter.cpp b/clang/utils/TableGen/MveEmitter.cpp
index fae889d68346c33..ad0c407be7429ce 100644
--- a/clang/utils/TableGen/MveEmitter.cpp
+++ b/clang/utils/TableGen/MveEmitter.cpp
@@ -1846,7 +1846,7 @@ void MveEmitter::EmitHeader(raw_ostream &OS) {
// declared 'static inline' without a body, which is fine
// provided clang recognizes them as builtins, and has the
// effect that this type signature is used in place of the one
- // that Builtins.def didn't provide. That's how we can get
+ // that Builtins.td didn't provide. That's how we can get
// structure types that weren't defined until this header was
// included to be part of the type signature of a builtin that
// was known to clang already.
diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp
index 7efb6c731d3e5ee..6c1767d541df82f 100644
--- a/clang/utils/TableGen/TableGen.cpp
+++ b/clang/utils/TableGen/TableGen.cpp
@@ -49,6 +49,7 @@ enum ActionType {
GenClangAttrNodeTraverse,
GenClangBasicReader,
GenClangBasicWriter,
+ GenClangBuiltins,
GenClangDiagsDefs,
GenClangDiagGroups,
GenClangDiagsIndexName,
@@ -172,6 +173,8 @@ cl::opt<ActionType> Action(
"Generate clang attribute text node dumper"),
clEnumValN(GenClangAttrNodeTraverse, "gen-clang-attr-node-traverse",
"Generate clang attribute traverser"),
+ clEnumValN(GenClangBuiltins, "gen-clang-builtins",
+ "Generate clang builtins list"),
clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
"Generate Clang diagnostics definitions"),
clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",
@@ -373,6 +376,9 @@ bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
case GenClangAttrNodeTraverse:
EmitClangAttrNodeTraverse(Records, OS);
break;
+ case GenClangBuiltins:
+ EmitClangBuiltins(Records, OS);
+ break;
case GenClangDiagsDefs:
EmitClangDiagsDefs(Records, OS, ClangComponent);
break;
diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h
index d8f447069376bca..d61f873ae4d3533 100644
--- a/clang/utils/TableGen/TableGenBackends.h
+++ b/clang/utils/TableGen/TableGenBackends.h
@@ -67,6 +67,8 @@ void EmitClangAttrNodeTraverse(llvm::RecordKeeper &Records,
llvm::raw_ostream &OS);
void EmitClangAttrDocTable(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangBuiltins(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+
void EmitClangDiagsDefs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS,
const std::string &Component);
void EmitClangDiagGroups(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
>From 867df54ff54324a85add48b94e3d4d6f5824fae1 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Thu, 18 Jan 2024 06:21:41 +0100
Subject: [PATCH 2/2] Try to fix the CI
---
clang/include/clang/AST/Expr.h | 9 +-
clang/include/clang/Basic/Builtins.td | 185 ++++++++++++++++++++++++--
clang/lib/AST/Expr.cpp | 1 -
clang/lib/Sema/SemaChecking.cpp | 6 +-
4 files changed, 185 insertions(+), 16 deletions(-)
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index 1d2c719a73828c9..6f219e14a1431f5 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -6571,11 +6571,14 @@ class AtomicExpr : public Expr {
/// \return empty atomic scope model if the atomic op code does not have
/// scope operand.
static std::unique_ptr<AtomicScopeModel> getScopeModel(AtomicOp Op) {
- if (Op >= AO__opencl_atomic_compare_exchange_strong && Op <= AO__opencl_atomic_store)
+ // FIXME: Allow grouping of builtins to be able to only check >= and <=
+ if (Op >= AO__opencl_atomic_compare_exchange_strong &&
+ Op <= AO__opencl_atomic_store && Op != AO__opencl_atomic_init)
return AtomicScopeModel::create(AtomicScopeModelKind::OpenCL);
- else if (Op >= AO__hip_atomic_compare_exchange_strong && Op <= AO__hip_atomic_store)
+ if (Op >= AO__hip_atomic_compare_exchange_strong &&
+ Op <= AO__hip_atomic_store)
return AtomicScopeModel::create(AtomicScopeModelKind::HIP);
- else if (Op >= AO__scoped_atomic_load && Op <= AO__scoped_atomic_fetch_max)
+ if (Op >= AO__scoped_atomic_add_fetch && Op <= AO__scoped_atomic_xor_fetch)
return AtomicScopeModel::create(AtomicScopeModelKind::Generic);
return AtomicScopeModel::create(AtomicScopeModelKind::None);
}
diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td
index 0a3faf156bbd9f1..fdd1cf8221dcc76 100644
--- a/clang/include/clang/Basic/Builtins.td
+++ b/clang/include/clang/Basic/Builtins.td
@@ -599,6 +599,27 @@ def IsNormal : Builtin {
let Prototype = "int(...)";
}
+def IsSubnormal : Builtin {
+ let Spellings = ["__builtin_issubnormal"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsZero : Builtin {
+ let Spellings = ["__builtin_iszero"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
+def IsSignaling : Builtin {
+ let Spellings = ["__builtin_issignaling"];
+ let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const,
+ CustomTypeChecking, Constexpr];
+ let Prototype = "int(...)";
+}
+
def IsFPClass : Builtin {
let Spellings = ["__builtin_isfpclass"];
let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
@@ -754,12 +775,6 @@ def BuiltinAssumeAligned : Builtin {
let Prototype = "void*(void const*, size_t, ...)";
}
-def BuiltinBcopy : Builtin {
- let Spellings = ["__builtin_bcopy"];
- let Attributes = [NoThrow];
- let Prototype = "void(void*, void*, size_t)";
-}
-
def BuiltinFree : Builtin {
let Spellings = ["__builtin_free"];
let Attributes = [FunctionWithBuiltinPrefix, NoThrow];
@@ -1826,6 +1841,151 @@ def AtomicIsLockFree : Builtin {
let Prototype = "bool(size_t, void const volatile*)";
}
+// GNU atomic builtins with atomic scopes.
+def ScopedAtomicLoad : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_load"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicLoadN : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_load_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicStore : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_store"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicStoreN : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_store_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicExchange : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicExchangeN : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_exchange_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicCompareExchange : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_compare_exchange"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicCompareExchangeN : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_compare_exchange_n"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchAdd : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_add"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchSub : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_sub"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchAnd : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_and"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchOr : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_or"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchXor : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_xor"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchNand : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_nand"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchMin : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_min"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicFetchMax : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_fetch_max"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicAddFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_add_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicSubFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_sub_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicAndFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_and_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicOrFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_or_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicXorFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_xor_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicNandFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_nand_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicMinFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_min_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
+def ScopedAtomicMaxFetch : AtomicBuiltin {
+ let Spellings = ["__scoped_atomic_max_fetch"];
+ let Attributes = [CustomTypeChecking];
+ let Prototype = "void(...)";
+}
+
// OpenCL 2.0 atomic builtins.
def OpenCLAtomicInit : AtomicBuiltin {
let Spellings = ["__opencl_atomic_init"];
@@ -2954,6 +3114,13 @@ def BZero : GNULibBuiltin<"strings.h"> {
let AddBuiltinPrefixedAlias = 1;
}
+def Bcopy : GNULibBuiltin<"strings.h"> {
+ let Spellings = ["bcopy"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(void const*, void*, size_t)";
+ let AddBuiltinPrefixedAlias = 1;
+}
+
// FIXME: This should be part of BCmp.
def BuiltinBCmp : Builtin {
let Spellings = ["__builtin_bcmp"];
@@ -3931,19 +4098,19 @@ class SOverflowTemplate :
Template<["int", "long int", "long long int"],
["_overflow", "l_overflow", "ll_overflow"]>;
-def SaddOverflow : Builtin, UOverflowTemplate {
+def SaddOverflow : Builtin, SOverflowTemplate {
let Spellings = ["__builtin_sadd"];
let Attributes = [NoThrow, Constexpr];
let Prototype = "bool(T const, T const, T*)";
}
-def SsubOverflow : Builtin, UOverflowTemplate {
+def SsubOverflow : Builtin, SOverflowTemplate {
let Spellings = ["__builtin_ssub"];
let Attributes = [NoThrow, Constexpr];
let Prototype = "bool(T const, T const, T*)";
}
-def SmulOverflow : Builtin, UOverflowTemplate {
+def SmulOverflow : Builtin, SOverflowTemplate {
let Spellings = ["__builtin_smul"];
let Attributes = [NoThrow, Constexpr];
let Prototype = "bool(T const, T const, T*)";
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 3d977187236fff1..b125fc676da8419 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -4873,7 +4873,6 @@ AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr *> args, QualType t,
AtomicOp op, SourceLocation RP)
: Expr(AtomicExprClass, t, VK_PRValue, OK_Ordinary),
NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
- assert(op != AO__opencl_atomic_init || args.size() == 3);
assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
for (unsigned i = 0; i != args.size(); i++)
SubExprs[i] = args[i];
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 710549ae34b6418..efa0bf14a96b22b 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -7741,10 +7741,10 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
Op <= AtomicExpr::AO__opencl_atomic_store;
bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
Op <= AtomicExpr::AO__hip_atomic_store;
- bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_load &&
- Op <= AtomicExpr::AO__scoped_atomic_fetch_max;
+ bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&
+ Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;
bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
- Op <= AtomicExpr::AO__c11_atomic_store) ||
+ Op <= AtomicExpr::AO__c11_atomic_store) ||
IsOpenCL;
bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
Op == AtomicExpr::AO__atomic_store_n ||
More information about the cfe-commits
mailing list