[llvm] [Analysis] Reuse RuntimeLibCalls.td for TargetLibraryInfo (PR #199529)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Jun 3 06:52:46 PDT 2026
https://github.com/sujianIBM updated https://github.com/llvm/llvm-project/pull/199529
>From 0ebcf5afb98b5991822e3b842f498bc4e2bc03ad Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Wed, 18 Mar 2026 13:22:36 +0000
Subject: [PATCH 1/8] Add function signature to RuntimeLibcall.
---
.../llvm/Analysis/TargetLibraryInfo.td | 2 +-
.../llvm/Analysis/TargetLibraryInfoImpl.td | 44 -
llvm/include/llvm/IR/RuntimeLibcalls.td | 1033 +++++++++++------
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 54 +-
.../Basic/TargetLibraryInfoEmitter.cpp | 15 +-
5 files changed, 737 insertions(+), 411 deletions(-)
delete mode 100644 llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
index 6b17e70b87f55..c9046ef2a02aa 100644
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.td
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
-include "llvm/Analysis/TargetLibraryInfoImpl.td"
+include "llvm/IR/RuntimeLibcalls.td"
/// void *operator new(unsigned int);
def msvc_new_int : TargetLibCall<"??2 at YAPAXI@Z", Ptr, [Int]>;
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td b/llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td
deleted file mode 100644
index cd1a0bb45b5de..0000000000000
--- a/llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td
+++ /dev/null
@@ -1,44 +0,0 @@
-//===-- TargetLibraryInfoImpl.td - File that describes library functions --===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// Return type or argument type of library function.
-class FuncArgType {
- string Name = NAME;
-}
-
-// Recognized types of library function arguments and return types.
-def Void : FuncArgType;
-def Bool : FuncArgType; // 8 bits on all targets
-def Int16 : FuncArgType;
-def Int32 : FuncArgType;
-def Int : FuncArgType;
-def IntPlus : FuncArgType; // Int or bigger.
-def Long : FuncArgType; // Either 32 or 64 bits.
-def IntX : FuncArgType; // Any integer type.
-def Int64 : FuncArgType;
-def LLong : FuncArgType; // 64 bits on all targets.
-def SizeT : FuncArgType; // size_t.
-def SSizeT : FuncArgType; // POSIX ssize_t.
-def Flt : FuncArgType; // IEEE float.
-def Dbl : FuncArgType; // IEEE double.
-def LDbl : FuncArgType; // Any floating type (TODO: tighten this up).
-def Floating : FuncArgType; // Any floating type.
-def Ptr : FuncArgType; // Any pointer type.
-def Struct : FuncArgType; // Any struct type.
-def Ellip : FuncArgType; // The ellipsis (...).
-def Same : FuncArgType; // Same argument type as the previous one.
-
-
-// Definition of library function.
-class TargetLibCall<string Str, FuncArgType RetType,
- list<FuncArgType> ArgTypes = []> {
- string Name = NAME;
- string String = Str;
- FuncArgType ReturnType = RetType;
- list<FuncArgType> ArgumentTypes = ArgTypes;
-}
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index cbdc48a9a717f..66500c9feabab 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -126,80 +126,386 @@ foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
def DIV_#FPTy : RuntimeLibcall;
def FAST_DIV_#FPTy : RuntimeLibcall;
- def REM_#FPTy : RuntimeLibcall;
+ //def REM_#FPTy : RuntimeLibcall;
def FMA_#FPTy : RuntimeLibcall;
def POWI_#FPTy : RuntimeLibcall;
- def SQRT_#FPTy : RuntimeLibcall;
+ //def SQRT_#FPTy : RuntimeLibcall;
def FAST_SQRT_#FPTy : RuntimeLibcall;
- def CBRT_#FPTy : RuntimeLibcall;
- def LOG_#FPTy : RuntimeLibcall;
- def LOG_FINITE_#FPTy : RuntimeLibcall;
- def LOG2_#FPTy : RuntimeLibcall;
- def LOG2_FINITE_#FPTy : RuntimeLibcall;
- def LOG10_#FPTy : RuntimeLibcall;
- def LOG10_FINITE_#FPTy : RuntimeLibcall;
- def EXP_#FPTy : RuntimeLibcall;
- def EXP_FINITE_#FPTy : RuntimeLibcall;
- def EXP2_#FPTy : RuntimeLibcall;
- def EXP2_FINITE_#FPTy : RuntimeLibcall;
- def EXP10_#FPTy : RuntimeLibcall;
+ //def CBRT_#FPTy : RuntimeLibcall;
+ //def LOG_#FPTy : RuntimeLibcall;
+ //def LOG_FINITE_#FPTy : RuntimeLibcall;
+ //def LOG2_#FPTy : RuntimeLibcall;
+ //def LOG2_FINITE_#FPTy : RuntimeLibcall;
+ //def LOG10_#FPTy : RuntimeLibcall;
+ //def LOG10_FINITE_#FPTy : RuntimeLibcall;
+ //def EXP_#FPTy : RuntimeLibcall;
+ //def EXP_FINITE_#FPTy : RuntimeLibcall;
+ //def EXP2_#FPTy : RuntimeLibcall;
+ //def EXP2_FINITE_#FPTy : RuntimeLibcall;
+ //def EXP10_#FPTy : RuntimeLibcall;
def EXP10_FINITE_#FPTy : RuntimeLibcall;
- def SIN_#FPTy : RuntimeLibcall;
- def COS_#FPTy : RuntimeLibcall;
- def TAN_#FPTy : RuntimeLibcall;
- def SINH_#FPTy : RuntimeLibcall;
- def COSH_#FPTy : RuntimeLibcall;
- def TANH_#FPTy : RuntimeLibcall;
- def ASIN_#FPTy : RuntimeLibcall;
- def ACOS_#FPTy : RuntimeLibcall;
- def ATAN_#FPTy : RuntimeLibcall;
- def ATAN2_#FPTy : RuntimeLibcall;
- def SINCOS_#FPTy : RuntimeLibcall;
- def REMQUO_#FPTy : RuntimeLibcall;
- def FDIM_#FPTy : RuntimeLibcall;
-
- def CABS_#FPTy : RuntimeLibcall;
+ //def SIN_#FPTy : RuntimeLibcall;
+ //def COS_#FPTy : RuntimeLibcall;
+ //def TAN_#FPTy : RuntimeLibcall;
+ //def SINH_#FPTy : RuntimeLibcall;
+ //def COSH_#FPTy : RuntimeLibcall;
+ //def TANH_#FPTy : RuntimeLibcall;
+ //def ASIN_#FPTy : RuntimeLibcall;
+ //def ACOS_#FPTy : RuntimeLibcall;
+ //def ATAN_#FPTy : RuntimeLibcall;
+ //def ATAN2_#FPTy : RuntimeLibcall;
+ //def SINCOS_#FPTy : RuntimeLibcall;
+ //def REMQUO_#FPTy : RuntimeLibcall;
+ //def FDIM_#FPTy : RuntimeLibcall;
+
+ //def CABS_#FPTy : RuntimeLibcall;
}
+ def REM_F32 : RuntimeLibcall<Flt, [Flt, Flt], "fmodf">;
+ def REM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "fmod">;
+ def REM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "fmodl">;
+ def REM_F80 : RuntimeLibcall;
+ def REM_PPCF128 : RuntimeLibcall;
+
+ def SQRT_F32 : RuntimeLibcall<Flt, [Flt], "sqrtf">;
+ def SQRT_F64 : RuntimeLibcall<Dbl, [Dbl], "sqrt">;
+ def SQRT_F128 : RuntimeLibcall<LDbl, [LDbl], "sqrtl">;
+ def SQRT_F80 : RuntimeLibcall;
+ def SQRT_PPCF128 : RuntimeLibcall;
+
+ def CBRT_F32 : RuntimeLibcall<Flt, [Flt], "cbrtf">;
+ def CBRT_F64 : RuntimeLibcall<Dbl, [Dbl], "cbrt">;
+ def CBRT_F128 : RuntimeLibcall<LDbl, [LDbl], "cbrtl">;
+ def CBRT_F80 : RuntimeLibcall;
+ def CBRT_PPCF128 : RuntimeLibcall;
+
+ def LOG_F32 : RuntimeLibcall<Flt, [Flt], "logf">;
+ def LOG_F64 : RuntimeLibcall<Dbl, [Dbl], "log">;
+ def LOG_F128 : RuntimeLibcall<LDbl, [LDbl], "logl">;
+ def LOG_F80 : RuntimeLibcall;
+ def LOG_PPCF128 : RuntimeLibcall;
+
+ def LOG_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "logf_finite">;
+ def LOG_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "log_finite">;
+ def LOG_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "logl_finite">;
+ def LOG_FINITE_F80 : RuntimeLibcall;
+ def LOG_FINITE_PPCF128 : RuntimeLibcall;
+
+ def LOG2_F32 : RuntimeLibcall<Flt, [Flt], "log2f">;
+ def LOG2_F64 : RuntimeLibcall<Dbl, [Dbl], "log2">;
+ def LOG2_F128 : RuntimeLibcall<LDbl, [LDbl], "log2l">;
+ def LOG2_F80 : RuntimeLibcall;
+ def LOG2_PPCF128 : RuntimeLibcall;
+
+ def LOG2_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "log2f_finite">;
+ def LOG2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "log2_finite">;
+ def LOG2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "log2l_finite">;
+ def LOG2_FINITE_F80 : RuntimeLibcall;
+ def LOG2_FINITE_PPCF128 : RuntimeLibcall;
+
+ def LOG10_F32 : RuntimeLibcall<Flt, [Flt], "log10f">;
+ def LOG10_F64 : RuntimeLibcall<Dbl, [Dbl], "log10">;
+ def LOG10_F128 : RuntimeLibcall<LDbl, [LDbl], "log10l">;
+ def LOG10_F80 : RuntimeLibcall;
+ def LOG10_PPCF128 : RuntimeLibcall;
+
+ def LOG10_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "log10f_finite">;
+ def LOG10_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "log10_finite">;
+ def LOG10_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "log10l_finite">;
+ def LOG10_FINITE_F80 : RuntimeLibcall;
+ def LOG10_FINITE_PPCF128 : RuntimeLibcall;
+
+ def EXP_F32 : RuntimeLibcall<Flt, [Flt], "expf">;
+ def EXP_F64 : RuntimeLibcall<Dbl, [Dbl], "exp">;
+ def EXP_F128 : RuntimeLibcall<LDbl, [LDbl], "expl">;
+ def EXP_F80 : RuntimeLibcall;
+ def EXP_PPCF128 : RuntimeLibcall;
+
+ def EXP_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "expf_finite">;
+ def EXP_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "exp_finite">;
+ def EXP_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "expl_finite">;
+ def EXP_FINITE_F80 : RuntimeLibcall;
+ def EXP_FINITE_PPCF128 : RuntimeLibcall;
+
+ def EXP2_F32 : RuntimeLibcall<Flt, [Flt], "exp2f">;
+ def EXP2_F64 : RuntimeLibcall<Dbl, [Dbl], "exp2">;
+ def EXP2_F128 : RuntimeLibcall<LDbl, [LDbl], "exp2l">;
+ def EXP2_F80 : RuntimeLibcall;
+ def EXP2_PPCF128 : RuntimeLibcall;
+
+ def EXP2_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "exp2f_finite">;
+ def EXP2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "exp2_finite">;
+ def EXP2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "exp2l_finite">;
+ def EXP2_FINITE_F80 : RuntimeLibcall;
+ def EXP2_FINITE_PPCF128 : RuntimeLibcall;
+
+ def EXP10_F32 : RuntimeLibcall<Flt, [Flt], "exp10f">;
+ def EXP10_F64 : RuntimeLibcall<Dbl, [Dbl], "exp10">;
+ def EXP10_F128 : RuntimeLibcall<LDbl, [LDbl], "exp10l">;
+ def EXP10_F80 : RuntimeLibcall;
+ def EXP10_PPCF128 : RuntimeLibcall;
+
+ def SIN_F32 : RuntimeLibcall<Flt, [Flt], "sinf">;
+ def SIN_F64 : RuntimeLibcall<Dbl, [Dbl], "sin">;
+ def SIN_F128 : RuntimeLibcall<LDbl, [LDbl], "sinl">;
+ def SIN_F80 : RuntimeLibcall;
+ def SIN_PPCF128 : RuntimeLibcall;
+
+ def COS_F32 : RuntimeLibcall<Flt, [Flt], "cosf">;
+ def COS_F64 : RuntimeLibcall<Dbl, [Dbl], "cos">;
+ def COS_F128 : RuntimeLibcall<LDbl, [LDbl], "cosl">;
+ def COS_F80 : RuntimeLibcall;
+ def COS_PPCF128 : RuntimeLibcall;
+
+ def TAN_F32 : RuntimeLibcall<Flt, [Flt], "tanf">;
+ def TAN_F64 : RuntimeLibcall<Dbl, [Dbl], "tan">;
+ def TAN_F128 : RuntimeLibcall<LDbl, [LDbl], "tanl">;
+ def TAN_F80 : RuntimeLibcall;
+ def TAN_PPCF128 : RuntimeLibcall;
+
+ def SINH_F32 : RuntimeLibcall<Flt, [Flt], "sinhf">;
+ def SINH_F64 : RuntimeLibcall<Dbl, [Dbl], "sinh">;
+ def SINH_F128 : RuntimeLibcall<LDbl, [LDbl], "sinhl">;
+ def SINH_F80 : RuntimeLibcall;
+ def SINH_PPCF128 : RuntimeLibcall;
+
+ def COSH_F32 : RuntimeLibcall<Flt, [Flt], "coshf">;
+ def COSH_F64 : RuntimeLibcall<Dbl, [Dbl], "cosh">;
+ def COSH_F128 : RuntimeLibcall<LDbl, [LDbl], "coshl">;
+ def COSH_F80 : RuntimeLibcall;
+ def COSH_PPCF128 : RuntimeLibcall;
+
+ def TANH_F32 : RuntimeLibcall<Flt, [Flt], "tanhf">;
+ def TANH_F64 : RuntimeLibcall<Dbl, [Dbl], "tanh">;
+ def TANH_F128 : RuntimeLibcall<LDbl, [LDbl], "tanhl">;
+ def TANH_F80 : RuntimeLibcall;
+ def TANH_PPCF128 : RuntimeLibcall;
+
+ def ASIN_F32 : RuntimeLibcall<Flt, [Flt], "asinf">;
+ def ASIN_F64 : RuntimeLibcall<Dbl, [Dbl], "asin">;
+ def ASIN_F128 : RuntimeLibcall<LDbl, [LDbl], "asinl">;
+ def ASIN_F80 : RuntimeLibcall;
+ def ASIN_PPCF128 : RuntimeLibcall;
+
+ def ACOS_F32 : RuntimeLibcall<Flt, [Flt], "acosf">;
+ def ACOS_F64 : RuntimeLibcall<Dbl, [Dbl], "acos">;
+ def ACOS_F128 : RuntimeLibcall<LDbl, [LDbl], "acosl">;
+ def ACOS_F80 : RuntimeLibcall;
+ def ACOS_PPCF128 : RuntimeLibcall;
+
+ def ATAN_F32 : RuntimeLibcall<Flt, [Flt], "atanf">;
+ def ATAN_F64 : RuntimeLibcall<Dbl, [Dbl], "atan">;
+ def ATAN_F128 : RuntimeLibcall<LDbl, [LDbl], "atanl">;
+ def ATAN_F80 : RuntimeLibcall;
+ def ATAN_PPCF128 : RuntimeLibcall;
+
+ def ATAN2_F32 : RuntimeLibcall<Flt, [Flt, Flt], "atan2f">;
+ def ATAN2_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "atan2">;
+ def ATAN2_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "atan2l">;
+ def ATAN2_F80 : RuntimeLibcall;
+ def ATAN2_PPCF128 : RuntimeLibcall;
+
+ def SINCOS_F32 : RuntimeLibcall<Void, [Flt, Ptr, Ptr], "sincosf">;
+ def SINCOS_F64 : RuntimeLibcall<Void, [Dbl, Ptr, Ptr], "sincos">;
+ def SINCOS_F128 : RuntimeLibcall<Void, [LDbl, Ptr, Ptr], "sincosl">;
+ def SINCOS_F80 : RuntimeLibcall;
+ def SINCOS_PPCF128 : RuntimeLibcall;
+
+ def REMQUO_F32 : RuntimeLibcall<Flt, [Flt, Flt, Ptr], "remquof">;
+ def REMQUO_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl, Ptr], "remquo">;
+ def REMQUO_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl, Ptr], "remquol">;
+ def REMQUO_F80 : RuntimeLibcall;
+ def REMQUO_PPCF128 : RuntimeLibcall;
+
+ def FDIM_F32 : RuntimeLibcall<Flt, [Flt, Flt], "fdimf">;
+ def FDIM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "fdim">;
+ def FDIM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "fdiml">;
+ def FDIM_F80 : RuntimeLibcall;
+ def FDIM_PPCF128 : RuntimeLibcall;
+
+ def CABS_F32 : RuntimeLibcall<NoneType, [], "cabsf">;
+ def CABS_F64 : RuntimeLibcall<NoneType, [], "cabs">;
+ def CABS_F128 : RuntimeLibcall<NoneType, [], "cabsl">;
+ def CABS_F80 : RuntimeLibcall;
+ def CABS_PPCF128 : RuntimeLibcall;
+
foreach FPTy = [ "F32", "F64" ] in {
def SINCOS_STRET_#FPTy : RuntimeLibcall;
}
foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
- def POW_#FPTy : RuntimeLibcall;
- def POW_FINITE_#FPTy : RuntimeLibcall;
- def CEIL_#FPTy : RuntimeLibcall;
- def TRUNC_#FPTy : RuntimeLibcall;
- def RINT_#FPTy : RuntimeLibcall;
- def NEARBYINT_#FPTy : RuntimeLibcall;
- def ROUND_#FPTy : RuntimeLibcall;
- def ROUNDEVEN_#FPTy : RuntimeLibcall;
- def FLOOR_#FPTy : RuntimeLibcall;
- def COPYSIGN_#FPTy : RuntimeLibcall;
- def FMIN_#FPTy : RuntimeLibcall;
- def FMAX_#FPTy : RuntimeLibcall;
+ //def POW_#FPTy : RuntimeLibcall;
+ //def POW_FINITE_#FPTy : RuntimeLibcall;
+ //def CEIL_#FPTy : RuntimeLibcall;
+ //def TRUNC_#FPTy : RuntimeLibcall;
+ //def RINT_#FPTy : RuntimeLibcall;
+ //def NEARBYINT_#FPTy : RuntimeLibcall;
+ //def ROUND_#FPTy : RuntimeLibcall;
+ //def ROUNDEVEN_#FPTy : RuntimeLibcall;
+ //def FLOOR_#FPTy : RuntimeLibcall;
+ //def COPYSIGN_#FPTy : RuntimeLibcall;
+ //def FMIN_#FPTy : RuntimeLibcall;
+ //def FMAX_#FPTy : RuntimeLibcall;
def FMINIMUM_#FPTy : RuntimeLibcall;
def FMAXIMUM_#FPTy : RuntimeLibcall;
- def FMINIMUM_NUM_#FPTy : RuntimeLibcall;
- def FMAXIMUM_NUM_#FPTy : RuntimeLibcall;
+ //def FMINIMUM_NUM_#FPTy : RuntimeLibcall;
+ //def FMAXIMUM_NUM_#FPTy : RuntimeLibcall;
def LROUND_#FPTy : RuntimeLibcall;
def LLROUND_#FPTy : RuntimeLibcall;
def LRINT_#FPTy : RuntimeLibcall;
def LLRINT_#FPTy : RuntimeLibcall;
- def LDEXP_#FPTy : RuntimeLibcall;
- def FREXP_#FPTy : RuntimeLibcall;
+ //def LDEXP_#FPTy : RuntimeLibcall;
+ //def FREXP_#FPTy : RuntimeLibcall;
def SINCOSPI_#FPTy : RuntimeLibcall;
- def MODF_#FPTy : RuntimeLibcall;
- def NAN_#FPTy : RuntimeLibcall;
- def NEXTTOWARD_#FPTy : RuntimeLibcall;
- def REMAINDER_#FPTy : RuntimeLibcall;
- def SCALBLN_#FPTy : RuntimeLibcall;
- def SCALBN_#FPTy : RuntimeLibcall;
- def TGAMMA_#FPTy : RuntimeLibcall;
+ //def MODF_#FPTy : RuntimeLibcall;
+ //def NAN_#FPTy : RuntimeLibcall;
+ //def NEXTTOWARD_#FPTy : RuntimeLibcall;
+ //def REMAINDER_#FPTy : RuntimeLibcall;
+ //def SCALBLN_#FPTy : RuntimeLibcall;
+ //def SCALBN_#FPTy : RuntimeLibcall;
+ //def TGAMMA_#FPTy : RuntimeLibcall;
}
+ def POW_F32 : RuntimeLibcall<Flt, [Flt, Flt], "powf">;
+ def POW_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "pow">;
+ def POW_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "powl">;
+ def POW_F80 : RuntimeLibcall;
+ def POW_PPCF128 : RuntimeLibcall;
+
+ def POW_FINITE_F32 : RuntimeLibcall<Dbl, [Dbl, Dbl], "pow_finite">;
+ def POW_FINITE_F64 : RuntimeLibcall<Flt, [Flt, Flt], "powf_finite">;
+ def POW_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "powl_finite">;
+ def POW_FINITE_F80 : RuntimeLibcall;
+ def POW_FINITE_PPCF128 : RuntimeLibcall;
+
+ def CEIL_F32 : RuntimeLibcall<Flt, [Flt], "ceilf">;
+ def CEIL_F64 : RuntimeLibcall<Dbl, [Dbl], "ceil">;
+ def CEIL_F128 : RuntimeLibcall<LDbl, [LDbl], "ceill">;
+ def CEIL_F80 : RuntimeLibcall;
+ def CEIL_PPCF128 : RuntimeLibcall;
+
+ def TRUNC_F32 : RuntimeLibcall<Flt, [Flt], "truncf">;
+ def TRUNC_F64 : RuntimeLibcall<Dbl, [Dbl], "trunc">;
+ def TRUNC_F128 : RuntimeLibcall<LDbl, [LDbl], "truncl">;
+ def TRUNC_F80 : RuntimeLibcall;
+ def TRUNC_PPCF128 : RuntimeLibcall;
+
+ def RINT_F32 : RuntimeLibcall<Flt, [Flt], "rintf">;
+ def RINT_F64 : RuntimeLibcall<Dbl, [Dbl], "rint">;
+ def RINT_F128 : RuntimeLibcall<LDbl, [LDbl], "rintl">;
+ def RINT_F80 : RuntimeLibcall;
+ def RINT_PPCF128 : RuntimeLibcall;
+
+ def NEARBYINT_F32 : RuntimeLibcall<Flt, [Flt], "nearbyintf">;
+ def NEARBYINT_F64 : RuntimeLibcall<Dbl, [Dbl], "nearbyint">;
+ def NEARBYINT_F128 : RuntimeLibcall<LDbl, [LDbl], "nearbyintl">;
+ def NEARBYINT_F80 : RuntimeLibcall;
+ def NEARBYINT_PPCF128 : RuntimeLibcall;
+
+ def ROUND_F32 : RuntimeLibcall<Flt, [Flt], "roundf">;
+ def ROUND_F64 : RuntimeLibcall<Dbl, [Dbl], "round">;
+ def ROUND_F128 : RuntimeLibcall<LDbl, [LDbl], "roundl">;
+ def ROUND_F80 : RuntimeLibcall;
+ def ROUND_PPCF128 : RuntimeLibcall;
+
+ def ROUNDEVEN_F32 : RuntimeLibcall<Flt, [Flt], "roundevenf">;
+ def ROUNDEVEN_F64 : RuntimeLibcall<Dbl, [Dbl], "roundeven">;
+ def ROUNDEVEN_F128 : RuntimeLibcall<LDbl, [LDbl], "roundevenl">;
+ def ROUNDEVEN_F80 : RuntimeLibcall;
+ def ROUNDEVEN_PPCF128 : RuntimeLibcall;
+
+ def FLOOR_F32 : RuntimeLibcall<Flt, [Flt], "floorf">;
+ def FLOOR_F64 : RuntimeLibcall<Dbl, [Dbl], "floor">;
+ def FLOOR_F128 : RuntimeLibcall<LDbl, [LDbl], "floorl">;
+ def FLOOR_F80 : RuntimeLibcall;
+ def FLOOR_PPCF128 : RuntimeLibcall;
+
+ def COPYSIGN_F32 : RuntimeLibcall<Flt, [Flt, Flt], "copysignf">;
+ def COPYSIGN_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "copysign">;
+ def COPYSIGN_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "copysignl">;
+ def COPYSIGN_F80 : RuntimeLibcall;
+ def COPYSIGN_PPCF128 : RuntimeLibcall;
+
+ def FMIN_F32 : RuntimeLibcall<Floating, [Same, Same], "fminf">;
+ def FMIN_F64 : RuntimeLibcall<Floating, [Same, Same], "fmin">;
+ def FMIN_F128 : RuntimeLibcall<Floating, [Same, Same], "fminl">;
+ def FMIN_F80 : RuntimeLibcall;
+ def FMIN_PPCF128 : RuntimeLibcall;
+
+ def FMAX_F32 : RuntimeLibcall<Floating, [Same, Same], "fmaxf">;
+ def FMAX_F64 : RuntimeLibcall<Floating, [Same, Same], "fmax">;
+ def FMAX_F128 : RuntimeLibcall<Floating, [Same, Same], "fmaxl">;
+ def FMAX_F80 : RuntimeLibcall;
+ def FMAX_PPCF128 : RuntimeLibcall;
+
+ def FMINIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same], "fminimum_numf">;
+ def FMINIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same], "fminimum_num">;
+ def FMINIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same], "fminimum_numl">;
+ def FMINIMUM_NUM_F80 : RuntimeLibcall;
+ def FMINIMUM_NUM_PPCF128 : RuntimeLibcall;
+
+ def FMAXIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same], "fmaximum_numf">;
+ def FMAXIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same], "fmaximum_num">;
+ def FMAXIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same], "fmaximum_numl">;
+ def FMAXIMUM_NUM_F80 : RuntimeLibcall;
+ def FMAXIMUM_NUM_PPCF128 : RuntimeLibcall;
+
+ def LDEXP_F32 : RuntimeLibcall<Flt, [Flt, Int], "ldexpf">;
+ def LDEXP_F64 : RuntimeLibcall<Dbl, [Dbl, Int], "ldexp">;
+ def LDEXP_F128 : RuntimeLibcall<LDbl, [LDbl, Int], "ldexpl">;
+ def LDEXP_F80 : RuntimeLibcall;
+ def LDEXP_PPCF128 : RuntimeLibcall;
+
+ def FREXP_F32 : RuntimeLibcall<Flt, [Flt, Ptr], "frexpf">;
+ def FREXP_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr], "frexp">;
+ def FREXP_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr], "frexpl">;
+ def FREXP_F80 : RuntimeLibcall;
+ def FREXP_PPCF128 : RuntimeLibcall;
+
+ def MODF_F32 : RuntimeLibcall<Flt, [Flt, Ptr], "modff">;
+ def MODF_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr], "modf">;
+ def MODF_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr], "modfl">;
+ def MODF_F80 : RuntimeLibcall;
+ def MODF_PPCF128 : RuntimeLibcall;
+
+ def NAN_F32 : RuntimeLibcall<Flt, [Ptr], "nanf">;
+ def NAN_F64 : RuntimeLibcall<Dbl, [Ptr], "nan">;
+ def NAN_F128 : RuntimeLibcall<LDbl, [Ptr], "nanl">;
+ def NAN_F80 : RuntimeLibcall;
+ def NAN_PPCF128 : RuntimeLibcall;
+
+ def NEXTTOWARD_F32 : RuntimeLibcall<Flt, [Flt, LDbl], "nexttowardf">;
+ def NEXTTOWARD_F64 : RuntimeLibcall<Dbl, [Dbl, LDbl], "nexttoward">;
+ def NEXTTOWARD_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "nexttowardl">;
+ def NEXTTOWARD_F80 : RuntimeLibcall;
+ def NEXTTOWARD_PPCF128 : RuntimeLibcall;
+
+ def REMAINDER_F32 : RuntimeLibcall<Flt, [Flt, Flt], "remainderf">;
+ def REMAINDER_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "remainder">;
+ def REMAINDER_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "remainderl">;
+ def REMAINDER_F80 : RuntimeLibcall;
+ def REMAINDER_PPCF128 : RuntimeLibcall;
+
+ def SCALBLN_F32 : RuntimeLibcall<Flt, [Flt, Long], "scalblnf">;
+ def SCALBLN_F64 : RuntimeLibcall<Dbl, [Dbl, Long], "scalbln">;
+ def SCALBLN_F128 : RuntimeLibcall<LDbl, [LDbl, Long], "scalblnl">;
+ def SCALBLN_F80 : RuntimeLibcall;
+ def SCALBLN_PPCF128 : RuntimeLibcall;
+
+ def SCALBN_F32 : RuntimeLibcall<Flt, [Flt, Int], "scalbnf">;
+ def SCALBN_F64 : RuntimeLibcall<Dbl, [Dbl, Int], "scalbn">;
+ def SCALBN_F128 : RuntimeLibcall<LDbl, [LDbl, Int], "scalbnl">;
+ def SCALBN_F80 : RuntimeLibcall;
+ def SCALBN_PPCF128 : RuntimeLibcall;
+
+ def TGAMMA_F32 : RuntimeLibcall<Flt, [Flt], "tgammaf">;
+ def TGAMMA_F64 : RuntimeLibcall<Dbl, [Dbl], "tgamma">;
+ def TGAMMA_F128 : RuntimeLibcall<LDbl, [LDbl], "tgammal">;
+ def TGAMMA_F80 : RuntimeLibcall;
+ def TGAMMA_PPCF128 : RuntimeLibcall;
+
defvar F32VectorSuffixes = ["V2F32", "V4F32", "V8F32", "V16F32", "NXV4F32"];
defvar F64VectorSuffixes = ["V2F64", "V4F64", "V8F64", "NXV2F64"];
@@ -387,18 +693,18 @@ foreach FPTy = ["F32", "F64", "F128", "PPCF128"] in {
}
// Memory
-def MEMCMP : RuntimeLibcall;
-def MEMCPY : RuntimeLibcall;
-def MEMCPY_CHK : RuntimeLibcall;
-def MEMMOVE : RuntimeLibcall;
-def MEMMOVE_CHK : RuntimeLibcall;
-def MEMSET : RuntimeLibcall;
-def MEMSET_CHK : RuntimeLibcall;
-def MALLOC : RuntimeLibcall;
-def CALLOC : RuntimeLibcall;
-def FREE : RuntimeLibcall;
-def BZERO : RuntimeLibcall;
-def STRLEN : RuntimeLibcall;
+def MEMCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "memcmp">;
+def MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "memcpy">;
+def MEMCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "memcpy_chk">;
+def MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "memmove">;
+def MEMMOVE_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "memmove_chk">;
+def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT], "memset">;
+def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT], "memset_chk">;
+def MALLOC : RuntimeLibcall<Ptr, [SizeT], "malloc">;
+def CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT], "calloc">;
+def FREE : RuntimeLibcall<Void, [Ptr], "free">;
+def BZERO : RuntimeLibcall<Void, [Ptr, SizeT], "bzero">;
+def STRLEN : RuntimeLibcall<SizeT, [Ptr], "strlen">;
// Element-wise unordered-atomic memory of different sizes
foreach MemSize = [1, 2, 4, 8, 16] in {
@@ -439,12 +745,19 @@ defset list<RuntimeLibcall> LibCalls__sync = {
defset list<RuntimeLibcall> LibCalls__atomic = {
// Atomic `__atomic_*' libcalls.
foreach MemSize = ["", "_1", "_2", "_4", "_8", "_16"] in {
- def ATOMIC_LOAD#MemSize : RuntimeLibcall;
- def ATOMIC_STORE#MemSize : RuntimeLibcall;
+ //def ATOMIC_LOAD#MemSize : RuntimeLibcall;
+ //def ATOMIC_STORE#MemSize : RuntimeLibcall;
def ATOMIC_EXCHANGE#MemSize : RuntimeLibcall;
def ATOMIC_COMPARE_EXCHANGE#MemSize : RuntimeLibcall;
}
+ def ATOMIC_LOAD : RuntimeLibcall<Void, [SizeT, Ptr, Ptr, Int], "atomic_load">;
+ def ATOMIC_STORE : RuntimeLibcall<Void, [SizeT, Ptr, Ptr, Int], "atomic_store">;
+ foreach MemSize = ["_1", "_2", "_4", "_8", "_16"] in {
+ def ATOMIC_LOAD#MemSize : RuntimeLibcall;
+ def ATOMIC_STORE#MemSize : RuntimeLibcall;
+ }
+
foreach MemSize = [1, 2, 4, 8, 16] in {
def ATOMIC_FETCH_ADD_#MemSize : RuntimeLibcall;
def ATOMIC_FETCH_SUB_#MemSize : RuntimeLibcall;
@@ -591,301 +904,301 @@ def OBJC_RETAIN_AUTORELEASE : RuntimeLibcall;
def OBJC_SYNC_ENTER : RuntimeLibcall;
def OBJC_SYNC_EXIT : RuntimeLibcall;
-def ABORT : RuntimeLibcall;
-def ABS : RuntimeLibcall;
-def ACCESS : RuntimeLibcall;
-def ALIGNED_ALLOC : RuntimeLibcall;
-def ATEXIT : RuntimeLibcall;
-def ATOF : RuntimeLibcall;
-def ATOI : RuntimeLibcall;
-def ATOL : RuntimeLibcall;
-def ATOLL : RuntimeLibcall;
-def BCMP : RuntimeLibcall;
-def BCOPY : RuntimeLibcall;
-def CHMOD : RuntimeLibcall;
-def CHOWN : RuntimeLibcall;
-def CLEARERR : RuntimeLibcall;
-def CLOSEDIR : RuntimeLibcall;
-def CTERMID : RuntimeLibcall;
-def CXA_ATEXIT : RuntimeLibcall;
-def CXA_GUARD_ABORT : RuntimeLibcall;
-def CXA_GUARD_ACQUIRE : RuntimeLibcall;
-def CXA_GUARD_RELEASE : RuntimeLibcall;
-def CXA_THROW : RuntimeLibcall;
-def DUNDER_ISOC99_SCANF : RuntimeLibcall;
-def DUNDER_ISOC99_SSCANF : RuntimeLibcall;
-def DUNDER_STRDUP : RuntimeLibcall;
-def DUNDER_STRNDUP : RuntimeLibcall;
-def DUNDER_STRTOK_R : RuntimeLibcall;
+def ABORT : RuntimeLibcall<Void, [], "abort">;
+def ABS : RuntimeLibcall<Int, [Int], "abs">;
+def ACCESS : RuntimeLibcall<Int, [Ptr, Int], "access">;
+def ALIGNED_ALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT], "aligned_alloc">;
+def ATEXIT : RuntimeLibcall<Int, [Ptr], "atexit">;
+def ATOF : RuntimeLibcall<Dbl, [Ptr], "atof">;
+def ATOI : RuntimeLibcall<Int, [Ptr], "atoi">;
+def ATOL : RuntimeLibcall<Long, [Ptr], "atol">;
+def ATOLL : RuntimeLibcall<LLong, [Ptr], "atoll">;
+def BCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "bcmp">;
+def BCOPY : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "bcopy">;
+def CHMOD : RuntimeLibcall<Int, [Ptr, IntX], "chmod">;
+def CHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX], "chown">;
+def CLEARERR : RuntimeLibcall<Void, [Ptr], "clearerr">;
+def CLOSEDIR : RuntimeLibcall<Int, [Ptr], "closedir">;
+def CTERMID : RuntimeLibcall<Ptr, [Ptr], "ctermid">;
+def CXA_ATEXIT : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "cxa_atexit">;
+def CXA_GUARD_ABORT : RuntimeLibcall<Void, [Ptr], "cxa_guard_abort">;
+def CXA_GUARD_ACQUIRE : RuntimeLibcall<Int, [Ptr], "cxa_guard_acquire">;
+def CXA_GUARD_RELEASE : RuntimeLibcall<Void, [Ptr], "cxa_guard_release">;
+def CXA_THROW : RuntimeLibcall<Void, [Ptr, Ptr, Ptr], "cxa_throw">;
+def DUNDER_ISOC99_SCANF : RuntimeLibcall<Int, [Ptr, Ellip], "dunder_isoc99_scanf">;
+def DUNDER_ISOC99_SSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "dunder_isoc99_sscanf">;
+def DUNDER_STRDUP : RuntimeLibcall<Ptr, [Ptr], "dunder_strdup">;
+def DUNDER_STRNDUP : RuntimeLibcall<Ptr, [Ptr, SizeT], "dunder_strndup">;
+def DUNDER_STRTOK_R : RuntimeLibcall<Ptr, [Ptr, Ptr, Ptr], "dunder_strtok_r">;
def ENUM_VARIANT : RuntimeLibcall;
-def EXECL : RuntimeLibcall;
-def EXECLE : RuntimeLibcall;
-def EXECLP : RuntimeLibcall;
-def EXECV : RuntimeLibcall;
-def EXECVE : RuntimeLibcall;
-def EXECVP : RuntimeLibcall;
-def EXECVPE : RuntimeLibcall;
-def EXIT : RuntimeLibcall;
-def FCLOSE : RuntimeLibcall;
-def FDOPEN : RuntimeLibcall;
-def FEOF : RuntimeLibcall;
-def FERROR : RuntimeLibcall;
-def FFLUSH : RuntimeLibcall;
-def FFS : RuntimeLibcall;
-def FFSL : RuntimeLibcall;
-def FFSLL : RuntimeLibcall;
-def FGETC : RuntimeLibcall;
-def FGETC_UNLOCKED : RuntimeLibcall;
-def FGETPOS : RuntimeLibcall;
-def FGETS : RuntimeLibcall;
-def FGETS_UNLOCKED : RuntimeLibcall;
-def FILENO : RuntimeLibcall;
-def FIPRINTF : RuntimeLibcall;
-def FLOCKFILE : RuntimeLibcall;
-def FLS : RuntimeLibcall;
-def FLSL : RuntimeLibcall;
-def FLSLL : RuntimeLibcall;
-def FOPEN : RuntimeLibcall;
-def FOPEN64 : RuntimeLibcall;
-def FORK : RuntimeLibcall;
-def FPRINTF : RuntimeLibcall;
-def FPUTC : RuntimeLibcall;
-def FPUTC_UNLOCKED : RuntimeLibcall;
-def FPUTS : RuntimeLibcall;
-def FPUTS_UNLOCKED : RuntimeLibcall;
-def FREAD : RuntimeLibcall;
-def FREAD_UNLOCKED : RuntimeLibcall;
-def FSCANF : RuntimeLibcall;
-def FSEEK : RuntimeLibcall;
-def FSEEKO : RuntimeLibcall;
-def FSEEKO64 : RuntimeLibcall;
-def FSETPOS : RuntimeLibcall;
-def FSTAT : RuntimeLibcall;
-def FSTAT64 : RuntimeLibcall;
-def FSTATVFS : RuntimeLibcall;
-def FSTATVFS64 : RuntimeLibcall;
-def FTELL : RuntimeLibcall;
-def FTELLO : RuntimeLibcall;
-def FTELLO64 : RuntimeLibcall;
-def FTRYLOCKFILE : RuntimeLibcall;
-def FUNLOCKFILE : RuntimeLibcall;
-def FWRITE : RuntimeLibcall;
-def FWRITE_UNLOCKED : RuntimeLibcall;
-def GETC : RuntimeLibcall;
-def GETCHAR : RuntimeLibcall;
-def GETCHAR_UNLOCKED : RuntimeLibcall;
-def GETC_UNLOCKED : RuntimeLibcall;
-def GETENV : RuntimeLibcall;
-def GETITIMER : RuntimeLibcall;
-def GETLOGIN_R : RuntimeLibcall;
-def GETPWNAM : RuntimeLibcall;
-def GETS : RuntimeLibcall;
-def GETTIMEOFDAY : RuntimeLibcall;
-def HTONL : RuntimeLibcall;
-def HTONS : RuntimeLibcall;
-def IPRINTF : RuntimeLibcall;
-def ISASCII : RuntimeLibcall;
-def ISDIGIT : RuntimeLibcall;
-def LABS : RuntimeLibcall;
-def LCHOWN : RuntimeLibcall;
-def LLABS : RuntimeLibcall;
-def LSTAT : RuntimeLibcall;
-def LSTAT64 : RuntimeLibcall;
-def MEMALIGN : RuntimeLibcall;
-def MEMCCPY : RuntimeLibcall;
-def MEMCCPY_CHK : RuntimeLibcall;
-def MEMCHR : RuntimeLibcall;
-def MEMPCPY : RuntimeLibcall;
-def MEMPCPY_CHK : RuntimeLibcall;
-def MEMRCHR : RuntimeLibcall;
-def MEMSET_PATTERN16 : RuntimeLibcall;
-def MEMSET_PATTERN4 : RuntimeLibcall;
-def MEMSET_PATTERN8 : RuntimeLibcall;
-def MKDIR : RuntimeLibcall;
-def MKTIME : RuntimeLibcall;
-def MSVC_DELETE_ARRAY_PTR32 : RuntimeLibcall;
-def MSVC_DELETE_ARRAY_PTR32_INT : RuntimeLibcall;
-def MSVC_DELETE_ARRAY_PTR32_NOTHROW : RuntimeLibcall;
-def MSVC_DELETE_ARRAY_PTR64 : RuntimeLibcall;
-def MSVC_DELETE_ARRAY_PTR64_LONGLONG : RuntimeLibcall;
-def MSVC_DELETE_ARRAY_PTR64_NOTHROW : RuntimeLibcall;
-def MSVC_DELETE_PTR32 : RuntimeLibcall;
-def MSVC_DELETE_PTR32_INT : RuntimeLibcall;
-def MSVC_DELETE_PTR32_NOTHROW : RuntimeLibcall;
-def MSVC_DELETE_PTR64 : RuntimeLibcall;
-def MSVC_DELETE_PTR64_LONGLONG : RuntimeLibcall;
-def MSVC_DELETE_PTR64_NOTHROW : RuntimeLibcall;
-def MSVC_NEW_ARRAY_INT : RuntimeLibcall;
-def MSVC_NEW_ARRAY_INT_NOTHROW : RuntimeLibcall;
-def MSVC_NEW_ARRAY_LONGLONG : RuntimeLibcall;
-def MSVC_NEW_ARRAY_LONGLONG_NOTHROW : RuntimeLibcall;
-def MSVC_NEW_INT : RuntimeLibcall;
-def MSVC_NEW_INT_NOTHROW : RuntimeLibcall;
-def MSVC_NEW_LONGLONG : RuntimeLibcall;
-def MSVC_NEW_LONGLONG_NOTHROW : RuntimeLibcall;
-def NTOHL : RuntimeLibcall;
-def NTOHS : RuntimeLibcall;
-def OPEN : RuntimeLibcall;
-def OPEN64 : RuntimeLibcall;
-def OPENDIR : RuntimeLibcall;
-def PCLOSE : RuntimeLibcall;
-def PERROR : RuntimeLibcall;
-def POPEN : RuntimeLibcall;
-def POSIX_MEMALIGN : RuntimeLibcall;
-def PREAD : RuntimeLibcall;
-def PRINTF : RuntimeLibcall;
-def PUTC : RuntimeLibcall;
-def PUTCHAR : RuntimeLibcall;
-def PUTCHAR_UNLOCKED : RuntimeLibcall;
-def PUTC_UNLOCKED : RuntimeLibcall;
-def PUTS : RuntimeLibcall;
-def PVALLOC : RuntimeLibcall;
-def PWRITE : RuntimeLibcall;
-def QSORT : RuntimeLibcall;
-def READ : RuntimeLibcall;
-def READLINK : RuntimeLibcall;
-def REALLOC : RuntimeLibcall;
-def REALLOCARRAY : RuntimeLibcall;
-def REALLOCF : RuntimeLibcall;
-def REALPATH : RuntimeLibcall;
-def REMOVE : RuntimeLibcall;
-def RENAME : RuntimeLibcall;
-def REWIND : RuntimeLibcall;
-def RMDIR : RuntimeLibcall;
-def SCANF : RuntimeLibcall;
-def SETBUF : RuntimeLibcall;
-def SETITIMER : RuntimeLibcall;
-def SETVBUF : RuntimeLibcall;
-def SIPRINTF : RuntimeLibcall;
-def SIZE_RETURNING_NEW : RuntimeLibcall;
-def SIZE_RETURNING_NEW_ALIGNED : RuntimeLibcall;
-def SIZE_RETURNING_NEW_ALIGNED_HOT_COLD : RuntimeLibcall;
-def SIZE_RETURNING_NEW_HOT_COLD : RuntimeLibcall;
-def SMALL_FPRINTF : RuntimeLibcall;
-def SMALL_PRINTF : RuntimeLibcall;
-def SMALL_SPRINTF : RuntimeLibcall;
-def SNPRINTF : RuntimeLibcall;
-def SNPRINTF_CHK : RuntimeLibcall;
-def SPRINTF : RuntimeLibcall;
-def SPRINTF_CHK : RuntimeLibcall;
-def SSCANF : RuntimeLibcall;
-def STAT : RuntimeLibcall;
-def STAT64 : RuntimeLibcall;
-def STATVFS : RuntimeLibcall;
-def STATVFS64 : RuntimeLibcall;
-def STPCPY : RuntimeLibcall;
-def STPCPY_CHK : RuntimeLibcall;
-def STPNCPY : RuntimeLibcall;
-def STPNCPY_CHK : RuntimeLibcall;
-def STRCASECMP : RuntimeLibcall;
-def STRCAT : RuntimeLibcall;
-def STRCAT_CHK : RuntimeLibcall;
-def STRCHR : RuntimeLibcall;
-def STRCMP : RuntimeLibcall;
-def STRCOLL : RuntimeLibcall;
-def STRCPY : RuntimeLibcall;
-def STRCPY_CHK : RuntimeLibcall;
-def STRCSPN : RuntimeLibcall;
-def STRDUP : RuntimeLibcall;
-def STRLCAT : RuntimeLibcall;
-def STRLCAT_CHK : RuntimeLibcall;
-def STRLCPY : RuntimeLibcall;
-def STRLCPY_CHK : RuntimeLibcall;
-def STRLEN_CHK : RuntimeLibcall;
-def STRNCASECMP : RuntimeLibcall;
-def STRNCAT : RuntimeLibcall;
-def STRNCAT_CHK : RuntimeLibcall;
-def STRNCMP : RuntimeLibcall;
-def STRNCPY : RuntimeLibcall;
-def STRNCPY_CHK : RuntimeLibcall;
-def STRNDUP : RuntimeLibcall;
-def STRNLEN : RuntimeLibcall;
-def STRPBRK : RuntimeLibcall;
-def STRRCHR : RuntimeLibcall;
-def STRSPN : RuntimeLibcall;
-def STRSTR : RuntimeLibcall;
-def STRTOD : RuntimeLibcall;
-def STRTOF : RuntimeLibcall;
-def STRTOK : RuntimeLibcall;
-def STRTOK_R : RuntimeLibcall;
-def STRTOL : RuntimeLibcall;
-def STRTOLD : RuntimeLibcall;
-def STRTOLL : RuntimeLibcall;
-def STRTOUL : RuntimeLibcall;
-def STRTOULL : RuntimeLibcall;
-def STRXFRM : RuntimeLibcall;
-def SYSTEM : RuntimeLibcall;
-def TERMINATE : RuntimeLibcall;
-def TIMES : RuntimeLibcall;
-def TMPFILE : RuntimeLibcall;
-def TMPFILE64 : RuntimeLibcall;
-def TOASCII : RuntimeLibcall;
-def UNAME : RuntimeLibcall;
-def UNDER_IO_GETC : RuntimeLibcall;
-def UNDER_IO_PUTC : RuntimeLibcall;
-def UNGETC : RuntimeLibcall;
-def UNLINK : RuntimeLibcall;
-def UNSETENV : RuntimeLibcall;
-def UTIME : RuntimeLibcall;
-def UTIMES : RuntimeLibcall;
-def VALLOC : RuntimeLibcall;
-def VEC_CALLOC : RuntimeLibcall;
-def VEC_FREE : RuntimeLibcall;
-def VEC_MALLOC : RuntimeLibcall;
-def VEC_REALLOC : RuntimeLibcall;
-def VFPRINTF : RuntimeLibcall;
-def VFSCANF : RuntimeLibcall;
-def VPRINTF : RuntimeLibcall;
-def VSCANF : RuntimeLibcall;
-def VSNPRINTF : RuntimeLibcall;
-def VSNPRINTF_CHK : RuntimeLibcall;
-def VSPRINTF : RuntimeLibcall;
-def VSPRINTF_CHK : RuntimeLibcall;
-def VSSCANF : RuntimeLibcall;
-def WCSLEN : RuntimeLibcall;
-def WRITE : RuntimeLibcall;
-def ZDAPV : RuntimeLibcall;
-def ZDAPVJ : RuntimeLibcall;
-def ZDAPVJST11ALIGN_VAL_T : RuntimeLibcall;
-def ZDAPVM : RuntimeLibcall;
-def ZDAPVMST11ALIGN_VAL_T : RuntimeLibcall;
-def ZDAPVRKST9NOTHROW_T : RuntimeLibcall;
-def ZDAPVST11ALIGN_VAL_T : RuntimeLibcall;
-def ZDAPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall;
-def ZDLPV : RuntimeLibcall;
-def ZDLPVJ : RuntimeLibcall;
-def ZDLPVJST11ALIGN_VAL_T : RuntimeLibcall;
-def ZDLPVM : RuntimeLibcall;
-def ZDLPVMST11ALIGN_VAL_T : RuntimeLibcall;
-def ZDLPVRKST9NOTHROW_T : RuntimeLibcall;
-def ZDLPVST11ALIGN_VAL_T : RuntimeLibcall;
-def ZDLPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall;
-def ZNAJ : RuntimeLibcall;
-def ZNAJRKST9NOTHROW_T : RuntimeLibcall;
-def ZNAJST11ALIGN_VAL_T : RuntimeLibcall;
-def ZNAJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall;
-def ZNAM : RuntimeLibcall;
-def ZNAM12__HOT_COLD_T : RuntimeLibcall;
-def ZNAMRKST9NOTHROW_T : RuntimeLibcall;
-def ZNAMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall;
-def ZNAMST11ALIGN_VAL_T : RuntimeLibcall;
-def ZNAMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall;
-def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall;
-def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall;
-def ZNWJ : RuntimeLibcall;
-def ZNWJRKST9NOTHROW_T : RuntimeLibcall;
-def ZNWJST11ALIGN_VAL_T : RuntimeLibcall;
-def ZNWJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall;
-def ZNWM : RuntimeLibcall;
-def ZNWM12__HOT_COLD_T : RuntimeLibcall;
-def ZNWMRKST9NOTHROW_T : RuntimeLibcall;
-def ZNWMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall;
-def ZNWMST11ALIGN_VAL_T : RuntimeLibcall;
-def ZNWMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall;
-def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall;
-def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall;
-def KMPC_ALLOC_SHARED : RuntimeLibcall;
-def KMPC_FREE_SHARED : RuntimeLibcall;
+def EXECL : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "execl">;
+def EXECLE : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "execle">;
+def EXECLP : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "execlp">;
+def EXECV : RuntimeLibcall<Int, [Ptr, Ptr], "execv">;
+def EXECVE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "execve">;
+def EXECVP : RuntimeLibcall<Int, [Ptr, Ptr], "execvp">;
+def EXECVPE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "execvpe">;
+def EXIT : RuntimeLibcall<Void, [Int], "exit">;
+def FCLOSE : RuntimeLibcall<Int, [Ptr], "fclose">;
+def FDOPEN : RuntimeLibcall<Ptr, [Int, Ptr], "fdopen">;
+def FEOF : RuntimeLibcall<Int, [Ptr], "feof">;
+def FERROR : RuntimeLibcall<Int, [Ptr], "ferror">;
+def FFLUSH : RuntimeLibcall<Int, [Ptr], "fflush">;
+def FFS : RuntimeLibcall<Int, [Int], "ffs">;
+def FFSL : RuntimeLibcall<Int, [Long], "ffsl">;
+def FFSLL : RuntimeLibcall<Int, [LLong], "ffsll">;
+def FGETC : RuntimeLibcall<Int, [Ptr], "fgetc">;
+def FGETC_UNLOCKED : RuntimeLibcall<Int, [Ptr], "fgetc_unlocked">;
+def FGETPOS : RuntimeLibcall<Int, [Ptr, Ptr], "fgetpos">;
+def FGETS : RuntimeLibcall<Ptr, [Ptr, Int, Ptr], "fgets">;
+def FGETS_UNLOCKED : RuntimeLibcall<Ptr, [Ptr, Int, Ptr], "fgets_unlocked">;
+def FILENO : RuntimeLibcall<Int, [Ptr], "fileno">;
+def FIPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "fiprintf">;
+def FLOCKFILE : RuntimeLibcall<Void, [Ptr], "flockfile">;
+def FLS : RuntimeLibcall<Int, [Int], "fls">;
+def FLSL : RuntimeLibcall<Int, [Long], "flsl">;
+def FLSLL : RuntimeLibcall<Int, [LLong], "flsll">;
+def FOPEN : RuntimeLibcall<Ptr, [Ptr, Ptr], "fopen">;
+def FOPEN64 : RuntimeLibcall<Ptr, [Ptr, Ptr], "fopen64">;
+def FORK : RuntimeLibcall<Int, [], "fork">;
+def FPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "fprintf">;
+def FPUTC : RuntimeLibcall<Int, [Int, Ptr], "fputc">;
+def FPUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr], "fputc_unlocked">;
+def FPUTS : RuntimeLibcall<Int, [Ptr, Ptr], "fputs">;
+def FPUTS_UNLOCKED : RuntimeLibcall<Int, [Ptr, Ptr], "fputs_unlocked">;
+def FREAD : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fread">;
+def FREAD_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fread_unlocked">;
+def FSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "fscanf">;
+def FSEEK : RuntimeLibcall<Int, [Ptr, Long, Int], "fseek">;
+def FSEEKO : RuntimeLibcall<Int, [Ptr, IntX, Int], "fseeko">;
+def FSEEKO64 : RuntimeLibcall<Int, [Ptr, Int64, Int], "fseeko64">;
+def FSETPOS : RuntimeLibcall<Int, [Ptr, Ptr], "fsetpos">;
+def FSTAT : RuntimeLibcall<Int, [Int, Ptr], "fstat">;
+def FSTAT64 : RuntimeLibcall<Int, [Int, Ptr], "fstat64">;
+def FSTATVFS : RuntimeLibcall<Int, [Int, Ptr], "fstatvfs">;
+def FSTATVFS64 : RuntimeLibcall<Int, [Int, Ptr], "fstatvfs64">;
+def FTELL : RuntimeLibcall<Long, [Ptr], "ftell">;
+def FTELLO : RuntimeLibcall<IntPlus, [Ptr], "ftello">;
+def FTELLO64 : RuntimeLibcall<Int64, [Ptr], "ftello64">;
+def FTRYLOCKFILE : RuntimeLibcall<Int, [Ptr], "ftrylockfile">;
+def FUNLOCKFILE : RuntimeLibcall<Void, [Ptr], "funlockfile">;
+def FWRITE : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fwrite">;
+def FWRITE_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fwrite_unlocked">;
+def GETC : RuntimeLibcall<Int, [Ptr], "getc">;
+def GETCHAR : RuntimeLibcall<Int, [], "getchar">;
+def GETCHAR_UNLOCKED : RuntimeLibcall<Int, [], "getchar_unlocked">;
+def GETC_UNLOCKED : RuntimeLibcall<Int, [Ptr], "getc_unlocked">;
+def GETENV : RuntimeLibcall<Ptr, [Ptr], "getenv">;
+def GETITIMER : RuntimeLibcall<Int, [Int, Ptr], "getitimer">;
+def GETLOGIN_R : RuntimeLibcall<Int, [Ptr, SizeT], "getlogin_r">;
+def GETPWNAM : RuntimeLibcall<Ptr, [Ptr], "getpwnam">;
+def GETS : RuntimeLibcall<Ptr, [Ptr], "gets">;
+def GETTIMEOFDAY : RuntimeLibcall<Int, [Ptr, Ptr], "gettimeofday">;
+def HTONL : RuntimeLibcall<Int32, [Int32], "htonl">;
+def HTONS : RuntimeLibcall<Int16, [Int16], "htons">;
+def IPRINTF : RuntimeLibcall<Int, [Ptr, Ellip], "iprintf">;
+def ISASCII : RuntimeLibcall<Int, [Int], "isascii">;
+def ISDIGIT : RuntimeLibcall<Int, [Int], "isdigit">;
+def LABS : RuntimeLibcall<Long, [Same], "labs">;
+def LCHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX], "lchown">;
+def LLABS : RuntimeLibcall<LLong, [LLong], "llabs">;
+def LSTAT : RuntimeLibcall<Int, [Ptr, Ptr], "lstat">;
+def LSTAT64 : RuntimeLibcall<Int, [Ptr, Ptr], "lstat64">;
+def MEMALIGN : RuntimeLibcall<Ptr, [SizeT, SizeT], "memalign">;
+def MEMCCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, Int, SizeT], "memccpy">;
+def MEMCCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, Int, SizeT, SizeT], "memccpy_chk">;
+def MEMCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT], "memchr">;
+def MEMPCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "mempcpy">;
+def MEMPCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "mempcpy_chk">;
+def MEMRCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT], "memrchr">;
+def MEMSET_PATTERN16 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "memset_pattern16">;
+def MEMSET_PATTERN4 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "memset_pattern4">;
+def MEMSET_PATTERN8 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "memset_pattern8">;
+def MKDIR : RuntimeLibcall<Int, [Ptr, IntX], "mkdir">;
+def MKTIME : RuntimeLibcall<IntPlus, [Ptr], "mktime">;
+def MSVC_DELETE_ARRAY_PTR32 : RuntimeLibcall<Void, [Ptr], "msvc_delete_array_ptr32">;
+def MSVC_DELETE_ARRAY_PTR32_INT : RuntimeLibcall<Void, [Ptr, Int], "msvc_delete_array_ptr32_int">;
+def MSVC_DELETE_ARRAY_PTR32_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_array_ptr32_nothrow">;
+def MSVC_DELETE_ARRAY_PTR64 : RuntimeLibcall<Void, [Ptr], "msvc_delete_array_ptr64">;
+def MSVC_DELETE_ARRAY_PTR64_LONGLONG : RuntimeLibcall<Void, [Ptr, LLong], "msvc_delete_array_ptr64_longlong">;
+def MSVC_DELETE_ARRAY_PTR64_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_array_ptr64_nothrow">;
+def MSVC_DELETE_PTR32 : RuntimeLibcall<Void, [Ptr], "msvc_delete_ptr32">;
+def MSVC_DELETE_PTR32_INT : RuntimeLibcall<Void, [Ptr, Int], "msvc_delete_ptr32_int">;
+def MSVC_DELETE_PTR32_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_ptr32_nothrow">;
+def MSVC_DELETE_PTR64 : RuntimeLibcall<Void, [Ptr], "msvc_delete_ptr64">;
+def MSVC_DELETE_PTR64_LONGLONG : RuntimeLibcall<Void, [Ptr, LLong], "msvc_delete_ptr64_longlong">;
+def MSVC_DELETE_PTR64_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_ptr64_nothrow">;
+def MSVC_NEW_ARRAY_INT : RuntimeLibcall<Ptr, [Int], "msvc_new_array_int">;
+def MSVC_NEW_ARRAY_INT_NOTHROW : RuntimeLibcall<Ptr, [Int, Ptr], "msvc_new_array_int_nothrow">;
+def MSVC_NEW_ARRAY_LONGLONG : RuntimeLibcall<Ptr, [LLong], "msvc_new_array_longlong">;
+def MSVC_NEW_ARRAY_LONGLONG_NOTHROW : RuntimeLibcall<Ptr, [LLong, Ptr], "msvc_new_array_longlong_nothrow">;
+def MSVC_NEW_INT : RuntimeLibcall<Ptr, [Int], "msvc_new_int">;
+def MSVC_NEW_INT_NOTHROW : RuntimeLibcall<Ptr, [Int, Ptr], "msvc_new_int_nothrow">;
+def MSVC_NEW_LONGLONG : RuntimeLibcall<Ptr, [LLong], "msvc_new_longlong">;
+def MSVC_NEW_LONGLONG_NOTHROW : RuntimeLibcall<Ptr, [LLong, Ptr], "msvc_new_longlong_nothrow">;
+def NTOHL : RuntimeLibcall<Int32, [Int32], "ntohl">;
+def NTOHS : RuntimeLibcall<Int16, [Int16], "ntohs">;
+def OPEN : RuntimeLibcall<Int, [Ptr, Int, Ellip], "open">;
+def OPEN64 : RuntimeLibcall<Int, [Ptr, Int, Ellip], "open64">;
+def OPENDIR : RuntimeLibcall<Ptr, [Ptr], "opendir">;
+def PCLOSE : RuntimeLibcall<Int, [Ptr], "pclose">;
+def PERROR : RuntimeLibcall<Void, [Ptr], "perror">;
+def POPEN : RuntimeLibcall<Ptr, [Ptr, Ptr], "popen">;
+def POSIX_MEMALIGN : RuntimeLibcall<Int, [Ptr, SizeT, SizeT], "posix_memalign">;
+def PREAD : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus], "pread">;
+def PRINTF : RuntimeLibcall<Int, [Ptr, Ellip], "printf">;
+def PUTC : RuntimeLibcall<Int, [Int, Ptr], "putc">;
+def PUTCHAR : RuntimeLibcall<Int, [Int], "putchar">;
+def PUTCHAR_UNLOCKED : RuntimeLibcall<Int, [Int], "putchar_unlocked">;
+def PUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr], "putc_unlocked">;
+def PUTS : RuntimeLibcall<Int, [Ptr], "puts">;
+def PVALLOC : RuntimeLibcall<Ptr, [SizeT], "pvalloc">;
+def PWRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus], "pwrite">;
+def QSORT : RuntimeLibcall<Void, [Ptr, SizeT, SizeT, Ptr], "qsort">;
+def READ : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT], "read">;
+def READLINK : RuntimeLibcall<SSizeT, [Ptr, Ptr, SizeT], "readlink">;
+def REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT], "realloc">;
+def REALLOCARRAY : RuntimeLibcall<Ptr, [Ptr, SizeT, SizeT], "reallocarray">;
+def REALLOCF : RuntimeLibcall<Ptr, [Ptr, SizeT], "reallocf">;
+def REALPATH : RuntimeLibcall<Ptr, [Ptr, Ptr], "realpath">;
+def REMOVE : RuntimeLibcall<Int, [Ptr], "remove">;
+def RENAME : RuntimeLibcall<Int, [Ptr, Ptr], "rename">;
+def REWIND : RuntimeLibcall<Void, [Ptr], "rewind">;
+def RMDIR : RuntimeLibcall<Int, [Ptr], "rmdir">;
+def SCANF : RuntimeLibcall<Int, [Ptr, Ellip], "scanf">;
+def SETBUF : RuntimeLibcall<Void, [Ptr, Ptr], "setbuf">;
+def SETITIMER : RuntimeLibcall<Int, [Int, Ptr, Ptr], "setitimer">;
+def SETVBUF : RuntimeLibcall<Int, [Ptr, Ptr, Int, SizeT], "setvbuf">;
+def SIPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "siprintf">;
+def SIZE_RETURNING_NEW : RuntimeLibcall<NoneType, [], "size_returning_new">;
+def SIZE_RETURNING_NEW_ALIGNED : RuntimeLibcall<NoneType, [], "size_returning_new_aligned">;
+def SIZE_RETURNING_NEW_ALIGNED_HOT_COLD : RuntimeLibcall<NoneType, [], "size_returning_new_aligned_hot_cold">;
+def SIZE_RETURNING_NEW_HOT_COLD : RuntimeLibcall<NoneType, [], "size_returning_new_hot_cold">;
+def SMALL_FPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "small_fprintf">;
+def SMALL_PRINTF : RuntimeLibcall<Int, [Ptr, Ellip], "small_printf">;
+def SMALL_SPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "small_sprintf">;
+def SNPRINTF : RuntimeLibcall<Int, [Ptr, SizeT, Ptr, Ellip], "snprintf">;
+def SNPRINTF_CHK : RuntimeLibcall<Int, [Ptr, SizeT, Int, SizeT, Ptr, Ellip], "snprintf_chk">;
+def SPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "sprintf">;
+def SPRINTF_CHK : RuntimeLibcall<Int, [Ptr, Int, SizeT, Ptr, Ellip], "sprintf_chk">;
+def SSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "sscanf">;
+def STAT : RuntimeLibcall<Int, [Ptr, Ptr], "stat">;
+def STAT64 : RuntimeLibcall<Int, [Ptr, Ptr], "stat64">;
+def STATVFS : RuntimeLibcall<Int, [Ptr, Ptr], "statvfs">;
+def STATVFS64 : RuntimeLibcall<Int, [Ptr, Ptr], "statvfs64">;
+def STPCPY : RuntimeLibcall<Ptr, [Ptr, Ptr], "stpcpy">;
+def STPCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "stpcpy_chk">;
+def STPNCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "stpncpy">;
+def STPNCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "stpncpy_chk">;
+def STRCASECMP : RuntimeLibcall<Int, [Ptr, Ptr], "strcasecmp">;
+def STRCAT : RuntimeLibcall<Ptr, [Ptr, Ptr], "strcat">;
+def STRCAT_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strcat_chk">;
+def STRCHR : RuntimeLibcall<Ptr, [Ptr, Int], "strchr">;
+def STRCMP : RuntimeLibcall<Int, [Ptr, Ptr], "strcmp">;
+def STRCOLL : RuntimeLibcall<Int, [Ptr, Ptr], "strcoll">;
+def STRCPY : RuntimeLibcall<Ptr, [Ptr, Ptr], "strcpy">;
+def STRCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strcpy_chk">;
+def STRCSPN : RuntimeLibcall<SizeT, [Ptr, Ptr], "strcspn">;
+def STRDUP : RuntimeLibcall<Ptr, [Ptr], "strdup">;
+def STRLCAT : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT], "strlcat">;
+def STRLCAT_CHK : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT, SizeT], "strlcat_chk">;
+def STRLCPY : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT], "strlcpy">;
+def STRLCPY_CHK : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT, SizeT], "strlcpy_chk">;
+def STRLEN_CHK : RuntimeLibcall<SizeT, [Ptr, SizeT], "strlen_chk">;
+def STRNCASECMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "strncasecmp">;
+def STRNCAT : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strncat">;
+def STRNCAT_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "strncat_chk">;
+def STRNCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "strncmp">;
+def STRNCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strncpy">;
+def STRNCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "strncpy_chk">;
+def STRNDUP : RuntimeLibcall<Ptr, [Ptr, SizeT], "strndup">;
+def STRNLEN : RuntimeLibcall<SizeT, [Ptr, SizeT], "strnlen">;
+def STRPBRK : RuntimeLibcall<Ptr, [Ptr, Ptr], "strpbrk">;
+def STRRCHR : RuntimeLibcall<Ptr, [Ptr, Int], "strrchr">;
+def STRSPN : RuntimeLibcall<SizeT, [Ptr, Ptr], "strspn">;
+def STRSTR : RuntimeLibcall<Ptr, [Ptr, Ptr], "strstr">;
+def STRTOD : RuntimeLibcall<Dbl, [Ptr, Ptr], "strtod">;
+def STRTOF : RuntimeLibcall<Flt, [Ptr, Ptr], "strtof">;
+def STRTOK : RuntimeLibcall<Ptr, [Ptr, Ptr], "strtok">;
+def STRTOK_R : RuntimeLibcall<Ptr, [Ptr, Ptr, Ptr], "strtok_r">;
+def STRTOL : RuntimeLibcall<Long, [Ptr, Ptr, Int], "strtol">;
+def STRTOLD : RuntimeLibcall<LDbl, [Ptr, Ptr], "strtold">;
+def STRTOLL : RuntimeLibcall<LLong, [Ptr, Ptr, Int], "strtoll">;
+def STRTOUL : RuntimeLibcall<Long, [Ptr, Ptr, Int], "strtoul">;
+def STRTOULL : RuntimeLibcall<LLong, [Ptr, Ptr, Int], "strtoull">;
+def STRXFRM : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT], "strxfrm">;
+def SYSTEM : RuntimeLibcall<Int, [Ptr], "system">;
+def TERMINATE : RuntimeLibcall<Void, [], "terminate">;
+def TIMES : RuntimeLibcall<IntPlus, [Ptr], "times">;
+def TMPFILE : RuntimeLibcall<Ptr, [], "tmpfile">;
+def TMPFILE64 : RuntimeLibcall<Ptr, [], "tmpfile64">;
+def TOASCII : RuntimeLibcall<Int, [Int], "toascii">;
+def UNAME : RuntimeLibcall<Int, [Ptr], "uname">;
+def UNDER_IO_GETC : RuntimeLibcall<Int, [Ptr], "under_IO_getc">;
+def UNDER_IO_PUTC : RuntimeLibcall<Int, [Int, Ptr], "under_IO_putc">;
+def UNGETC : RuntimeLibcall<Int, [Int, Ptr], "ungetc">;
+def UNLINK : RuntimeLibcall<Int, [Ptr], "unlink">;
+def UNSETENV : RuntimeLibcall<Int, [Ptr], "unsetenv">;
+def UTIME : RuntimeLibcall<Int, [Ptr, Ptr], "utime">;
+def UTIMES : RuntimeLibcall<Int, [Ptr, Ptr], "utimes">;
+def VALLOC : RuntimeLibcall<Ptr, [SizeT], "valloc">;
+def VEC_CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT], "vec_calloc">;
+def VEC_FREE : RuntimeLibcall<Void, [Ptr], "vec_free">;
+def VEC_MALLOC : RuntimeLibcall<Ptr, [SizeT], "vec_malloc">;
+def VEC_REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT], "vec_realloc">;
+def VFPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vfprintf">;
+def VFSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vfscanf">;
+def VPRINTF : RuntimeLibcall<Int, [Ptr, Ptr], "vprintf">;
+def VSCANF : RuntimeLibcall<Int, [Ptr, Ptr], "vscanf">;
+def VSNPRINTF : RuntimeLibcall<Int, [Ptr, SizeT, Ptr, Ptr], "vsnprintf">;
+def VSNPRINTF_CHK : RuntimeLibcall<Int, [Ptr, SizeT, Int, SizeT, Ptr, Ptr], "vsnprintf_chk">;
+def VSPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vsprintf">;
+def VSPRINTF_CHK : RuntimeLibcall<Int, [Ptr, Int, SizeT, Ptr, Ptr], "vsprintf_chk">;
+def VSSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vsscanf">;
+def WCSLEN : RuntimeLibcall<SizeT, [Ptr], "wcslen">;
+def WRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT], "write">;
+def ZDAPV : RuntimeLibcall<Void, [Ptr], "ZdaPv">;
+def ZDAPVJ : RuntimeLibcall<Void, [Ptr, Int], "ZdaPvj">;
+def ZDAPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int], "ZdaPvjSt11align_val_t">;
+def ZDAPVM : RuntimeLibcall<Void, [Ptr, Long], "ZdaPvm">;
+def ZDAPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long], "ZdaPvmSt11align_val_t">;
+def ZDAPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr], "ZdlPvRKSt9nothrow_t">;
+def ZDAPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus], "ZdlPvSt11align_val_t">;
+def ZDAPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr], "ZdlPvSt11align_val_tRKSt9nothrow_t">;
+def ZDLPV : RuntimeLibcall<Void, [Ptr], "ZdlPv">;
+def ZDLPVJ : RuntimeLibcall<Void, [Ptr, Int], "ZdlPvj">;
+def ZDLPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int], "ZdlPvjSt11align_val_t">;
+def ZDLPVM : RuntimeLibcall<Void, [Ptr, Long], "ZdlPvm">;
+def ZDLPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long], "ZdlPvmSt11align_val_t">;
+def ZDLPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr], "ZdlPvRKSt9nothrow_t">;
+def ZDLPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus], "ZdlPvSt11align_val_t">;
+def ZDLPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr], "ZdlPvSt11align_val_tRKSt9nothrow_t">;
+def ZNAJ : RuntimeLibcall<Ptr, [Int], "Znaj">;
+def ZNAJRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Ptr], "ZnajRKSt9nothrow_t">;
+def ZNAJST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Int, Int], "ZnajSt11align_val_t">;
+def ZNAJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Int, Ptr], "ZnajSt11align_val_tRKSt9nothrow_t">;
+def ZNAM : RuntimeLibcall<Ptr, [Long], "Znam">;
+def ZNAM12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Bool], "Znam12__hot_cold_t">;
+def ZNAMRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Ptr], "ZnamRKSt9nothrow_t">;
+def ZNAMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Ptr, Bool], "ZnamRKSt9nothrow_t12__hot_cold_t">;
+def ZNAMST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Long, Long], "ZnamSt11align_val_t">;
+def ZNAMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Bool], "ZnamSt11align_val_t12__hot_cold_t">;
+def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Long, Ptr], "ZnamSt11align_val_tRKSt9nothrow_t">;
+def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Ptr, Bool], "ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t">;
+def ZNWJ : RuntimeLibcall<Ptr, [Int], "Znwj">;
+def ZNWJRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Ptr], "ZnwjRKSt9nothrow_t">;
+def ZNWJST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Int, Int], "ZnwjSt11align_val_t">;
+def ZNWJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Int, Ptr], "ZnwjSt11align_val_tRKSt9nothrow_t">;
+def ZNWM : RuntimeLibcall<Ptr, [Long], "Znwm">;
+def ZNWM12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Bool], "Znwm12__hot_cold_t">;
+def ZNWMRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Ptr], "ZnwmRKSt9nothrow_t">;
+def ZNWMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Ptr, Bool], "ZnwmRKSt9nothrow_t12__hot_cold_t">;
+def ZNWMST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Long, Long], "ZnwmSt11align_val_t">;
+def ZNWMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Bool], "ZnwmSt11align_val_t12__hot_cold_t">;
+def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Long, Ptr], "ZnwmSt11align_val_tRKSt9nothrow_t">;
+def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Ptr, Bool], "ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t">;
+def KMPC_ALLOC_SHARED : RuntimeLibcall<Ptr, [SizeT], "__kmpc_alloc_shared">;
+def KMPC_FREE_SHARED : RuntimeLibcall<Void, [Ptr, SizeT], "__kmpc_free_shared">;
//--------------------------------------------------------------------
// Global variable references
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 92853125379f5..46ef2ac64a818 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -40,6 +40,34 @@ def SMEABI_PreserveMost_From_X0 : LibcallCallingConv<[{CallingConv::AArch64_SME_
def SMEABI_PreserveMost_From_X1 : LibcallCallingConv<[{CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X1}]>;
def SMEABI_PreserveMost_From_X2 : LibcallCallingConv<[{CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2}]>;
+// Return type or argument type of library function.
+class FuncArgType {
+ string Name = NAME;
+}
+
+// Recognized types of library function arguments and return types.
+def NoneType : FuncArgType; // dummy
+def Void : FuncArgType;
+def Bool : FuncArgType; // 8 bits on all targets
+def Int16 : FuncArgType;
+def Int32 : FuncArgType;
+def Int : FuncArgType;
+def IntPlus : FuncArgType; // Int or bigger.
+def Long : FuncArgType; // Either 32 or 64 bits.
+def IntX : FuncArgType; // Any integer type.
+def Int64 : FuncArgType;
+def LLong : FuncArgType; // 64 bits on all targets.
+def SizeT : FuncArgType; // size_t.
+def SSizeT : FuncArgType; // POSIX ssize_t.
+def Flt : FuncArgType; // IEEE float.
+def Dbl : FuncArgType; // IEEE double.
+def LDbl : FuncArgType; // Any floating type (TODO: tighten this up).
+def Floating : FuncArgType; // Any floating type.
+def Ptr : FuncArgType; // Any pointer type.
+def Struct : FuncArgType; // Any struct type.
+def Ellip : FuncArgType; // The ellipsis (...).
+def Same : FuncArgType; // Same argument type as the previous one.
+
/// Abstract definition for functionality the compiler may need to
/// emit a call to. Emits the RTLIB::Libcall enum - This enum defines
/// all of the runtime library calls the backend can emit. The various
@@ -49,10 +77,13 @@ def SMEABI_PreserveMost_From_X2 : LibcallCallingConv<[{CallingConv::AArch64_SME_
/// When adding PPCF128 functions here, note that their names generally need
/// to be overridden for Darwin with the xxx$LDBL128 form. See
/// PPCISelLowering.cpp.
-class RuntimeLibcall {
+class RuntimeLibcall<FuncArgType RetType = NoneType,
+ list<FuncArgType> ArgTypes = [],
+ string EnumName = ""> {
string Name = NAME;
-
- // TODO: Record type signature and attributes
+ FuncArgType ReturnType = RetType;
+ list<FuncArgType> ArgumentTypes = ArgTypes;
+ string LibFuncEnumName = EnumName; // For TargetLibraryInfo
}
// Concrete implementation of a libcall, which may have a different
@@ -93,3 +124,20 @@ class SystemRuntimeLibrary<RuntimeLibcallPredicate Pred, dag funcList> {
RuntimeLibcallPredicate TriplePred = Pred;
LibcallImpls MemberList = LibcallImpls<funcList>;
}
+
+// Definitions of library function for TargetLibraryInfo.
+class TargetLibCall;
+
+class TargetLibCall_D<string FuncName, FuncArgType RetType,
+ list<FuncArgType> ArgTypes = []>
+ : TargetLibCall {
+ string LibCallFuncName = FuncName;
+ FuncArgType ReturnType = RetType;
+ list<FuncArgType> ArgumentTypes = ArgTypes;
+}
+
+class TargetLibCall_R<RuntimeLibcallImpl LibcallImpl>
+ : TargetLibCall {
+ RuntimeLibcallImpl RTLibcallImpl = LibcallImpl;
+}
+
diff --git a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
index 0aff464e08c5b..6b1e95189ffdf 100644
--- a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
@@ -78,11 +78,18 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoEnum(
// the string.
void TargetLibraryInfoEmitter::emitTargetLibraryInfoStringTable(
raw_ostream &OS) const {
+
+ auto getFuncName = [](const Record *R) -> StringRef {
+ if (R->isSubClassOf("TargetLibCall_R"))
+ R = R->getValueAsDef("RTLibcallImpl");
+ return R->getValueAsString("LibCallFuncName");
+ };
+
llvm::StringToOffsetTable Table(
/*AppendZero=*/true,
"TargetLibraryInfoImpl::", /*UsePrefixForStorageMember=*/false);
for (const auto *R : AllTargetLibcalls)
- Table.GetOrAddStringOffset(R->getValueAsString("String"));
+ Table.GetOrAddStringOffset(getFuncName(R));
size_t NumEl = AllTargetLibcalls.size() + 1;
@@ -97,7 +104,7 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoStringTable(
"{\n";
OS.indent(2) << "0, //\n";
for (const auto *R : AllTargetLibcalls) {
- StringRef Str = R->getValueAsString("String");
+ StringRef Str = getFuncName(R);
OS.indent(2) << Table.GetStringOffset(Str) << ", // " << Str << "\n";
}
OS << "};\n";
@@ -105,7 +112,7 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoStringTable(
<< NumEl << "] = {\n";
OS << " 0,\n";
for (const auto *R : AllTargetLibcalls)
- OS.indent(2) << R->getValueAsString("String").size() << ",\n";
+ OS.indent(2) << getFuncName(R).size() << ",\n";
OS << "};\n";
}
@@ -133,6 +140,8 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoSignatureTable(
using Signature = std::vector<StringRef>;
SequenceToOffsetTable<Signature> SignatureTable("NoFuncArgType");
auto GetSignature = [](const Record *R) -> Signature {
+ if (R->isSubClassOf("TargetLibCall_R"))
+ R = R->getValueAsDef("RTLibcallImpl")->getValueAsDef("Provides");
const auto *Tys = R->getValueAsListInit("ArgumentTypes");
Signature Sig;
Sig.reserve(Tys->size() + 1);
>From 3a29126ecdd57ae83a818c425d4ff0848adaa026 Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Thu, 19 Mar 2026 20:08:13 +0000
Subject: [PATCH 2/8] Reuse data in RuntimeLibcall for TargetLibraryInfo.
---
.../llvm/Analysis/TargetLibraryInfo.td | 1149 ++++++++---------
llvm/include/llvm/IR/RuntimeLibcalls.td | 10 +-
.../Basic/TargetLibraryInfoEmitter.cpp | 13 +-
3 files changed, 568 insertions(+), 604 deletions(-)
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
index c9046ef2a02aa..d74bf31ad1be7 100644
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.td
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
@@ -9,158 +9,143 @@
include "llvm/IR/RuntimeLibcalls.td"
/// void *operator new(unsigned int);
-def msvc_new_int : TargetLibCall<"??2 at YAPAXI@Z", Ptr, [Int]>;
+def TLI_msvc_new_int : TargetLibCall_R<__2_YAPAXI_Z>;
/// void *operator new(unsigned int, const std::nothrow_t&);
-def msvc_new_int_nothrow
- : TargetLibCall<"??2 at YAPAXIABUnothrow_t@std@@@Z", Ptr, [Int, Ptr]>;
+def TLI_msvc_new_int_nothrow : TargetLibCall_R<__2_YAPAXIABUnothrow_t_std___Z>;
/// void *operator new(unsigned long long);
-def msvc_new_longlong : TargetLibCall<"??2 at YAPEAX_K@Z", Ptr, [LLong]>;
+def TLI_msvc_new_longlong : TargetLibCall_R<__2_YAPEAX_K_Z>;
/// void *operator new(unsigned long long, const std::nothrow_t&);
-def msvc_new_longlong_nothrow
- : TargetLibCall<"??2 at YAPEAX_KAEBUnothrow_t@std@@@Z", Ptr, [LLong, Ptr]>;
+def TLI_msvc_new_longlong_nothrow
+ : TargetLibCall_R<__2_YAPEAX_KAEBUnothrow_t_std___Z>;
/// void operator delete(void*);
-def msvc_delete_ptr32 : TargetLibCall<"??3 at YAXPAX@Z", Void, [Ptr]>;
+def TLI_msvc_delete_ptr32 : TargetLibCall_R<__3_YAXPAX_Z>;
/// void operator delete(void*, const std::nothrow_t&);
-def msvc_delete_ptr32_nothrow
- : TargetLibCall<"??3 at YAXPAXABUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
+def TLI_msvc_delete_ptr32_nothrow
+ : TargetLibCall_R<__3_YAXPAXABUnothrow_t_std___Z>;
/// void operator delete(void*, unsigned int);
-def msvc_delete_ptr32_int : TargetLibCall<"??3 at YAXPAXI@Z", Void, [Ptr, Int]>;
+def TLI_msvc_delete_ptr32_int : TargetLibCall_R<__3_YAXPAXI_Z>;
/// void operator delete(void*);
-def msvc_delete_ptr64 : TargetLibCall<"??3 at YAXPEAX@Z", Void, [Ptr]>;
+def TLI_msvc_delete_ptr64 : TargetLibCall_R<__3_YAXPEAX_Z>;
/// void operator delete(void*, const std::nothrow_t&);
-def msvc_delete_ptr64_nothrow
- : TargetLibCall<"??3 at YAXPEAXAEBUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
+def TLI_msvc_delete_ptr64_nothrow
+ : TargetLibCall_R<__3_YAXPEAXAEBUnothrow_t_std___Z>;
/// void operator delete(void*, unsigned long long);
-def msvc_delete_ptr64_longlong
- : TargetLibCall<"??3 at YAXPEAX_K@Z", Void, [Ptr, LLong]>;
+def TLI_msvc_delete_ptr64_longlong : TargetLibCall_R<__3_YAXPEAX_K_Z>;
/// void *operator new[](unsigned int);
-def msvc_new_array_int : TargetLibCall<"??_U at YAPAXI@Z", Ptr, [Int]>;
+def TLI_msvc_new_array_int : TargetLibCall_R<___U_YAPAXI_Z>;
/// void *operator new](unsigned int, [const std::nothrow_t&);
-def msvc_new_array_int_nothrow
- : TargetLibCall<"??_U at YAPAXIABUnothrow_t@std@@@Z", Ptr, [Int, Ptr]>;
+def TLI_msvc_new_array_int_nothrow
+ : TargetLibCall_R<___U_YAPAXIABUnothrow_t_std___Z>;
/// void *operator new[](unsigned long long);
-def msvc_new_array_longlong : TargetLibCall<"??_U at YAPEAX_K@Z", Ptr, [LLong]>;
+def TLI_msvc_new_array_longlong : TargetLibCall_R<___U_YAPEAX_K_Z>;
/// void *operator new](unsigned long long, [const std::nothrow_t&);
-def msvc_new_array_longlong_nothrow
- : TargetLibCall<"??_U at YAPEAX_KAEBUnothrow_t@std@@@Z", Ptr, [LLong, Ptr]>;
+def TLI_msvc_new_array_longlong_nothrow
+ : TargetLibCall_R<___U_YAPEAX_KAEBUnothrow_t_std___Z>;
/// void operator delete[](void*);
-def msvc_delete_array_ptr32 : TargetLibCall<"??_V at YAXPAX@Z", Void, [Ptr]>;
+def TLI_msvc_delete_array_ptr32 : TargetLibCall_R<___V_YAXPAX_Z>;
/// void operator delete](void*, [const std::nothrow_t&);
-def msvc_delete_array_ptr32_nothrow
- : TargetLibCall<"??_V at YAXPAXABUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
+def TLI_msvc_delete_array_ptr32_nothrow
+ : TargetLibCall_R<___V_YAXPAXABUnothrow_t_std___Z>;
/// void operator delete](void*, [unsigned int);
-def msvc_delete_array_ptr32_int
- : TargetLibCall<"??_V at YAXPAXI@Z", Void, [Ptr, Int]>;
+def TLI_msvc_delete_array_ptr32_int : TargetLibCall_R<___V_YAXPAXI_Z>;
/// void operator delete[](void*);
-def msvc_delete_array_ptr64 : TargetLibCall<"??_V at YAXPEAX@Z", Void, [Ptr]>;
+def TLI_msvc_delete_array_ptr64 : TargetLibCall_R<___V_YAXPEAX_Z>;
/// void operator delete](void*, [const std::nothrow_t&);
-def msvc_delete_array_ptr64_nothrow
- : TargetLibCall<"??_V at YAXPEAXAEBUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
+def TLI_msvc_delete_array_ptr64_nothrow
+ : TargetLibCall_R<___V_YAXPEAXAEBUnothrow_t_std___Z>;
/// void operator delete](void*, [unsigned long long);
-def msvc_delete_array_ptr64_longlong
- : TargetLibCall<"??_V at YAXPEAX_K@Z", Void, [Ptr, LLong]>;
+def TLI_msvc_delete_array_ptr64_longlong : TargetLibCall_R<___V_YAXPEAX_K_Z>;
/// int _IO_getc(_IO_FILE * __fp);
-def under_IO_getc : TargetLibCall<"_IO_getc", Int, [Ptr]>;
+def TLI_under_IO_getc : TargetLibCall_R<_IO_getc>;
/// int _IO_putc(int __c, _IO_FILE * __fp);
-def under_IO_putc : TargetLibCall<"_IO_putc", Int, [Int, Ptr]>;
+def TLI_under_IO_putc : TargetLibCall_R<_IO_putc>;
/// void operator delete[](void*);
-def ZdaPv : TargetLibCall<"_ZdaPv", Void, [Ptr]>;
+def TLI_ZdaPv : TargetLibCall_R<_ZdaPv>;
/// void operator delete](void*, [const std::nothrow_t&);
-def ZdaPvRKSt9nothrow_t
- : TargetLibCall<"_ZdaPvRKSt9nothrow_t", Void, [Ptr, Ptr]>;
+def TLI_ZdaPvRKSt9nothrow_t : TargetLibCall_R<_ZdaPvRKSt9nothrow_t>;
/// void operator delete](void*, [std::align_val_t);
-def ZdaPvSt11align_val_t
- : TargetLibCall<"_ZdaPvSt11align_val_t", Void, [Ptr, IntPlus]>;
+def TLI_ZdaPvSt11align_val_t : TargetLibCall_R<_ZdaPvSt11align_val_t>;
/// void operator delete](void*, [std::align_val_t, const std::nothrow_t&)
-def ZdaPvSt11align_val_tRKSt9nothrow_t
- : TargetLibCall<"_ZdaPvSt11align_val_tRKSt9nothrow_t",
- Void, [Ptr, IntPlus, Ptr]>;
+def TLI_ZdaPvSt11align_val_tRKSt9nothrow_t
+ : TargetLibCall_R<_ZdaPvSt11align_val_tRKSt9nothrow_t>;
/// void operator delete](void*, [unsigned int);
-def ZdaPvj : TargetLibCall<"_ZdaPvj", Void, [Ptr, Int]>;
+def TLI_ZdaPvj : TargetLibCall_R<_ZdaPvj>;
/// void operator delete](void*, [unsigned int, std::align_val_t);
-def ZdaPvjSt11align_val_t
- : TargetLibCall<"_ZdaPvjSt11align_val_t", Void, [Ptr, Int, Int]>;
+def TLI_ZdaPvjSt11align_val_t : TargetLibCall_R<_ZdaPvjSt11align_val_t>;
/// void operator delete](void*, [unsigned long);
-def ZdaPvm : TargetLibCall<"_ZdaPvm", Void, [Ptr, Long]>;
+def TLI_ZdaPvm : TargetLibCall_R<_ZdaPvm>;
/// void operator delete](void*, [unsigned long, std::align_val_t);
-def ZdaPvmSt11align_val_t
- : TargetLibCall<"_ZdaPvmSt11align_val_t", Void, [Ptr, Long, Long]>;
+def TLI_ZdaPvmSt11align_val_t : TargetLibCall_R<_ZdaPvmSt11align_val_t>;
/// void operator delete(void*);
-def ZdlPv : TargetLibCall<"_ZdlPv", Void, [Ptr]>;
+def TLI_ZdlPv : TargetLibCall_R<_ZdlPv>;
/// void operator delete(void*, const std::nothrow_t&);
-def ZdlPvRKSt9nothrow_t
- : TargetLibCall<"_ZdlPvRKSt9nothrow_t", Void, [Ptr, Ptr]>;
+def TLI_ZdlPvRKSt9nothrow_t : TargetLibCall_R<_ZdlPvRKSt9nothrow_t>;
/// void operator delete(void*, std::align_val_t)
-def ZdlPvSt11align_val_t
- : TargetLibCall<"_ZdlPvSt11align_val_t", Void, [Ptr, IntPlus]>;
+def TLI_ZdlPvSt11align_val_t : TargetLibCall_R<_ZdlPvSt11align_val_t>;
/// void operator delete(void*, std::align_val_t, const std::nothrow_t&)
-def ZdlPvSt11align_val_tRKSt9nothrow_t
- : TargetLibCall<"_ZdlPvSt11align_val_tRKSt9nothrow_t",
- Void, [Ptr, IntPlus, Ptr]>;
+def TLI_ZdlPvSt11align_val_tRKSt9nothrow_t
+ : TargetLibCall_R<_ZdlPvSt11align_val_tRKSt9nothrow_t>;
/// void operator delete(void*, unsigned int);
-def ZdlPvj : TargetLibCall<"_ZdlPvj", Void, [Ptr, Int]>;
+def TLI_ZdlPvj : TargetLibCall_R<_ZdlPvj>;
/// void operator delete(void*, unsigned int, std::align_val_t)
-def ZdlPvjSt11align_val_t
- : TargetLibCall<"_ZdlPvjSt11align_val_t", Void, [Ptr, Int, Int]>;
+def TLI_ZdlPvjSt11align_val_t : TargetLibCall_R<_ZdlPvjSt11align_val_t>;
/// void operator delete(void*, unsigned long);
-def ZdlPvm : TargetLibCall<"_ZdlPvm", Void, [Ptr, Long]>;
+def TLI_ZdlPvm : TargetLibCall_R<_ZdlPvm>;
/// void operator delete(void*, unsigned long, std::align_val_t)
-def ZdlPvmSt11align_val_t
- : TargetLibCall<"_ZdlPvmSt11align_val_t", Void, [Ptr, Long, Long]>;
+def TLI_ZdlPvmSt11align_val_t : TargetLibCall_R<_ZdlPvmSt11align_val_t>;
/// void *operator new[](unsigned int);
-def Znaj : TargetLibCall<"_Znaj", Ptr, [Int]>;
+def TLI_Znaj : TargetLibCall_R<_Znaj>;
/// void *operator new](unsigned int, [const std::nothrow_t&);
-def ZnajRKSt9nothrow_t : TargetLibCall<"_ZnajRKSt9nothrow_t", Ptr, [Int, Ptr]>;
+def TLI_ZnajRKSt9nothrow_t : TargetLibCall_R<_ZnajRKSt9nothrow_t>;
/// void *operator new](unsigned int, [std::align_val_t)
-def ZnajSt11align_val_t
- : TargetLibCall<"_ZnajSt11align_val_t", Ptr, [Int, Int]>;
+def TLI_ZnajSt11align_val_t : TargetLibCall_R<_ZnajSt11align_val_t>;
/// void *operator new](unsigned int, [std::align_val_t, const std::nothrow_t&)
-def ZnajSt11align_val_tRKSt9nothrow_t
- : TargetLibCall<"_ZnajSt11align_val_tRKSt9nothrow_t", Ptr, [Int, Int, Ptr]>;
+def TLI_ZnajSt11align_val_tRKSt9nothrow_t
+ : TargetLibCall_R<_ZnajSt11align_val_tRKSt9nothrow_t>;
/// void *operator new[](unsigned long);
-def Znam : TargetLibCall<"_Znam", Ptr, [Long]>;
+def TLI_Znam : TargetLibCall_R<_Znam>;
/// void *operator new](unsigned long, [__hot_cold_t)
/// Currently this and other operator new interfaces that take a __hot_cold_t
@@ -168,85 +153,72 @@ def Znam : TargetLibCall<"_Znam", Ptr, [Long]>;
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
/// and for the definition of the __hot_cold_t parameter see:
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
-def Znam12__hot_cold_t
- : TargetLibCall<"_Znam12__hot_cold_t", Ptr, [Long, Bool]>;
+def TLI_Znam12__hot_cold_t : TargetLibCall_R<_Znam12__hot_cold_t>;
/// void *operator new](unsigned long, [const std::nothrow_t&);
-def ZnamRKSt9nothrow_t : TargetLibCall<"_ZnamRKSt9nothrow_t", Ptr, [Long, Ptr]>;
+def TLI_ZnamRKSt9nothrow_t : TargetLibCall_R<_ZnamRKSt9nothrow_t>;
/// void *operator new](unsigned long, [const std::nothrow_t&, __hot_cold_t)
-def ZnamRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall<"_ZnamRKSt9nothrow_t12__hot_cold_t",
- Ptr, [Long, Ptr, Bool]>;
+def TLI_ZnamRKSt9nothrow_t12__hot_cold_t
+ : TargetLibCall_R<_ZnamRKSt9nothrow_t12__hot_cold_t>;
/// void *operator new](unsigned long, [std::align_val_t)
-def ZnamSt11align_val_t
- : TargetLibCall<"_ZnamSt11align_val_t", Ptr, [Long, Long]>;
+def TLI_ZnamSt11align_val_t : TargetLibCall_R<_ZnamSt11align_val_t>;
/// void *operator new](unsigned long, [std::align_val_t, __hot_cold_t)
-def ZnamSt11align_val_t12__hot_cold_t
- : TargetLibCall<"_ZnamSt11align_val_t12__hot_cold_t",
- Ptr, [Long, Long, Bool]>;
+def TLI_ZnamSt11align_val_t12__hot_cold_t
+ : TargetLibCall_R<_ZnamSt11align_val_t12__hot_cold_t>;
/// void *operator new](unsigned long, [std::align_val_t, const std::nothrow_t&)
-def ZnamSt11align_val_tRKSt9nothrow_t
- : TargetLibCall<"_ZnamSt11align_val_tRKSt9nothrow_t",
- Ptr, [Long, Long, Ptr]>;
+def TLI_ZnamSt11align_val_tRKSt9nothrow_t
+ : TargetLibCall_R<_ZnamSt11align_val_tRKSt9nothrow_t>;
/// void *operator new](unsigned long, [std::align_val_t, const std::nothrow_t&,
/// __hot_cold_t)
-def ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall<"_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t",
- Ptr, [Long, Long, Ptr, Bool]>;
+def TLI_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t
+ : TargetLibCall_R<_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t>;
/// void *operator new(unsigned int);
-def Znwj : TargetLibCall<"_Znwj", Ptr, [Int]>;
+def TLI_Znwj : TargetLibCall_R<_Znwj>;
/// void *operator new(unsigned int, const std::nothrow_t&);
-def ZnwjRKSt9nothrow_t : TargetLibCall<"_ZnwjRKSt9nothrow_t", Ptr, [Int, Ptr]>;
+def TLI_ZnwjRKSt9nothrow_t : TargetLibCall_R<_ZnwjRKSt9nothrow_t>;
/// void *operator new(unsigned int, std::align_val_t)
-def ZnwjSt11align_val_t
- : TargetLibCall<"_ZnwjSt11align_val_t", Ptr, [Int, Int]>;
+def TLI_ZnwjSt11align_val_t : TargetLibCall_R<_ZnwjSt11align_val_t>;
/// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&)
-def ZnwjSt11align_val_tRKSt9nothrow_t
- : TargetLibCall<"_ZnwjSt11align_val_tRKSt9nothrow_t", Ptr, [Int, Int, Ptr]>;
+def TLI_ZnwjSt11align_val_tRKSt9nothrow_t
+ : TargetLibCall_R<_ZnwjSt11align_val_tRKSt9nothrow_t>;
/// void *operator new(unsigned long);
-def Znwm : TargetLibCall<"_Znwm", Ptr, [Long]>;
+def TLI_Znwm : TargetLibCall_R<_Znwm>;
/// void *operator new(unsigned long, __hot_cold_t)
-def Znwm12__hot_cold_t
- : TargetLibCall<"_Znwm12__hot_cold_t", Ptr, [Long, Bool]>;
+def TLI_Znwm12__hot_cold_t : TargetLibCall_R<_Znwm12__hot_cold_t>;
/// void *operator new(unsigned long, const std::nothrow_t&);
-def ZnwmRKSt9nothrow_t : TargetLibCall<"_ZnwmRKSt9nothrow_t", Ptr, [Long, Ptr]>;
+def TLI_ZnwmRKSt9nothrow_t : TargetLibCall_R<_ZnwmRKSt9nothrow_t>;
/// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
-def ZnwmRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall<"_ZnwmRKSt9nothrow_t12__hot_cold_t",
- Ptr, [Long, Ptr, Bool]>;
+def TLI_ZnwmRKSt9nothrow_t12__hot_cold_t
+ : TargetLibCall_R<_ZnwmRKSt9nothrow_t12__hot_cold_t>;
/// void *operator new(unsigned long, std::align_val_t)
-def ZnwmSt11align_val_t
- : TargetLibCall<"_ZnwmSt11align_val_t", Ptr, [Long, Long]>;
+def TLI_ZnwmSt11align_val_t : TargetLibCall_R<_ZnwmSt11align_val_t>;
/// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
-def ZnwmSt11align_val_t12__hot_cold_t
- : TargetLibCall<"_ZnwmSt11align_val_t12__hot_cold_t",
- Ptr, [Long, Long, Bool]>;
+def TLI_ZnwmSt11align_val_t12__hot_cold_t
+ : TargetLibCall_R<_ZnwmSt11align_val_t12__hot_cold_t>;
/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
-def ZnwmSt11align_val_tRKSt9nothrow_t
- : TargetLibCall<"_ZnwmSt11align_val_tRKSt9nothrow_t",
- Ptr, [Long, Long, Ptr]>;
+def TLI_ZnwmSt11align_val_tRKSt9nothrow_t
+ : TargetLibCall_R<_ZnwmSt11align_val_tRKSt9nothrow_t>;
/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&,
/// __hot_cold_t)
-def ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall<"_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t",
- Ptr, [Long, Long, Ptr, Bool]>;
+def TLI_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t
+ : TargetLibCall_R<_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t>;
/// The following are variants of operator new which return the actual size
/// reserved by the allocator proposed in P0901R5 (Size feedback in operator
@@ -255,1436 +227,1425 @@ def ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
/// __sized_ptr_t __size_returning_new(size_t size)
-def size_returning_new
- : TargetLibCall<"__size_returning_new", ? /* Checked manually. */>;
+def TLI_size_returning_new : TargetLibCall_R<__size_returning_new>;
/// __sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t)
-def size_returning_new_hot_cold
- : TargetLibCall<"__size_returning_new_hot_cold", ? /* Checked manually. */>;
+def TLI_size_returning_new_hot_cold
+ : TargetLibCall_R<__size_returning_new_hot_cold>;
/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t)
-def size_returning_new_aligned
- : TargetLibCall<"__size_returning_new_aligned", ? /* Checked manually. */>;
+def TLI_size_returning_new_aligned
+ : TargetLibCall_R<__size_returning_new_aligned>;
/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t,
/// __hot_cold_t)
-def size_returning_new_aligned_hot_cold
- : TargetLibCall<"__size_returning_new_aligned_hot_cold",
- ? /* Checked manually. */>;
+def TLI_size_returning_new_aligned_hot_cold
+ : TargetLibCall_R<__size_returning_new_aligned_hot_cold>;
/// double __acos_finite(double x);
-def acos_finite : TargetLibCall<"__acos_finite", Dbl, [Dbl]>;
+def TLI_acos_finite : TargetLibCall_D<"__acos_finite", Dbl, [Dbl]>;
/// float __acosf_finite(float x);
-def acosf_finite : TargetLibCall<"__acosf_finite", Flt, [Flt]>;
+def TLI_acosf_finite : TargetLibCall_D<"__acosf_finite", Flt, [Flt]>;
/// double __acosh_finite(double x);
-def acosh_finite : TargetLibCall<"__acosh_finite", Dbl, [Dbl]>;
+def TLI_acosh_finite : TargetLibCall_D<"__acosh_finite", Dbl, [Dbl]>;
/// float __acoshf_finite(float x);
-def acoshf_finite : TargetLibCall<"__acoshf_finite", Flt, [Flt]>;
+def TLI_acoshf_finite : TargetLibCall_D<"__acoshf_finite", Flt, [Flt]>;
/// long double __acoshl_finite(long double x);
-def acoshl_finite : TargetLibCall<"__acoshl_finite", LDbl, [LDbl]>;
+def TLI_acoshl_finite : TargetLibCall_D<"__acoshl_finite", LDbl, [LDbl]>;
/// long double __acosl_finite(long double x);
-def acosl_finite : TargetLibCall<"__acosl_finite", LDbl, [LDbl]>;
+def TLI_acosl_finite : TargetLibCall_D<"__acosl_finite", LDbl, [LDbl]>;
/// double __asin_finite(double x);
-def asin_finite : TargetLibCall<"__asin_finite", Dbl, [Dbl]>;
+def TLI_asin_finite : TargetLibCall_D<"__asin_finite", Dbl, [Dbl]>;
/// float __asinf_finite(float x);
-def asinf_finite : TargetLibCall<"__asinf_finite", Flt, [Flt]>;
+def TLI_asinf_finite : TargetLibCall_D<"__asinf_finite", Flt, [Flt]>;
/// long double __asinl_finite(long double x);
-def asinl_finite : TargetLibCall<"__asinl_finite", LDbl, [LDbl]>;
+def TLI_asinl_finite : TargetLibCall_D<"__asinl_finite", LDbl, [LDbl]>;
/// double atan2_finite(double y, double x);
-def atan2_finite : TargetLibCall<"__atan2_finite", Dbl, [Dbl, Dbl]>;
+def TLI_atan2_finite : TargetLibCall_D<"__atan2_finite", Dbl, [Dbl, Dbl]>;
/// float atan2f_finite(float y, float x);
-def atan2f_finite : TargetLibCall<"__atan2f_finite", Flt, [Flt, Flt]>;
+def TLI_atan2f_finite : TargetLibCall_D<"__atan2f_finite", Flt, [Flt, Flt]>;
/// long double atan2l_finite(long double y, long double x);
-def atan2l_finite : TargetLibCall<"__atan2l_finite", LDbl, [LDbl, LDbl]>;
+def TLI_atan2l_finite : TargetLibCall_D<"__atan2l_finite", LDbl, [LDbl, LDbl]>;
/// double __atanh_finite(double x);
-def atanh_finite : TargetLibCall<"__atanh_finite", Dbl, [Dbl]>;
+def TLI_atanh_finite : TargetLibCall_D<"__atanh_finite", Dbl, [Dbl]>;
/// float __atanhf_finite(float x);
-def atanhf_finite : TargetLibCall<"__atanhf_finite", Flt, [Flt]>;
+def TLI_atanhf_finite : TargetLibCall_D<"__atanhf_finite", Flt, [Flt]>;
/// long double __atanhl_finite(long double x);
-def atanhl_finite : TargetLibCall<"__atanhl_finite", LDbl, [LDbl]>;
+def TLI_atanhl_finite : TargetLibCall_D<"__atanhl_finite", LDbl, [LDbl]>;
/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
-def atomic_load : TargetLibCall<"__atomic_load", Void, [SizeT, Ptr, Ptr, Int]>;
+def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
-def atomic_store
- : TargetLibCall<"__atomic_store", Void, [SizeT, Ptr, Ptr, Int]>;
+def TLI_atomic_store : TargetLibCall_R<__atomic_store>;
/// double __cosh_finite(double x);
-def cosh_finite : TargetLibCall<"__cosh_finite", Dbl, [Dbl]>;
+def TLI_cosh_finite : TargetLibCall_D<"__cosh_finite", Dbl, [Dbl]>;
/// float __coshf_finite(float x);
-def coshf_finite : TargetLibCall<"__coshf_finite", Flt, [Flt]>;
+def TLI_coshf_finite : TargetLibCall_D<"__coshf_finite", Flt, [Flt]>;
/// long double __coshl_finite(long double x);
-def coshl_finite : TargetLibCall<"__coshl_finite", LDbl, [LDbl]>;
+def TLI_coshl_finite : TargetLibCall_D<"__coshl_finite", LDbl, [LDbl]>;
/// double __cospi(double x);
-def cospi : TargetLibCall<"__cospi", Dbl, [Dbl]>;
+def TLI_cospi : TargetLibCall_D<"__cospi", Dbl, [Dbl]>;
/// float __cospif(float x);
-def cospif : TargetLibCall<"__cospif", Flt, [Flt]>;
+def TLI_cospif : TargetLibCall_D<"__cospif", Flt, [Flt]>;
/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
-def cxa_atexit : TargetLibCall<"__cxa_atexit", Int, [Ptr, Ptr, Ptr]>;
+def TLI_cxa_atexit : TargetLibCall_R<__cxa_atexit>;
/// int atexit(void (*f)(void));
-def atexit : TargetLibCall<"atexit", Int, [Ptr]>;
+def TLI_atexit : TargetLibCall_R<atexit>;
/// void abort(void)
-def abort : TargetLibCall<"abort", Void, []>;
+def TLI_abort : TargetLibCall_R<abort>;
/// void exit(int)
-def exit : TargetLibCall<"exit", Void, [Int]>;
+def TLI_exit : TargetLibCall_R<exit>;
/// void _Exit(int)
-def Exit : TargetLibCall<"_Exit", Void, [Int]>;
+def TLI_Exit : TargetLibCall_D<"_Exit", Void, [Int]>;
/// void std::terminate();
-def terminate : TargetLibCall<"_ZSt9terminatev", Void, []>;
+def TLI_terminate : TargetLibCall_R<_ZSt9terminatev>;
/// void __cxa_throw(void *, void *, void (*)(void *));
-def cxa_throw : TargetLibCall<"__cxa_throw", Void, [Ptr, Ptr, Ptr]>;
+def TLI_cxa_throw : TargetLibCall_R<__cxa_throw>;
/// void __cxa_guard_abort(guard_t *guard);
/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
-def cxa_guard_abort : TargetLibCall<"__cxa_guard_abort", Void, [Ptr]>;
+def TLI_cxa_guard_abort : TargetLibCall_R<__cxa_guard_abort>;
/// int __cxa_guard_acquire(guard_t *guard);
-def cxa_guard_acquire : TargetLibCall<"__cxa_guard_acquire", Int, [Ptr]>;
+def TLI_cxa_guard_acquire : TargetLibCall_R<__cxa_guard_acquire>;
/// void __cxa_guard_release(guard_t *guard);
-def cxa_guard_release : TargetLibCall<"__cxa_guard_release", Void, [Ptr]>;
+def TLI_cxa_guard_release : TargetLibCall_R<__cxa_guard_release>;
/// double __exp10_finite(double x);
-def exp10_finite : TargetLibCall<"__exp10_finite", Dbl, [Dbl]>;
+def TLI_exp10_finite : TargetLibCall_D<"__exp10_finite", Dbl, [Dbl]>;
+
/// float __exp10f_finite(float x);
-def exp10f_finite : TargetLibCall<"__exp10f_finite", Flt, [Flt]>;
+def TLI_exp10f_finite : TargetLibCall_D<"__exp10f_finite", Flt, [Flt]>;
/// long double __exp10l_finite(long double x);
-def exp10l_finite : TargetLibCall<"__exp10l_finite", LDbl, [LDbl]>;
+def TLI_exp10l_finite : TargetLibCall_D<"__exp10l_finite", LDbl, [LDbl]>;
/// double __exp2_finite(double x);
-def exp2_finite : TargetLibCall<"__exp2_finite", Dbl, [Dbl]>;
+def TLI_exp2_finite : TargetLibCall_R<__exp2_finite>;
/// float __exp2f_finite(float x);
-def exp2f_finite : TargetLibCall<"__exp2f_finite", Flt, [Flt]>;
+def TLI_exp2f_finite : TargetLibCall_R<__exp2f_finite>;
/// long double __exp2l_finite(long double x);
-def exp2l_finite : TargetLibCall<"__exp2l_finite", LDbl, [LDbl]>;
+def TLI_exp2l_finite : TargetLibCall_R<__exp2l_finite_f128>;
/// double __exp_finite(double x);
-def exp_finite : TargetLibCall<"__exp_finite", Dbl, [Dbl]>;
+def TLI_exp_finite : TargetLibCall_R<__exp_finite>;
/// float __expf_finite(float x);
-def expf_finite : TargetLibCall<"__expf_finite", Flt, [Flt]>;
+def TLI_expf_finite : TargetLibCall_R<__expf_finite>;
/// long double __expl_finite(long double x);
-def expl_finite : TargetLibCall<"__expl_finite", LDbl, [LDbl]>;
+def TLI_expl_finite : TargetLibCall_R<__expl_finite_f128>;
/// int __isoc99_scanf (const char *format, ...)
-def dunder_isoc99_scanf : TargetLibCall<"__isoc99_scanf", Int, [Ptr, Ellip]>;
+def TLI_dunder_isoc99_scanf : TargetLibCall_R<__isoc99_scanf>;
/// int __isoc99_sscanf(const char *s, const char *format, ...)
-def dunder_isoc99_sscanf
- : TargetLibCall<"__isoc99_sscanf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_dunder_isoc99_sscanf : TargetLibCall_R<__isoc99_sscanf>;
/// double __log10_finite(double x);
-def log10_finite : TargetLibCall<"__log10_finite", Dbl, [Dbl]>;
+def TLI_log10_finite : TargetLibCall_R<__log10_finite>;
/// float __log10f_finite(float x);
-def log10f_finite : TargetLibCall<"__log10f_finite", Flt, [Flt]>;
+def TLI_log10f_finite : TargetLibCall_R<__log10f_finite>;
/// long double __log10l_finite(long double x);
-def log10l_finite : TargetLibCall<"__log10l_finite", LDbl, [LDbl]>;
+def TLI_log10l_finite : TargetLibCall_R<__log10l_finite_f128>;
/// double __log2_finite(double x);
-def log2_finite : TargetLibCall<"__log2_finite", Dbl, [Dbl]>;
+def TLI_log2_finite : TargetLibCall_R<__log2_finite>;
/// float __log2f_finite(float x);
-def log2f_finite : TargetLibCall<"__log2f_finite", Flt, [Flt]>;
+def TLI_log2f_finite : TargetLibCall_R<__log2f_finite>;
/// long double __log2l_finite(long double x);
-def log2l_finite : TargetLibCall<"__log2l_finite", LDbl, [LDbl]>;
+def TLI_log2l_finite : TargetLibCall_R<__log2l_finite_f128>;
/// double __log_finite(double x);
-def log_finite : TargetLibCall<"__log_finite", Dbl, [Dbl]>;
+def TLI_log_finite : TargetLibCall_R<__log_finite>;
/// float __logf_finite(float x);
-def logf_finite : TargetLibCall<"__logf_finite", Flt, [Flt]>;
+def TLI_logf_finite : TargetLibCall_R<__logf_finite>;
/// long double __logl_finite(long double x);
-def logl_finite : TargetLibCall<"__logl_finite", LDbl, [LDbl]>;
+def TLI_logl_finite : TargetLibCall_R<__logl_finite_f128>;
/// void *__memccpy_chk(void *dst, const void *src, int c, size_t n,
/// size_t dstsize)
-def memccpy_chk
- : TargetLibCall<"__memccpy_chk", Ptr, [Ptr, Ptr, Int, SizeT, SizeT]>;
+def TLI_memccpy_chk : TargetLibCall_R<__memccpy_chk>;
/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-def memcpy_chk : TargetLibCall<"__memcpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_memcpy_chk : TargetLibCall_R<__memcpy_chk>;
/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
-def memmove_chk : TargetLibCall<"__memmove_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_memmove_chk : TargetLibCall_R<__memmove_chk>;
/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-def mempcpy_chk : TargetLibCall<"__mempcpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_mempcpy_chk : TargetLibCall_R<__mempcpy_chk>;
/// void *__memset_chk(void *s, int v, size_t n, size_t s1size);
-def memset_chk : TargetLibCall<"__memset_chk", Ptr, [Ptr, Int, SizeT, SizeT]>;
+def TLI_memset_chk : TargetLibCall_R<__memset_chk>;
// int __nvvm_reflect(const char *)
-def nvvm_reflect : TargetLibCall<"__nvvm_reflect", Int, [Ptr]>;
+def TLI_nvvm_reflect : TargetLibCall_D<"__nvvm_reflect", Int, [Ptr]>;
/// double __pow_finite(double x, double y);
-def pow_finite : TargetLibCall<"__pow_finite", Dbl, [Dbl, Dbl]>;
+def TLI_pow_finite : TargetLibCall_R<__pow_finite>;
/// float _powf_finite(float x, float y);
-def powf_finite : TargetLibCall<"__powf_finite", Flt, [Flt, Flt]>;
+def TLI_powf_finite : TargetLibCall_R<__powf_finite>;
/// long double __powl_finite(long double x, long double y);
-def powl_finite : TargetLibCall<"__powl_finite", LDbl, [LDbl, LDbl]>;
+def TLI_powl_finite : TargetLibCall_R<__powl_finite_f128>;
/// double __sincospi_stret(double x);
-def sincospi_stret
- : TargetLibCall<"__sincospi_stret", ? /* Checked manually. */>;
+def TLI_sincospi_stret
+ : TargetLibCall_D<"__sincospi_stret", ? /* Checked manually. */>;
/// float __sincospif_stret(float x);
-def sincospif_stret
- : TargetLibCall<"__sincospif_stret", ? /* Checked manually. */>;
+def TLI_sincospif_stret
+ : TargetLibCall_D<"__sincospif_stret", ? /* Checked manually. */>;
/// double __sinh_finite(double x);
-def sinh_finite : TargetLibCall<"__sinh_finite", Dbl, [Dbl]>;
+def TLI_sinh_finite : TargetLibCall_D<"__sinh_finite", Dbl, [Dbl]>;
/// float _sinhf_finite(float x);
-def sinhf_finite : TargetLibCall<"__sinhf_finite", Flt, [Flt]>;
+def TLI_sinhf_finite : TargetLibCall_D<"__sinhf_finite", Flt, [Flt]>;
/// long double __sinhl_finite(long double x);
-def sinhl_finite : TargetLibCall<"__sinhl_finite", LDbl, [LDbl]>;
+def TLI_sinhl_finite : TargetLibCall_D<"__sinhl_finite", LDbl, [LDbl]>;
/// double __sinpi(double x);
-def sinpi : TargetLibCall<"__sinpi", Dbl, [Dbl]>;
+def TLI_sinpi : TargetLibCall_D<"__sinpi", Dbl, [Dbl]>;
/// float __sinpif(float x);
-def sinpif : TargetLibCall<"__sinpif", Flt, [Flt]>;
+def TLI_sinpif : TargetLibCall_D<"__sinpif", Flt, [Flt]>;
/// int __small_fprintf(FILE *stream, const char *format, ...);
-def small_fprintf : TargetLibCall<"__small_fprintf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_small_fprintf : TargetLibCall_R<__small_fprintf>;
/// int __small_printf(const char *format, ...);
-def small_printf : TargetLibCall<"__small_printf", Int, [Ptr, Ellip]>;
+def TLI_small_printf : TargetLibCall_R<__small_printf>;
/// int __small_sprintf(char *str, const char *format, ...);
-def small_sprintf : TargetLibCall<"__small_sprintf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_small_sprintf : TargetLibCall_R<__small_sprintf>;
/// int __snprintf_chk(char *s, size_t n, int flags, size_t slen,
/// const char *format, ...);
-def snprintf_chk : TargetLibCall<"__snprintf_chk",
- Int, [Ptr, SizeT, Int, SizeT, Ptr, Ellip]>;
+def TLI_snprintf_chk : TargetLibCall_R<__snprintf_chk>;
/// int __sprintf_chk(char *str, int flags, size_t str_len,
/// const char *format, ...);
-def sprintf_chk
- : TargetLibCall<"__sprintf_chk", Int, [Ptr, Int, SizeT, Ptr, Ellip]>;
+def TLI_sprintf_chk : TargetLibCall_R<__sprintf_chk>;
/// double __sqrt_finite(double x);
-def sqrt_finite : TargetLibCall<"__sqrt_finite", Dbl, [Dbl]>;
+def TLI_sqrt_finite : TargetLibCall_D<"__sqrt_finite", Dbl, [Dbl]>;
/// float __sqrt_finite(float x);
-def sqrtf_finite : TargetLibCall<"__sqrtf_finite", Flt, [Flt]>;
+def TLI_sqrtf_finite : TargetLibCall_D<"__sqrtf_finite", Flt, [Flt]>;
/// long double __sqrt_finite(long double x);
-def sqrtl_finite : TargetLibCall<"__sqrtl_finite", LDbl, [LDbl]>;
+def TLI_sqrtl_finite : TargetLibCall_D<"__sqrtl_finite", LDbl, [LDbl]>;
/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
-def stpcpy_chk : TargetLibCall<"__stpcpy_chk", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_stpcpy_chk : TargetLibCall_R<__stpcpy_chk>;
/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
-def stpncpy_chk : TargetLibCall<"__stpncpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_stpncpy_chk : TargetLibCall_R<__stpncpy_chk>;
/// char *__strcat_chk(char *s1, const char *s2, size_t s1size);
-def strcat_chk : TargetLibCall<"__strcat_chk", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_strcat_chk : TargetLibCall_R<__strcat_chk>;
/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
-def strcpy_chk : TargetLibCall<"__strcpy_chk", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_strcpy_chk : TargetLibCall_R<__strcpy_chk>;
/// char * __strdup(const char *s);
-def dunder_strdup : TargetLibCall<"__strdup", Ptr, [Ptr]>;
+def TLI_dunder_strdup : TargetLibCall_R<__strdup>;
/// size_t __strlcat_chk(char *dst, const char *src, size_t size,
/// size_t dstsize);
-def strlcat_chk
- : TargetLibCall<"__strlcat_chk", SizeT, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_strlcat_chk : TargetLibCall_R<__strlcat_chk>;
/// size_t __strlcpy_chk(char *dst, const char *src, size_t size,
/// size_t dstsize);
-def strlcpy_chk
- : TargetLibCall<"__strlcpy_chk", SizeT, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_strlcpy_chk : TargetLibCall_R<__strlcpy_chk>;
/// size_t __strlen_chk(const char *s1, size_t s1size);
-def strlen_chk : TargetLibCall<"__strlen_chk", SizeT, [Ptr, SizeT]>;
+def TLI_strlen_chk : TargetLibCall_R<__strlen_chk>;
/// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
-def strncat_chk : TargetLibCall<"__strncat_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_strncat_chk : TargetLibCall_R<__strncat_chk>;
/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
-def strncpy_chk : TargetLibCall<"__strncpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def TLI_strncpy_chk : TargetLibCall_R<__strncpy_chk>;
/// char *__strndup(const char *s, size_t n);
-def dunder_strndup : TargetLibCall<"__strndup", Ptr, [Ptr, SizeT]>;
+def TLI_dunder_strndup : TargetLibCall_R<__strndup>;
/// char * __strtok_r(char *s, const char *delim, char **save_ptr);
-def dunder_strtok_r : TargetLibCall<"__strtok_r", Ptr, [Ptr, Ptr, Ptr]>;
+def TLI_dunder_strtok_r : TargetLibCall_R<__strtok_r>;
/// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen,
/// const char *format, va_list ap);
-def vsnprintf_chk
- : TargetLibCall<"__vsnprintf_chk", Int, [Ptr, SizeT, Int, SizeT, Ptr, Ptr]>;
+def TLI_vsnprintf_chk : TargetLibCall_R<__vsnprintf_chk>;
/// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format,
/// va_list ap);
-def vsprintf_chk
- : TargetLibCall<"__vsprintf_chk", Int, [Ptr, Int, SizeT, Ptr, Ptr]>;
+def TLI_vsprintf_chk : TargetLibCall_R<__vsprintf_chk>;
/// int abs(int j);
-def abs : TargetLibCall<"abs", Int, [Int]>;
+def TLI_abs : TargetLibCall_R<abs>;
/// int access(const char *path, int amode);
-def access : TargetLibCall<"access", Int, [Ptr, Int]>;
+def TLI_access : TargetLibCall_R<access>;
/// double acos(double x);
-def acos : TargetLibCall<"acos", Dbl, [Dbl]>;
+def TLI_acos : TargetLibCall_R<acos>;
/// float acosf(float x);
-def acosf : TargetLibCall<"acosf", Flt, [Flt]>;
+def TLI_acosf : TargetLibCall_R<acosf>;
/// double acosh(double x);
-def acosh : TargetLibCall<"acosh", Dbl, [Dbl]>;
+def TLI_acosh : TargetLibCall_D<"acosh", Dbl, [Dbl]>;
/// float acoshf(float x);
-def acoshf : TargetLibCall<"acoshf", Flt, [Flt]>;
+def TLI_acoshf : TargetLibCall_D<"acoshf", Flt, [Flt]>;
/// long double acoshl(long double x);
-def acoshl : TargetLibCall<"acoshl", LDbl, [LDbl]>;
+def TLI_acoshl : TargetLibCall_D<"acoshl", LDbl, [LDbl]>;
/// long double acosl(long double x);
-def acosl : TargetLibCall<"acosl", LDbl, [LDbl]>;
+def TLI_acosl : TargetLibCall_R<acosl_f128>;
/// void *aligned_alloc(size_t alignment, size_t size);
-def aligned_alloc : TargetLibCall<"aligned_alloc", Ptr, [SizeT, SizeT]>;
+def TLI_aligned_alloc : TargetLibCall_R<aligned_alloc>;
/// double asin(double x);
-def asin : TargetLibCall<"asin", Dbl, [Dbl]>;
+def TLI_asin : TargetLibCall_R<asin>;
/// float asinf(float x);
-def asinf : TargetLibCall<"asinf", Flt, [Flt]>;
+def TLI_asinf : TargetLibCall_R<asinf>;
/// double asinh(double x);
-def asinh : TargetLibCall<"asinh", Dbl, [Dbl]>;
+def TLI_asinh : TargetLibCall_D<"asinh", Dbl, [Dbl]>;
/// float asinhf(float x);
-def asinhf : TargetLibCall<"asinhf", Flt, [Flt]>;
+def TLI_asinhf : TargetLibCall_D<"asinhf", Flt, [Flt]>;
/// long double asinhl(long double x);
-def asinhl : TargetLibCall<"asinhl", LDbl, [LDbl]>;
+def TLI_asinhl : TargetLibCall_D<"asinhl", LDbl, [LDbl]>;
/// long double asinl(long double x);
-def asinl : TargetLibCall<"asinl", LDbl, [LDbl]>;
+def TLI_asinl : TargetLibCall_R<asinl_f128>;
/// double atan(double x);
-def atan : TargetLibCall<"atan", Dbl, [Dbl]>;
+def TLI_atan : TargetLibCall_R<atan>;
/// double atan2(double y, double x);
-def atan2 : TargetLibCall<"atan2", Dbl, [Dbl, Dbl]>;
+def TLI_atan2 : TargetLibCall_R<atan2>;
/// float atan2f(float y, float x);
-def atan2f : TargetLibCall<"atan2f", Flt, [Flt, Flt]>;
+def TLI_atan2f : TargetLibCall_R<atan2f>;
/// long double atan2l(long double y, long double x);
-def atan2l : TargetLibCall<"atan2l", LDbl, [LDbl, LDbl]>;
+def TLI_atan2l : TargetLibCall_R<atan2l_f128>;
/// float atanf(float x);
-def atanf : TargetLibCall<"atanf", Flt, [Flt]>;
+def TLI_atanf : TargetLibCall_R<atanf>;
/// double atanh(double x);
-def atanh : TargetLibCall<"atanh", Dbl, [Dbl]>;
+def TLI_atanh : TargetLibCall_D<"atanh", Dbl, [Dbl]>;
+
/// float atanhf(float x);
-def atanhf : TargetLibCall<"atanhf", Flt, [Flt]>;
+def TLI_atanhf : TargetLibCall_D<"atanhf", Flt, [Flt]>;
/// long double atanhl(long double x);
-def atanhl : TargetLibCall<"atanhl", LDbl, [LDbl]>;
+def TLI_atanhl : TargetLibCall_D<"atanhl", LDbl, [LDbl]>;
/// long double atanl(long double x);
-def atanl : TargetLibCall<"atanl", LDbl, [LDbl]>;
+def TLI_atanl : TargetLibCall_R<atanl_f128>;
/// double atof(const char *str);
-def atof : TargetLibCall<"atof", Dbl, [Ptr]>;
+def TLI_atof : TargetLibCall_R<atof>;
/// int atoi(const char *str);
-def atoi : TargetLibCall<"atoi", Int, [Ptr]>;
+def TLI_atoi : TargetLibCall_R<atoi>;
/// long atol(const char *str);
-def atol : TargetLibCall<"atol", Long, [Ptr]>;
+def TLI_atol : TargetLibCall_R<atol>;
/// long long atoll(const char *nptr);
-def atoll : TargetLibCall<"atoll", LLong, [Ptr]>;
+def TLI_atoll : TargetLibCall_R<atoll>;
/// int bcmp(const void *s1, const void *s2, size_t n);
-def bcmp : TargetLibCall<"bcmp", Int, [Ptr, Ptr, SizeT]>;
+def TLI_bcmp : TargetLibCall_R<bcmp>;
/// void bcopy(const void *s1, void *s2, size_t n);
-def bcopy : TargetLibCall<"bcopy", Void, [Ptr, Ptr, SizeT]>;
+def TLI_bcopy : TargetLibCall_R<bcopy>;
/// void bzero(void *s, size_t n);
-def bzero : TargetLibCall<"bzero", Void, [Ptr, SizeT]>;
+def TLI_bzero : TargetLibCall_R<bzero>;
/// double cabs(double complex z)
-def cabs : TargetLibCall<"cabs", ? /* Checked manually. */>;
+def TLI_cabs : TargetLibCall_R<cabs>;
/// float cabs(float complex z)
-def cabsf : TargetLibCall<"cabsf", ? /* Checked manually. */>;
+def TLI_cabsf : TargetLibCall_R<cabsf>;
/// long double cabs(long double complex z)
-def cabsl : TargetLibCall<"cabsl", ? /* Checked manually. */>;
+def TLI_cabsl : TargetLibCall_R<cabsl_f128>;
/// void *calloc(size_t count, size_t size);
-def calloc : TargetLibCall<"calloc", Ptr, [SizeT, SizeT]>;
+def TLI_calloc : TargetLibCall_R<calloc>;
/// double cbrt(double x);
-def cbrt : TargetLibCall<"cbrt", Dbl, [Dbl]>;
+def TLI_cbrt : TargetLibCall_R<cbrt>;
/// float cbrtf(float x);
-def cbrtf : TargetLibCall<"cbrtf", Flt, [Flt]>;
+def TLI_cbrtf : TargetLibCall_R<cbrtf>;
/// long double cbrtl(long double x);
-def cbrtl : TargetLibCall<"cbrtl", LDbl, [LDbl]>;
+def TLI_cbrtl : TargetLibCall_R<cbrtl_f128>;
/// double ceil(double x);
-def ceil : TargetLibCall<"ceil", Dbl, [Dbl]>;
+def TLI_ceil : TargetLibCall_R<ceil>;
/// float ceilf(float x);
-def ceilf : TargetLibCall<"ceilf", Flt, [Flt]>;
+def TLI_ceilf : TargetLibCall_R<ceilf>;
/// long double ceill(long double x);
-def ceill : TargetLibCall<"ceill", LDbl, [LDbl]>;
+def TLI_ceill : TargetLibCall_R<ceill_f128>;
/// int chmod(const char *path, mode_t mode);
-def chmod : TargetLibCall<"chmod", Int, [Ptr, IntX]>;
+def TLI_chmod : TargetLibCall_R<chmod>;
/// int chown(const char *path, uid_t owner, gid_t group);
-def chown : TargetLibCall<"chown", Int, [Ptr, IntX, IntX]>;
+def TLI_chown : TargetLibCall_R<chown>;
/// void clearerr(FILE *stream);
-def clearerr : TargetLibCall<"clearerr", Void, [Ptr]>;
+def TLI_clearerr : TargetLibCall_R<clearerr>;
/// int closedir(DIR *dirp);
-def closedir : TargetLibCall<"closedir", Int, [Ptr]>;
+def TLI_closedir : TargetLibCall_R<closedir>;
/// double copysign(double x, double y);
-def copysign : TargetLibCall<"copysign", Dbl, [Dbl, Dbl]>;
+def TLI_copysign : TargetLibCall_R<copysign>;
/// float copysignf(float x, float y);
-def copysignf : TargetLibCall<"copysignf", Flt, [Flt, Flt]>;
+def TLI_copysignf : TargetLibCall_R<copysignf>;
/// long double copysignl(long double x, long double y);
-def copysignl : TargetLibCall<"copysignl", LDbl, [LDbl, LDbl]>;
+def TLI_copysignl : TargetLibCall_R<copysignl_f128>;
/// double cos(double x);
-def cos : TargetLibCall<"cos", Dbl, [Dbl]>;
+def TLI_cos : TargetLibCall_R<cos>;
/// float cosf(float x);
-def cosf : TargetLibCall<"cosf", Flt, [Flt]>;
+def TLI_cosf : TargetLibCall_R<cosf>;
/// double cosh(double x);
-def cosh : TargetLibCall<"cosh", Dbl, [Dbl]>;
+def TLI_cosh : TargetLibCall_R<cosh>;
/// float coshf(float x);
-def coshf : TargetLibCall<"coshf", Flt, [Flt]>;
+def TLI_coshf : TargetLibCall_R<coshf>;
/// long double coshl(long double x);
-def coshl : TargetLibCall<"coshl", LDbl, [LDbl]>;
+def TLI_coshl : TargetLibCall_R<coshl_f128>;
/// long double cosl(long double x);
-def cosl : TargetLibCall<"cosl", LDbl, [LDbl]>;
+def TLI_cosl : TargetLibCall_R<cosl_f128>;
/// char *ctermid(char *s);
-def ctermid : TargetLibCall<"ctermid", Ptr, [Ptr]>;
+def TLI_ctermid : TargetLibCall_R<ctermid>;
/// double erf(double x);
-def erf : TargetLibCall<"erf", Dbl, [Dbl]>;
+def TLI_erf : TargetLibCall_D<"erf", Dbl, [Dbl]>;
+
/// float erff(float x);
-def erff : TargetLibCall<"erff", Flt, [Flt]>;
+def TLI_erff : TargetLibCall_D<"erff", Flt, [Flt]>;
/// long double erfl(long double x);
-def erfl : TargetLibCall<"erfl", LDbl, [LDbl]>;
+def TLI_erfl : TargetLibCall_D<"erfl", LDbl, [LDbl]>;
/// double tgamma(double x);
-def tgamma : TargetLibCall<"tgamma", Dbl, [Dbl]>;
+def TLI_tgamma : TargetLibCall_R<tgamma>;
/// float tgammaf(float x);
-def tgammaf : TargetLibCall<"tgammaf", Flt, [Flt]>;
+def TLI_tgammaf : TargetLibCall_R<tgammaf>;
/// long double tgammal(long double x);
-def tgammal : TargetLibCall<"tgammal", LDbl, [LDbl]>;
+def TLI_tgammal : TargetLibCall_R<tgammal_f128>;
/// int execl(const char *path, const char *arg, ...);
-def execl : TargetLibCall<"execl", Int, [Ptr, Ptr, Ellip]>;
+def TLI_execl : TargetLibCall_R<execl>;
/// int execle(const char *file, const char *arg, ..., char * const envp[]);
-def execle : TargetLibCall<"execle", Int, [Ptr, Ptr, Ellip]>;
+def TLI_execle : TargetLibCall_R<execle>;
/// int execlp(const char *file, const char *arg, ...);
-def execlp : TargetLibCall<"execlp", Int, [Ptr, Ptr, Ellip]>;
+def TLI_execlp : TargetLibCall_R<execlp>;
/// int execv(const char *path, char *const argv[]);
-def execv : TargetLibCall<"execv", Int, [Ptr, Ptr]>;
+def TLI_execv : TargetLibCall_R<execv>;
/// int execvP(const char *file, const char *search_path, char *const argv[]);
-def execvP : TargetLibCall<"execvP", Int, [Ptr, Ptr, Ptr]>;
+def TLI_execvP : TargetLibCall_D<"execvP", Int, [Ptr, Ptr, Ptr]>;
/// int execve(const char *filename, char *const argv], [char *const envp[]);
-def execve : TargetLibCall<"execve", Int, [Ptr, Ptr, Ptr]>;
+def TLI_execve : TargetLibCall_R<execve>;
/// int execvp(const char *file, char *const argv[]);
-def execvp : TargetLibCall<"execvp", Int, [Ptr, Ptr]>;
+def TLI_execvp : TargetLibCall_R<execvp>;
/// int execvpe(const char *file, char *const argv], [char *const envp[]);
-def execvpe : TargetLibCall<"execvpe", Int, [Ptr, Ptr, Ptr]>;
+def TLI_execvpe : TargetLibCall_R<execvpe>;
/// double exp(double x);
-def exp : TargetLibCall<"exp", Dbl, [Dbl]>;
+def TLI_exp : TargetLibCall_R<exp>;
/// double exp10(double x);
-def exp10 : TargetLibCall<"exp10", Dbl, [Dbl]>;
+def TLI_exp10 : TargetLibCall_R<exp10>;
/// float exp10f(float x);
-def exp10f : TargetLibCall<"exp10f", Flt, [Flt]>;
+def TLI_exp10f : TargetLibCall_R<exp10f>;
/// long double exp10l(long double x);
-def exp10l : TargetLibCall<"exp10l", LDbl, [LDbl]>;
+def TLI_exp10l : TargetLibCall_R<exp10l_f128>;
/// double exp2(double x);
-def exp2 : TargetLibCall<"exp2", Dbl, [Dbl]>;
+def TLI_exp2 : TargetLibCall_R<exp2>;
/// float exp2f(float x);
-def exp2f : TargetLibCall<"exp2f", Flt, [Flt]>;
+def TLI_exp2f : TargetLibCall_R<exp2f>;
/// long double exp2l(long double x);
-def exp2l : TargetLibCall<"exp2l", LDbl, [LDbl]>;
+def TLI_exp2l : TargetLibCall_R<exp2l_f128>;
/// float expf(float x);
-def expf : TargetLibCall<"expf", Flt, [Flt]>;
+def TLI_expf : TargetLibCall_R<expf>;
/// long double expl(long double x);
-def expl : TargetLibCall<"expl", LDbl, [LDbl]>;
+def TLI_expl : TargetLibCall_R<expl_f128>;
/// double expm1(double x);
-def expm1 : TargetLibCall<"expm1", Dbl, [Dbl]>;
+def TLI_expm1 : TargetLibCall_D<"expm1", Dbl, [Dbl]>;
/// float expm1f(float x);
-def expm1f : TargetLibCall<"expm1f", Flt, [Flt]>;
+def TLI_expm1f : TargetLibCall_D<"expm1f", Flt, [Flt]>;
/// long double expm1l(long double x);
-def expm1l : TargetLibCall<"expm1l", LDbl, [LDbl]>;
+def TLI_expm1l : TargetLibCall_D<"expm1l", LDbl, [LDbl]>;
/// double fabs(double x);
-def fabs : TargetLibCall<"fabs", Dbl, [Dbl]>;
+def TLI_fabs : TargetLibCall_D<"fabs", Dbl, [Dbl]>;
/// float fabsf(float x);
-def fabsf : TargetLibCall<"fabsf", Flt, [Flt]>;
+def TLI_fabsf : TargetLibCall_D<"fabsf", Flt, [Flt]>;
/// long double fabsl(long double x);
-def fabsl : TargetLibCall<"fabsl", LDbl, [LDbl]>;
+def TLI_fabsl : TargetLibCall_D<"fabsl", LDbl, [LDbl]>;
/// int fclose(FILE *stream);
-def fclose : TargetLibCall<"fclose", Int, [Ptr]>;
+def TLI_fclose : TargetLibCall_R<fclose>;
/// FILE *fdopen(int fildes, const char *mode);
-def fdopen : TargetLibCall<"fdopen", Ptr, [Int, Ptr]>;
+def TLI_fdopen : TargetLibCall_R<fdopen>;
/// int feof(FILE *stream);
-def feof : TargetLibCall<"feof", Int, [Ptr]>;
+def TLI_feof : TargetLibCall_R<feof>;
/// int ferror(FILE *stream);
-def ferror : TargetLibCall<"ferror", Int, [Ptr]>;
+def TLI_ferror : TargetLibCall_R<ferror>;
/// int fflush(FILE *stream);
-def fflush : TargetLibCall<"fflush", Int, [Ptr]>;
+def TLI_fflush : TargetLibCall_R<fflush>;
/// int ffs(int i);
-def ffs : TargetLibCall<"ffs", Int, [Int]>;
+def TLI_ffs : TargetLibCall_R<ffs>;
/// int ffsl(long int i);
-def ffsl : TargetLibCall<"ffsl", Int, [Long]>;
+def TLI_ffsl : TargetLibCall_R<ffsl>;
/// int ffsll(long long int i);
-def ffsll : TargetLibCall<"ffsll", Int, [LLong]>;
+def TLI_ffsll : TargetLibCall_R<ffsll>;
/// int fgetc(FILE *stream);
-def fgetc : TargetLibCall<"fgetc", Int, [Ptr]>;
+def TLI_fgetc : TargetLibCall_R<fgetc>;
/// int fgetc_unlocked(FILE *stream);
-def fgetc_unlocked : TargetLibCall<"fgetc_unlocked", Int, [Ptr]>;
+def TLI_fgetc_unlocked : TargetLibCall_R<fgetc_unlocked>;
/// int fgetpos(FILE *stream, fpos_t *pos);
-def fgetpos : TargetLibCall<"fgetpos", Int, [Ptr, Ptr]>;
+def TLI_fgetpos : TargetLibCall_R<fgetpos>;
/// char *fgets(char *s, int n, FILE *stream);
-def fgets : TargetLibCall<"fgets", Ptr, [Ptr, Int, Ptr]>;
+def TLI_fgets : TargetLibCall_R<fgets>;
/// char *fgets_unlocked(char *s, int n, FILE *stream);
-def fgets_unlocked : TargetLibCall<"fgets_unlocked", Ptr, [Ptr, Int, Ptr]>;
+def TLI_fgets_unlocked : TargetLibCall_R<fgets_unlocked>;
/// int fileno(FILE *stream);
-def fileno : TargetLibCall<"fileno", Int, [Ptr]>;
+def TLI_fileno : TargetLibCall_R<fileno>;
/// int fiprintf(FILE *stream, const char *format, ...);
-def fiprintf : TargetLibCall<"fiprintf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_fiprintf : TargetLibCall_R<fiprintf>;
/// void flockfile(FILE *file);
-def flockfile : TargetLibCall<"flockfile", Void, [Ptr]>;
+def TLI_flockfile : TargetLibCall_R<flockfile>;
/// double floor(double x);
-def floor : TargetLibCall<"floor", Dbl, [Dbl]>;
+def TLI_floor : TargetLibCall_R<floor>;
/// float floorf(float x);
-def floorf : TargetLibCall<"floorf", Flt, [Flt]>;
+def TLI_floorf : TargetLibCall_R<floorf>;
/// long double floorl(long double x);
-def floorl : TargetLibCall<"floorl", LDbl, [LDbl]>;
+def TLI_floorl : TargetLibCall_R<floorl_f128>;
/// int fls(int i);
-def fls : TargetLibCall<"fls", Int, [Int]>;
+def TLI_fls : TargetLibCall_R<fls>;
/// int flsl(long int i);
-def flsl : TargetLibCall<"flsl", Int, [Long]>;
+def TLI_flsl : TargetLibCall_R<flsl>;
/// int flsll(long long int i);
-def flsll : TargetLibCall<"flsll", Int, [LLong]>;
+def TLI_flsll : TargetLibCall_R<flsll>;
// Calls to fmax and fmin library functions expand to the llvm.maxnnum and
// llvm.minnum intrinsics with the correct parameter types for the arguments
// (all types must match).
/// double fmax(double x, double y);
-def fmax : TargetLibCall<"fmax", Floating, [Same, Same]>;
+def TLI_fmax : TargetLibCall_R<fmax>;
/// float fmaxf(float x, float y);
-def fmaxf : TargetLibCall<"fmaxf", Floating, [Same, Same]>;
+def TLI_fmaxf : TargetLibCall_R<fmaxf>;
/// long double fmaxl(long double x, long double y);
-def fmaxl : TargetLibCall<"fmaxl", Floating, [Same, Same]>;
+def TLI_fmaxl : TargetLibCall_R<fmaxl_f128>;
/// double fmin(double x, double y);
-def fmin : TargetLibCall<"fmin", Floating, [Same, Same]>;
+def TLI_fmin : TargetLibCall_R<fmin>;
/// float fminf(float x, float y);
-def fminf : TargetLibCall<"fminf", Floating, [Same, Same]>;
+def TLI_fminf : TargetLibCall_R<fminf>;
/// long double fminl(long double x, long double y);
-def fminl : TargetLibCall<"fminl", Floating, [Same, Same]>;
+def TLI_fminl : TargetLibCall_R<fminl_f128>;
// Calls to fmaximum_num and fminimum_num library functions expand to the
// llvm.maximumnum and llvm.minimumnum intrinsics with the correct parameter
// types for the arguments (all types must match).
/// double fmaximum_num(double x, double y);
-def fmaximum_num : TargetLibCall<"fmaximum_num", Floating, [Same, Same]>;
+def TLI_fmaximum_num : TargetLibCall_R<fmaximum_num>;
/// float fmaximum_numf(float x, float y);
-def fmaximum_numf : TargetLibCall<"fmaximum_numf", Floating, [Same, Same]>;
+def TLI_fmaximum_numf : TargetLibCall_R<fmaximum_numf>;
/// long double fmaximum_numl(long double x, long double y);
-def fmaximum_numl : TargetLibCall<"fmaximum_numl", Floating, [Same, Same]>;
+def TLI_fmaximum_numl : TargetLibCall_R<fmaximum_numl_f128>;
/// double fminimum_num(double x, double y);
-def fminimum_num : TargetLibCall<"fminimum_num", Floating, [Same, Same]>;
+def TLI_fminimum_num : TargetLibCall_R<fminimum_num>;
/// float fminimum_numf(float x, float y);
-def fminimum_numf : TargetLibCall<"fminimum_numf", Floating, [Same, Same]>;
+def TLI_fminimum_numf : TargetLibCall_R<fminimum_numf>;
/// long double fminimum_numl(long double x, long double y);
-def fminimum_numl : TargetLibCall<"fminimum_numl", Floating, [Same, Same]>;
+def TLI_fminimum_numl : TargetLibCall_R<fminimum_numl_f128>;
/// double fmod(double x, double y);
-def fmod : TargetLibCall<"fmod", Dbl, [Dbl, Dbl]>;
+def TLI_fmod : TargetLibCall_R<fmod>;
/// float fmodf(float x, float y);
-def fmodf : TargetLibCall<"fmodf", Flt, [Flt, Flt]>;
+def TLI_fmodf : TargetLibCall_R<fmodf>;
/// long double fmodl(long double x, long double y);
-def fmodl : TargetLibCall<"fmodl", LDbl, [LDbl, LDbl]>;
+def TLI_fmodl : TargetLibCall_R<fmodl_f128>;
/// FILE *fopen(const char *filename, const char *mode);
-def fopen : TargetLibCall<"fopen", Ptr, [Ptr, Ptr]>;
+def TLI_fopen : TargetLibCall_R<fopen>;
/// FILE *fopen64(const char *filename, const char *opentype)
-def fopen64 : TargetLibCall<"fopen64", Ptr, [Ptr, Ptr]>;
+def TLI_fopen64 : TargetLibCall_R<fopen64>;
/// int fork();
-def fork : TargetLibCall<"fork", Int, []>;
+def TLI_fork : TargetLibCall_R<fork>;
/// int fprintf(FILE *stream, const char *format, ...);
-def fprintf : TargetLibCall<"fprintf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_fprintf : TargetLibCall_R<fprintf>;
/// int fputc(int c, FILE *stream);
-def fputc : TargetLibCall<"fputc", Int, [Int, Ptr]>;
+def TLI_fputc : TargetLibCall_R<fputc>;
/// int fputc_unlocked(int c, FILE *stream);
-def fputc_unlocked : TargetLibCall<"fputc_unlocked", Int, [Int, Ptr]>;
+def TLI_fputc_unlocked : TargetLibCall_R<fputc_unlocked>;
/// int fputs(const char *s, FILE *stream);
-def fputs : TargetLibCall<"fputs", Int, [Ptr, Ptr]>;
+def TLI_fputs : TargetLibCall_R<fputs>;
/// int fputs_unlocked(const char *s, FILE *stream);
-def fputs_unlocked : TargetLibCall<"fputs_unlocked", Int, [Ptr, Ptr]>;
+def TLI_fputs_unlocked : TargetLibCall_R<fputs_unlocked>;
/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
-def fread : TargetLibCall<"fread", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def TLI_fread : TargetLibCall_R<fread>;
/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
-def fread_unlocked
- : TargetLibCall<"fread_unlocked", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def TLI_fread_unlocked : TargetLibCall_R<fread_unlocked>;
/// void free(void *ptr);
-def free : TargetLibCall<"free", Void, [Ptr]>;
+def TLI_free : TargetLibCall_R<free>;
/// double frexp(double num, int *exp);
-def frexp : TargetLibCall<"frexp", Dbl, [Dbl, Ptr]>;
+def TLI_frexp : TargetLibCall_R<frexp>;
/// float frexpf(float num, int *exp);
-def frexpf : TargetLibCall<"frexpf", Flt, [Flt, Ptr]>;
+def TLI_frexpf : TargetLibCall_R<frexpf>;
/// long double frexpl(long double num, int *exp);
-def frexpl : TargetLibCall<"frexpl", LDbl, [LDbl, Ptr]>;
+def TLI_frexpl : TargetLibCall_R<frexpl_f128>;
/// int fscanf(FILE *stream, const char *format, ... );
-def fscanf : TargetLibCall<"fscanf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_fscanf : TargetLibCall_R<fscanf>;
/// int fseek(FILE *stream, long offset, int whence);
-def fseek : TargetLibCall<"fseek", Int, [Ptr, Long, Int]>;
+def TLI_fseek : TargetLibCall_R<fseek>;
/// int fseeko(FILE *stream, off_t offset, int whence);
-def fseeko : TargetLibCall<"fseeko", Int, [Ptr, IntX, Int]>;
+def TLI_fseeko : TargetLibCall_R<fseeko>;
/// int fseeko64(FILE *stream, off64_t offset, int whence)
-def fseeko64 : TargetLibCall<"fseeko64", Int, [Ptr, Int64, Int]>;
+def TLI_fseeko64 : TargetLibCall_R<fseeko64>;
/// int fsetpos(FILE *stream, const fpos_t *pos);
-def fsetpos : TargetLibCall<"fsetpos", Int, [Ptr, Ptr]>;
+def TLI_fsetpos : TargetLibCall_R<fsetpos>;
/// int fstat(int fildes, struct stat *buf);
-def fstat : TargetLibCall<"fstat", Int, [Int, Ptr]>;
+def TLI_fstat : TargetLibCall_R<fstat>;
/// int fstat64(int filedes, struct stat64 *buf)
-def fstat64 : TargetLibCall<"fstat64", Int, [Int, Ptr]>;
+def TLI_fstat64 : TargetLibCall_R<fstat64>;
/// int fstatvfs(int fildes, struct statvfs *buf);
-def fstatvfs : TargetLibCall<"fstatvfs", Int, [Int, Ptr]>;
+def TLI_fstatvfs : TargetLibCall_R<fstatvfs>;
/// int fstatvfs64(int fildes, struct statvfs64 *buf);
-def fstatvfs64 : TargetLibCall<"fstatvfs64", Int, [Int, Ptr]>;
+def TLI_fstatvfs64 : TargetLibCall_R<fstatvfs64>;
/// long ftell(FILE *stream);
-def ftell : TargetLibCall<"ftell", Long, [Ptr]>;
+def TLI_ftell : TargetLibCall_R<ftell>;
/// off_t ftello(FILE *stream);
-def ftello : TargetLibCall<"ftello", IntPlus, [Ptr]>;
+def TLI_ftello : TargetLibCall_R<ftello>;
/// off64_t ftello64(FILE *stream)
-def ftello64 : TargetLibCall<"ftello64", Int64, [Ptr]>;
+def TLI_ftello64 : TargetLibCall_R<ftello64>;
/// int ftrylockfile(FILE *file);
-def ftrylockfile : TargetLibCall<"ftrylockfile", Int, [Ptr]>;
+def TLI_ftrylockfile : TargetLibCall_R<ftrylockfile>;
/// void funlockfile(FILE *file);
-def funlockfile : TargetLibCall<"funlockfile", Void, [Ptr]>;
+def TLI_funlockfile : TargetLibCall_R<funlockfile>;
/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
-def fwrite : TargetLibCall<"fwrite", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def TLI_fwrite : TargetLibCall_R<fwrite>;
/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems,
/// FILE *stream);
-def fwrite_unlocked
- : TargetLibCall<"fwrite_unlocked", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def TLI_fwrite_unlocked : TargetLibCall_R<fwrite_unlocked>;
/// int getc(FILE *stream);
-def getc : TargetLibCall<"getc", Int, [Ptr]>;
+def TLI_getc : TargetLibCall_R<getc>;
/// int getc_unlocked(FILE *stream);
-def getc_unlocked : TargetLibCall<"getc_unlocked", Int, [Ptr]>;
+def TLI_getc_unlocked : TargetLibCall_R<getc_unlocked>;
/// int getchar(void);
-def getchar : TargetLibCall<"getchar", Int, []>;
+def TLI_getchar : TargetLibCall_R<getchar>;
/// int getchar_unlocked(void);
-def getchar_unlocked : TargetLibCall<"getchar_unlocked", Int, []>;
+def TLI_getchar_unlocked : TargetLibCall_R<getchar_unlocked>;
/// char *getenv(const char *name);
-def getenv : TargetLibCall<"getenv", Ptr, [Ptr]>;
+def TLI_getenv : TargetLibCall_R<getenv>;
/// int getitimer(int which, struct itimerval *value);
-def getitimer : TargetLibCall<"getitimer", Int, [Int, Ptr]>;
+def TLI_getitimer : TargetLibCall_R<getitimer>;
/// int getlogin_r(char *name, size_t namesize);
-def getlogin_r : TargetLibCall<"getlogin_r", Int, [Ptr, SizeT]>;
+def TLI_getlogin_r : TargetLibCall_R<getlogin_r>;
/// struct passwd *getpwnam(const char *name);
-def getpwnam : TargetLibCall<"getpwnam", Ptr, [Ptr]>;
+def TLI_getpwnam : TargetLibCall_R<getpwnam>;
/// char *gets(char *s);
-def gets : TargetLibCall<"gets", Ptr, [Ptr]>;
+def TLI_gets : TargetLibCall_R<gets>;
/// int gettimeofday(struct timeval *tp, void *tzp);
-def gettimeofday : TargetLibCall<"gettimeofday", Int, [Ptr, Ptr]>;
+def TLI_gettimeofday : TargetLibCall_R<gettimeofday>;
/// uint32_t htonl(uint32_t hostlong);
-def htonl : TargetLibCall<"htonl", Int32, [Int32]>;
+def TLI_htonl : TargetLibCall_R<htonl>;
/// uint16_t htons(uint16_t hostshort);
-def htons : TargetLibCall<"htons", Int16, [Int16]>;
+def TLI_htons : TargetLibCall_R<htons>;
/// double hypot(double x, double y);
-def hypot : TargetLibCall<"hypot", Dbl, [Dbl, Dbl]>;
+def TLI_hypot : TargetLibCall_D<"hypot", Dbl, [Dbl, Dbl]>;
/// float hypotf(float x, float y);
-def hypotf : TargetLibCall<"hypotf", Flt, [Flt, Flt]>;
+def TLI_hypotf : TargetLibCall_D<"hypotf", Flt, [Flt, Flt]>;
/// long double hypotl(long double x, long double y);
-def hypotl : TargetLibCall<"hypotl", LDbl, [LDbl, LDbl]>;
+def TLI_hypotl : TargetLibCall_D<"hypotl", LDbl, [LDbl, LDbl]>;
/// int iprintf(const char *format, ...);
-def iprintf : TargetLibCall<"iprintf", Int, [Ptr, Ellip]>;
+def TLI_iprintf : TargetLibCall_R<iprintf>;
/// int isascii(int c);
-def isascii : TargetLibCall<"isascii", Int, [Int]>;
+def TLI_isascii : TargetLibCall_R<isascii>;
/// int isdigit(int c);
-def isdigit : TargetLibCall<"isdigit", Int, [Int]>;
+def TLI_isdigit : TargetLibCall_R<isdigit>;
/// long int labs(long int j);
-def labs : TargetLibCall<"labs", Long, [Same]>;
+def TLI_labs : TargetLibCall_R<labs>;
/// int lchown(const char *path, uid_t owner, gid_t group);
-def lchown : TargetLibCall<"lchown", Int, [Ptr, IntX, IntX]>;
+def TLI_lchown : TargetLibCall_R<lchown>;
/// double ldexp(double x, int n);
-def ldexp : TargetLibCall<"ldexp", Dbl, [Dbl, Int]>;
+def TLI_ldexp : TargetLibCall_R<ldexp>;
/// float ldexpf(float x, int n);
-def ldexpf : TargetLibCall<"ldexpf", Flt, [Flt, Int]>;
+def TLI_ldexpf : TargetLibCall_R<ldexpf>;
/// long double ldexpl(long double x, int n);
-def ldexpl : TargetLibCall<"ldexpl", LDbl, [LDbl, Int]>;
+def TLI_ldexpl : TargetLibCall_R<ldexpl_f128>;
/// long long int llabs(long long int j);
-def llabs : TargetLibCall<"llabs", LLong, [LLong]>;
+def TLI_llabs : TargetLibCall_R<llabs>;
/// double log(double x);
-def log : TargetLibCall<"log", Dbl, [Dbl]>;
+def TLI_log : TargetLibCall_R<log>;
/// double log10(double x);
-def log10 : TargetLibCall<"log10", Dbl, [Dbl]>;
+def TLI_log10 : TargetLibCall_R<log10>;
/// float log10f(float x);
-def log10f : TargetLibCall<"log10f", Flt, [Flt]>;
+def TLI_log10f : TargetLibCall_R<log10f>;
/// long double log10l(long double x);
-def log10l : TargetLibCall<"log10l", LDbl, [LDbl]>;
+def TLI_log10l : TargetLibCall_R<log10l_f128>;
/// double log1p(double x);
-def log1p : TargetLibCall<"log1p", Dbl, [Dbl]>;
+def TLI_log1p : TargetLibCall_D<"log1p", Dbl, [Dbl]>;
/// float log1pf(float x);
-def log1pf : TargetLibCall<"log1pf", Flt, [Flt]>;
+def TLI_log1pf : TargetLibCall_D<"log1pf", Flt, [Flt]>;
/// long double log1pl(long double x);
-def log1pl : TargetLibCall<"log1pl", LDbl, [LDbl]>;
+def TLI_log1pl : TargetLibCall_D<"log1pl", LDbl, [LDbl]>;
/// double log2(double x);
-def log2 : TargetLibCall<"log2", Dbl, [Dbl]>;
+def TLI_log2 : TargetLibCall_R<log2>;
/// float log2f(float x);
-def log2f : TargetLibCall<"log2f", Flt, [Flt]>;
+def TLI_log2f : TargetLibCall_R<log2f>;
/// double long double log2l(long double x);
-def log2l : TargetLibCall<"log2l", LDbl, [LDbl]>;
+def TLI_log2l : TargetLibCall_R<log2l_f128>;
/// int ilogb(double x);
-def ilogb : TargetLibCall<"ilogb", Int, [Dbl]>;
+def TLI_ilogb : TargetLibCall_D<"ilogb", Int, [Dbl]>;
/// int ilogbf(float x);
-def ilogbf : TargetLibCall<"ilogbf", Int, [Flt]>;
+def TLI_ilogbf : TargetLibCall_D<"ilogbf", Int, [Flt]>;
/// int ilogbl(long double x);
-def ilogbl : TargetLibCall<"ilogbl", Int, [LDbl]>;
+def TLI_ilogbl : TargetLibCall_D<"ilogbl", Int, [LDbl]>;
/// double logb(double x);
-def logb : TargetLibCall<"logb", Dbl, [Dbl]>;
+def TLI_logb : TargetLibCall_D<"logb", Dbl, [Dbl]>;
/// float logbf(float x);
-def logbf : TargetLibCall<"logbf", Flt, [Flt]>;
+def TLI_logbf : TargetLibCall_D<"logbf", Flt, [Flt]>;
/// long double logbl(long double x);
-def logbl : TargetLibCall<"logbl", LDbl, [LDbl]>;
+def TLI_logbl : TargetLibCall_D<"logbl", LDbl, [LDbl]>;
/// float logf(float x);
-def logf : TargetLibCall<"logf", Flt, [Flt]>;
+def TLI_logf : TargetLibCall_R<logf>;
/// long double logl(long double x);
-def logl : TargetLibCall<"logl", LDbl, [LDbl]>;
+def TLI_logl : TargetLibCall_R<logl_f128>;
/// int lstat(const char *path, struct stat *buf);
-def lstat : TargetLibCall<"lstat", Int, [Ptr, Ptr]>;
+def TLI_lstat : TargetLibCall_R<lstat>;
/// int lstat64(const char *path, struct stat64 *buf);
-def lstat64 : TargetLibCall<"lstat64", Int, [Ptr, Ptr]>;
+def TLI_lstat64 : TargetLibCall_R<lstat64>;
/// void *malloc(size_t size);
-def malloc : TargetLibCall<"malloc", Ptr, [SizeT]>;
+def TLI_malloc : TargetLibCall_R<malloc>;
/// void *memalign(size_t boundary, size_t size);
-def memalign : TargetLibCall<"memalign", Ptr, [SizeT, SizeT]>;
+def TLI_memalign : TargetLibCall_R<memalign>;
/// void *memccpy(void *s1, const void *s2, int c, size_t n);
-def memccpy : TargetLibCall<"memccpy", Ptr, [Ptr, Ptr, Int, SizeT]>;
+def TLI_memccpy : TargetLibCall_R<memccpy>;
/// void *memchr(const void *s, int c, size_t n);
-def memchr : TargetLibCall<"memchr", Ptr, [Ptr, Int, SizeT]>;
+def TLI_memchr : TargetLibCall_R<memchr>;
/// int memcmp(const void *s1, const void *s2, size_t n);
-def memcmp : TargetLibCall<"memcmp", Int, [Ptr, Ptr, SizeT]>;
+def TLI_memcmp : TargetLibCall_R<memcmp>;
/// void *memcpy(void *s1, const void *s2, size_t n);
-def memcpy : TargetLibCall<"memcpy", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_memcpy : TargetLibCall_R<memcpy>;
/// void *memmove(void *s1, const void *s2, size_t n);
-def memmove : TargetLibCall<"memmove", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_memmove : TargetLibCall_R<memmove>;
/// void *mempcpy(void *s1, const void *s2, size_t n);
-def mempcpy : TargetLibCall<"mempcpy", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_mempcpy : TargetLibCall_R<mempcpy>;
/// void *memrchr(const void *s, int c, size_t n);
-def memrchr : TargetLibCall<"memrchr", Ptr, [Ptr, Int, SizeT]>;
+def TLI_memrchr : TargetLibCall_R<memrchr>;
/// void *memset(void *b, int c, size_t len);
-def memset : TargetLibCall<"memset", Ptr, [Ptr, Int, SizeT]>;
+def TLI_memset : TargetLibCall_R<memset>;
/// void memset_pattern16(void *b, const void *pattern16, size_t len);
-def memset_pattern16
- : TargetLibCall<"memset_pattern16", Void, [Ptr, Ptr, SizeT]>;
+def TLI_memset_pattern16 : TargetLibCall_R<memset_pattern16>;
/// void memset_pattern4(void *b, const void *pattern4, size_t len);
-def memset_pattern4 : TargetLibCall<"memset_pattern4", Void, [Ptr, Ptr, SizeT]>;
+def TLI_memset_pattern4 : TargetLibCall_R<memset_pattern4>;
/// void memset_pattern8(void *b, const void *pattern8, size_t len);
-def memset_pattern8 : TargetLibCall<"memset_pattern8", Void, [Ptr, Ptr, SizeT]>;
+def TLI_memset_pattern8 : TargetLibCall_R<memset_pattern8>;
/// int mkdir(const char *path, mode_t mode);
-def mkdir : TargetLibCall<"mkdir", Int, [Ptr, IntX]>;
+def TLI_mkdir : TargetLibCall_R<mkdir>;
/// time_t mktime(struct tm *timeptr);
-def mktime : TargetLibCall<"mktime", IntPlus, [Ptr]>;
+def TLI_mktime : TargetLibCall_R<mktime>;
/// double modf(double x, double *iptr);
-def modf : TargetLibCall<"modf", Dbl, [Dbl, Ptr]>;
+def TLI_modf : TargetLibCall_R<modf>;
/// float modff(float, float *iptr);
-def modff : TargetLibCall<"modff", Flt, [Flt, Ptr]>;
+def TLI_modff : TargetLibCall_R<modff>;
/// long double modfl(long double value, long double *iptr);
-def modfl : TargetLibCall<"modfl", LDbl, [LDbl, Ptr]>;
+def TLI_modfl : TargetLibCall_R<modfl_f128>;
/// double nan(const char *arg);
-def nan : TargetLibCall<"nan", Dbl, [Ptr]>;
+def TLI_nan : TargetLibCall_R<nan>;
/// float nanf(const char *arg);
-def nanf : TargetLibCall<"nanf", Flt, [Ptr]>;
+def TLI_nanf : TargetLibCall_R<nanf>;
/// long double nanl(const char *arg);
-def nanl : TargetLibCall<"nanl", LDbl, [Ptr]>;
+def TLI_nanl : TargetLibCall_R<nanl_f128>;
/// double nearbyint(double x);
-def nearbyint : TargetLibCall<"nearbyint", Dbl, [Dbl]>;
+def TLI_nearbyint : TargetLibCall_R<nearbyint>;
/// float nearbyintf(float x);
-def nearbyintf : TargetLibCall<"nearbyintf", Flt, [Flt]>;
+def TLI_nearbyintf : TargetLibCall_R<nearbyintf>;
/// long double nearbyintl(long double x);
-def nearbyintl : TargetLibCall<"nearbyintl", LDbl, [LDbl]>;
+def TLI_nearbyintl : TargetLibCall_R<nearbyintl_f128>;
/// double nextafter(double x, double y);
-def nextafter : TargetLibCall< "nextafter", Dbl, [Dbl, Dbl]>;
+def TLI_nextafter : TargetLibCall_D< "nextafter", Dbl, [Dbl, Dbl]>;
/// float nextafterf(float x, float y);
-def nextafterf : TargetLibCall< "nextafterf", Flt, [Flt, Flt]>;
+def TLI_nextafterf : TargetLibCall_D< "nextafterf", Flt, [Flt, Flt]>;
/// long double nextafterl(long double x, long double y);
-def nextafterl : TargetLibCall< "nextafterl", LDbl, [LDbl, LDbl]>;
+def TLI_nextafterl : TargetLibCall_D< "nextafterl", LDbl, [LDbl, LDbl]>;
/// double nexttoward(double x, long double y);
-def nexttoward : TargetLibCall< "nexttoward", Dbl, [Dbl, LDbl]>;
+def TLI_nexttoward : TargetLibCall_R<nexttoward>;
/// float nexttowardf(float x, long double y);
-def nexttowardf : TargetLibCall< "nexttowardf", Flt, [Flt, LDbl]>;
+def TLI_nexttowardf : TargetLibCall_R<nexttowardf>;
/// long double nexttowardl(long double x, long double y);
-def nexttowardl : TargetLibCall< "nexttowardl", LDbl, [LDbl, LDbl]>;
+def TLI_nexttowardl : TargetLibCall_R<nexttowardl_f128>;
/// uint32_t ntohl(uint32_t netlong);
-def ntohl : TargetLibCall<"ntohl", Int32, [Int32]>;
+def TLI_ntohl : TargetLibCall_R<ntohl>;
/// uint16_t ntohs(uint16_t netshort);
-def ntohs : TargetLibCall<"ntohs", Int16, [Int16]>;
+def TLI_ntohs : TargetLibCall_R<ntohs>;
/// int open(const char *path, int oflag, ... );
-def open : TargetLibCall<"open", Int, [Ptr, Int, Ellip]>;
+def TLI_open : TargetLibCall_R<open>;
/// int open64(const char *filename, int flags, [mode_t mode])
-def open64 : TargetLibCall<"open64", Int, [Ptr, Int, Ellip]>;
+def TLI_open64 : TargetLibCall_R<open64>;
/// DIR *opendir(const char *dirname);
-def opendir : TargetLibCall<"opendir", Ptr, [Ptr]>;
+def TLI_opendir : TargetLibCall_R<opendir>;
/// int pclose(FILE *stream);
-def pclose : TargetLibCall<"pclose", Int, [Ptr]>;
+def TLI_pclose : TargetLibCall_R<pclose>;
/// void perror(const char *s);
-def perror : TargetLibCall<"perror", Void, [Ptr]>;
+def TLI_perror : TargetLibCall_R<perror>;
/// FILE *popen(const char *command, const char *mode);
-def popen : TargetLibCall<"popen", Ptr, [Ptr, Ptr]>;
+def TLI_popen : TargetLibCall_R<popen>;
/// int posix_memalign(void **memptr, size_t alignment, size_t size);
-def posix_memalign : TargetLibCall<"posix_memalign", Int, [Ptr, SizeT, SizeT]>;
+def TLI_posix_memalign : TargetLibCall_R<posix_memalign>;
/// double pow(double x, double y);
-def pow : TargetLibCall<"pow", Dbl, [Dbl, Dbl]>;
+def TLI_pow : TargetLibCall_R<pow>;
/// float powf(float x, float y);
-def powf : TargetLibCall<"powf", Flt, [Flt, Flt]>;
+def TLI_powf : TargetLibCall_R<powf>;
/// long double powl(long double x, long double y);
-def powl : TargetLibCall<"powl", LDbl, [LDbl, LDbl]>;
+def TLI_powl : TargetLibCall_R<powl_f128>;
/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
-def pread : TargetLibCall<"pread", SSizeT, [Int, Ptr, SizeT, IntPlus]>;
+def TLI_pread : TargetLibCall_R<pread>;
/// int printf(const char *format, ...);
-def printf : TargetLibCall<"printf", Int, [Ptr, Ellip]>;
+def TLI_printf : TargetLibCall_R<printf>;
/// int putc(int c, FILE *stream);
-def putc : TargetLibCall<"putc", Int, [Int, Ptr]>;
+def TLI_putc : TargetLibCall_R<putc>;
/// int putc_unlocked(int c, FILE *stream);
-def putc_unlocked : TargetLibCall<"putc_unlocked", Int, [Int, Ptr]>;
+def TLI_putc_unlocked : TargetLibCall_R<putc_unlocked>;
/// int putchar(int c);
-def putchar : TargetLibCall<"putchar", Int, [Int]>;
+def TLI_putchar : TargetLibCall_R<putchar>;
/// int putchar_unlocked(int c);
-def putchar_unlocked : TargetLibCall<"putchar_unlocked", Int, [Int]>;
+def TLI_putchar_unlocked : TargetLibCall_R<putchar_unlocked>;
/// int puts(const char *s);
-def puts : TargetLibCall<"puts", Int, [Ptr]>;
+def TLI_puts : TargetLibCall_R<puts>;
/// void *pvalloc(size_t size);
-def pvalloc : TargetLibCall<"pvalloc", Ptr, [SizeT]>;
+def TLI_pvalloc : TargetLibCall_R<pvalloc>;
/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
-def pwrite : TargetLibCall<"pwrite", SSizeT, [Int, Ptr, SizeT, IntPlus]>;
+def TLI_pwrite : TargetLibCall_R<pwrite>;
/// void qsort(void *base, size_t nel, size_t width,
/// int (*compar)(const void *, const void *));
-def qsort : TargetLibCall<"qsort", Void, [Ptr, SizeT, SizeT, Ptr]>;
+def TLI_qsort : TargetLibCall_R<qsort>;
/// ssize_t read(int fildes, void *buf, size_t nbyte);
-def read : TargetLibCall<"read", SSizeT, [Int, Ptr, SizeT]>;
+def TLI_read : TargetLibCall_R<read>;
/// ssize_t readlink(const char *path, char *buf, size_t bufsize);
-def readlink : TargetLibCall<"readlink", SSizeT, [Ptr, Ptr, SizeT]>;
+def TLI_readlink : TargetLibCall_R<readlink>;
/// void *realloc(void *ptr, size_t size);
-def realloc : TargetLibCall<"realloc", Ptr, [Ptr, SizeT]>;
+def TLI_realloc : TargetLibCall_R<realloc>;
/// void *reallocf(void *ptr, size_t size);
-def reallocf : TargetLibCall<"reallocf", Ptr, [Ptr, SizeT]>;
+def TLI_reallocf : TargetLibCall_R<reallocf>;
/// void *reallocarray(void *ptr, size_t nmemb, size_t size);
-def reallocarray : TargetLibCall<"reallocarray", Ptr, [Ptr, SizeT, SizeT]>;
+def TLI_reallocarray : TargetLibCall_R<reallocarray>;
/// char *realpath(const char *file_name, char *resolved_name);
-def realpath : TargetLibCall<"realpath", Ptr, [Ptr, Ptr]>;
+def TLI_realpath : TargetLibCall_R<realpath>;
/// double remainder(double x, double y);
-def remainder : TargetLibCall<"remainder", Dbl, [Dbl, Dbl]>;
+def TLI_remainder : TargetLibCall_R<remainder>;
/// float remainderf(float x, float y);
-def remainderf : TargetLibCall<"remainderf", Flt, [Flt, Flt]>;
+def TLI_remainderf : TargetLibCall_R<remainderf>;
/// long double remainderl(long double x, long double y);
-def remainderl : TargetLibCall<"remainderl", LDbl, [LDbl, LDbl]>;
+def TLI_remainderl : TargetLibCall_R<remainderl_f128>;
/// double remquo(double x, double y, int *quo);
-def remquo : TargetLibCall<"remquo", Dbl, [Dbl, Dbl, Ptr]>;
+def TLI_remquo : TargetLibCall_R<remquo>;
/// float remquof(float x, float y, int *quo);
-def remquof : TargetLibCall<"remquof", Flt, [Flt, Flt, Ptr]>;
+def TLI_remquof : TargetLibCall_R<remquof>;
/// long double remquol(long double x, long double y, int *quo);
-def remquol : TargetLibCall<"remquol", LDbl, [LDbl, LDbl, Ptr]>;
+def TLI_remquol : TargetLibCall_R<remquol_f128>;
/// double fdim(double x, double y);
-def fdim : TargetLibCall<"fdim", Dbl, [Dbl, Dbl]>;
+def TLI_fdim : TargetLibCall_R<fdim>;
/// float fdimf(float x, float y);
-def fdimf : TargetLibCall<"fdimf", Flt, [Flt, Flt]>;
+def TLI_fdimf : TargetLibCall_R<fdimf>;
/// long double fdiml(long double x, long double y);
-def fdiml : TargetLibCall<"fdiml", LDbl, [LDbl, LDbl]>;
+def TLI_fdiml : TargetLibCall_R<fdiml_f128>;
/// int remove(const char *path);
-def remove : TargetLibCall<"remove", Int, [Ptr]>;
+def TLI_remove : TargetLibCall_R<remove>;
/// int rename(const char *old, const char *new);
-def rename : TargetLibCall<"rename", Int, [Ptr, Ptr]>;
+def TLI_rename : TargetLibCall_R<rename>;
/// void rewind(FILE *stream);
-def rewind : TargetLibCall<"rewind", Void, [Ptr]>;
+def TLI_rewind : TargetLibCall_R<rewind>;
/// double rint(double x);
-def rint : TargetLibCall<"rint", Dbl, [Dbl]>;
+def TLI_rint : TargetLibCall_R<rint>;
/// float rintf(float x);
-def rintf : TargetLibCall<"rintf", Flt, [Flt]>;
+def TLI_rintf : TargetLibCall_R<rintf>;
/// long double rintl(long double x);
-def rintl : TargetLibCall<"rintl", LDbl, [LDbl]>;
+def TLI_rintl : TargetLibCall_R<rintl_f128>;
/// int rmdir(const char *path);
-def rmdir : TargetLibCall<"rmdir", Int, [Ptr]>;
+def TLI_rmdir : TargetLibCall_R<rmdir>;
/// double round(double x);
-def round : TargetLibCall<"round", Dbl, [Dbl]>;
+def TLI_round : TargetLibCall_R<round>;
/// double roundeven(double x);
-def roundeven : TargetLibCall<"roundeven", Dbl, [Dbl]>;
+def TLI_roundeven : TargetLibCall_R<roundeven>;
/// float roundevenf(float x);
-def roundevenf : TargetLibCall<"roundevenf", Flt, [Flt]>;
+def TLI_roundevenf : TargetLibCall_R<roundevenf>;
/// long double roundevenl(long double x);
-def roundevenl : TargetLibCall<"roundevenl", LDbl, [LDbl]>;
+def TLI_roundevenl : TargetLibCall_R<roundevenl_f128>;
/// float roundf(float x);
-def roundf : TargetLibCall<"roundf", Flt, [Flt]>;
+def TLI_roundf : TargetLibCall_R<roundf>;
/// long double roundl(long double x);
-def roundl : TargetLibCall<"roundl", LDbl, [LDbl]>;
+def TLI_roundl : TargetLibCall_R<roundl_f128>;
/// double scalbln(double arg, long exp);
-def scalbln : TargetLibCall<"scalbln", Dbl, [Dbl, Long]>;
+def TLI_scalbln : TargetLibCall_R<scalbln>;
/// float scalblnf(float arg, long exp);
-def scalblnf : TargetLibCall<"scalblnf", Flt, [Flt, Long]>;
+def TLI_scalblnf : TargetLibCall_R<scalblnf>;
/// long double scalblnl(long double arg, long exp);
-def scalblnl : TargetLibCall<"scalblnl", LDbl, [LDbl, Long]>;
+def TLI_scalblnl : TargetLibCall_R<scalblnl_f128>;
/// double scalbn(double arg, int exp);
-def scalbn : TargetLibCall<"scalbn", Dbl, [Dbl, Int]>;
+def TLI_scalbn : TargetLibCall_R<scalbn>;
/// float scalbnf(float arg, int exp);
-def scalbnf : TargetLibCall<"scalbnf", Flt, [Flt, Int]>;
+def TLI_scalbnf : TargetLibCall_R<scalbnf>;
/// long double scalbnl(long double arg, int exp);
-def scalbnl : TargetLibCall<"scalbnl", LDbl, [LDbl, Int]>;
+def TLI_scalbnl : TargetLibCall_R<scalbnl_f128>;
/// int scanf(const char *restrict format, ... );
-def scanf : TargetLibCall<"scanf", Int, [Ptr, Ellip]>;
+def TLI_scanf : TargetLibCall_R<scanf>;
/// void setbuf(FILE *stream, char *buf);
-def setbuf : TargetLibCall<"setbuf", Void, [Ptr, Ptr]>;
+def TLI_setbuf : TargetLibCall_R<setbuf>;
/// int setitimer(int which, const struct itimerval *value,
/// struct itimerval *ovalue);
-def setitimer : TargetLibCall<"setitimer", Int, [Int, Ptr, Ptr]>;
+def TLI_setitimer : TargetLibCall_R<setitimer>;
/// int setvbuf(FILE *stream, char *buf, int type, size_t size);
-def setvbuf : TargetLibCall<"setvbuf", Int, [Ptr, Ptr, Int, SizeT]>;
+def TLI_setvbuf : TargetLibCall_R<setvbuf>;
/// double sin(double x);
-def sin : TargetLibCall<"sin", Dbl, [Dbl]>;
+def TLI_sin : TargetLibCall_R<sin>;
/// float sinf(float x);
-def sinf : TargetLibCall<"sinf", Flt, [Flt]>;
+def TLI_sinf : TargetLibCall_R<sinf>;
/// double sinh(double x);
-def sinh : TargetLibCall<"sinh", Dbl, [Dbl]>;
+def TLI_sinh : TargetLibCall_R<sinh>;
/// float sinhf(float x);
-def sinhf : TargetLibCall<"sinhf", Flt, [Flt]>;
+def TLI_sinhf : TargetLibCall_R<sinhf>;
/// long double sinhl(long double x);
-def sinhl : TargetLibCall<"sinhl", LDbl, [LDbl]>;
+def TLI_sinhl : TargetLibCall_R<sinhl_f128>;
/// long double sinl(long double x);
-def sinl : TargetLibCall<"sinl", LDbl, [LDbl]>;
+def TLI_sinl : TargetLibCall_R<sinl_f128>;
/// void sincos(double x, double *sin_out, double *cos_out);
-def sincos : TargetLibCall<"sincos", Void, [Dbl, Ptr, Ptr]>;
+def TLI_sincos : TargetLibCall_R<sincos>;
/// void sincosf(float x, float *sin_out, float *cos_out);
-def sincosf : TargetLibCall<"sincosf", Void, [Flt, Ptr, Ptr]>;
+def TLI_sincosf : TargetLibCall_R<sincosf>;
/// void sincosl(long double x, long double *sin_out, long double *cos_out);
-def sincosl : TargetLibCall<"sincosl", Void, [LDbl, Ptr, Ptr]>;
+def TLI_sincosl : TargetLibCall_R<sincosl_f128>;
/// int siprintf(char *str, const char *format, ...);
-def siprintf : TargetLibCall<"siprintf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_siprintf : TargetLibCall_R<siprintf>;
/// int snprintf(char *s, size_t n, const char *format, ...);
-def snprintf : TargetLibCall<"snprintf", Int, [Ptr, SizeT, Ptr, Ellip]>;
+def TLI_snprintf : TargetLibCall_R<snprintf>;
/// int sprintf(char *str, const char *format, ...);
-def sprintf : TargetLibCall<"sprintf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_sprintf : TargetLibCall_R<sprintf>;
/// double sqrt(double x);
-def sqrt : TargetLibCall<"sqrt", Dbl, [Dbl]>;
+def TLI_sqrt : TargetLibCall_R<sqrt>;
/// float sqrtf(float x);
-def sqrtf : TargetLibCall<"sqrtf", Flt, [Flt]>;
+def TLI_sqrtf : TargetLibCall_R<sqrtf>;
/// long double sqrtl(long double x);
-def sqrtl : TargetLibCall<"sqrtl", LDbl, [LDbl]>;
+def TLI_sqrtl : TargetLibCall_R<sqrtl_f128>;
/// int sscanf(const char *s, const char *format, ... );
-def sscanf : TargetLibCall<"sscanf", Int, [Ptr, Ptr, Ellip]>;
+def TLI_sscanf : TargetLibCall_R<sscanf>;
/// int stat(const char *path, struct stat *buf);
-def stat : TargetLibCall<"stat", Int, [Ptr, Ptr]>;
+def TLI_stat : TargetLibCall_R<stat>;
/// int stat64(const char *path, struct stat64 *buf);
-def stat64 : TargetLibCall<"stat64", Int, [Ptr, Ptr]>;
+def TLI_stat64 : TargetLibCall_R<stat64>;
/// int statvfs(const char *path, struct statvfs *buf);
-def statvfs : TargetLibCall<"statvfs", Int, [Ptr, Ptr]>;
+def TLI_statvfs : TargetLibCall_R<statvfs>;
/// int statvfs64(const char *path, struct statvfs64 *buf)
-def statvfs64 : TargetLibCall<"statvfs64", Int, [Ptr, Ptr]>;
+def TLI_statvfs64 : TargetLibCall_R<statvfs64>;
/// char *stpcpy(char *s1, const char *s2);
-def stpcpy : TargetLibCall<"stpcpy", Ptr, [Ptr, Ptr]>;
+def TLI_stpcpy : TargetLibCall_R<stpcpy>;
/// char *stpncpy(char *s1, const char *s2, size_t n);
-def stpncpy : TargetLibCall<"stpncpy", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_stpncpy : TargetLibCall_R<stpncpy>;
/// int strcasecmp(const char *s1, const char *s2);
-def strcasecmp : TargetLibCall<"strcasecmp", Int, [Ptr, Ptr]>;
+def TLI_strcasecmp : TargetLibCall_R<strcasecmp>;
/// char *strcat(char *s1, const char *s2);
-def strcat : TargetLibCall<"strcat", Ptr, [Ptr, Ptr]>;
+def TLI_strcat : TargetLibCall_R<strcat>;
/// char *strchr(const char *s, int c);
-def strchr : TargetLibCall<"strchr", Ptr, [Ptr, Int]>;
+def TLI_strchr : TargetLibCall_R<strchr>;
/// int strcmp(const char *s1, const char *s2);
-def strcmp : TargetLibCall<"strcmp", Int, [Ptr, Ptr]>;
+def TLI_strcmp : TargetLibCall_R<strcmp>;
/// int strcoll(const char *s1, const char *s2);
-def strcoll : TargetLibCall<"strcoll", Int, [Ptr, Ptr]>;
+def TLI_strcoll : TargetLibCall_R<strcoll>;
/// char *strcpy(char *s1, const char *s2);
-def strcpy : TargetLibCall<"strcpy", Ptr, [Ptr, Ptr]>;
+def TLI_strcpy : TargetLibCall_R<strcpy>;
/// size_t strcspn(const char *s1, const char *s2);
-def strcspn : TargetLibCall<"strcspn", SizeT, [Ptr, Ptr]>;
+def TLI_strcspn : TargetLibCall_R<strcspn>;
/// char *strdup(const char *s1);
-def strdup : TargetLibCall<"strdup", Ptr, [Ptr]>;
+def TLI_strdup : TargetLibCall_R<strdup>;
/// size_t strlcat(char *dst, const char *src, size_t size);
-def strlcat : TargetLibCall<"strlcat", SizeT, [Ptr, Ptr, SizeT]>;
+def TLI_strlcat : TargetLibCall_R<strlcat>;
/// size_t strlcpy(char *dst, const char *src, size_t size);
-def strlcpy : TargetLibCall<"strlcpy", SizeT, [Ptr, Ptr, SizeT]>;
+def TLI_strlcpy : TargetLibCall_R<strlcpy>;
/// size_t strlen(const char *s);
-def strlen : TargetLibCall<"strlen", SizeT, [Ptr]>;
+def TLI_strlen : TargetLibCall_R<strlen>;
/// int strncasecmp(const char *s1, const char *s2, size_t n);
-def strncasecmp : TargetLibCall<"strncasecmp", Int, [Ptr, Ptr, SizeT]>;
+def TLI_strncasecmp : TargetLibCall_R<strncasecmp>;
/// char *strncat(char *s1, const char *s2, size_t n);
-def strncat : TargetLibCall<"strncat", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_strncat : TargetLibCall_R<strncat>;
/// int strncmp(const char *s1, const char *s2, size_t n);
-def strncmp : TargetLibCall<"strncmp", Int, [Ptr, Ptr, SizeT]>;
+def TLI_strncmp : TargetLibCall_R<strncmp>;
/// char *strncpy(char *s1, const char *s2, size_t n);
-def strncpy : TargetLibCall<"strncpy", Ptr, [Ptr, Ptr, SizeT]>;
+def TLI_strncpy : TargetLibCall_R<strncpy>;
/// char *strndup(const char *s1, size_t n);
-def strndup : TargetLibCall<"strndup", Ptr, [Ptr, SizeT]>;
+def TLI_strndup : TargetLibCall_R<strndup>;
/// size_t strnlen(const char *s, size_t maxlen);
-def strnlen : TargetLibCall<"strnlen", SizeT, [Ptr, SizeT]>;
+def TLI_strnlen : TargetLibCall_R<strnlen>;
/// char *strpbrk(const char *s1, const char *s2);
-def strpbrk : TargetLibCall<"strpbrk", Ptr, [Ptr, Ptr]>;
+def TLI_strpbrk : TargetLibCall_R<strpbrk>;
/// char *strrchr(const char *s, int c);
-def strrchr : TargetLibCall<"strrchr", Ptr, [Ptr, Int]>;
+def TLI_strrchr : TargetLibCall_R<strrchr>;
/// size_t strspn(const char *s1, const char *s2);
-def strspn : TargetLibCall<"strspn", SizeT, [Ptr, Ptr]>;
+def TLI_strspn : TargetLibCall_R<strspn>;
/// char *strstr(const char *s1, const char *s2);
-def strstr : TargetLibCall<"strstr", Ptr, [Ptr, Ptr]>;
+def TLI_strstr : TargetLibCall_R<strstr>;
/// double strtod(const char *nptr, char **endptr);
-def strtod : TargetLibCall<"strtod", Dbl, [Ptr, Ptr]>;
+def TLI_strtod : TargetLibCall_R<strtod>;
/// float strtof(const char *nptr, char **endptr);
-def strtof : TargetLibCall<"strtof", Flt, [Ptr, Ptr]>;
+def TLI_strtof : TargetLibCall_R<strtof>;
/// char *strtok(char *s1, const char *s2);
-def strtok : TargetLibCall<"strtok", Ptr, [Ptr, Ptr]>;
+def TLI_strtok : TargetLibCall_R<strtok>;
/// char *strtok_r(char *s, const char *sep, char **lasts);
-def strtok_r : TargetLibCall<"strtok_r", Ptr, [Ptr, Ptr, Ptr]>;
+def TLI_strtok_r : TargetLibCall_R<strtok_r>;
/// long int strtol(const char *nptr, char **endptr, int base);
-def strtol : TargetLibCall<"strtol", Long, [Ptr, Ptr, Int]>;
+def TLI_strtol : TargetLibCall_R<strtol>;
/// long double strtold(const char *nptr, char **endptr);
-def strtold : TargetLibCall<"strtold", LDbl, [Ptr, Ptr]>;
+def TLI_strtold : TargetLibCall_R<strtold>;
/// long long int strtoll(const char *nptr, char **endptr, int base);
-def strtoll : TargetLibCall<"strtoll", LLong, [Ptr, Ptr, Int]>;
+def TLI_strtoll : TargetLibCall_R<strtoll>;
/// unsigned long int strtoul(const char *nptr, char **endptr, int base);
-def strtoul : TargetLibCall<"strtoul", Long, [Ptr, Ptr, Int]>;
+def TLI_strtoul : TargetLibCall_R<strtoul>;
/// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
-def strtoull : TargetLibCall<"strtoull", LLong, [Ptr, Ptr, Int]>;
+def TLI_strtoull : TargetLibCall_R<strtoull>;
/// size_t strxfrm(char *s1, const char *s2, size_t n);
-def strxfrm : TargetLibCall<"strxfrm", SizeT, [Ptr, Ptr, SizeT]>;
+def TLI_strxfrm : TargetLibCall_R<strxfrm>;
/// int system(const char *command);
-def system : TargetLibCall<"system", Int, [Ptr]>;
+def TLI_system : TargetLibCall_R<system>;
/// double tan(double x);
-def tan : TargetLibCall<"tan", Dbl, [Dbl]>;
+def TLI_tan : TargetLibCall_R<tan>;
/// float tanf(float x);
-def tanf : TargetLibCall<"tanf", Flt, [Flt]>;
+def TLI_tanf : TargetLibCall_R<tanf>;
/// double tanh(double x);
-def tanh : TargetLibCall<"tanh", Dbl, [Dbl]>;
+def TLI_tanh : TargetLibCall_R<tanh>;
/// float tanhf(float x);
-def tanhf : TargetLibCall<"tanhf", Flt, [Flt]>;
+def TLI_tanhf : TargetLibCall_R<tanhf>;
/// long double tanhl(long double x);
-def tanhl : TargetLibCall<"tanhl", LDbl, [LDbl]>;
+def TLI_tanhl : TargetLibCall_R<tanhl_f128>;
/// long double tanl(long double x);
-def tanl : TargetLibCall<"tanl", LDbl, [LDbl]>;
+def TLI_tanl : TargetLibCall_R<tanl_f128>;
/// clock_t times(struct tms *buffer);
-def times : TargetLibCall<"times", IntPlus, [Ptr]>;
+def TLI_times : TargetLibCall_R<times>;
/// FILE *tmpfile(void);
-def tmpfile : TargetLibCall<"tmpfile", Ptr, []>;
+def TLI_tmpfile : TargetLibCall_R<tmpfile>;
/// FILE *tmpfile64(void)
-def tmpfile64 : TargetLibCall<"tmpfile64", Ptr, []>;
+def TLI_tmpfile64 : TargetLibCall_R<tmpfile64>;
/// int toascii(int c);
-def toascii : TargetLibCall<"toascii", Int, [Int]>;
+def TLI_toascii : TargetLibCall_R<toascii>;
/// double trunc(double x);
-def trunc : TargetLibCall<"trunc", Dbl, [Dbl]>;
+def TLI_trunc : TargetLibCall_R<trunc>;
/// float truncf(float x);
-def truncf : TargetLibCall<"truncf", Flt, [Flt]>;
+def TLI_truncf : TargetLibCall_R<truncf>;
/// long double truncl(long double x);
-def truncl : TargetLibCall<"truncl", LDbl, [LDbl]>;
+def TLI_truncl : TargetLibCall_R<truncl_f128>;
/// int uname(struct utsname *name);
-def uname : TargetLibCall<"uname", Int, [Ptr]>;
+def TLI_uname : TargetLibCall_R<uname>;
/// int ungetc(int c, FILE *stream);
-def ungetc : TargetLibCall<"ungetc", Int, [Int, Ptr]>;
+def TLI_ungetc : TargetLibCall_R<ungetc>;
/// int unlink(const char *path);
-def unlink : TargetLibCall<"unlink", Int, [Ptr]>;
+def TLI_unlink : TargetLibCall_R<unlink>;
/// int unsetenv(const char *name);
-def unsetenv : TargetLibCall<"unsetenv", Int, [Ptr]>;
+def TLI_unsetenv : TargetLibCall_R<unsetenv>;
/// int utime(const char *path, const struct utimbuf *times);
-def utime : TargetLibCall<"utime", Int, [Ptr, Ptr]>;
+def TLI_utime : TargetLibCall_R<utime>;
/// int utimes(const char *path, const struct timeval times[2]);
-def utimes : TargetLibCall<"utimes", Int, [Ptr, Ptr]>;
+def TLI_utimes : TargetLibCall_R<utimes>;
/// void *valloc(size_t size);
-def valloc : TargetLibCall<"valloc", Ptr, [SizeT]>;
+def TLI_valloc : TargetLibCall_R<valloc>;
/// void *vec_calloc(size_t count, size_t size);
-def vec_calloc : TargetLibCall<"vec_calloc", Ptr, [SizeT, SizeT]>;
+def TLI_vec_calloc : TargetLibCall_R<vec_calloc>;
/// void vec_free(void *ptr);
-def vec_free : TargetLibCall<"vec_free", Void, [Ptr]>;
+def TLI_vec_free : TargetLibCall_R<vec_free>;
/// void *vec_malloc(size_t size);
-def vec_malloc : TargetLibCall<"vec_malloc", Ptr, [SizeT]>;
+def TLI_vec_malloc : TargetLibCall_R<vec_malloc>;
/// void *vec_realloc(void *ptr, size_t size);
-def vec_realloc : TargetLibCall<"vec_realloc", Ptr, [Ptr, SizeT]>;
+def TLI_vec_realloc : TargetLibCall_R<vec_realloc>;
/// int vfprintf(FILE *stream, const char *format, va_list ap);
-def vfprintf : TargetLibCall<"vfprintf", Int, [Ptr, Ptr, Ptr]>;
+def TLI_vfprintf : TargetLibCall_R<vfprintf>;
/// int vfscanf(FILE *stream, const char *format, va_list arg);
-def vfscanf : TargetLibCall<"vfscanf", Int, [Ptr, Ptr, Ptr]>;
+def TLI_vfscanf : TargetLibCall_R<vfscanf>;
/// int vprintf(const char *restrict format, va_list ap);
-def vprintf : TargetLibCall<"vprintf", Int, [Ptr, Ptr]>;
+def TLI_vprintf : TargetLibCall_R<vprintf>;
/// int vscanf(const char *format, va_list arg);
-def vscanf : TargetLibCall<"vscanf", Int, [Ptr, Ptr]>;
+def TLI_vscanf : TargetLibCall_R<vscanf>;
/// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
-def vsnprintf : TargetLibCall<"vsnprintf", Int, [Ptr, SizeT, Ptr, Ptr]>;
+def TLI_vsnprintf : TargetLibCall_R<vsnprintf>;
/// int vsprintf(char *s, const char *format, va_list ap);
-def vsprintf : TargetLibCall<"vsprintf", Int, [Ptr, Ptr, Ptr]>;
+def TLI_vsprintf : TargetLibCall_R<vsprintf>;
/// int vsscanf(const char *s, const char *format, va_list arg);
-def vsscanf : TargetLibCall<"vsscanf", Int, [Ptr, Ptr, Ptr]>;
+def TLI_vsscanf : TargetLibCall_R<vsscanf>;
/// size_t wcslen (const wchar_t* wcs);
-def wcslen : TargetLibCall<"wcslen", SizeT, [Ptr]>;
+def TLI_wcslen : TargetLibCall_R<wcslen>;
/// ssize_t write(int fildes, const void *buf, size_t nbyte);
-def write : TargetLibCall<"write", SSizeT, [Int, Ptr, SizeT]>;
+def TLI_write : TargetLibCall_R<write>;
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 66500c9feabab..4207b31eb1a29 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -374,8 +374,8 @@ foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
def POW_F80 : RuntimeLibcall;
def POW_PPCF128 : RuntimeLibcall;
- def POW_FINITE_F32 : RuntimeLibcall<Dbl, [Dbl, Dbl], "pow_finite">;
- def POW_FINITE_F64 : RuntimeLibcall<Flt, [Flt, Flt], "powf_finite">;
+ def POW_FINITE_F32 : RuntimeLibcall<Flt, [Flt, Flt], "powf_finite">;
+ def POW_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "pow_finite">;
def POW_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "powl_finite">;
def POW_FINITE_F80 : RuntimeLibcall;
def POW_FINITE_PPCF128 : RuntimeLibcall;
@@ -1162,9 +1162,9 @@ def ZDAPVJ : RuntimeLibcall<Void, [Ptr, Int], "ZdaPvj">;
def ZDAPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int], "ZdaPvjSt11align_val_t">;
def ZDAPVM : RuntimeLibcall<Void, [Ptr, Long], "ZdaPvm">;
def ZDAPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long], "ZdaPvmSt11align_val_t">;
-def ZDAPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr], "ZdlPvRKSt9nothrow_t">;
-def ZDAPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus], "ZdlPvSt11align_val_t">;
-def ZDAPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr], "ZdlPvSt11align_val_tRKSt9nothrow_t">;
+def ZDAPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr], "ZdaPvRKSt9nothrow_t">;
+def ZDAPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus], "ZdaPvSt11align_val_t">;
+def ZDAPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr], "ZdaPvSt11align_val_tRKSt9nothrow_t">;
def ZDLPV : RuntimeLibcall<Void, [Ptr], "ZdlPv">;
def ZDLPVJ : RuntimeLibcall<Void, [Ptr, Int], "ZdlPvj">;
def ZDLPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int], "ZdlPvjSt11align_val_t">;
diff --git a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
index 6b1e95189ffdf..95e6b07cbfaaa 100644
--- a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
@@ -61,12 +61,12 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoEnum(
OS << "enum LibFunc : unsigned {\n";
OS.indent(2) << "NotLibFunc = 0,\n";
for (const auto *R : AllTargetLibcalls)
- OS.indent(2) << "LibFunc_" << R->getName() << ",\n";
+ OS.indent(2) << "LibFunc_" << R->getName().drop_front(4) << ",\n";
OS.indent(2) << "NumLibFuncs,\n";
OS.indent(2) << "End_LibFunc = NumLibFuncs,\n";
if (AllTargetLibcalls.size()) {
OS.indent(2) << "Begin_LibFunc = LibFunc_"
- << AllTargetLibcalls[0]->getName() << ",\n";
+ << AllTargetLibcalls[0]->getName().drop_front(4) << ",\n";
} else {
OS.indent(2) << "Begin_LibFunc = NotLibFunc,\n";
}
@@ -146,7 +146,7 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoSignatureTable(
Signature Sig;
Sig.reserve(Tys->size() + 1);
const Record *RetType = R->getValueAsOptionalDef("ReturnType");
- if (RetType)
+ if (RetType && (RetType->getName() != "NoneType"))
Sig.push_back(RetType->getName());
for (unsigned I = 0, E = Tys->size(); I < E; ++I) {
Sig.push_back(Tys->getElementAsRecord(I)->getName());
@@ -162,8 +162,11 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoSignatureTable(
IfDefEmitter IfDef(OS, "GET_TARGET_LIBRARY_INFO_SIGNATURE_TABLE");
OS << "enum FuncArgTypeID : char {\n";
OS.indent(2) << "NoFuncArgType = 0,\n";
- for (const auto *R : FuncTypeArgs)
+ for (const auto *R : FuncTypeArgs) {
+ if (R->getName() == "NoneType")
+ continue;
OS.indent(2) << R->getName() << ",\n";
+ }
OS << "};\n";
OS << "static const FuncArgTypeID SignatureTable[] = {\n";
SignatureTable.emit(OS, [](raw_ostream &OS, StringRef E) { OS << E; });
@@ -172,7 +175,7 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoSignatureTable(
OS.indent(2) << SignatureTable.get(NoFuncSig) << ", //\n";
for (const auto *R : AllTargetLibcalls) {
OS.indent(2) << SignatureTable.get(GetSignature(R)) << ", // "
- << R->getName() << "\n";
+ << R->getName().drop_front(4) << "\n";
}
OS << "};\n";
}
>From 0698ff6c49f12e8e1deb9d7b17a487977d234b5b Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Fri, 20 Mar 2026 19:56:02 +0000
Subject: [PATCH 3/8] Remove LibFuncEnumName from RuntimeLibcall.
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 922 ++++++++++----------
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 4 +-
2 files changed, 462 insertions(+), 464 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 4207b31eb1a29..9aa536377edc6 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -163,171 +163,171 @@ foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
//def CABS_#FPTy : RuntimeLibcall;
}
- def REM_F32 : RuntimeLibcall<Flt, [Flt, Flt], "fmodf">;
- def REM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "fmod">;
- def REM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "fmodl">;
+ def REM_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def REM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def REM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def REM_F80 : RuntimeLibcall;
def REM_PPCF128 : RuntimeLibcall;
- def SQRT_F32 : RuntimeLibcall<Flt, [Flt], "sqrtf">;
- def SQRT_F64 : RuntimeLibcall<Dbl, [Dbl], "sqrt">;
- def SQRT_F128 : RuntimeLibcall<LDbl, [LDbl], "sqrtl">;
+ def SQRT_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def SQRT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def SQRT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def SQRT_F80 : RuntimeLibcall;
def SQRT_PPCF128 : RuntimeLibcall;
- def CBRT_F32 : RuntimeLibcall<Flt, [Flt], "cbrtf">;
- def CBRT_F64 : RuntimeLibcall<Dbl, [Dbl], "cbrt">;
- def CBRT_F128 : RuntimeLibcall<LDbl, [LDbl], "cbrtl">;
+ def CBRT_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def CBRT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def CBRT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def CBRT_F80 : RuntimeLibcall;
def CBRT_PPCF128 : RuntimeLibcall;
- def LOG_F32 : RuntimeLibcall<Flt, [Flt], "logf">;
- def LOG_F64 : RuntimeLibcall<Dbl, [Dbl], "log">;
- def LOG_F128 : RuntimeLibcall<LDbl, [LDbl], "logl">;
+ def LOG_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def LOG_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def LOG_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def LOG_F80 : RuntimeLibcall;
def LOG_PPCF128 : RuntimeLibcall;
- def LOG_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "logf_finite">;
- def LOG_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "log_finite">;
- def LOG_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "logl_finite">;
+ def LOG_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def LOG_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def LOG_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def LOG_FINITE_F80 : RuntimeLibcall;
def LOG_FINITE_PPCF128 : RuntimeLibcall;
- def LOG2_F32 : RuntimeLibcall<Flt, [Flt], "log2f">;
- def LOG2_F64 : RuntimeLibcall<Dbl, [Dbl], "log2">;
- def LOG2_F128 : RuntimeLibcall<LDbl, [LDbl], "log2l">;
+ def LOG2_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def LOG2_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def LOG2_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def LOG2_F80 : RuntimeLibcall;
def LOG2_PPCF128 : RuntimeLibcall;
- def LOG2_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "log2f_finite">;
- def LOG2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "log2_finite">;
- def LOG2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "log2l_finite">;
+ def LOG2_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def LOG2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def LOG2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def LOG2_FINITE_F80 : RuntimeLibcall;
def LOG2_FINITE_PPCF128 : RuntimeLibcall;
- def LOG10_F32 : RuntimeLibcall<Flt, [Flt], "log10f">;
- def LOG10_F64 : RuntimeLibcall<Dbl, [Dbl], "log10">;
- def LOG10_F128 : RuntimeLibcall<LDbl, [LDbl], "log10l">;
+ def LOG10_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def LOG10_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def LOG10_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def LOG10_F80 : RuntimeLibcall;
def LOG10_PPCF128 : RuntimeLibcall;
- def LOG10_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "log10f_finite">;
- def LOG10_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "log10_finite">;
- def LOG10_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "log10l_finite">;
+ def LOG10_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def LOG10_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def LOG10_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def LOG10_FINITE_F80 : RuntimeLibcall;
def LOG10_FINITE_PPCF128 : RuntimeLibcall;
- def EXP_F32 : RuntimeLibcall<Flt, [Flt], "expf">;
- def EXP_F64 : RuntimeLibcall<Dbl, [Dbl], "exp">;
- def EXP_F128 : RuntimeLibcall<LDbl, [LDbl], "expl">;
+ def EXP_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def EXP_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def EXP_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def EXP_F80 : RuntimeLibcall;
def EXP_PPCF128 : RuntimeLibcall;
- def EXP_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "expf_finite">;
- def EXP_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "exp_finite">;
- def EXP_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "expl_finite">;
+ def EXP_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def EXP_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def EXP_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def EXP_FINITE_F80 : RuntimeLibcall;
def EXP_FINITE_PPCF128 : RuntimeLibcall;
- def EXP2_F32 : RuntimeLibcall<Flt, [Flt], "exp2f">;
- def EXP2_F64 : RuntimeLibcall<Dbl, [Dbl], "exp2">;
- def EXP2_F128 : RuntimeLibcall<LDbl, [LDbl], "exp2l">;
+ def EXP2_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def EXP2_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def EXP2_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def EXP2_F80 : RuntimeLibcall;
def EXP2_PPCF128 : RuntimeLibcall;
- def EXP2_FINITE_F32 : RuntimeLibcall<Flt, [Flt], "exp2f_finite">;
- def EXP2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl], "exp2_finite">;
- def EXP2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl], "exp2l_finite">;
+ def EXP2_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def EXP2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def EXP2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def EXP2_FINITE_F80 : RuntimeLibcall;
def EXP2_FINITE_PPCF128 : RuntimeLibcall;
- def EXP10_F32 : RuntimeLibcall<Flt, [Flt], "exp10f">;
- def EXP10_F64 : RuntimeLibcall<Dbl, [Dbl], "exp10">;
- def EXP10_F128 : RuntimeLibcall<LDbl, [LDbl], "exp10l">;
+ def EXP10_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def EXP10_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def EXP10_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def EXP10_F80 : RuntimeLibcall;
def EXP10_PPCF128 : RuntimeLibcall;
- def SIN_F32 : RuntimeLibcall<Flt, [Flt], "sinf">;
- def SIN_F64 : RuntimeLibcall<Dbl, [Dbl], "sin">;
- def SIN_F128 : RuntimeLibcall<LDbl, [LDbl], "sinl">;
+ def SIN_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def SIN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def SIN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def SIN_F80 : RuntimeLibcall;
def SIN_PPCF128 : RuntimeLibcall;
- def COS_F32 : RuntimeLibcall<Flt, [Flt], "cosf">;
- def COS_F64 : RuntimeLibcall<Dbl, [Dbl], "cos">;
- def COS_F128 : RuntimeLibcall<LDbl, [LDbl], "cosl">;
+ def COS_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def COS_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def COS_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def COS_F80 : RuntimeLibcall;
def COS_PPCF128 : RuntimeLibcall;
- def TAN_F32 : RuntimeLibcall<Flt, [Flt], "tanf">;
- def TAN_F64 : RuntimeLibcall<Dbl, [Dbl], "tan">;
- def TAN_F128 : RuntimeLibcall<LDbl, [LDbl], "tanl">;
+ def TAN_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def TAN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def TAN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def TAN_F80 : RuntimeLibcall;
def TAN_PPCF128 : RuntimeLibcall;
- def SINH_F32 : RuntimeLibcall<Flt, [Flt], "sinhf">;
- def SINH_F64 : RuntimeLibcall<Dbl, [Dbl], "sinh">;
- def SINH_F128 : RuntimeLibcall<LDbl, [LDbl], "sinhl">;
+ def SINH_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def SINH_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def SINH_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def SINH_F80 : RuntimeLibcall;
def SINH_PPCF128 : RuntimeLibcall;
- def COSH_F32 : RuntimeLibcall<Flt, [Flt], "coshf">;
- def COSH_F64 : RuntimeLibcall<Dbl, [Dbl], "cosh">;
- def COSH_F128 : RuntimeLibcall<LDbl, [LDbl], "coshl">;
+ def COSH_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def COSH_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def COSH_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def COSH_F80 : RuntimeLibcall;
def COSH_PPCF128 : RuntimeLibcall;
- def TANH_F32 : RuntimeLibcall<Flt, [Flt], "tanhf">;
- def TANH_F64 : RuntimeLibcall<Dbl, [Dbl], "tanh">;
- def TANH_F128 : RuntimeLibcall<LDbl, [LDbl], "tanhl">;
+ def TANH_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def TANH_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def TANH_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def TANH_F80 : RuntimeLibcall;
def TANH_PPCF128 : RuntimeLibcall;
- def ASIN_F32 : RuntimeLibcall<Flt, [Flt], "asinf">;
- def ASIN_F64 : RuntimeLibcall<Dbl, [Dbl], "asin">;
- def ASIN_F128 : RuntimeLibcall<LDbl, [LDbl], "asinl">;
+ def ASIN_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def ASIN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def ASIN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def ASIN_F80 : RuntimeLibcall;
def ASIN_PPCF128 : RuntimeLibcall;
- def ACOS_F32 : RuntimeLibcall<Flt, [Flt], "acosf">;
- def ACOS_F64 : RuntimeLibcall<Dbl, [Dbl], "acos">;
- def ACOS_F128 : RuntimeLibcall<LDbl, [LDbl], "acosl">;
+ def ACOS_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def ACOS_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def ACOS_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def ACOS_F80 : RuntimeLibcall;
def ACOS_PPCF128 : RuntimeLibcall;
- def ATAN_F32 : RuntimeLibcall<Flt, [Flt], "atanf">;
- def ATAN_F64 : RuntimeLibcall<Dbl, [Dbl], "atan">;
- def ATAN_F128 : RuntimeLibcall<LDbl, [LDbl], "atanl">;
+ def ATAN_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def ATAN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def ATAN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def ATAN_F80 : RuntimeLibcall;
def ATAN_PPCF128 : RuntimeLibcall;
- def ATAN2_F32 : RuntimeLibcall<Flt, [Flt, Flt], "atan2f">;
- def ATAN2_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "atan2">;
- def ATAN2_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "atan2l">;
+ def ATAN2_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def ATAN2_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def ATAN2_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def ATAN2_F80 : RuntimeLibcall;
def ATAN2_PPCF128 : RuntimeLibcall;
- def SINCOS_F32 : RuntimeLibcall<Void, [Flt, Ptr, Ptr], "sincosf">;
- def SINCOS_F64 : RuntimeLibcall<Void, [Dbl, Ptr, Ptr], "sincos">;
- def SINCOS_F128 : RuntimeLibcall<Void, [LDbl, Ptr, Ptr], "sincosl">;
+ def SINCOS_F32 : RuntimeLibcall<Void, [Flt, Ptr, Ptr]>;
+ def SINCOS_F64 : RuntimeLibcall<Void, [Dbl, Ptr, Ptr]>;
+ def SINCOS_F128 : RuntimeLibcall<Void, [LDbl, Ptr, Ptr]>;
def SINCOS_F80 : RuntimeLibcall;
def SINCOS_PPCF128 : RuntimeLibcall;
- def REMQUO_F32 : RuntimeLibcall<Flt, [Flt, Flt, Ptr], "remquof">;
- def REMQUO_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl, Ptr], "remquo">;
- def REMQUO_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl, Ptr], "remquol">;
+ def REMQUO_F32 : RuntimeLibcall<Flt, [Flt, Flt, Ptr]>;
+ def REMQUO_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl, Ptr]>;
+ def REMQUO_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl, Ptr]>;
def REMQUO_F80 : RuntimeLibcall;
def REMQUO_PPCF128 : RuntimeLibcall;
- def FDIM_F32 : RuntimeLibcall<Flt, [Flt, Flt], "fdimf">;
- def FDIM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "fdim">;
- def FDIM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "fdiml">;
+ def FDIM_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def FDIM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def FDIM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def FDIM_F80 : RuntimeLibcall;
def FDIM_PPCF128 : RuntimeLibcall;
- def CABS_F32 : RuntimeLibcall<NoneType, [], "cabsf">;
- def CABS_F64 : RuntimeLibcall<NoneType, [], "cabs">;
- def CABS_F128 : RuntimeLibcall<NoneType, [], "cabsl">;
+ def CABS_F32 : RuntimeLibcall<NoneType, []>;
+ def CABS_F64 : RuntimeLibcall<NoneType, []>;
+ def CABS_F128 : RuntimeLibcall<NoneType, []>;
def CABS_F80 : RuntimeLibcall;
def CABS_PPCF128 : RuntimeLibcall;
@@ -368,141 +368,141 @@ foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
//def TGAMMA_#FPTy : RuntimeLibcall;
}
- def POW_F32 : RuntimeLibcall<Flt, [Flt, Flt], "powf">;
- def POW_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "pow">;
- def POW_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "powl">;
+ def POW_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def POW_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def POW_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def POW_F80 : RuntimeLibcall;
def POW_PPCF128 : RuntimeLibcall;
- def POW_FINITE_F32 : RuntimeLibcall<Flt, [Flt, Flt], "powf_finite">;
- def POW_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "pow_finite">;
- def POW_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "powl_finite">;
+ def POW_FINITE_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def POW_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def POW_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def POW_FINITE_F80 : RuntimeLibcall;
def POW_FINITE_PPCF128 : RuntimeLibcall;
- def CEIL_F32 : RuntimeLibcall<Flt, [Flt], "ceilf">;
- def CEIL_F64 : RuntimeLibcall<Dbl, [Dbl], "ceil">;
- def CEIL_F128 : RuntimeLibcall<LDbl, [LDbl], "ceill">;
+ def CEIL_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def CEIL_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def CEIL_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def CEIL_F80 : RuntimeLibcall;
def CEIL_PPCF128 : RuntimeLibcall;
- def TRUNC_F32 : RuntimeLibcall<Flt, [Flt], "truncf">;
- def TRUNC_F64 : RuntimeLibcall<Dbl, [Dbl], "trunc">;
- def TRUNC_F128 : RuntimeLibcall<LDbl, [LDbl], "truncl">;
+ def TRUNC_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def TRUNC_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def TRUNC_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def TRUNC_F80 : RuntimeLibcall;
def TRUNC_PPCF128 : RuntimeLibcall;
- def RINT_F32 : RuntimeLibcall<Flt, [Flt], "rintf">;
- def RINT_F64 : RuntimeLibcall<Dbl, [Dbl], "rint">;
- def RINT_F128 : RuntimeLibcall<LDbl, [LDbl], "rintl">;
+ def RINT_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def RINT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def RINT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def RINT_F80 : RuntimeLibcall;
def RINT_PPCF128 : RuntimeLibcall;
- def NEARBYINT_F32 : RuntimeLibcall<Flt, [Flt], "nearbyintf">;
- def NEARBYINT_F64 : RuntimeLibcall<Dbl, [Dbl], "nearbyint">;
- def NEARBYINT_F128 : RuntimeLibcall<LDbl, [LDbl], "nearbyintl">;
+ def NEARBYINT_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def NEARBYINT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def NEARBYINT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def NEARBYINT_F80 : RuntimeLibcall;
def NEARBYINT_PPCF128 : RuntimeLibcall;
- def ROUND_F32 : RuntimeLibcall<Flt, [Flt], "roundf">;
- def ROUND_F64 : RuntimeLibcall<Dbl, [Dbl], "round">;
- def ROUND_F128 : RuntimeLibcall<LDbl, [LDbl], "roundl">;
+ def ROUND_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def ROUND_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def ROUND_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def ROUND_F80 : RuntimeLibcall;
def ROUND_PPCF128 : RuntimeLibcall;
- def ROUNDEVEN_F32 : RuntimeLibcall<Flt, [Flt], "roundevenf">;
- def ROUNDEVEN_F64 : RuntimeLibcall<Dbl, [Dbl], "roundeven">;
- def ROUNDEVEN_F128 : RuntimeLibcall<LDbl, [LDbl], "roundevenl">;
+ def ROUNDEVEN_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def ROUNDEVEN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def ROUNDEVEN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def ROUNDEVEN_F80 : RuntimeLibcall;
def ROUNDEVEN_PPCF128 : RuntimeLibcall;
- def FLOOR_F32 : RuntimeLibcall<Flt, [Flt], "floorf">;
- def FLOOR_F64 : RuntimeLibcall<Dbl, [Dbl], "floor">;
- def FLOOR_F128 : RuntimeLibcall<LDbl, [LDbl], "floorl">;
+ def FLOOR_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def FLOOR_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def FLOOR_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def FLOOR_F80 : RuntimeLibcall;
def FLOOR_PPCF128 : RuntimeLibcall;
- def COPYSIGN_F32 : RuntimeLibcall<Flt, [Flt, Flt], "copysignf">;
- def COPYSIGN_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "copysign">;
- def COPYSIGN_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "copysignl">;
+ def COPYSIGN_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def COPYSIGN_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def COPYSIGN_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def COPYSIGN_F80 : RuntimeLibcall;
def COPYSIGN_PPCF128 : RuntimeLibcall;
- def FMIN_F32 : RuntimeLibcall<Floating, [Same, Same], "fminf">;
- def FMIN_F64 : RuntimeLibcall<Floating, [Same, Same], "fmin">;
- def FMIN_F128 : RuntimeLibcall<Floating, [Same, Same], "fminl">;
+ def FMIN_F32 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMIN_F64 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMIN_F128 : RuntimeLibcall<Floating, [Same, Same]>;
def FMIN_F80 : RuntimeLibcall;
def FMIN_PPCF128 : RuntimeLibcall;
- def FMAX_F32 : RuntimeLibcall<Floating, [Same, Same], "fmaxf">;
- def FMAX_F64 : RuntimeLibcall<Floating, [Same, Same], "fmax">;
- def FMAX_F128 : RuntimeLibcall<Floating, [Same, Same], "fmaxl">;
+ def FMAX_F32 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMAX_F64 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMAX_F128 : RuntimeLibcall<Floating, [Same, Same]>;
def FMAX_F80 : RuntimeLibcall;
def FMAX_PPCF128 : RuntimeLibcall;
- def FMINIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same], "fminimum_numf">;
- def FMINIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same], "fminimum_num">;
- def FMINIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same], "fminimum_numl">;
+ def FMINIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMINIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMINIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same]>;
def FMINIMUM_NUM_F80 : RuntimeLibcall;
def FMINIMUM_NUM_PPCF128 : RuntimeLibcall;
- def FMAXIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same], "fmaximum_numf">;
- def FMAXIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same], "fmaximum_num">;
- def FMAXIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same], "fmaximum_numl">;
+ def FMAXIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMAXIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMAXIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same]>;
def FMAXIMUM_NUM_F80 : RuntimeLibcall;
def FMAXIMUM_NUM_PPCF128 : RuntimeLibcall;
- def LDEXP_F32 : RuntimeLibcall<Flt, [Flt, Int], "ldexpf">;
- def LDEXP_F64 : RuntimeLibcall<Dbl, [Dbl, Int], "ldexp">;
- def LDEXP_F128 : RuntimeLibcall<LDbl, [LDbl, Int], "ldexpl">;
+ def LDEXP_F32 : RuntimeLibcall<Flt, [Flt, Int]>;
+ def LDEXP_F64 : RuntimeLibcall<Dbl, [Dbl, Int]>;
+ def LDEXP_F128 : RuntimeLibcall<LDbl, [LDbl, Int]>;
def LDEXP_F80 : RuntimeLibcall;
def LDEXP_PPCF128 : RuntimeLibcall;
- def FREXP_F32 : RuntimeLibcall<Flt, [Flt, Ptr], "frexpf">;
- def FREXP_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr], "frexp">;
- def FREXP_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr], "frexpl">;
+ def FREXP_F32 : RuntimeLibcall<Flt, [Flt, Ptr]>;
+ def FREXP_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr]>;
+ def FREXP_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr]>;
def FREXP_F80 : RuntimeLibcall;
def FREXP_PPCF128 : RuntimeLibcall;
- def MODF_F32 : RuntimeLibcall<Flt, [Flt, Ptr], "modff">;
- def MODF_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr], "modf">;
- def MODF_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr], "modfl">;
+ def MODF_F32 : RuntimeLibcall<Flt, [Flt, Ptr]>;
+ def MODF_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr]>;
+ def MODF_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr]>;
def MODF_F80 : RuntimeLibcall;
def MODF_PPCF128 : RuntimeLibcall;
- def NAN_F32 : RuntimeLibcall<Flt, [Ptr], "nanf">;
- def NAN_F64 : RuntimeLibcall<Dbl, [Ptr], "nan">;
- def NAN_F128 : RuntimeLibcall<LDbl, [Ptr], "nanl">;
+ def NAN_F32 : RuntimeLibcall<Flt, [Ptr]>;
+ def NAN_F64 : RuntimeLibcall<Dbl, [Ptr]>;
+ def NAN_F128 : RuntimeLibcall<LDbl, [Ptr]>;
def NAN_F80 : RuntimeLibcall;
def NAN_PPCF128 : RuntimeLibcall;
- def NEXTTOWARD_F32 : RuntimeLibcall<Flt, [Flt, LDbl], "nexttowardf">;
- def NEXTTOWARD_F64 : RuntimeLibcall<Dbl, [Dbl, LDbl], "nexttoward">;
- def NEXTTOWARD_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "nexttowardl">;
+ def NEXTTOWARD_F32 : RuntimeLibcall<Flt, [Flt, LDbl]>;
+ def NEXTTOWARD_F64 : RuntimeLibcall<Dbl, [Dbl, LDbl]>;
+ def NEXTTOWARD_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def NEXTTOWARD_F80 : RuntimeLibcall;
def NEXTTOWARD_PPCF128 : RuntimeLibcall;
- def REMAINDER_F32 : RuntimeLibcall<Flt, [Flt, Flt], "remainderf">;
- def REMAINDER_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl], "remainder">;
- def REMAINDER_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl], "remainderl">;
+ def REMAINDER_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
+ def REMAINDER_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
+ def REMAINDER_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
def REMAINDER_F80 : RuntimeLibcall;
def REMAINDER_PPCF128 : RuntimeLibcall;
- def SCALBLN_F32 : RuntimeLibcall<Flt, [Flt, Long], "scalblnf">;
- def SCALBLN_F64 : RuntimeLibcall<Dbl, [Dbl, Long], "scalbln">;
- def SCALBLN_F128 : RuntimeLibcall<LDbl, [LDbl, Long], "scalblnl">;
+ def SCALBLN_F32 : RuntimeLibcall<Flt, [Flt, Long]>;
+ def SCALBLN_F64 : RuntimeLibcall<Dbl, [Dbl, Long]>;
+ def SCALBLN_F128 : RuntimeLibcall<LDbl, [LDbl, Long]>;
def SCALBLN_F80 : RuntimeLibcall;
def SCALBLN_PPCF128 : RuntimeLibcall;
- def SCALBN_F32 : RuntimeLibcall<Flt, [Flt, Int], "scalbnf">;
- def SCALBN_F64 : RuntimeLibcall<Dbl, [Dbl, Int], "scalbn">;
- def SCALBN_F128 : RuntimeLibcall<LDbl, [LDbl, Int], "scalbnl">;
+ def SCALBN_F32 : RuntimeLibcall<Flt, [Flt, Int]>;
+ def SCALBN_F64 : RuntimeLibcall<Dbl, [Dbl, Int]>;
+ def SCALBN_F128 : RuntimeLibcall<LDbl, [LDbl, Int]>;
def SCALBN_F80 : RuntimeLibcall;
def SCALBN_PPCF128 : RuntimeLibcall;
- def TGAMMA_F32 : RuntimeLibcall<Flt, [Flt], "tgammaf">;
- def TGAMMA_F64 : RuntimeLibcall<Dbl, [Dbl], "tgamma">;
- def TGAMMA_F128 : RuntimeLibcall<LDbl, [LDbl], "tgammal">;
+ def TGAMMA_F32 : RuntimeLibcall<Flt, [Flt]>;
+ def TGAMMA_F64 : RuntimeLibcall<Dbl, [Dbl]>;
+ def TGAMMA_F128 : RuntimeLibcall<LDbl, [LDbl]>;
def TGAMMA_F80 : RuntimeLibcall;
def TGAMMA_PPCF128 : RuntimeLibcall;
@@ -693,18 +693,18 @@ foreach FPTy = ["F32", "F64", "F128", "PPCF128"] in {
}
// Memory
-def MEMCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "memcmp">;
-def MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "memcpy">;
-def MEMCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "memcpy_chk">;
-def MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "memmove">;
-def MEMMOVE_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "memmove_chk">;
-def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT], "memset">;
-def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT], "memset_chk">;
-def MALLOC : RuntimeLibcall<Ptr, [SizeT], "malloc">;
-def CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT], "calloc">;
-def FREE : RuntimeLibcall<Void, [Ptr], "free">;
-def BZERO : RuntimeLibcall<Void, [Ptr, SizeT], "bzero">;
-def STRLEN : RuntimeLibcall<SizeT, [Ptr], "strlen">;
+def MEMCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]>;
+def MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def MEMCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def MEMMOVE_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
+def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT]>;
+def MALLOC : RuntimeLibcall<Ptr, [SizeT]>;
+def CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT]>;
+def FREE : RuntimeLibcall<Void, [Ptr]>;
+def BZERO : RuntimeLibcall<Void, [Ptr, SizeT]>;
+def STRLEN : RuntimeLibcall<SizeT, [Ptr]>;
// Element-wise unordered-atomic memory of different sizes
foreach MemSize = [1, 2, 4, 8, 16] in {
@@ -751,8 +751,8 @@ defset list<RuntimeLibcall> LibCalls__atomic = {
def ATOMIC_COMPARE_EXCHANGE#MemSize : RuntimeLibcall;
}
- def ATOMIC_LOAD : RuntimeLibcall<Void, [SizeT, Ptr, Ptr, Int], "atomic_load">;
- def ATOMIC_STORE : RuntimeLibcall<Void, [SizeT, Ptr, Ptr, Int], "atomic_store">;
+ def ATOMIC_LOAD : RuntimeLibcall<Void, [SizeT, Ptr, Ptr, Int]>;
+ def ATOMIC_STORE : RuntimeLibcall<Void, [SizeT, Ptr, Ptr, Int]>;
foreach MemSize = ["_1", "_2", "_4", "_8", "_16"] in {
def ATOMIC_LOAD#MemSize : RuntimeLibcall;
def ATOMIC_STORE#MemSize : RuntimeLibcall;
@@ -904,301 +904,301 @@ def OBJC_RETAIN_AUTORELEASE : RuntimeLibcall;
def OBJC_SYNC_ENTER : RuntimeLibcall;
def OBJC_SYNC_EXIT : RuntimeLibcall;
-def ABORT : RuntimeLibcall<Void, [], "abort">;
-def ABS : RuntimeLibcall<Int, [Int], "abs">;
-def ACCESS : RuntimeLibcall<Int, [Ptr, Int], "access">;
-def ALIGNED_ALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT], "aligned_alloc">;
-def ATEXIT : RuntimeLibcall<Int, [Ptr], "atexit">;
-def ATOF : RuntimeLibcall<Dbl, [Ptr], "atof">;
-def ATOI : RuntimeLibcall<Int, [Ptr], "atoi">;
-def ATOL : RuntimeLibcall<Long, [Ptr], "atol">;
-def ATOLL : RuntimeLibcall<LLong, [Ptr], "atoll">;
-def BCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "bcmp">;
-def BCOPY : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "bcopy">;
-def CHMOD : RuntimeLibcall<Int, [Ptr, IntX], "chmod">;
-def CHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX], "chown">;
-def CLEARERR : RuntimeLibcall<Void, [Ptr], "clearerr">;
-def CLOSEDIR : RuntimeLibcall<Int, [Ptr], "closedir">;
-def CTERMID : RuntimeLibcall<Ptr, [Ptr], "ctermid">;
-def CXA_ATEXIT : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "cxa_atexit">;
-def CXA_GUARD_ABORT : RuntimeLibcall<Void, [Ptr], "cxa_guard_abort">;
-def CXA_GUARD_ACQUIRE : RuntimeLibcall<Int, [Ptr], "cxa_guard_acquire">;
-def CXA_GUARD_RELEASE : RuntimeLibcall<Void, [Ptr], "cxa_guard_release">;
-def CXA_THROW : RuntimeLibcall<Void, [Ptr, Ptr, Ptr], "cxa_throw">;
-def DUNDER_ISOC99_SCANF : RuntimeLibcall<Int, [Ptr, Ellip], "dunder_isoc99_scanf">;
-def DUNDER_ISOC99_SSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "dunder_isoc99_sscanf">;
-def DUNDER_STRDUP : RuntimeLibcall<Ptr, [Ptr], "dunder_strdup">;
-def DUNDER_STRNDUP : RuntimeLibcall<Ptr, [Ptr, SizeT], "dunder_strndup">;
-def DUNDER_STRTOK_R : RuntimeLibcall<Ptr, [Ptr, Ptr, Ptr], "dunder_strtok_r">;
+def ABORT : RuntimeLibcall<Void, []>;
+def ABS : RuntimeLibcall<Int, [Int]>;
+def ACCESS : RuntimeLibcall<Int, [Ptr, Int]>;
+def ALIGNED_ALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT]>;
+def ATEXIT : RuntimeLibcall<Int, [Ptr]>;
+def ATOF : RuntimeLibcall<Dbl, [Ptr]>;
+def ATOI : RuntimeLibcall<Int, [Ptr]>;
+def ATOL : RuntimeLibcall<Long, [Ptr]>;
+def ATOLL : RuntimeLibcall<LLong, [Ptr]>;
+def BCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]>;
+def BCOPY : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def CHMOD : RuntimeLibcall<Int, [Ptr, IntX]>;
+def CHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX]>;
+def CLEARERR : RuntimeLibcall<Void, [Ptr]>;
+def CLOSEDIR : RuntimeLibcall<Int, [Ptr]>;
+def CTERMID : RuntimeLibcall<Ptr, [Ptr]>;
+def CXA_ATEXIT : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def CXA_GUARD_ABORT : RuntimeLibcall<Void, [Ptr]>;
+def CXA_GUARD_ACQUIRE : RuntimeLibcall<Int, [Ptr]>;
+def CXA_GUARD_RELEASE : RuntimeLibcall<Void, [Ptr]>;
+def CXA_THROW : RuntimeLibcall<Void, [Ptr, Ptr, Ptr]>;
+def DUNDER_ISOC99_SCANF : RuntimeLibcall<Int, [Ptr, Ellip]>;
+def DUNDER_ISOC99_SSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def DUNDER_STRDUP : RuntimeLibcall<Ptr, [Ptr]>;
+def DUNDER_STRNDUP : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def DUNDER_STRTOK_R : RuntimeLibcall<Ptr, [Ptr, Ptr, Ptr]>;
def ENUM_VARIANT : RuntimeLibcall;
-def EXECL : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "execl">;
-def EXECLE : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "execle">;
-def EXECLP : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "execlp">;
-def EXECV : RuntimeLibcall<Int, [Ptr, Ptr], "execv">;
-def EXECVE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "execve">;
-def EXECVP : RuntimeLibcall<Int, [Ptr, Ptr], "execvp">;
-def EXECVPE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "execvpe">;
-def EXIT : RuntimeLibcall<Void, [Int], "exit">;
-def FCLOSE : RuntimeLibcall<Int, [Ptr], "fclose">;
-def FDOPEN : RuntimeLibcall<Ptr, [Int, Ptr], "fdopen">;
-def FEOF : RuntimeLibcall<Int, [Ptr], "feof">;
-def FERROR : RuntimeLibcall<Int, [Ptr], "ferror">;
-def FFLUSH : RuntimeLibcall<Int, [Ptr], "fflush">;
-def FFS : RuntimeLibcall<Int, [Int], "ffs">;
-def FFSL : RuntimeLibcall<Int, [Long], "ffsl">;
-def FFSLL : RuntimeLibcall<Int, [LLong], "ffsll">;
-def FGETC : RuntimeLibcall<Int, [Ptr], "fgetc">;
-def FGETC_UNLOCKED : RuntimeLibcall<Int, [Ptr], "fgetc_unlocked">;
-def FGETPOS : RuntimeLibcall<Int, [Ptr, Ptr], "fgetpos">;
-def FGETS : RuntimeLibcall<Ptr, [Ptr, Int, Ptr], "fgets">;
-def FGETS_UNLOCKED : RuntimeLibcall<Ptr, [Ptr, Int, Ptr], "fgets_unlocked">;
-def FILENO : RuntimeLibcall<Int, [Ptr], "fileno">;
-def FIPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "fiprintf">;
-def FLOCKFILE : RuntimeLibcall<Void, [Ptr], "flockfile">;
-def FLS : RuntimeLibcall<Int, [Int], "fls">;
-def FLSL : RuntimeLibcall<Int, [Long], "flsl">;
-def FLSLL : RuntimeLibcall<Int, [LLong], "flsll">;
-def FOPEN : RuntimeLibcall<Ptr, [Ptr, Ptr], "fopen">;
-def FOPEN64 : RuntimeLibcall<Ptr, [Ptr, Ptr], "fopen64">;
-def FORK : RuntimeLibcall<Int, [], "fork">;
-def FPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "fprintf">;
-def FPUTC : RuntimeLibcall<Int, [Int, Ptr], "fputc">;
-def FPUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr], "fputc_unlocked">;
-def FPUTS : RuntimeLibcall<Int, [Ptr, Ptr], "fputs">;
-def FPUTS_UNLOCKED : RuntimeLibcall<Int, [Ptr, Ptr], "fputs_unlocked">;
-def FREAD : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fread">;
-def FREAD_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fread_unlocked">;
-def FSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "fscanf">;
-def FSEEK : RuntimeLibcall<Int, [Ptr, Long, Int], "fseek">;
-def FSEEKO : RuntimeLibcall<Int, [Ptr, IntX, Int], "fseeko">;
-def FSEEKO64 : RuntimeLibcall<Int, [Ptr, Int64, Int], "fseeko64">;
-def FSETPOS : RuntimeLibcall<Int, [Ptr, Ptr], "fsetpos">;
-def FSTAT : RuntimeLibcall<Int, [Int, Ptr], "fstat">;
-def FSTAT64 : RuntimeLibcall<Int, [Int, Ptr], "fstat64">;
-def FSTATVFS : RuntimeLibcall<Int, [Int, Ptr], "fstatvfs">;
-def FSTATVFS64 : RuntimeLibcall<Int, [Int, Ptr], "fstatvfs64">;
-def FTELL : RuntimeLibcall<Long, [Ptr], "ftell">;
-def FTELLO : RuntimeLibcall<IntPlus, [Ptr], "ftello">;
-def FTELLO64 : RuntimeLibcall<Int64, [Ptr], "ftello64">;
-def FTRYLOCKFILE : RuntimeLibcall<Int, [Ptr], "ftrylockfile">;
-def FUNLOCKFILE : RuntimeLibcall<Void, [Ptr], "funlockfile">;
-def FWRITE : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fwrite">;
-def FWRITE_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr], "fwrite_unlocked">;
-def GETC : RuntimeLibcall<Int, [Ptr], "getc">;
-def GETCHAR : RuntimeLibcall<Int, [], "getchar">;
-def GETCHAR_UNLOCKED : RuntimeLibcall<Int, [], "getchar_unlocked">;
-def GETC_UNLOCKED : RuntimeLibcall<Int, [Ptr], "getc_unlocked">;
-def GETENV : RuntimeLibcall<Ptr, [Ptr], "getenv">;
-def GETITIMER : RuntimeLibcall<Int, [Int, Ptr], "getitimer">;
-def GETLOGIN_R : RuntimeLibcall<Int, [Ptr, SizeT], "getlogin_r">;
-def GETPWNAM : RuntimeLibcall<Ptr, [Ptr], "getpwnam">;
-def GETS : RuntimeLibcall<Ptr, [Ptr], "gets">;
-def GETTIMEOFDAY : RuntimeLibcall<Int, [Ptr, Ptr], "gettimeofday">;
-def HTONL : RuntimeLibcall<Int32, [Int32], "htonl">;
-def HTONS : RuntimeLibcall<Int16, [Int16], "htons">;
-def IPRINTF : RuntimeLibcall<Int, [Ptr, Ellip], "iprintf">;
-def ISASCII : RuntimeLibcall<Int, [Int], "isascii">;
-def ISDIGIT : RuntimeLibcall<Int, [Int], "isdigit">;
-def LABS : RuntimeLibcall<Long, [Same], "labs">;
-def LCHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX], "lchown">;
-def LLABS : RuntimeLibcall<LLong, [LLong], "llabs">;
-def LSTAT : RuntimeLibcall<Int, [Ptr, Ptr], "lstat">;
-def LSTAT64 : RuntimeLibcall<Int, [Ptr, Ptr], "lstat64">;
-def MEMALIGN : RuntimeLibcall<Ptr, [SizeT, SizeT], "memalign">;
-def MEMCCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, Int, SizeT], "memccpy">;
-def MEMCCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, Int, SizeT, SizeT], "memccpy_chk">;
-def MEMCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT], "memchr">;
-def MEMPCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "mempcpy">;
-def MEMPCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "mempcpy_chk">;
-def MEMRCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT], "memrchr">;
-def MEMSET_PATTERN16 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "memset_pattern16">;
-def MEMSET_PATTERN4 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "memset_pattern4">;
-def MEMSET_PATTERN8 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT], "memset_pattern8">;
-def MKDIR : RuntimeLibcall<Int, [Ptr, IntX], "mkdir">;
-def MKTIME : RuntimeLibcall<IntPlus, [Ptr], "mktime">;
-def MSVC_DELETE_ARRAY_PTR32 : RuntimeLibcall<Void, [Ptr], "msvc_delete_array_ptr32">;
-def MSVC_DELETE_ARRAY_PTR32_INT : RuntimeLibcall<Void, [Ptr, Int], "msvc_delete_array_ptr32_int">;
-def MSVC_DELETE_ARRAY_PTR32_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_array_ptr32_nothrow">;
-def MSVC_DELETE_ARRAY_PTR64 : RuntimeLibcall<Void, [Ptr], "msvc_delete_array_ptr64">;
-def MSVC_DELETE_ARRAY_PTR64_LONGLONG : RuntimeLibcall<Void, [Ptr, LLong], "msvc_delete_array_ptr64_longlong">;
-def MSVC_DELETE_ARRAY_PTR64_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_array_ptr64_nothrow">;
-def MSVC_DELETE_PTR32 : RuntimeLibcall<Void, [Ptr], "msvc_delete_ptr32">;
-def MSVC_DELETE_PTR32_INT : RuntimeLibcall<Void, [Ptr, Int], "msvc_delete_ptr32_int">;
-def MSVC_DELETE_PTR32_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_ptr32_nothrow">;
-def MSVC_DELETE_PTR64 : RuntimeLibcall<Void, [Ptr], "msvc_delete_ptr64">;
-def MSVC_DELETE_PTR64_LONGLONG : RuntimeLibcall<Void, [Ptr, LLong], "msvc_delete_ptr64_longlong">;
-def MSVC_DELETE_PTR64_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr], "msvc_delete_ptr64_nothrow">;
-def MSVC_NEW_ARRAY_INT : RuntimeLibcall<Ptr, [Int], "msvc_new_array_int">;
-def MSVC_NEW_ARRAY_INT_NOTHROW : RuntimeLibcall<Ptr, [Int, Ptr], "msvc_new_array_int_nothrow">;
-def MSVC_NEW_ARRAY_LONGLONG : RuntimeLibcall<Ptr, [LLong], "msvc_new_array_longlong">;
-def MSVC_NEW_ARRAY_LONGLONG_NOTHROW : RuntimeLibcall<Ptr, [LLong, Ptr], "msvc_new_array_longlong_nothrow">;
-def MSVC_NEW_INT : RuntimeLibcall<Ptr, [Int], "msvc_new_int">;
-def MSVC_NEW_INT_NOTHROW : RuntimeLibcall<Ptr, [Int, Ptr], "msvc_new_int_nothrow">;
-def MSVC_NEW_LONGLONG : RuntimeLibcall<Ptr, [LLong], "msvc_new_longlong">;
-def MSVC_NEW_LONGLONG_NOTHROW : RuntimeLibcall<Ptr, [LLong, Ptr], "msvc_new_longlong_nothrow">;
-def NTOHL : RuntimeLibcall<Int32, [Int32], "ntohl">;
-def NTOHS : RuntimeLibcall<Int16, [Int16], "ntohs">;
-def OPEN : RuntimeLibcall<Int, [Ptr, Int, Ellip], "open">;
-def OPEN64 : RuntimeLibcall<Int, [Ptr, Int, Ellip], "open64">;
-def OPENDIR : RuntimeLibcall<Ptr, [Ptr], "opendir">;
-def PCLOSE : RuntimeLibcall<Int, [Ptr], "pclose">;
-def PERROR : RuntimeLibcall<Void, [Ptr], "perror">;
-def POPEN : RuntimeLibcall<Ptr, [Ptr, Ptr], "popen">;
-def POSIX_MEMALIGN : RuntimeLibcall<Int, [Ptr, SizeT, SizeT], "posix_memalign">;
-def PREAD : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus], "pread">;
-def PRINTF : RuntimeLibcall<Int, [Ptr, Ellip], "printf">;
-def PUTC : RuntimeLibcall<Int, [Int, Ptr], "putc">;
-def PUTCHAR : RuntimeLibcall<Int, [Int], "putchar">;
-def PUTCHAR_UNLOCKED : RuntimeLibcall<Int, [Int], "putchar_unlocked">;
-def PUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr], "putc_unlocked">;
-def PUTS : RuntimeLibcall<Int, [Ptr], "puts">;
-def PVALLOC : RuntimeLibcall<Ptr, [SizeT], "pvalloc">;
-def PWRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus], "pwrite">;
-def QSORT : RuntimeLibcall<Void, [Ptr, SizeT, SizeT, Ptr], "qsort">;
-def READ : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT], "read">;
-def READLINK : RuntimeLibcall<SSizeT, [Ptr, Ptr, SizeT], "readlink">;
-def REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT], "realloc">;
-def REALLOCARRAY : RuntimeLibcall<Ptr, [Ptr, SizeT, SizeT], "reallocarray">;
-def REALLOCF : RuntimeLibcall<Ptr, [Ptr, SizeT], "reallocf">;
-def REALPATH : RuntimeLibcall<Ptr, [Ptr, Ptr], "realpath">;
-def REMOVE : RuntimeLibcall<Int, [Ptr], "remove">;
-def RENAME : RuntimeLibcall<Int, [Ptr, Ptr], "rename">;
-def REWIND : RuntimeLibcall<Void, [Ptr], "rewind">;
-def RMDIR : RuntimeLibcall<Int, [Ptr], "rmdir">;
-def SCANF : RuntimeLibcall<Int, [Ptr, Ellip], "scanf">;
-def SETBUF : RuntimeLibcall<Void, [Ptr, Ptr], "setbuf">;
-def SETITIMER : RuntimeLibcall<Int, [Int, Ptr, Ptr], "setitimer">;
-def SETVBUF : RuntimeLibcall<Int, [Ptr, Ptr, Int, SizeT], "setvbuf">;
-def SIPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "siprintf">;
-def SIZE_RETURNING_NEW : RuntimeLibcall<NoneType, [], "size_returning_new">;
-def SIZE_RETURNING_NEW_ALIGNED : RuntimeLibcall<NoneType, [], "size_returning_new_aligned">;
-def SIZE_RETURNING_NEW_ALIGNED_HOT_COLD : RuntimeLibcall<NoneType, [], "size_returning_new_aligned_hot_cold">;
-def SIZE_RETURNING_NEW_HOT_COLD : RuntimeLibcall<NoneType, [], "size_returning_new_hot_cold">;
-def SMALL_FPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "small_fprintf">;
-def SMALL_PRINTF : RuntimeLibcall<Int, [Ptr, Ellip], "small_printf">;
-def SMALL_SPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "small_sprintf">;
-def SNPRINTF : RuntimeLibcall<Int, [Ptr, SizeT, Ptr, Ellip], "snprintf">;
-def SNPRINTF_CHK : RuntimeLibcall<Int, [Ptr, SizeT, Int, SizeT, Ptr, Ellip], "snprintf_chk">;
-def SPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "sprintf">;
-def SPRINTF_CHK : RuntimeLibcall<Int, [Ptr, Int, SizeT, Ptr, Ellip], "sprintf_chk">;
-def SSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip], "sscanf">;
-def STAT : RuntimeLibcall<Int, [Ptr, Ptr], "stat">;
-def STAT64 : RuntimeLibcall<Int, [Ptr, Ptr], "stat64">;
-def STATVFS : RuntimeLibcall<Int, [Ptr, Ptr], "statvfs">;
-def STATVFS64 : RuntimeLibcall<Int, [Ptr, Ptr], "statvfs64">;
-def STPCPY : RuntimeLibcall<Ptr, [Ptr, Ptr], "stpcpy">;
-def STPCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "stpcpy_chk">;
-def STPNCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "stpncpy">;
-def STPNCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "stpncpy_chk">;
-def STRCASECMP : RuntimeLibcall<Int, [Ptr, Ptr], "strcasecmp">;
-def STRCAT : RuntimeLibcall<Ptr, [Ptr, Ptr], "strcat">;
-def STRCAT_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strcat_chk">;
-def STRCHR : RuntimeLibcall<Ptr, [Ptr, Int], "strchr">;
-def STRCMP : RuntimeLibcall<Int, [Ptr, Ptr], "strcmp">;
-def STRCOLL : RuntimeLibcall<Int, [Ptr, Ptr], "strcoll">;
-def STRCPY : RuntimeLibcall<Ptr, [Ptr, Ptr], "strcpy">;
-def STRCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strcpy_chk">;
-def STRCSPN : RuntimeLibcall<SizeT, [Ptr, Ptr], "strcspn">;
-def STRDUP : RuntimeLibcall<Ptr, [Ptr], "strdup">;
-def STRLCAT : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT], "strlcat">;
-def STRLCAT_CHK : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT, SizeT], "strlcat_chk">;
-def STRLCPY : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT], "strlcpy">;
-def STRLCPY_CHK : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT, SizeT], "strlcpy_chk">;
-def STRLEN_CHK : RuntimeLibcall<SizeT, [Ptr, SizeT], "strlen_chk">;
-def STRNCASECMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "strncasecmp">;
-def STRNCAT : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strncat">;
-def STRNCAT_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "strncat_chk">;
-def STRNCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT], "strncmp">;
-def STRNCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT], "strncpy">;
-def STRNCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT], "strncpy_chk">;
-def STRNDUP : RuntimeLibcall<Ptr, [Ptr, SizeT], "strndup">;
-def STRNLEN : RuntimeLibcall<SizeT, [Ptr, SizeT], "strnlen">;
-def STRPBRK : RuntimeLibcall<Ptr, [Ptr, Ptr], "strpbrk">;
-def STRRCHR : RuntimeLibcall<Ptr, [Ptr, Int], "strrchr">;
-def STRSPN : RuntimeLibcall<SizeT, [Ptr, Ptr], "strspn">;
-def STRSTR : RuntimeLibcall<Ptr, [Ptr, Ptr], "strstr">;
-def STRTOD : RuntimeLibcall<Dbl, [Ptr, Ptr], "strtod">;
-def STRTOF : RuntimeLibcall<Flt, [Ptr, Ptr], "strtof">;
-def STRTOK : RuntimeLibcall<Ptr, [Ptr, Ptr], "strtok">;
-def STRTOK_R : RuntimeLibcall<Ptr, [Ptr, Ptr, Ptr], "strtok_r">;
-def STRTOL : RuntimeLibcall<Long, [Ptr, Ptr, Int], "strtol">;
-def STRTOLD : RuntimeLibcall<LDbl, [Ptr, Ptr], "strtold">;
-def STRTOLL : RuntimeLibcall<LLong, [Ptr, Ptr, Int], "strtoll">;
-def STRTOUL : RuntimeLibcall<Long, [Ptr, Ptr, Int], "strtoul">;
-def STRTOULL : RuntimeLibcall<LLong, [Ptr, Ptr, Int], "strtoull">;
-def STRXFRM : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT], "strxfrm">;
-def SYSTEM : RuntimeLibcall<Int, [Ptr], "system">;
-def TERMINATE : RuntimeLibcall<Void, [], "terminate">;
-def TIMES : RuntimeLibcall<IntPlus, [Ptr], "times">;
-def TMPFILE : RuntimeLibcall<Ptr, [], "tmpfile">;
-def TMPFILE64 : RuntimeLibcall<Ptr, [], "tmpfile64">;
-def TOASCII : RuntimeLibcall<Int, [Int], "toascii">;
-def UNAME : RuntimeLibcall<Int, [Ptr], "uname">;
-def UNDER_IO_GETC : RuntimeLibcall<Int, [Ptr], "under_IO_getc">;
-def UNDER_IO_PUTC : RuntimeLibcall<Int, [Int, Ptr], "under_IO_putc">;
-def UNGETC : RuntimeLibcall<Int, [Int, Ptr], "ungetc">;
-def UNLINK : RuntimeLibcall<Int, [Ptr], "unlink">;
-def UNSETENV : RuntimeLibcall<Int, [Ptr], "unsetenv">;
-def UTIME : RuntimeLibcall<Int, [Ptr, Ptr], "utime">;
-def UTIMES : RuntimeLibcall<Int, [Ptr, Ptr], "utimes">;
-def VALLOC : RuntimeLibcall<Ptr, [SizeT], "valloc">;
-def VEC_CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT], "vec_calloc">;
-def VEC_FREE : RuntimeLibcall<Void, [Ptr], "vec_free">;
-def VEC_MALLOC : RuntimeLibcall<Ptr, [SizeT], "vec_malloc">;
-def VEC_REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT], "vec_realloc">;
-def VFPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vfprintf">;
-def VFSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vfscanf">;
-def VPRINTF : RuntimeLibcall<Int, [Ptr, Ptr], "vprintf">;
-def VSCANF : RuntimeLibcall<Int, [Ptr, Ptr], "vscanf">;
-def VSNPRINTF : RuntimeLibcall<Int, [Ptr, SizeT, Ptr, Ptr], "vsnprintf">;
-def VSNPRINTF_CHK : RuntimeLibcall<Int, [Ptr, SizeT, Int, SizeT, Ptr, Ptr], "vsnprintf_chk">;
-def VSPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vsprintf">;
-def VSPRINTF_CHK : RuntimeLibcall<Int, [Ptr, Int, SizeT, Ptr, Ptr], "vsprintf_chk">;
-def VSSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr], "vsscanf">;
-def WCSLEN : RuntimeLibcall<SizeT, [Ptr], "wcslen">;
-def WRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT], "write">;
-def ZDAPV : RuntimeLibcall<Void, [Ptr], "ZdaPv">;
-def ZDAPVJ : RuntimeLibcall<Void, [Ptr, Int], "ZdaPvj">;
-def ZDAPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int], "ZdaPvjSt11align_val_t">;
-def ZDAPVM : RuntimeLibcall<Void, [Ptr, Long], "ZdaPvm">;
-def ZDAPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long], "ZdaPvmSt11align_val_t">;
-def ZDAPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr], "ZdaPvRKSt9nothrow_t">;
-def ZDAPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus], "ZdaPvSt11align_val_t">;
-def ZDAPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr], "ZdaPvSt11align_val_tRKSt9nothrow_t">;
-def ZDLPV : RuntimeLibcall<Void, [Ptr], "ZdlPv">;
-def ZDLPVJ : RuntimeLibcall<Void, [Ptr, Int], "ZdlPvj">;
-def ZDLPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int], "ZdlPvjSt11align_val_t">;
-def ZDLPVM : RuntimeLibcall<Void, [Ptr, Long], "ZdlPvm">;
-def ZDLPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long], "ZdlPvmSt11align_val_t">;
-def ZDLPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr], "ZdlPvRKSt9nothrow_t">;
-def ZDLPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus], "ZdlPvSt11align_val_t">;
-def ZDLPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr], "ZdlPvSt11align_val_tRKSt9nothrow_t">;
-def ZNAJ : RuntimeLibcall<Ptr, [Int], "Znaj">;
-def ZNAJRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Ptr], "ZnajRKSt9nothrow_t">;
-def ZNAJST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Int, Int], "ZnajSt11align_val_t">;
-def ZNAJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Int, Ptr], "ZnajSt11align_val_tRKSt9nothrow_t">;
-def ZNAM : RuntimeLibcall<Ptr, [Long], "Znam">;
-def ZNAM12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Bool], "Znam12__hot_cold_t">;
-def ZNAMRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Ptr], "ZnamRKSt9nothrow_t">;
-def ZNAMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Ptr, Bool], "ZnamRKSt9nothrow_t12__hot_cold_t">;
-def ZNAMST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Long, Long], "ZnamSt11align_val_t">;
-def ZNAMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Bool], "ZnamSt11align_val_t12__hot_cold_t">;
-def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Long, Ptr], "ZnamSt11align_val_tRKSt9nothrow_t">;
-def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Ptr, Bool], "ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t">;
-def ZNWJ : RuntimeLibcall<Ptr, [Int], "Znwj">;
-def ZNWJRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Ptr], "ZnwjRKSt9nothrow_t">;
-def ZNWJST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Int, Int], "ZnwjSt11align_val_t">;
-def ZNWJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Int, Ptr], "ZnwjSt11align_val_tRKSt9nothrow_t">;
-def ZNWM : RuntimeLibcall<Ptr, [Long], "Znwm">;
-def ZNWM12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Bool], "Znwm12__hot_cold_t">;
-def ZNWMRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Ptr], "ZnwmRKSt9nothrow_t">;
-def ZNWMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Ptr, Bool], "ZnwmRKSt9nothrow_t12__hot_cold_t">;
-def ZNWMST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Long, Long], "ZnwmSt11align_val_t">;
-def ZNWMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Bool], "ZnwmSt11align_val_t12__hot_cold_t">;
-def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Long, Ptr], "ZnwmSt11align_val_tRKSt9nothrow_t">;
-def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Ptr, Bool], "ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t">;
-def KMPC_ALLOC_SHARED : RuntimeLibcall<Ptr, [SizeT], "__kmpc_alloc_shared">;
-def KMPC_FREE_SHARED : RuntimeLibcall<Void, [Ptr, SizeT], "__kmpc_free_shared">;
+def EXECL : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def EXECLE : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def EXECLP : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def EXECV : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def EXECVE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def EXECVP : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def EXECVPE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def EXIT : RuntimeLibcall<Void, [Int]>;
+def FCLOSE : RuntimeLibcall<Int, [Ptr]>;
+def FDOPEN : RuntimeLibcall<Ptr, [Int, Ptr]>;
+def FEOF : RuntimeLibcall<Int, [Ptr]>;
+def FERROR : RuntimeLibcall<Int, [Ptr]>;
+def FFLUSH : RuntimeLibcall<Int, [Ptr]>;
+def FFS : RuntimeLibcall<Int, [Int]>;
+def FFSL : RuntimeLibcall<Int, [Long]>;
+def FFSLL : RuntimeLibcall<Int, [LLong]>;
+def FGETC : RuntimeLibcall<Int, [Ptr]>;
+def FGETC_UNLOCKED : RuntimeLibcall<Int, [Ptr]>;
+def FGETPOS : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def FGETS : RuntimeLibcall<Ptr, [Ptr, Int, Ptr]>;
+def FGETS_UNLOCKED : RuntimeLibcall<Ptr, [Ptr, Int, Ptr]>;
+def FILENO : RuntimeLibcall<Int, [Ptr]>;
+def FIPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def FLOCKFILE : RuntimeLibcall<Void, [Ptr]>;
+def FLS : RuntimeLibcall<Int, [Int]>;
+def FLSL : RuntimeLibcall<Int, [Long]>;
+def FLSLL : RuntimeLibcall<Int, [LLong]>;
+def FOPEN : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def FOPEN64 : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def FORK : RuntimeLibcall<Int, []>;
+def FPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def FPUTC : RuntimeLibcall<Int, [Int, Ptr]>;
+def FPUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr]>;
+def FPUTS : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def FPUTS_UNLOCKED : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def FREAD : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def FREAD_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def FSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def FSEEK : RuntimeLibcall<Int, [Ptr, Long, Int]>;
+def FSEEKO : RuntimeLibcall<Int, [Ptr, IntX, Int]>;
+def FSEEKO64 : RuntimeLibcall<Int, [Ptr, Int64, Int]>;
+def FSETPOS : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def FSTAT : RuntimeLibcall<Int, [Int, Ptr]>;
+def FSTAT64 : RuntimeLibcall<Int, [Int, Ptr]>;
+def FSTATVFS : RuntimeLibcall<Int, [Int, Ptr]>;
+def FSTATVFS64 : RuntimeLibcall<Int, [Int, Ptr]>;
+def FTELL : RuntimeLibcall<Long, [Ptr]>;
+def FTELLO : RuntimeLibcall<IntPlus, [Ptr]>;
+def FTELLO64 : RuntimeLibcall<Int64, [Ptr]>;
+def FTRYLOCKFILE : RuntimeLibcall<Int, [Ptr]>;
+def FUNLOCKFILE : RuntimeLibcall<Void, [Ptr]>;
+def FWRITE : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def FWRITE_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr]>;
+def GETC : RuntimeLibcall<Int, [Ptr]>;
+def GETCHAR : RuntimeLibcall<Int, []>;
+def GETCHAR_UNLOCKED : RuntimeLibcall<Int, []>;
+def GETC_UNLOCKED : RuntimeLibcall<Int, [Ptr]>;
+def GETENV : RuntimeLibcall<Ptr, [Ptr]>;
+def GETITIMER : RuntimeLibcall<Int, [Int, Ptr]>;
+def GETLOGIN_R : RuntimeLibcall<Int, [Ptr, SizeT]>;
+def GETPWNAM : RuntimeLibcall<Ptr, [Ptr]>;
+def GETS : RuntimeLibcall<Ptr, [Ptr]>;
+def GETTIMEOFDAY : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def HTONL : RuntimeLibcall<Int32, [Int32]>;
+def HTONS : RuntimeLibcall<Int16, [Int16]>;
+def IPRINTF : RuntimeLibcall<Int, [Ptr, Ellip]>;
+def ISASCII : RuntimeLibcall<Int, [Int]>;
+def ISDIGIT : RuntimeLibcall<Int, [Int]>;
+def LABS : RuntimeLibcall<Long, [Same]>;
+def LCHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX]>;
+def LLABS : RuntimeLibcall<LLong, [LLong]>;
+def LSTAT : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def LSTAT64 : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def MEMALIGN : RuntimeLibcall<Ptr, [SizeT, SizeT]>;
+def MEMCCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, Int, SizeT]>;
+def MEMCCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, Int, SizeT, SizeT]>;
+def MEMCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
+def MEMPCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def MEMPCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def MEMRCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
+def MEMSET_PATTERN16 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def MEMSET_PATTERN4 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def MEMSET_PATTERN8 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def MKDIR : RuntimeLibcall<Int, [Ptr, IntX]>;
+def MKTIME : RuntimeLibcall<IntPlus, [Ptr]>;
+def MSVC_DELETE_ARRAY_PTR32 : RuntimeLibcall<Void, [Ptr]>;
+def MSVC_DELETE_ARRAY_PTR32_INT : RuntimeLibcall<Void, [Ptr, Int]>;
+def MSVC_DELETE_ARRAY_PTR32_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def MSVC_DELETE_ARRAY_PTR64 : RuntimeLibcall<Void, [Ptr]>;
+def MSVC_DELETE_ARRAY_PTR64_LONGLONG : RuntimeLibcall<Void, [Ptr, LLong]>;
+def MSVC_DELETE_ARRAY_PTR64_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def MSVC_DELETE_PTR32 : RuntimeLibcall<Void, [Ptr]>;
+def MSVC_DELETE_PTR32_INT : RuntimeLibcall<Void, [Ptr, Int]>;
+def MSVC_DELETE_PTR32_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def MSVC_DELETE_PTR64 : RuntimeLibcall<Void, [Ptr]>;
+def MSVC_DELETE_PTR64_LONGLONG : RuntimeLibcall<Void, [Ptr, LLong]>;
+def MSVC_DELETE_PTR64_NOTHROW : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def MSVC_NEW_ARRAY_INT : RuntimeLibcall<Ptr, [Int]>;
+def MSVC_NEW_ARRAY_INT_NOTHROW : RuntimeLibcall<Ptr, [Int, Ptr]>;
+def MSVC_NEW_ARRAY_LONGLONG : RuntimeLibcall<Ptr, [LLong]>;
+def MSVC_NEW_ARRAY_LONGLONG_NOTHROW : RuntimeLibcall<Ptr, [LLong, Ptr]>;
+def MSVC_NEW_INT : RuntimeLibcall<Ptr, [Int]>;
+def MSVC_NEW_INT_NOTHROW : RuntimeLibcall<Ptr, [Int, Ptr]>;
+def MSVC_NEW_LONGLONG : RuntimeLibcall<Ptr, [LLong]>;
+def MSVC_NEW_LONGLONG_NOTHROW : RuntimeLibcall<Ptr, [LLong, Ptr]>;
+def NTOHL : RuntimeLibcall<Int32, [Int32]>;
+def NTOHS : RuntimeLibcall<Int16, [Int16]>;
+def OPEN : RuntimeLibcall<Int, [Ptr, Int, Ellip]>;
+def OPEN64 : RuntimeLibcall<Int, [Ptr, Int, Ellip]>;
+def OPENDIR : RuntimeLibcall<Ptr, [Ptr]>;
+def PCLOSE : RuntimeLibcall<Int, [Ptr]>;
+def PERROR : RuntimeLibcall<Void, [Ptr]>;
+def POPEN : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def POSIX_MEMALIGN : RuntimeLibcall<Int, [Ptr, SizeT, SizeT]>;
+def PREAD : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus]>;
+def PRINTF : RuntimeLibcall<Int, [Ptr, Ellip]>;
+def PUTC : RuntimeLibcall<Int, [Int, Ptr]>;
+def PUTCHAR : RuntimeLibcall<Int, [Int]>;
+def PUTCHAR_UNLOCKED : RuntimeLibcall<Int, [Int]>;
+def PUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr]>;
+def PUTS : RuntimeLibcall<Int, [Ptr]>;
+def PVALLOC : RuntimeLibcall<Ptr, [SizeT]>;
+def PWRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus]>;
+def QSORT : RuntimeLibcall<Void, [Ptr, SizeT, SizeT, Ptr]>;
+def READ : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT]>;
+def READLINK : RuntimeLibcall<SSizeT, [Ptr, Ptr, SizeT]>;
+def REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def REALLOCARRAY : RuntimeLibcall<Ptr, [Ptr, SizeT, SizeT]>;
+def REALLOCF : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def REALPATH : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def REMOVE : RuntimeLibcall<Int, [Ptr]>;
+def RENAME : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def REWIND : RuntimeLibcall<Void, [Ptr]>;
+def RMDIR : RuntimeLibcall<Int, [Ptr]>;
+def SCANF : RuntimeLibcall<Int, [Ptr, Ellip]>;
+def SETBUF : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def SETITIMER : RuntimeLibcall<Int, [Int, Ptr, Ptr]>;
+def SETVBUF : RuntimeLibcall<Int, [Ptr, Ptr, Int, SizeT]>;
+def SIPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def SIZE_RETURNING_NEW : RuntimeLibcall<NoneType, []>;
+def SIZE_RETURNING_NEW_ALIGNED : RuntimeLibcall<NoneType, []>;
+def SIZE_RETURNING_NEW_ALIGNED_HOT_COLD : RuntimeLibcall<NoneType, []>;
+def SIZE_RETURNING_NEW_HOT_COLD : RuntimeLibcall<NoneType, []>;
+def SMALL_FPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def SMALL_PRINTF : RuntimeLibcall<Int, [Ptr, Ellip]>;
+def SMALL_SPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def SNPRINTF : RuntimeLibcall<Int, [Ptr, SizeT, Ptr, Ellip]>;
+def SNPRINTF_CHK : RuntimeLibcall<Int, [Ptr, SizeT, Int, SizeT, Ptr, Ellip]>;
+def SPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def SPRINTF_CHK : RuntimeLibcall<Int, [Ptr, Int, SizeT, Ptr, Ellip]>;
+def SSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
+def STAT : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STAT64 : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STATVFS : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STATVFS64 : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STPCPY : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def STPCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def STPNCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def STPNCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def STRCASECMP : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STRCAT : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def STRCAT_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def STRCHR : RuntimeLibcall<Ptr, [Ptr, Int]>;
+def STRCMP : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STRCOLL : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def STRCPY : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def STRCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def STRCSPN : RuntimeLibcall<SizeT, [Ptr, Ptr]>;
+def STRDUP : RuntimeLibcall<Ptr, [Ptr]>;
+def STRLCAT : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT]>;
+def STRLCAT_CHK : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT, SizeT]>;
+def STRLCPY : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT]>;
+def STRLCPY_CHK : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT, SizeT]>;
+def STRLEN_CHK : RuntimeLibcall<SizeT, [Ptr, SizeT]>;
+def STRNCASECMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]>;
+def STRNCAT : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def STRNCAT_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def STRNCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]>;
+def STRNCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def STRNCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def STRNDUP : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def STRNLEN : RuntimeLibcall<SizeT, [Ptr, SizeT]>;
+def STRPBRK : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def STRRCHR : RuntimeLibcall<Ptr, [Ptr, Int]>;
+def STRSPN : RuntimeLibcall<SizeT, [Ptr, Ptr]>;
+def STRSTR : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def STRTOD : RuntimeLibcall<Dbl, [Ptr, Ptr]>;
+def STRTOF : RuntimeLibcall<Flt, [Ptr, Ptr]>;
+def STRTOK : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def STRTOK_R : RuntimeLibcall<Ptr, [Ptr, Ptr, Ptr]>;
+def STRTOL : RuntimeLibcall<Long, [Ptr, Ptr, Int]>;
+def STRTOLD : RuntimeLibcall<LDbl, [Ptr, Ptr]>;
+def STRTOLL : RuntimeLibcall<LLong, [Ptr, Ptr, Int]>;
+def STRTOUL : RuntimeLibcall<Long, [Ptr, Ptr, Int]>;
+def STRTOULL : RuntimeLibcall<LLong, [Ptr, Ptr, Int]>;
+def STRXFRM : RuntimeLibcall<SizeT, [Ptr, Ptr, SizeT]>;
+def SYSTEM : RuntimeLibcall<Int, [Ptr]>;
+def TERMINATE : RuntimeLibcall<Void, []>;
+def TIMES : RuntimeLibcall<IntPlus, [Ptr]>;
+def TMPFILE : RuntimeLibcall<Ptr, []>;
+def TMPFILE64 : RuntimeLibcall<Ptr, []>;
+def TOASCII : RuntimeLibcall<Int, [Int]>;
+def UNAME : RuntimeLibcall<Int, [Ptr]>;
+def UNDER_IO_GETC : RuntimeLibcall<Int, [Ptr]>;
+def UNDER_IO_PUTC : RuntimeLibcall<Int, [Int, Ptr]>;
+def UNGETC : RuntimeLibcall<Int, [Int, Ptr]>;
+def UNLINK : RuntimeLibcall<Int, [Ptr]>;
+def UNSETENV : RuntimeLibcall<Int, [Ptr]>;
+def UTIME : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def UTIMES : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def VALLOC : RuntimeLibcall<Ptr, [SizeT]>;
+def VEC_CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT]>;
+def VEC_FREE : RuntimeLibcall<Void, [Ptr]>;
+def VEC_MALLOC : RuntimeLibcall<Ptr, [SizeT]>;
+def VEC_REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def VFPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def VFSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def VPRINTF : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def VSCANF : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def VSNPRINTF : RuntimeLibcall<Int, [Ptr, SizeT, Ptr, Ptr]>;
+def VSNPRINTF_CHK : RuntimeLibcall<Int, [Ptr, SizeT, Int, SizeT, Ptr, Ptr]>;
+def VSPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def VSPRINTF_CHK : RuntimeLibcall<Int, [Ptr, Int, SizeT, Ptr, Ptr]>;
+def VSSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
+def WCSLEN : RuntimeLibcall<SizeT, [Ptr]>;
+def WRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT]>;
+def ZDAPV : RuntimeLibcall<Void, [Ptr]>;
+def ZDAPVJ : RuntimeLibcall<Void, [Ptr, Int]>;
+def ZDAPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int]>;
+def ZDAPVM : RuntimeLibcall<Void, [Ptr, Long]>;
+def ZDAPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long]>;
+def ZDAPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def ZDAPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus]>;
+def ZDAPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr]>;
+def ZDLPV : RuntimeLibcall<Void, [Ptr]>;
+def ZDLPVJ : RuntimeLibcall<Void, [Ptr, Int]>;
+def ZDLPVJST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Int, Int]>;
+def ZDLPVM : RuntimeLibcall<Void, [Ptr, Long]>;
+def ZDLPVMST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, Long, Long]>;
+def ZDLPVRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def ZDLPVST11ALIGN_VAL_T : RuntimeLibcall<Void, [Ptr, IntPlus]>;
+def ZDLPVST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Void, [Ptr, IntPlus, Ptr]>;
+def ZNAJ : RuntimeLibcall<Ptr, [Int]>;
+def ZNAJRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Ptr]>;
+def ZNAJST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Int, Int]>;
+def ZNAJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Int, Ptr]>;
+def ZNAM : RuntimeLibcall<Ptr, [Long]>;
+def ZNAM12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Bool]>;
+def ZNAMRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Ptr]>;
+def ZNAMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Ptr, Bool]>;
+def ZNAMST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Long, Long]>;
+def ZNAMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Bool]>;
+def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Long, Ptr]>;
+def ZNAMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Ptr, Bool]>;
+def ZNWJ : RuntimeLibcall<Ptr, [Int]>;
+def ZNWJRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Ptr]>;
+def ZNWJST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Int, Int]>;
+def ZNWJST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Int, Int, Ptr]>;
+def ZNWM : RuntimeLibcall<Ptr, [Long]>;
+def ZNWM12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Bool]>;
+def ZNWMRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Ptr]>;
+def ZNWMRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Ptr, Bool]>;
+def ZNWMST11ALIGN_VAL_T : RuntimeLibcall<Ptr, [Long, Long]>;
+def ZNWMST11ALIGN_VAL_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Bool]>;
+def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T : RuntimeLibcall<Ptr, [Long, Long, Ptr]>;
+def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long, Long, Ptr, Bool]>;
+def KMPC_ALLOC_SHARED : RuntimeLibcall<Ptr, [SizeT]>;
+def KMPC_FREE_SHARED : RuntimeLibcall<Void, [Ptr, SizeT]>;
//--------------------------------------------------------------------
// Global variable references
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 46ef2ac64a818..45966053d8a50 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -78,12 +78,10 @@ def Same : FuncArgType; // Same argument type as the previous one.
/// to be overridden for Darwin with the xxx$LDBL128 form. See
/// PPCISelLowering.cpp.
class RuntimeLibcall<FuncArgType RetType = NoneType,
- list<FuncArgType> ArgTypes = [],
- string EnumName = ""> {
+ list<FuncArgType> ArgTypes = []> {
string Name = NAME;
FuncArgType ReturnType = RetType;
list<FuncArgType> ArgumentTypes = ArgTypes;
- string LibFuncEnumName = EnumName; // For TargetLibraryInfo
}
// Concrete implementation of a libcall, which may have a different
>From 91b65d1aeefccdb193c78f1bb39e6d74c42c382e Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Tue, 12 May 2026 00:55:35 +0000
Subject: [PATCH 4/8] Automatically convert FP types to avoid unrolling for
loops.
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 365 ++++----------------
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 15 +
2 files changed, 74 insertions(+), 306 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 9aa536377edc6..102e7fe38f165 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -161,175 +161,39 @@ foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
//def FDIM_#FPTy : RuntimeLibcall;
//def CABS_#FPTy : RuntimeLibcall;
-}
- def REM_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def REM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def REM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def REM_F80 : RuntimeLibcall;
- def REM_PPCF128 : RuntimeLibcall;
-
- def SQRT_F32 : RuntimeLibcall<Flt, [Flt]>;
- def SQRT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def SQRT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def SQRT_F80 : RuntimeLibcall;
- def SQRT_PPCF128 : RuntimeLibcall;
-
- def CBRT_F32 : RuntimeLibcall<Flt, [Flt]>;
- def CBRT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def CBRT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def CBRT_F80 : RuntimeLibcall;
- def CBRT_PPCF128 : RuntimeLibcall;
-
- def LOG_F32 : RuntimeLibcall<Flt, [Flt]>;
- def LOG_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def LOG_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def LOG_F80 : RuntimeLibcall;
- def LOG_PPCF128 : RuntimeLibcall;
-
- def LOG_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
- def LOG_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def LOG_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def LOG_FINITE_F80 : RuntimeLibcall;
- def LOG_FINITE_PPCF128 : RuntimeLibcall;
-
- def LOG2_F32 : RuntimeLibcall<Flt, [Flt]>;
- def LOG2_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def LOG2_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def LOG2_F80 : RuntimeLibcall;
- def LOG2_PPCF128 : RuntimeLibcall;
-
- def LOG2_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
- def LOG2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def LOG2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def LOG2_FINITE_F80 : RuntimeLibcall;
- def LOG2_FINITE_PPCF128 : RuntimeLibcall;
-
- def LOG10_F32 : RuntimeLibcall<Flt, [Flt]>;
- def LOG10_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def LOG10_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def LOG10_F80 : RuntimeLibcall;
- def LOG10_PPCF128 : RuntimeLibcall;
-
- def LOG10_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
- def LOG10_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def LOG10_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def LOG10_FINITE_F80 : RuntimeLibcall;
- def LOG10_FINITE_PPCF128 : RuntimeLibcall;
-
- def EXP_F32 : RuntimeLibcall<Flt, [Flt]>;
- def EXP_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def EXP_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def EXP_F80 : RuntimeLibcall;
- def EXP_PPCF128 : RuntimeLibcall;
-
- def EXP_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
- def EXP_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def EXP_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def EXP_FINITE_F80 : RuntimeLibcall;
- def EXP_FINITE_PPCF128 : RuntimeLibcall;
-
- def EXP2_F32 : RuntimeLibcall<Flt, [Flt]>;
- def EXP2_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def EXP2_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def EXP2_F80 : RuntimeLibcall;
- def EXP2_PPCF128 : RuntimeLibcall;
-
- def EXP2_FINITE_F32 : RuntimeLibcall<Flt, [Flt]>;
- def EXP2_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def EXP2_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def EXP2_FINITE_F80 : RuntimeLibcall;
- def EXP2_FINITE_PPCF128 : RuntimeLibcall;
-
- def EXP10_F32 : RuntimeLibcall<Flt, [Flt]>;
- def EXP10_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def EXP10_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def EXP10_F80 : RuntimeLibcall;
- def EXP10_PPCF128 : RuntimeLibcall;
-
- def SIN_F32 : RuntimeLibcall<Flt, [Flt]>;
- def SIN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def SIN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def SIN_F80 : RuntimeLibcall;
- def SIN_PPCF128 : RuntimeLibcall;
-
- def COS_F32 : RuntimeLibcall<Flt, [Flt]>;
- def COS_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def COS_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def COS_F80 : RuntimeLibcall;
- def COS_PPCF128 : RuntimeLibcall;
-
- def TAN_F32 : RuntimeLibcall<Flt, [Flt]>;
- def TAN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def TAN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def TAN_F80 : RuntimeLibcall;
- def TAN_PPCF128 : RuntimeLibcall;
-
- def SINH_F32 : RuntimeLibcall<Flt, [Flt]>;
- def SINH_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def SINH_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def SINH_F80 : RuntimeLibcall;
- def SINH_PPCF128 : RuntimeLibcall;
-
- def COSH_F32 : RuntimeLibcall<Flt, [Flt]>;
- def COSH_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def COSH_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def COSH_F80 : RuntimeLibcall;
- def COSH_PPCF128 : RuntimeLibcall;
-
- def TANH_F32 : RuntimeLibcall<Flt, [Flt]>;
- def TANH_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def TANH_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def TANH_F80 : RuntimeLibcall;
- def TANH_PPCF128 : RuntimeLibcall;
-
- def ASIN_F32 : RuntimeLibcall<Flt, [Flt]>;
- def ASIN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def ASIN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def ASIN_F80 : RuntimeLibcall;
- def ASIN_PPCF128 : RuntimeLibcall;
-
- def ACOS_F32 : RuntimeLibcall<Flt, [Flt]>;
- def ACOS_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def ACOS_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def ACOS_F80 : RuntimeLibcall;
- def ACOS_PPCF128 : RuntimeLibcall;
-
- def ATAN_F32 : RuntimeLibcall<Flt, [Flt]>;
- def ATAN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def ATAN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def ATAN_F80 : RuntimeLibcall;
- def ATAN_PPCF128 : RuntimeLibcall;
-
- def ATAN2_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def ATAN2_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def ATAN2_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def ATAN2_F80 : RuntimeLibcall;
- def ATAN2_PPCF128 : RuntimeLibcall;
-
- def SINCOS_F32 : RuntimeLibcall<Void, [Flt, Ptr, Ptr]>;
- def SINCOS_F64 : RuntimeLibcall<Void, [Dbl, Ptr, Ptr]>;
- def SINCOS_F128 : RuntimeLibcall<Void, [LDbl, Ptr, Ptr]>;
- def SINCOS_F80 : RuntimeLibcall;
- def SINCOS_PPCF128 : RuntimeLibcall;
-
- def REMQUO_F32 : RuntimeLibcall<Flt, [Flt, Flt, Ptr]>;
- def REMQUO_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl, Ptr]>;
- def REMQUO_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl, Ptr]>;
- def REMQUO_F80 : RuntimeLibcall;
- def REMQUO_PPCF128 : RuntimeLibcall;
-
- def FDIM_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def FDIM_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def FDIM_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def FDIM_F80 : RuntimeLibcall;
- def FDIM_PPCF128 : RuntimeLibcall;
-
- def CABS_F32 : RuntimeLibcall<NoneType, []>;
- def CABS_F64 : RuntimeLibcall<NoneType, []>;
- def CABS_F128 : RuntimeLibcall<NoneType, []>;
- def CABS_F80 : RuntimeLibcall;
- def CABS_PPCF128 : RuntimeLibcall;
+ def REM_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+ def SQRT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+
+ def CBRT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def LOG_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def LOG_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def LOG2_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def LOG2_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def LOG10_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def LOG10_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def EXP_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def EXP_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def EXP2_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def EXP2_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def EXP10_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+
+ def SIN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def COS_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def TAN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def SINH_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def COSH_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def TANH_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def ASIN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def ACOS_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def ATAN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def ATAN2_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+ def SINCOS_#FPTy : FPRuntimeLibcall<FPTy, Void, [Flt, Ptr, Ptr]>;
+ def REMQUO_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt, Ptr]>;
+ def FDIM_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+
+ def CABS_#FPTy : FPRuntimeLibcall<FPTy, NoneType, []>;
+}
foreach FPTy = [ "F32", "F64" ] in {
def SINCOS_STRET_#FPTy : RuntimeLibcall;
@@ -366,145 +230,34 @@ foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
//def SCALBLN_#FPTy : RuntimeLibcall;
//def SCALBN_#FPTy : RuntimeLibcall;
//def TGAMMA_#FPTy : RuntimeLibcall;
-}
- def POW_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def POW_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def POW_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def POW_F80 : RuntimeLibcall;
- def POW_PPCF128 : RuntimeLibcall;
-
- def POW_FINITE_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def POW_FINITE_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def POW_FINITE_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def POW_FINITE_F80 : RuntimeLibcall;
- def POW_FINITE_PPCF128 : RuntimeLibcall;
-
- def CEIL_F32 : RuntimeLibcall<Flt, [Flt]>;
- def CEIL_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def CEIL_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def CEIL_F80 : RuntimeLibcall;
- def CEIL_PPCF128 : RuntimeLibcall;
-
- def TRUNC_F32 : RuntimeLibcall<Flt, [Flt]>;
- def TRUNC_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def TRUNC_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def TRUNC_F80 : RuntimeLibcall;
- def TRUNC_PPCF128 : RuntimeLibcall;
-
- def RINT_F32 : RuntimeLibcall<Flt, [Flt]>;
- def RINT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def RINT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def RINT_F80 : RuntimeLibcall;
- def RINT_PPCF128 : RuntimeLibcall;
-
- def NEARBYINT_F32 : RuntimeLibcall<Flt, [Flt]>;
- def NEARBYINT_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def NEARBYINT_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def NEARBYINT_F80 : RuntimeLibcall;
- def NEARBYINT_PPCF128 : RuntimeLibcall;
-
- def ROUND_F32 : RuntimeLibcall<Flt, [Flt]>;
- def ROUND_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def ROUND_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def ROUND_F80 : RuntimeLibcall;
- def ROUND_PPCF128 : RuntimeLibcall;
-
- def ROUNDEVEN_F32 : RuntimeLibcall<Flt, [Flt]>;
- def ROUNDEVEN_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def ROUNDEVEN_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def ROUNDEVEN_F80 : RuntimeLibcall;
- def ROUNDEVEN_PPCF128 : RuntimeLibcall;
-
- def FLOOR_F32 : RuntimeLibcall<Flt, [Flt]>;
- def FLOOR_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def FLOOR_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def FLOOR_F80 : RuntimeLibcall;
- def FLOOR_PPCF128 : RuntimeLibcall;
-
- def COPYSIGN_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def COPYSIGN_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def COPYSIGN_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def COPYSIGN_F80 : RuntimeLibcall;
- def COPYSIGN_PPCF128 : RuntimeLibcall;
-
- def FMIN_F32 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMIN_F64 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMIN_F128 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMIN_F80 : RuntimeLibcall;
- def FMIN_PPCF128 : RuntimeLibcall;
-
- def FMAX_F32 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMAX_F64 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMAX_F128 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMAX_F80 : RuntimeLibcall;
- def FMAX_PPCF128 : RuntimeLibcall;
-
- def FMINIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMINIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMINIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMINIMUM_NUM_F80 : RuntimeLibcall;
- def FMINIMUM_NUM_PPCF128 : RuntimeLibcall;
-
- def FMAXIMUM_NUM_F32 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMAXIMUM_NUM_F64 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMAXIMUM_NUM_F128 : RuntimeLibcall<Floating, [Same, Same]>;
- def FMAXIMUM_NUM_F80 : RuntimeLibcall;
- def FMAXIMUM_NUM_PPCF128 : RuntimeLibcall;
-
- def LDEXP_F32 : RuntimeLibcall<Flt, [Flt, Int]>;
- def LDEXP_F64 : RuntimeLibcall<Dbl, [Dbl, Int]>;
- def LDEXP_F128 : RuntimeLibcall<LDbl, [LDbl, Int]>;
- def LDEXP_F80 : RuntimeLibcall;
- def LDEXP_PPCF128 : RuntimeLibcall;
-
- def FREXP_F32 : RuntimeLibcall<Flt, [Flt, Ptr]>;
- def FREXP_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr]>;
- def FREXP_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr]>;
- def FREXP_F80 : RuntimeLibcall;
- def FREXP_PPCF128 : RuntimeLibcall;
-
- def MODF_F32 : RuntimeLibcall<Flt, [Flt, Ptr]>;
- def MODF_F64 : RuntimeLibcall<Dbl, [Dbl, Ptr]>;
- def MODF_F128 : RuntimeLibcall<LDbl, [LDbl, Ptr]>;
- def MODF_F80 : RuntimeLibcall;
- def MODF_PPCF128 : RuntimeLibcall;
-
- def NAN_F32 : RuntimeLibcall<Flt, [Ptr]>;
- def NAN_F64 : RuntimeLibcall<Dbl, [Ptr]>;
- def NAN_F128 : RuntimeLibcall<LDbl, [Ptr]>;
- def NAN_F80 : RuntimeLibcall;
- def NAN_PPCF128 : RuntimeLibcall;
-
- def NEXTTOWARD_F32 : RuntimeLibcall<Flt, [Flt, LDbl]>;
- def NEXTTOWARD_F64 : RuntimeLibcall<Dbl, [Dbl, LDbl]>;
- def NEXTTOWARD_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def NEXTTOWARD_F80 : RuntimeLibcall;
- def NEXTTOWARD_PPCF128 : RuntimeLibcall;
-
- def REMAINDER_F32 : RuntimeLibcall<Flt, [Flt, Flt]>;
- def REMAINDER_F64 : RuntimeLibcall<Dbl, [Dbl, Dbl]>;
- def REMAINDER_F128 : RuntimeLibcall<LDbl, [LDbl, LDbl]>;
- def REMAINDER_F80 : RuntimeLibcall;
- def REMAINDER_PPCF128 : RuntimeLibcall;
-
- def SCALBLN_F32 : RuntimeLibcall<Flt, [Flt, Long]>;
- def SCALBLN_F64 : RuntimeLibcall<Dbl, [Dbl, Long]>;
- def SCALBLN_F128 : RuntimeLibcall<LDbl, [LDbl, Long]>;
- def SCALBLN_F80 : RuntimeLibcall;
- def SCALBLN_PPCF128 : RuntimeLibcall;
-
- def SCALBN_F32 : RuntimeLibcall<Flt, [Flt, Int]>;
- def SCALBN_F64 : RuntimeLibcall<Dbl, [Dbl, Int]>;
- def SCALBN_F128 : RuntimeLibcall<LDbl, [LDbl, Int]>;
- def SCALBN_F80 : RuntimeLibcall;
- def SCALBN_PPCF128 : RuntimeLibcall;
-
- def TGAMMA_F32 : RuntimeLibcall<Flt, [Flt]>;
- def TGAMMA_F64 : RuntimeLibcall<Dbl, [Dbl]>;
- def TGAMMA_F128 : RuntimeLibcall<LDbl, [LDbl]>;
- def TGAMMA_F80 : RuntimeLibcall;
- def TGAMMA_PPCF128 : RuntimeLibcall;
+ def POW_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+ def POW_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+ def CEIL_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def TRUNC_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def RINT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def NEARBYINT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def ROUND_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def ROUNDEVEN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def FLOOR_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+ def COPYSIGN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+ def FMIN_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
+ def FMAX_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
+
+ def FMINIMUM_NUM_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
+ def FMAXIMUM_NUM_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
+
+ def LDEXP_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Int]>;
+ def FREXP_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Ptr]>;
+
+ def MODF_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Ptr]>;
+ def NAN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Ptr]>;
+ def NEXTTOWARD_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, LDbl]>;
+ def REMAINDER_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
+ def SCALBLN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Long]>;
+ def SCALBN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Int]>;
+ def TGAMMA_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+}
defvar F32VectorSuffixes = ["V2F32", "V4F32", "V8F32", "V16F32", "NXV4F32"];
defvar F64VectorSuffixes = ["V2F64", "V4F64", "V8F64", "NXV2F64"];
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 45966053d8a50..444dd0aa2d52c 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -84,6 +84,21 @@ class RuntimeLibcall<FuncArgType RetType = NoneType,
list<FuncArgType> ArgumentTypes = ArgTypes;
}
+class FPRuntimeLibcall<string FPTy,
+ FuncArgType RetType = NoneType,
+ list<FuncArgType> ArgTypes = []>
+ : RuntimeLibcall<
+ !cond(!and(!eq(FPTy, "F64"), !eq(RetType, Flt)) : Dbl,
+ !and(!eq(FPTy, "F128"), !eq(RetType, Flt)) : LDbl,
+ !or(!eq(FPTy, "F80"), !eq(FPTy, "PPCF128")) : NoneType,
+ true : RetType),
+ !cond(!eq(FPTy, "F64") :
+ !foreach(ArgType, ArgTypes, !if(!eq(ArgType, Flt), Dbl, ArgType)),
+ !eq(FPTy, "F128") :
+ !foreach(ArgType, ArgTypes, !if(!eq(ArgType, Flt), LDbl, ArgType)),
+ !or(!eq(FPTy, "F80"), !eq(FPTy, "PPCF128")) : [],
+ true : ArgTypes)>;
+
// Concrete implementation of a libcall, which may have a different
// name and only be valid on some subset of targets.
>From 4795c2f22cefb5a8240f32e37a8d514fe5ea274a Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Tue, 12 May 2026 18:08:03 +0000
Subject: [PATCH 5/8] Use class TypeSuffix to link FP types to suffixes.
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 228 ++++++++------------
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 15 --
2 files changed, 90 insertions(+), 153 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 102e7fe38f165..19762e3f6914f 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -113,150 +113,102 @@ foreach IntTy = ["I32", "I64", "I128"] in {
def CTPOP_#IntTy : RuntimeLibcall;
}
-foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
- def ADD_#FPTy : RuntimeLibcall;
- def FAST_ADD_#FPTy : RuntimeLibcall;
-
- def SUB_#FPTy : RuntimeLibcall;
- def FAST_SUB_#FPTy : RuntimeLibcall;
-
- def MUL_#FPTy : RuntimeLibcall;
- def FAST_MUL_#FPTy : RuntimeLibcall;
-
- def DIV_#FPTy : RuntimeLibcall;
- def FAST_DIV_#FPTy : RuntimeLibcall;
-
- //def REM_#FPTy : RuntimeLibcall;
- def FMA_#FPTy : RuntimeLibcall;
- def POWI_#FPTy : RuntimeLibcall;
-
- //def SQRT_#FPTy : RuntimeLibcall;
- def FAST_SQRT_#FPTy : RuntimeLibcall;
-
- //def CBRT_#FPTy : RuntimeLibcall;
- //def LOG_#FPTy : RuntimeLibcall;
- //def LOG_FINITE_#FPTy : RuntimeLibcall;
- //def LOG2_#FPTy : RuntimeLibcall;
- //def LOG2_FINITE_#FPTy : RuntimeLibcall;
- //def LOG10_#FPTy : RuntimeLibcall;
- //def LOG10_FINITE_#FPTy : RuntimeLibcall;
- //def EXP_#FPTy : RuntimeLibcall;
- //def EXP_FINITE_#FPTy : RuntimeLibcall;
- //def EXP2_#FPTy : RuntimeLibcall;
- //def EXP2_FINITE_#FPTy : RuntimeLibcall;
- //def EXP10_#FPTy : RuntimeLibcall;
- def EXP10_FINITE_#FPTy : RuntimeLibcall;
- //def SIN_#FPTy : RuntimeLibcall;
- //def COS_#FPTy : RuntimeLibcall;
- //def TAN_#FPTy : RuntimeLibcall;
- //def SINH_#FPTy : RuntimeLibcall;
- //def COSH_#FPTy : RuntimeLibcall;
- //def TANH_#FPTy : RuntimeLibcall;
- //def ASIN_#FPTy : RuntimeLibcall;
- //def ACOS_#FPTy : RuntimeLibcall;
- //def ATAN_#FPTy : RuntimeLibcall;
- //def ATAN2_#FPTy : RuntimeLibcall;
- //def SINCOS_#FPTy : RuntimeLibcall;
- //def REMQUO_#FPTy : RuntimeLibcall;
- //def FDIM_#FPTy : RuntimeLibcall;
-
- //def CABS_#FPTy : RuntimeLibcall;
-
- def REM_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
- def SQRT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
-
- def CBRT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def LOG_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def LOG_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def LOG2_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def LOG2_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def LOG10_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def LOG10_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def EXP_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def EXP_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def EXP2_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def EXP2_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def EXP10_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
-
- def SIN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def COS_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def TAN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def SINH_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def COSH_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def TANH_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def ASIN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def ACOS_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def ATAN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def ATAN2_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
- def SINCOS_#FPTy : FPRuntimeLibcall<FPTy, Void, [Flt, Ptr, Ptr]>;
- def REMQUO_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt, Ptr]>;
- def FDIM_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
-
- def CABS_#FPTy : FPRuntimeLibcall<FPTy, NoneType, []>;
+
+class TypeSuffix<string S, FuncArgType Ty> {
+ string Suffix = S;
+ FuncArgType Type = Ty;
+}
+def F32 : TypeSuffix<"F32", Flt>;
+def F64 : TypeSuffix<"F64", Dbl>;
+def F80 : TypeSuffix<"F80", LDbl>;
+def F128 : TypeSuffix<"F128", LDbl>;
+def PPCF128 : TypeSuffix<"PPCF128", LDbl>;
+
+foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
+ def ADD_#FPTy.Suffix : RuntimeLibcall;
+ def FAST_ADD_#FPTy.Suffix : RuntimeLibcall;
+
+ def SUB_#FPTy.Suffix : RuntimeLibcall;
+ def FAST_SUB_#FPTy.Suffix : RuntimeLibcall;
+
+ def MUL_#FPTy.Suffix : RuntimeLibcall;
+ def FAST_MUL_#FPTy.Suffix : RuntimeLibcall;
+
+ def DIV_#FPTy.Suffix : RuntimeLibcall;
+ def FAST_DIV_#FPTy.Suffix : RuntimeLibcall;
+
+ def REM_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def FMA_#FPTy.Suffix : RuntimeLibcall;
+ def POWI_#FPTy.Suffix : RuntimeLibcall;
+
+ def SQRT_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def FAST_SQRT_#FPTy.Suffix : RuntimeLibcall;
+
+ def CBRT_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def LOG_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def LOG_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def LOG2_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def LOG2_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def LOG10_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def LOG10_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXP_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXP_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXP2_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXP2_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXP10_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXP10_FINITE_#FPTy.Suffix : RuntimeLibcall;
+ def SIN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def COS_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def TAN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def SINH_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def COSH_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def TANH_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ASIN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ACOS_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ATAN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ATAN2_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def SINCOS_#FPTy.Suffix : RuntimeLibcall<Void, [FPTy.Type, Ptr, Ptr]>;
+ def REMQUO_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type, Ptr]>;
+ def FDIM_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+
+ def CABS_#FPTy.Suffix : RuntimeLibcall<NoneType, []>;
}
foreach FPTy = [ "F32", "F64" ] in {
def SINCOS_STRET_#FPTy : RuntimeLibcall;
}
-foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
- //def POW_#FPTy : RuntimeLibcall;
- //def POW_FINITE_#FPTy : RuntimeLibcall;
- //def CEIL_#FPTy : RuntimeLibcall;
- //def TRUNC_#FPTy : RuntimeLibcall;
- //def RINT_#FPTy : RuntimeLibcall;
- //def NEARBYINT_#FPTy : RuntimeLibcall;
- //def ROUND_#FPTy : RuntimeLibcall;
- //def ROUNDEVEN_#FPTy : RuntimeLibcall;
- //def FLOOR_#FPTy : RuntimeLibcall;
- //def COPYSIGN_#FPTy : RuntimeLibcall;
- //def FMIN_#FPTy : RuntimeLibcall;
- //def FMAX_#FPTy : RuntimeLibcall;
- def FMINIMUM_#FPTy : RuntimeLibcall;
- def FMAXIMUM_#FPTy : RuntimeLibcall;
- //def FMINIMUM_NUM_#FPTy : RuntimeLibcall;
- //def FMAXIMUM_NUM_#FPTy : RuntimeLibcall;
- def LROUND_#FPTy : RuntimeLibcall;
- def LLROUND_#FPTy : RuntimeLibcall;
- def LRINT_#FPTy : RuntimeLibcall;
- def LLRINT_#FPTy : RuntimeLibcall;
- //def LDEXP_#FPTy : RuntimeLibcall;
- //def FREXP_#FPTy : RuntimeLibcall;
- def SINCOSPI_#FPTy : RuntimeLibcall;
- //def MODF_#FPTy : RuntimeLibcall;
- //def NAN_#FPTy : RuntimeLibcall;
- //def NEXTTOWARD_#FPTy : RuntimeLibcall;
- //def REMAINDER_#FPTy : RuntimeLibcall;
- //def SCALBLN_#FPTy : RuntimeLibcall;
- //def SCALBN_#FPTy : RuntimeLibcall;
- //def TGAMMA_#FPTy : RuntimeLibcall;
-
- def POW_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
- def POW_FINITE_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
- def CEIL_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def TRUNC_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def RINT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def NEARBYINT_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def ROUND_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def ROUNDEVEN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def FLOOR_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
- def COPYSIGN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
- def FMIN_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
- def FMAX_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
-
- def FMINIMUM_NUM_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
- def FMAXIMUM_NUM_#FPTy : FPRuntimeLibcall<FPTy, Floating, [Same, Same]>;
-
- def LDEXP_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Int]>;
- def FREXP_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Ptr]>;
-
- def MODF_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Ptr]>;
- def NAN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Ptr]>;
- def NEXTTOWARD_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, LDbl]>;
- def REMAINDER_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Flt]>;
- def SCALBLN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Long]>;
- def SCALBN_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt, Int]>;
- def TGAMMA_#FPTy : FPRuntimeLibcall<FPTy, Flt, [Flt]>;
+foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
+ def POW_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def POW_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def CEIL_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def TRUNC_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def RINT_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def NEARBYINT_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ROUND_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ROUNDEVEN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def FLOOR_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def COPYSIGN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def FMIN_#FPTy.Suffix : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMAX_#FPTy.Suffix : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMINIMUM_#FPTy.Suffix : RuntimeLibcall;
+ def FMAXIMUM_#FPTy.Suffix : RuntimeLibcall;
+ def FMINIMUM_NUM_#FPTy.Suffix : RuntimeLibcall<Floating, [Same, Same]>;
+ def FMAXIMUM_NUM_#FPTy.Suffix : RuntimeLibcall<Floating, [Same, Same]>;
+ def LROUND_#FPTy.Suffix : RuntimeLibcall;
+ def LLROUND_#FPTy.Suffix : RuntimeLibcall;
+ def LRINT_#FPTy.Suffix : RuntimeLibcall;
+ def LLRINT_#FPTy.Suffix : RuntimeLibcall;
+ def LDEXP_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Int]>;
+ def FREXP_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Ptr]>;
+ def SINCOSPI_#FPTy.Suffix : RuntimeLibcall;
+ def MODF_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Ptr]>;
+ def NAN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [Ptr]>;
+ def NEXTTOWARD_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, LDbl]>;
+ def REMAINDER_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def SCALBLN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Long]>;
+ def SCALBN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Int]>;
+ def TGAMMA_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
}
defvar F32VectorSuffixes = ["V2F32", "V4F32", "V8F32", "V16F32", "NXV4F32"];
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 444dd0aa2d52c..45966053d8a50 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -84,21 +84,6 @@ class RuntimeLibcall<FuncArgType RetType = NoneType,
list<FuncArgType> ArgumentTypes = ArgTypes;
}
-class FPRuntimeLibcall<string FPTy,
- FuncArgType RetType = NoneType,
- list<FuncArgType> ArgTypes = []>
- : RuntimeLibcall<
- !cond(!and(!eq(FPTy, "F64"), !eq(RetType, Flt)) : Dbl,
- !and(!eq(FPTy, "F128"), !eq(RetType, Flt)) : LDbl,
- !or(!eq(FPTy, "F80"), !eq(FPTy, "PPCF128")) : NoneType,
- true : RetType),
- !cond(!eq(FPTy, "F64") :
- !foreach(ArgType, ArgTypes, !if(!eq(ArgType, Flt), Dbl, ArgType)),
- !eq(FPTy, "F128") :
- !foreach(ArgType, ArgTypes, !if(!eq(ArgType, Flt), LDbl, ArgType)),
- !or(!eq(FPTy, "F80"), !eq(FPTy, "PPCF128")) : [],
- true : ArgTypes)>;
-
// Concrete implementation of a libcall, which may have a different
// name and only be valid on some subset of targets.
>From 49b2f4f0e18d7b0b5dc55029110bd4489cb28439 Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Wed, 13 May 2026 13:50:15 +0000
Subject: [PATCH 6/8] Fix lit test TargetLibraryInfo.td.
---
llvm/test/TableGen/TargetLibraryInfo.td | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/llvm/test/TableGen/TargetLibraryInfo.td b/llvm/test/TableGen/TargetLibraryInfo.td
index d88e1b6d58d5a..5b8f251a40281 100644
--- a/llvm/test/TableGen/TargetLibraryInfo.td
+++ b/llvm/test/TableGen/TargetLibraryInfo.td
@@ -1,15 +1,15 @@
// RUN: llvm-tblgen -gen-target-library-info -I %p/../../include %s | FileCheck %s
-include "llvm/Analysis/TargetLibraryInfoImpl.td"
+include "llvm/IR/RuntimeLibcallsImpl.td"
-def cosf : TargetLibCall< "cosf", Flt, [Flt]>;
-def sinf : TargetLibCall< "sinf", Flt, [Flt]>;
+def TLI_cosf : TargetLibCall_D< "cosf", Flt, [Flt]>;
+def TLI_sinf : TargetLibCall_D< "sinf", Flt, [Flt]>;
-def fmaxf : TargetLibCall< "fmaxf", Floating, [Same, Same]>;
+def TLI_fmaxf : TargetLibCall_D< "fmaxf", Floating, [Same, Same]>;
-def printf : TargetLibCall< "printf", Int, [Ptr, Ellip]>;
+def TLI_printf : TargetLibCall_D< "printf", Int, [Ptr, Ellip]>;
-def cabs : TargetLibCall< "cabs", ? /* Checked manually. */>;
+def TLI_cabs : TargetLibCall_D< "cabs", ? /* Checked manually. */>;
// CHECK: #ifdef GET_TARGET_LIBRARY_INFO_ENUM
// CHECK-NEXT: #undef GET_TARGET_LIBRARY_INFO_ENUM
>From 9ced4b8642b69b74488550cd3fe5baecc5ee707f Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Tue, 2 Jun 2026 18:11:48 +0000
Subject: [PATCH 7/8] Move 69 functions to RuntimeLibcalls.td.
---
.../llvm/Analysis/TargetLibraryInfo.td | 140 ++++---
llvm/include/llvm/IR/RuntimeLibcalls.td | 100 ++++-
sj_tmp | 370 ++++++++++++++++++
3 files changed, 537 insertions(+), 73 deletions(-)
create mode 100644 sj_tmp
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
index d74bf31ad1be7..598d0f727875f 100644
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.td
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
@@ -243,49 +243,49 @@ def TLI_size_returning_new_aligned_hot_cold
: TargetLibCall_R<__size_returning_new_aligned_hot_cold>;
/// double __acos_finite(double x);
-def TLI_acos_finite : TargetLibCall_D<"__acos_finite", Dbl, [Dbl]>;
+def TLI_acos_finite : TargetLibCall_R<__acos_finite>;
/// float __acosf_finite(float x);
-def TLI_acosf_finite : TargetLibCall_D<"__acosf_finite", Flt, [Flt]>;
+def TLI_acosf_finite : TargetLibCall_R<__acosf_finite>;
/// double __acosh_finite(double x);
-def TLI_acosh_finite : TargetLibCall_D<"__acosh_finite", Dbl, [Dbl]>;
+def TLI_acosh_finite : TargetLibCall_R<__acosh_finite>;
/// float __acoshf_finite(float x);
-def TLI_acoshf_finite : TargetLibCall_D<"__acoshf_finite", Flt, [Flt]>;
+def TLI_acoshf_finite : TargetLibCall_R<__acoshf_finite>;
/// long double __acoshl_finite(long double x);
-def TLI_acoshl_finite : TargetLibCall_D<"__acoshl_finite", LDbl, [LDbl]>;
+def TLI_acoshl_finite : TargetLibCall_R<__acoshl_finite>;
/// long double __acosl_finite(long double x);
-def TLI_acosl_finite : TargetLibCall_D<"__acosl_finite", LDbl, [LDbl]>;
+def TLI_acosl_finite : TargetLibCall_R<__acosl_finite>;
/// double __asin_finite(double x);
-def TLI_asin_finite : TargetLibCall_D<"__asin_finite", Dbl, [Dbl]>;
+def TLI_asin_finite : TargetLibCall_R<__asin_finite>;
/// float __asinf_finite(float x);
-def TLI_asinf_finite : TargetLibCall_D<"__asinf_finite", Flt, [Flt]>;
+def TLI_asinf_finite : TargetLibCall_R<__asinf_finite>;
/// long double __asinl_finite(long double x);
-def TLI_asinl_finite : TargetLibCall_D<"__asinl_finite", LDbl, [LDbl]>;
+def TLI_asinl_finite : TargetLibCall_R<__asinl_finite>;
/// double atan2_finite(double y, double x);
-def TLI_atan2_finite : TargetLibCall_D<"__atan2_finite", Dbl, [Dbl, Dbl]>;
+def TLI_atan2_finite : TargetLibCall_R<__atan2_finite>;
/// float atan2f_finite(float y, float x);
-def TLI_atan2f_finite : TargetLibCall_D<"__atan2f_finite", Flt, [Flt, Flt]>;
+def TLI_atan2f_finite : TargetLibCall_R<__atan2f_finite>;
/// long double atan2l_finite(long double y, long double x);
-def TLI_atan2l_finite : TargetLibCall_D<"__atan2l_finite", LDbl, [LDbl, LDbl]>;
+def TLI_atan2l_finite : TargetLibCall_R<__atan2l_finite>;
/// double __atanh_finite(double x);
-def TLI_atanh_finite : TargetLibCall_D<"__atanh_finite", Dbl, [Dbl]>;
+def TLI_atanh_finite : TargetLibCall_R<__atanh_finite>;
/// float __atanhf_finite(float x);
-def TLI_atanhf_finite : TargetLibCall_D<"__atanhf_finite", Flt, [Flt]>;
+def TLI_atanhf_finite : TargetLibCall_R<__atanhf_finite>;
/// long double __atanhl_finite(long double x);
-def TLI_atanhl_finite : TargetLibCall_D<"__atanhl_finite", LDbl, [LDbl]>;
+def TLI_atanhl_finite : TargetLibCall_R<__atanhl_finite>;
/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
@@ -294,19 +294,19 @@ def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
def TLI_atomic_store : TargetLibCall_R<__atomic_store>;
/// double __cosh_finite(double x);
-def TLI_cosh_finite : TargetLibCall_D<"__cosh_finite", Dbl, [Dbl]>;
+def TLI_cosh_finite : TargetLibCall_R<__cosh_finite>;
/// float __coshf_finite(float x);
-def TLI_coshf_finite : TargetLibCall_D<"__coshf_finite", Flt, [Flt]>;
+def TLI_coshf_finite : TargetLibCall_R<__coshf_finite>;
/// long double __coshl_finite(long double x);
-def TLI_coshl_finite : TargetLibCall_D<"__coshl_finite", LDbl, [LDbl]>;
+def TLI_coshl_finite : TargetLibCall_R<__coshl_finite>;
/// double __cospi(double x);
-def TLI_cospi : TargetLibCall_D<"__cospi", Dbl, [Dbl]>;
+def TLI_cospi : TargetLibCall_R<__cospi>;
/// float __cospif(float x);
-def TLI_cospif : TargetLibCall_D<"__cospif", Flt, [Flt]>;
+def TLI_cospif : TargetLibCall_R<__cospif>;
/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
def TLI_cxa_atexit : TargetLibCall_R<__cxa_atexit>;
@@ -321,7 +321,7 @@ def TLI_abort : TargetLibCall_R<abort>;
def TLI_exit : TargetLibCall_R<exit>;
/// void _Exit(int)
-def TLI_Exit : TargetLibCall_D<"_Exit", Void, [Int]>;
+def TLI_Exit : TargetLibCall_R<_Exit>;
/// void std::terminate();
def TLI_terminate : TargetLibCall_R<_ZSt9terminatev>;
@@ -340,14 +340,14 @@ def TLI_cxa_guard_acquire : TargetLibCall_R<__cxa_guard_acquire>;
def TLI_cxa_guard_release : TargetLibCall_R<__cxa_guard_release>;
/// double __exp10_finite(double x);
-def TLI_exp10_finite : TargetLibCall_D<"__exp10_finite", Dbl, [Dbl]>;
+def TLI_exp10_finite : TargetLibCall_R<__exp10_finite>;
/// float __exp10f_finite(float x);
-def TLI_exp10f_finite : TargetLibCall_D<"__exp10f_finite", Flt, [Flt]>;
+def TLI_exp10f_finite : TargetLibCall_R<__exp10f_finite>;
/// long double __exp10l_finite(long double x);
-def TLI_exp10l_finite : TargetLibCall_D<"__exp10l_finite", LDbl, [LDbl]>;
+def TLI_exp10l_finite : TargetLibCall_R<__exp10l_finite>;
/// double __exp2_finite(double x);
def TLI_exp2_finite : TargetLibCall_R<__exp2_finite>;
@@ -417,7 +417,7 @@ def TLI_mempcpy_chk : TargetLibCall_R<__mempcpy_chk>;
def TLI_memset_chk : TargetLibCall_R<__memset_chk>;
// int __nvvm_reflect(const char *)
-def TLI_nvvm_reflect : TargetLibCall_D<"__nvvm_reflect", Int, [Ptr]>;
+def TLI_nvvm_reflect : TargetLibCall_R<__nvvm_reflect>;
/// double __pow_finite(double x, double y);
def TLI_pow_finite : TargetLibCall_R<__pow_finite>;
@@ -429,27 +429,25 @@ def TLI_powf_finite : TargetLibCall_R<__powf_finite>;
def TLI_powl_finite : TargetLibCall_R<__powl_finite_f128>;
/// double __sincospi_stret(double x);
-def TLI_sincospi_stret
- : TargetLibCall_D<"__sincospi_stret", ? /* Checked manually. */>;
+def TLI_sincospi_stret : TargetLibCall_R<__sincospi_stret>;
/// float __sincospif_stret(float x);
-def TLI_sincospif_stret
- : TargetLibCall_D<"__sincospif_stret", ? /* Checked manually. */>;
+def TLI_sincospif_stret : TargetLibCall_R<__sincospif_stret>;
/// double __sinh_finite(double x);
-def TLI_sinh_finite : TargetLibCall_D<"__sinh_finite", Dbl, [Dbl]>;
+def TLI_sinh_finite : TargetLibCall_R<__sinh_finite>;
/// float _sinhf_finite(float x);
-def TLI_sinhf_finite : TargetLibCall_D<"__sinhf_finite", Flt, [Flt]>;
+def TLI_sinhf_finite : TargetLibCall_R<__sinhf_finite>;
/// long double __sinhl_finite(long double x);
-def TLI_sinhl_finite : TargetLibCall_D<"__sinhl_finite", LDbl, [LDbl]>;
+def TLI_sinhl_finite : TargetLibCall_R<__sinhl_finite>;
/// double __sinpi(double x);
-def TLI_sinpi : TargetLibCall_D<"__sinpi", Dbl, [Dbl]>;
+def TLI_sinpi : TargetLibCall_R<__sinpi>;
/// float __sinpif(float x);
-def TLI_sinpif : TargetLibCall_D<"__sinpif", Flt, [Flt]>;
+def TLI_sinpif : TargetLibCall_R<__sinpif>;
/// int __small_fprintf(FILE *stream, const char *format, ...);
def TLI_small_fprintf : TargetLibCall_R<__small_fprintf>;
@@ -469,13 +467,13 @@ def TLI_snprintf_chk : TargetLibCall_R<__snprintf_chk>;
def TLI_sprintf_chk : TargetLibCall_R<__sprintf_chk>;
/// double __sqrt_finite(double x);
-def TLI_sqrt_finite : TargetLibCall_D<"__sqrt_finite", Dbl, [Dbl]>;
+def TLI_sqrt_finite : TargetLibCall_R<__sqrt_finite>;
/// float __sqrt_finite(float x);
-def TLI_sqrtf_finite : TargetLibCall_D<"__sqrtf_finite", Flt, [Flt]>;
+def TLI_sqrtf_finite : TargetLibCall_R<__sqrtf_finite>;
/// long double __sqrt_finite(long double x);
-def TLI_sqrtl_finite : TargetLibCall_D<"__sqrtl_finite", LDbl, [LDbl]>;
+def TLI_sqrtl_finite : TargetLibCall_R<__sqrtl_finite>;
/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
def TLI_stpcpy_chk : TargetLibCall_R<__stpcpy_chk>;
@@ -536,13 +534,13 @@ def TLI_acos : TargetLibCall_R<acos>;
def TLI_acosf : TargetLibCall_R<acosf>;
/// double acosh(double x);
-def TLI_acosh : TargetLibCall_D<"acosh", Dbl, [Dbl]>;
+def TLI_acosh : TargetLibCall_R<acosh>;
/// float acoshf(float x);
-def TLI_acoshf : TargetLibCall_D<"acoshf", Flt, [Flt]>;
+def TLI_acoshf : TargetLibCall_R<acoshf>;
/// long double acoshl(long double x);
-def TLI_acoshl : TargetLibCall_D<"acoshl", LDbl, [LDbl]>;
+def TLI_acoshl : TargetLibCall_R<acoshl>;
/// long double acosl(long double x);
def TLI_acosl : TargetLibCall_R<acosl_f128>;
@@ -557,13 +555,13 @@ def TLI_asin : TargetLibCall_R<asin>;
def TLI_asinf : TargetLibCall_R<asinf>;
/// double asinh(double x);
-def TLI_asinh : TargetLibCall_D<"asinh", Dbl, [Dbl]>;
+def TLI_asinh : TargetLibCall_R<asinh>;
/// float asinhf(float x);
-def TLI_asinhf : TargetLibCall_D<"asinhf", Flt, [Flt]>;
+def TLI_asinhf : TargetLibCall_R<asinhf>;
/// long double asinhl(long double x);
-def TLI_asinhl : TargetLibCall_D<"asinhl", LDbl, [LDbl]>;
+def TLI_asinhl : TargetLibCall_R<asinhl>;
/// long double asinl(long double x);
def TLI_asinl : TargetLibCall_R<asinl_f128>;
@@ -584,14 +582,14 @@ def TLI_atan2l : TargetLibCall_R<atan2l_f128>;
def TLI_atanf : TargetLibCall_R<atanf>;
/// double atanh(double x);
-def TLI_atanh : TargetLibCall_D<"atanh", Dbl, [Dbl]>;
+def TLI_atanh : TargetLibCall_R<atanh>;
/// float atanhf(float x);
-def TLI_atanhf : TargetLibCall_D<"atanhf", Flt, [Flt]>;
+def TLI_atanhf : TargetLibCall_R<atanhf>;
/// long double atanhl(long double x);
-def TLI_atanhl : TargetLibCall_D<"atanhl", LDbl, [LDbl]>;
+def TLI_atanhl : TargetLibCall_R<atanhl>;
/// long double atanl(long double x);
def TLI_atanl : TargetLibCall_R<atanl_f128>;
@@ -690,14 +688,14 @@ def TLI_cosl : TargetLibCall_R<cosl_f128>;
def TLI_ctermid : TargetLibCall_R<ctermid>;
/// double erf(double x);
-def TLI_erf : TargetLibCall_D<"erf", Dbl, [Dbl]>;
+def TLI_erf : TargetLibCall_R<erf>;
/// float erff(float x);
-def TLI_erff : TargetLibCall_D<"erff", Flt, [Flt]>;
+def TLI_erff : TargetLibCall_R<erff>;
/// long double erfl(long double x);
-def TLI_erfl : TargetLibCall_D<"erfl", LDbl, [LDbl]>;
+def TLI_erfl : TargetLibCall_R<erfl>;
/// double tgamma(double x);
def TLI_tgamma : TargetLibCall_R<tgamma>;
@@ -721,7 +719,7 @@ def TLI_execlp : TargetLibCall_R<execlp>;
def TLI_execv : TargetLibCall_R<execv>;
/// int execvP(const char *file, const char *search_path, char *const argv[]);
-def TLI_execvP : TargetLibCall_D<"execvP", Int, [Ptr, Ptr, Ptr]>;
+def TLI_execvP : TargetLibCall_R<execvP>;
/// int execve(const char *filename, char *const argv], [char *const envp[]);
def TLI_execve : TargetLibCall_R<execve>;
@@ -760,22 +758,22 @@ def TLI_expf : TargetLibCall_R<expf>;
def TLI_expl : TargetLibCall_R<expl_f128>;
/// double expm1(double x);
-def TLI_expm1 : TargetLibCall_D<"expm1", Dbl, [Dbl]>;
+def TLI_expm1 : TargetLibCall_R<expm1>;
/// float expm1f(float x);
-def TLI_expm1f : TargetLibCall_D<"expm1f", Flt, [Flt]>;
+def TLI_expm1f : TargetLibCall_R<expm1f>;
/// long double expm1l(long double x);
-def TLI_expm1l : TargetLibCall_D<"expm1l", LDbl, [LDbl]>;
+def TLI_expm1l : TargetLibCall_R<expm1l>;
/// double fabs(double x);
-def TLI_fabs : TargetLibCall_D<"fabs", Dbl, [Dbl]>;
+def TLI_fabs : TargetLibCall_R<fabs>;
/// float fabsf(float x);
-def TLI_fabsf : TargetLibCall_D<"fabsf", Flt, [Flt]>;
+def TLI_fabsf : TargetLibCall_R<fabsf>;
/// long double fabsl(long double x);
-def TLI_fabsl : TargetLibCall_D<"fabsl", LDbl, [LDbl]>;
+def TLI_fabsl : TargetLibCall_R<fabsl>;
/// int fclose(FILE *stream);
def TLI_fclose : TargetLibCall_R<fclose>;
@@ -1022,13 +1020,13 @@ def TLI_htonl : TargetLibCall_R<htonl>;
def TLI_htons : TargetLibCall_R<htons>;
/// double hypot(double x, double y);
-def TLI_hypot : TargetLibCall_D<"hypot", Dbl, [Dbl, Dbl]>;
+def TLI_hypot : TargetLibCall_R<hypot>;
/// float hypotf(float x, float y);
-def TLI_hypotf : TargetLibCall_D<"hypotf", Flt, [Flt, Flt]>;
+def TLI_hypotf : TargetLibCall_R<hypotf>;
/// long double hypotl(long double x, long double y);
-def TLI_hypotl : TargetLibCall_D<"hypotl", LDbl, [LDbl, LDbl]>;
+def TLI_hypotl : TargetLibCall_R<hypotl>;
/// int iprintf(const char *format, ...);
def TLI_iprintf : TargetLibCall_R<iprintf>;
@@ -1070,13 +1068,13 @@ def TLI_log10f : TargetLibCall_R<log10f>;
def TLI_log10l : TargetLibCall_R<log10l_f128>;
/// double log1p(double x);
-def TLI_log1p : TargetLibCall_D<"log1p", Dbl, [Dbl]>;
+def TLI_log1p : TargetLibCall_R<log1p>;
/// float log1pf(float x);
-def TLI_log1pf : TargetLibCall_D<"log1pf", Flt, [Flt]>;
+def TLI_log1pf : TargetLibCall_R<log1pf>;
/// long double log1pl(long double x);
-def TLI_log1pl : TargetLibCall_D<"log1pl", LDbl, [LDbl]>;
+def TLI_log1pl : TargetLibCall_R<log1pl>;
/// double log2(double x);
def TLI_log2 : TargetLibCall_R<log2>;
@@ -1088,22 +1086,22 @@ def TLI_log2f : TargetLibCall_R<log2f>;
def TLI_log2l : TargetLibCall_R<log2l_f128>;
/// int ilogb(double x);
-def TLI_ilogb : TargetLibCall_D<"ilogb", Int, [Dbl]>;
+def TLI_ilogb : TargetLibCall_R<ilogb>;
/// int ilogbf(float x);
-def TLI_ilogbf : TargetLibCall_D<"ilogbf", Int, [Flt]>;
+def TLI_ilogbf : TargetLibCall_R<ilogbf>;
/// int ilogbl(long double x);
-def TLI_ilogbl : TargetLibCall_D<"ilogbl", Int, [LDbl]>;
+def TLI_ilogbl : TargetLibCall_R<ilogbl>;
/// double logb(double x);
-def TLI_logb : TargetLibCall_D<"logb", Dbl, [Dbl]>;
+def TLI_logb : TargetLibCall_R<logb>;
/// float logbf(float x);
-def TLI_logbf : TargetLibCall_D<"logbf", Flt, [Flt]>;
+def TLI_logbf : TargetLibCall_R<logbf>;
/// long double logbl(long double x);
-def TLI_logbl : TargetLibCall_D<"logbl", LDbl, [LDbl]>;
+def TLI_logbl : TargetLibCall_R<logbl>;
/// float logf(float x);
def TLI_logf : TargetLibCall_R<logf>;
@@ -1190,13 +1188,13 @@ def TLI_nearbyintf : TargetLibCall_R<nearbyintf>;
def TLI_nearbyintl : TargetLibCall_R<nearbyintl_f128>;
/// double nextafter(double x, double y);
-def TLI_nextafter : TargetLibCall_D< "nextafter", Dbl, [Dbl, Dbl]>;
+def TLI_nextafter : TargetLibCall_R<nextafter>;
/// float nextafterf(float x, float y);
-def TLI_nextafterf : TargetLibCall_D< "nextafterf", Flt, [Flt, Flt]>;
+def TLI_nextafterf : TargetLibCall_R<nextafterf>;
/// long double nextafterl(long double x, long double y);
-def TLI_nextafterl : TargetLibCall_D< "nextafterl", LDbl, [LDbl, LDbl]>;
+def TLI_nextafterl : TargetLibCall_R<nextafterl>;
/// double nexttoward(double x, long double y);
def TLI_nexttoward : TargetLibCall_R<nexttoward>;
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 19762e3f6914f..96ddd4992bb64 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -156,7 +156,7 @@ foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
def EXP2_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
def EXP2_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
def EXP10_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
- def EXP10_FINITE_#FPTy.Suffix : RuntimeLibcall;
+ def EXP10_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
def SIN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
def COS_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
def TAN_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
@@ -172,10 +172,33 @@ foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
def FDIM_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
def CABS_#FPTy.Suffix : RuntimeLibcall<NoneType, []>;
+
+ def ACOS_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ACOSH_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ASIN_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ATAN2_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def ATANH_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def COSH_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def SINH_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def SQRT_FINITE_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def COSPI_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def SINPI_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ACOSH_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ASINH_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ATANH_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ERF_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def EXPM1_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def FABS_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def HYPOT_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
+ def LOG1P_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def ILOGB_#FPTy.Suffix : RuntimeLibcall<Int, [FPTy.Type]>;
+ def LOGB_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]>;
+ def NEXTAFTER_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
}
foreach FPTy = [ "F32", "F64" ] in {
def SINCOS_STRET_#FPTy : RuntimeLibcall;
+ def SINCOSPI_STRET_#FPTy : RuntimeLibcall<NoneType, []>;
}
foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
@@ -642,6 +665,7 @@ def EXECLP : RuntimeLibcall<Int, [Ptr, Ptr, Ellip]>;
def EXECV : RuntimeLibcall<Int, [Ptr, Ptr]>;
def EXECVE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
def EXECVP : RuntimeLibcall<Int, [Ptr, Ptr]>;
+def EXECV_P : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
def EXECVPE : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
def EXIT : RuntimeLibcall<Void, [Int]>;
def FCLOSE : RuntimeLibcall<Int, [Ptr]>;
@@ -905,6 +929,8 @@ def ZNWMST11ALIGN_VAL_TRKST9NOTHROW_T12__HOT_COLD_T : RuntimeLibcall<Ptr, [Long,
def KMPC_ALLOC_SHARED : RuntimeLibcall<Ptr, [SizeT]>;
def KMPC_FREE_SHARED : RuntimeLibcall<Void, [Ptr, SizeT]>;
+def NVVM_REFLECT : RuntimeLibcall<Int, [Ptr]>;
+
//--------------------------------------------------------------------
// Global variable references
//--------------------------------------------------------------------
@@ -1618,7 +1644,7 @@ def execl : RuntimeLibcallImpl<EXECL>;
def execle : RuntimeLibcallImpl<EXECLE>;
def execlp : RuntimeLibcallImpl<EXECLP>;
def execv : RuntimeLibcallImpl<EXECV>;
-def execvP : RuntimeLibcallImpl<EXECVP>;
+def execvP : RuntimeLibcallImpl<EXECV_P>;
def execve : RuntimeLibcallImpl<EXECVE>;
def execvp : RuntimeLibcallImpl<EXECVP>;
def execvpe : RuntimeLibcallImpl<EXECVPE>;
@@ -1798,6 +1824,76 @@ def vsscanf : RuntimeLibcallImpl<VSSCANF>;
def wcslen : RuntimeLibcallImpl<WCSLEN>;
def write : RuntimeLibcallImpl<WRITE>;
+def __acos_finite : RuntimeLibcallImpl<ACOS_FINITE_F64>;
+def __acosf_finite : RuntimeLibcallImpl<ACOS_FINITE_F32>;
+def __acosl_finite : RuntimeLibcallImpl<ACOS_FINITE_F128>;
+def __acosh_finite : RuntimeLibcallImpl<ACOSH_FINITE_F64>;
+def __acoshf_finite : RuntimeLibcallImpl<ACOSH_FINITE_F32>;
+def __acoshl_finite : RuntimeLibcallImpl<ACOSH_FINITE_F128>;
+def __asin_finite : RuntimeLibcallImpl<ASIN_FINITE_F64>;
+def __asinf_finite : RuntimeLibcallImpl<ASIN_FINITE_F32>;
+def __asinl_finite : RuntimeLibcallImpl<ASIN_FINITE_F128>;
+def __atan2_finite : RuntimeLibcallImpl<ATAN2_FINITE_F64>;
+def __atan2f_finite : RuntimeLibcallImpl<ATAN2_FINITE_F32>;
+def __atan2l_finite : RuntimeLibcallImpl<ATAN2_FINITE_F128>;
+def __atanh_finite : RuntimeLibcallImpl<ATANH_FINITE_F64>;
+def __atanhf_finite : RuntimeLibcallImpl<ATANH_FINITE_F32>;
+def __atanhl_finite : RuntimeLibcallImpl<ATANH_FINITE_F128>;
+def __cosh_finite : RuntimeLibcallImpl<COSH_FINITE_F64>;
+def __coshf_finite : RuntimeLibcallImpl<COSH_FINITE_F32>;
+def __coshl_finite : RuntimeLibcallImpl<COSH_FINITE_F128>;
+def __sinh_finite : RuntimeLibcallImpl<SINH_FINITE_F64>;
+def __sinhf_finite : RuntimeLibcallImpl<SINH_FINITE_F32>;
+def __sinhl_finite : RuntimeLibcallImpl<SINH_FINITE_F128>;
+def __exp10_finite : RuntimeLibcallImpl<EXP10_FINITE_F64>;
+def __exp10f_finite : RuntimeLibcallImpl<EXP10_FINITE_F32>;
+def __exp10l_finite : RuntimeLibcallImpl<EXP10_FINITE_F128>;
+def __sqrt_finite : RuntimeLibcallImpl<SQRT_FINITE_F64>;
+def __sqrtf_finite : RuntimeLibcallImpl<SQRT_FINITE_F32>;
+def __sqrtl_finite : RuntimeLibcallImpl<SQRT_FINITE_F128>;
+def __cospi : RuntimeLibcallImpl<COSPI_F64>;
+def __cospif : RuntimeLibcallImpl<COSPI_F32>;
+def __sinpi : RuntimeLibcallImpl<SINPI_F64>;
+def __sinpif : RuntimeLibcallImpl<SINPI_F32>;
+def acosh : RuntimeLibcallImpl<ACOSH_F64>;
+def acoshf : RuntimeLibcallImpl<ACOSH_F32>;
+def acoshl : RuntimeLibcallImpl<ACOSH_F128>;
+def asinh : RuntimeLibcallImpl<ASINH_F64>;
+def asinhf : RuntimeLibcallImpl<ASINH_F32>;
+def asinhl : RuntimeLibcallImpl<ASINH_F128>;
+def atanh : RuntimeLibcallImpl<ATANH_F64>;
+def atanhf : RuntimeLibcallImpl<ATANH_F32>;
+def atanhl : RuntimeLibcallImpl<ATANH_F128>;
+def erf : RuntimeLibcallImpl<ERF_F64>;
+def erff : RuntimeLibcallImpl<ERF_F32>;
+def erfl : RuntimeLibcallImpl<ERF_F128>;
+def expm1 : RuntimeLibcallImpl<EXPM1_F64>;
+def expm1f : RuntimeLibcallImpl<EXPM1_F32>;
+def expm1l : RuntimeLibcallImpl<EXPM1_F128>;
+def fabs : RuntimeLibcallImpl<FABS_F64>;
+def fabsf : RuntimeLibcallImpl<FABS_F32>;
+def fabsl : RuntimeLibcallImpl<FABS_F128>;
+def hypot : RuntimeLibcallImpl<HYPOT_F64>;
+def hypotf : RuntimeLibcallImpl<HYPOT_F32>;
+def hypotl : RuntimeLibcallImpl<HYPOT_F128>;
+def log1p : RuntimeLibcallImpl<LOG1P_F64>;
+def log1pf : RuntimeLibcallImpl<LOG1P_F32>;
+def log1pl : RuntimeLibcallImpl<LOG1P_F128>;
+def ilogb : RuntimeLibcallImpl<ILOGB_F64>;
+def ilogbf : RuntimeLibcallImpl<ILOGB_F32>;
+def ilogbl : RuntimeLibcallImpl<ILOGB_F128>;
+def logb : RuntimeLibcallImpl<LOGB_F64>;
+def logbf : RuntimeLibcallImpl<LOGB_F32>;
+def logbl : RuntimeLibcallImpl<LOGB_F128>;
+def nextafter : RuntimeLibcallImpl<NEXTAFTER_F64>;
+def nextafterf : RuntimeLibcallImpl<NEXTAFTER_F32>;
+def nextafterl : RuntimeLibcallImpl<NEXTAFTER_F128>;
+
+def __nvvm_reflect : RuntimeLibcallImpl<NVVM_REFLECT>;
+
+def __sincospif_stret : RuntimeLibcallImpl<SINCOSPI_STRET_F32>;
+def __sincospi_stret : RuntimeLibcallImpl<SINCOSPI_STRET_F64>;
+
//--------------------------------------------------------------------
// compiler-rt/libgcc but 64-bit only, not available by default
//--------------------------------------------------------------------
diff --git a/sj_tmp b/sj_tmp
new file mode 100644
index 0000000000000..bb68ff9fd815f
--- /dev/null
+++ b/sj_tmp
@@ -0,0 +1,370 @@
+diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
+index d74bf31ad1be..598d0f727875 100644
+--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.td
++++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
+@@ -243,49 +243,49 @@ def TLI_size_returning_new_aligned_hot_cold
+ : TargetLibCall_R<__size_returning_new_aligned_hot_cold>;
+
+ /// double __acos_finite(double x);
+-def TLI_acos_finite : TargetLibCall_D<"__acos_finite", Dbl, [Dbl]>;
++def TLI_acos_finite : TargetLibCall_R<__acos_finite>;
+
+ /// float __acosf_finite(float x);
+-def TLI_acosf_finite : TargetLibCall_D<"__acosf_finite", Flt, [Flt]>;
++def TLI_acosf_finite : TargetLibCall_R<__acosf_finite>;
+
+ /// double __acosh_finite(double x);
+-def TLI_acosh_finite : TargetLibCall_D<"__acosh_finite", Dbl, [Dbl]>;
++def TLI_acosh_finite : TargetLibCall_R<__acosh_finite>;
+
+ /// float __acoshf_finite(float x);
+-def TLI_acoshf_finite : TargetLibCall_D<"__acoshf_finite", Flt, [Flt]>;
++def TLI_acoshf_finite : TargetLibCall_R<__acoshf_finite>;
+
+ /// long double __acoshl_finite(long double x);
+-def TLI_acoshl_finite : TargetLibCall_D<"__acoshl_finite", LDbl, [LDbl]>;
++def TLI_acoshl_finite : TargetLibCall_R<__acoshl_finite>;
+
+ /// long double __acosl_finite(long double x);
+-def TLI_acosl_finite : TargetLibCall_D<"__acosl_finite", LDbl, [LDbl]>;
++def TLI_acosl_finite : TargetLibCall_R<__acosl_finite>;
+
+ /// double __asin_finite(double x);
+-def TLI_asin_finite : TargetLibCall_D<"__asin_finite", Dbl, [Dbl]>;
++def TLI_asin_finite : TargetLibCall_R<__asin_finite>;
+
+ /// float __asinf_finite(float x);
+-def TLI_asinf_finite : TargetLibCall_D<"__asinf_finite", Flt, [Flt]>;
++def TLI_asinf_finite : TargetLibCall_R<__asinf_finite>;
+
+ /// long double __asinl_finite(long double x);
+-def TLI_asinl_finite : TargetLibCall_D<"__asinl_finite", LDbl, [LDbl]>;
++def TLI_asinl_finite : TargetLibCall_R<__asinl_finite>;
+
+ /// double atan2_finite(double y, double x);
+-def TLI_atan2_finite : TargetLibCall_D<"__atan2_finite", Dbl, [Dbl, Dbl]>;
++def TLI_atan2_finite : TargetLibCall_R<__atan2_finite>;
+
+ /// float atan2f_finite(float y, float x);
+-def TLI_atan2f_finite : TargetLibCall_D<"__atan2f_finite", Flt, [Flt, Flt]>;
++def TLI_atan2f_finite : TargetLibCall_R<__atan2f_finite>;
+
+ /// long double atan2l_finite(long double y, long double x);
+-def TLI_atan2l_finite : TargetLibCall_D<"__atan2l_finite", LDbl, [LDbl, LDbl]>;
++def TLI_atan2l_finite : TargetLibCall_R<__atan2l_finite>;
+
+ /// double __atanh_finite(double x);
+-def TLI_atanh_finite : TargetLibCall_D<"__atanh_finite", Dbl, [Dbl]>;
++def TLI_atanh_finite : TargetLibCall_R<__atanh_finite>;
+
+ /// float __atanhf_finite(float x);
+-def TLI_atanhf_finite : TargetLibCall_D<"__atanhf_finite", Flt, [Flt]>;
++def TLI_atanhf_finite : TargetLibCall_R<__atanhf_finite>;
+
+ /// long double __atanhl_finite(long double x);
+-def TLI_atanhl_finite : TargetLibCall_D<"__atanhl_finite", LDbl, [LDbl]>;
++def TLI_atanhl_finite : TargetLibCall_R<__atanhl_finite>;
+
+ /// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
+ def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
+@@ -294,19 +294,19 @@ def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
+ def TLI_atomic_store : TargetLibCall_R<__atomic_store>;
+
+ /// double __cosh_finite(double x);
+-def TLI_cosh_finite : TargetLibCall_D<"__cosh_finite", Dbl, [Dbl]>;
++def TLI_cosh_finite : TargetLibCall_R<__cosh_finite>;
+
+ /// float __coshf_finite(float x);
+-def TLI_coshf_finite : TargetLibCall_D<"__coshf_finite", Flt, [Flt]>;
++def TLI_coshf_finite : TargetLibCall_R<__coshf_finite>;
+
+ /// long double __coshl_finite(long double x);
+-def TLI_coshl_finite : TargetLibCall_D<"__coshl_finite", LDbl, [LDbl]>;
++def TLI_coshl_finite : TargetLibCall_R<__coshl_finite>;
+
+ /// double __cospi(double x);
+-def TLI_cospi : TargetLibCall_D<"__cospi", Dbl, [Dbl]>;
++def TLI_cospi : TargetLibCall_R<__cospi>;
+
+ /// float __cospif(float x);
+-def TLI_cospif : TargetLibCall_D<"__cospif", Flt, [Flt]>;
++def TLI_cospif : TargetLibCall_R<__cospif>;
+
+ /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
+ def TLI_cxa_atexit : TargetLibCall_R<__cxa_atexit>;
+@@ -321,7 +321,7 @@ def TLI_abort : TargetLibCall_R<abort>;
+ def TLI_exit : TargetLibCall_R<exit>;
+
+ /// void _Exit(int)
+-def TLI_Exit : TargetLibCall_D<"_Exit", Void, [Int]>;
++def TLI_Exit : TargetLibCall_R<_Exit>;
+
+ /// void std::terminate();
+ def TLI_terminate : TargetLibCall_R<_ZSt9terminatev>;
+@@ -340,14 +340,14 @@ def TLI_cxa_guard_acquire : TargetLibCall_R<__cxa_guard_acquire>;
+ def TLI_cxa_guard_release : TargetLibCall_R<__cxa_guard_release>;
+
+ /// double __exp10_finite(double x);
+-def TLI_exp10_finite : TargetLibCall_D<"__exp10_finite", Dbl, [Dbl]>;
++def TLI_exp10_finite : TargetLibCall_R<__exp10_finite>;
+
+
+ /// float __exp10f_finite(float x);
+-def TLI_exp10f_finite : TargetLibCall_D<"__exp10f_finite", Flt, [Flt]>;
++def TLI_exp10f_finite : TargetLibCall_R<__exp10f_finite>;
+
+ /// long double __exp10l_finite(long double x);
+-def TLI_exp10l_finite : TargetLibCall_D<"__exp10l_finite", LDbl, [LDbl]>;
++def TLI_exp10l_finite : TargetLibCall_R<__exp10l_finite>;
+
+ /// double __exp2_finite(double x);
+ def TLI_exp2_finite : TargetLibCall_R<__exp2_finite>;
+@@ -417,7 +417,7 @@ def TLI_mempcpy_chk : TargetLibCall_R<__mempcpy_chk>;
+ def TLI_memset_chk : TargetLibCall_R<__memset_chk>;
+
+ // int __nvvm_reflect(const char *)
+-def TLI_nvvm_reflect : TargetLibCall_D<"__nvvm_reflect", Int, [Ptr]>;
++def TLI_nvvm_reflect : TargetLibCall_R<__nvvm_reflect>;
+
+ /// double __pow_finite(double x, double y);
+ def TLI_pow_finite : TargetLibCall_R<__pow_finite>;
+@@ -429,27 +429,25 @@ def TLI_powf_finite : TargetLibCall_R<__powf_finite>;
+ def TLI_powl_finite : TargetLibCall_R<__powl_finite_f128>;
+
+ /// double __sincospi_stret(double x);
+-def TLI_sincospi_stret
+- : TargetLibCall_D<"__sincospi_stret", ? /* Checked manually. */>;
++def TLI_sincospi_stret : TargetLibCall_R<__sincospi_stret>;
+
+ /// float __sincospif_stret(float x);
+-def TLI_sincospif_stret
+- : TargetLibCall_D<"__sincospif_stret", ? /* Checked manually. */>;
++def TLI_sincospif_stret : TargetLibCall_R<__sincospif_stret>;
+
+ /// double __sinh_finite(double x);
+-def TLI_sinh_finite : TargetLibCall_D<"__sinh_finite", Dbl, [Dbl]>;
++def TLI_sinh_finite : TargetLibCall_R<__sinh_finite>;
+
+ /// float _sinhf_finite(float x);
+-def TLI_sinhf_finite : TargetLibCall_D<"__sinhf_finite", Flt, [Flt]>;
++def TLI_sinhf_finite : TargetLibCall_R<__sinhf_finite>;
+
+ /// long double __sinhl_finite(long double x);
+-def TLI_sinhl_finite : TargetLibCall_D<"__sinhl_finite", LDbl, [LDbl]>;
++def TLI_sinhl_finite : TargetLibCall_R<__sinhl_finite>;
+
+ /// double __sinpi(double x);
+-def TLI_sinpi : TargetLibCall_D<"__sinpi", Dbl, [Dbl]>;
++def TLI_sinpi : TargetLibCall_R<__sinpi>;
+
+ /// float __sinpif(float x);
+-def TLI_sinpif : TargetLibCall_D<"__sinpif", Flt, [Flt]>;
++def TLI_sinpif : TargetLibCall_R<__sinpif>;
+
+ /// int __small_fprintf(FILE *stream, const char *format, ...);
+ def TLI_small_fprintf : TargetLibCall_R<__small_fprintf>;
+@@ -469,13 +467,13 @@ def TLI_snprintf_chk : TargetLibCall_R<__snprintf_chk>;
+ def TLI_sprintf_chk : TargetLibCall_R<__sprintf_chk>;
+
+ /// double __sqrt_finite(double x);
+-def TLI_sqrt_finite : TargetLibCall_D<"__sqrt_finite", Dbl, [Dbl]>;
++def TLI_sqrt_finite : TargetLibCall_R<__sqrt_finite>;
+
+ /// float __sqrt_finite(float x);
+-def TLI_sqrtf_finite : TargetLibCall_D<"__sqrtf_finite", Flt, [Flt]>;
++def TLI_sqrtf_finite : TargetLibCall_R<__sqrtf_finite>;
+
+ /// long double __sqrt_finite(long double x);
+-def TLI_sqrtl_finite : TargetLibCall_D<"__sqrtl_finite", LDbl, [LDbl]>;
++def TLI_sqrtl_finite : TargetLibCall_R<__sqrtl_finite>;
+
+ /// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
+ def TLI_stpcpy_chk : TargetLibCall_R<__stpcpy_chk>;
+@@ -536,13 +534,13 @@ def TLI_acos : TargetLibCall_R<acos>;
+ def TLI_acosf : TargetLibCall_R<acosf>;
+
+ /// double acosh(double x);
+-def TLI_acosh : TargetLibCall_D<"acosh", Dbl, [Dbl]>;
++def TLI_acosh : TargetLibCall_R<acosh>;
+
+ /// float acoshf(float x);
+-def TLI_acoshf : TargetLibCall_D<"acoshf", Flt, [Flt]>;
++def TLI_acoshf : TargetLibCall_R<acoshf>;
+
+ /// long double acoshl(long double x);
+-def TLI_acoshl : TargetLibCall_D<"acoshl", LDbl, [LDbl]>;
++def TLI_acoshl : TargetLibCall_R<acoshl>;
+
+ /// long double acosl(long double x);
+ def TLI_acosl : TargetLibCall_R<acosl_f128>;
+@@ -557,13 +555,13 @@ def TLI_asin : TargetLibCall_R<asin>;
+ def TLI_asinf : TargetLibCall_R<asinf>;
+
+ /// double asinh(double x);
+-def TLI_asinh : TargetLibCall_D<"asinh", Dbl, [Dbl]>;
++def TLI_asinh : TargetLibCall_R<asinh>;
+
+ /// float asinhf(float x);
+-def TLI_asinhf : TargetLibCall_D<"asinhf", Flt, [Flt]>;
++def TLI_asinhf : TargetLibCall_R<asinhf>;
+
+ /// long double asinhl(long double x);
+-def TLI_asinhl : TargetLibCall_D<"asinhl", LDbl, [LDbl]>;
++def TLI_asinhl : TargetLibCall_R<asinhl>;
+
+ /// long double asinl(long double x);
+ def TLI_asinl : TargetLibCall_R<asinl_f128>;
+@@ -584,14 +582,14 @@ def TLI_atan2l : TargetLibCall_R<atan2l_f128>;
+ def TLI_atanf : TargetLibCall_R<atanf>;
+
+ /// double atanh(double x);
+-def TLI_atanh : TargetLibCall_D<"atanh", Dbl, [Dbl]>;
++def TLI_atanh : TargetLibCall_R<atanh>;
+
+
+ /// float atanhf(float x);
+-def TLI_atanhf : TargetLibCall_D<"atanhf", Flt, [Flt]>;
++def TLI_atanhf : TargetLibCall_R<atanhf>;
+
+ /// long double atanhl(long double x);
+-def TLI_atanhl : TargetLibCall_D<"atanhl", LDbl, [LDbl]>;
++def TLI_atanhl : TargetLibCall_R<atanhl>;
+
+ /// long double atanl(long double x);
+ def TLI_atanl : TargetLibCall_R<atanl_f128>;
+@@ -690,14 +688,14 @@ def TLI_cosl : TargetLibCall_R<cosl_f128>;
+ def TLI_ctermid : TargetLibCall_R<ctermid>;
+
+ /// double erf(double x);
+-def TLI_erf : TargetLibCall_D<"erf", Dbl, [Dbl]>;
++def TLI_erf : TargetLibCall_R<erf>;
+
+
+ /// float erff(float x);
+-def TLI_erff : TargetLibCall_D<"erff", Flt, [Flt]>;
++def TLI_erff : TargetLibCall_R<erff>;
+
+ /// long double erfl(long double x);
+-def TLI_erfl : TargetLibCall_D<"erfl", LDbl, [LDbl]>;
++def TLI_erfl : TargetLibCall_R<erfl>;
+
+ /// double tgamma(double x);
+ def TLI_tgamma : TargetLibCall_R<tgamma>;
+@@ -721,7 +719,7 @@ def TLI_execlp : TargetLibCall_R<execlp>;
+ def TLI_execv : TargetLibCall_R<execv>;
+
+ /// int execvP(const char *file, const char *search_path, char *const argv[]);
+-def TLI_execvP : TargetLibCall_D<"execvP", Int, [Ptr, Ptr, Ptr]>;
++def TLI_execvP : TargetLibCall_R<execvP>;
+
+ /// int execve(const char *filename, char *const argv], [char *const envp[]);
+ def TLI_execve : TargetLibCall_R<execve>;
+@@ -760,22 +758,22 @@ def TLI_expf : TargetLibCall_R<expf>;
+ def TLI_expl : TargetLibCall_R<expl_f128>;
+
+ /// double expm1(double x);
+-def TLI_expm1 : TargetLibCall_D<"expm1", Dbl, [Dbl]>;
++def TLI_expm1 : TargetLibCall_R<expm1>;
+
+ /// float expm1f(float x);
+-def TLI_expm1f : TargetLibCall_D<"expm1f", Flt, [Flt]>;
++def TLI_expm1f : TargetLibCall_R<expm1f>;
+
+ /// long double expm1l(long double x);
+-def TLI_expm1l : TargetLibCall_D<"expm1l", LDbl, [LDbl]>;
++def TLI_expm1l : TargetLibCall_R<expm1l>;
+
+ /// double fabs(double x);
+-def TLI_fabs : TargetLibCall_D<"fabs", Dbl, [Dbl]>;
++def TLI_fabs : TargetLibCall_R<fabs>;
+
+ /// float fabsf(float x);
+-def TLI_fabsf : TargetLibCall_D<"fabsf", Flt, [Flt]>;
++def TLI_fabsf : TargetLibCall_R<fabsf>;
+
+ /// long double fabsl(long double x);
+-def TLI_fabsl : TargetLibCall_D<"fabsl", LDbl, [LDbl]>;
++def TLI_fabsl : TargetLibCall_R<fabsl>;
+
+ /// int fclose(FILE *stream);
+ def TLI_fclose : TargetLibCall_R<fclose>;
+@@ -1022,13 +1020,13 @@ def TLI_htonl : TargetLibCall_R<htonl>;
+ def TLI_htons : TargetLibCall_R<htons>;
+
+ /// double hypot(double x, double y);
+-def TLI_hypot : TargetLibCall_D<"hypot", Dbl, [Dbl, Dbl]>;
++def TLI_hypot : TargetLibCall_R<hypot>;
+
+ /// float hypotf(float x, float y);
+-def TLI_hypotf : TargetLibCall_D<"hypotf", Flt, [Flt, Flt]>;
++def TLI_hypotf : TargetLibCall_R<hypotf>;
+
+ /// long double hypotl(long double x, long double y);
+-def TLI_hypotl : TargetLibCall_D<"hypotl", LDbl, [LDbl, LDbl]>;
++def TLI_hypotl : TargetLibCall_R<hypotl>;
+
+ /// int iprintf(const char *format, ...);
+ def TLI_iprintf : TargetLibCall_R<iprintf>;
+@@ -1070,13 +1068,13 @@ def TLI_log10f : TargetLibCall_R<log10f>;
+ def TLI_log10l : TargetLibCall_R<log10l_f128>;
+
+ /// double log1p(double x);
+-def TLI_log1p : TargetLibCall_D<"log1p", Dbl, [Dbl]>;
++def TLI_log1p : TargetLibCall_R<log1p>;
+
+ /// float log1pf(float x);
+-def TLI_log1pf : TargetLibCall_D<"log1pf", Flt, [Flt]>;
++def TLI_log1pf : TargetLibCall_R<log1pf>;
+
+ /// long double log1pl(long double x);
+-def TLI_log1pl : TargetLibCall_D<"log1pl", LDbl, [LDbl]>;
++def TLI_log1pl : TargetLibCall_R<log1pl>;
+
+ /// double log2(double x);
+ def TLI_log2 : TargetLibCall_R<log2>;
+@@ -1088,22 +1086,22 @@ def TLI_log2f : TargetLibCall_R<log2f>;
+ def TLI_log2l : TargetLibCall_R<log2l_f128>;
+
+ /// int ilogb(double x);
+-def TLI_ilogb : TargetLibCall_D<"ilogb", Int, [Dbl]>;
++def TLI_ilogb : TargetLibCall_R<ilogb>;
+
+ /// int ilogbf(float x);
+-def TLI_ilogbf : TargetLibCall_D<"ilogbf", Int, [Flt]>;
++def TLI_ilogbf : TargetLibCall_R<ilogbf>;
+
+ /// int ilogbl(long double x);
+-def TLI_ilogbl : TargetLibCall_D<"ilogbl", Int, [LDbl]>;
++def TLI_ilogbl : TargetLibCall_R<ilogbl>;
+
+ /// double logb(double x);
+-def TLI_logb : TargetLibCall_D<"logb", Dbl, [Dbl]>;
++def TLI_logb : TargetLibCall_R<logb>;
+
+ /// float logbf(float x);
+-def TLI_logbf : TargetLibCall_D<"logbf", Flt, [Flt]>;
++def TLI_logbf : TargetLibCall_R<logbf>;
+
+ /// long double logbl(long double x);
+-def TLI_logbl : TargetLibCall_D<"logbl", LDbl, [LDbl]>;
++def TLI_logbl : TargetLibCall_R<logbl>;
+
+ /// float logf(float x);
+ def TLI_logf : TargetLibCall_R<logf>;
+@@ -1190,13 +1188,13 @@ def TLI_nearbyintf : TargetLibCall_R<nearbyintf>;
+ def TLI_nearbyintl : TargetLibCall_R<nearbyintl_f128>;
+
+ /// double nextafter(double x, double y);
+-def TLI_nextafter : TargetLibCall_D< "nextafter", Dbl, [Dbl, Dbl]>;
++def TLI_nextafter : TargetLibCall_R<nextafter>;
+
+ /// float nextafterf(float x, float y);
+-def TLI_nextafterf : TargetLibCall_D< "nextafterf", Flt, [Flt, Flt]>;
++def TLI_nextafterf : TargetLibCall_R<nextafterf>;
+
+ /// long double nextafterl(long double x, long double y);
+-def TLI_nextafterl : TargetLibCall_D< "nextafterl", LDbl, [LDbl, LDbl]>;
++def TLI_nextafterl : TargetLibCall_R<nextafterl>;
+
+ /// double nexttoward(double x, long double y);
+ def TLI_nexttoward : TargetLibCall_R<nexttoward>;
>From 20e434b5ababcf5c4901671186fd13e197a9aaa4 Mon Sep 17 00:00:00 2001
From: Jian Su <jian.su at ibm.com>
Date: Tue, 2 Jun 2026 19:50:42 +0000
Subject: [PATCH 8/8] Remove TargetLibCall_D.
---
.../llvm/Analysis/TargetLibraryInfo.td | 1056 ++++++++---------
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 15 +-
llvm/test/TableGen/TargetLibraryInfo.td | 21 +-
.../Basic/TargetLibraryInfoEmitter.cpp | 6 +-
sj_tmp | 370 ------
5 files changed, 547 insertions(+), 921 deletions(-)
delete mode 100644 sj_tmp
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
index 598d0f727875f..764dffe288d87 100644
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.td
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
@@ -9,143 +9,143 @@
include "llvm/IR/RuntimeLibcalls.td"
/// void *operator new(unsigned int);
-def TLI_msvc_new_int : TargetLibCall_R<__2_YAPAXI_Z>;
+def TLI_msvc_new_int : TargetLibCall<__2_YAPAXI_Z>;
/// void *operator new(unsigned int, const std::nothrow_t&);
-def TLI_msvc_new_int_nothrow : TargetLibCall_R<__2_YAPAXIABUnothrow_t_std___Z>;
+def TLI_msvc_new_int_nothrow : TargetLibCall<__2_YAPAXIABUnothrow_t_std___Z>;
/// void *operator new(unsigned long long);
-def TLI_msvc_new_longlong : TargetLibCall_R<__2_YAPEAX_K_Z>;
+def TLI_msvc_new_longlong : TargetLibCall<__2_YAPEAX_K_Z>;
/// void *operator new(unsigned long long, const std::nothrow_t&);
def TLI_msvc_new_longlong_nothrow
- : TargetLibCall_R<__2_YAPEAX_KAEBUnothrow_t_std___Z>;
+ : TargetLibCall<__2_YAPEAX_KAEBUnothrow_t_std___Z>;
/// void operator delete(void*);
-def TLI_msvc_delete_ptr32 : TargetLibCall_R<__3_YAXPAX_Z>;
+def TLI_msvc_delete_ptr32 : TargetLibCall<__3_YAXPAX_Z>;
/// void operator delete(void*, const std::nothrow_t&);
def TLI_msvc_delete_ptr32_nothrow
- : TargetLibCall_R<__3_YAXPAXABUnothrow_t_std___Z>;
+ : TargetLibCall<__3_YAXPAXABUnothrow_t_std___Z>;
/// void operator delete(void*, unsigned int);
-def TLI_msvc_delete_ptr32_int : TargetLibCall_R<__3_YAXPAXI_Z>;
+def TLI_msvc_delete_ptr32_int : TargetLibCall<__3_YAXPAXI_Z>;
/// void operator delete(void*);
-def TLI_msvc_delete_ptr64 : TargetLibCall_R<__3_YAXPEAX_Z>;
+def TLI_msvc_delete_ptr64 : TargetLibCall<__3_YAXPEAX_Z>;
/// void operator delete(void*, const std::nothrow_t&);
def TLI_msvc_delete_ptr64_nothrow
- : TargetLibCall_R<__3_YAXPEAXAEBUnothrow_t_std___Z>;
+ : TargetLibCall<__3_YAXPEAXAEBUnothrow_t_std___Z>;
/// void operator delete(void*, unsigned long long);
-def TLI_msvc_delete_ptr64_longlong : TargetLibCall_R<__3_YAXPEAX_K_Z>;
+def TLI_msvc_delete_ptr64_longlong : TargetLibCall<__3_YAXPEAX_K_Z>;
/// void *operator new[](unsigned int);
-def TLI_msvc_new_array_int : TargetLibCall_R<___U_YAPAXI_Z>;
+def TLI_msvc_new_array_int : TargetLibCall<___U_YAPAXI_Z>;
/// void *operator new](unsigned int, [const std::nothrow_t&);
def TLI_msvc_new_array_int_nothrow
- : TargetLibCall_R<___U_YAPAXIABUnothrow_t_std___Z>;
+ : TargetLibCall<___U_YAPAXIABUnothrow_t_std___Z>;
/// void *operator new[](unsigned long long);
-def TLI_msvc_new_array_longlong : TargetLibCall_R<___U_YAPEAX_K_Z>;
+def TLI_msvc_new_array_longlong : TargetLibCall<___U_YAPEAX_K_Z>;
/// void *operator new](unsigned long long, [const std::nothrow_t&);
def TLI_msvc_new_array_longlong_nothrow
- : TargetLibCall_R<___U_YAPEAX_KAEBUnothrow_t_std___Z>;
+ : TargetLibCall<___U_YAPEAX_KAEBUnothrow_t_std___Z>;
/// void operator delete[](void*);
-def TLI_msvc_delete_array_ptr32 : TargetLibCall_R<___V_YAXPAX_Z>;
+def TLI_msvc_delete_array_ptr32 : TargetLibCall<___V_YAXPAX_Z>;
/// void operator delete](void*, [const std::nothrow_t&);
def TLI_msvc_delete_array_ptr32_nothrow
- : TargetLibCall_R<___V_YAXPAXABUnothrow_t_std___Z>;
+ : TargetLibCall<___V_YAXPAXABUnothrow_t_std___Z>;
/// void operator delete](void*, [unsigned int);
-def TLI_msvc_delete_array_ptr32_int : TargetLibCall_R<___V_YAXPAXI_Z>;
+def TLI_msvc_delete_array_ptr32_int : TargetLibCall<___V_YAXPAXI_Z>;
/// void operator delete[](void*);
-def TLI_msvc_delete_array_ptr64 : TargetLibCall_R<___V_YAXPEAX_Z>;
+def TLI_msvc_delete_array_ptr64 : TargetLibCall<___V_YAXPEAX_Z>;
/// void operator delete](void*, [const std::nothrow_t&);
def TLI_msvc_delete_array_ptr64_nothrow
- : TargetLibCall_R<___V_YAXPEAXAEBUnothrow_t_std___Z>;
+ : TargetLibCall<___V_YAXPEAXAEBUnothrow_t_std___Z>;
/// void operator delete](void*, [unsigned long long);
-def TLI_msvc_delete_array_ptr64_longlong : TargetLibCall_R<___V_YAXPEAX_K_Z>;
+def TLI_msvc_delete_array_ptr64_longlong : TargetLibCall<___V_YAXPEAX_K_Z>;
/// int _IO_getc(_IO_FILE * __fp);
-def TLI_under_IO_getc : TargetLibCall_R<_IO_getc>;
+def TLI_under_IO_getc : TargetLibCall<_IO_getc>;
/// int _IO_putc(int __c, _IO_FILE * __fp);
-def TLI_under_IO_putc : TargetLibCall_R<_IO_putc>;
+def TLI_under_IO_putc : TargetLibCall<_IO_putc>;
/// void operator delete[](void*);
-def TLI_ZdaPv : TargetLibCall_R<_ZdaPv>;
+def TLI_ZdaPv : TargetLibCall<_ZdaPv>;
/// void operator delete](void*, [const std::nothrow_t&);
-def TLI_ZdaPvRKSt9nothrow_t : TargetLibCall_R<_ZdaPvRKSt9nothrow_t>;
+def TLI_ZdaPvRKSt9nothrow_t : TargetLibCall<_ZdaPvRKSt9nothrow_t>;
/// void operator delete](void*, [std::align_val_t);
-def TLI_ZdaPvSt11align_val_t : TargetLibCall_R<_ZdaPvSt11align_val_t>;
+def TLI_ZdaPvSt11align_val_t : TargetLibCall<_ZdaPvSt11align_val_t>;
/// void operator delete](void*, [std::align_val_t, const std::nothrow_t&)
def TLI_ZdaPvSt11align_val_tRKSt9nothrow_t
- : TargetLibCall_R<_ZdaPvSt11align_val_tRKSt9nothrow_t>;
+ : TargetLibCall<_ZdaPvSt11align_val_tRKSt9nothrow_t>;
/// void operator delete](void*, [unsigned int);
-def TLI_ZdaPvj : TargetLibCall_R<_ZdaPvj>;
+def TLI_ZdaPvj : TargetLibCall<_ZdaPvj>;
/// void operator delete](void*, [unsigned int, std::align_val_t);
-def TLI_ZdaPvjSt11align_val_t : TargetLibCall_R<_ZdaPvjSt11align_val_t>;
+def TLI_ZdaPvjSt11align_val_t : TargetLibCall<_ZdaPvjSt11align_val_t>;
/// void operator delete](void*, [unsigned long);
-def TLI_ZdaPvm : TargetLibCall_R<_ZdaPvm>;
+def TLI_ZdaPvm : TargetLibCall<_ZdaPvm>;
/// void operator delete](void*, [unsigned long, std::align_val_t);
-def TLI_ZdaPvmSt11align_val_t : TargetLibCall_R<_ZdaPvmSt11align_val_t>;
+def TLI_ZdaPvmSt11align_val_t : TargetLibCall<_ZdaPvmSt11align_val_t>;
/// void operator delete(void*);
-def TLI_ZdlPv : TargetLibCall_R<_ZdlPv>;
+def TLI_ZdlPv : TargetLibCall<_ZdlPv>;
/// void operator delete(void*, const std::nothrow_t&);
-def TLI_ZdlPvRKSt9nothrow_t : TargetLibCall_R<_ZdlPvRKSt9nothrow_t>;
+def TLI_ZdlPvRKSt9nothrow_t : TargetLibCall<_ZdlPvRKSt9nothrow_t>;
/// void operator delete(void*, std::align_val_t)
-def TLI_ZdlPvSt11align_val_t : TargetLibCall_R<_ZdlPvSt11align_val_t>;
+def TLI_ZdlPvSt11align_val_t : TargetLibCall<_ZdlPvSt11align_val_t>;
/// void operator delete(void*, std::align_val_t, const std::nothrow_t&)
def TLI_ZdlPvSt11align_val_tRKSt9nothrow_t
- : TargetLibCall_R<_ZdlPvSt11align_val_tRKSt9nothrow_t>;
+ : TargetLibCall<_ZdlPvSt11align_val_tRKSt9nothrow_t>;
/// void operator delete(void*, unsigned int);
-def TLI_ZdlPvj : TargetLibCall_R<_ZdlPvj>;
+def TLI_ZdlPvj : TargetLibCall<_ZdlPvj>;
/// void operator delete(void*, unsigned int, std::align_val_t)
-def TLI_ZdlPvjSt11align_val_t : TargetLibCall_R<_ZdlPvjSt11align_val_t>;
+def TLI_ZdlPvjSt11align_val_t : TargetLibCall<_ZdlPvjSt11align_val_t>;
/// void operator delete(void*, unsigned long);
-def TLI_ZdlPvm : TargetLibCall_R<_ZdlPvm>;
+def TLI_ZdlPvm : TargetLibCall<_ZdlPvm>;
/// void operator delete(void*, unsigned long, std::align_val_t)
-def TLI_ZdlPvmSt11align_val_t : TargetLibCall_R<_ZdlPvmSt11align_val_t>;
+def TLI_ZdlPvmSt11align_val_t : TargetLibCall<_ZdlPvmSt11align_val_t>;
/// void *operator new[](unsigned int);
-def TLI_Znaj : TargetLibCall_R<_Znaj>;
+def TLI_Znaj : TargetLibCall<_Znaj>;
/// void *operator new](unsigned int, [const std::nothrow_t&);
-def TLI_ZnajRKSt9nothrow_t : TargetLibCall_R<_ZnajRKSt9nothrow_t>;
+def TLI_ZnajRKSt9nothrow_t : TargetLibCall<_ZnajRKSt9nothrow_t>;
/// void *operator new](unsigned int, [std::align_val_t)
-def TLI_ZnajSt11align_val_t : TargetLibCall_R<_ZnajSt11align_val_t>;
+def TLI_ZnajSt11align_val_t : TargetLibCall<_ZnajSt11align_val_t>;
/// void *operator new](unsigned int, [std::align_val_t, const std::nothrow_t&)
def TLI_ZnajSt11align_val_tRKSt9nothrow_t
- : TargetLibCall_R<_ZnajSt11align_val_tRKSt9nothrow_t>;
+ : TargetLibCall<_ZnajSt11align_val_tRKSt9nothrow_t>;
/// void *operator new[](unsigned long);
-def TLI_Znam : TargetLibCall_R<_Znam>;
+def TLI_Znam : TargetLibCall<_Znam>;
/// void *operator new](unsigned long, [__hot_cold_t)
/// Currently this and other operator new interfaces that take a __hot_cold_t
@@ -153,72 +153,72 @@ def TLI_Znam : TargetLibCall_R<_Znam>;
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
/// and for the definition of the __hot_cold_t parameter see:
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
-def TLI_Znam12__hot_cold_t : TargetLibCall_R<_Znam12__hot_cold_t>;
+def TLI_Znam12__hot_cold_t : TargetLibCall<_Znam12__hot_cold_t>;
/// void *operator new](unsigned long, [const std::nothrow_t&);
-def TLI_ZnamRKSt9nothrow_t : TargetLibCall_R<_ZnamRKSt9nothrow_t>;
+def TLI_ZnamRKSt9nothrow_t : TargetLibCall<_ZnamRKSt9nothrow_t>;
/// void *operator new](unsigned long, [const std::nothrow_t&, __hot_cold_t)
def TLI_ZnamRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall_R<_ZnamRKSt9nothrow_t12__hot_cold_t>;
+ : TargetLibCall<_ZnamRKSt9nothrow_t12__hot_cold_t>;
/// void *operator new](unsigned long, [std::align_val_t)
-def TLI_ZnamSt11align_val_t : TargetLibCall_R<_ZnamSt11align_val_t>;
+def TLI_ZnamSt11align_val_t : TargetLibCall<_ZnamSt11align_val_t>;
/// void *operator new](unsigned long, [std::align_val_t, __hot_cold_t)
def TLI_ZnamSt11align_val_t12__hot_cold_t
- : TargetLibCall_R<_ZnamSt11align_val_t12__hot_cold_t>;
+ : TargetLibCall<_ZnamSt11align_val_t12__hot_cold_t>;
/// void *operator new](unsigned long, [std::align_val_t, const std::nothrow_t&)
def TLI_ZnamSt11align_val_tRKSt9nothrow_t
- : TargetLibCall_R<_ZnamSt11align_val_tRKSt9nothrow_t>;
+ : TargetLibCall<_ZnamSt11align_val_tRKSt9nothrow_t>;
/// void *operator new](unsigned long, [std::align_val_t, const std::nothrow_t&,
/// __hot_cold_t)
def TLI_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall_R<_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t>;
+ : TargetLibCall<_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t>;
/// void *operator new(unsigned int);
-def TLI_Znwj : TargetLibCall_R<_Znwj>;
+def TLI_Znwj : TargetLibCall<_Znwj>;
/// void *operator new(unsigned int, const std::nothrow_t&);
-def TLI_ZnwjRKSt9nothrow_t : TargetLibCall_R<_ZnwjRKSt9nothrow_t>;
+def TLI_ZnwjRKSt9nothrow_t : TargetLibCall<_ZnwjRKSt9nothrow_t>;
/// void *operator new(unsigned int, std::align_val_t)
-def TLI_ZnwjSt11align_val_t : TargetLibCall_R<_ZnwjSt11align_val_t>;
+def TLI_ZnwjSt11align_val_t : TargetLibCall<_ZnwjSt11align_val_t>;
/// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&)
def TLI_ZnwjSt11align_val_tRKSt9nothrow_t
- : TargetLibCall_R<_ZnwjSt11align_val_tRKSt9nothrow_t>;
+ : TargetLibCall<_ZnwjSt11align_val_tRKSt9nothrow_t>;
/// void *operator new(unsigned long);
-def TLI_Znwm : TargetLibCall_R<_Znwm>;
+def TLI_Znwm : TargetLibCall<_Znwm>;
/// void *operator new(unsigned long, __hot_cold_t)
-def TLI_Znwm12__hot_cold_t : TargetLibCall_R<_Znwm12__hot_cold_t>;
+def TLI_Znwm12__hot_cold_t : TargetLibCall<_Znwm12__hot_cold_t>;
/// void *operator new(unsigned long, const std::nothrow_t&);
-def TLI_ZnwmRKSt9nothrow_t : TargetLibCall_R<_ZnwmRKSt9nothrow_t>;
+def TLI_ZnwmRKSt9nothrow_t : TargetLibCall<_ZnwmRKSt9nothrow_t>;
/// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
def TLI_ZnwmRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall_R<_ZnwmRKSt9nothrow_t12__hot_cold_t>;
+ : TargetLibCall<_ZnwmRKSt9nothrow_t12__hot_cold_t>;
/// void *operator new(unsigned long, std::align_val_t)
-def TLI_ZnwmSt11align_val_t : TargetLibCall_R<_ZnwmSt11align_val_t>;
+def TLI_ZnwmSt11align_val_t : TargetLibCall<_ZnwmSt11align_val_t>;
/// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
def TLI_ZnwmSt11align_val_t12__hot_cold_t
- : TargetLibCall_R<_ZnwmSt11align_val_t12__hot_cold_t>;
+ : TargetLibCall<_ZnwmSt11align_val_t12__hot_cold_t>;
/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
def TLI_ZnwmSt11align_val_tRKSt9nothrow_t
- : TargetLibCall_R<_ZnwmSt11align_val_tRKSt9nothrow_t>;
+ : TargetLibCall<_ZnwmSt11align_val_tRKSt9nothrow_t>;
/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&,
/// __hot_cold_t)
def TLI_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t
- : TargetLibCall_R<_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t>;
+ : TargetLibCall<_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t>;
/// The following are variants of operator new which return the actual size
/// reserved by the allocator proposed in P0901R5 (Size feedback in operator
@@ -227,1423 +227,1423 @@ def TLI_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
/// __sized_ptr_t __size_returning_new(size_t size)
-def TLI_size_returning_new : TargetLibCall_R<__size_returning_new>;
+def TLI_size_returning_new : TargetLibCall<__size_returning_new>;
/// __sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t)
def TLI_size_returning_new_hot_cold
- : TargetLibCall_R<__size_returning_new_hot_cold>;
+ : TargetLibCall<__size_returning_new_hot_cold>;
/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t)
def TLI_size_returning_new_aligned
- : TargetLibCall_R<__size_returning_new_aligned>;
+ : TargetLibCall<__size_returning_new_aligned>;
/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t,
/// __hot_cold_t)
def TLI_size_returning_new_aligned_hot_cold
- : TargetLibCall_R<__size_returning_new_aligned_hot_cold>;
+ : TargetLibCall<__size_returning_new_aligned_hot_cold>;
/// double __acos_finite(double x);
-def TLI_acos_finite : TargetLibCall_R<__acos_finite>;
+def TLI_acos_finite : TargetLibCall<__acos_finite>;
/// float __acosf_finite(float x);
-def TLI_acosf_finite : TargetLibCall_R<__acosf_finite>;
+def TLI_acosf_finite : TargetLibCall<__acosf_finite>;
/// double __acosh_finite(double x);
-def TLI_acosh_finite : TargetLibCall_R<__acosh_finite>;
+def TLI_acosh_finite : TargetLibCall<__acosh_finite>;
/// float __acoshf_finite(float x);
-def TLI_acoshf_finite : TargetLibCall_R<__acoshf_finite>;
+def TLI_acoshf_finite : TargetLibCall<__acoshf_finite>;
/// long double __acoshl_finite(long double x);
-def TLI_acoshl_finite : TargetLibCall_R<__acoshl_finite>;
+def TLI_acoshl_finite : TargetLibCall<__acoshl_finite>;
/// long double __acosl_finite(long double x);
-def TLI_acosl_finite : TargetLibCall_R<__acosl_finite>;
+def TLI_acosl_finite : TargetLibCall<__acosl_finite>;
/// double __asin_finite(double x);
-def TLI_asin_finite : TargetLibCall_R<__asin_finite>;
+def TLI_asin_finite : TargetLibCall<__asin_finite>;
/// float __asinf_finite(float x);
-def TLI_asinf_finite : TargetLibCall_R<__asinf_finite>;
+def TLI_asinf_finite : TargetLibCall<__asinf_finite>;
/// long double __asinl_finite(long double x);
-def TLI_asinl_finite : TargetLibCall_R<__asinl_finite>;
+def TLI_asinl_finite : TargetLibCall<__asinl_finite>;
/// double atan2_finite(double y, double x);
-def TLI_atan2_finite : TargetLibCall_R<__atan2_finite>;
+def TLI_atan2_finite : TargetLibCall<__atan2_finite>;
/// float atan2f_finite(float y, float x);
-def TLI_atan2f_finite : TargetLibCall_R<__atan2f_finite>;
+def TLI_atan2f_finite : TargetLibCall<__atan2f_finite>;
/// long double atan2l_finite(long double y, long double x);
-def TLI_atan2l_finite : TargetLibCall_R<__atan2l_finite>;
+def TLI_atan2l_finite : TargetLibCall<__atan2l_finite>;
/// double __atanh_finite(double x);
-def TLI_atanh_finite : TargetLibCall_R<__atanh_finite>;
+def TLI_atanh_finite : TargetLibCall<__atanh_finite>;
/// float __atanhf_finite(float x);
-def TLI_atanhf_finite : TargetLibCall_R<__atanhf_finite>;
+def TLI_atanhf_finite : TargetLibCall<__atanhf_finite>;
/// long double __atanhl_finite(long double x);
-def TLI_atanhl_finite : TargetLibCall_R<__atanhl_finite>;
+def TLI_atanhl_finite : TargetLibCall<__atanhl_finite>;
/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
-def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
+def TLI_atomic_load : TargetLibCall<__atomic_load>;
/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
-def TLI_atomic_store : TargetLibCall_R<__atomic_store>;
+def TLI_atomic_store : TargetLibCall<__atomic_store>;
/// double __cosh_finite(double x);
-def TLI_cosh_finite : TargetLibCall_R<__cosh_finite>;
+def TLI_cosh_finite : TargetLibCall<__cosh_finite>;
/// float __coshf_finite(float x);
-def TLI_coshf_finite : TargetLibCall_R<__coshf_finite>;
+def TLI_coshf_finite : TargetLibCall<__coshf_finite>;
/// long double __coshl_finite(long double x);
-def TLI_coshl_finite : TargetLibCall_R<__coshl_finite>;
+def TLI_coshl_finite : TargetLibCall<__coshl_finite>;
/// double __cospi(double x);
-def TLI_cospi : TargetLibCall_R<__cospi>;
+def TLI_cospi : TargetLibCall<__cospi>;
/// float __cospif(float x);
-def TLI_cospif : TargetLibCall_R<__cospif>;
+def TLI_cospif : TargetLibCall<__cospif>;
/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
-def TLI_cxa_atexit : TargetLibCall_R<__cxa_atexit>;
+def TLI_cxa_atexit : TargetLibCall<__cxa_atexit>;
/// int atexit(void (*f)(void));
-def TLI_atexit : TargetLibCall_R<atexit>;
+def TLI_atexit : TargetLibCall<atexit>;
/// void abort(void)
-def TLI_abort : TargetLibCall_R<abort>;
+def TLI_abort : TargetLibCall<abort>;
/// void exit(int)
-def TLI_exit : TargetLibCall_R<exit>;
+def TLI_exit : TargetLibCall<exit>;
/// void _Exit(int)
-def TLI_Exit : TargetLibCall_R<_Exit>;
+def TLI_Exit : TargetLibCall<_Exit>;
/// void std::terminate();
-def TLI_terminate : TargetLibCall_R<_ZSt9terminatev>;
+def TLI_terminate : TargetLibCall<_ZSt9terminatev>;
/// void __cxa_throw(void *, void *, void (*)(void *));
-def TLI_cxa_throw : TargetLibCall_R<__cxa_throw>;
+def TLI_cxa_throw : TargetLibCall<__cxa_throw>;
/// void __cxa_guard_abort(guard_t *guard);
/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
-def TLI_cxa_guard_abort : TargetLibCall_R<__cxa_guard_abort>;
+def TLI_cxa_guard_abort : TargetLibCall<__cxa_guard_abort>;
/// int __cxa_guard_acquire(guard_t *guard);
-def TLI_cxa_guard_acquire : TargetLibCall_R<__cxa_guard_acquire>;
+def TLI_cxa_guard_acquire : TargetLibCall<__cxa_guard_acquire>;
/// void __cxa_guard_release(guard_t *guard);
-def TLI_cxa_guard_release : TargetLibCall_R<__cxa_guard_release>;
+def TLI_cxa_guard_release : TargetLibCall<__cxa_guard_release>;
/// double __exp10_finite(double x);
-def TLI_exp10_finite : TargetLibCall_R<__exp10_finite>;
+def TLI_exp10_finite : TargetLibCall<__exp10_finite>;
/// float __exp10f_finite(float x);
-def TLI_exp10f_finite : TargetLibCall_R<__exp10f_finite>;
+def TLI_exp10f_finite : TargetLibCall<__exp10f_finite>;
/// long double __exp10l_finite(long double x);
-def TLI_exp10l_finite : TargetLibCall_R<__exp10l_finite>;
+def TLI_exp10l_finite : TargetLibCall<__exp10l_finite>;
/// double __exp2_finite(double x);
-def TLI_exp2_finite : TargetLibCall_R<__exp2_finite>;
+def TLI_exp2_finite : TargetLibCall<__exp2_finite>;
/// float __exp2f_finite(float x);
-def TLI_exp2f_finite : TargetLibCall_R<__exp2f_finite>;
+def TLI_exp2f_finite : TargetLibCall<__exp2f_finite>;
/// long double __exp2l_finite(long double x);
-def TLI_exp2l_finite : TargetLibCall_R<__exp2l_finite_f128>;
+def TLI_exp2l_finite : TargetLibCall<__exp2l_finite_f128>;
/// double __exp_finite(double x);
-def TLI_exp_finite : TargetLibCall_R<__exp_finite>;
+def TLI_exp_finite : TargetLibCall<__exp_finite>;
/// float __expf_finite(float x);
-def TLI_expf_finite : TargetLibCall_R<__expf_finite>;
+def TLI_expf_finite : TargetLibCall<__expf_finite>;
/// long double __expl_finite(long double x);
-def TLI_expl_finite : TargetLibCall_R<__expl_finite_f128>;
+def TLI_expl_finite : TargetLibCall<__expl_finite_f128>;
/// int __isoc99_scanf (const char *format, ...)
-def TLI_dunder_isoc99_scanf : TargetLibCall_R<__isoc99_scanf>;
+def TLI_dunder_isoc99_scanf : TargetLibCall<__isoc99_scanf>;
/// int __isoc99_sscanf(const char *s, const char *format, ...)
-def TLI_dunder_isoc99_sscanf : TargetLibCall_R<__isoc99_sscanf>;
+def TLI_dunder_isoc99_sscanf : TargetLibCall<__isoc99_sscanf>;
/// double __log10_finite(double x);
-def TLI_log10_finite : TargetLibCall_R<__log10_finite>;
+def TLI_log10_finite : TargetLibCall<__log10_finite>;
/// float __log10f_finite(float x);
-def TLI_log10f_finite : TargetLibCall_R<__log10f_finite>;
+def TLI_log10f_finite : TargetLibCall<__log10f_finite>;
/// long double __log10l_finite(long double x);
-def TLI_log10l_finite : TargetLibCall_R<__log10l_finite_f128>;
+def TLI_log10l_finite : TargetLibCall<__log10l_finite_f128>;
/// double __log2_finite(double x);
-def TLI_log2_finite : TargetLibCall_R<__log2_finite>;
+def TLI_log2_finite : TargetLibCall<__log2_finite>;
/// float __log2f_finite(float x);
-def TLI_log2f_finite : TargetLibCall_R<__log2f_finite>;
+def TLI_log2f_finite : TargetLibCall<__log2f_finite>;
/// long double __log2l_finite(long double x);
-def TLI_log2l_finite : TargetLibCall_R<__log2l_finite_f128>;
+def TLI_log2l_finite : TargetLibCall<__log2l_finite_f128>;
/// double __log_finite(double x);
-def TLI_log_finite : TargetLibCall_R<__log_finite>;
+def TLI_log_finite : TargetLibCall<__log_finite>;
/// float __logf_finite(float x);
-def TLI_logf_finite : TargetLibCall_R<__logf_finite>;
+def TLI_logf_finite : TargetLibCall<__logf_finite>;
/// long double __logl_finite(long double x);
-def TLI_logl_finite : TargetLibCall_R<__logl_finite_f128>;
+def TLI_logl_finite : TargetLibCall<__logl_finite_f128>;
/// void *__memccpy_chk(void *dst, const void *src, int c, size_t n,
/// size_t dstsize)
-def TLI_memccpy_chk : TargetLibCall_R<__memccpy_chk>;
+def TLI_memccpy_chk : TargetLibCall<__memccpy_chk>;
/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-def TLI_memcpy_chk : TargetLibCall_R<__memcpy_chk>;
+def TLI_memcpy_chk : TargetLibCall<__memcpy_chk>;
/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
-def TLI_memmove_chk : TargetLibCall_R<__memmove_chk>;
+def TLI_memmove_chk : TargetLibCall<__memmove_chk>;
/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-def TLI_mempcpy_chk : TargetLibCall_R<__mempcpy_chk>;
+def TLI_mempcpy_chk : TargetLibCall<__mempcpy_chk>;
/// void *__memset_chk(void *s, int v, size_t n, size_t s1size);
-def TLI_memset_chk : TargetLibCall_R<__memset_chk>;
+def TLI_memset_chk : TargetLibCall<__memset_chk>;
// int __nvvm_reflect(const char *)
-def TLI_nvvm_reflect : TargetLibCall_R<__nvvm_reflect>;
+def TLI_nvvm_reflect : TargetLibCall<__nvvm_reflect>;
/// double __pow_finite(double x, double y);
-def TLI_pow_finite : TargetLibCall_R<__pow_finite>;
+def TLI_pow_finite : TargetLibCall<__pow_finite>;
/// float _powf_finite(float x, float y);
-def TLI_powf_finite : TargetLibCall_R<__powf_finite>;
+def TLI_powf_finite : TargetLibCall<__powf_finite>;
/// long double __powl_finite(long double x, long double y);
-def TLI_powl_finite : TargetLibCall_R<__powl_finite_f128>;
+def TLI_powl_finite : TargetLibCall<__powl_finite_f128>;
/// double __sincospi_stret(double x);
-def TLI_sincospi_stret : TargetLibCall_R<__sincospi_stret>;
+def TLI_sincospi_stret : TargetLibCall<__sincospi_stret>;
/// float __sincospif_stret(float x);
-def TLI_sincospif_stret : TargetLibCall_R<__sincospif_stret>;
+def TLI_sincospif_stret : TargetLibCall<__sincospif_stret>;
/// double __sinh_finite(double x);
-def TLI_sinh_finite : TargetLibCall_R<__sinh_finite>;
+def TLI_sinh_finite : TargetLibCall<__sinh_finite>;
/// float _sinhf_finite(float x);
-def TLI_sinhf_finite : TargetLibCall_R<__sinhf_finite>;
+def TLI_sinhf_finite : TargetLibCall<__sinhf_finite>;
/// long double __sinhl_finite(long double x);
-def TLI_sinhl_finite : TargetLibCall_R<__sinhl_finite>;
+def TLI_sinhl_finite : TargetLibCall<__sinhl_finite>;
/// double __sinpi(double x);
-def TLI_sinpi : TargetLibCall_R<__sinpi>;
+def TLI_sinpi : TargetLibCall<__sinpi>;
/// float __sinpif(float x);
-def TLI_sinpif : TargetLibCall_R<__sinpif>;
+def TLI_sinpif : TargetLibCall<__sinpif>;
/// int __small_fprintf(FILE *stream, const char *format, ...);
-def TLI_small_fprintf : TargetLibCall_R<__small_fprintf>;
+def TLI_small_fprintf : TargetLibCall<__small_fprintf>;
/// int __small_printf(const char *format, ...);
-def TLI_small_printf : TargetLibCall_R<__small_printf>;
+def TLI_small_printf : TargetLibCall<__small_printf>;
/// int __small_sprintf(char *str, const char *format, ...);
-def TLI_small_sprintf : TargetLibCall_R<__small_sprintf>;
+def TLI_small_sprintf : TargetLibCall<__small_sprintf>;
/// int __snprintf_chk(char *s, size_t n, int flags, size_t slen,
/// const char *format, ...);
-def TLI_snprintf_chk : TargetLibCall_R<__snprintf_chk>;
+def TLI_snprintf_chk : TargetLibCall<__snprintf_chk>;
/// int __sprintf_chk(char *str, int flags, size_t str_len,
/// const char *format, ...);
-def TLI_sprintf_chk : TargetLibCall_R<__sprintf_chk>;
+def TLI_sprintf_chk : TargetLibCall<__sprintf_chk>;
/// double __sqrt_finite(double x);
-def TLI_sqrt_finite : TargetLibCall_R<__sqrt_finite>;
+def TLI_sqrt_finite : TargetLibCall<__sqrt_finite>;
/// float __sqrt_finite(float x);
-def TLI_sqrtf_finite : TargetLibCall_R<__sqrtf_finite>;
+def TLI_sqrtf_finite : TargetLibCall<__sqrtf_finite>;
/// long double __sqrt_finite(long double x);
-def TLI_sqrtl_finite : TargetLibCall_R<__sqrtl_finite>;
+def TLI_sqrtl_finite : TargetLibCall<__sqrtl_finite>;
/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
-def TLI_stpcpy_chk : TargetLibCall_R<__stpcpy_chk>;
+def TLI_stpcpy_chk : TargetLibCall<__stpcpy_chk>;
/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
-def TLI_stpncpy_chk : TargetLibCall_R<__stpncpy_chk>;
+def TLI_stpncpy_chk : TargetLibCall<__stpncpy_chk>;
/// char *__strcat_chk(char *s1, const char *s2, size_t s1size);
-def TLI_strcat_chk : TargetLibCall_R<__strcat_chk>;
+def TLI_strcat_chk : TargetLibCall<__strcat_chk>;
/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
-def TLI_strcpy_chk : TargetLibCall_R<__strcpy_chk>;
+def TLI_strcpy_chk : TargetLibCall<__strcpy_chk>;
/// char * __strdup(const char *s);
-def TLI_dunder_strdup : TargetLibCall_R<__strdup>;
+def TLI_dunder_strdup : TargetLibCall<__strdup>;
/// size_t __strlcat_chk(char *dst, const char *src, size_t size,
/// size_t dstsize);
-def TLI_strlcat_chk : TargetLibCall_R<__strlcat_chk>;
+def TLI_strlcat_chk : TargetLibCall<__strlcat_chk>;
/// size_t __strlcpy_chk(char *dst, const char *src, size_t size,
/// size_t dstsize);
-def TLI_strlcpy_chk : TargetLibCall_R<__strlcpy_chk>;
+def TLI_strlcpy_chk : TargetLibCall<__strlcpy_chk>;
/// size_t __strlen_chk(const char *s1, size_t s1size);
-def TLI_strlen_chk : TargetLibCall_R<__strlen_chk>;
+def TLI_strlen_chk : TargetLibCall<__strlen_chk>;
/// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
-def TLI_strncat_chk : TargetLibCall_R<__strncat_chk>;
+def TLI_strncat_chk : TargetLibCall<__strncat_chk>;
/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
-def TLI_strncpy_chk : TargetLibCall_R<__strncpy_chk>;
+def TLI_strncpy_chk : TargetLibCall<__strncpy_chk>;
/// char *__strndup(const char *s, size_t n);
-def TLI_dunder_strndup : TargetLibCall_R<__strndup>;
+def TLI_dunder_strndup : TargetLibCall<__strndup>;
/// char * __strtok_r(char *s, const char *delim, char **save_ptr);
-def TLI_dunder_strtok_r : TargetLibCall_R<__strtok_r>;
+def TLI_dunder_strtok_r : TargetLibCall<__strtok_r>;
/// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen,
/// const char *format, va_list ap);
-def TLI_vsnprintf_chk : TargetLibCall_R<__vsnprintf_chk>;
+def TLI_vsnprintf_chk : TargetLibCall<__vsnprintf_chk>;
/// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format,
/// va_list ap);
-def TLI_vsprintf_chk : TargetLibCall_R<__vsprintf_chk>;
+def TLI_vsprintf_chk : TargetLibCall<__vsprintf_chk>;
/// int abs(int j);
-def TLI_abs : TargetLibCall_R<abs>;
+def TLI_abs : TargetLibCall<abs>;
/// int access(const char *path, int amode);
-def TLI_access : TargetLibCall_R<access>;
+def TLI_access : TargetLibCall<access>;
/// double acos(double x);
-def TLI_acos : TargetLibCall_R<acos>;
+def TLI_acos : TargetLibCall<acos>;
/// float acosf(float x);
-def TLI_acosf : TargetLibCall_R<acosf>;
+def TLI_acosf : TargetLibCall<acosf>;
/// double acosh(double x);
-def TLI_acosh : TargetLibCall_R<acosh>;
+def TLI_acosh : TargetLibCall<acosh>;
/// float acoshf(float x);
-def TLI_acoshf : TargetLibCall_R<acoshf>;
+def TLI_acoshf : TargetLibCall<acoshf>;
/// long double acoshl(long double x);
-def TLI_acoshl : TargetLibCall_R<acoshl>;
+def TLI_acoshl : TargetLibCall<acoshl>;
/// long double acosl(long double x);
-def TLI_acosl : TargetLibCall_R<acosl_f128>;
+def TLI_acosl : TargetLibCall<acosl_f128>;
/// void *aligned_alloc(size_t alignment, size_t size);
-def TLI_aligned_alloc : TargetLibCall_R<aligned_alloc>;
+def TLI_aligned_alloc : TargetLibCall<aligned_alloc>;
/// double asin(double x);
-def TLI_asin : TargetLibCall_R<asin>;
+def TLI_asin : TargetLibCall<asin>;
/// float asinf(float x);
-def TLI_asinf : TargetLibCall_R<asinf>;
+def TLI_asinf : TargetLibCall<asinf>;
/// double asinh(double x);
-def TLI_asinh : TargetLibCall_R<asinh>;
+def TLI_asinh : TargetLibCall<asinh>;
/// float asinhf(float x);
-def TLI_asinhf : TargetLibCall_R<asinhf>;
+def TLI_asinhf : TargetLibCall<asinhf>;
/// long double asinhl(long double x);
-def TLI_asinhl : TargetLibCall_R<asinhl>;
+def TLI_asinhl : TargetLibCall<asinhl>;
/// long double asinl(long double x);
-def TLI_asinl : TargetLibCall_R<asinl_f128>;
+def TLI_asinl : TargetLibCall<asinl_f128>;
/// double atan(double x);
-def TLI_atan : TargetLibCall_R<atan>;
+def TLI_atan : TargetLibCall<atan>;
/// double atan2(double y, double x);
-def TLI_atan2 : TargetLibCall_R<atan2>;
+def TLI_atan2 : TargetLibCall<atan2>;
/// float atan2f(float y, float x);
-def TLI_atan2f : TargetLibCall_R<atan2f>;
+def TLI_atan2f : TargetLibCall<atan2f>;
/// long double atan2l(long double y, long double x);
-def TLI_atan2l : TargetLibCall_R<atan2l_f128>;
+def TLI_atan2l : TargetLibCall<atan2l_f128>;
/// float atanf(float x);
-def TLI_atanf : TargetLibCall_R<atanf>;
+def TLI_atanf : TargetLibCall<atanf>;
/// double atanh(double x);
-def TLI_atanh : TargetLibCall_R<atanh>;
+def TLI_atanh : TargetLibCall<atanh>;
/// float atanhf(float x);
-def TLI_atanhf : TargetLibCall_R<atanhf>;
+def TLI_atanhf : TargetLibCall<atanhf>;
/// long double atanhl(long double x);
-def TLI_atanhl : TargetLibCall_R<atanhl>;
+def TLI_atanhl : TargetLibCall<atanhl>;
/// long double atanl(long double x);
-def TLI_atanl : TargetLibCall_R<atanl_f128>;
+def TLI_atanl : TargetLibCall<atanl_f128>;
/// double atof(const char *str);
-def TLI_atof : TargetLibCall_R<atof>;
+def TLI_atof : TargetLibCall<atof>;
/// int atoi(const char *str);
-def TLI_atoi : TargetLibCall_R<atoi>;
+def TLI_atoi : TargetLibCall<atoi>;
/// long atol(const char *str);
-def TLI_atol : TargetLibCall_R<atol>;
+def TLI_atol : TargetLibCall<atol>;
/// long long atoll(const char *nptr);
-def TLI_atoll : TargetLibCall_R<atoll>;
+def TLI_atoll : TargetLibCall<atoll>;
/// int bcmp(const void *s1, const void *s2, size_t n);
-def TLI_bcmp : TargetLibCall_R<bcmp>;
+def TLI_bcmp : TargetLibCall<bcmp>;
/// void bcopy(const void *s1, void *s2, size_t n);
-def TLI_bcopy : TargetLibCall_R<bcopy>;
+def TLI_bcopy : TargetLibCall<bcopy>;
/// void bzero(void *s, size_t n);
-def TLI_bzero : TargetLibCall_R<bzero>;
+def TLI_bzero : TargetLibCall<bzero>;
/// double cabs(double complex z)
-def TLI_cabs : TargetLibCall_R<cabs>;
+def TLI_cabs : TargetLibCall<cabs>;
/// float cabs(float complex z)
-def TLI_cabsf : TargetLibCall_R<cabsf>;
+def TLI_cabsf : TargetLibCall<cabsf>;
/// long double cabs(long double complex z)
-def TLI_cabsl : TargetLibCall_R<cabsl_f128>;
+def TLI_cabsl : TargetLibCall<cabsl_f128>;
/// void *calloc(size_t count, size_t size);
-def TLI_calloc : TargetLibCall_R<calloc>;
+def TLI_calloc : TargetLibCall<calloc>;
/// double cbrt(double x);
-def TLI_cbrt : TargetLibCall_R<cbrt>;
+def TLI_cbrt : TargetLibCall<cbrt>;
/// float cbrtf(float x);
-def TLI_cbrtf : TargetLibCall_R<cbrtf>;
+def TLI_cbrtf : TargetLibCall<cbrtf>;
/// long double cbrtl(long double x);
-def TLI_cbrtl : TargetLibCall_R<cbrtl_f128>;
+def TLI_cbrtl : TargetLibCall<cbrtl_f128>;
/// double ceil(double x);
-def TLI_ceil : TargetLibCall_R<ceil>;
+def TLI_ceil : TargetLibCall<ceil>;
/// float ceilf(float x);
-def TLI_ceilf : TargetLibCall_R<ceilf>;
+def TLI_ceilf : TargetLibCall<ceilf>;
/// long double ceill(long double x);
-def TLI_ceill : TargetLibCall_R<ceill_f128>;
+def TLI_ceill : TargetLibCall<ceill_f128>;
/// int chmod(const char *path, mode_t mode);
-def TLI_chmod : TargetLibCall_R<chmod>;
+def TLI_chmod : TargetLibCall<chmod>;
/// int chown(const char *path, uid_t owner, gid_t group);
-def TLI_chown : TargetLibCall_R<chown>;
+def TLI_chown : TargetLibCall<chown>;
/// void clearerr(FILE *stream);
-def TLI_clearerr : TargetLibCall_R<clearerr>;
+def TLI_clearerr : TargetLibCall<clearerr>;
/// int closedir(DIR *dirp);
-def TLI_closedir : TargetLibCall_R<closedir>;
+def TLI_closedir : TargetLibCall<closedir>;
/// double copysign(double x, double y);
-def TLI_copysign : TargetLibCall_R<copysign>;
+def TLI_copysign : TargetLibCall<copysign>;
/// float copysignf(float x, float y);
-def TLI_copysignf : TargetLibCall_R<copysignf>;
+def TLI_copysignf : TargetLibCall<copysignf>;
/// long double copysignl(long double x, long double y);
-def TLI_copysignl : TargetLibCall_R<copysignl_f128>;
+def TLI_copysignl : TargetLibCall<copysignl_f128>;
/// double cos(double x);
-def TLI_cos : TargetLibCall_R<cos>;
+def TLI_cos : TargetLibCall<cos>;
/// float cosf(float x);
-def TLI_cosf : TargetLibCall_R<cosf>;
+def TLI_cosf : TargetLibCall<cosf>;
/// double cosh(double x);
-def TLI_cosh : TargetLibCall_R<cosh>;
+def TLI_cosh : TargetLibCall<cosh>;
/// float coshf(float x);
-def TLI_coshf : TargetLibCall_R<coshf>;
+def TLI_coshf : TargetLibCall<coshf>;
/// long double coshl(long double x);
-def TLI_coshl : TargetLibCall_R<coshl_f128>;
+def TLI_coshl : TargetLibCall<coshl_f128>;
/// long double cosl(long double x);
-def TLI_cosl : TargetLibCall_R<cosl_f128>;
+def TLI_cosl : TargetLibCall<cosl_f128>;
/// char *ctermid(char *s);
-def TLI_ctermid : TargetLibCall_R<ctermid>;
+def TLI_ctermid : TargetLibCall<ctermid>;
/// double erf(double x);
-def TLI_erf : TargetLibCall_R<erf>;
+def TLI_erf : TargetLibCall<erf>;
/// float erff(float x);
-def TLI_erff : TargetLibCall_R<erff>;
+def TLI_erff : TargetLibCall<erff>;
/// long double erfl(long double x);
-def TLI_erfl : TargetLibCall_R<erfl>;
+def TLI_erfl : TargetLibCall<erfl>;
/// double tgamma(double x);
-def TLI_tgamma : TargetLibCall_R<tgamma>;
+def TLI_tgamma : TargetLibCall<tgamma>;
/// float tgammaf(float x);
-def TLI_tgammaf : TargetLibCall_R<tgammaf>;
+def TLI_tgammaf : TargetLibCall<tgammaf>;
/// long double tgammal(long double x);
-def TLI_tgammal : TargetLibCall_R<tgammal_f128>;
+def TLI_tgammal : TargetLibCall<tgammal_f128>;
/// int execl(const char *path, const char *arg, ...);
-def TLI_execl : TargetLibCall_R<execl>;
+def TLI_execl : TargetLibCall<execl>;
/// int execle(const char *file, const char *arg, ..., char * const envp[]);
-def TLI_execle : TargetLibCall_R<execle>;
+def TLI_execle : TargetLibCall<execle>;
/// int execlp(const char *file, const char *arg, ...);
-def TLI_execlp : TargetLibCall_R<execlp>;
+def TLI_execlp : TargetLibCall<execlp>;
/// int execv(const char *path, char *const argv[]);
-def TLI_execv : TargetLibCall_R<execv>;
+def TLI_execv : TargetLibCall<execv>;
/// int execvP(const char *file, const char *search_path, char *const argv[]);
-def TLI_execvP : TargetLibCall_R<execvP>;
+def TLI_execvP : TargetLibCall<execvP>;
/// int execve(const char *filename, char *const argv], [char *const envp[]);
-def TLI_execve : TargetLibCall_R<execve>;
+def TLI_execve : TargetLibCall<execve>;
/// int execvp(const char *file, char *const argv[]);
-def TLI_execvp : TargetLibCall_R<execvp>;
+def TLI_execvp : TargetLibCall<execvp>;
/// int execvpe(const char *file, char *const argv], [char *const envp[]);
-def TLI_execvpe : TargetLibCall_R<execvpe>;
+def TLI_execvpe : TargetLibCall<execvpe>;
/// double exp(double x);
-def TLI_exp : TargetLibCall_R<exp>;
+def TLI_exp : TargetLibCall<exp>;
/// double exp10(double x);
-def TLI_exp10 : TargetLibCall_R<exp10>;
+def TLI_exp10 : TargetLibCall<exp10>;
/// float exp10f(float x);
-def TLI_exp10f : TargetLibCall_R<exp10f>;
+def TLI_exp10f : TargetLibCall<exp10f>;
/// long double exp10l(long double x);
-def TLI_exp10l : TargetLibCall_R<exp10l_f128>;
+def TLI_exp10l : TargetLibCall<exp10l_f128>;
/// double exp2(double x);
-def TLI_exp2 : TargetLibCall_R<exp2>;
+def TLI_exp2 : TargetLibCall<exp2>;
/// float exp2f(float x);
-def TLI_exp2f : TargetLibCall_R<exp2f>;
+def TLI_exp2f : TargetLibCall<exp2f>;
/// long double exp2l(long double x);
-def TLI_exp2l : TargetLibCall_R<exp2l_f128>;
+def TLI_exp2l : TargetLibCall<exp2l_f128>;
/// float expf(float x);
-def TLI_expf : TargetLibCall_R<expf>;
+def TLI_expf : TargetLibCall<expf>;
/// long double expl(long double x);
-def TLI_expl : TargetLibCall_R<expl_f128>;
+def TLI_expl : TargetLibCall<expl_f128>;
/// double expm1(double x);
-def TLI_expm1 : TargetLibCall_R<expm1>;
+def TLI_expm1 : TargetLibCall<expm1>;
/// float expm1f(float x);
-def TLI_expm1f : TargetLibCall_R<expm1f>;
+def TLI_expm1f : TargetLibCall<expm1f>;
/// long double expm1l(long double x);
-def TLI_expm1l : TargetLibCall_R<expm1l>;
+def TLI_expm1l : TargetLibCall<expm1l>;
/// double fabs(double x);
-def TLI_fabs : TargetLibCall_R<fabs>;
+def TLI_fabs : TargetLibCall<fabs>;
/// float fabsf(float x);
-def TLI_fabsf : TargetLibCall_R<fabsf>;
+def TLI_fabsf : TargetLibCall<fabsf>;
/// long double fabsl(long double x);
-def TLI_fabsl : TargetLibCall_R<fabsl>;
+def TLI_fabsl : TargetLibCall<fabsl>;
/// int fclose(FILE *stream);
-def TLI_fclose : TargetLibCall_R<fclose>;
+def TLI_fclose : TargetLibCall<fclose>;
/// FILE *fdopen(int fildes, const char *mode);
-def TLI_fdopen : TargetLibCall_R<fdopen>;
+def TLI_fdopen : TargetLibCall<fdopen>;
/// int feof(FILE *stream);
-def TLI_feof : TargetLibCall_R<feof>;
+def TLI_feof : TargetLibCall<feof>;
/// int ferror(FILE *stream);
-def TLI_ferror : TargetLibCall_R<ferror>;
+def TLI_ferror : TargetLibCall<ferror>;
/// int fflush(FILE *stream);
-def TLI_fflush : TargetLibCall_R<fflush>;
+def TLI_fflush : TargetLibCall<fflush>;
/// int ffs(int i);
-def TLI_ffs : TargetLibCall_R<ffs>;
+def TLI_ffs : TargetLibCall<ffs>;
/// int ffsl(long int i);
-def TLI_ffsl : TargetLibCall_R<ffsl>;
+def TLI_ffsl : TargetLibCall<ffsl>;
/// int ffsll(long long int i);
-def TLI_ffsll : TargetLibCall_R<ffsll>;
+def TLI_ffsll : TargetLibCall<ffsll>;
/// int fgetc(FILE *stream);
-def TLI_fgetc : TargetLibCall_R<fgetc>;
+def TLI_fgetc : TargetLibCall<fgetc>;
/// int fgetc_unlocked(FILE *stream);
-def TLI_fgetc_unlocked : TargetLibCall_R<fgetc_unlocked>;
+def TLI_fgetc_unlocked : TargetLibCall<fgetc_unlocked>;
/// int fgetpos(FILE *stream, fpos_t *pos);
-def TLI_fgetpos : TargetLibCall_R<fgetpos>;
+def TLI_fgetpos : TargetLibCall<fgetpos>;
/// char *fgets(char *s, int n, FILE *stream);
-def TLI_fgets : TargetLibCall_R<fgets>;
+def TLI_fgets : TargetLibCall<fgets>;
/// char *fgets_unlocked(char *s, int n, FILE *stream);
-def TLI_fgets_unlocked : TargetLibCall_R<fgets_unlocked>;
+def TLI_fgets_unlocked : TargetLibCall<fgets_unlocked>;
/// int fileno(FILE *stream);
-def TLI_fileno : TargetLibCall_R<fileno>;
+def TLI_fileno : TargetLibCall<fileno>;
/// int fiprintf(FILE *stream, const char *format, ...);
-def TLI_fiprintf : TargetLibCall_R<fiprintf>;
+def TLI_fiprintf : TargetLibCall<fiprintf>;
/// void flockfile(FILE *file);
-def TLI_flockfile : TargetLibCall_R<flockfile>;
+def TLI_flockfile : TargetLibCall<flockfile>;
/// double floor(double x);
-def TLI_floor : TargetLibCall_R<floor>;
+def TLI_floor : TargetLibCall<floor>;
/// float floorf(float x);
-def TLI_floorf : TargetLibCall_R<floorf>;
+def TLI_floorf : TargetLibCall<floorf>;
/// long double floorl(long double x);
-def TLI_floorl : TargetLibCall_R<floorl_f128>;
+def TLI_floorl : TargetLibCall<floorl_f128>;
/// int fls(int i);
-def TLI_fls : TargetLibCall_R<fls>;
+def TLI_fls : TargetLibCall<fls>;
/// int flsl(long int i);
-def TLI_flsl : TargetLibCall_R<flsl>;
+def TLI_flsl : TargetLibCall<flsl>;
/// int flsll(long long int i);
-def TLI_flsll : TargetLibCall_R<flsll>;
+def TLI_flsll : TargetLibCall<flsll>;
// Calls to fmax and fmin library functions expand to the llvm.maxnnum and
// llvm.minnum intrinsics with the correct parameter types for the arguments
// (all types must match).
/// double fmax(double x, double y);
-def TLI_fmax : TargetLibCall_R<fmax>;
+def TLI_fmax : TargetLibCall<fmax>;
/// float fmaxf(float x, float y);
-def TLI_fmaxf : TargetLibCall_R<fmaxf>;
+def TLI_fmaxf : TargetLibCall<fmaxf>;
/// long double fmaxl(long double x, long double y);
-def TLI_fmaxl : TargetLibCall_R<fmaxl_f128>;
+def TLI_fmaxl : TargetLibCall<fmaxl_f128>;
/// double fmin(double x, double y);
-def TLI_fmin : TargetLibCall_R<fmin>;
+def TLI_fmin : TargetLibCall<fmin>;
/// float fminf(float x, float y);
-def TLI_fminf : TargetLibCall_R<fminf>;
+def TLI_fminf : TargetLibCall<fminf>;
/// long double fminl(long double x, long double y);
-def TLI_fminl : TargetLibCall_R<fminl_f128>;
+def TLI_fminl : TargetLibCall<fminl_f128>;
// Calls to fmaximum_num and fminimum_num library functions expand to the
// llvm.maximumnum and llvm.minimumnum intrinsics with the correct parameter
// types for the arguments (all types must match).
/// double fmaximum_num(double x, double y);
-def TLI_fmaximum_num : TargetLibCall_R<fmaximum_num>;
+def TLI_fmaximum_num : TargetLibCall<fmaximum_num>;
/// float fmaximum_numf(float x, float y);
-def TLI_fmaximum_numf : TargetLibCall_R<fmaximum_numf>;
+def TLI_fmaximum_numf : TargetLibCall<fmaximum_numf>;
/// long double fmaximum_numl(long double x, long double y);
-def TLI_fmaximum_numl : TargetLibCall_R<fmaximum_numl_f128>;
+def TLI_fmaximum_numl : TargetLibCall<fmaximum_numl_f128>;
/// double fminimum_num(double x, double y);
-def TLI_fminimum_num : TargetLibCall_R<fminimum_num>;
+def TLI_fminimum_num : TargetLibCall<fminimum_num>;
/// float fminimum_numf(float x, float y);
-def TLI_fminimum_numf : TargetLibCall_R<fminimum_numf>;
+def TLI_fminimum_numf : TargetLibCall<fminimum_numf>;
/// long double fminimum_numl(long double x, long double y);
-def TLI_fminimum_numl : TargetLibCall_R<fminimum_numl_f128>;
+def TLI_fminimum_numl : TargetLibCall<fminimum_numl_f128>;
/// double fmod(double x, double y);
-def TLI_fmod : TargetLibCall_R<fmod>;
+def TLI_fmod : TargetLibCall<fmod>;
/// float fmodf(float x, float y);
-def TLI_fmodf : TargetLibCall_R<fmodf>;
+def TLI_fmodf : TargetLibCall<fmodf>;
/// long double fmodl(long double x, long double y);
-def TLI_fmodl : TargetLibCall_R<fmodl_f128>;
+def TLI_fmodl : TargetLibCall<fmodl_f128>;
/// FILE *fopen(const char *filename, const char *mode);
-def TLI_fopen : TargetLibCall_R<fopen>;
+def TLI_fopen : TargetLibCall<fopen>;
/// FILE *fopen64(const char *filename, const char *opentype)
-def TLI_fopen64 : TargetLibCall_R<fopen64>;
+def TLI_fopen64 : TargetLibCall<fopen64>;
/// int fork();
-def TLI_fork : TargetLibCall_R<fork>;
+def TLI_fork : TargetLibCall<fork>;
/// int fprintf(FILE *stream, const char *format, ...);
-def TLI_fprintf : TargetLibCall_R<fprintf>;
+def TLI_fprintf : TargetLibCall<fprintf>;
/// int fputc(int c, FILE *stream);
-def TLI_fputc : TargetLibCall_R<fputc>;
+def TLI_fputc : TargetLibCall<fputc>;
/// int fputc_unlocked(int c, FILE *stream);
-def TLI_fputc_unlocked : TargetLibCall_R<fputc_unlocked>;
+def TLI_fputc_unlocked : TargetLibCall<fputc_unlocked>;
/// int fputs(const char *s, FILE *stream);
-def TLI_fputs : TargetLibCall_R<fputs>;
+def TLI_fputs : TargetLibCall<fputs>;
/// int fputs_unlocked(const char *s, FILE *stream);
-def TLI_fputs_unlocked : TargetLibCall_R<fputs_unlocked>;
+def TLI_fputs_unlocked : TargetLibCall<fputs_unlocked>;
/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
-def TLI_fread : TargetLibCall_R<fread>;
+def TLI_fread : TargetLibCall<fread>;
/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
-def TLI_fread_unlocked : TargetLibCall_R<fread_unlocked>;
+def TLI_fread_unlocked : TargetLibCall<fread_unlocked>;
/// void free(void *ptr);
-def TLI_free : TargetLibCall_R<free>;
+def TLI_free : TargetLibCall<free>;
/// double frexp(double num, int *exp);
-def TLI_frexp : TargetLibCall_R<frexp>;
+def TLI_frexp : TargetLibCall<frexp>;
/// float frexpf(float num, int *exp);
-def TLI_frexpf : TargetLibCall_R<frexpf>;
+def TLI_frexpf : TargetLibCall<frexpf>;
/// long double frexpl(long double num, int *exp);
-def TLI_frexpl : TargetLibCall_R<frexpl_f128>;
+def TLI_frexpl : TargetLibCall<frexpl_f128>;
/// int fscanf(FILE *stream, const char *format, ... );
-def TLI_fscanf : TargetLibCall_R<fscanf>;
+def TLI_fscanf : TargetLibCall<fscanf>;
/// int fseek(FILE *stream, long offset, int whence);
-def TLI_fseek : TargetLibCall_R<fseek>;
+def TLI_fseek : TargetLibCall<fseek>;
/// int fseeko(FILE *stream, off_t offset, int whence);
-def TLI_fseeko : TargetLibCall_R<fseeko>;
+def TLI_fseeko : TargetLibCall<fseeko>;
/// int fseeko64(FILE *stream, off64_t offset, int whence)
-def TLI_fseeko64 : TargetLibCall_R<fseeko64>;
+def TLI_fseeko64 : TargetLibCall<fseeko64>;
/// int fsetpos(FILE *stream, const fpos_t *pos);
-def TLI_fsetpos : TargetLibCall_R<fsetpos>;
+def TLI_fsetpos : TargetLibCall<fsetpos>;
/// int fstat(int fildes, struct stat *buf);
-def TLI_fstat : TargetLibCall_R<fstat>;
+def TLI_fstat : TargetLibCall<fstat>;
/// int fstat64(int filedes, struct stat64 *buf)
-def TLI_fstat64 : TargetLibCall_R<fstat64>;
+def TLI_fstat64 : TargetLibCall<fstat64>;
/// int fstatvfs(int fildes, struct statvfs *buf);
-def TLI_fstatvfs : TargetLibCall_R<fstatvfs>;
+def TLI_fstatvfs : TargetLibCall<fstatvfs>;
/// int fstatvfs64(int fildes, struct statvfs64 *buf);
-def TLI_fstatvfs64 : TargetLibCall_R<fstatvfs64>;
+def TLI_fstatvfs64 : TargetLibCall<fstatvfs64>;
/// long ftell(FILE *stream);
-def TLI_ftell : TargetLibCall_R<ftell>;
+def TLI_ftell : TargetLibCall<ftell>;
/// off_t ftello(FILE *stream);
-def TLI_ftello : TargetLibCall_R<ftello>;
+def TLI_ftello : TargetLibCall<ftello>;
/// off64_t ftello64(FILE *stream)
-def TLI_ftello64 : TargetLibCall_R<ftello64>;
+def TLI_ftello64 : TargetLibCall<ftello64>;
/// int ftrylockfile(FILE *file);
-def TLI_ftrylockfile : TargetLibCall_R<ftrylockfile>;
+def TLI_ftrylockfile : TargetLibCall<ftrylockfile>;
/// void funlockfile(FILE *file);
-def TLI_funlockfile : TargetLibCall_R<funlockfile>;
+def TLI_funlockfile : TargetLibCall<funlockfile>;
/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
-def TLI_fwrite : TargetLibCall_R<fwrite>;
+def TLI_fwrite : TargetLibCall<fwrite>;
/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems,
/// FILE *stream);
-def TLI_fwrite_unlocked : TargetLibCall_R<fwrite_unlocked>;
+def TLI_fwrite_unlocked : TargetLibCall<fwrite_unlocked>;
/// int getc(FILE *stream);
-def TLI_getc : TargetLibCall_R<getc>;
+def TLI_getc : TargetLibCall<getc>;
/// int getc_unlocked(FILE *stream);
-def TLI_getc_unlocked : TargetLibCall_R<getc_unlocked>;
+def TLI_getc_unlocked : TargetLibCall<getc_unlocked>;
/// int getchar(void);
-def TLI_getchar : TargetLibCall_R<getchar>;
+def TLI_getchar : TargetLibCall<getchar>;
/// int getchar_unlocked(void);
-def TLI_getchar_unlocked : TargetLibCall_R<getchar_unlocked>;
+def TLI_getchar_unlocked : TargetLibCall<getchar_unlocked>;
/// char *getenv(const char *name);
-def TLI_getenv : TargetLibCall_R<getenv>;
+def TLI_getenv : TargetLibCall<getenv>;
/// int getitimer(int which, struct itimerval *value);
-def TLI_getitimer : TargetLibCall_R<getitimer>;
+def TLI_getitimer : TargetLibCall<getitimer>;
/// int getlogin_r(char *name, size_t namesize);
-def TLI_getlogin_r : TargetLibCall_R<getlogin_r>;
+def TLI_getlogin_r : TargetLibCall<getlogin_r>;
/// struct passwd *getpwnam(const char *name);
-def TLI_getpwnam : TargetLibCall_R<getpwnam>;
+def TLI_getpwnam : TargetLibCall<getpwnam>;
/// char *gets(char *s);
-def TLI_gets : TargetLibCall_R<gets>;
+def TLI_gets : TargetLibCall<gets>;
/// int gettimeofday(struct timeval *tp, void *tzp);
-def TLI_gettimeofday : TargetLibCall_R<gettimeofday>;
+def TLI_gettimeofday : TargetLibCall<gettimeofday>;
/// uint32_t htonl(uint32_t hostlong);
-def TLI_htonl : TargetLibCall_R<htonl>;
+def TLI_htonl : TargetLibCall<htonl>;
/// uint16_t htons(uint16_t hostshort);
-def TLI_htons : TargetLibCall_R<htons>;
+def TLI_htons : TargetLibCall<htons>;
/// double hypot(double x, double y);
-def TLI_hypot : TargetLibCall_R<hypot>;
+def TLI_hypot : TargetLibCall<hypot>;
/// float hypotf(float x, float y);
-def TLI_hypotf : TargetLibCall_R<hypotf>;
+def TLI_hypotf : TargetLibCall<hypotf>;
/// long double hypotl(long double x, long double y);
-def TLI_hypotl : TargetLibCall_R<hypotl>;
+def TLI_hypotl : TargetLibCall<hypotl>;
/// int iprintf(const char *format, ...);
-def TLI_iprintf : TargetLibCall_R<iprintf>;
+def TLI_iprintf : TargetLibCall<iprintf>;
/// int isascii(int c);
-def TLI_isascii : TargetLibCall_R<isascii>;
+def TLI_isascii : TargetLibCall<isascii>;
/// int isdigit(int c);
-def TLI_isdigit : TargetLibCall_R<isdigit>;
+def TLI_isdigit : TargetLibCall<isdigit>;
/// long int labs(long int j);
-def TLI_labs : TargetLibCall_R<labs>;
+def TLI_labs : TargetLibCall<labs>;
/// int lchown(const char *path, uid_t owner, gid_t group);
-def TLI_lchown : TargetLibCall_R<lchown>;
+def TLI_lchown : TargetLibCall<lchown>;
/// double ldexp(double x, int n);
-def TLI_ldexp : TargetLibCall_R<ldexp>;
+def TLI_ldexp : TargetLibCall<ldexp>;
/// float ldexpf(float x, int n);
-def TLI_ldexpf : TargetLibCall_R<ldexpf>;
+def TLI_ldexpf : TargetLibCall<ldexpf>;
/// long double ldexpl(long double x, int n);
-def TLI_ldexpl : TargetLibCall_R<ldexpl_f128>;
+def TLI_ldexpl : TargetLibCall<ldexpl_f128>;
/// long long int llabs(long long int j);
-def TLI_llabs : TargetLibCall_R<llabs>;
+def TLI_llabs : TargetLibCall<llabs>;
/// double log(double x);
-def TLI_log : TargetLibCall_R<log>;
+def TLI_log : TargetLibCall<log>;
/// double log10(double x);
-def TLI_log10 : TargetLibCall_R<log10>;
+def TLI_log10 : TargetLibCall<log10>;
/// float log10f(float x);
-def TLI_log10f : TargetLibCall_R<log10f>;
+def TLI_log10f : TargetLibCall<log10f>;
/// long double log10l(long double x);
-def TLI_log10l : TargetLibCall_R<log10l_f128>;
+def TLI_log10l : TargetLibCall<log10l_f128>;
/// double log1p(double x);
-def TLI_log1p : TargetLibCall_R<log1p>;
+def TLI_log1p : TargetLibCall<log1p>;
/// float log1pf(float x);
-def TLI_log1pf : TargetLibCall_R<log1pf>;
+def TLI_log1pf : TargetLibCall<log1pf>;
/// long double log1pl(long double x);
-def TLI_log1pl : TargetLibCall_R<log1pl>;
+def TLI_log1pl : TargetLibCall<log1pl>;
/// double log2(double x);
-def TLI_log2 : TargetLibCall_R<log2>;
+def TLI_log2 : TargetLibCall<log2>;
/// float log2f(float x);
-def TLI_log2f : TargetLibCall_R<log2f>;
+def TLI_log2f : TargetLibCall<log2f>;
/// double long double log2l(long double x);
-def TLI_log2l : TargetLibCall_R<log2l_f128>;
+def TLI_log2l : TargetLibCall<log2l_f128>;
/// int ilogb(double x);
-def TLI_ilogb : TargetLibCall_R<ilogb>;
+def TLI_ilogb : TargetLibCall<ilogb>;
/// int ilogbf(float x);
-def TLI_ilogbf : TargetLibCall_R<ilogbf>;
+def TLI_ilogbf : TargetLibCall<ilogbf>;
/// int ilogbl(long double x);
-def TLI_ilogbl : TargetLibCall_R<ilogbl>;
+def TLI_ilogbl : TargetLibCall<ilogbl>;
/// double logb(double x);
-def TLI_logb : TargetLibCall_R<logb>;
+def TLI_logb : TargetLibCall<logb>;
/// float logbf(float x);
-def TLI_logbf : TargetLibCall_R<logbf>;
+def TLI_logbf : TargetLibCall<logbf>;
/// long double logbl(long double x);
-def TLI_logbl : TargetLibCall_R<logbl>;
+def TLI_logbl : TargetLibCall<logbl>;
/// float logf(float x);
-def TLI_logf : TargetLibCall_R<logf>;
+def TLI_logf : TargetLibCall<logf>;
/// long double logl(long double x);
-def TLI_logl : TargetLibCall_R<logl_f128>;
+def TLI_logl : TargetLibCall<logl_f128>;
/// int lstat(const char *path, struct stat *buf);
-def TLI_lstat : TargetLibCall_R<lstat>;
+def TLI_lstat : TargetLibCall<lstat>;
/// int lstat64(const char *path, struct stat64 *buf);
-def TLI_lstat64 : TargetLibCall_R<lstat64>;
+def TLI_lstat64 : TargetLibCall<lstat64>;
/// void *malloc(size_t size);
-def TLI_malloc : TargetLibCall_R<malloc>;
+def TLI_malloc : TargetLibCall<malloc>;
/// void *memalign(size_t boundary, size_t size);
-def TLI_memalign : TargetLibCall_R<memalign>;
+def TLI_memalign : TargetLibCall<memalign>;
/// void *memccpy(void *s1, const void *s2, int c, size_t n);
-def TLI_memccpy : TargetLibCall_R<memccpy>;
+def TLI_memccpy : TargetLibCall<memccpy>;
/// void *memchr(const void *s, int c, size_t n);
-def TLI_memchr : TargetLibCall_R<memchr>;
+def TLI_memchr : TargetLibCall<memchr>;
/// int memcmp(const void *s1, const void *s2, size_t n);
-def TLI_memcmp : TargetLibCall_R<memcmp>;
+def TLI_memcmp : TargetLibCall<memcmp>;
/// void *memcpy(void *s1, const void *s2, size_t n);
-def TLI_memcpy : TargetLibCall_R<memcpy>;
+def TLI_memcpy : TargetLibCall<memcpy>;
/// void *memmove(void *s1, const void *s2, size_t n);
-def TLI_memmove : TargetLibCall_R<memmove>;
+def TLI_memmove : TargetLibCall<memmove>;
/// void *mempcpy(void *s1, const void *s2, size_t n);
-def TLI_mempcpy : TargetLibCall_R<mempcpy>;
+def TLI_mempcpy : TargetLibCall<mempcpy>;
/// void *memrchr(const void *s, int c, size_t n);
-def TLI_memrchr : TargetLibCall_R<memrchr>;
+def TLI_memrchr : TargetLibCall<memrchr>;
/// void *memset(void *b, int c, size_t len);
-def TLI_memset : TargetLibCall_R<memset>;
+def TLI_memset : TargetLibCall<memset>;
/// void memset_pattern16(void *b, const void *pattern16, size_t len);
-def TLI_memset_pattern16 : TargetLibCall_R<memset_pattern16>;
+def TLI_memset_pattern16 : TargetLibCall<memset_pattern16>;
/// void memset_pattern4(void *b, const void *pattern4, size_t len);
-def TLI_memset_pattern4 : TargetLibCall_R<memset_pattern4>;
+def TLI_memset_pattern4 : TargetLibCall<memset_pattern4>;
/// void memset_pattern8(void *b, const void *pattern8, size_t len);
-def TLI_memset_pattern8 : TargetLibCall_R<memset_pattern8>;
+def TLI_memset_pattern8 : TargetLibCall<memset_pattern8>;
/// int mkdir(const char *path, mode_t mode);
-def TLI_mkdir : TargetLibCall_R<mkdir>;
+def TLI_mkdir : TargetLibCall<mkdir>;
/// time_t mktime(struct tm *timeptr);
-def TLI_mktime : TargetLibCall_R<mktime>;
+def TLI_mktime : TargetLibCall<mktime>;
/// double modf(double x, double *iptr);
-def TLI_modf : TargetLibCall_R<modf>;
+def TLI_modf : TargetLibCall<modf>;
/// float modff(float, float *iptr);
-def TLI_modff : TargetLibCall_R<modff>;
+def TLI_modff : TargetLibCall<modff>;
/// long double modfl(long double value, long double *iptr);
-def TLI_modfl : TargetLibCall_R<modfl_f128>;
+def TLI_modfl : TargetLibCall<modfl_f128>;
/// double nan(const char *arg);
-def TLI_nan : TargetLibCall_R<nan>;
+def TLI_nan : TargetLibCall<nan>;
/// float nanf(const char *arg);
-def TLI_nanf : TargetLibCall_R<nanf>;
+def TLI_nanf : TargetLibCall<nanf>;
/// long double nanl(const char *arg);
-def TLI_nanl : TargetLibCall_R<nanl_f128>;
+def TLI_nanl : TargetLibCall<nanl_f128>;
/// double nearbyint(double x);
-def TLI_nearbyint : TargetLibCall_R<nearbyint>;
+def TLI_nearbyint : TargetLibCall<nearbyint>;
/// float nearbyintf(float x);
-def TLI_nearbyintf : TargetLibCall_R<nearbyintf>;
+def TLI_nearbyintf : TargetLibCall<nearbyintf>;
/// long double nearbyintl(long double x);
-def TLI_nearbyintl : TargetLibCall_R<nearbyintl_f128>;
+def TLI_nearbyintl : TargetLibCall<nearbyintl_f128>;
/// double nextafter(double x, double y);
-def TLI_nextafter : TargetLibCall_R<nextafter>;
+def TLI_nextafter : TargetLibCall<nextafter>;
/// float nextafterf(float x, float y);
-def TLI_nextafterf : TargetLibCall_R<nextafterf>;
+def TLI_nextafterf : TargetLibCall<nextafterf>;
/// long double nextafterl(long double x, long double y);
-def TLI_nextafterl : TargetLibCall_R<nextafterl>;
+def TLI_nextafterl : TargetLibCall<nextafterl>;
/// double nexttoward(double x, long double y);
-def TLI_nexttoward : TargetLibCall_R<nexttoward>;
+def TLI_nexttoward : TargetLibCall<nexttoward>;
/// float nexttowardf(float x, long double y);
-def TLI_nexttowardf : TargetLibCall_R<nexttowardf>;
+def TLI_nexttowardf : TargetLibCall<nexttowardf>;
/// long double nexttowardl(long double x, long double y);
-def TLI_nexttowardl : TargetLibCall_R<nexttowardl_f128>;
+def TLI_nexttowardl : TargetLibCall<nexttowardl_f128>;
/// uint32_t ntohl(uint32_t netlong);
-def TLI_ntohl : TargetLibCall_R<ntohl>;
+def TLI_ntohl : TargetLibCall<ntohl>;
/// uint16_t ntohs(uint16_t netshort);
-def TLI_ntohs : TargetLibCall_R<ntohs>;
+def TLI_ntohs : TargetLibCall<ntohs>;
/// int open(const char *path, int oflag, ... );
-def TLI_open : TargetLibCall_R<open>;
+def TLI_open : TargetLibCall<open>;
/// int open64(const char *filename, int flags, [mode_t mode])
-def TLI_open64 : TargetLibCall_R<open64>;
+def TLI_open64 : TargetLibCall<open64>;
/// DIR *opendir(const char *dirname);
-def TLI_opendir : TargetLibCall_R<opendir>;
+def TLI_opendir : TargetLibCall<opendir>;
/// int pclose(FILE *stream);
-def TLI_pclose : TargetLibCall_R<pclose>;
+def TLI_pclose : TargetLibCall<pclose>;
/// void perror(const char *s);
-def TLI_perror : TargetLibCall_R<perror>;
+def TLI_perror : TargetLibCall<perror>;
/// FILE *popen(const char *command, const char *mode);
-def TLI_popen : TargetLibCall_R<popen>;
+def TLI_popen : TargetLibCall<popen>;
/// int posix_memalign(void **memptr, size_t alignment, size_t size);
-def TLI_posix_memalign : TargetLibCall_R<posix_memalign>;
+def TLI_posix_memalign : TargetLibCall<posix_memalign>;
/// double pow(double x, double y);
-def TLI_pow : TargetLibCall_R<pow>;
+def TLI_pow : TargetLibCall<pow>;
/// float powf(float x, float y);
-def TLI_powf : TargetLibCall_R<powf>;
+def TLI_powf : TargetLibCall<powf>;
/// long double powl(long double x, long double y);
-def TLI_powl : TargetLibCall_R<powl_f128>;
+def TLI_powl : TargetLibCall<powl_f128>;
/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
-def TLI_pread : TargetLibCall_R<pread>;
+def TLI_pread : TargetLibCall<pread>;
/// int printf(const char *format, ...);
-def TLI_printf : TargetLibCall_R<printf>;
+def TLI_printf : TargetLibCall<printf>;
/// int putc(int c, FILE *stream);
-def TLI_putc : TargetLibCall_R<putc>;
+def TLI_putc : TargetLibCall<putc>;
/// int putc_unlocked(int c, FILE *stream);
-def TLI_putc_unlocked : TargetLibCall_R<putc_unlocked>;
+def TLI_putc_unlocked : TargetLibCall<putc_unlocked>;
/// int putchar(int c);
-def TLI_putchar : TargetLibCall_R<putchar>;
+def TLI_putchar : TargetLibCall<putchar>;
/// int putchar_unlocked(int c);
-def TLI_putchar_unlocked : TargetLibCall_R<putchar_unlocked>;
+def TLI_putchar_unlocked : TargetLibCall<putchar_unlocked>;
/// int puts(const char *s);
-def TLI_puts : TargetLibCall_R<puts>;
+def TLI_puts : TargetLibCall<puts>;
/// void *pvalloc(size_t size);
-def TLI_pvalloc : TargetLibCall_R<pvalloc>;
+def TLI_pvalloc : TargetLibCall<pvalloc>;
/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
-def TLI_pwrite : TargetLibCall_R<pwrite>;
+def TLI_pwrite : TargetLibCall<pwrite>;
/// void qsort(void *base, size_t nel, size_t width,
/// int (*compar)(const void *, const void *));
-def TLI_qsort : TargetLibCall_R<qsort>;
+def TLI_qsort : TargetLibCall<qsort>;
/// ssize_t read(int fildes, void *buf, size_t nbyte);
-def TLI_read : TargetLibCall_R<read>;
+def TLI_read : TargetLibCall<read>;
/// ssize_t readlink(const char *path, char *buf, size_t bufsize);
-def TLI_readlink : TargetLibCall_R<readlink>;
+def TLI_readlink : TargetLibCall<readlink>;
/// void *realloc(void *ptr, size_t size);
-def TLI_realloc : TargetLibCall_R<realloc>;
+def TLI_realloc : TargetLibCall<realloc>;
/// void *reallocf(void *ptr, size_t size);
-def TLI_reallocf : TargetLibCall_R<reallocf>;
+def TLI_reallocf : TargetLibCall<reallocf>;
/// void *reallocarray(void *ptr, size_t nmemb, size_t size);
-def TLI_reallocarray : TargetLibCall_R<reallocarray>;
+def TLI_reallocarray : TargetLibCall<reallocarray>;
/// char *realpath(const char *file_name, char *resolved_name);
-def TLI_realpath : TargetLibCall_R<realpath>;
+def TLI_realpath : TargetLibCall<realpath>;
/// double remainder(double x, double y);
-def TLI_remainder : TargetLibCall_R<remainder>;
+def TLI_remainder : TargetLibCall<remainder>;
/// float remainderf(float x, float y);
-def TLI_remainderf : TargetLibCall_R<remainderf>;
+def TLI_remainderf : TargetLibCall<remainderf>;
/// long double remainderl(long double x, long double y);
-def TLI_remainderl : TargetLibCall_R<remainderl_f128>;
+def TLI_remainderl : TargetLibCall<remainderl_f128>;
/// double remquo(double x, double y, int *quo);
-def TLI_remquo : TargetLibCall_R<remquo>;
+def TLI_remquo : TargetLibCall<remquo>;
/// float remquof(float x, float y, int *quo);
-def TLI_remquof : TargetLibCall_R<remquof>;
+def TLI_remquof : TargetLibCall<remquof>;
/// long double remquol(long double x, long double y, int *quo);
-def TLI_remquol : TargetLibCall_R<remquol_f128>;
+def TLI_remquol : TargetLibCall<remquol_f128>;
/// double fdim(double x, double y);
-def TLI_fdim : TargetLibCall_R<fdim>;
+def TLI_fdim : TargetLibCall<fdim>;
/// float fdimf(float x, float y);
-def TLI_fdimf : TargetLibCall_R<fdimf>;
+def TLI_fdimf : TargetLibCall<fdimf>;
/// long double fdiml(long double x, long double y);
-def TLI_fdiml : TargetLibCall_R<fdiml_f128>;
+def TLI_fdiml : TargetLibCall<fdiml_f128>;
/// int remove(const char *path);
-def TLI_remove : TargetLibCall_R<remove>;
+def TLI_remove : TargetLibCall<remove>;
/// int rename(const char *old, const char *new);
-def TLI_rename : TargetLibCall_R<rename>;
+def TLI_rename : TargetLibCall<rename>;
/// void rewind(FILE *stream);
-def TLI_rewind : TargetLibCall_R<rewind>;
+def TLI_rewind : TargetLibCall<rewind>;
/// double rint(double x);
-def TLI_rint : TargetLibCall_R<rint>;
+def TLI_rint : TargetLibCall<rint>;
/// float rintf(float x);
-def TLI_rintf : TargetLibCall_R<rintf>;
+def TLI_rintf : TargetLibCall<rintf>;
/// long double rintl(long double x);
-def TLI_rintl : TargetLibCall_R<rintl_f128>;
+def TLI_rintl : TargetLibCall<rintl_f128>;
/// int rmdir(const char *path);
-def TLI_rmdir : TargetLibCall_R<rmdir>;
+def TLI_rmdir : TargetLibCall<rmdir>;
/// double round(double x);
-def TLI_round : TargetLibCall_R<round>;
+def TLI_round : TargetLibCall<round>;
/// double roundeven(double x);
-def TLI_roundeven : TargetLibCall_R<roundeven>;
+def TLI_roundeven : TargetLibCall<roundeven>;
/// float roundevenf(float x);
-def TLI_roundevenf : TargetLibCall_R<roundevenf>;
+def TLI_roundevenf : TargetLibCall<roundevenf>;
/// long double roundevenl(long double x);
-def TLI_roundevenl : TargetLibCall_R<roundevenl_f128>;
+def TLI_roundevenl : TargetLibCall<roundevenl_f128>;
/// float roundf(float x);
-def TLI_roundf : TargetLibCall_R<roundf>;
+def TLI_roundf : TargetLibCall<roundf>;
/// long double roundl(long double x);
-def TLI_roundl : TargetLibCall_R<roundl_f128>;
+def TLI_roundl : TargetLibCall<roundl_f128>;
/// double scalbln(double arg, long exp);
-def TLI_scalbln : TargetLibCall_R<scalbln>;
+def TLI_scalbln : TargetLibCall<scalbln>;
/// float scalblnf(float arg, long exp);
-def TLI_scalblnf : TargetLibCall_R<scalblnf>;
+def TLI_scalblnf : TargetLibCall<scalblnf>;
/// long double scalblnl(long double arg, long exp);
-def TLI_scalblnl : TargetLibCall_R<scalblnl_f128>;
+def TLI_scalblnl : TargetLibCall<scalblnl_f128>;
/// double scalbn(double arg, int exp);
-def TLI_scalbn : TargetLibCall_R<scalbn>;
+def TLI_scalbn : TargetLibCall<scalbn>;
/// float scalbnf(float arg, int exp);
-def TLI_scalbnf : TargetLibCall_R<scalbnf>;
+def TLI_scalbnf : TargetLibCall<scalbnf>;
/// long double scalbnl(long double arg, int exp);
-def TLI_scalbnl : TargetLibCall_R<scalbnl_f128>;
+def TLI_scalbnl : TargetLibCall<scalbnl_f128>;
/// int scanf(const char *restrict format, ... );
-def TLI_scanf : TargetLibCall_R<scanf>;
+def TLI_scanf : TargetLibCall<scanf>;
/// void setbuf(FILE *stream, char *buf);
-def TLI_setbuf : TargetLibCall_R<setbuf>;
+def TLI_setbuf : TargetLibCall<setbuf>;
/// int setitimer(int which, const struct itimerval *value,
/// struct itimerval *ovalue);
-def TLI_setitimer : TargetLibCall_R<setitimer>;
+def TLI_setitimer : TargetLibCall<setitimer>;
/// int setvbuf(FILE *stream, char *buf, int type, size_t size);
-def TLI_setvbuf : TargetLibCall_R<setvbuf>;
+def TLI_setvbuf : TargetLibCall<setvbuf>;
/// double sin(double x);
-def TLI_sin : TargetLibCall_R<sin>;
+def TLI_sin : TargetLibCall<sin>;
/// float sinf(float x);
-def TLI_sinf : TargetLibCall_R<sinf>;
+def TLI_sinf : TargetLibCall<sinf>;
/// double sinh(double x);
-def TLI_sinh : TargetLibCall_R<sinh>;
+def TLI_sinh : TargetLibCall<sinh>;
/// float sinhf(float x);
-def TLI_sinhf : TargetLibCall_R<sinhf>;
+def TLI_sinhf : TargetLibCall<sinhf>;
/// long double sinhl(long double x);
-def TLI_sinhl : TargetLibCall_R<sinhl_f128>;
+def TLI_sinhl : TargetLibCall<sinhl_f128>;
/// long double sinl(long double x);
-def TLI_sinl : TargetLibCall_R<sinl_f128>;
+def TLI_sinl : TargetLibCall<sinl_f128>;
/// void sincos(double x, double *sin_out, double *cos_out);
-def TLI_sincos : TargetLibCall_R<sincos>;
+def TLI_sincos : TargetLibCall<sincos>;
/// void sincosf(float x, float *sin_out, float *cos_out);
-def TLI_sincosf : TargetLibCall_R<sincosf>;
+def TLI_sincosf : TargetLibCall<sincosf>;
/// void sincosl(long double x, long double *sin_out, long double *cos_out);
-def TLI_sincosl : TargetLibCall_R<sincosl_f128>;
+def TLI_sincosl : TargetLibCall<sincosl_f128>;
/// int siprintf(char *str, const char *format, ...);
-def TLI_siprintf : TargetLibCall_R<siprintf>;
+def TLI_siprintf : TargetLibCall<siprintf>;
/// int snprintf(char *s, size_t n, const char *format, ...);
-def TLI_snprintf : TargetLibCall_R<snprintf>;
+def TLI_snprintf : TargetLibCall<snprintf>;
/// int sprintf(char *str, const char *format, ...);
-def TLI_sprintf : TargetLibCall_R<sprintf>;
+def TLI_sprintf : TargetLibCall<sprintf>;
/// double sqrt(double x);
-def TLI_sqrt : TargetLibCall_R<sqrt>;
+def TLI_sqrt : TargetLibCall<sqrt>;
/// float sqrtf(float x);
-def TLI_sqrtf : TargetLibCall_R<sqrtf>;
+def TLI_sqrtf : TargetLibCall<sqrtf>;
/// long double sqrtl(long double x);
-def TLI_sqrtl : TargetLibCall_R<sqrtl_f128>;
+def TLI_sqrtl : TargetLibCall<sqrtl_f128>;
/// int sscanf(const char *s, const char *format, ... );
-def TLI_sscanf : TargetLibCall_R<sscanf>;
+def TLI_sscanf : TargetLibCall<sscanf>;
/// int stat(const char *path, struct stat *buf);
-def TLI_stat : TargetLibCall_R<stat>;
+def TLI_stat : TargetLibCall<stat>;
/// int stat64(const char *path, struct stat64 *buf);
-def TLI_stat64 : TargetLibCall_R<stat64>;
+def TLI_stat64 : TargetLibCall<stat64>;
/// int statvfs(const char *path, struct statvfs *buf);
-def TLI_statvfs : TargetLibCall_R<statvfs>;
+def TLI_statvfs : TargetLibCall<statvfs>;
/// int statvfs64(const char *path, struct statvfs64 *buf)
-def TLI_statvfs64 : TargetLibCall_R<statvfs64>;
+def TLI_statvfs64 : TargetLibCall<statvfs64>;
/// char *stpcpy(char *s1, const char *s2);
-def TLI_stpcpy : TargetLibCall_R<stpcpy>;
+def TLI_stpcpy : TargetLibCall<stpcpy>;
/// char *stpncpy(char *s1, const char *s2, size_t n);
-def TLI_stpncpy : TargetLibCall_R<stpncpy>;
+def TLI_stpncpy : TargetLibCall<stpncpy>;
/// int strcasecmp(const char *s1, const char *s2);
-def TLI_strcasecmp : TargetLibCall_R<strcasecmp>;
+def TLI_strcasecmp : TargetLibCall<strcasecmp>;
/// char *strcat(char *s1, const char *s2);
-def TLI_strcat : TargetLibCall_R<strcat>;
+def TLI_strcat : TargetLibCall<strcat>;
/// char *strchr(const char *s, int c);
-def TLI_strchr : TargetLibCall_R<strchr>;
+def TLI_strchr : TargetLibCall<strchr>;
/// int strcmp(const char *s1, const char *s2);
-def TLI_strcmp : TargetLibCall_R<strcmp>;
+def TLI_strcmp : TargetLibCall<strcmp>;
/// int strcoll(const char *s1, const char *s2);
-def TLI_strcoll : TargetLibCall_R<strcoll>;
+def TLI_strcoll : TargetLibCall<strcoll>;
/// char *strcpy(char *s1, const char *s2);
-def TLI_strcpy : TargetLibCall_R<strcpy>;
+def TLI_strcpy : TargetLibCall<strcpy>;
/// size_t strcspn(const char *s1, const char *s2);
-def TLI_strcspn : TargetLibCall_R<strcspn>;
+def TLI_strcspn : TargetLibCall<strcspn>;
/// char *strdup(const char *s1);
-def TLI_strdup : TargetLibCall_R<strdup>;
+def TLI_strdup : TargetLibCall<strdup>;
/// size_t strlcat(char *dst, const char *src, size_t size);
-def TLI_strlcat : TargetLibCall_R<strlcat>;
+def TLI_strlcat : TargetLibCall<strlcat>;
/// size_t strlcpy(char *dst, const char *src, size_t size);
-def TLI_strlcpy : TargetLibCall_R<strlcpy>;
+def TLI_strlcpy : TargetLibCall<strlcpy>;
/// size_t strlen(const char *s);
-def TLI_strlen : TargetLibCall_R<strlen>;
+def TLI_strlen : TargetLibCall<strlen>;
/// int strncasecmp(const char *s1, const char *s2, size_t n);
-def TLI_strncasecmp : TargetLibCall_R<strncasecmp>;
+def TLI_strncasecmp : TargetLibCall<strncasecmp>;
/// char *strncat(char *s1, const char *s2, size_t n);
-def TLI_strncat : TargetLibCall_R<strncat>;
+def TLI_strncat : TargetLibCall<strncat>;
/// int strncmp(const char *s1, const char *s2, size_t n);
-def TLI_strncmp : TargetLibCall_R<strncmp>;
+def TLI_strncmp : TargetLibCall<strncmp>;
/// char *strncpy(char *s1, const char *s2, size_t n);
-def TLI_strncpy : TargetLibCall_R<strncpy>;
+def TLI_strncpy : TargetLibCall<strncpy>;
/// char *strndup(const char *s1, size_t n);
-def TLI_strndup : TargetLibCall_R<strndup>;
+def TLI_strndup : TargetLibCall<strndup>;
/// size_t strnlen(const char *s, size_t maxlen);
-def TLI_strnlen : TargetLibCall_R<strnlen>;
+def TLI_strnlen : TargetLibCall<strnlen>;
/// char *strpbrk(const char *s1, const char *s2);
-def TLI_strpbrk : TargetLibCall_R<strpbrk>;
+def TLI_strpbrk : TargetLibCall<strpbrk>;
/// char *strrchr(const char *s, int c);
-def TLI_strrchr : TargetLibCall_R<strrchr>;
+def TLI_strrchr : TargetLibCall<strrchr>;
/// size_t strspn(const char *s1, const char *s2);
-def TLI_strspn : TargetLibCall_R<strspn>;
+def TLI_strspn : TargetLibCall<strspn>;
/// char *strstr(const char *s1, const char *s2);
-def TLI_strstr : TargetLibCall_R<strstr>;
+def TLI_strstr : TargetLibCall<strstr>;
/// double strtod(const char *nptr, char **endptr);
-def TLI_strtod : TargetLibCall_R<strtod>;
+def TLI_strtod : TargetLibCall<strtod>;
/// float strtof(const char *nptr, char **endptr);
-def TLI_strtof : TargetLibCall_R<strtof>;
+def TLI_strtof : TargetLibCall<strtof>;
/// char *strtok(char *s1, const char *s2);
-def TLI_strtok : TargetLibCall_R<strtok>;
+def TLI_strtok : TargetLibCall<strtok>;
/// char *strtok_r(char *s, const char *sep, char **lasts);
-def TLI_strtok_r : TargetLibCall_R<strtok_r>;
+def TLI_strtok_r : TargetLibCall<strtok_r>;
/// long int strtol(const char *nptr, char **endptr, int base);
-def TLI_strtol : TargetLibCall_R<strtol>;
+def TLI_strtol : TargetLibCall<strtol>;
/// long double strtold(const char *nptr, char **endptr);
-def TLI_strtold : TargetLibCall_R<strtold>;
+def TLI_strtold : TargetLibCall<strtold>;
/// long long int strtoll(const char *nptr, char **endptr, int base);
-def TLI_strtoll : TargetLibCall_R<strtoll>;
+def TLI_strtoll : TargetLibCall<strtoll>;
/// unsigned long int strtoul(const char *nptr, char **endptr, int base);
-def TLI_strtoul : TargetLibCall_R<strtoul>;
+def TLI_strtoul : TargetLibCall<strtoul>;
/// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
-def TLI_strtoull : TargetLibCall_R<strtoull>;
+def TLI_strtoull : TargetLibCall<strtoull>;
/// size_t strxfrm(char *s1, const char *s2, size_t n);
-def TLI_strxfrm : TargetLibCall_R<strxfrm>;
+def TLI_strxfrm : TargetLibCall<strxfrm>;
/// int system(const char *command);
-def TLI_system : TargetLibCall_R<system>;
+def TLI_system : TargetLibCall<system>;
/// double tan(double x);
-def TLI_tan : TargetLibCall_R<tan>;
+def TLI_tan : TargetLibCall<tan>;
/// float tanf(float x);
-def TLI_tanf : TargetLibCall_R<tanf>;
+def TLI_tanf : TargetLibCall<tanf>;
/// double tanh(double x);
-def TLI_tanh : TargetLibCall_R<tanh>;
+def TLI_tanh : TargetLibCall<tanh>;
/// float tanhf(float x);
-def TLI_tanhf : TargetLibCall_R<tanhf>;
+def TLI_tanhf : TargetLibCall<tanhf>;
/// long double tanhl(long double x);
-def TLI_tanhl : TargetLibCall_R<tanhl_f128>;
+def TLI_tanhl : TargetLibCall<tanhl_f128>;
/// long double tanl(long double x);
-def TLI_tanl : TargetLibCall_R<tanl_f128>;
+def TLI_tanl : TargetLibCall<tanl_f128>;
/// clock_t times(struct tms *buffer);
-def TLI_times : TargetLibCall_R<times>;
+def TLI_times : TargetLibCall<times>;
/// FILE *tmpfile(void);
-def TLI_tmpfile : TargetLibCall_R<tmpfile>;
+def TLI_tmpfile : TargetLibCall<tmpfile>;
/// FILE *tmpfile64(void)
-def TLI_tmpfile64 : TargetLibCall_R<tmpfile64>;
+def TLI_tmpfile64 : TargetLibCall<tmpfile64>;
/// int toascii(int c);
-def TLI_toascii : TargetLibCall_R<toascii>;
+def TLI_toascii : TargetLibCall<toascii>;
/// double trunc(double x);
-def TLI_trunc : TargetLibCall_R<trunc>;
+def TLI_trunc : TargetLibCall<trunc>;
/// float truncf(float x);
-def TLI_truncf : TargetLibCall_R<truncf>;
+def TLI_truncf : TargetLibCall<truncf>;
/// long double truncl(long double x);
-def TLI_truncl : TargetLibCall_R<truncl_f128>;
+def TLI_truncl : TargetLibCall<truncl_f128>;
/// int uname(struct utsname *name);
-def TLI_uname : TargetLibCall_R<uname>;
+def TLI_uname : TargetLibCall<uname>;
/// int ungetc(int c, FILE *stream);
-def TLI_ungetc : TargetLibCall_R<ungetc>;
+def TLI_ungetc : TargetLibCall<ungetc>;
/// int unlink(const char *path);
-def TLI_unlink : TargetLibCall_R<unlink>;
+def TLI_unlink : TargetLibCall<unlink>;
/// int unsetenv(const char *name);
-def TLI_unsetenv : TargetLibCall_R<unsetenv>;
+def TLI_unsetenv : TargetLibCall<unsetenv>;
/// int utime(const char *path, const struct utimbuf *times);
-def TLI_utime : TargetLibCall_R<utime>;
+def TLI_utime : TargetLibCall<utime>;
/// int utimes(const char *path, const struct timeval times[2]);
-def TLI_utimes : TargetLibCall_R<utimes>;
+def TLI_utimes : TargetLibCall<utimes>;
/// void *valloc(size_t size);
-def TLI_valloc : TargetLibCall_R<valloc>;
+def TLI_valloc : TargetLibCall<valloc>;
/// void *vec_calloc(size_t count, size_t size);
-def TLI_vec_calloc : TargetLibCall_R<vec_calloc>;
+def TLI_vec_calloc : TargetLibCall<vec_calloc>;
/// void vec_free(void *ptr);
-def TLI_vec_free : TargetLibCall_R<vec_free>;
+def TLI_vec_free : TargetLibCall<vec_free>;
/// void *vec_malloc(size_t size);
-def TLI_vec_malloc : TargetLibCall_R<vec_malloc>;
+def TLI_vec_malloc : TargetLibCall<vec_malloc>;
/// void *vec_realloc(void *ptr, size_t size);
-def TLI_vec_realloc : TargetLibCall_R<vec_realloc>;
+def TLI_vec_realloc : TargetLibCall<vec_realloc>;
/// int vfprintf(FILE *stream, const char *format, va_list ap);
-def TLI_vfprintf : TargetLibCall_R<vfprintf>;
+def TLI_vfprintf : TargetLibCall<vfprintf>;
/// int vfscanf(FILE *stream, const char *format, va_list arg);
-def TLI_vfscanf : TargetLibCall_R<vfscanf>;
+def TLI_vfscanf : TargetLibCall<vfscanf>;
/// int vprintf(const char *restrict format, va_list ap);
-def TLI_vprintf : TargetLibCall_R<vprintf>;
+def TLI_vprintf : TargetLibCall<vprintf>;
/// int vscanf(const char *format, va_list arg);
-def TLI_vscanf : TargetLibCall_R<vscanf>;
+def TLI_vscanf : TargetLibCall<vscanf>;
/// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
-def TLI_vsnprintf : TargetLibCall_R<vsnprintf>;
+def TLI_vsnprintf : TargetLibCall<vsnprintf>;
/// int vsprintf(char *s, const char *format, va_list ap);
-def TLI_vsprintf : TargetLibCall_R<vsprintf>;
+def TLI_vsprintf : TargetLibCall<vsprintf>;
/// int vsscanf(const char *s, const char *format, va_list arg);
-def TLI_vsscanf : TargetLibCall_R<vsscanf>;
+def TLI_vsscanf : TargetLibCall<vsscanf>;
/// size_t wcslen (const wchar_t* wcs);
-def TLI_wcslen : TargetLibCall_R<wcslen>;
+def TLI_wcslen : TargetLibCall<wcslen>;
/// ssize_t write(int fildes, const void *buf, size_t nbyte);
-def TLI_write : TargetLibCall_R<write>;
+def TLI_write : TargetLibCall<write>;
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 45966053d8a50..06c1fccc6ac37 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -123,19 +123,8 @@ class SystemRuntimeLibrary<RuntimeLibcallPredicate Pred, dag funcList> {
LibcallImpls MemberList = LibcallImpls<funcList>;
}
-// Definitions of library function for TargetLibraryInfo.
-class TargetLibCall;
-
-class TargetLibCall_D<string FuncName, FuncArgType RetType,
- list<FuncArgType> ArgTypes = []>
- : TargetLibCall {
- string LibCallFuncName = FuncName;
- FuncArgType ReturnType = RetType;
- list<FuncArgType> ArgumentTypes = ArgTypes;
-}
-
-class TargetLibCall_R<RuntimeLibcallImpl LibcallImpl>
- : TargetLibCall {
+/// Definition of library function for TargetLibraryInfo.
+class TargetLibCall<RuntimeLibcallImpl LibcallImpl> {
RuntimeLibcallImpl RTLibcallImpl = LibcallImpl;
}
diff --git a/llvm/test/TableGen/TargetLibraryInfo.td b/llvm/test/TableGen/TargetLibraryInfo.td
index 5b8f251a40281..703b178c61e38 100644
--- a/llvm/test/TableGen/TargetLibraryInfo.td
+++ b/llvm/test/TableGen/TargetLibraryInfo.td
@@ -2,14 +2,23 @@
include "llvm/IR/RuntimeLibcallsImpl.td"
-def TLI_cosf : TargetLibCall_D< "cosf", Flt, [Flt]>;
-def TLI_sinf : TargetLibCall_D< "sinf", Flt, [Flt]>;
+def COS_F32 : RuntimeLibcall<Flt, [Flt]>;
+def SIN_F32 : RuntimeLibcall<Flt, [Flt]>;
+def FMAX_F32 : RuntimeLibcall<Floating, [Same, Same]>;
+def PRINTF : RuntimeLibcall<Int, [Ptr, Ellip]>;
+def CABS_F64 : RuntimeLibcall<NoneType, []>;
-def TLI_fmaxf : TargetLibCall_D< "fmaxf", Floating, [Same, Same]>;
+def cosf : RuntimeLibcallImpl<COS_F32>;
+def sinf : RuntimeLibcallImpl<SIN_F32>;
+def fmaxf : RuntimeLibcallImpl<FMAX_F32>;
+def printf : RuntimeLibcallImpl<PRINTF>;
+def cabs : RuntimeLibcallImpl<CABS_F64>;
-def TLI_printf : TargetLibCall_D< "printf", Int, [Ptr, Ellip]>;
-
-def TLI_cabs : TargetLibCall_D< "cabs", ? /* Checked manually. */>;
+def TLI_cosf : TargetLibCall<cosf>;
+def TLI_sinf : TargetLibCall<sinf>;
+def TLI_fmaxf : TargetLibCall<fmaxf>;
+def TLI_printf : TargetLibCall<printf>;
+def TLI_cabs : TargetLibCall<cabs>;
// CHECK: #ifdef GET_TARGET_LIBRARY_INFO_ENUM
// CHECK-NEXT: #undef GET_TARGET_LIBRARY_INFO_ENUM
diff --git a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
index 95e6b07cbfaaa..da1c853c3a774 100644
--- a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
@@ -80,8 +80,7 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoStringTable(
raw_ostream &OS) const {
auto getFuncName = [](const Record *R) -> StringRef {
- if (R->isSubClassOf("TargetLibCall_R"))
- R = R->getValueAsDef("RTLibcallImpl");
+ R = R->getValueAsDef("RTLibcallImpl");
return R->getValueAsString("LibCallFuncName");
};
@@ -140,8 +139,7 @@ void TargetLibraryInfoEmitter::emitTargetLibraryInfoSignatureTable(
using Signature = std::vector<StringRef>;
SequenceToOffsetTable<Signature> SignatureTable("NoFuncArgType");
auto GetSignature = [](const Record *R) -> Signature {
- if (R->isSubClassOf("TargetLibCall_R"))
- R = R->getValueAsDef("RTLibcallImpl")->getValueAsDef("Provides");
+ R = R->getValueAsDef("RTLibcallImpl")->getValueAsDef("Provides");
const auto *Tys = R->getValueAsListInit("ArgumentTypes");
Signature Sig;
Sig.reserve(Tys->size() + 1);
diff --git a/sj_tmp b/sj_tmp
deleted file mode 100644
index bb68ff9fd815f..0000000000000
--- a/sj_tmp
+++ /dev/null
@@ -1,370 +0,0 @@
-diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
-index d74bf31ad1be..598d0f727875 100644
---- a/llvm/include/llvm/Analysis/TargetLibraryInfo.td
-+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
-@@ -243,49 +243,49 @@ def TLI_size_returning_new_aligned_hot_cold
- : TargetLibCall_R<__size_returning_new_aligned_hot_cold>;
-
- /// double __acos_finite(double x);
--def TLI_acos_finite : TargetLibCall_D<"__acos_finite", Dbl, [Dbl]>;
-+def TLI_acos_finite : TargetLibCall_R<__acos_finite>;
-
- /// float __acosf_finite(float x);
--def TLI_acosf_finite : TargetLibCall_D<"__acosf_finite", Flt, [Flt]>;
-+def TLI_acosf_finite : TargetLibCall_R<__acosf_finite>;
-
- /// double __acosh_finite(double x);
--def TLI_acosh_finite : TargetLibCall_D<"__acosh_finite", Dbl, [Dbl]>;
-+def TLI_acosh_finite : TargetLibCall_R<__acosh_finite>;
-
- /// float __acoshf_finite(float x);
--def TLI_acoshf_finite : TargetLibCall_D<"__acoshf_finite", Flt, [Flt]>;
-+def TLI_acoshf_finite : TargetLibCall_R<__acoshf_finite>;
-
- /// long double __acoshl_finite(long double x);
--def TLI_acoshl_finite : TargetLibCall_D<"__acoshl_finite", LDbl, [LDbl]>;
-+def TLI_acoshl_finite : TargetLibCall_R<__acoshl_finite>;
-
- /// long double __acosl_finite(long double x);
--def TLI_acosl_finite : TargetLibCall_D<"__acosl_finite", LDbl, [LDbl]>;
-+def TLI_acosl_finite : TargetLibCall_R<__acosl_finite>;
-
- /// double __asin_finite(double x);
--def TLI_asin_finite : TargetLibCall_D<"__asin_finite", Dbl, [Dbl]>;
-+def TLI_asin_finite : TargetLibCall_R<__asin_finite>;
-
- /// float __asinf_finite(float x);
--def TLI_asinf_finite : TargetLibCall_D<"__asinf_finite", Flt, [Flt]>;
-+def TLI_asinf_finite : TargetLibCall_R<__asinf_finite>;
-
- /// long double __asinl_finite(long double x);
--def TLI_asinl_finite : TargetLibCall_D<"__asinl_finite", LDbl, [LDbl]>;
-+def TLI_asinl_finite : TargetLibCall_R<__asinl_finite>;
-
- /// double atan2_finite(double y, double x);
--def TLI_atan2_finite : TargetLibCall_D<"__atan2_finite", Dbl, [Dbl, Dbl]>;
-+def TLI_atan2_finite : TargetLibCall_R<__atan2_finite>;
-
- /// float atan2f_finite(float y, float x);
--def TLI_atan2f_finite : TargetLibCall_D<"__atan2f_finite", Flt, [Flt, Flt]>;
-+def TLI_atan2f_finite : TargetLibCall_R<__atan2f_finite>;
-
- /// long double atan2l_finite(long double y, long double x);
--def TLI_atan2l_finite : TargetLibCall_D<"__atan2l_finite", LDbl, [LDbl, LDbl]>;
-+def TLI_atan2l_finite : TargetLibCall_R<__atan2l_finite>;
-
- /// double __atanh_finite(double x);
--def TLI_atanh_finite : TargetLibCall_D<"__atanh_finite", Dbl, [Dbl]>;
-+def TLI_atanh_finite : TargetLibCall_R<__atanh_finite>;
-
- /// float __atanhf_finite(float x);
--def TLI_atanhf_finite : TargetLibCall_D<"__atanhf_finite", Flt, [Flt]>;
-+def TLI_atanhf_finite : TargetLibCall_R<__atanhf_finite>;
-
- /// long double __atanhl_finite(long double x);
--def TLI_atanhl_finite : TargetLibCall_D<"__atanhl_finite", LDbl, [LDbl]>;
-+def TLI_atanhl_finite : TargetLibCall_R<__atanhl_finite>;
-
- /// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
- def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
-@@ -294,19 +294,19 @@ def TLI_atomic_load : TargetLibCall_R<__atomic_load>;
- def TLI_atomic_store : TargetLibCall_R<__atomic_store>;
-
- /// double __cosh_finite(double x);
--def TLI_cosh_finite : TargetLibCall_D<"__cosh_finite", Dbl, [Dbl]>;
-+def TLI_cosh_finite : TargetLibCall_R<__cosh_finite>;
-
- /// float __coshf_finite(float x);
--def TLI_coshf_finite : TargetLibCall_D<"__coshf_finite", Flt, [Flt]>;
-+def TLI_coshf_finite : TargetLibCall_R<__coshf_finite>;
-
- /// long double __coshl_finite(long double x);
--def TLI_coshl_finite : TargetLibCall_D<"__coshl_finite", LDbl, [LDbl]>;
-+def TLI_coshl_finite : TargetLibCall_R<__coshl_finite>;
-
- /// double __cospi(double x);
--def TLI_cospi : TargetLibCall_D<"__cospi", Dbl, [Dbl]>;
-+def TLI_cospi : TargetLibCall_R<__cospi>;
-
- /// float __cospif(float x);
--def TLI_cospif : TargetLibCall_D<"__cospif", Flt, [Flt]>;
-+def TLI_cospif : TargetLibCall_R<__cospif>;
-
- /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
- def TLI_cxa_atexit : TargetLibCall_R<__cxa_atexit>;
-@@ -321,7 +321,7 @@ def TLI_abort : TargetLibCall_R<abort>;
- def TLI_exit : TargetLibCall_R<exit>;
-
- /// void _Exit(int)
--def TLI_Exit : TargetLibCall_D<"_Exit", Void, [Int]>;
-+def TLI_Exit : TargetLibCall_R<_Exit>;
-
- /// void std::terminate();
- def TLI_terminate : TargetLibCall_R<_ZSt9terminatev>;
-@@ -340,14 +340,14 @@ def TLI_cxa_guard_acquire : TargetLibCall_R<__cxa_guard_acquire>;
- def TLI_cxa_guard_release : TargetLibCall_R<__cxa_guard_release>;
-
- /// double __exp10_finite(double x);
--def TLI_exp10_finite : TargetLibCall_D<"__exp10_finite", Dbl, [Dbl]>;
-+def TLI_exp10_finite : TargetLibCall_R<__exp10_finite>;
-
-
- /// float __exp10f_finite(float x);
--def TLI_exp10f_finite : TargetLibCall_D<"__exp10f_finite", Flt, [Flt]>;
-+def TLI_exp10f_finite : TargetLibCall_R<__exp10f_finite>;
-
- /// long double __exp10l_finite(long double x);
--def TLI_exp10l_finite : TargetLibCall_D<"__exp10l_finite", LDbl, [LDbl]>;
-+def TLI_exp10l_finite : TargetLibCall_R<__exp10l_finite>;
-
- /// double __exp2_finite(double x);
- def TLI_exp2_finite : TargetLibCall_R<__exp2_finite>;
-@@ -417,7 +417,7 @@ def TLI_mempcpy_chk : TargetLibCall_R<__mempcpy_chk>;
- def TLI_memset_chk : TargetLibCall_R<__memset_chk>;
-
- // int __nvvm_reflect(const char *)
--def TLI_nvvm_reflect : TargetLibCall_D<"__nvvm_reflect", Int, [Ptr]>;
-+def TLI_nvvm_reflect : TargetLibCall_R<__nvvm_reflect>;
-
- /// double __pow_finite(double x, double y);
- def TLI_pow_finite : TargetLibCall_R<__pow_finite>;
-@@ -429,27 +429,25 @@ def TLI_powf_finite : TargetLibCall_R<__powf_finite>;
- def TLI_powl_finite : TargetLibCall_R<__powl_finite_f128>;
-
- /// double __sincospi_stret(double x);
--def TLI_sincospi_stret
-- : TargetLibCall_D<"__sincospi_stret", ? /* Checked manually. */>;
-+def TLI_sincospi_stret : TargetLibCall_R<__sincospi_stret>;
-
- /// float __sincospif_stret(float x);
--def TLI_sincospif_stret
-- : TargetLibCall_D<"__sincospif_stret", ? /* Checked manually. */>;
-+def TLI_sincospif_stret : TargetLibCall_R<__sincospif_stret>;
-
- /// double __sinh_finite(double x);
--def TLI_sinh_finite : TargetLibCall_D<"__sinh_finite", Dbl, [Dbl]>;
-+def TLI_sinh_finite : TargetLibCall_R<__sinh_finite>;
-
- /// float _sinhf_finite(float x);
--def TLI_sinhf_finite : TargetLibCall_D<"__sinhf_finite", Flt, [Flt]>;
-+def TLI_sinhf_finite : TargetLibCall_R<__sinhf_finite>;
-
- /// long double __sinhl_finite(long double x);
--def TLI_sinhl_finite : TargetLibCall_D<"__sinhl_finite", LDbl, [LDbl]>;
-+def TLI_sinhl_finite : TargetLibCall_R<__sinhl_finite>;
-
- /// double __sinpi(double x);
--def TLI_sinpi : TargetLibCall_D<"__sinpi", Dbl, [Dbl]>;
-+def TLI_sinpi : TargetLibCall_R<__sinpi>;
-
- /// float __sinpif(float x);
--def TLI_sinpif : TargetLibCall_D<"__sinpif", Flt, [Flt]>;
-+def TLI_sinpif : TargetLibCall_R<__sinpif>;
-
- /// int __small_fprintf(FILE *stream, const char *format, ...);
- def TLI_small_fprintf : TargetLibCall_R<__small_fprintf>;
-@@ -469,13 +467,13 @@ def TLI_snprintf_chk : TargetLibCall_R<__snprintf_chk>;
- def TLI_sprintf_chk : TargetLibCall_R<__sprintf_chk>;
-
- /// double __sqrt_finite(double x);
--def TLI_sqrt_finite : TargetLibCall_D<"__sqrt_finite", Dbl, [Dbl]>;
-+def TLI_sqrt_finite : TargetLibCall_R<__sqrt_finite>;
-
- /// float __sqrt_finite(float x);
--def TLI_sqrtf_finite : TargetLibCall_D<"__sqrtf_finite", Flt, [Flt]>;
-+def TLI_sqrtf_finite : TargetLibCall_R<__sqrtf_finite>;
-
- /// long double __sqrt_finite(long double x);
--def TLI_sqrtl_finite : TargetLibCall_D<"__sqrtl_finite", LDbl, [LDbl]>;
-+def TLI_sqrtl_finite : TargetLibCall_R<__sqrtl_finite>;
-
- /// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
- def TLI_stpcpy_chk : TargetLibCall_R<__stpcpy_chk>;
-@@ -536,13 +534,13 @@ def TLI_acos : TargetLibCall_R<acos>;
- def TLI_acosf : TargetLibCall_R<acosf>;
-
- /// double acosh(double x);
--def TLI_acosh : TargetLibCall_D<"acosh", Dbl, [Dbl]>;
-+def TLI_acosh : TargetLibCall_R<acosh>;
-
- /// float acoshf(float x);
--def TLI_acoshf : TargetLibCall_D<"acoshf", Flt, [Flt]>;
-+def TLI_acoshf : TargetLibCall_R<acoshf>;
-
- /// long double acoshl(long double x);
--def TLI_acoshl : TargetLibCall_D<"acoshl", LDbl, [LDbl]>;
-+def TLI_acoshl : TargetLibCall_R<acoshl>;
-
- /// long double acosl(long double x);
- def TLI_acosl : TargetLibCall_R<acosl_f128>;
-@@ -557,13 +555,13 @@ def TLI_asin : TargetLibCall_R<asin>;
- def TLI_asinf : TargetLibCall_R<asinf>;
-
- /// double asinh(double x);
--def TLI_asinh : TargetLibCall_D<"asinh", Dbl, [Dbl]>;
-+def TLI_asinh : TargetLibCall_R<asinh>;
-
- /// float asinhf(float x);
--def TLI_asinhf : TargetLibCall_D<"asinhf", Flt, [Flt]>;
-+def TLI_asinhf : TargetLibCall_R<asinhf>;
-
- /// long double asinhl(long double x);
--def TLI_asinhl : TargetLibCall_D<"asinhl", LDbl, [LDbl]>;
-+def TLI_asinhl : TargetLibCall_R<asinhl>;
-
- /// long double asinl(long double x);
- def TLI_asinl : TargetLibCall_R<asinl_f128>;
-@@ -584,14 +582,14 @@ def TLI_atan2l : TargetLibCall_R<atan2l_f128>;
- def TLI_atanf : TargetLibCall_R<atanf>;
-
- /// double atanh(double x);
--def TLI_atanh : TargetLibCall_D<"atanh", Dbl, [Dbl]>;
-+def TLI_atanh : TargetLibCall_R<atanh>;
-
-
- /// float atanhf(float x);
--def TLI_atanhf : TargetLibCall_D<"atanhf", Flt, [Flt]>;
-+def TLI_atanhf : TargetLibCall_R<atanhf>;
-
- /// long double atanhl(long double x);
--def TLI_atanhl : TargetLibCall_D<"atanhl", LDbl, [LDbl]>;
-+def TLI_atanhl : TargetLibCall_R<atanhl>;
-
- /// long double atanl(long double x);
- def TLI_atanl : TargetLibCall_R<atanl_f128>;
-@@ -690,14 +688,14 @@ def TLI_cosl : TargetLibCall_R<cosl_f128>;
- def TLI_ctermid : TargetLibCall_R<ctermid>;
-
- /// double erf(double x);
--def TLI_erf : TargetLibCall_D<"erf", Dbl, [Dbl]>;
-+def TLI_erf : TargetLibCall_R<erf>;
-
-
- /// float erff(float x);
--def TLI_erff : TargetLibCall_D<"erff", Flt, [Flt]>;
-+def TLI_erff : TargetLibCall_R<erff>;
-
- /// long double erfl(long double x);
--def TLI_erfl : TargetLibCall_D<"erfl", LDbl, [LDbl]>;
-+def TLI_erfl : TargetLibCall_R<erfl>;
-
- /// double tgamma(double x);
- def TLI_tgamma : TargetLibCall_R<tgamma>;
-@@ -721,7 +719,7 @@ def TLI_execlp : TargetLibCall_R<execlp>;
- def TLI_execv : TargetLibCall_R<execv>;
-
- /// int execvP(const char *file, const char *search_path, char *const argv[]);
--def TLI_execvP : TargetLibCall_D<"execvP", Int, [Ptr, Ptr, Ptr]>;
-+def TLI_execvP : TargetLibCall_R<execvP>;
-
- /// int execve(const char *filename, char *const argv], [char *const envp[]);
- def TLI_execve : TargetLibCall_R<execve>;
-@@ -760,22 +758,22 @@ def TLI_expf : TargetLibCall_R<expf>;
- def TLI_expl : TargetLibCall_R<expl_f128>;
-
- /// double expm1(double x);
--def TLI_expm1 : TargetLibCall_D<"expm1", Dbl, [Dbl]>;
-+def TLI_expm1 : TargetLibCall_R<expm1>;
-
- /// float expm1f(float x);
--def TLI_expm1f : TargetLibCall_D<"expm1f", Flt, [Flt]>;
-+def TLI_expm1f : TargetLibCall_R<expm1f>;
-
- /// long double expm1l(long double x);
--def TLI_expm1l : TargetLibCall_D<"expm1l", LDbl, [LDbl]>;
-+def TLI_expm1l : TargetLibCall_R<expm1l>;
-
- /// double fabs(double x);
--def TLI_fabs : TargetLibCall_D<"fabs", Dbl, [Dbl]>;
-+def TLI_fabs : TargetLibCall_R<fabs>;
-
- /// float fabsf(float x);
--def TLI_fabsf : TargetLibCall_D<"fabsf", Flt, [Flt]>;
-+def TLI_fabsf : TargetLibCall_R<fabsf>;
-
- /// long double fabsl(long double x);
--def TLI_fabsl : TargetLibCall_D<"fabsl", LDbl, [LDbl]>;
-+def TLI_fabsl : TargetLibCall_R<fabsl>;
-
- /// int fclose(FILE *stream);
- def TLI_fclose : TargetLibCall_R<fclose>;
-@@ -1022,13 +1020,13 @@ def TLI_htonl : TargetLibCall_R<htonl>;
- def TLI_htons : TargetLibCall_R<htons>;
-
- /// double hypot(double x, double y);
--def TLI_hypot : TargetLibCall_D<"hypot", Dbl, [Dbl, Dbl]>;
-+def TLI_hypot : TargetLibCall_R<hypot>;
-
- /// float hypotf(float x, float y);
--def TLI_hypotf : TargetLibCall_D<"hypotf", Flt, [Flt, Flt]>;
-+def TLI_hypotf : TargetLibCall_R<hypotf>;
-
- /// long double hypotl(long double x, long double y);
--def TLI_hypotl : TargetLibCall_D<"hypotl", LDbl, [LDbl, LDbl]>;
-+def TLI_hypotl : TargetLibCall_R<hypotl>;
-
- /// int iprintf(const char *format, ...);
- def TLI_iprintf : TargetLibCall_R<iprintf>;
-@@ -1070,13 +1068,13 @@ def TLI_log10f : TargetLibCall_R<log10f>;
- def TLI_log10l : TargetLibCall_R<log10l_f128>;
-
- /// double log1p(double x);
--def TLI_log1p : TargetLibCall_D<"log1p", Dbl, [Dbl]>;
-+def TLI_log1p : TargetLibCall_R<log1p>;
-
- /// float log1pf(float x);
--def TLI_log1pf : TargetLibCall_D<"log1pf", Flt, [Flt]>;
-+def TLI_log1pf : TargetLibCall_R<log1pf>;
-
- /// long double log1pl(long double x);
--def TLI_log1pl : TargetLibCall_D<"log1pl", LDbl, [LDbl]>;
-+def TLI_log1pl : TargetLibCall_R<log1pl>;
-
- /// double log2(double x);
- def TLI_log2 : TargetLibCall_R<log2>;
-@@ -1088,22 +1086,22 @@ def TLI_log2f : TargetLibCall_R<log2f>;
- def TLI_log2l : TargetLibCall_R<log2l_f128>;
-
- /// int ilogb(double x);
--def TLI_ilogb : TargetLibCall_D<"ilogb", Int, [Dbl]>;
-+def TLI_ilogb : TargetLibCall_R<ilogb>;
-
- /// int ilogbf(float x);
--def TLI_ilogbf : TargetLibCall_D<"ilogbf", Int, [Flt]>;
-+def TLI_ilogbf : TargetLibCall_R<ilogbf>;
-
- /// int ilogbl(long double x);
--def TLI_ilogbl : TargetLibCall_D<"ilogbl", Int, [LDbl]>;
-+def TLI_ilogbl : TargetLibCall_R<ilogbl>;
-
- /// double logb(double x);
--def TLI_logb : TargetLibCall_D<"logb", Dbl, [Dbl]>;
-+def TLI_logb : TargetLibCall_R<logb>;
-
- /// float logbf(float x);
--def TLI_logbf : TargetLibCall_D<"logbf", Flt, [Flt]>;
-+def TLI_logbf : TargetLibCall_R<logbf>;
-
- /// long double logbl(long double x);
--def TLI_logbl : TargetLibCall_D<"logbl", LDbl, [LDbl]>;
-+def TLI_logbl : TargetLibCall_R<logbl>;
-
- /// float logf(float x);
- def TLI_logf : TargetLibCall_R<logf>;
-@@ -1190,13 +1188,13 @@ def TLI_nearbyintf : TargetLibCall_R<nearbyintf>;
- def TLI_nearbyintl : TargetLibCall_R<nearbyintl_f128>;
-
- /// double nextafter(double x, double y);
--def TLI_nextafter : TargetLibCall_D< "nextafter", Dbl, [Dbl, Dbl]>;
-+def TLI_nextafter : TargetLibCall_R<nextafter>;
-
- /// float nextafterf(float x, float y);
--def TLI_nextafterf : TargetLibCall_D< "nextafterf", Flt, [Flt, Flt]>;
-+def TLI_nextafterf : TargetLibCall_R<nextafterf>;
-
- /// long double nextafterl(long double x, long double y);
--def TLI_nextafterl : TargetLibCall_D< "nextafterl", LDbl, [LDbl, LDbl]>;
-+def TLI_nextafterl : TargetLibCall_R<nextafterl>;
-
- /// double nexttoward(double x, long double y);
- def TLI_nexttoward : TargetLibCall_R<nexttoward>;
More information about the llvm-commits
mailing list