[llvm-branch-commits] [llvm] TableGen: Add runtime libcall backend (PR #144972)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Jun 19 19:50:29 PDT 2025
https://github.com/arsenm created https://github.com/llvm/llvm-project/pull/144972
Replace RuntimeLibcalls.def with a tablegenerated version. This
is in preparation for splitting RuntimeLibcalls into two components.
For now match the existing functionality.
>From 819d345c57e801141dcae85eb04151663beece1f Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Thu, 5 Jun 2025 19:52:36 +0900
Subject: [PATCH] TableGen: Add runtime libcall backend
Replace RuntimeLibcalls.def with a tablegenerated version. This
is in preparation for splitting RuntimeLibcalls into two components.
For now match the existing functionality. In the future the selection
of calls can also be generated.
---
llvm/include/llvm/IR/CMakeLists.txt | 3 +
llvm/include/llvm/IR/RuntimeLibcalls.def | 701 -----------
llvm/include/llvm/IR/RuntimeLibcalls.h | 36 +-
llvm/include/llvm/IR/RuntimeLibcalls.td | 1054 +++++++++++++++++
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 32 +
llvm/include/module.modulemap | 1 -
llvm/lib/IR/RuntimeLibcalls.cpp | 108 +-
llvm/lib/IR/ZOSLibcallNames.def | 100 --
llvm/lib/Object/IRSymtab.cpp | 2 +-
llvm/test/TableGen/RuntimeLibcallEmitter.td | 40 +
llvm/utils/TableGen/Basic/CMakeLists.txt | 1 +
.../TableGen/Basic/RuntimeLibcallsEmitter.cpp | 305 +++++
.../llvm/utils/TableGen/Basic/BUILD.gn | 1 +
13 files changed, 1488 insertions(+), 896 deletions(-)
delete mode 100644 llvm/include/llvm/IR/RuntimeLibcalls.def
create mode 100644 llvm/include/llvm/IR/RuntimeLibcalls.td
create mode 100644 llvm/include/llvm/IR/RuntimeLibcallsImpl.td
delete mode 100644 llvm/lib/IR/ZOSLibcallNames.def
create mode 100644 llvm/test/TableGen/RuntimeLibcallEmitter.td
create mode 100644 llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
diff --git a/llvm/include/llvm/IR/CMakeLists.txt b/llvm/include/llvm/IR/CMakeLists.txt
index 468d663796ed4..c5c4cc4d21b84 100644
--- a/llvm/include/llvm/IR/CMakeLists.txt
+++ b/llvm/include/llvm/IR/CMakeLists.txt
@@ -1,6 +1,9 @@
set(LLVM_TARGET_DEFINITIONS Attributes.td)
tablegen(LLVM Attributes.inc -gen-attrs)
+set(LLVM_TARGET_DEFINITIONS RuntimeLibcalls.td)
+tablegen(LLVM RuntimeLibcalls.inc -gen-runtime-libcalls)
+
set(LLVM_TARGET_DEFINITIONS Intrinsics.td)
tablegen(LLVM IntrinsicImpl.inc -gen-intrinsic-impl)
tablegen(LLVM IntrinsicEnums.inc -gen-intrinsic-enums)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.def b/llvm/include/llvm/IR/RuntimeLibcalls.def
deleted file mode 100644
index 247643525ff48..0000000000000
--- a/llvm/include/llvm/IR/RuntimeLibcalls.def
+++ /dev/null
@@ -1,701 +0,0 @@
-//===-- llvm/RuntimeLibcalls.def - File that describes libcalls -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines all of the runtime library calls the backend can emit.
-// The various long double types cannot be merged, because 80-bit library
-// functions use "xf" and 128-bit use "tf".
-//
-// When adding PPCF128 functions here, note that their names generally need
-// to be overridden for Darwin with the xxx$LDBL128 form. See
-// PPCISelLowering.cpp.
-//
-//===----------------------------------------------------------------------===//
-
-// NOTE: NO INCLUDE GUARD DESIRED!
-
-// Provide definitions of macros so that users of this file do not have to
-// define everything to use it...
-
-// Declare the enumerator for each libcall, along with its default name. Some
-// libcalls have different names on particular OSes or architectures. These
-// are set in InitLibcalls() in TargetLoweringBase.cpp and/or by targets
-// using TargetLoweringBase::setLibcallName()
-#ifndef HANDLE_LIBCALL
-#error "HANDLE_LIBCALL must be defined"
-#endif
-
-// Integer
-HANDLE_LIBCALL(SHL_I16, "__ashlhi3")
-HANDLE_LIBCALL(SHL_I32, "__ashlsi3")
-HANDLE_LIBCALL(SHL_I64, "__ashldi3")
-HANDLE_LIBCALL(SHL_I128, "__ashlti3")
-HANDLE_LIBCALL(SRL_I16, "__lshrhi3")
-HANDLE_LIBCALL(SRL_I32, "__lshrsi3")
-HANDLE_LIBCALL(SRL_I64, "__lshrdi3")
-HANDLE_LIBCALL(SRL_I128, "__lshrti3")
-HANDLE_LIBCALL(SRA_I16, "__ashrhi3")
-HANDLE_LIBCALL(SRA_I32, "__ashrsi3")
-HANDLE_LIBCALL(SRA_I64, "__ashrdi3")
-HANDLE_LIBCALL(SRA_I128, "__ashrti3")
-HANDLE_LIBCALL(MUL_I8, "__mulqi3")
-HANDLE_LIBCALL(MUL_I16, "__mulhi3")
-HANDLE_LIBCALL(MUL_I32, "__mulsi3")
-HANDLE_LIBCALL(MUL_I64, "__muldi3")
-HANDLE_LIBCALL(MUL_I128, "__multi3")
-HANDLE_LIBCALL(MULO_I32, "__mulosi4")
-HANDLE_LIBCALL(MULO_I64, "__mulodi4")
-HANDLE_LIBCALL(MULO_I128, "__muloti4")
-HANDLE_LIBCALL(SDIV_I8, "__divqi3")
-HANDLE_LIBCALL(SDIV_I16, "__divhi3")
-HANDLE_LIBCALL(SDIV_I32, "__divsi3")
-HANDLE_LIBCALL(SDIV_I64, "__divdi3")
-HANDLE_LIBCALL(SDIV_I128, "__divti3")
-HANDLE_LIBCALL(UDIV_I8, "__udivqi3")
-HANDLE_LIBCALL(UDIV_I16, "__udivhi3")
-HANDLE_LIBCALL(UDIV_I32, "__udivsi3")
-HANDLE_LIBCALL(UDIV_I64, "__udivdi3")
-HANDLE_LIBCALL(UDIV_I128, "__udivti3")
-HANDLE_LIBCALL(SREM_I8, "__modqi3")
-HANDLE_LIBCALL(SREM_I16, "__modhi3")
-HANDLE_LIBCALL(SREM_I32, "__modsi3")
-HANDLE_LIBCALL(SREM_I64, "__moddi3")
-HANDLE_LIBCALL(SREM_I128, "__modti3")
-HANDLE_LIBCALL(UREM_I8, "__umodqi3")
-HANDLE_LIBCALL(UREM_I16, "__umodhi3")
-HANDLE_LIBCALL(UREM_I32, "__umodsi3")
-HANDLE_LIBCALL(UREM_I64, "__umoddi3")
-HANDLE_LIBCALL(UREM_I128, "__umodti3")
-HANDLE_LIBCALL(SDIVREM_I8, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SDIVREM_I16, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SDIVREM_I32, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SDIVREM_I64, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SDIVREM_I128, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(UDIVREM_I8, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(UDIVREM_I16, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(UDIVREM_I32, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(UDIVREM_I64, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(UDIVREM_I128, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(NEG_I32, "__negsi2")
-HANDLE_LIBCALL(NEG_I64, "__negdi2")
-HANDLE_LIBCALL(CTLZ_I32, "__clzsi2")
-HANDLE_LIBCALL(CTLZ_I64, "__clzdi2")
-HANDLE_LIBCALL(CTLZ_I128, "__clzti2")
-HANDLE_LIBCALL(CTPOP_I32, "__popcountsi2")
-HANDLE_LIBCALL(CTPOP_I64, "__popcountdi2")
-HANDLE_LIBCALL(CTPOP_I128, "__popcountti2")
-
-// Floating-point
-HANDLE_LIBCALL(ADD_F32, "__addsf3")
-HANDLE_LIBCALL(ADD_F64, "__adddf3")
-HANDLE_LIBCALL(ADD_F80, "__addxf3")
-HANDLE_LIBCALL(ADD_F128, "__addtf3")
-HANDLE_LIBCALL(ADD_PPCF128, "__gcc_qadd")
-HANDLE_LIBCALL(SUB_F32, "__subsf3")
-HANDLE_LIBCALL(SUB_F64, "__subdf3")
-HANDLE_LIBCALL(SUB_F80, "__subxf3")
-HANDLE_LIBCALL(SUB_F128, "__subtf3")
-HANDLE_LIBCALL(SUB_PPCF128, "__gcc_qsub")
-HANDLE_LIBCALL(MUL_F32, "__mulsf3")
-HANDLE_LIBCALL(MUL_F64, "__muldf3")
-HANDLE_LIBCALL(MUL_F80, "__mulxf3")
-HANDLE_LIBCALL(MUL_F128, "__multf3")
-HANDLE_LIBCALL(MUL_PPCF128, "__gcc_qmul")
-HANDLE_LIBCALL(DIV_F32, "__divsf3")
-HANDLE_LIBCALL(DIV_F64, "__divdf3")
-HANDLE_LIBCALL(DIV_F80, "__divxf3")
-HANDLE_LIBCALL(DIV_F128, "__divtf3")
-HANDLE_LIBCALL(DIV_PPCF128, "__gcc_qdiv")
-HANDLE_LIBCALL(REM_F32, "fmodf")
-HANDLE_LIBCALL(REM_F64, "fmod")
-HANDLE_LIBCALL(REM_F80, "fmodl")
-HANDLE_LIBCALL(REM_F128, "fmodl")
-HANDLE_LIBCALL(REM_PPCF128, "fmodl")
-HANDLE_LIBCALL(FMA_F32, "fmaf")
-HANDLE_LIBCALL(FMA_F64, "fma")
-HANDLE_LIBCALL(FMA_F80, "fmal")
-HANDLE_LIBCALL(FMA_F128, "fmal")
-HANDLE_LIBCALL(FMA_PPCF128, "fmal")
-HANDLE_LIBCALL(POWI_F32, "__powisf2")
-HANDLE_LIBCALL(POWI_F64, "__powidf2")
-HANDLE_LIBCALL(POWI_F80, "__powixf2")
-HANDLE_LIBCALL(POWI_F128, "__powitf2")
-HANDLE_LIBCALL(POWI_PPCF128, "__powitf2")
-HANDLE_LIBCALL(SQRT_F32, "sqrtf")
-HANDLE_LIBCALL(SQRT_F64, "sqrt")
-HANDLE_LIBCALL(SQRT_F80, "sqrtl")
-HANDLE_LIBCALL(SQRT_F128, "sqrtl")
-HANDLE_LIBCALL(SQRT_PPCF128, "sqrtl")
-HANDLE_LIBCALL(CBRT_F32, "cbrtf")
-HANDLE_LIBCALL(CBRT_F64, "cbrt")
-HANDLE_LIBCALL(CBRT_F80, "cbrtl")
-HANDLE_LIBCALL(CBRT_F128, "cbrtl")
-HANDLE_LIBCALL(CBRT_PPCF128, "cbrtl")
-HANDLE_LIBCALL(LOG_F32, "logf")
-HANDLE_LIBCALL(LOG_F64, "log")
-HANDLE_LIBCALL(LOG_F80, "logl")
-HANDLE_LIBCALL(LOG_F128, "logl")
-HANDLE_LIBCALL(LOG_PPCF128, "logl")
-HANDLE_LIBCALL(LOG_FINITE_F32, "__logf_finite")
-HANDLE_LIBCALL(LOG_FINITE_F64, "__log_finite")
-HANDLE_LIBCALL(LOG_FINITE_F80, "__logl_finite")
-HANDLE_LIBCALL(LOG_FINITE_F128, "__logl_finite")
-HANDLE_LIBCALL(LOG_FINITE_PPCF128, "__logl_finite")
-HANDLE_LIBCALL(LOG2_F32, "log2f")
-HANDLE_LIBCALL(LOG2_F64, "log2")
-HANDLE_LIBCALL(LOG2_F80, "log2l")
-HANDLE_LIBCALL(LOG2_F128, "log2l")
-HANDLE_LIBCALL(LOG2_PPCF128, "log2l")
-HANDLE_LIBCALL(LOG2_FINITE_F32, "__log2f_finite")
-HANDLE_LIBCALL(LOG2_FINITE_F64, "__log2_finite")
-HANDLE_LIBCALL(LOG2_FINITE_F80, "__log2l_finite")
-HANDLE_LIBCALL(LOG2_FINITE_F128, "__log2l_finite")
-HANDLE_LIBCALL(LOG2_FINITE_PPCF128, "__log2l_finite")
-HANDLE_LIBCALL(LOG10_F32, "log10f")
-HANDLE_LIBCALL(LOG10_F64, "log10")
-HANDLE_LIBCALL(LOG10_F80, "log10l")
-HANDLE_LIBCALL(LOG10_F128, "log10l")
-HANDLE_LIBCALL(LOG10_PPCF128, "log10l")
-HANDLE_LIBCALL(LOG10_FINITE_F32, "__log10f_finite")
-HANDLE_LIBCALL(LOG10_FINITE_F64, "__log10_finite")
-HANDLE_LIBCALL(LOG10_FINITE_F80, "__log10l_finite")
-HANDLE_LIBCALL(LOG10_FINITE_F128, "__log10l_finite")
-HANDLE_LIBCALL(LOG10_FINITE_PPCF128, "__log10l_finite")
-HANDLE_LIBCALL(EXP_F32, "expf")
-HANDLE_LIBCALL(EXP_F64, "exp")
-HANDLE_LIBCALL(EXP_F80, "expl")
-HANDLE_LIBCALL(EXP_F128, "expl")
-HANDLE_LIBCALL(EXP_PPCF128, "expl")
-HANDLE_LIBCALL(EXP_FINITE_F32, "__expf_finite")
-HANDLE_LIBCALL(EXP_FINITE_F64, "__exp_finite")
-HANDLE_LIBCALL(EXP_FINITE_F80, "__expl_finite")
-HANDLE_LIBCALL(EXP_FINITE_F128, "__expl_finite")
-HANDLE_LIBCALL(EXP_FINITE_PPCF128, "__expl_finite")
-HANDLE_LIBCALL(EXP2_F32, "exp2f")
-HANDLE_LIBCALL(EXP2_F64, "exp2")
-HANDLE_LIBCALL(EXP2_F80, "exp2l")
-HANDLE_LIBCALL(EXP2_F128, "exp2l")
-HANDLE_LIBCALL(EXP2_PPCF128, "exp2l")
-HANDLE_LIBCALL(EXP2_FINITE_F32, "__exp2f_finite")
-HANDLE_LIBCALL(EXP2_FINITE_F64, "__exp2_finite")
-HANDLE_LIBCALL(EXP2_FINITE_F80, "__exp2l_finite")
-HANDLE_LIBCALL(EXP2_FINITE_F128, "__exp2l_finite")
-HANDLE_LIBCALL(EXP2_FINITE_PPCF128, "__exp2l_finite")
-HANDLE_LIBCALL(EXP10_F32, "exp10f")
-HANDLE_LIBCALL(EXP10_F64, "exp10")
-HANDLE_LIBCALL(EXP10_F80, "exp10l")
-HANDLE_LIBCALL(EXP10_F128, "exp10l")
-HANDLE_LIBCALL(EXP10_PPCF128, "exp10l")
-HANDLE_LIBCALL(SIN_F32, "sinf")
-HANDLE_LIBCALL(SIN_F64, "sin")
-HANDLE_LIBCALL(SIN_F80, "sinl")
-HANDLE_LIBCALL(SIN_F128, "sinl")
-HANDLE_LIBCALL(SIN_PPCF128, "sinl")
-HANDLE_LIBCALL(COS_F32, "cosf")
-HANDLE_LIBCALL(COS_F64, "cos")
-HANDLE_LIBCALL(COS_F80, "cosl")
-HANDLE_LIBCALL(COS_F128, "cosl")
-HANDLE_LIBCALL(COS_PPCF128, "cosl")
-HANDLE_LIBCALL(TAN_F32, "tanf")
-HANDLE_LIBCALL(TAN_F64, "tan")
-HANDLE_LIBCALL(TAN_F80, "tanl")
-HANDLE_LIBCALL(TAN_F128,"tanl")
-HANDLE_LIBCALL(TAN_PPCF128, "tanl")
-HANDLE_LIBCALL(SINH_F32, "sinhf")
-HANDLE_LIBCALL(SINH_F64, "sinh")
-HANDLE_LIBCALL(SINH_F80, "sinhl")
-HANDLE_LIBCALL(SINH_F128, "sinhl")
-HANDLE_LIBCALL(SINH_PPCF128, "sinhl")
-HANDLE_LIBCALL(COSH_F32, "coshf")
-HANDLE_LIBCALL(COSH_F64, "cosh")
-HANDLE_LIBCALL(COSH_F80, "coshl")
-HANDLE_LIBCALL(COSH_F128, "coshl")
-HANDLE_LIBCALL(COSH_PPCF128, "coshl")
-HANDLE_LIBCALL(TANH_F32, "tanhf")
-HANDLE_LIBCALL(TANH_F64, "tanh")
-HANDLE_LIBCALL(TANH_F80, "tanhl")
-HANDLE_LIBCALL(TANH_F128,"tanhl")
-HANDLE_LIBCALL(TANH_PPCF128, "tanhl")
-HANDLE_LIBCALL(ASIN_F32, "asinf")
-HANDLE_LIBCALL(ASIN_F64, "asin")
-HANDLE_LIBCALL(ASIN_F80, "asinl")
-HANDLE_LIBCALL(ASIN_F128, "asinl")
-HANDLE_LIBCALL(ASIN_PPCF128, "asinl")
-HANDLE_LIBCALL(ACOS_F32, "acosf")
-HANDLE_LIBCALL(ACOS_F64, "acos")
-HANDLE_LIBCALL(ACOS_F80, "acosl")
-HANDLE_LIBCALL(ACOS_F128, "acosl")
-HANDLE_LIBCALL(ACOS_PPCF128, "acosl")
-HANDLE_LIBCALL(ATAN_F32, "atanf")
-HANDLE_LIBCALL(ATAN_F64, "atan")
-HANDLE_LIBCALL(ATAN_F80, "atanl")
-HANDLE_LIBCALL(ATAN_F128,"atanl")
-HANDLE_LIBCALL(ATAN_PPCF128, "atanl")
-HANDLE_LIBCALL(ATAN2_F32, "atan2f")
-HANDLE_LIBCALL(ATAN2_F64, "atan2")
-HANDLE_LIBCALL(ATAN2_F80, "atan2l")
-HANDLE_LIBCALL(ATAN2_F128,"atan2l")
-HANDLE_LIBCALL(ATAN2_PPCF128, "atan2l")
-HANDLE_LIBCALL(SINCOS_F32, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SINCOS_F64, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SINCOS_F80, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SINCOS_F128, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SINCOS_PPCF128, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SINCOS_STRET_F32, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(SINCOS_STRET_F64, LIBCALL_NO_NAME)
-HANDLE_LIBCALL(POW_F32, "powf")
-HANDLE_LIBCALL(POW_F64, "pow")
-HANDLE_LIBCALL(POW_F80, "powl")
-HANDLE_LIBCALL(POW_F128, "powl")
-HANDLE_LIBCALL(POW_PPCF128, "powl")
-HANDLE_LIBCALL(POW_FINITE_F32, "__powf_finite")
-HANDLE_LIBCALL(POW_FINITE_F64, "__pow_finite")
-HANDLE_LIBCALL(POW_FINITE_F80, "__powl_finite")
-HANDLE_LIBCALL(POW_FINITE_F128, "__powl_finite")
-HANDLE_LIBCALL(POW_FINITE_PPCF128, "__powl_finite")
-HANDLE_LIBCALL(CEIL_F32, "ceilf")
-HANDLE_LIBCALL(CEIL_F64, "ceil")
-HANDLE_LIBCALL(CEIL_F80, "ceill")
-HANDLE_LIBCALL(CEIL_F128, "ceill")
-HANDLE_LIBCALL(CEIL_PPCF128, "ceill")
-HANDLE_LIBCALL(TRUNC_F32, "truncf")
-HANDLE_LIBCALL(TRUNC_F64, "trunc")
-HANDLE_LIBCALL(TRUNC_F80, "truncl")
-HANDLE_LIBCALL(TRUNC_F128, "truncl")
-HANDLE_LIBCALL(TRUNC_PPCF128, "truncl")
-HANDLE_LIBCALL(RINT_F32, "rintf")
-HANDLE_LIBCALL(RINT_F64, "rint")
-HANDLE_LIBCALL(RINT_F80, "rintl")
-HANDLE_LIBCALL(RINT_F128, "rintl")
-HANDLE_LIBCALL(RINT_PPCF128, "rintl")
-HANDLE_LIBCALL(NEARBYINT_F32, "nearbyintf")
-HANDLE_LIBCALL(NEARBYINT_F64, "nearbyint")
-HANDLE_LIBCALL(NEARBYINT_F80, "nearbyintl")
-HANDLE_LIBCALL(NEARBYINT_F128, "nearbyintl")
-HANDLE_LIBCALL(NEARBYINT_PPCF128, "nearbyintl")
-HANDLE_LIBCALL(ROUND_F32, "roundf")
-HANDLE_LIBCALL(ROUND_F64, "round")
-HANDLE_LIBCALL(ROUND_F80, "roundl")
-HANDLE_LIBCALL(ROUND_F128, "roundl")
-HANDLE_LIBCALL(ROUND_PPCF128, "roundl")
-HANDLE_LIBCALL(ROUNDEVEN_F32, "roundevenf")
-HANDLE_LIBCALL(ROUNDEVEN_F64, "roundeven")
-HANDLE_LIBCALL(ROUNDEVEN_F80, "roundevenl")
-HANDLE_LIBCALL(ROUNDEVEN_F128, "roundevenl")
-HANDLE_LIBCALL(ROUNDEVEN_PPCF128, "roundevenl")
-HANDLE_LIBCALL(FLOOR_F32, "floorf")
-HANDLE_LIBCALL(FLOOR_F64, "floor")
-HANDLE_LIBCALL(FLOOR_F80, "floorl")
-HANDLE_LIBCALL(FLOOR_F128, "floorl")
-HANDLE_LIBCALL(FLOOR_PPCF128, "floorl")
-HANDLE_LIBCALL(COPYSIGN_F32, "copysignf")
-HANDLE_LIBCALL(COPYSIGN_F64, "copysign")
-HANDLE_LIBCALL(COPYSIGN_F80, "copysignl")
-HANDLE_LIBCALL(COPYSIGN_F128, "copysignl")
-HANDLE_LIBCALL(COPYSIGN_PPCF128, "copysignl")
-HANDLE_LIBCALL(FMIN_F32, "fminf")
-HANDLE_LIBCALL(FMIN_F64, "fmin")
-HANDLE_LIBCALL(FMIN_F80, "fminl")
-HANDLE_LIBCALL(FMIN_F128, "fminl")
-HANDLE_LIBCALL(FMIN_PPCF128, "fminl")
-HANDLE_LIBCALL(FMAX_F32, "fmaxf")
-HANDLE_LIBCALL(FMAX_F64, "fmax")
-HANDLE_LIBCALL(FMAX_F80, "fmaxl")
-HANDLE_LIBCALL(FMAX_F128, "fmaxl")
-HANDLE_LIBCALL(FMAX_PPCF128, "fmaxl")
-HANDLE_LIBCALL(FMINIMUM_F32, "fminimumf")
-HANDLE_LIBCALL(FMINIMUM_F64, "fminimum")
-HANDLE_LIBCALL(FMINIMUM_F80, "fminimuml")
-HANDLE_LIBCALL(FMINIMUM_F128, "fminimuml")
-HANDLE_LIBCALL(FMINIMUM_PPCF128, "fminimuml")
-HANDLE_LIBCALL(FMAXIMUM_F32, "fmaximumf")
-HANDLE_LIBCALL(FMAXIMUM_F64, "fmaximum")
-HANDLE_LIBCALL(FMAXIMUM_F80, "fmaximuml")
-HANDLE_LIBCALL(FMAXIMUM_F128, "fmaximuml")
-HANDLE_LIBCALL(FMAXIMUM_PPCF128, "fmaximum_numl")
-HANDLE_LIBCALL(FMINIMUM_NUM_F32, "fminimum_numf")
-HANDLE_LIBCALL(FMINIMUM_NUM_F64, "fminimum_num")
-HANDLE_LIBCALL(FMINIMUM_NUM_F80, "fminimum_numl")
-HANDLE_LIBCALL(FMINIMUM_NUM_F128, "fminimum_numl")
-HANDLE_LIBCALL(FMINIMUM_NUM_PPCF128, "fminimum_numl")
-HANDLE_LIBCALL(FMAXIMUM_NUM_F32, "fmaximum_numf")
-HANDLE_LIBCALL(FMAXIMUM_NUM_F64, "fmaximum_num")
-HANDLE_LIBCALL(FMAXIMUM_NUM_F80, "fmaximum_numl")
-HANDLE_LIBCALL(FMAXIMUM_NUM_F128, "fmaximum_numl")
-HANDLE_LIBCALL(FMAXIMUM_NUM_PPCF128, "fmaximum_numl")
-HANDLE_LIBCALL(LROUND_F32, "lroundf")
-HANDLE_LIBCALL(LROUND_F64, "lround")
-HANDLE_LIBCALL(LROUND_F80, "lroundl")
-HANDLE_LIBCALL(LROUND_F128, "lroundl")
-HANDLE_LIBCALL(LROUND_PPCF128, "lroundl")
-HANDLE_LIBCALL(LLROUND_F32, "llroundf")
-HANDLE_LIBCALL(LLROUND_F64, "llround")
-HANDLE_LIBCALL(LLROUND_F80, "llroundl")
-HANDLE_LIBCALL(LLROUND_F128, "llroundl")
-HANDLE_LIBCALL(LLROUND_PPCF128, "llroundl")
-HANDLE_LIBCALL(LRINT_F32, "lrintf")
-HANDLE_LIBCALL(LRINT_F64, "lrint")
-HANDLE_LIBCALL(LRINT_F80, "lrintl")
-HANDLE_LIBCALL(LRINT_F128, "lrintl")
-HANDLE_LIBCALL(LRINT_PPCF128, "lrintl")
-HANDLE_LIBCALL(LLRINT_F32, "llrintf")
-HANDLE_LIBCALL(LLRINT_F64, "llrint")
-HANDLE_LIBCALL(LLRINT_F80, "llrintl")
-HANDLE_LIBCALL(LLRINT_F128, "llrintl")
-HANDLE_LIBCALL(LLRINT_PPCF128, "llrintl")
-HANDLE_LIBCALL(LDEXP_F32, "ldexpf")
-HANDLE_LIBCALL(LDEXP_F64, "ldexp")
-HANDLE_LIBCALL(LDEXP_F80, "ldexpl")
-HANDLE_LIBCALL(LDEXP_F128, "ldexpl")
-HANDLE_LIBCALL(LDEXP_PPCF128, "ldexpl")
-HANDLE_LIBCALL(FREXP_F32, "frexpf")
-HANDLE_LIBCALL(FREXP_F64, "frexp")
-HANDLE_LIBCALL(FREXP_F80, "frexpl")
-HANDLE_LIBCALL(FREXP_F128, "frexpl")
-HANDLE_LIBCALL(FREXP_PPCF128, "frexpl")
-HANDLE_LIBCALL(SINCOSPI_F32, "sincospif")
-HANDLE_LIBCALL(SINCOSPI_F64, "sincospi")
-HANDLE_LIBCALL(SINCOSPI_F80, "sincospil")
-HANDLE_LIBCALL(SINCOSPI_F128, "sincospil")
-HANDLE_LIBCALL(SINCOSPI_PPCF128, "sincospil")
-HANDLE_LIBCALL(MODF_F32, "modff")
-HANDLE_LIBCALL(MODF_F64, "modf")
-HANDLE_LIBCALL(MODF_F80, "modfl")
-HANDLE_LIBCALL(MODF_F128, "modfl")
-HANDLE_LIBCALL(MODF_PPCF128, "modfl")
-
-// Floating point environment
-HANDLE_LIBCALL(FEGETENV, "fegetenv")
-HANDLE_LIBCALL(FESETENV, "fesetenv")
-
-// Floating point control modes
-HANDLE_LIBCALL(FEGETMODE, "fegetmode")
-HANDLE_LIBCALL(FESETMODE, "fesetmode")
-
-// Conversion
-HANDLE_LIBCALL(FPEXT_BF16_F32, "__extendbfsf2")
-HANDLE_LIBCALL(FPEXT_F32_PPCF128, "__gcc_stoq")
-HANDLE_LIBCALL(FPEXT_F64_PPCF128, "__gcc_dtoq")
-HANDLE_LIBCALL(FPEXT_F80_F128, "__extendxftf2")
-HANDLE_LIBCALL(FPEXT_F64_F128, "__extenddftf2")
-HANDLE_LIBCALL(FPEXT_F32_F128, "__extendsftf2")
-HANDLE_LIBCALL(FPEXT_F16_F128, "__extendhftf2")
-HANDLE_LIBCALL(FPEXT_F16_F80, "__extendhfxf2")
-HANDLE_LIBCALL(FPEXT_F32_F64, "__extendsfdf2")
-HANDLE_LIBCALL(FPEXT_F16_F64, "__extendhfdf2")
-HANDLE_LIBCALL(FPEXT_F16_F32, "__extendhfsf2")
-HANDLE_LIBCALL(FPROUND_F32_F16, "__truncsfhf2")
-HANDLE_LIBCALL(FPROUND_F64_F16, "__truncdfhf2")
-HANDLE_LIBCALL(FPROUND_F80_F16, "__truncxfhf2")
-HANDLE_LIBCALL(FPROUND_F128_F16, "__trunctfhf2")
-HANDLE_LIBCALL(FPROUND_PPCF128_F16, "__trunctfhf2")
-HANDLE_LIBCALL(FPROUND_F32_BF16, "__truncsfbf2")
-HANDLE_LIBCALL(FPROUND_F64_BF16, "__truncdfbf2")
-HANDLE_LIBCALL(FPROUND_F80_BF16, "__truncxfbf2")
-HANDLE_LIBCALL(FPROUND_F128_BF16, "__trunctfbf2")
-HANDLE_LIBCALL(FPROUND_F64_F32, "__truncdfsf2")
-HANDLE_LIBCALL(FPROUND_F80_F32, "__truncxfsf2")
-HANDLE_LIBCALL(FPROUND_F128_F32, "__trunctfsf2")
-HANDLE_LIBCALL(FPROUND_PPCF128_F32, "__gcc_qtos")
-HANDLE_LIBCALL(FPROUND_F80_F64, "__truncxfdf2")
-HANDLE_LIBCALL(FPROUND_F128_F64, "__trunctfdf2")
-HANDLE_LIBCALL(FPROUND_PPCF128_F64, "__gcc_qtod")
-HANDLE_LIBCALL(FPROUND_F128_F80, "__trunctfxf2")
-HANDLE_LIBCALL(FPTOSINT_F16_I32, "__fixhfsi")
-HANDLE_LIBCALL(FPTOSINT_F16_I64, "__fixhfdi")
-HANDLE_LIBCALL(FPTOSINT_F16_I128, "__fixhfti")
-HANDLE_LIBCALL(FPTOSINT_F32_I32, "__fixsfsi")
-HANDLE_LIBCALL(FPTOSINT_F32_I64, "__fixsfdi")
-HANDLE_LIBCALL(FPTOSINT_F32_I128, "__fixsfti")
-HANDLE_LIBCALL(FPTOSINT_F64_I32, "__fixdfsi")
-HANDLE_LIBCALL(FPTOSINT_F64_I64, "__fixdfdi")
-HANDLE_LIBCALL(FPTOSINT_F64_I128, "__fixdfti")
-HANDLE_LIBCALL(FPTOSINT_F80_I32, "__fixxfsi")
-HANDLE_LIBCALL(FPTOSINT_F80_I64, "__fixxfdi")
-HANDLE_LIBCALL(FPTOSINT_F80_I128, "__fixxfti")
-HANDLE_LIBCALL(FPTOSINT_F128_I32, "__fixtfsi")
-HANDLE_LIBCALL(FPTOSINT_F128_I64, "__fixtfdi")
-HANDLE_LIBCALL(FPTOSINT_F128_I128, "__fixtfti")
-HANDLE_LIBCALL(FPTOSINT_PPCF128_I32, "__gcc_qtou")
-HANDLE_LIBCALL(FPTOSINT_PPCF128_I64, "__fixtfdi")
-HANDLE_LIBCALL(FPTOSINT_PPCF128_I128, "__fixtfti")
-HANDLE_LIBCALL(FPTOUINT_F16_I32, "__fixunshfsi")
-HANDLE_LIBCALL(FPTOUINT_F16_I64, "__fixunshfdi")
-HANDLE_LIBCALL(FPTOUINT_F16_I128, "__fixunshfti")
-HANDLE_LIBCALL(FPTOUINT_F32_I32, "__fixunssfsi")
-HANDLE_LIBCALL(FPTOUINT_F32_I64, "__fixunssfdi")
-HANDLE_LIBCALL(FPTOUINT_F32_I128, "__fixunssfti")
-HANDLE_LIBCALL(FPTOUINT_F64_I32, "__fixunsdfsi")
-HANDLE_LIBCALL(FPTOUINT_F64_I64, "__fixunsdfdi")
-HANDLE_LIBCALL(FPTOUINT_F64_I128, "__fixunsdfti")
-HANDLE_LIBCALL(FPTOUINT_F80_I32, "__fixunsxfsi")
-HANDLE_LIBCALL(FPTOUINT_F80_I64, "__fixunsxfdi")
-HANDLE_LIBCALL(FPTOUINT_F80_I128, "__fixunsxfti")
-HANDLE_LIBCALL(FPTOUINT_F128_I32, "__fixunstfsi")
-HANDLE_LIBCALL(FPTOUINT_F128_I64, "__fixunstfdi")
-HANDLE_LIBCALL(FPTOUINT_F128_I128, "__fixunstfti")
-HANDLE_LIBCALL(FPTOUINT_PPCF128_I32, "__fixunstfsi")
-HANDLE_LIBCALL(FPTOUINT_PPCF128_I64, "__fixunstfdi")
-HANDLE_LIBCALL(FPTOUINT_PPCF128_I128, "__fixunstfti")
-HANDLE_LIBCALL(SINTTOFP_I32_F16, "__floatsihf")
-HANDLE_LIBCALL(SINTTOFP_I32_F32, "__floatsisf")
-HANDLE_LIBCALL(SINTTOFP_I32_F64, "__floatsidf")
-HANDLE_LIBCALL(SINTTOFP_I32_F80, "__floatsixf")
-HANDLE_LIBCALL(SINTTOFP_I32_F128, "__floatsitf")
-HANDLE_LIBCALL(SINTTOFP_I32_PPCF128, "__gcc_itoq")
-HANDLE_LIBCALL(SINTTOFP_I64_BF16, "__floatdibf")
-HANDLE_LIBCALL(SINTTOFP_I64_F16, "__floatdihf")
-HANDLE_LIBCALL(SINTTOFP_I64_F32, "__floatdisf")
-HANDLE_LIBCALL(SINTTOFP_I64_F64, "__floatdidf")
-HANDLE_LIBCALL(SINTTOFP_I64_F80, "__floatdixf")
-HANDLE_LIBCALL(SINTTOFP_I64_F128, "__floatditf")
-HANDLE_LIBCALL(SINTTOFP_I64_PPCF128, "__floatditf")
-HANDLE_LIBCALL(SINTTOFP_I128_F16, "__floattihf")
-HANDLE_LIBCALL(SINTTOFP_I128_F32, "__floattisf")
-HANDLE_LIBCALL(SINTTOFP_I128_F64, "__floattidf")
-HANDLE_LIBCALL(SINTTOFP_I128_F80, "__floattixf")
-HANDLE_LIBCALL(SINTTOFP_I128_F128, "__floattitf")
-HANDLE_LIBCALL(SINTTOFP_I128_PPCF128, "__floattitf")
-HANDLE_LIBCALL(UINTTOFP_I32_F16, "__floatunsihf")
-HANDLE_LIBCALL(UINTTOFP_I32_F32, "__floatunsisf")
-HANDLE_LIBCALL(UINTTOFP_I32_F64, "__floatunsidf")
-HANDLE_LIBCALL(UINTTOFP_I32_F80, "__floatunsixf")
-HANDLE_LIBCALL(UINTTOFP_I32_F128, "__floatunsitf")
-HANDLE_LIBCALL(UINTTOFP_I32_PPCF128, "__gcc_utoq")
-HANDLE_LIBCALL(UINTTOFP_I64_BF16, "__floatundibf")
-HANDLE_LIBCALL(UINTTOFP_I64_F16, "__floatundihf")
-HANDLE_LIBCALL(UINTTOFP_I64_F32, "__floatundisf")
-HANDLE_LIBCALL(UINTTOFP_I64_F64, "__floatundidf")
-HANDLE_LIBCALL(UINTTOFP_I64_F80, "__floatundixf")
-HANDLE_LIBCALL(UINTTOFP_I64_F128, "__floatunditf")
-HANDLE_LIBCALL(UINTTOFP_I64_PPCF128, "__floatunditf")
-HANDLE_LIBCALL(UINTTOFP_I128_F16, "__floatuntihf")
-HANDLE_LIBCALL(UINTTOFP_I128_F32, "__floatuntisf")
-HANDLE_LIBCALL(UINTTOFP_I128_F64, "__floatuntidf")
-HANDLE_LIBCALL(UINTTOFP_I128_F80, "__floatuntixf")
-HANDLE_LIBCALL(UINTTOFP_I128_F128, "__floatuntitf")
-HANDLE_LIBCALL(UINTTOFP_I128_PPCF128, "__floatuntitf")
-HANDLE_LIBCALL(CONVERT_F128_PPCF128, "__extendkftf2")
-HANDLE_LIBCALL(CONVERT_PPCF128_F128, "__trunctfkf2")
-
-// Comparison
-HANDLE_LIBCALL(OEQ_F32, "__eqsf2")
-HANDLE_LIBCALL(OEQ_F64, "__eqdf2")
-HANDLE_LIBCALL(OEQ_F128, "__eqtf2")
-HANDLE_LIBCALL(OEQ_PPCF128, "__gcc_qeq")
-HANDLE_LIBCALL(UNE_F32, "__nesf2")
-HANDLE_LIBCALL(UNE_F64, "__nedf2")
-HANDLE_LIBCALL(UNE_F128, "__netf2")
-HANDLE_LIBCALL(UNE_PPCF128, "__gcc_qne")
-HANDLE_LIBCALL(OGE_F32, "__gesf2")
-HANDLE_LIBCALL(OGE_F64, "__gedf2")
-HANDLE_LIBCALL(OGE_F128, "__getf2")
-HANDLE_LIBCALL(OGE_PPCF128, "__gcc_qge")
-HANDLE_LIBCALL(OLT_F32, "__ltsf2")
-HANDLE_LIBCALL(OLT_F64, "__ltdf2")
-HANDLE_LIBCALL(OLT_F128, "__lttf2")
-HANDLE_LIBCALL(OLT_PPCF128, "__gcc_qlt")
-HANDLE_LIBCALL(OLE_F32, "__lesf2")
-HANDLE_LIBCALL(OLE_F64, "__ledf2")
-HANDLE_LIBCALL(OLE_F128, "__letf2")
-HANDLE_LIBCALL(OLE_PPCF128, "__gcc_qle")
-HANDLE_LIBCALL(OGT_F32, "__gtsf2")
-HANDLE_LIBCALL(OGT_F64, "__gtdf2")
-HANDLE_LIBCALL(OGT_F128, "__gttf2")
-HANDLE_LIBCALL(OGT_PPCF128, "__gcc_qgt")
-HANDLE_LIBCALL(UO_F32, "__unordsf2")
-HANDLE_LIBCALL(UO_F64, "__unorddf2")
-HANDLE_LIBCALL(UO_F128, "__unordtf2")
-HANDLE_LIBCALL(UO_PPCF128, "__gcc_qunord")
-
-// Memory
-HANDLE_LIBCALL(MEMCPY, "memcpy")
-HANDLE_LIBCALL(MEMMOVE, "memmove")
-HANDLE_LIBCALL(MEMSET, "memset")
-// DSEPass can emit calloc if it finds a pair of malloc/memset
-HANDLE_LIBCALL(CALLOC, "calloc")
-HANDLE_LIBCALL(BZERO, LIBCALL_NO_NAME)
-
-// Element-wise unordered-atomic memory of different sizes
-HANDLE_LIBCALL(MEMCPY_ELEMENT_UNORDERED_ATOMIC_1, "__llvm_memcpy_element_unordered_atomic_1")
-HANDLE_LIBCALL(MEMCPY_ELEMENT_UNORDERED_ATOMIC_2, "__llvm_memcpy_element_unordered_atomic_2")
-HANDLE_LIBCALL(MEMCPY_ELEMENT_UNORDERED_ATOMIC_4, "__llvm_memcpy_element_unordered_atomic_4")
-HANDLE_LIBCALL(MEMCPY_ELEMENT_UNORDERED_ATOMIC_8, "__llvm_memcpy_element_unordered_atomic_8")
-HANDLE_LIBCALL(MEMCPY_ELEMENT_UNORDERED_ATOMIC_16, "__llvm_memcpy_element_unordered_atomic_16")
-HANDLE_LIBCALL(MEMMOVE_ELEMENT_UNORDERED_ATOMIC_1, "__llvm_memmove_element_unordered_atomic_1")
-HANDLE_LIBCALL(MEMMOVE_ELEMENT_UNORDERED_ATOMIC_2, "__llvm_memmove_element_unordered_atomic_2")
-HANDLE_LIBCALL(MEMMOVE_ELEMENT_UNORDERED_ATOMIC_4, "__llvm_memmove_element_unordered_atomic_4")
-HANDLE_LIBCALL(MEMMOVE_ELEMENT_UNORDERED_ATOMIC_8, "__llvm_memmove_element_unordered_atomic_8")
-HANDLE_LIBCALL(MEMMOVE_ELEMENT_UNORDERED_ATOMIC_16, "__llvm_memmove_element_unordered_atomic_16")
-HANDLE_LIBCALL(MEMSET_ELEMENT_UNORDERED_ATOMIC_1, "__llvm_memset_element_unordered_atomic_1")
-HANDLE_LIBCALL(MEMSET_ELEMENT_UNORDERED_ATOMIC_2, "__llvm_memset_element_unordered_atomic_2")
-HANDLE_LIBCALL(MEMSET_ELEMENT_UNORDERED_ATOMIC_4, "__llvm_memset_element_unordered_atomic_4")
-HANDLE_LIBCALL(MEMSET_ELEMENT_UNORDERED_ATOMIC_8, "__llvm_memset_element_unordered_atomic_8")
-HANDLE_LIBCALL(MEMSET_ELEMENT_UNORDERED_ATOMIC_16, "__llvm_memset_element_unordered_atomic_16")
-
-// Exception handling
-HANDLE_LIBCALL(UNWIND_RESUME, "_Unwind_Resume")
-HANDLE_LIBCALL(CXA_END_CLEANUP, "__cxa_end_cleanup")
-
-// Note: there are two sets of atomics libcalls; see
-// <https://llvm.org/docs/Atomics.html> for more info on the
-// difference between them.
-
-// Atomic '__sync_*' libcalls.
-HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_1, "__sync_val_compare_and_swap_1")
-HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_2, "__sync_val_compare_and_swap_2")
-HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_4, "__sync_val_compare_and_swap_4")
-HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_8, "__sync_val_compare_and_swap_8")
-HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_16, "__sync_val_compare_and_swap_16")
-HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_1, "__sync_lock_test_and_set_1")
-HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_2, "__sync_lock_test_and_set_2")
-HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_4, "__sync_lock_test_and_set_4")
-HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_8, "__sync_lock_test_and_set_8")
-HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_16, "__sync_lock_test_and_set_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_1, "__sync_fetch_and_add_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_2, "__sync_fetch_and_add_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_4, "__sync_fetch_and_add_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_8, "__sync_fetch_and_add_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_16, "__sync_fetch_and_add_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_1, "__sync_fetch_and_sub_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_2, "__sync_fetch_and_sub_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_4, "__sync_fetch_and_sub_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_8, "__sync_fetch_and_sub_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_16, "__sync_fetch_and_sub_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_AND_1, "__sync_fetch_and_and_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_AND_2, "__sync_fetch_and_and_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_AND_4, "__sync_fetch_and_and_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_AND_8, "__sync_fetch_and_and_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_AND_16, "__sync_fetch_and_and_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_OR_1, "__sync_fetch_and_or_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_OR_2, "__sync_fetch_and_or_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_OR_4, "__sync_fetch_and_or_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_OR_8, "__sync_fetch_and_or_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_OR_16, "__sync_fetch_and_or_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_1, "__sync_fetch_and_xor_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_2, "__sync_fetch_and_xor_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_4, "__sync_fetch_and_xor_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_8, "__sync_fetch_and_xor_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_16, "__sync_fetch_and_xor_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_1, "__sync_fetch_and_nand_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_2, "__sync_fetch_and_nand_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_4, "__sync_fetch_and_nand_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_8, "__sync_fetch_and_nand_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_16, "__sync_fetch_and_nand_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_1, "__sync_fetch_and_max_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_2, "__sync_fetch_and_max_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_4, "__sync_fetch_and_max_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_8, "__sync_fetch_and_max_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_16, "__sync_fetch_and_max_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_1, "__sync_fetch_and_umax_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_2, "__sync_fetch_and_umax_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_4, "__sync_fetch_and_umax_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_8, "__sync_fetch_and_umax_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_16, "__sync_fetch_and_umax_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_1, "__sync_fetch_and_min_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_2, "__sync_fetch_and_min_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_4, "__sync_fetch_and_min_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_8, "__sync_fetch_and_min_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_16, "__sync_fetch_and_min_16")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_1, "__sync_fetch_and_umin_1")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_2, "__sync_fetch_and_umin_2")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_4, "__sync_fetch_and_umin_4")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_8, "__sync_fetch_and_umin_8")
-HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_16, "__sync_fetch_and_umin_16")
-
-// Atomic `__atomic_*' libcalls.
-HANDLE_LIBCALL(ATOMIC_LOAD, "__atomic_load")
-HANDLE_LIBCALL(ATOMIC_LOAD_1, "__atomic_load_1")
-HANDLE_LIBCALL(ATOMIC_LOAD_2, "__atomic_load_2")
-HANDLE_LIBCALL(ATOMIC_LOAD_4, "__atomic_load_4")
-HANDLE_LIBCALL(ATOMIC_LOAD_8, "__atomic_load_8")
-HANDLE_LIBCALL(ATOMIC_LOAD_16, "__atomic_load_16")
-
-HANDLE_LIBCALL(ATOMIC_STORE, "__atomic_store")
-HANDLE_LIBCALL(ATOMIC_STORE_1, "__atomic_store_1")
-HANDLE_LIBCALL(ATOMIC_STORE_2, "__atomic_store_2")
-HANDLE_LIBCALL(ATOMIC_STORE_4, "__atomic_store_4")
-HANDLE_LIBCALL(ATOMIC_STORE_8, "__atomic_store_8")
-HANDLE_LIBCALL(ATOMIC_STORE_16, "__atomic_store_16")
-
-HANDLE_LIBCALL(ATOMIC_EXCHANGE, "__atomic_exchange")
-HANDLE_LIBCALL(ATOMIC_EXCHANGE_1, "__atomic_exchange_1")
-HANDLE_LIBCALL(ATOMIC_EXCHANGE_2, "__atomic_exchange_2")
-HANDLE_LIBCALL(ATOMIC_EXCHANGE_4, "__atomic_exchange_4")
-HANDLE_LIBCALL(ATOMIC_EXCHANGE_8, "__atomic_exchange_8")
-HANDLE_LIBCALL(ATOMIC_EXCHANGE_16, "__atomic_exchange_16")
-
-HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE, "__atomic_compare_exchange")
-HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_1, "__atomic_compare_exchange_1")
-HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_2, "__atomic_compare_exchange_2")
-HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_4, "__atomic_compare_exchange_4")
-HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_8, "__atomic_compare_exchange_8")
-HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_16, "__atomic_compare_exchange_16")
-
-HANDLE_LIBCALL(ATOMIC_FETCH_ADD_1, "__atomic_fetch_add_1")
-HANDLE_LIBCALL(ATOMIC_FETCH_ADD_2, "__atomic_fetch_add_2")
-HANDLE_LIBCALL(ATOMIC_FETCH_ADD_4, "__atomic_fetch_add_4")
-HANDLE_LIBCALL(ATOMIC_FETCH_ADD_8, "__atomic_fetch_add_8")
-HANDLE_LIBCALL(ATOMIC_FETCH_ADD_16, "__atomic_fetch_add_16")
-HANDLE_LIBCALL(ATOMIC_FETCH_SUB_1, "__atomic_fetch_sub_1")
-HANDLE_LIBCALL(ATOMIC_FETCH_SUB_2, "__atomic_fetch_sub_2")
-HANDLE_LIBCALL(ATOMIC_FETCH_SUB_4, "__atomic_fetch_sub_4")
-HANDLE_LIBCALL(ATOMIC_FETCH_SUB_8, "__atomic_fetch_sub_8")
-HANDLE_LIBCALL(ATOMIC_FETCH_SUB_16, "__atomic_fetch_sub_16")
-HANDLE_LIBCALL(ATOMIC_FETCH_AND_1, "__atomic_fetch_and_1")
-HANDLE_LIBCALL(ATOMIC_FETCH_AND_2, "__atomic_fetch_and_2")
-HANDLE_LIBCALL(ATOMIC_FETCH_AND_4, "__atomic_fetch_and_4")
-HANDLE_LIBCALL(ATOMIC_FETCH_AND_8, "__atomic_fetch_and_8")
-HANDLE_LIBCALL(ATOMIC_FETCH_AND_16, "__atomic_fetch_and_16")
-HANDLE_LIBCALL(ATOMIC_FETCH_OR_1, "__atomic_fetch_or_1")
-HANDLE_LIBCALL(ATOMIC_FETCH_OR_2, "__atomic_fetch_or_2")
-HANDLE_LIBCALL(ATOMIC_FETCH_OR_4, "__atomic_fetch_or_4")
-HANDLE_LIBCALL(ATOMIC_FETCH_OR_8, "__atomic_fetch_or_8")
-HANDLE_LIBCALL(ATOMIC_FETCH_OR_16, "__atomic_fetch_or_16")
-HANDLE_LIBCALL(ATOMIC_FETCH_XOR_1, "__atomic_fetch_xor_1")
-HANDLE_LIBCALL(ATOMIC_FETCH_XOR_2, "__atomic_fetch_xor_2")
-HANDLE_LIBCALL(ATOMIC_FETCH_XOR_4, "__atomic_fetch_xor_4")
-HANDLE_LIBCALL(ATOMIC_FETCH_XOR_8, "__atomic_fetch_xor_8")
-HANDLE_LIBCALL(ATOMIC_FETCH_XOR_16, "__atomic_fetch_xor_16")
-HANDLE_LIBCALL(ATOMIC_FETCH_NAND_1, "__atomic_fetch_nand_1")
-HANDLE_LIBCALL(ATOMIC_FETCH_NAND_2, "__atomic_fetch_nand_2")
-HANDLE_LIBCALL(ATOMIC_FETCH_NAND_4, "__atomic_fetch_nand_4")
-HANDLE_LIBCALL(ATOMIC_FETCH_NAND_8, "__atomic_fetch_nand_8")
-HANDLE_LIBCALL(ATOMIC_FETCH_NAND_16, "__atomic_fetch_nand_16")
-
-// Out-of-line atomics libcalls
-#define HLCALLS(A, N) \
- HANDLE_LIBCALL(A##N##_RELAX, LIBCALL_NO_NAME) \
- HANDLE_LIBCALL(A##N##_ACQ, LIBCALL_NO_NAME) \
- HANDLE_LIBCALL(A##N##_REL, LIBCALL_NO_NAME) \
- HANDLE_LIBCALL(A##N##_ACQ_REL, LIBCALL_NO_NAME)
-#define HLCALL5(A) \
- HLCALLS(A, 1) HLCALLS(A, 2) HLCALLS(A, 4) HLCALLS(A, 8) HLCALLS(A, 16)
-HLCALL5(OUTLINE_ATOMIC_CAS)
-HLCALL5(OUTLINE_ATOMIC_SWP)
-HLCALL5(OUTLINE_ATOMIC_LDADD)
-HLCALL5(OUTLINE_ATOMIC_LDSET)
-HLCALL5(OUTLINE_ATOMIC_LDCLR)
-HLCALL5(OUTLINE_ATOMIC_LDEOR)
-#undef HLCALLS
-#undef HLCALL5
-
-// Stack Protector Fail
-HANDLE_LIBCALL(STACKPROTECTOR_CHECK_FAIL, "__stack_chk_fail")
-
-// Deoptimization
-HANDLE_LIBCALL(DEOPTIMIZE, "__llvm_deoptimize")
-
-// Return address
-HANDLE_LIBCALL(RETURN_ADDRESS, LIBCALL_NO_NAME)
-
-// Clear cache
-HANDLE_LIBCALL(CLEAR_CACHE, "__clear_cache")
-HANDLE_LIBCALL(RISCV_FLUSH_ICACHE, "__riscv_flush_icache")
-
-HANDLE_LIBCALL(UNKNOWN_LIBCALL, LIBCALL_NO_NAME)
-
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h
index b7660e1e3c3d8..e063076fac71a 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -23,23 +23,11 @@
#include "llvm/Support/Compiler.h"
#include "llvm/TargetParser/Triple.h"
-namespace llvm {
-namespace RTLIB {
+#define GET_RUNTIME_LIBCALL_ENUM
+#include "llvm/IR/RuntimeLibcalls.inc"
+#undef GET_RUNTIME_LIBCALL_ENUM
-/// RTLIB::Libcall enum - This enum defines all of the runtime library calls
-/// the backend can emit. The various long double types cannot be merged,
-/// because 80-bit library functions use "xf" and 128-bit use "tf".
-///
-/// When adding PPCF128 functions here, note that their names generally need
-/// to be overridden for Darwin with the xxx$LDBL128 form. See
-/// PPCISelLowering.cpp.
-///
-enum Libcall {
-#define HANDLE_LIBCALL(code, name) code,
-#include "llvm/IR/RuntimeLibcalls.def"
-#undef HANDLE_LIBCALL
-};
-} // namespace RTLIB
+namespace llvm {
template <> struct enum_iteration_traits<RTLIB::Libcall> {
static constexpr bool is_iterable = true;
@@ -59,6 +47,8 @@ struct RuntimeLibcallsInfo {
ExceptionHandling ExceptionModel = ExceptionHandling::None,
FloatABI::ABIType FloatABI = FloatABI::Default,
EABI EABIVersion = EABI::Default) {
+ initSoftFloatCmpLibcallPredicates();
+ initDefaultLibCallNames();
initLibcalls(TT, ExceptionModel, FloatABI, EABIVersion);
}
@@ -117,6 +107,9 @@ struct RuntimeLibcallsInfo {
}
private:
+ static const char *const
+ DefaultLibcallRoutineNames[RTLIB::UNKNOWN_LIBCALL + 1];
+
/// Stores the name each libcall.
const char *LibcallRoutineNames[RTLIB::UNKNOWN_LIBCALL + 1] = {nullptr};
@@ -155,6 +148,17 @@ struct RuntimeLibcallsInfo {
(TT.isAndroid() && !TT.isAndroidVersionLT(9));
}
+ void initDefaultLibCallNames();
+
+ /// Generated by tablegen.
+ void setPPCLibCallNameOverrides();
+
+ /// Generated by tablegen.
+ void setZOSLibCallNameOverrides();
+
+ /// Generated by tablegen.
+ void setWindowsArm64LibCallNameOverrides();
+
void initSoftFloatCmpLibcallPredicates();
/// Set default libcall names. If a target wants to opt-out of a libcall it
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
new file mode 100644
index 0000000000000..c6f00c345cde8
--- /dev/null
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -0,0 +1,1054 @@
+//===-- llvm/RuntimeLibcallList.td - Describe libcalls --------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+include "llvm/IR/RuntimeLibcallsImpl.td"
+
+//--------------------------------------------------------------------
+// Declare all kinds of used libcalls
+//--------------------------------------------------------------------
+
+// Integer
+foreach IntTy = ["I16", "I32", "I64", "I128"] in {
+ def SHL_#IntTy : RuntimeLibcall;
+ def SRL_#IntTy : RuntimeLibcall;
+ def SRA_#IntTy : RuntimeLibcall;
+}
+
+foreach IntTy = ["I8", "I16", "I32", "I64", "I128"] in {
+ def MUL_#IntTy : RuntimeLibcall;
+}
+
+foreach IntTy = ["I32", "I64", "I128" ] in {
+ def MULO_#IntTy : RuntimeLibcall;
+}
+
+foreach IntTy = ["I8", "I16", "I32", "I64", "I128"] in {
+ def SDIV_#IntTy : RuntimeLibcall;
+ def UDIV_#IntTy : RuntimeLibcall;
+ def SREM_#IntTy : RuntimeLibcall;
+ def UREM_#IntTy : RuntimeLibcall;
+ def SDIVREM_#IntTy : RuntimeLibcall;
+ def UDIVREM_#IntTy : RuntimeLibcall;
+}
+
+foreach IntTy = ["I32", "I64" ] in {
+ def NEG_#IntTy : RuntimeLibcall;
+}
+
+foreach IntTy = ["I32", "I64", "I128"] in {
+ def CTLZ_#IntTy : RuntimeLibcall;
+ def CTPOP_#IntTy : RuntimeLibcall;
+}
+
+foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
+ def ADD_#FPTy : RuntimeLibcall;
+ def SUB_#FPTy : RuntimeLibcall;
+ def MUL_#FPTy : RuntimeLibcall;
+ def DIV_#FPTy : RuntimeLibcall;
+ def REM_#FPTy : RuntimeLibcall;
+ def FMA_#FPTy : RuntimeLibcall;
+ def POWI_#FPTy : RuntimeLibcall;
+ def 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;
+}
+
+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 FEGETENV : RuntimeLibcall;
+def FESETENV : RuntimeLibcall;
+
+def FEGETMODE : RuntimeLibcall;
+def FESETMODE : RuntimeLibcall;
+
+def FPEXT_BF16_F32 : RuntimeLibcall;
+def FPEXT_F32_PPCF128 : RuntimeLibcall;
+def FPEXT_F64_PPCF128 : RuntimeLibcall;
+def FPEXT_F80_F128 : RuntimeLibcall;
+def FPEXT_F64_F128 : RuntimeLibcall;
+def FPEXT_F32_F128 : RuntimeLibcall;
+def FPEXT_F16_F128 : RuntimeLibcall;
+def FPEXT_F16_F80 : RuntimeLibcall;
+def FPEXT_F32_F64 : RuntimeLibcall;
+def FPEXT_F16_F64 : RuntimeLibcall;
+def FPEXT_F16_F32 : RuntimeLibcall;
+def FPROUND_F32_F16 : RuntimeLibcall;
+def FPROUND_F64_F16 : RuntimeLibcall;
+def FPROUND_F80_F16 : RuntimeLibcall;
+def FPROUND_F128_F16 : RuntimeLibcall;
+def FPROUND_PPCF128_F16 : RuntimeLibcall;
+def FPROUND_F32_BF16 : RuntimeLibcall;
+def FPROUND_F64_BF16 : RuntimeLibcall;
+def FPROUND_F80_BF16 : RuntimeLibcall;
+def FPROUND_F128_BF16 : RuntimeLibcall;
+def FPROUND_F64_F32 : RuntimeLibcall;
+def FPROUND_F80_F32 : RuntimeLibcall;
+def FPROUND_F128_F32 : RuntimeLibcall;
+def FPROUND_PPCF128_F32 : RuntimeLibcall;
+def FPROUND_F80_F64 : RuntimeLibcall;
+def FPROUND_F128_F64 : RuntimeLibcall;
+def FPROUND_PPCF128_F64 : RuntimeLibcall;
+def FPROUND_F128_F80 : RuntimeLibcall;
+def FPTOSINT_F16_I32 : RuntimeLibcall;
+def FPTOSINT_F16_I64 : RuntimeLibcall;
+def FPTOSINT_F16_I128 : RuntimeLibcall;
+def FPTOSINT_F32_I32 : RuntimeLibcall;
+def FPTOSINT_F32_I64 : RuntimeLibcall;
+def FPTOSINT_F32_I128 : RuntimeLibcall;
+def FPTOSINT_F64_I32 : RuntimeLibcall;
+def FPTOSINT_F64_I64 : RuntimeLibcall;
+def FPTOSINT_F64_I128 : RuntimeLibcall;
+def FPTOSINT_F80_I32 : RuntimeLibcall;
+def FPTOSINT_F80_I64 : RuntimeLibcall;
+def FPTOSINT_F80_I128 : RuntimeLibcall;
+def FPTOSINT_F128_I32 : RuntimeLibcall;
+def FPTOSINT_F128_I64 : RuntimeLibcall;
+def FPTOSINT_F128_I128 : RuntimeLibcall;
+def FPTOSINT_PPCF128_I32 : RuntimeLibcall;
+def FPTOSINT_PPCF128_I64 : RuntimeLibcall;
+def FPTOSINT_PPCF128_I128 : RuntimeLibcall;
+def FPTOUINT_F16_I32 : RuntimeLibcall;
+def FPTOUINT_F16_I64 : RuntimeLibcall;
+def FPTOUINT_F16_I128 : RuntimeLibcall;
+def FPTOUINT_F32_I32 : RuntimeLibcall;
+def FPTOUINT_F32_I64 : RuntimeLibcall;
+def FPTOUINT_F32_I128 : RuntimeLibcall;
+def FPTOUINT_F64_I32 : RuntimeLibcall;
+def FPTOUINT_F64_I64 : RuntimeLibcall;
+def FPTOUINT_F64_I128 : RuntimeLibcall;
+def FPTOUINT_F80_I32 : RuntimeLibcall;
+def FPTOUINT_F80_I64 : RuntimeLibcall;
+def FPTOUINT_F80_I128 : RuntimeLibcall;
+def FPTOUINT_F128_I32 : RuntimeLibcall;
+def FPTOUINT_F128_I64 : RuntimeLibcall;
+def FPTOUINT_F128_I128 : RuntimeLibcall;
+def FPTOUINT_PPCF128_I32 : RuntimeLibcall;
+def FPTOUINT_PPCF128_I64 : RuntimeLibcall;
+def FPTOUINT_PPCF128_I128 : RuntimeLibcall;
+def SINTTOFP_I32_F16 : RuntimeLibcall;
+def SINTTOFP_I32_F32 : RuntimeLibcall;
+def SINTTOFP_I32_F64 : RuntimeLibcall;
+def SINTTOFP_I32_F80 : RuntimeLibcall;
+def SINTTOFP_I32_F128 : RuntimeLibcall;
+def SINTTOFP_I32_PPCF128 : RuntimeLibcall;
+def SINTTOFP_I64_BF16 : RuntimeLibcall;
+def SINTTOFP_I64_F16 : RuntimeLibcall;
+def SINTTOFP_I64_F32 : RuntimeLibcall;
+def SINTTOFP_I64_F64 : RuntimeLibcall;
+def SINTTOFP_I64_F80 : RuntimeLibcall;
+def SINTTOFP_I64_F128 : RuntimeLibcall;
+def SINTTOFP_I64_PPCF128 : RuntimeLibcall;
+def SINTTOFP_I128_F16 : RuntimeLibcall;
+def SINTTOFP_I128_F32 : RuntimeLibcall;
+def SINTTOFP_I128_F64 : RuntimeLibcall;
+def SINTTOFP_I128_F80 : RuntimeLibcall;
+def SINTTOFP_I128_F128 : RuntimeLibcall;
+def SINTTOFP_I128_PPCF128 : RuntimeLibcall;
+def UINTTOFP_I32_F16 : RuntimeLibcall;
+def UINTTOFP_I32_F32 : RuntimeLibcall;
+def UINTTOFP_I32_F64 : RuntimeLibcall;
+def UINTTOFP_I32_F80 : RuntimeLibcall;
+def UINTTOFP_I32_F128 : RuntimeLibcall;
+def UINTTOFP_I32_PPCF128 : RuntimeLibcall;
+def UINTTOFP_I64_BF16 : RuntimeLibcall;
+def UINTTOFP_I64_F16 : RuntimeLibcall;
+def UINTTOFP_I64_F32 : RuntimeLibcall;
+def UINTTOFP_I64_F64 : RuntimeLibcall;
+def UINTTOFP_I64_F80 : RuntimeLibcall;
+def UINTTOFP_I64_F128 : RuntimeLibcall;
+def UINTTOFP_I64_PPCF128 : RuntimeLibcall;
+def UINTTOFP_I128_F16 : RuntimeLibcall;
+def UINTTOFP_I128_F32 : RuntimeLibcall;
+def UINTTOFP_I128_F64 : RuntimeLibcall;
+def UINTTOFP_I128_F80 : RuntimeLibcall;
+def UINTTOFP_I128_F128 : RuntimeLibcall;
+def UINTTOFP_I128_PPCF128 : RuntimeLibcall;
+def CONVERT_F128_PPCF128 : RuntimeLibcall;
+def CONVERT_PPCF128_F128 : RuntimeLibcall;
+
+// Comparisons
+foreach FPTy = ["F32", "F64", "F128", "PPCF128"] in {
+ def OEQ_#FPTy : RuntimeLibcall;
+ def UNE_#FPTy : RuntimeLibcall;
+ def OGE_#FPTy : RuntimeLibcall;
+ def OLT_#FPTy : RuntimeLibcall;
+ def OLE_#FPTy : RuntimeLibcall;
+ def OGT_#FPTy : RuntimeLibcall;
+ def UO_#FPTy : RuntimeLibcall;
+}
+
+// Memory
+def MEMCPY : RuntimeLibcall;
+def MEMMOVE : RuntimeLibcall;
+def MEMSET : RuntimeLibcall;
+def CALLOC : RuntimeLibcall;
+def BZERO : RuntimeLibcall;
+
+// Element-wise unordered-atomic memory of different sizes
+foreach MemSize = [1, 2, 4, 8, 16] in {
+ def MEMCPY_ELEMENT_UNORDERED_ATOMIC_#MemSize : RuntimeLibcall;
+ def MEMMOVE_ELEMENT_UNORDERED_ATOMIC_#MemSize : RuntimeLibcall;
+ def MEMSET_ELEMENT_UNORDERED_ATOMIC_#MemSize : RuntimeLibcall;
+}
+
+// Exception handling
+def UNWIND_RESUME : RuntimeLibcall;
+def CXA_END_CLEANUP : RuntimeLibcall;
+
+// Note: there are two sets of atomics libcalls; see
+// <https://llvm.org/docs/Atomics.html> for more info on the
+// difference between them.
+
+// Atomic '__sync_*' libcalls.
+defset list<RuntimeLibcall> LibCalls__sync = {
+ foreach MemSize = [1, 2, 4, 8, 16] in {
+ def SYNC_VAL_COMPARE_AND_SWAP_#MemSize : RuntimeLibcall;
+ def SYNC_LOCK_TEST_AND_SET_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_ADD_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_SUB_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_AND_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_OR_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_XOR_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_NAND_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_MAX_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_UMAX_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_MIN_#MemSize : RuntimeLibcall;
+ def SYNC_FETCH_AND_UMIN_#MemSize : RuntimeLibcall;
+ }
+}
+
+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_EXCHANGE#MemSize : RuntimeLibcall;
+ def ATOMIC_COMPARE_EXCHANGE#MemSize : RuntimeLibcall;
+ }
+
+ foreach MemSize = [1, 2, 4, 8, 16] in {
+ def ATOMIC_FETCH_ADD_#MemSize : RuntimeLibcall;
+ def ATOMIC_FETCH_SUB_#MemSize : RuntimeLibcall;
+ def ATOMIC_FETCH_AND_#MemSize : RuntimeLibcall;
+ def ATOMIC_FETCH_OR_#MemSize : RuntimeLibcall;
+ def ATOMIC_FETCH_XOR_#MemSize : RuntimeLibcall;
+ def ATOMIC_FETCH_NAND_#MemSize : RuntimeLibcall;
+ }
+}
+
+multiclass AtomicOrderSizeLibcall {
+ def _RELAX : RuntimeLibcall;
+ def _ACQ : RuntimeLibcall;
+ def _REL : RuntimeLibcall;
+ def _ACQ_REL : RuntimeLibcall;
+}
+
+// Out-of-line atomics libcalls
+defset list<RuntimeLibcall> LibCalls__OutOfLineAtomic = {
+ foreach MemSize = [1, 2, 4, 8, 16] in {
+ defm OUTLINE_ATOMIC_CAS#MemSize : AtomicOrderSizeLibcall;
+ defm OUTLINE_ATOMIC_SWP#MemSize : AtomicOrderSizeLibcall;
+ defm OUTLINE_ATOMIC_LDADD#MemSize : AtomicOrderSizeLibcall;
+ defm OUTLINE_ATOMIC_LDSET#MemSize : AtomicOrderSizeLibcall;
+ defm OUTLINE_ATOMIC_LDCLR#MemSize : AtomicOrderSizeLibcall;
+ defm OUTLINE_ATOMIC_LDEOR#MemSize : AtomicOrderSizeLibcall;
+ }
+}
+
+// Stack Protector Fail
+def STACKPROTECTOR_CHECK_FAIL : RuntimeLibcall;
+
+// Deoptimization
+def DEOPTIMIZE : RuntimeLibcall;
+
+// Return address
+def RETURN_ADDRESS : RuntimeLibcall;
+
+// Clear cache
+def CLEAR_CACHE : RuntimeLibcall;
+def RISCV_FLUSH_ICACHE : RuntimeLibcall;
+
+multiclass LibmLongDoubleLibCall<string libcall_basename = !toupper(NAME),
+ string rtbasename = NAME> {
+ def NAME#"_f128"
+ : RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_F128"),
+ !strconcat(rtbasename, "l")>;
+ def NAME#"_ppcf128"
+ : RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_PPCF128"),
+ !strconcat(rtbasename, "l")>;
+ def NAME#"_f80"
+ : RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_F80"),
+ !strconcat(rtbasename, "l")>;
+}
+
+//--------------------------------------------------------------------
+// Define implementation default libcalls
+//--------------------------------------------------------------------
+
+defset list<RuntimeLibcallImpl> DefaultRuntimeLibcallImpls = {
+let IsDefault = true in {
+
+//--------------------------------------------------------------------
+// compiler-rt / libgcc
+//--------------------------------------------------------------------
+
+def __ashlhi3 : RuntimeLibcallImpl<SHL_I16>;
+def __ashlsi3 : RuntimeLibcallImpl<SHL_I32>;
+def __ashldi3 : RuntimeLibcallImpl<SHL_I64>;
+def __ashlti3 : RuntimeLibcallImpl<SHL_I128>;
+
+def __lshrhi3 : RuntimeLibcallImpl<SRL_I16>;
+def __lshrsi3 : RuntimeLibcallImpl<SRL_I32>;
+def __lshrdi3 : RuntimeLibcallImpl<SRL_I64>;
+def __lshrti3 : RuntimeLibcallImpl<SRL_I128>;
+
+def __ashrhi3 : RuntimeLibcallImpl<SRA_I16>;
+def __ashrsi3 : RuntimeLibcallImpl<SRA_I32>;
+def __ashrdi3 : RuntimeLibcallImpl<SRA_I64>;
+def __ashrti3 : RuntimeLibcallImpl<SRA_I128>;
+
+def __mulqi3 : RuntimeLibcallImpl<MUL_I8>;
+def __mulhi3 : RuntimeLibcallImpl<MUL_I16>;
+def __mulsi3 : RuntimeLibcallImpl<MUL_I32>;
+def __muldi3 : RuntimeLibcallImpl<MUL_I64>;
+def __multi3 : RuntimeLibcallImpl<MUL_I128>;
+
+def __mulosi4 : RuntimeLibcallImpl<MULO_I32>;
+def __mulodi4 : RuntimeLibcallImpl<MULO_I64>;
+def __muloti4 : RuntimeLibcallImpl<MULO_I128>;
+
+def __divqi3 : RuntimeLibcallImpl<SDIV_I8>;
+def __divhi3 : RuntimeLibcallImpl<SDIV_I16>;
+def __divsi3 : RuntimeLibcallImpl<SDIV_I32>;
+def __divdi3 : RuntimeLibcallImpl<SDIV_I64>;
+def __divti3 : RuntimeLibcallImpl<SDIV_I128>;
+
+def __udivqi3 : RuntimeLibcallImpl<UDIV_I8>;
+def __udivhi3 : RuntimeLibcallImpl<UDIV_I16>;
+def __udivsi3 : RuntimeLibcallImpl<UDIV_I32>;
+def __udivdi3 : RuntimeLibcallImpl<UDIV_I64>;
+def __udivti3 : RuntimeLibcallImpl<UDIV_I128>;
+
+def __modqi3 : RuntimeLibcallImpl<SREM_I8>;
+def __modhi3 : RuntimeLibcallImpl<SREM_I16>;
+def __modsi3 : RuntimeLibcallImpl<SREM_I32>;
+def __moddi3 : RuntimeLibcallImpl<SREM_I64>;
+def __modti3 : RuntimeLibcallImpl<SREM_I128>;
+
+def __umodqi3 : RuntimeLibcallImpl<UREM_I8>;
+def __umodhi3 : RuntimeLibcallImpl<UREM_I16>;
+def __umodsi3 : RuntimeLibcallImpl<UREM_I32>;
+def __umoddi3 : RuntimeLibcallImpl<UREM_I64>;
+def __umodti3 : RuntimeLibcallImpl<UREM_I128>;
+
+def __negsi2 : RuntimeLibcallImpl<NEG_I32>;
+def __negdi2 : RuntimeLibcallImpl<NEG_I64>;
+
+def __clzsi2 : RuntimeLibcallImpl<CTLZ_I32>;
+def __clzdi2 : RuntimeLibcallImpl<CTLZ_I64>;
+def __clzti2 : RuntimeLibcallImpl<CTLZ_I128>;
+
+def __popcountsi2 : RuntimeLibcallImpl<CTPOP_I32>;
+def __popcountdi2 : RuntimeLibcallImpl<CTPOP_I64>;
+def __popcountti2 : RuntimeLibcallImpl<CTPOP_I128>;
+
+def __addsf3 : RuntimeLibcallImpl<ADD_F32>;
+def __adddf3 : RuntimeLibcallImpl<ADD_F64>;
+def __addxf3 : RuntimeLibcallImpl<ADD_F80>;
+def __addtf3 : RuntimeLibcallImpl<ADD_F128>;
+def __gcc_qadd : RuntimeLibcallImpl<ADD_PPCF128>;
+
+def __subsf3 : RuntimeLibcallImpl<SUB_F32>;
+def __subdf3 : RuntimeLibcallImpl<SUB_F64>;
+def __subxf3 : RuntimeLibcallImpl<SUB_F80>;
+def __subtf3 : RuntimeLibcallImpl<SUB_F128>;
+def __gcc_qsub : RuntimeLibcallImpl<SUB_PPCF128>;
+
+def __mulsf3 : RuntimeLibcallImpl<MUL_F32>;
+def __muldf3 : RuntimeLibcallImpl<MUL_F64>;
+def __mulxf3 : RuntimeLibcallImpl<MUL_F80>;
+def __multf3 : RuntimeLibcallImpl<MUL_F128>;
+def __gcc_qmul : RuntimeLibcallImpl<MUL_PPCF128>;
+
+def __divsf3 : RuntimeLibcallImpl<DIV_F32>;
+def __divdf3 : RuntimeLibcallImpl<DIV_F64>;
+def __divxf3 : RuntimeLibcallImpl<DIV_F80>;
+def __divtf3 : RuntimeLibcallImpl<DIV_F128>;
+def __gcc_qdiv : RuntimeLibcallImpl<DIV_PPCF128>;
+
+def __powisf2 : RuntimeLibcallImpl<POWI_F32>;
+def __powidf2 : RuntimeLibcallImpl<POWI_F64>;
+def __powixf2 : RuntimeLibcallImpl<POWI_F80>;
+def __powitf2_f128 : RuntimeLibcallImpl<POWI_F128, "__powitf2">;
+def __powitf2_ppc128 : RuntimeLibcallImpl<POWI_PPCF128, "__powitf2">;
+
+// Conversion
+def __extendbfsf2 : RuntimeLibcallImpl<FPEXT_BF16_F32>;
+def __gcc_stoq : RuntimeLibcallImpl<FPEXT_F32_PPCF128>;
+def __gcc_dtoq : RuntimeLibcallImpl<FPEXT_F64_PPCF128>;
+def __extendxftf2 : RuntimeLibcallImpl<FPEXT_F80_F128>;
+def __extenddftf2 : RuntimeLibcallImpl<FPEXT_F64_F128>;
+def __extendsftf2 : RuntimeLibcallImpl<FPEXT_F32_F128>;
+def __extendhftf2 : RuntimeLibcallImpl<FPEXT_F16_F128>;
+def __extendhfxf2 : RuntimeLibcallImpl<FPEXT_F16_F80>;
+def __extendsfdf2 : RuntimeLibcallImpl<FPEXT_F32_F64>;
+def __extendhfdf2 : RuntimeLibcallImpl<FPEXT_F16_F64>;
+def __extendhfsf2 : RuntimeLibcallImpl<FPEXT_F16_F32>;
+def __truncsfhf2 : RuntimeLibcallImpl<FPROUND_F32_F16>;
+def __truncdfhf2 : RuntimeLibcallImpl<FPROUND_F64_F16>;
+def __truncxfhf2 : RuntimeLibcallImpl<FPROUND_F80_F16>;
+def __trunctfhf2_f128 : RuntimeLibcallImpl<FPROUND_F128_F16, "__trunctfhf2">;
+def __trunctfhf2_ppcf128 : RuntimeLibcallImpl<FPROUND_PPCF128_F16, "__trunctfhf2">;
+def __truncsfbf2 : RuntimeLibcallImpl<FPROUND_F32_BF16>;
+def __truncdfbf2 : RuntimeLibcallImpl<FPROUND_F64_BF16>;
+def __truncxfbf2 : RuntimeLibcallImpl<FPROUND_F80_BF16>;
+def __trunctfbf2 : RuntimeLibcallImpl<FPROUND_F128_BF16>;
+def __truncdfsf2 : RuntimeLibcallImpl<FPROUND_F64_F32>;
+def __truncxfsf2 : RuntimeLibcallImpl<FPROUND_F80_F32>;
+def __trunctfsf2 : RuntimeLibcallImpl<FPROUND_F128_F32>;
+def __gcc_qtos : RuntimeLibcallImpl<FPROUND_PPCF128_F32>;
+def __truncxfdf2 : RuntimeLibcallImpl<FPROUND_F80_F64>;
+def __trunctfdf2 : RuntimeLibcallImpl<FPROUND_F128_F64>;
+def __gcc_qtod : RuntimeLibcallImpl<FPROUND_PPCF128_F64>;
+def __trunctfxf2 : RuntimeLibcallImpl<FPROUND_F128_F80>;
+def __fixhfsi : RuntimeLibcallImpl<FPTOSINT_F16_I32>;
+def __fixhfdi : RuntimeLibcallImpl<FPTOSINT_F16_I64>;
+def __fixhfti : RuntimeLibcallImpl<FPTOSINT_F16_I128>;
+def __fixsfsi : RuntimeLibcallImpl<FPTOSINT_F32_I32>;
+def __fixsfdi : RuntimeLibcallImpl<FPTOSINT_F32_I64>;
+def __fixsfti : RuntimeLibcallImpl<FPTOSINT_F32_I128>;
+def __fixdfsi : RuntimeLibcallImpl<FPTOSINT_F64_I32>;
+def __fixdfdi : RuntimeLibcallImpl<FPTOSINT_F64_I64>;
+def __fixdfti : RuntimeLibcallImpl<FPTOSINT_F64_I128>;
+def __fixxfsi : RuntimeLibcallImpl<FPTOSINT_F80_I32>;
+def __fixxfdi : RuntimeLibcallImpl<FPTOSINT_F80_I64>;
+def __fixxfti : RuntimeLibcallImpl<FPTOSINT_F80_I128>;
+def __fixtfsi : RuntimeLibcallImpl<FPTOSINT_F128_I32>;
+def __fixtfdi_f128 : RuntimeLibcallImpl<FPTOSINT_F128_I64, "__fixtfdi">;
+def __fixtfti_f128 : RuntimeLibcallImpl<FPTOSINT_F128_I128, "__fixtfti">;
+def __gcc_qtou : RuntimeLibcallImpl<FPTOSINT_PPCF128_I32>;
+def __fixtfdi_ppcf128 : RuntimeLibcallImpl<FPTOSINT_PPCF128_I64, "__fixtfdi">;
+def __fixtfti_ppcf128 : RuntimeLibcallImpl<FPTOSINT_PPCF128_I128, "__fixtfti">;
+def __fixunshfsi : RuntimeLibcallImpl<FPTOUINT_F16_I32>;
+def __fixunshfdi : RuntimeLibcallImpl<FPTOUINT_F16_I64>;
+def __fixunshfti : RuntimeLibcallImpl<FPTOUINT_F16_I128>;
+def __fixunssfsi : RuntimeLibcallImpl<FPTOUINT_F32_I32>;
+def __fixunssfdi : RuntimeLibcallImpl<FPTOUINT_F32_I64>;
+def __fixunssfti : RuntimeLibcallImpl<FPTOUINT_F32_I128>;
+def __fixunsdfsi : RuntimeLibcallImpl<FPTOUINT_F64_I32>;
+def __fixunsdfdi : RuntimeLibcallImpl<FPTOUINT_F64_I64>;
+def __fixunsdfti : RuntimeLibcallImpl<FPTOUINT_F64_I128>;
+def __fixunsxfsi : RuntimeLibcallImpl<FPTOUINT_F80_I32>;
+def __fixunsxfdi : RuntimeLibcallImpl<FPTOUINT_F80_I64>;
+def __fixunsxfti : RuntimeLibcallImpl<FPTOUINT_F80_I128>;
+def __fixunstfsi_f128 : RuntimeLibcallImpl<FPTOUINT_F128_I32, "__fixunstfsi">;
+def __fixunstfdi_f128 : RuntimeLibcallImpl<FPTOUINT_F128_I64, "__fixunstfdi">;
+def __fixunstfti_f128 : RuntimeLibcallImpl<FPTOUINT_F128_I128, "__fixunstfti">;
+def __fixunstfsi_ppcf128 : RuntimeLibcallImpl<FPTOUINT_PPCF128_I32, "__fixunstfsi">;
+def __fixunstfdi_ppcf128 : RuntimeLibcallImpl<FPTOUINT_PPCF128_I64, "__fixunstfdi">;
+def __fixunstfti_ppcf128 : RuntimeLibcallImpl<FPTOUINT_PPCF128_I128, "__fixunstfti">;
+def __floatsihf : RuntimeLibcallImpl<SINTTOFP_I32_F16>;
+def __floatsisf : RuntimeLibcallImpl<SINTTOFP_I32_F32>;
+def __floatsidf : RuntimeLibcallImpl<SINTTOFP_I32_F64>;
+def __floatsixf : RuntimeLibcallImpl<SINTTOFP_I32_F80>;
+def __floatsitf : RuntimeLibcallImpl<SINTTOFP_I32_F128>;
+def __gcc_itoq : RuntimeLibcallImpl<SINTTOFP_I32_PPCF128>;
+def __floatdibf : RuntimeLibcallImpl<SINTTOFP_I64_BF16>;
+def __floatdihf : RuntimeLibcallImpl<SINTTOFP_I64_F16>;
+def __floatdisf : RuntimeLibcallImpl<SINTTOFP_I64_F32>;
+def __floatdidf : RuntimeLibcallImpl<SINTTOFP_I64_F64>;
+def __floatdixf : RuntimeLibcallImpl<SINTTOFP_I64_F80>;
+def __floatditf_f128 : RuntimeLibcallImpl<SINTTOFP_I64_F128, "__floatditf">;
+def __floatditf_ppcf128 : RuntimeLibcallImpl<SINTTOFP_I64_PPCF128, "__floatditf">;
+def __floattihf : RuntimeLibcallImpl<SINTTOFP_I128_F16>;
+def __floattisf : RuntimeLibcallImpl<SINTTOFP_I128_F32>;
+def __floattidf : RuntimeLibcallImpl<SINTTOFP_I128_F64>;
+def __floattixf : RuntimeLibcallImpl<SINTTOFP_I128_F80>;
+def __floattitf_f128 : RuntimeLibcallImpl<SINTTOFP_I128_F128, "__floattitf">;
+def __floattitf_ppcf128 : RuntimeLibcallImpl<SINTTOFP_I128_PPCF128, "__floattitf">;
+def __floatunsihf : RuntimeLibcallImpl<UINTTOFP_I32_F16>;
+def __floatunsisf : RuntimeLibcallImpl<UINTTOFP_I32_F32>;
+def __floatunsidf : RuntimeLibcallImpl<UINTTOFP_I32_F64>;
+def __floatunsixf : RuntimeLibcallImpl<UINTTOFP_I32_F80>;
+def __floatunsitf : RuntimeLibcallImpl<UINTTOFP_I32_F128>;
+def __gcc_utoq : RuntimeLibcallImpl<UINTTOFP_I32_PPCF128>;
+def __floatundibf : RuntimeLibcallImpl<UINTTOFP_I64_BF16>;
+def __floatundihf : RuntimeLibcallImpl<UINTTOFP_I64_F16>;
+def __floatundisf : RuntimeLibcallImpl<UINTTOFP_I64_F32>;
+def __floatundidf : RuntimeLibcallImpl<UINTTOFP_I64_F64>;
+def __floatundixf : RuntimeLibcallImpl<UINTTOFP_I64_F80>;
+def __floatunditf_f128 : RuntimeLibcallImpl<UINTTOFP_I64_F128, "__floatunditf">;
+def __floatunditf_ppcf128 : RuntimeLibcallImpl<UINTTOFP_I64_PPCF128, "__floatunditf">;
+def __floatuntihf : RuntimeLibcallImpl<UINTTOFP_I128_F16>;
+def __floatuntisf : RuntimeLibcallImpl<UINTTOFP_I128_F32>;
+def __floatuntidf : RuntimeLibcallImpl<UINTTOFP_I128_F64>;
+def __floatuntixf : RuntimeLibcallImpl<UINTTOFP_I128_F80>;
+def __floatuntitf_f128 : RuntimeLibcallImpl<UINTTOFP_I128_F128, "__floatuntitf">;
+def __floatuntitf_ppcf128 : RuntimeLibcallImpl<UINTTOFP_I128_PPCF128, "__floatuntitf">;
+def __extendkftf2 : RuntimeLibcallImpl<CONVERT_F128_PPCF128>;
+def __trunctfkf2 : RuntimeLibcallImpl<CONVERT_PPCF128_F128>;
+
+// Comparison
+def __eqsf2 : RuntimeLibcallImpl<OEQ_F32>;
+def __eqdf2 : RuntimeLibcallImpl<OEQ_F64>;
+def __eqtf2 : RuntimeLibcallImpl<OEQ_F128>;
+def __gcc_qeq : RuntimeLibcallImpl<OEQ_PPCF128>;
+def __nesf2 : RuntimeLibcallImpl<UNE_F32>;
+def __nedf2 : RuntimeLibcallImpl<UNE_F64>;
+def __netf2 : RuntimeLibcallImpl<UNE_F128>;
+def __gcc_qne : RuntimeLibcallImpl<UNE_PPCF128>;
+def __gesf2 : RuntimeLibcallImpl<OGE_F32>;
+def __gedf2 : RuntimeLibcallImpl<OGE_F64>;
+def __getf2 : RuntimeLibcallImpl<OGE_F128>;
+def __gcc_qge : RuntimeLibcallImpl<OGE_PPCF128>;
+def __ltsf2 : RuntimeLibcallImpl<OLT_F32>;
+def __ltdf2 : RuntimeLibcallImpl<OLT_F64>;
+def __lttf2 : RuntimeLibcallImpl<OLT_F128>;
+def __gcc_qlt : RuntimeLibcallImpl<OLT_PPCF128>;
+def __lesf2 : RuntimeLibcallImpl<OLE_F32>;
+def __ledf2 : RuntimeLibcallImpl<OLE_F64>;
+def __letf2 : RuntimeLibcallImpl<OLE_F128>;
+def __gcc_qle : RuntimeLibcallImpl<OLE_PPCF128>;
+def __gtsf2 : RuntimeLibcallImpl<OGT_F32>;
+def __gtdf2 : RuntimeLibcallImpl<OGT_F64>;
+def __gttf2 : RuntimeLibcallImpl<OGT_F128>;
+def __gcc_qgt : RuntimeLibcallImpl<OGT_PPCF128>;
+def __unordsf2 : RuntimeLibcallImpl<UO_F32>;
+def __unorddf2 : RuntimeLibcallImpl<UO_F64>;
+def __unordtf2 : RuntimeLibcallImpl<UO_F128>;
+def __gcc_qunord : RuntimeLibcallImpl<UO_PPCF128>;
+
+// Element-wise unordered-atomic memory of different sizes
+foreach MemSize = [ 1, 2, 4, 8, 16 ] in {
+ def __llvm_memcpy_element_unordered_atomic_#MemSize : RuntimeLibcallImpl<
+ !cast<RuntimeLibcall>("MEMCPY_ELEMENT_UNORDERED_ATOMIC_"#MemSize)>;
+
+ def __llvm_memmove_element_unordered_atomic_#MemSize : RuntimeLibcallImpl<
+ !cast<RuntimeLibcall>("MEMMOVE_ELEMENT_UNORDERED_ATOMIC_"#MemSize)>;
+
+ def __llvm_memset_element_unordered_atomic_#MemSize : RuntimeLibcallImpl<
+ !cast<RuntimeLibcall>("MEMSET_ELEMENT_UNORDERED_ATOMIC_"#MemSize)>;
+}
+
+// Exception handling
+def _Unwind_Resume : RuntimeLibcallImpl<UNWIND_RESUME>;
+def __cxa_end_cleanup : RuntimeLibcallImpl<CXA_END_CLEANUP>;
+
+// Atomic '__sync_*' libcalls.
+foreach lc = LibCalls__sync in {
+ def __#!tolower(!cast<string>(lc)) : RuntimeLibcallImpl<lc>;
+}
+
+// Atomic `__atomic_*' libcalls.
+foreach lc = LibCalls__atomic in {
+ def __#!tolower(!cast<string>(lc)) : RuntimeLibcallImpl<lc>;
+}
+
+// Stack Protector Fail
+def __stack_chk_fail : RuntimeLibcallImpl<STACKPROTECTOR_CHECK_FAIL>;
+
+// Deoptimization
+def __llvm_deoptimize : RuntimeLibcallImpl<DEOPTIMIZE>;
+
+// Clear cache
+def __clear_cache : RuntimeLibcallImpl<CLEAR_CACHE>;
+def __riscv_flush_icache : RuntimeLibcallImpl<RISCV_FLUSH_ICACHE>;
+
+//--------------------------------------------------------------------
+// libm
+//--------------------------------------------------------------------
+
+def fmodf : RuntimeLibcallImpl<REM_F32>;
+def fmod : RuntimeLibcallImpl<REM_F64>;
+def fmodl_f128 : RuntimeLibcallImpl<REM_F128, "fmodl">;
+def fmodl_f80 : RuntimeLibcallImpl<REM_F80, "fmodl">;
+def fmodl_ppc128 : RuntimeLibcallImpl<REM_PPCF128, "fmodl">;
+
+def fmaf : RuntimeLibcallImpl<FMA_F32>;
+def fma : RuntimeLibcallImpl<FMA_F64>;
+defm fma : LibmLongDoubleLibCall;
+
+def sqrtf : RuntimeLibcallImpl<SQRT_F32>;
+def sqrt : RuntimeLibcallImpl<SQRT_F64>;
+defm sqrt : LibmLongDoubleLibCall;
+
+def cbrtf : RuntimeLibcallImpl<CBRT_F32>;
+def cbrt : RuntimeLibcallImpl<CBRT_F64>;
+defm cbrt : LibmLongDoubleLibCall;
+
+def logf : RuntimeLibcallImpl<LOG_F32>;
+def log : RuntimeLibcallImpl<LOG_F64>;
+defm log : LibmLongDoubleLibCall;
+
+def __logf_finite : RuntimeLibcallImpl<LOG_FINITE_F32>;
+def __log_finite : RuntimeLibcallImpl<LOG_FINITE_F64>;
+def __logl_finite_f80 : RuntimeLibcallImpl<LOG_FINITE_F80, "__logl_finite">;
+def __logl_finite_f128 : RuntimeLibcallImpl<LOG_FINITE_F128, "__logl_finite">;
+def __logl_finite_ppcf128 : RuntimeLibcallImpl<LOG_FINITE_PPCF128, "__logl_finite">;
+
+def log2f : RuntimeLibcallImpl<LOG2_F32>;
+def log2 : RuntimeLibcallImpl<LOG2_F64>;
+defm log2 : LibmLongDoubleLibCall;
+
+def __log2f_finite : RuntimeLibcallImpl<LOG2_FINITE_F32>;
+def __log2_finite : RuntimeLibcallImpl<LOG2_FINITE_F64>;
+def __log2l_finite_f80 : RuntimeLibcallImpl<LOG2_FINITE_F80, "__log2l_finite">;
+def __log2l_finite_f128 : RuntimeLibcallImpl<LOG2_FINITE_F128, "__log2l_finite">;
+def __log2l_finite_ppcf128 : RuntimeLibcallImpl<LOG2_FINITE_PPCF128, "__log2l_finite">;
+
+def log10f : RuntimeLibcallImpl<LOG10_F32>;
+def log10 : RuntimeLibcallImpl<LOG10_F64>;
+defm log10 : LibmLongDoubleLibCall;
+
+def __log10f_finite : RuntimeLibcallImpl<LOG10_FINITE_F32>;
+def __log10_finite : RuntimeLibcallImpl<LOG10_FINITE_F64>;
+def __log10l_finite_f80 : RuntimeLibcallImpl<LOG10_FINITE_F80, "__log10l_finite">;
+def __log10l_finite_f128 : RuntimeLibcallImpl<LOG10_FINITE_F128, "__log10l_finite">;
+def __log10l_finite_ppcf128 : RuntimeLibcallImpl<LOG10_FINITE_PPCF128, "__log10l_finite">;
+
+def expf : RuntimeLibcallImpl<EXP_F32>;
+def exp : RuntimeLibcallImpl<EXP_F64>;
+defm exp : LibmLongDoubleLibCall<"EXP", "exp">;
+
+def __expf_finite : RuntimeLibcallImpl<EXP_FINITE_F32>;
+def __exp_finite : RuntimeLibcallImpl<EXP_FINITE_F64>;
+def __expl_finite_f80 : RuntimeLibcallImpl<EXP_FINITE_F80, "__expl_finite">;
+def __expl_finite_f128 : RuntimeLibcallImpl<EXP_FINITE_F128, "__expl_finite">;
+def __expl_finite_ppcf128 : RuntimeLibcallImpl<EXP_FINITE_PPCF128, "__expl_finite">;
+
+def exp2f : RuntimeLibcallImpl<EXP2_F32>;
+def exp2 : RuntimeLibcallImpl<EXP2_F64>;
+defm exp2 : LibmLongDoubleLibCall<"EXP2", "exp2">;
+
+def __exp2f_finite : RuntimeLibcallImpl<EXP2_FINITE_F32>;
+def __exp2_finite : RuntimeLibcallImpl<EXP2_FINITE_F64>;
+def __exp2l_finite_f80 : RuntimeLibcallImpl<EXP2_FINITE_F80, "__exp2l_finite">;
+def __exp2l_finite_f128 : RuntimeLibcallImpl<EXP2_FINITE_F128, "__exp2l_finite">;
+def __exp2l_finite_ppcf128 : RuntimeLibcallImpl<EXP2_FINITE_PPCF128, "__exp2l_finite">;
+
+def exp10f : RuntimeLibcallImpl<EXP10_F32>;
+def exp10 : RuntimeLibcallImpl<EXP10_F64>;
+def exp10l_f80 : RuntimeLibcallImpl<EXP10_F80, "exp10l">;
+def exp10l_f128 : RuntimeLibcallImpl<EXP10_F128, "exp10l">;
+def exp10l_ppcf128 : RuntimeLibcallImpl<EXP10_PPCF128, "exp10l">;
+
+def sinf : RuntimeLibcallImpl<SIN_F32>;
+def sin : RuntimeLibcallImpl<SIN_F64>;
+defm sin : LibmLongDoubleLibCall;
+
+def cosf : RuntimeLibcallImpl<COS_F32>;
+def cos : RuntimeLibcallImpl<COS_F64>;
+defm cos : LibmLongDoubleLibCall;
+
+def tanf : RuntimeLibcallImpl<TAN_F32>;
+def tan : RuntimeLibcallImpl<TAN_F64>;
+defm tan : LibmLongDoubleLibCall;
+
+def sinhf : RuntimeLibcallImpl<SINH_F32>;
+def sinh : RuntimeLibcallImpl<SINH_F64>;
+defm sinh : LibmLongDoubleLibCall;
+
+def coshf : RuntimeLibcallImpl<COSH_F32>;
+def cosh : RuntimeLibcallImpl<COSH_F64>;
+defm cosh : LibmLongDoubleLibCall;
+
+def tanhf : RuntimeLibcallImpl<TANH_F32>;
+def tanh : RuntimeLibcallImpl<TANH_F64>;
+defm tanh : LibmLongDoubleLibCall;
+
+def asinf : RuntimeLibcallImpl<ASIN_F32>;
+def asin : RuntimeLibcallImpl<ASIN_F64>;
+defm asin : LibmLongDoubleLibCall;
+
+def acosf : RuntimeLibcallImpl<ACOS_F32>;
+def acos : RuntimeLibcallImpl<ACOS_F64>;
+defm acos : LibmLongDoubleLibCall;
+
+def atanf : RuntimeLibcallImpl<ATAN_F32>;
+def atan : RuntimeLibcallImpl<ATAN_F64>;
+defm atan : LibmLongDoubleLibCall;
+
+def atan2f : RuntimeLibcallImpl<ATAN2_F32>;
+def atan2 : RuntimeLibcallImpl<ATAN2_F64>;
+defm atan2 : LibmLongDoubleLibCall;
+
+def powf : RuntimeLibcallImpl<POW_F32>;
+def pow : RuntimeLibcallImpl<POW_F64>;
+defm pow : LibmLongDoubleLibCall;
+
+def __powf_finite : RuntimeLibcallImpl<POW_FINITE_F32>;
+def __pow_finite : RuntimeLibcallImpl<POW_FINITE_F64>;
+def __powl_finite_f80 : RuntimeLibcallImpl<POW_FINITE_F80, "__powl_finite">;
+def __powl_finite_f128 : RuntimeLibcallImpl<POW_FINITE_F128, "__powl_finite">;
+def __powl_finite_ppcf128 : RuntimeLibcallImpl<POW_FINITE_PPCF128, "__powl_finite">;
+
+def ceilf : RuntimeLibcallImpl<CEIL_F32>;
+def ceil : RuntimeLibcallImpl<CEIL_F64>;
+defm ceil : LibmLongDoubleLibCall;
+
+def truncf : RuntimeLibcallImpl<TRUNC_F32>;
+def trunc : RuntimeLibcallImpl<TRUNC_F64>;
+defm trunc : LibmLongDoubleLibCall;
+
+def rintf : RuntimeLibcallImpl<RINT_F32>;
+def rint : RuntimeLibcallImpl<RINT_F64>;
+defm rint : LibmLongDoubleLibCall;
+
+def nearbyintf : RuntimeLibcallImpl<NEARBYINT_F32>;
+def nearbyint : RuntimeLibcallImpl<NEARBYINT_F64>;
+defm nearbyint : LibmLongDoubleLibCall;
+
+def roundf : RuntimeLibcallImpl<ROUND_F32>;
+def round : RuntimeLibcallImpl<ROUND_F64>;
+defm round : LibmLongDoubleLibCall;
+
+def roundevenf : RuntimeLibcallImpl<ROUNDEVEN_F32>;
+def roundeven : RuntimeLibcallImpl<ROUNDEVEN_F64>;
+defm roundeven : LibmLongDoubleLibCall;
+
+def floorf : RuntimeLibcallImpl<FLOOR_F32>;
+def floor : RuntimeLibcallImpl<FLOOR_F64>;
+defm floor : LibmLongDoubleLibCall;
+
+def copysignf : RuntimeLibcallImpl<COPYSIGN_F32>;
+def copysign : RuntimeLibcallImpl<COPYSIGN_F64>;
+defm copysign : LibmLongDoubleLibCall;
+
+def fminf : RuntimeLibcallImpl<FMIN_F32>;
+def fmin : RuntimeLibcallImpl<FMIN_F64>;
+defm fmin : LibmLongDoubleLibCall;
+
+def fmaxf : RuntimeLibcallImpl<FMAX_F32>;
+def fmax : RuntimeLibcallImpl<FMAX_F64>;
+defm fmax : LibmLongDoubleLibCall;
+
+def fminimumf : RuntimeLibcallImpl<FMINIMUM_F32>;
+def fminimum : RuntimeLibcallImpl<FMINIMUM_F64>;
+defm fminimum : LibmLongDoubleLibCall;
+
+def fmaximumf : RuntimeLibcallImpl<FMAXIMUM_F32>;
+def fmaximum : RuntimeLibcallImpl<FMAXIMUM_F64>;
+defm fmaximum : LibmLongDoubleLibCall;
+
+def fminimum_numf : RuntimeLibcallImpl<FMINIMUM_NUM_F32>;
+def fminimum_num : RuntimeLibcallImpl<FMINIMUM_NUM_F64>;
+defm fminimum_num : LibmLongDoubleLibCall;
+
+def fmaximum_numf : RuntimeLibcallImpl<FMAXIMUM_NUM_F32>;
+def fmaximum_num : RuntimeLibcallImpl<FMAXIMUM_NUM_F64>;
+defm fmaximum_num : LibmLongDoubleLibCall;
+
+def lroundf : RuntimeLibcallImpl<LROUND_F32>;
+def lround : RuntimeLibcallImpl<LROUND_F64>;
+defm lround : LibmLongDoubleLibCall;
+
+def llroundf : RuntimeLibcallImpl<LLROUND_F32>;
+def llround : RuntimeLibcallImpl<LLROUND_F64>;
+defm llround : LibmLongDoubleLibCall;
+
+def lrintf : RuntimeLibcallImpl<LRINT_F32>;
+def lrint : RuntimeLibcallImpl<LRINT_F64>;
+defm lrint : LibmLongDoubleLibCall;
+
+def llrintf : RuntimeLibcallImpl<LLRINT_F32>;
+def llrint : RuntimeLibcallImpl<LLRINT_F64>;
+defm llrint : LibmLongDoubleLibCall;
+
+def ldexpf : RuntimeLibcallImpl<LDEXP_F32>;
+def ldexp : RuntimeLibcallImpl<LDEXP_F64>;
+defm ldexp : LibmLongDoubleLibCall;
+
+def frexpf : RuntimeLibcallImpl<FREXP_F32>;
+def frexp : RuntimeLibcallImpl<FREXP_F64>;
+defm frexp : LibmLongDoubleLibCall;
+
+def sincospif : RuntimeLibcallImpl<SINCOSPI_F32>;
+def sincospi : RuntimeLibcallImpl<SINCOSPI_F64>;
+defm sincospi : LibmLongDoubleLibCall;
+
+def modff : RuntimeLibcallImpl<MODF_F32>;
+def modf : RuntimeLibcallImpl<MODF_F64>;
+defm modf : LibmLongDoubleLibCall;
+
+// Floating point environment
+def fegetenv : RuntimeLibcallImpl<FEGETENV>;
+def fesetenv : RuntimeLibcallImpl<FESETENV>;
+
+// Floating point control modes
+def fegetmode : RuntimeLibcallImpl<FEGETMODE>;
+def fesetmode : RuntimeLibcallImpl<FESETMODE>;
+
+//--------------------------------------------------------------------
+// libc
+//--------------------------------------------------------------------
+
+// Memory
+def memcpy : RuntimeLibcallImpl<MEMCPY>;
+def memmove : RuntimeLibcallImpl<MEMMOVE>;
+def memset : RuntimeLibcallImpl<MEMSET>;
+
+// DSEPass can emit calloc if it finds a pair of malloc/memset
+def calloc : RuntimeLibcallImpl<CALLOC>;
+
+} // End let IsDefault = true
+} // End defset DefaultRuntimeLibcallImpls
+
+//--------------------------------------------------------------------
+// Define implementation other libcalls
+//--------------------------------------------------------------------
+
+// TODO: Define other custom names targets use to override
+
+def __exp10f : RuntimeLibcallImpl<EXP10_F32>;
+def __exp10 : RuntimeLibcallImpl<EXP10_F64>;
+
+def __sincosf_stret : RuntimeLibcallImpl<SINCOS_STRET_F32>;
+def __sincos_stret : RuntimeLibcallImpl<SINCOS_STRET_F64>;
+
+def sincosf : RuntimeLibcallImpl<SINCOS_F32>;
+def sincos : RuntimeLibcallImpl<SINCOS_F64>;
+defm sincos : LibmLongDoubleLibCall;
+
+def bzero : RuntimeLibcallImpl<BZERO>;
+def __bzero : RuntimeLibcallImpl<BZERO>;
+def _Unwind_SjLj_Resume : RuntimeLibcallImpl<UNWIND_RESUME>;
+
+//===----------------------------------------------------------------------===//
+// F128 libm Runtime Libcalls
+//===----------------------------------------------------------------------===//
+
+def logf128 : RuntimeLibcallImpl<LOG_F128>;
+def log2f128 : RuntimeLibcallImpl<LOG2_F128>;
+def log10f128 : RuntimeLibcallImpl<LOG10_F128>;
+def expf128 : RuntimeLibcallImpl<EXP_F128>;
+def exp2f128 : RuntimeLibcallImpl<EXP2_F128>;
+def exp10f128 : RuntimeLibcallImpl<EXP10_F128>;
+def sinf128 : RuntimeLibcallImpl<SIN_F128>;
+def cosf128 : RuntimeLibcallImpl<COS_F128>;
+def tanf128 : RuntimeLibcallImpl<TAN_F128>;
+def tanhf128 : RuntimeLibcallImpl<TAN_F128>;
+def sincosf128 : RuntimeLibcallImpl<SINCOS_F128>;
+def powf128 : RuntimeLibcallImpl<POW_F128>;
+def fminf128 : RuntimeLibcallImpl<FMIN_F128>;
+def fmaxf128 : RuntimeLibcallImpl<FMAX_F128>;
+def fmodf128 : RuntimeLibcallImpl<REM_F128>;
+def sqrtf128 : RuntimeLibcallImpl<SQRT_F128>;
+def ceilf128 : RuntimeLibcallImpl<CEIL_F128>;
+def floorf128 : RuntimeLibcallImpl<FLOOR_F128>;
+def truncf128 : RuntimeLibcallImpl<TRUNC_F128>;
+def roundf128 : RuntimeLibcallImpl<ROUND_F128>;
+def lroundf128 : RuntimeLibcallImpl<LROUND_F128>;
+def llroundf128 : RuntimeLibcallImpl<LLROUND_F128>;
+def rintf128 : RuntimeLibcallImpl<RINT_F128>;
+def lrintf128 : RuntimeLibcallImpl<LRINT_F128>;
+def llrintf128 : RuntimeLibcallImpl<LLRINT_F128>;
+def nearbyintf128 : RuntimeLibcallImpl<NEARBYINT_F128>;
+def fmaf128 : RuntimeLibcallImpl<FMA_F128>;
+def frexpf128 : RuntimeLibcallImpl<FREXP_F128>;
+
+def cbrtf128 : RuntimeLibcallImpl<CBRT_F128>;
+def fminimumf128 : RuntimeLibcallImpl<FMINIMUM_F128>;
+def fmaximumf128 : RuntimeLibcallImpl<FMAXIMUM_F128>;
+def fminimum_numf128 : RuntimeLibcallImpl<FMINIMUM_NUM_F128>;
+def fmaximum_numf128 : RuntimeLibcallImpl<FMAXIMUM_NUM_F128>;
+def asinf128 : RuntimeLibcallImpl<ASIN_F128>;
+def acosf128 : RuntimeLibcallImpl<ACOS_F128>;
+def atanf128 : RuntimeLibcallImpl<ATAN_F128>;
+def atan2f128 : RuntimeLibcallImpl<ATAN2_F128>;
+def ldexpf128 : RuntimeLibcallImpl<LDEXP_F128>;
+def roundevenf128 : RuntimeLibcallImpl<ROUNDEVEN_F128>;
+def modff128 : RuntimeLibcallImpl<MODF_F128>;
+def sinhf128 : RuntimeLibcallImpl<SINH_F128>;
+def coshf128 : RuntimeLibcallImpl<COSH_F128>;
+def copysignf128 : RuntimeLibcallImpl<COPYSIGN_F128>;
+
+def __logf128_finite : RuntimeLibcallImpl<LOG_FINITE_F128>;
+def __log2f128_finite : RuntimeLibcallImpl<LOG2_FINITE_F128>;
+def __log10f128_finite : RuntimeLibcallImpl<LOG10_FINITE_F128>;
+def __expf128_finite : RuntimeLibcallImpl<EXP_FINITE_F128>;
+def __exp2f128_finite : RuntimeLibcallImpl<EXP2_FINITE_F128>;
+def __exp10f128_finite : RuntimeLibcallImpl<EXP10_FINITE_F128>;
+def __powf128_finite : RuntimeLibcallImpl<POW_FINITE_F128>;
+
+//===----------------------------------------------------------------------===//
+// PPC Runtime Libcalls
+//===----------------------------------------------------------------------===//
+
+class PPCRuntimeLibcallImpl<RuntimeLibcall P, string Name = NAME>
+ : RuntimeLibcallImpl<P, Name>;
+
+// For IEEE quad-precision libcall names, PPC uses "kf" instead of "tf".
+def __addkf3 : PPCRuntimeLibcallImpl<ADD_F128>;
+def __subkf3 : PPCRuntimeLibcallImpl<SUB_F128>;
+def __mulkf3 : PPCRuntimeLibcallImpl<MUL_F128>;
+def __divkf3 : PPCRuntimeLibcallImpl<DIV_F128>;
+def __powikf2 : PPCRuntimeLibcallImpl<POWI_F128>;
+def __extendsfkf2 : PPCRuntimeLibcallImpl<FPEXT_F32_F128>;
+def __extenddfkf2 : PPCRuntimeLibcallImpl<FPEXT_F64_F128>;
+def __trunckfhf2 : PPCRuntimeLibcallImpl<FPROUND_F128_F16>;
+def __trunckfsf2 : PPCRuntimeLibcallImpl<FPROUND_F128_F32>;
+def __trunckfdf2 : PPCRuntimeLibcallImpl<FPROUND_F128_F64>;
+def __fixkfsi : PPCRuntimeLibcallImpl<FPTOSINT_F128_I32>;
+def __fixkfdi : PPCRuntimeLibcallImpl<FPTOSINT_F128_I64>;
+def __fixkfti : PPCRuntimeLibcallImpl<FPTOSINT_F128_I128>;
+def __fixunskfsi : PPCRuntimeLibcallImpl<FPTOUINT_F128_I32>;
+def __fixunskfdi : PPCRuntimeLibcallImpl<FPTOUINT_F128_I64>;
+def __fixunskfti : PPCRuntimeLibcallImpl<FPTOUINT_F128_I128>;
+def __floatsikf : PPCRuntimeLibcallImpl<SINTTOFP_I32_F128>;
+def __floatdikf : PPCRuntimeLibcallImpl<SINTTOFP_I64_F128>;
+def __floattikf : PPCRuntimeLibcallImpl<SINTTOFP_I128_F128>;
+def __floatunsikf : PPCRuntimeLibcallImpl<UINTTOFP_I32_F128>;
+def __floatundikf : PPCRuntimeLibcallImpl<UINTTOFP_I64_F128>;
+def __floatuntikf : PPCRuntimeLibcallImpl<UINTTOFP_I128_F128>;
+def __eqkf2 : PPCRuntimeLibcallImpl<OEQ_F128>;
+def __nekf2 : PPCRuntimeLibcallImpl<UNE_F128>;
+def __gekf2 : PPCRuntimeLibcallImpl<OGE_F128>;
+def __ltkf2 : PPCRuntimeLibcallImpl<OLT_F128>;
+def __lekf2 : PPCRuntimeLibcallImpl<OLE_F128>;
+def __gtkf2 : PPCRuntimeLibcallImpl<OGT_F128>;
+def __unordkf2 : PPCRuntimeLibcallImpl<UO_F128>;
+
+//===----------------------------------------------------------------------===//
+// ZOS Runtime Libcalls
+//===----------------------------------------------------------------------===//
+
+class ZOSRuntimeLibcallImpl<RuntimeLibcall P, string Name = NAME>
+ : RuntimeLibcallImpl<P, Name>;
+
+def zos___TRNC_B : ZOSRuntimeLibcallImpl<TRUNC_F64, "@@TRNC at B">;
+def zos___FTRC_B : ZOSRuntimeLibcallImpl<TRUNC_F32, "@@FTRC at B">;
+def zos___LTRC_B : ZOSRuntimeLibcallImpl<TRUNC_F128, "@@LTRC at B">;
+def zos___WSQT_B : ZOSRuntimeLibcallImpl<SQRT_F64, "@@WSQT at B">;
+def zos___FSQT_B : ZOSRuntimeLibcallImpl<SQRT_F32, "@@FSQT at B">;
+def zos___LSQT_B : ZOSRuntimeLibcallImpl<SQRT_F128, "@@LSQT at B">;
+def zos___SSIN_B : ZOSRuntimeLibcallImpl<SIN_F64, "@@SSIN at B">;
+def zos___FSIN_B : ZOSRuntimeLibcallImpl<SIN_F32, "@@FSIN at B">;
+def zos___LSIN_B : ZOSRuntimeLibcallImpl<SIN_F128, "@@LSIN at B">;
+def zos___ROUN_B : ZOSRuntimeLibcallImpl<ROUND_F64, "@@ROUN at B">;
+def zos___ROUNFB : ZOSRuntimeLibcallImpl<ROUND_F32, "@@ROUNFB">;
+def zos___ROUNLB : ZOSRuntimeLibcallImpl<ROUND_F128, "@@ROUNLB">;
+def zos___SRNT_B : ZOSRuntimeLibcallImpl<RINT_F64, "@@SRNT at B">;
+def zos___RINTFB : ZOSRuntimeLibcallImpl<RINT_F32, "@@RINTFB">;
+def zos___RINTLB : ZOSRuntimeLibcallImpl<RINT_F128, "@@RINTLB">;
+def zos___WFMD_B : ZOSRuntimeLibcallImpl<REM_F64, "@@WFMD at B">;
+def zos___FFMD_B : ZOSRuntimeLibcallImpl<REM_F32, "@@FFMD at B">;
+def zos___LFMD_B : ZOSRuntimeLibcallImpl<REM_F128, "@@LFMD at B">;
+def zos___WPOW_B : ZOSRuntimeLibcallImpl<POW_F64, "@@WPOW at B">;
+def zos___FPOW_B : ZOSRuntimeLibcallImpl<POW_F32, "@@FPOW at B">;
+def zos___LPOW_B : ZOSRuntimeLibcallImpl<POW_F128, "@@LPOW at B">;
+def zos___NBYI_B : ZOSRuntimeLibcallImpl<NEARBYINT_F64, "@@NBYI at B">;
+def zos___NBYIFB : ZOSRuntimeLibcallImpl<NEARBYINT_F32, "@@NBYIFB">;
+def zos___NBYILB : ZOSRuntimeLibcallImpl<NEARBYINT_F128, "@@NBYILB">;
+def zos___ROND_B : ZOSRuntimeLibcallImpl<LROUND_F64, "@@ROND at B">;
+def zos___FRND_B : ZOSRuntimeLibcallImpl<LROUND_F32, "@@FRND at B">;
+def zos___LRND_B : ZOSRuntimeLibcallImpl<LROUND_F128, "@@LRND at B">;
+def zos___LRNT_B : ZOSRuntimeLibcallImpl<LRINT_F64, "@@LRNT at B">;
+def zos___LRNTFB : ZOSRuntimeLibcallImpl<LRINT_F32, "@@LRNTFB">;
+def zos___LRNTLB : ZOSRuntimeLibcallImpl<LRINT_F128, "@@LRNTLB">;
+def zos___WLOG_B : ZOSRuntimeLibcallImpl<LOG_F64, "@@WLOG at B">;
+def zos___FLOG_B : ZOSRuntimeLibcallImpl<LOG_F32, "@@FLOG at B">;
+def zos___LLOG_B : ZOSRuntimeLibcallImpl<LOG_F128, "@@LLOG at B">;
+def zos___LOG2_B : ZOSRuntimeLibcallImpl<LOG2_F64, "@@LOG2 at B">;
+def zos___FLG2_B : ZOSRuntimeLibcallImpl<LOG2_F32, "@@FLG2 at B">;
+def zos___LLG2_B : ZOSRuntimeLibcallImpl<LOG2_F128, "@@LLG2 at B">;
+def zos___WLG1_B : ZOSRuntimeLibcallImpl<LOG10_F64, "@@WLG1 at B">;
+def zos___FLG1_B : ZOSRuntimeLibcallImpl<LOG10_F32, "@@FLG1 at B">;
+def zos___LLG1_B : ZOSRuntimeLibcallImpl<LOG10_F128, "@@LLG1 at B">;
+def zos___LLRD_B : ZOSRuntimeLibcallImpl<LLROUND_F64, "@@LLRD at B">;
+def zos___LLRDFB : ZOSRuntimeLibcallImpl<LLROUND_F32, "@@LLRDFB">;
+def zos___LLRDLB : ZOSRuntimeLibcallImpl<LLROUND_F128, "@@LLRDLB">;
+def zos___LLRT_B : ZOSRuntimeLibcallImpl<LLRINT_F64, "@@LLRT at B">;
+def zos___LLRTFB : ZOSRuntimeLibcallImpl<LLRINT_F32, "@@LLRTFB">;
+def zos___LLRTLB : ZOSRuntimeLibcallImpl<LLRINT_F128, "@@LLRTLB">;
+def zos___SLXP_B : ZOSRuntimeLibcallImpl<LDEXP_F64, "@@SLXP at B">;
+def zos___FLXP_B : ZOSRuntimeLibcallImpl<LDEXP_F32, "@@FLXP at B">;
+def zos___LLXP_B : ZOSRuntimeLibcallImpl<LDEXP_F128, "@@LLXP at B">;
+def zos___SFXP_B : ZOSRuntimeLibcallImpl<FREXP_F64, "@@SFXP at B">;
+def zos___FFXP_B : ZOSRuntimeLibcallImpl<FREXP_F32, "@@FFXP at B">;
+def zos___LFXP_B : ZOSRuntimeLibcallImpl<FREXP_F128, "@@LFXP at B">;
+def zos___FMIN_B : ZOSRuntimeLibcallImpl<FMIN_F64, "@@FMIN at B">;
+def zos___FMINFB : ZOSRuntimeLibcallImpl<FMIN_F32, "@@FMINFB">;
+def zos___FMINLB : ZOSRuntimeLibcallImpl<FMIN_F128, "@@FMINLB">;
+def zos___FMA_B : ZOSRuntimeLibcallImpl<FMA_F64, "@@FMA at B">;
+def zos___FMAFB : ZOSRuntimeLibcallImpl<FMA_F32, "@@FMAFB">;
+def zos___FMALB : ZOSRuntimeLibcallImpl<FMA_F128, "@@FMALB">;
+def zos___FMAX_B : ZOSRuntimeLibcallImpl<FMAX_F64, "@@FMAX at B">;
+def zos___FMAXFB : ZOSRuntimeLibcallImpl<FMAX_F32, "@@FMAXFB">;
+def zos___FMAXLB : ZOSRuntimeLibcallImpl<FMAX_F128, "@@FMAXLB">;
+def zos___SFLR_B : ZOSRuntimeLibcallImpl<FLOOR_F64, "@@SFLR at B">;
+def zos___FFLR_B : ZOSRuntimeLibcallImpl<FLOOR_F32, "@@FFLR at B">;
+def zos___LFLR_B : ZOSRuntimeLibcallImpl<FLOOR_F128, "@@LFLR at B">;
+def zos___WEXP_B : ZOSRuntimeLibcallImpl<EXP_F64, "@@WEXP at B">;
+def zos___FEXP_B : ZOSRuntimeLibcallImpl<EXP_F32, "@@FEXP at B">;
+def zos___LEXP_B : ZOSRuntimeLibcallImpl<EXP_F128, "@@LEXP at B">;
+def zos___EXP2_B : ZOSRuntimeLibcallImpl<EXP2_F64, "@@EXP2 at B">;
+def zos___FXP2_B : ZOSRuntimeLibcallImpl<EXP2_F32, "@@FXP2 at B">;
+def zos___LXP2_B : ZOSRuntimeLibcallImpl<EXP2_F128, "@@LXP2 at B">;
+def zos___SCOS_B : ZOSRuntimeLibcallImpl<COS_F64, "@@SCOS at B">;
+def zos___FCOS_B : ZOSRuntimeLibcallImpl<COS_F32, "@@FCOS at B">;
+def zos___LCOS_B : ZOSRuntimeLibcallImpl<COS_F128, "@@LCOS at B">;
+def zos___DCPY_B : ZOSRuntimeLibcallImpl<COPYSIGN_F64, "@@DCPY at B">;
+def zos___FCPY_B : ZOSRuntimeLibcallImpl<COPYSIGN_F32, "@@FCPY at B">;
+def zos___LCPY_B : ZOSRuntimeLibcallImpl<COPYSIGN_F128, "@@LCPY at B">;
+def zos___SCEL_B : ZOSRuntimeLibcallImpl<CEIL_F64, "@@SCEL at B">;
+def zos___FCEL_B : ZOSRuntimeLibcallImpl<CEIL_F32, "@@FCEL at B">;
+def zos___LCEL_B : ZOSRuntimeLibcallImpl<CEIL_F128, "@@LCEL at B">;
+def zos___SCRT_B : ZOSRuntimeLibcallImpl<CBRT_F64, "@@SCRT at B">;
+def zos___FCBT_B : ZOSRuntimeLibcallImpl<CBRT_F32, "@@FCBT at B">;
+def zos___LCBT_B : ZOSRuntimeLibcallImpl<CBRT_F128, "@@LCBT at B">;
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
new file mode 100644
index 0000000000000..9444a0a838cdd
--- /dev/null
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -0,0 +1,32 @@
+//===-- llvm/RuntimeLibcalls.td - File that describes libcalls ------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+/// 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
+/// long double types cannot be merged, because 80-bit library
+/// functions use "xf" and 128-bit use "tf".
+///
+/// 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 {
+ string Name = NAME;
+
+ // TODO: Record type signature and attributes
+}
+
+// Concrete implementation of a libcall, which may have a different
+// name and only be valid on some subset of targets.
+
+// TODO: Do we need a way to conditionally select calling convention?
+class RuntimeLibcallImpl<RuntimeLibcall P, string Name = NAME> {
+ RuntimeLibcall Provides = P;
+ string LibCallFuncName = Name;
+ bit IsDefault = false;
+}
diff --git a/llvm/include/module.modulemap b/llvm/include/module.modulemap
index 9d7dbb8e4b071..a4bd6b9ed370d 100644
--- a/llvm/include/module.modulemap
+++ b/llvm/include/module.modulemap
@@ -268,7 +268,6 @@ module LLVM_IR {
textual header "llvm/IR/FixedMetadataKinds.def"
textual header "llvm/IR/Value.def"
textual header "llvm/IR/VPIntrinsics.def"
- textual header "llvm/IR/RuntimeLibcalls.def"
}
module LLVM_IRReader {
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 627c9fa8fac2a..632bd4d53dbd0 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -12,6 +12,12 @@
using namespace llvm;
using namespace RTLIB;
+#define GET_INIT_RUNTIME_LIBCALL_UTILS
+#define GET_INIT_RUNTIME_LIBCALL_NAMES
+#include "llvm/IR/RuntimeLibcalls.inc"
+#undef GET_INIT_RUNTIME_LIBCALL_UTILS
+#undef GET_INIT_RUNTIME_LIBCALL_NAMES
+
static cl::opt<bool>
HexagonEnableFastMathRuntimeCalls("hexagon-fast-math", cl::Hidden,
cl::desc("Enable Fast Math processing"));
@@ -30,34 +36,21 @@ static void setAArch64LibcallNames(RuntimeLibcallsInfo &Info,
LCALLNAMES(A, B, 1) \
LCALLNAMES(A, B, 2) \
LCALLNAMES(A, B, 4) LCALLNAMES(A, B, 8) LCALLNAMES(A, B, 16)
- LCALLNAME5(RTLIB::OUTLINE_ATOMIC_CAS, __aarch64_cas)
- LCALLNAME4(RTLIB::OUTLINE_ATOMIC_SWP, __aarch64_swp)
- LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDADD, __aarch64_ldadd)
- LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDSET, __aarch64_ldset)
- LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDCLR, __aarch64_ldclr)
- LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDEOR, __aarch64_ldeor)
if (TT.isWindowsArm64EC()) {
- // FIXME: are there calls we need to exclude from this?
-#define HANDLE_LIBCALL(code, name) \
- if (sizeof(name) != 1) { \
- const char *libcallName = Info.getLibcallName(RTLIB::code); \
- if (libcallName && libcallName[0] != '#') { \
- assert(strcmp(libcallName, name) == 0 && "Unexpected name"); \
- Info.setLibcallName(RTLIB::code, "#" name); \
- } \
- }
-#define LIBCALL_NO_NAME ""
-#include "llvm/IR/RuntimeLibcalls.def"
-#undef HANDLE_LIBCALL
-#undef LIBCALL_NO_NAME
-
LCALLNAME5(RTLIB::OUTLINE_ATOMIC_CAS, #__aarch64_cas)
LCALLNAME4(RTLIB::OUTLINE_ATOMIC_SWP, #__aarch64_swp)
LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDADD, #__aarch64_ldadd)
LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDSET, #__aarch64_ldset)
LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDCLR, #__aarch64_ldclr)
LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDEOR, #__aarch64_ldeor)
+ } else {
+ LCALLNAME5(RTLIB::OUTLINE_ATOMIC_CAS, __aarch64_cas)
+ LCALLNAME4(RTLIB::OUTLINE_ATOMIC_SWP, __aarch64_swp)
+ LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDADD, __aarch64_ldadd)
+ LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDSET, __aarch64_ldset)
+ LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDCLR, __aarch64_ldclr)
+ LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDEOR, __aarch64_ldeor)
}
#undef LCALLNAMES
@@ -354,22 +347,20 @@ static void setLongDoubleIsF128Libm(RuntimeLibcallsInfo &Info,
}
}
+void RuntimeLibcallsInfo::initDefaultLibCallNames() {
+ std::memcpy(LibcallRoutineNames, DefaultLibcallRoutineNames,
+ sizeof(LibcallRoutineNames));
+ static_assert(sizeof(LibcallRoutineNames) ==
+ sizeof(DefaultLibcallRoutineNames),
+ "libcall array size should match");
+}
+
/// Set default libcall names. If a target wants to opt-out of a libcall it
/// should be placed here.
void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
ExceptionHandling ExceptionModel,
FloatABI::ABIType FloatABI,
EABI EABIVersion) {
- initSoftFloatCmpLibcallPredicates();
-
- initSoftFloatCmpLibcallPredicates();
-
-#define HANDLE_LIBCALL(code, name) setLibcallName(RTLIB::code, name);
-#define LIBCALL_NO_NAME nullptr
-#include "llvm/IR/RuntimeLibcalls.def"
-#undef HANDLE_LIBCALL
-#undef LIBCALL_NO_NAME
-
// Use the f128 variants of math functions on x86
if (TT.isX86() && TT.isGNUEnvironment())
setLongDoubleIsF128Libm(*this, /*FiniteOnlyFuncs=*/true);
@@ -379,37 +370,8 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
setLibcallName(RTLIB::UNWIND_RESUME, "_Unwind_SjLj_Resume");
}
- // For IEEE quad-precision libcall names, PPC uses "kf" instead of "tf".
if (TT.isPPC()) {
- setLibcallName(RTLIB::ADD_F128, "__addkf3");
- setLibcallName(RTLIB::SUB_F128, "__subkf3");
- setLibcallName(RTLIB::MUL_F128, "__mulkf3");
- setLibcallName(RTLIB::DIV_F128, "__divkf3");
- setLibcallName(RTLIB::POWI_F128, "__powikf2");
- setLibcallName(RTLIB::FPEXT_F32_F128, "__extendsfkf2");
- setLibcallName(RTLIB::FPEXT_F64_F128, "__extenddfkf2");
- setLibcallName(RTLIB::FPROUND_F128_F16, "__trunckfhf2");
- setLibcallName(RTLIB::FPROUND_F128_F32, "__trunckfsf2");
- setLibcallName(RTLIB::FPROUND_F128_F64, "__trunckfdf2");
- setLibcallName(RTLIB::FPTOSINT_F128_I32, "__fixkfsi");
- setLibcallName(RTLIB::FPTOSINT_F128_I64, "__fixkfdi");
- setLibcallName(RTLIB::FPTOSINT_F128_I128, "__fixkfti");
- setLibcallName(RTLIB::FPTOUINT_F128_I32, "__fixunskfsi");
- setLibcallName(RTLIB::FPTOUINT_F128_I64, "__fixunskfdi");
- setLibcallName(RTLIB::FPTOUINT_F128_I128, "__fixunskfti");
- setLibcallName(RTLIB::SINTTOFP_I32_F128, "__floatsikf");
- setLibcallName(RTLIB::SINTTOFP_I64_F128, "__floatdikf");
- setLibcallName(RTLIB::SINTTOFP_I128_F128, "__floattikf");
- setLibcallName(RTLIB::UINTTOFP_I32_F128, "__floatunsikf");
- setLibcallName(RTLIB::UINTTOFP_I64_F128, "__floatundikf");
- setLibcallName(RTLIB::UINTTOFP_I128_F128, "__floatuntikf");
- setLibcallName(RTLIB::OEQ_F128, "__eqkf2");
- setLibcallName(RTLIB::UNE_F128, "__nekf2");
- setLibcallName(RTLIB::OGE_F128, "__gekf2");
- setLibcallName(RTLIB::OLT_F128, "__ltkf2");
- setLibcallName(RTLIB::OLE_F128, "__lekf2");
- setLibcallName(RTLIB::OGT_F128, "__gtkf2");
- setLibcallName(RTLIB::UO_F128, "__unordkf2");
+ setPPCLibCallNameOverrides();
// TODO: Do the finite only functions exist?
setLongDoubleIsF128Libm(*this, /*FiniteOnlyFuncs=*/false);
@@ -522,7 +484,7 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
// Disable most libcalls on AMDGPU and NVPTX.
if (TT.isAMDGPU() || TT.isNVPTX()) {
for (RTLIB::Libcall LC : RTLIB::libcalls()) {
- if (LC < RTLIB::ATOMIC_LOAD || LC > RTLIB::ATOMIC_FETCH_NAND_16)
+ if (!isAtomicLibCall(LC))
setLibcallName(LC, nullptr);
}
}
@@ -554,11 +516,13 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
}
}
- if (TT.isAArch64())
+ if (TT.isAArch64()) {
+ if (TT.isWindowsArm64EC())
+ setWindowsArm64LibCallNameOverrides();
setAArch64LibcallNames(*this, TT);
- else if (TT.isARM() || TT.isThumb())
+ } else if (TT.isARM() || TT.isThumb()) {
setARMLibcallNames(*this, TT, FloatABI, EABIVersion);
- else if (TT.getArch() == Triple::ArchType::avr) {
+ } else if (TT.getArch() == Triple::ArchType::avr) {
// Division rtlib functions (not supported), use divmod functions instead
setLibcallName(RTLIB::SDIV_I8, nullptr);
setLibcallName(RTLIB::SDIV_I16, nullptr);
@@ -611,19 +575,6 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
setLibcallName(RTLIB::RETURN_ADDRESS, "emscripten_return_address");
}
- if (TT.isSystemZ() && TT.isOSzOS()) {
- struct RTLibCallMapping {
- RTLIB::Libcall Code;
- const char *Name;
- };
- static RTLibCallMapping RTLibCallCommon[] = {
-#define HANDLE_LIBCALL(code, name) {RTLIB::code, name},
-#include "ZOSLibcallNames.def"
- };
- for (auto &E : RTLibCallCommon)
- setLibcallName(E.Code, E.Name);
- }
-
if (TT.getArch() == Triple::ArchType::hexagon) {
setLibcallName(RTLIB::SDIV_I32, "__hexagon_divsi3");
setLibcallName(RTLIB::SDIV_I64, "__hexagon_divdi3");
@@ -664,4 +615,7 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
if (TT.getArch() == Triple::ArchType::msp430)
setMSP430Libcalls(*this, TT);
+
+ if (TT.isSystemZ() && TT.isOSzOS())
+ setZOSLibCallNameOverrides();
}
diff --git a/llvm/lib/IR/ZOSLibcallNames.def b/llvm/lib/IR/ZOSLibcallNames.def
deleted file mode 100644
index 12a01522a7e64..0000000000000
--- a/llvm/lib/IR/ZOSLibcallNames.def
+++ /dev/null
@@ -1,100 +0,0 @@
-//===-- ZOSLibcallNames.def ----------------------------------- -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines all of the runtime library functions on z/OS which can be
-// generated during instruction selection.
-//
-//===----------------------------------------------------------------------===//
-
-#if !defined(HANDLE_LIBCALL)
-#error "HANDLE_LIBCALL must be defined"
-#endif
-
-HANDLE_LIBCALL(TRUNC_F64, "@@TRNC at B")
-HANDLE_LIBCALL(TRUNC_F32, "@@FTRC at B")
-HANDLE_LIBCALL(TRUNC_F128, "@@LTRC at B")
-HANDLE_LIBCALL(SQRT_F64, "@@WSQT at B")
-HANDLE_LIBCALL(SQRT_F32, "@@FSQT at B")
-HANDLE_LIBCALL(SQRT_F128, "@@LSQT at B")
-HANDLE_LIBCALL(SIN_F64, "@@SSIN at B")
-HANDLE_LIBCALL(SIN_F32, "@@FSIN at B")
-HANDLE_LIBCALL(SIN_F128, "@@LSIN at B")
-HANDLE_LIBCALL(ROUND_F64, "@@ROUN at B")
-HANDLE_LIBCALL(ROUND_F32, "@@ROUNFB")
-HANDLE_LIBCALL(ROUND_F128, "@@ROUNLB")
-HANDLE_LIBCALL(RINT_F64, "@@SRNT at B")
-HANDLE_LIBCALL(RINT_F32, "@@RINTFB")
-HANDLE_LIBCALL(RINT_F128, "@@RINTLB")
-HANDLE_LIBCALL(REM_F64, "@@WFMD at B")
-HANDLE_LIBCALL(REM_F32, "@@FFMD at B")
-HANDLE_LIBCALL(REM_F128, "@@LFMD at B")
-HANDLE_LIBCALL(POW_F64, "@@WPOW at B")
-HANDLE_LIBCALL(POW_F32, "@@FPOW at B")
-HANDLE_LIBCALL(POW_F128, "@@LPOW at B")
-HANDLE_LIBCALL(NEARBYINT_F64, "@@NBYI at B")
-HANDLE_LIBCALL(NEARBYINT_F32, "@@NBYIFB")
-HANDLE_LIBCALL(NEARBYINT_F128, "@@NBYILB")
-HANDLE_LIBCALL(LROUND_F64, "@@ROND at B")
-HANDLE_LIBCALL(LROUND_F32, "@@FRND at B")
-HANDLE_LIBCALL(LROUND_F128, "@@LRND at B")
-HANDLE_LIBCALL(LRINT_F64, "@@LRNT at B")
-HANDLE_LIBCALL(LRINT_F32, "@@LRNTFB")
-HANDLE_LIBCALL(LRINT_F128, "@@LRNTLB")
-HANDLE_LIBCALL(LOG_F64, "@@WLOG at B")
-HANDLE_LIBCALL(LOG_F32, "@@FLOG at B")
-HANDLE_LIBCALL(LOG_F128, "@@LLOG at B")
-HANDLE_LIBCALL(LOG2_F64, "@@LOG2 at B")
-HANDLE_LIBCALL(LOG2_F32, "@@FLG2 at B")
-HANDLE_LIBCALL(LOG2_F128, "@@LLG2 at B")
-HANDLE_LIBCALL(LOG10_F64, "@@WLG1 at B")
-HANDLE_LIBCALL(LOG10_F32, "@@FLG1 at B")
-HANDLE_LIBCALL(LOG10_F128, "@@LLG1 at B")
-HANDLE_LIBCALL(LLROUND_F64, "@@LLRD at B")
-HANDLE_LIBCALL(LLROUND_F32, "@@LLRDFB")
-HANDLE_LIBCALL(LLROUND_F128, "@@LLRDLB")
-HANDLE_LIBCALL(LLRINT_F64, "@@LLRT at B")
-HANDLE_LIBCALL(LLRINT_F32, "@@LLRTFB")
-HANDLE_LIBCALL(LLRINT_F128, "@@LLRTLB")
-HANDLE_LIBCALL(LDEXP_F64, "@@SLXP at B")
-HANDLE_LIBCALL(LDEXP_F32, "@@FLXP at B")
-HANDLE_LIBCALL(LDEXP_F128, "@@LLXP at B")
-HANDLE_LIBCALL(FREXP_F64, "@@SFXP at B")
-HANDLE_LIBCALL(FREXP_F32, "@@FFXP at B")
-HANDLE_LIBCALL(FREXP_F128, "@@LFXP at B")
-HANDLE_LIBCALL(FMIN_F64, "@@FMIN at B")
-HANDLE_LIBCALL(FMIN_F32, "@@FMINFB")
-HANDLE_LIBCALL(FMIN_F128, "@@FMINLB")
-HANDLE_LIBCALL(FMA_F64, "@@FMA at B")
-HANDLE_LIBCALL(FMA_F32, "@@FMAFB")
-HANDLE_LIBCALL(FMA_F128, "@@FMALB")
-HANDLE_LIBCALL(FMAX_F64, "@@FMAX at B")
-HANDLE_LIBCALL(FMAX_F32, "@@FMAXFB")
-HANDLE_LIBCALL(FMAX_F128, "@@FMAXLB")
-HANDLE_LIBCALL(FLOOR_F64, "@@SFLR at B")
-HANDLE_LIBCALL(FLOOR_F32, "@@FFLR at B")
-HANDLE_LIBCALL(FLOOR_F128, "@@LFLR at B")
-HANDLE_LIBCALL(EXP_F64, "@@WEXP at B")
-HANDLE_LIBCALL(EXP_F32, "@@FEXP at B")
-HANDLE_LIBCALL(EXP_F128, "@@LEXP at B")
-HANDLE_LIBCALL(EXP2_F64, "@@EXP2 at B")
-HANDLE_LIBCALL(EXP2_F32, "@@FXP2 at B")
-HANDLE_LIBCALL(EXP2_F128, "@@LXP2 at B")
-HANDLE_LIBCALL(COS_F64, "@@SCOS at B")
-HANDLE_LIBCALL(COS_F32, "@@FCOS at B")
-HANDLE_LIBCALL(COS_F128, "@@LCOS at B")
-HANDLE_LIBCALL(COPYSIGN_F64, "@@DCPY at B")
-HANDLE_LIBCALL(COPYSIGN_F32, "@@FCPY at B")
-HANDLE_LIBCALL(COPYSIGN_F128, "@@LCPY at B")
-HANDLE_LIBCALL(CEIL_F64, "@@SCEL at B")
-HANDLE_LIBCALL(CEIL_F32, "@@FCEL at B")
-HANDLE_LIBCALL(CEIL_F128, "@@LCEL at B")
-HANDLE_LIBCALL(CBRT_F64, "@@SCRT at B")
-HANDLE_LIBCALL(CBRT_F32, "@@FCBT at B")
-HANDLE_LIBCALL(CBRT_F128, "@@LCBT at B")
-
-#undef HANDLE_LIBCALL
diff --git a/llvm/lib/Object/IRSymtab.cpp b/llvm/lib/Object/IRSymtab.cpp
index 494ec089d7bd1..2f25c771a93fa 100644
--- a/llvm/lib/Object/IRSymtab.cpp
+++ b/llvm/lib/Object/IRSymtab.cpp
@@ -48,7 +48,7 @@ static cl::opt<bool> DisableBitcodeVersionUpgrade(
static const char *PreservedSymbols[] = {
// There are global variables, so put it here instead of in
- // RuntimeLibcalls.def.
+ // RuntimeLibcalls.td.
// TODO: Are there similar such variables?
"__ssp_canary_word",
"__stack_chk_guard",
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter.td b/llvm/test/TableGen/RuntimeLibcallEmitter.td
new file mode 100644
index 0000000000000..8f66bedf860c8
--- /dev/null
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter.td
@@ -0,0 +1,40 @@
+// RUN: llvm-tblgen -gen-runtime-libcalls -I %p/../../include %s | FileCheck %s
+
+include "llvm/IR/RuntimeLibcallsImpl.td"
+
+
+def SHL_I32 : RuntimeLibcall;
+def SRL_I64 : RuntimeLibcall;
+def BZERO : RuntimeLibcall;
+
+// Test default names.
+let IsDefault = true in {
+ def __ashlsi3 : RuntimeLibcallImpl<SHL_I32>;
+ def __lshrdi3 : RuntimeLibcallImpl<SRL_I64>;
+}
+
+// Ignore non-default in initDefaultLibCallNames.
+def bzero : RuntimeLibcallImpl<BZERO>;
+
+// All entries should be emitted in Libcall enum.
+// CHECK: #ifdef GET_RUNTIME_LIBCALL_ENUM
+// CHECK-NEXT: namespace llvm {
+// CHECK-NEXT: namespace RTLIB {
+// CHECK-NEXT: enum Libcall {
+// CHECK-NEXT: BZERO = 0,
+// CHECK-NEXT: SHL_I32 = 1,
+// CHECK-NEXT: SRL_I64 = 2,
+// CHECK-NEXT: UNKNOWN_LIBCALL = 3
+// CHECK-NEXT: };
+// CHECK-EMPTY:
+// CHECK-NEXT: } // End namespace RTLIB
+// CHECK-NEXT: } // End namespace llvm
+// CHECK-NEXT: #endif
+
+// CHECK: #ifdef GET_INIT_RUNTIME_LIBCALL_NAMES
+// CHECK-NEXT: const char *const llvm::RTLIB::RuntimeLibcallsInfo::DefaultLibcallRoutineNames[RTLIB::UNKNOWN_LIBCALL + 1] = {
+// CHECK-NEXT: nullptr, // RTLIB::BZERO
+// CHECK-NEXT: "__ashlsi3", // RTLIB::SHL_I32
+// CHECK-NEXT: "__lshrdi3", // RTLIB::SRL_I64
+// CHECK-NEXT: nullptr // RTLIB::UNKNOWN_LIBCALL
+// CHECK-NEXT: };
diff --git a/llvm/utils/TableGen/Basic/CMakeLists.txt b/llvm/utils/TableGen/Basic/CMakeLists.txt
index 1f4d3a7bc123c..b4a66ecce6440 100644
--- a/llvm/utils/TableGen/Basic/CMakeLists.txt
+++ b/llvm/utils/TableGen/Basic/CMakeLists.txt
@@ -15,6 +15,7 @@ add_llvm_library(LLVMTableGenBasic OBJECT EXCLUDE_FROM_ALL DISABLE_LLVM_LINK_LLV
DirectiveEmitter.cpp
IntrinsicEmitter.cpp
RISCVTargetDefEmitter.cpp
+ RuntimeLibcallsEmitter.cpp
SDNodeProperties.cpp
TableGen.cpp
TargetFeaturesEmitter.cpp
diff --git a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
new file mode 100644
index 0000000000000..2691437e22edb
--- /dev/null
+++ b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
@@ -0,0 +1,305 @@
+//===- RuntimeLibcallEmitter.cpp - Properties from RuntimeLibcalls.td -----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+using namespace llvm;
+
+namespace {
+
+class RuntimeLibcall {
+ const Record *TheDef = nullptr;
+
+public:
+ RuntimeLibcall() = delete;
+ RuntimeLibcall(const Record *Def) : TheDef(Def) { assert(Def); }
+
+ ~RuntimeLibcall() { assert(TheDef); }
+
+ const Record *getDef() const { return TheDef; }
+
+ StringRef getName() const { return TheDef->getName(); }
+
+ void emitEnumEntry(raw_ostream &OS) const {
+ OS << "RTLIB::" << TheDef->getValueAsString("Name");
+ }
+};
+
+class RuntimeLibcallImpl {
+ const Record *TheDef;
+ const RuntimeLibcall *Provides = nullptr;
+
+public:
+ RuntimeLibcallImpl(
+ const Record *Def,
+ const DenseMap<const Record *, const RuntimeLibcall *> &ProvideMap)
+ : TheDef(Def) {
+ if (const Record *ProvidesDef = Def->getValueAsDef("Provides"))
+ Provides = ProvideMap.lookup(ProvidesDef);
+ }
+
+ ~RuntimeLibcallImpl() {}
+
+ const Record *getDef() const { return TheDef; }
+
+ StringRef getName() const { return TheDef->getName(); }
+
+ const RuntimeLibcall *getProvides() const { return Provides; }
+
+ StringRef getLibcallFuncName() const {
+ return TheDef->getValueAsString("LibCallFuncName");
+ }
+
+ void emitQuotedLibcallFuncName(raw_ostream &OS) const {
+ OS << '\"' << getLibcallFuncName() << '\"';
+ }
+
+ bool isDefault() const { return TheDef->getValueAsBit("IsDefault"); }
+
+ void emitEnumEntry(raw_ostream &OS) const {
+ OS << "RTLIB::" << TheDef->getName();
+ }
+};
+
+class RuntimeLibcallEmitter {
+private:
+ const RecordKeeper &Records;
+
+ DenseMap<const Record *, const RuntimeLibcall *> Def2RuntimeLibcall;
+
+ const RuntimeLibcall *getRuntimeLibcall(const Record *Def) const {
+ return Def2RuntimeLibcall.lookup(Def);
+ }
+
+ std::vector<RuntimeLibcall> RuntimeLibcallDefList;
+ std::vector<RuntimeLibcallImpl> RuntimeLibcallImplDefList;
+
+ DenseMap<const RuntimeLibcall *, const RuntimeLibcallImpl *>
+ LibCallToDefaultImpl;
+
+ void
+ emitTargetOverrideFunc(raw_ostream &OS, StringRef FuncName,
+ ArrayRef<RuntimeLibcallImpl> LibCallImplList) const;
+
+ void emitGetRuntimeLibcallEnum(raw_ostream &OS) const;
+
+ void emitWindowsArm64LibCallNameOverrides(raw_ostream &OS) const;
+
+ void emitGetInitRuntimeLibcallNames(raw_ostream &OS) const;
+ void emitGetInitRuntimeLibcallUtils(raw_ostream &OS) const;
+
+public:
+ RuntimeLibcallEmitter(const RecordKeeper &R) : Records(R) {
+
+ ArrayRef<const Record *> AllRuntimeLibcalls =
+ Records.getAllDerivedDefinitions("RuntimeLibcall");
+
+ RuntimeLibcallDefList.reserve(AllRuntimeLibcalls.size());
+
+ for (const Record *RuntimeLibcallDef : AllRuntimeLibcalls) {
+ RuntimeLibcallDefList.emplace_back(RuntimeLibcallDef);
+ Def2RuntimeLibcall[RuntimeLibcallDef] = &RuntimeLibcallDefList.back();
+ }
+
+ for (RuntimeLibcall &LibCall : RuntimeLibcallDefList)
+ Def2RuntimeLibcall[LibCall.getDef()] = &LibCall;
+
+ ArrayRef<const Record *> AllRuntimeLibcallImpls =
+ Records.getAllDerivedDefinitions("RuntimeLibcallImpl");
+ RuntimeLibcallImplDefList.reserve(AllRuntimeLibcallImpls.size());
+
+ for (const Record *LibCallImplDef : AllRuntimeLibcallImpls) {
+ RuntimeLibcallImplDefList.emplace_back(LibCallImplDef,
+ Def2RuntimeLibcall);
+
+ RuntimeLibcallImpl &LibCallImpl = RuntimeLibcallImplDefList.back();
+
+ // const RuntimeLibcallImpl &LibCallImpl =
+ // RuntimeLibcallImplDefList.back();
+ if (LibCallImpl.isDefault()) {
+ const RuntimeLibcall *Provides = LibCallImpl.getProvides();
+ if (!Provides)
+ PrintFatalError(LibCallImplDef->getLoc(),
+ "default implementations must provide a libcall");
+ LibCallToDefaultImpl[Provides] = &LibCallImpl;
+ }
+ }
+ }
+
+ std::vector<RuntimeLibcallImpl>
+ getRuntimeLibcallImplSet(StringRef Name) const {
+ std::vector<RuntimeLibcallImpl> Result;
+ ArrayRef<const Record *> ImplSet =
+ Records.getAllDerivedDefinitionsIfDefined(Name);
+ Result.reserve(ImplSet.size());
+
+ for (const Record *LibCallImplDef : ImplSet)
+ Result.emplace_back(LibCallImplDef, Def2RuntimeLibcall);
+ return Result;
+ }
+
+ void run(raw_ostream &OS);
+};
+
+} // End anonymous namespace.
+
+/// Emit a method \p FuncName of RTLIB::RuntimeLibcallsInfo to override the
+/// libcall names in \p LibCallImplList.
+void RuntimeLibcallEmitter::emitTargetOverrideFunc(
+ raw_ostream &OS, StringRef FuncName,
+ ArrayRef<RuntimeLibcallImpl> LibCallImplList) const {
+ OS << "void llvm::RTLIB::RuntimeLibcallsInfo::" << FuncName << "() {\n";
+
+ if (LibCallImplList.empty()) {
+ OS << " llvm_unreachable(\"override set not defined\");\n";
+ } else {
+ // for (const Record *LibCallImpl : LibCallImplList) {
+ for (const RuntimeLibcallImpl &LibCallImpl : LibCallImplList) {
+ const RuntimeLibcall *Provides = LibCallImpl.getProvides();
+ OS << " LibcallRoutineNames[";
+ Provides->emitEnumEntry(OS);
+ OS << "] = ";
+ LibCallImpl.emitQuotedLibcallFuncName(OS);
+ OS << ";\n";
+ }
+ }
+
+ OS << "}\n\n";
+}
+
+void RuntimeLibcallEmitter::emitGetRuntimeLibcallEnum(raw_ostream &OS) const {
+ OS << "#ifdef GET_RUNTIME_LIBCALL_ENUM\n"
+ "namespace llvm {\n"
+ "namespace RTLIB {\n"
+ "enum Libcall {\n";
+
+ size_t CallTypeEnumVal = 0;
+ for (const RuntimeLibcall &LibCall : RuntimeLibcallDefList) {
+ StringRef Name = LibCall.getName();
+ OS << " " << Name << " = " << CallTypeEnumVal++ << ",\n";
+ }
+
+ // TODO: Emit libcall names as string offset table.
+
+ OS << " UNKNOWN_LIBCALL = " << CallTypeEnumVal
+ << "\n};\n\n"
+ "} // End namespace RTLIB\n"
+ "} // End namespace llvm\n"
+ "#endif\n\n";
+}
+
+void RuntimeLibcallEmitter::emitWindowsArm64LibCallNameOverrides(
+ raw_ostream &OS) const {
+ // FIXME: Stop treating this as a special case
+ OS << "void "
+ "llvm::RTLIB::RuntimeLibcallsInfo::setWindowsArm64LibCallNameOverrides("
+ ") {\n"
+ " static const char *const "
+ "WindowsArm64RoutineNames[RTLIB::UNKNOWN_LIBCALL + 1] = {\n";
+ for (const RuntimeLibcall &LibCall : RuntimeLibcallDefList) {
+ auto I = LibCallToDefaultImpl.find(&LibCall);
+ if (I == LibCallToDefaultImpl.end())
+ OS << " nullptr,";
+ else {
+ const RuntimeLibcallImpl *LibCallImpl = I->second;
+ assert(LibCallImpl);
+ OS << " \"#" << LibCallImpl->getLibcallFuncName() << "\",";
+ }
+
+ OS << " // ";
+ LibCall.emitEnumEntry(OS);
+ OS << '\n';
+ }
+
+ OS << " nullptr // RTLIB::UNKNOWN_LIBCALL\n"
+ " };\n\n"
+ " std::memcpy(LibcallRoutineNames, WindowsArm64RoutineNames,\n"
+ " sizeof(LibcallRoutineNames));\n"
+ " static_assert(sizeof(LibcallRoutineNames) == "
+ "sizeof(WindowsArm64RoutineNames),\n"
+ " \"libcall array size should match\");\n"
+ "}\n#endif\n\n";
+}
+
+void RuntimeLibcallEmitter::emitGetInitRuntimeLibcallNames(
+ raw_ostream &OS) const {
+ // TODO: Emit libcall names as string offset table.
+
+ OS << "#ifdef GET_INIT_RUNTIME_LIBCALL_NAMES\n"
+ "const char *const "
+ "llvm::RTLIB::RuntimeLibcallsInfo::"
+ "DefaultLibcallRoutineNames[RTLIB::UNKNOWN_LIBCALL + 1] = {\n";
+
+ for (const RuntimeLibcall &LibCall : RuntimeLibcallDefList) {
+ auto I = LibCallToDefaultImpl.find(&LibCall);
+ if (I == LibCallToDefaultImpl.end())
+ OS << " nullptr,";
+ else {
+ const RuntimeLibcallImpl *LibCallImpl = I->second;
+ OS << " ";
+ LibCallImpl->emitQuotedLibcallFuncName(OS);
+ OS << ',';
+ }
+
+ OS << " // ";
+ LibCall.emitEnumEntry(OS);
+ OS << '\n';
+ }
+
+ OS << " nullptr // RTLIB::UNKNOWN_LIBCALL\n"
+ "};\n\n";
+
+ std::vector<RuntimeLibcallImpl> ZOSRuntimeLibcallImplList =
+ getRuntimeLibcallImplSet("ZOSRuntimeLibcallImpl");
+ emitTargetOverrideFunc(OS, "setZOSLibCallNameOverrides",
+ ZOSRuntimeLibcallImplList);
+
+ std::vector<RuntimeLibcallImpl> PPCRuntimeLibcallImplList =
+ getRuntimeLibcallImplSet("PPCRuntimeLibcallImpl");
+ emitTargetOverrideFunc(OS, "setPPCLibCallNameOverrides",
+ PPCRuntimeLibcallImplList);
+
+ emitWindowsArm64LibCallNameOverrides(OS);
+}
+
+void RuntimeLibcallEmitter::emitGetInitRuntimeLibcallUtils(
+ raw_ostream &OS) const {
+ // FIXME: Hack we shouldn't really need
+ OS << "#ifdef GET_INIT_RUNTIME_LIBCALL_UTILS\n"
+ "static inline bool isAtomicLibCall(llvm::RTLIB::Libcall LC) {\n"
+ " switch (LC) {\n";
+ for (const RuntimeLibcall &LibCall : RuntimeLibcallDefList) {
+ StringRef Name = LibCall.getName();
+ if (Name.contains("ATOMIC")) {
+ OS << " case ";
+ LibCall.emitEnumEntry(OS);
+ OS << ":\n";
+ }
+ }
+
+ OS << " return true;\n"
+ " default:\n"
+ " return false;\n"
+ " }\n\n"
+ " llvm_unreachable(\"covered switch over libcalls\");\n"
+ "}\n#endif\n\n";
+}
+
+void RuntimeLibcallEmitter::run(raw_ostream &OS) {
+ emitSourceFileHeader("Runtime LibCalls Source Fragment", OS, Records);
+ emitGetRuntimeLibcallEnum(OS);
+ emitGetInitRuntimeLibcallNames(OS);
+ emitGetInitRuntimeLibcallUtils(OS);
+}
+
+static TableGen::Emitter::OptClass<RuntimeLibcallEmitter>
+ X("gen-runtime-libcalls", "Generate RuntimeLibcalls");
diff --git a/llvm/utils/gn/secondary/llvm/utils/TableGen/Basic/BUILD.gn b/llvm/utils/gn/secondary/llvm/utils/TableGen/Basic/BUILD.gn
index 5838118f2711d..43916cef756ff 100644
--- a/llvm/utils/gn/secondary/llvm/utils/TableGen/Basic/BUILD.gn
+++ b/llvm/utils/gn/secondary/llvm/utils/TableGen/Basic/BUILD.gn
@@ -10,6 +10,7 @@ source_set("Basic") {
"DirectiveEmitter.cpp",
"IntrinsicEmitter.cpp",
"RISCVTargetDefEmitter.cpp",
+ "RuntimeLibcallsEmitter.cpp",
"SDNodeProperties.cpp",
"TableGen.cpp",
"TargetFeaturesEmitter.cpp",
More information about the llvm-branch-commits
mailing list