TableGen: Add runtime libcall backend (#144972)
Replace RuntimeLibcalls.def with a tablegenerated version. This is in preparation for splitting RuntimeLibcalls into two components. For now match the existing functionality.
This commit is contained in:
Matt Arsenault
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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, StringRef ABIName = "") {
|
||||
initSoftFloatCmpLibcallPredicates();
|
||||
initDefaultLibCallNames();
|
||||
initLibcalls(TT, ExceptionModel, FloatABI, EABIVersion, ABIName);
|
||||
}
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -157,6 +150,17 @@ private:
|
||||
(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
|
||||
|
||||
1054
llvm/include/llvm/IR/RuntimeLibcalls.td
Normal file
1054
llvm/include/llvm/IR/RuntimeLibcalls.td
Normal file
File diff suppressed because it is too large
Load Diff
32
llvm/include/llvm/IR/RuntimeLibcallsImpl.td
Normal file
32
llvm/include/llvm/IR/RuntimeLibcallsImpl.td
Normal file
@@ -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;
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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, StringRef ABIName) {
|
||||
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);
|
||||
@@ -490,7 +452,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);
|
||||
}
|
||||
}
|
||||
@@ -522,11 +484,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);
|
||||
@@ -579,19 +543,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");
|
||||
@@ -632,6 +583,9 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
|
||||
|
||||
if (TT.getArch() == Triple::ArchType::msp430)
|
||||
setMSP430Libcalls(*this, TT);
|
||||
|
||||
if (TT.isSystemZ() && TT.isOSzOS())
|
||||
setZOSLibCallNameOverrides();
|
||||
}
|
||||
|
||||
bool RuntimeLibcallsInfo::darwinHasExp10(const Triple &TT) {
|
||||
|
||||
@@ -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@B")
|
||||
HANDLE_LIBCALL(TRUNC_F32, "@@FTRC@B")
|
||||
HANDLE_LIBCALL(TRUNC_F128, "@@LTRC@B")
|
||||
HANDLE_LIBCALL(SQRT_F64, "@@WSQT@B")
|
||||
HANDLE_LIBCALL(SQRT_F32, "@@FSQT@B")
|
||||
HANDLE_LIBCALL(SQRT_F128, "@@LSQT@B")
|
||||
HANDLE_LIBCALL(SIN_F64, "@@SSIN@B")
|
||||
HANDLE_LIBCALL(SIN_F32, "@@FSIN@B")
|
||||
HANDLE_LIBCALL(SIN_F128, "@@LSIN@B")
|
||||
HANDLE_LIBCALL(ROUND_F64, "@@ROUN@B")
|
||||
HANDLE_LIBCALL(ROUND_F32, "@@ROUNFB")
|
||||
HANDLE_LIBCALL(ROUND_F128, "@@ROUNLB")
|
||||
HANDLE_LIBCALL(RINT_F64, "@@SRNT@B")
|
||||
HANDLE_LIBCALL(RINT_F32, "@@RINTFB")
|
||||
HANDLE_LIBCALL(RINT_F128, "@@RINTLB")
|
||||
HANDLE_LIBCALL(REM_F64, "@@WFMD@B")
|
||||
HANDLE_LIBCALL(REM_F32, "@@FFMD@B")
|
||||
HANDLE_LIBCALL(REM_F128, "@@LFMD@B")
|
||||
HANDLE_LIBCALL(POW_F64, "@@WPOW@B")
|
||||
HANDLE_LIBCALL(POW_F32, "@@FPOW@B")
|
||||
HANDLE_LIBCALL(POW_F128, "@@LPOW@B")
|
||||
HANDLE_LIBCALL(NEARBYINT_F64, "@@NBYI@B")
|
||||
HANDLE_LIBCALL(NEARBYINT_F32, "@@NBYIFB")
|
||||
HANDLE_LIBCALL(NEARBYINT_F128, "@@NBYILB")
|
||||
HANDLE_LIBCALL(LROUND_F64, "@@ROND@B")
|
||||
HANDLE_LIBCALL(LROUND_F32, "@@FRND@B")
|
||||
HANDLE_LIBCALL(LROUND_F128, "@@LRND@B")
|
||||
HANDLE_LIBCALL(LRINT_F64, "@@LRNT@B")
|
||||
HANDLE_LIBCALL(LRINT_F32, "@@LRNTFB")
|
||||
HANDLE_LIBCALL(LRINT_F128, "@@LRNTLB")
|
||||
HANDLE_LIBCALL(LOG_F64, "@@WLOG@B")
|
||||
HANDLE_LIBCALL(LOG_F32, "@@FLOG@B")
|
||||
HANDLE_LIBCALL(LOG_F128, "@@LLOG@B")
|
||||
HANDLE_LIBCALL(LOG2_F64, "@@LOG2@B")
|
||||
HANDLE_LIBCALL(LOG2_F32, "@@FLG2@B")
|
||||
HANDLE_LIBCALL(LOG2_F128, "@@LLG2@B")
|
||||
HANDLE_LIBCALL(LOG10_F64, "@@WLG1@B")
|
||||
HANDLE_LIBCALL(LOG10_F32, "@@FLG1@B")
|
||||
HANDLE_LIBCALL(LOG10_F128, "@@LLG1@B")
|
||||
HANDLE_LIBCALL(LLROUND_F64, "@@LLRD@B")
|
||||
HANDLE_LIBCALL(LLROUND_F32, "@@LLRDFB")
|
||||
HANDLE_LIBCALL(LLROUND_F128, "@@LLRDLB")
|
||||
HANDLE_LIBCALL(LLRINT_F64, "@@LLRT@B")
|
||||
HANDLE_LIBCALL(LLRINT_F32, "@@LLRTFB")
|
||||
HANDLE_LIBCALL(LLRINT_F128, "@@LLRTLB")
|
||||
HANDLE_LIBCALL(LDEXP_F64, "@@SLXP@B")
|
||||
HANDLE_LIBCALL(LDEXP_F32, "@@FLXP@B")
|
||||
HANDLE_LIBCALL(LDEXP_F128, "@@LLXP@B")
|
||||
HANDLE_LIBCALL(FREXP_F64, "@@SFXP@B")
|
||||
HANDLE_LIBCALL(FREXP_F32, "@@FFXP@B")
|
||||
HANDLE_LIBCALL(FREXP_F128, "@@LFXP@B")
|
||||
HANDLE_LIBCALL(FMIN_F64, "@@FMIN@B")
|
||||
HANDLE_LIBCALL(FMIN_F32, "@@FMINFB")
|
||||
HANDLE_LIBCALL(FMIN_F128, "@@FMINLB")
|
||||
HANDLE_LIBCALL(FMA_F64, "@@FMA@B")
|
||||
HANDLE_LIBCALL(FMA_F32, "@@FMAFB")
|
||||
HANDLE_LIBCALL(FMA_F128, "@@FMALB")
|
||||
HANDLE_LIBCALL(FMAX_F64, "@@FMAX@B")
|
||||
HANDLE_LIBCALL(FMAX_F32, "@@FMAXFB")
|
||||
HANDLE_LIBCALL(FMAX_F128, "@@FMAXLB")
|
||||
HANDLE_LIBCALL(FLOOR_F64, "@@SFLR@B")
|
||||
HANDLE_LIBCALL(FLOOR_F32, "@@FFLR@B")
|
||||
HANDLE_LIBCALL(FLOOR_F128, "@@LFLR@B")
|
||||
HANDLE_LIBCALL(EXP_F64, "@@WEXP@B")
|
||||
HANDLE_LIBCALL(EXP_F32, "@@FEXP@B")
|
||||
HANDLE_LIBCALL(EXP_F128, "@@LEXP@B")
|
||||
HANDLE_LIBCALL(EXP2_F64, "@@EXP2@B")
|
||||
HANDLE_LIBCALL(EXP2_F32, "@@FXP2@B")
|
||||
HANDLE_LIBCALL(EXP2_F128, "@@LXP2@B")
|
||||
HANDLE_LIBCALL(COS_F64, "@@SCOS@B")
|
||||
HANDLE_LIBCALL(COS_F32, "@@FCOS@B")
|
||||
HANDLE_LIBCALL(COS_F128, "@@LCOS@B")
|
||||
HANDLE_LIBCALL(COPYSIGN_F64, "@@DCPY@B")
|
||||
HANDLE_LIBCALL(COPYSIGN_F32, "@@FCPY@B")
|
||||
HANDLE_LIBCALL(COPYSIGN_F128, "@@LCPY@B")
|
||||
HANDLE_LIBCALL(CEIL_F64, "@@SCEL@B")
|
||||
HANDLE_LIBCALL(CEIL_F32, "@@FCEL@B")
|
||||
HANDLE_LIBCALL(CEIL_F128, "@@LCEL@B")
|
||||
HANDLE_LIBCALL(CBRT_F64, "@@SCRT@B")
|
||||
HANDLE_LIBCALL(CBRT_F32, "@@FCBT@B")
|
||||
HANDLE_LIBCALL(CBRT_F128, "@@LCBT@B")
|
||||
|
||||
#undef HANDLE_LIBCALL
|
||||
@@ -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",
|
||||
|
||||
40
llvm/test/TableGen/RuntimeLibcallEmitter.td
Normal file
40
llvm/test/TableGen/RuntimeLibcallEmitter.td
Normal file
@@ -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: };
|
||||
@@ -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
|
||||
|
||||
305
llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
Normal file
305
llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
Normal file
@@ -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");
|
||||
@@ -10,6 +10,7 @@ source_set("Basic") {
|
||||
"DirectiveEmitter.cpp",
|
||||
"IntrinsicEmitter.cpp",
|
||||
"RISCVTargetDefEmitter.cpp",
|
||||
"RuntimeLibcallsEmitter.cpp",
|
||||
"SDNodeProperties.cpp",
|
||||
"TableGen.cpp",
|
||||
"TargetFeaturesEmitter.cpp",
|
||||
|
||||
Reference in New Issue
Block a user