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 -// 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 { 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 +// for more info on the +// difference between them. + +// Atomic '__sync_*' libcalls. +defset list 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 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 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 { + def NAME#"_f128" + : RuntimeLibcallImpl(libcall_basename#"_F128"), + !strconcat(rtbasename, "l")>; + def NAME#"_ppcf128" + : RuntimeLibcallImpl(libcall_basename#"_PPCF128"), + !strconcat(rtbasename, "l")>; + def NAME#"_f80" + : RuntimeLibcallImpl(libcall_basename#"_F80"), + !strconcat(rtbasename, "l")>; +} + +//-------------------------------------------------------------------- +// Define implementation default libcalls +//-------------------------------------------------------------------- + +defset list DefaultRuntimeLibcallImpls = { +let IsDefault = true in { + +//-------------------------------------------------------------------- +// compiler-rt / libgcc +//-------------------------------------------------------------------- + +def __ashlhi3 : RuntimeLibcallImpl; +def __ashlsi3 : RuntimeLibcallImpl; +def __ashldi3 : RuntimeLibcallImpl; +def __ashlti3 : RuntimeLibcallImpl; + +def __lshrhi3 : RuntimeLibcallImpl; +def __lshrsi3 : RuntimeLibcallImpl; +def __lshrdi3 : RuntimeLibcallImpl; +def __lshrti3 : RuntimeLibcallImpl; + +def __ashrhi3 : RuntimeLibcallImpl; +def __ashrsi3 : RuntimeLibcallImpl; +def __ashrdi3 : RuntimeLibcallImpl; +def __ashrti3 : RuntimeLibcallImpl; + +def __mulqi3 : RuntimeLibcallImpl; +def __mulhi3 : RuntimeLibcallImpl; +def __mulsi3 : RuntimeLibcallImpl; +def __muldi3 : RuntimeLibcallImpl; +def __multi3 : RuntimeLibcallImpl; + +def __mulosi4 : RuntimeLibcallImpl; +def __mulodi4 : RuntimeLibcallImpl; +def __muloti4 : RuntimeLibcallImpl; + +def __divqi3 : RuntimeLibcallImpl; +def __divhi3 : RuntimeLibcallImpl; +def __divsi3 : RuntimeLibcallImpl; +def __divdi3 : RuntimeLibcallImpl; +def __divti3 : RuntimeLibcallImpl; + +def __udivqi3 : RuntimeLibcallImpl; +def __udivhi3 : RuntimeLibcallImpl; +def __udivsi3 : RuntimeLibcallImpl; +def __udivdi3 : RuntimeLibcallImpl; +def __udivti3 : RuntimeLibcallImpl; + +def __modqi3 : RuntimeLibcallImpl; +def __modhi3 : RuntimeLibcallImpl; +def __modsi3 : RuntimeLibcallImpl; +def __moddi3 : RuntimeLibcallImpl; +def __modti3 : RuntimeLibcallImpl; + +def __umodqi3 : RuntimeLibcallImpl; +def __umodhi3 : RuntimeLibcallImpl; +def __umodsi3 : RuntimeLibcallImpl; +def __umoddi3 : RuntimeLibcallImpl; +def __umodti3 : RuntimeLibcallImpl; + +def __negsi2 : RuntimeLibcallImpl; +def __negdi2 : RuntimeLibcallImpl; + +def __clzsi2 : RuntimeLibcallImpl; +def __clzdi2 : RuntimeLibcallImpl; +def __clzti2 : RuntimeLibcallImpl; + +def __popcountsi2 : RuntimeLibcallImpl; +def __popcountdi2 : RuntimeLibcallImpl; +def __popcountti2 : RuntimeLibcallImpl; + +def __addsf3 : RuntimeLibcallImpl; +def __adddf3 : RuntimeLibcallImpl; +def __addxf3 : RuntimeLibcallImpl; +def __addtf3 : RuntimeLibcallImpl; +def __gcc_qadd : RuntimeLibcallImpl; + +def __subsf3 : RuntimeLibcallImpl; +def __subdf3 : RuntimeLibcallImpl; +def __subxf3 : RuntimeLibcallImpl; +def __subtf3 : RuntimeLibcallImpl; +def __gcc_qsub : RuntimeLibcallImpl; + +def __mulsf3 : RuntimeLibcallImpl; +def __muldf3 : RuntimeLibcallImpl; +def __mulxf3 : RuntimeLibcallImpl; +def __multf3 : RuntimeLibcallImpl; +def __gcc_qmul : RuntimeLibcallImpl; + +def __divsf3 : RuntimeLibcallImpl; +def __divdf3 : RuntimeLibcallImpl; +def __divxf3 : RuntimeLibcallImpl; +def __divtf3 : RuntimeLibcallImpl; +def __gcc_qdiv : RuntimeLibcallImpl; + +def __powisf2 : RuntimeLibcallImpl; +def __powidf2 : RuntimeLibcallImpl; +def __powixf2 : RuntimeLibcallImpl; +def __powitf2_f128 : RuntimeLibcallImpl; +def __powitf2_ppc128 : RuntimeLibcallImpl; + +// Conversion +def __extendbfsf2 : RuntimeLibcallImpl; +def __gcc_stoq : RuntimeLibcallImpl; +def __gcc_dtoq : RuntimeLibcallImpl; +def __extendxftf2 : RuntimeLibcallImpl; +def __extenddftf2 : RuntimeLibcallImpl; +def __extendsftf2 : RuntimeLibcallImpl; +def __extendhftf2 : RuntimeLibcallImpl; +def __extendhfxf2 : RuntimeLibcallImpl; +def __extendsfdf2 : RuntimeLibcallImpl; +def __extendhfdf2 : RuntimeLibcallImpl; +def __extendhfsf2 : RuntimeLibcallImpl; +def __truncsfhf2 : RuntimeLibcallImpl; +def __truncdfhf2 : RuntimeLibcallImpl; +def __truncxfhf2 : RuntimeLibcallImpl; +def __trunctfhf2_f128 : RuntimeLibcallImpl; +def __trunctfhf2_ppcf128 : RuntimeLibcallImpl; +def __truncsfbf2 : RuntimeLibcallImpl; +def __truncdfbf2 : RuntimeLibcallImpl; +def __truncxfbf2 : RuntimeLibcallImpl; +def __trunctfbf2 : RuntimeLibcallImpl; +def __truncdfsf2 : RuntimeLibcallImpl; +def __truncxfsf2 : RuntimeLibcallImpl; +def __trunctfsf2 : RuntimeLibcallImpl; +def __gcc_qtos : RuntimeLibcallImpl; +def __truncxfdf2 : RuntimeLibcallImpl; +def __trunctfdf2 : RuntimeLibcallImpl; +def __gcc_qtod : RuntimeLibcallImpl; +def __trunctfxf2 : RuntimeLibcallImpl; +def __fixhfsi : RuntimeLibcallImpl; +def __fixhfdi : RuntimeLibcallImpl; +def __fixhfti : RuntimeLibcallImpl; +def __fixsfsi : RuntimeLibcallImpl; +def __fixsfdi : RuntimeLibcallImpl; +def __fixsfti : RuntimeLibcallImpl; +def __fixdfsi : RuntimeLibcallImpl; +def __fixdfdi : RuntimeLibcallImpl; +def __fixdfti : RuntimeLibcallImpl; +def __fixxfsi : RuntimeLibcallImpl; +def __fixxfdi : RuntimeLibcallImpl; +def __fixxfti : RuntimeLibcallImpl; +def __fixtfsi : RuntimeLibcallImpl; +def __fixtfdi_f128 : RuntimeLibcallImpl; +def __fixtfti_f128 : RuntimeLibcallImpl; +def __gcc_qtou : RuntimeLibcallImpl; +def __fixtfdi_ppcf128 : RuntimeLibcallImpl; +def __fixtfti_ppcf128 : RuntimeLibcallImpl; +def __fixunshfsi : RuntimeLibcallImpl; +def __fixunshfdi : RuntimeLibcallImpl; +def __fixunshfti : RuntimeLibcallImpl; +def __fixunssfsi : RuntimeLibcallImpl; +def __fixunssfdi : RuntimeLibcallImpl; +def __fixunssfti : RuntimeLibcallImpl; +def __fixunsdfsi : RuntimeLibcallImpl; +def __fixunsdfdi : RuntimeLibcallImpl; +def __fixunsdfti : RuntimeLibcallImpl; +def __fixunsxfsi : RuntimeLibcallImpl; +def __fixunsxfdi : RuntimeLibcallImpl; +def __fixunsxfti : RuntimeLibcallImpl; +def __fixunstfsi_f128 : RuntimeLibcallImpl; +def __fixunstfdi_f128 : RuntimeLibcallImpl; +def __fixunstfti_f128 : RuntimeLibcallImpl; +def __fixunstfsi_ppcf128 : RuntimeLibcallImpl; +def __fixunstfdi_ppcf128 : RuntimeLibcallImpl; +def __fixunstfti_ppcf128 : RuntimeLibcallImpl; +def __floatsihf : RuntimeLibcallImpl; +def __floatsisf : RuntimeLibcallImpl; +def __floatsidf : RuntimeLibcallImpl; +def __floatsixf : RuntimeLibcallImpl; +def __floatsitf : RuntimeLibcallImpl; +def __gcc_itoq : RuntimeLibcallImpl; +def __floatdibf : RuntimeLibcallImpl; +def __floatdihf : RuntimeLibcallImpl; +def __floatdisf : RuntimeLibcallImpl; +def __floatdidf : RuntimeLibcallImpl; +def __floatdixf : RuntimeLibcallImpl; +def __floatditf_f128 : RuntimeLibcallImpl; +def __floatditf_ppcf128 : RuntimeLibcallImpl; +def __floattihf : RuntimeLibcallImpl; +def __floattisf : RuntimeLibcallImpl; +def __floattidf : RuntimeLibcallImpl; +def __floattixf : RuntimeLibcallImpl; +def __floattitf_f128 : RuntimeLibcallImpl; +def __floattitf_ppcf128 : RuntimeLibcallImpl; +def __floatunsihf : RuntimeLibcallImpl; +def __floatunsisf : RuntimeLibcallImpl; +def __floatunsidf : RuntimeLibcallImpl; +def __floatunsixf : RuntimeLibcallImpl; +def __floatunsitf : RuntimeLibcallImpl; +def __gcc_utoq : RuntimeLibcallImpl; +def __floatundibf : RuntimeLibcallImpl; +def __floatundihf : RuntimeLibcallImpl; +def __floatundisf : RuntimeLibcallImpl; +def __floatundidf : RuntimeLibcallImpl; +def __floatundixf : RuntimeLibcallImpl; +def __floatunditf_f128 : RuntimeLibcallImpl; +def __floatunditf_ppcf128 : RuntimeLibcallImpl; +def __floatuntihf : RuntimeLibcallImpl; +def __floatuntisf : RuntimeLibcallImpl; +def __floatuntidf : RuntimeLibcallImpl; +def __floatuntixf : RuntimeLibcallImpl; +def __floatuntitf_f128 : RuntimeLibcallImpl; +def __floatuntitf_ppcf128 : RuntimeLibcallImpl; +def __extendkftf2 : RuntimeLibcallImpl; +def __trunctfkf2 : RuntimeLibcallImpl; + +// Comparison +def __eqsf2 : RuntimeLibcallImpl; +def __eqdf2 : RuntimeLibcallImpl; +def __eqtf2 : RuntimeLibcallImpl; +def __gcc_qeq : RuntimeLibcallImpl; +def __nesf2 : RuntimeLibcallImpl; +def __nedf2 : RuntimeLibcallImpl; +def __netf2 : RuntimeLibcallImpl; +def __gcc_qne : RuntimeLibcallImpl; +def __gesf2 : RuntimeLibcallImpl; +def __gedf2 : RuntimeLibcallImpl; +def __getf2 : RuntimeLibcallImpl; +def __gcc_qge : RuntimeLibcallImpl; +def __ltsf2 : RuntimeLibcallImpl; +def __ltdf2 : RuntimeLibcallImpl; +def __lttf2 : RuntimeLibcallImpl; +def __gcc_qlt : RuntimeLibcallImpl; +def __lesf2 : RuntimeLibcallImpl; +def __ledf2 : RuntimeLibcallImpl; +def __letf2 : RuntimeLibcallImpl; +def __gcc_qle : RuntimeLibcallImpl; +def __gtsf2 : RuntimeLibcallImpl; +def __gtdf2 : RuntimeLibcallImpl; +def __gttf2 : RuntimeLibcallImpl; +def __gcc_qgt : RuntimeLibcallImpl; +def __unordsf2 : RuntimeLibcallImpl; +def __unorddf2 : RuntimeLibcallImpl; +def __unordtf2 : RuntimeLibcallImpl; +def __gcc_qunord : RuntimeLibcallImpl; + +// 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("MEMCPY_ELEMENT_UNORDERED_ATOMIC_"#MemSize)>; + + def __llvm_memmove_element_unordered_atomic_#MemSize : RuntimeLibcallImpl< + !cast("MEMMOVE_ELEMENT_UNORDERED_ATOMIC_"#MemSize)>; + + def __llvm_memset_element_unordered_atomic_#MemSize : RuntimeLibcallImpl< + !cast("MEMSET_ELEMENT_UNORDERED_ATOMIC_"#MemSize)>; +} + +// Exception handling +def _Unwind_Resume : RuntimeLibcallImpl; +def __cxa_end_cleanup : RuntimeLibcallImpl; + +// Atomic '__sync_*' libcalls. +foreach lc = LibCalls__sync in { + def __#!tolower(!cast(lc)) : RuntimeLibcallImpl; +} + +// Atomic `__atomic_*' libcalls. +foreach lc = LibCalls__atomic in { + def __#!tolower(!cast(lc)) : RuntimeLibcallImpl; +} + +// Stack Protector Fail +def __stack_chk_fail : RuntimeLibcallImpl; + +// Deoptimization +def __llvm_deoptimize : RuntimeLibcallImpl; + +// Clear cache +def __clear_cache : RuntimeLibcallImpl; +def __riscv_flush_icache : RuntimeLibcallImpl; + +//-------------------------------------------------------------------- +// libm +//-------------------------------------------------------------------- + +def fmodf : RuntimeLibcallImpl; +def fmod : RuntimeLibcallImpl; +def fmodl_f128 : RuntimeLibcallImpl; +def fmodl_f80 : RuntimeLibcallImpl; +def fmodl_ppc128 : RuntimeLibcallImpl; + +def fmaf : RuntimeLibcallImpl; +def fma : RuntimeLibcallImpl; +defm fma : LibmLongDoubleLibCall; + +def sqrtf : RuntimeLibcallImpl; +def sqrt : RuntimeLibcallImpl; +defm sqrt : LibmLongDoubleLibCall; + +def cbrtf : RuntimeLibcallImpl; +def cbrt : RuntimeLibcallImpl; +defm cbrt : LibmLongDoubleLibCall; + +def logf : RuntimeLibcallImpl; +def log : RuntimeLibcallImpl; +defm log : LibmLongDoubleLibCall; + +def __logf_finite : RuntimeLibcallImpl; +def __log_finite : RuntimeLibcallImpl; +def __logl_finite_f80 : RuntimeLibcallImpl; +def __logl_finite_f128 : RuntimeLibcallImpl; +def __logl_finite_ppcf128 : RuntimeLibcallImpl; + +def log2f : RuntimeLibcallImpl; +def log2 : RuntimeLibcallImpl; +defm log2 : LibmLongDoubleLibCall; + +def __log2f_finite : RuntimeLibcallImpl; +def __log2_finite : RuntimeLibcallImpl; +def __log2l_finite_f80 : RuntimeLibcallImpl; +def __log2l_finite_f128 : RuntimeLibcallImpl; +def __log2l_finite_ppcf128 : RuntimeLibcallImpl; + +def log10f : RuntimeLibcallImpl; +def log10 : RuntimeLibcallImpl; +defm log10 : LibmLongDoubleLibCall; + +def __log10f_finite : RuntimeLibcallImpl; +def __log10_finite : RuntimeLibcallImpl; +def __log10l_finite_f80 : RuntimeLibcallImpl; +def __log10l_finite_f128 : RuntimeLibcallImpl; +def __log10l_finite_ppcf128 : RuntimeLibcallImpl; + +def expf : RuntimeLibcallImpl; +def exp : RuntimeLibcallImpl; +defm exp : LibmLongDoubleLibCall<"EXP", "exp">; + +def __expf_finite : RuntimeLibcallImpl; +def __exp_finite : RuntimeLibcallImpl; +def __expl_finite_f80 : RuntimeLibcallImpl; +def __expl_finite_f128 : RuntimeLibcallImpl; +def __expl_finite_ppcf128 : RuntimeLibcallImpl; + +def exp2f : RuntimeLibcallImpl; +def exp2 : RuntimeLibcallImpl; +defm exp2 : LibmLongDoubleLibCall<"EXP2", "exp2">; + +def __exp2f_finite : RuntimeLibcallImpl; +def __exp2_finite : RuntimeLibcallImpl; +def __exp2l_finite_f80 : RuntimeLibcallImpl; +def __exp2l_finite_f128 : RuntimeLibcallImpl; +def __exp2l_finite_ppcf128 : RuntimeLibcallImpl; + +def exp10f : RuntimeLibcallImpl; +def exp10 : RuntimeLibcallImpl; +def exp10l_f80 : RuntimeLibcallImpl; +def exp10l_f128 : RuntimeLibcallImpl; +def exp10l_ppcf128 : RuntimeLibcallImpl; + +def sinf : RuntimeLibcallImpl; +def sin : RuntimeLibcallImpl; +defm sin : LibmLongDoubleLibCall; + +def cosf : RuntimeLibcallImpl; +def cos : RuntimeLibcallImpl; +defm cos : LibmLongDoubleLibCall; + +def tanf : RuntimeLibcallImpl; +def tan : RuntimeLibcallImpl; +defm tan : LibmLongDoubleLibCall; + +def sinhf : RuntimeLibcallImpl; +def sinh : RuntimeLibcallImpl; +defm sinh : LibmLongDoubleLibCall; + +def coshf : RuntimeLibcallImpl; +def cosh : RuntimeLibcallImpl; +defm cosh : LibmLongDoubleLibCall; + +def tanhf : RuntimeLibcallImpl; +def tanh : RuntimeLibcallImpl; +defm tanh : LibmLongDoubleLibCall; + +def asinf : RuntimeLibcallImpl; +def asin : RuntimeLibcallImpl; +defm asin : LibmLongDoubleLibCall; + +def acosf : RuntimeLibcallImpl; +def acos : RuntimeLibcallImpl; +defm acos : LibmLongDoubleLibCall; + +def atanf : RuntimeLibcallImpl; +def atan : RuntimeLibcallImpl; +defm atan : LibmLongDoubleLibCall; + +def atan2f : RuntimeLibcallImpl; +def atan2 : RuntimeLibcallImpl; +defm atan2 : LibmLongDoubleLibCall; + +def powf : RuntimeLibcallImpl; +def pow : RuntimeLibcallImpl; +defm pow : LibmLongDoubleLibCall; + +def __powf_finite : RuntimeLibcallImpl; +def __pow_finite : RuntimeLibcallImpl; +def __powl_finite_f80 : RuntimeLibcallImpl; +def __powl_finite_f128 : RuntimeLibcallImpl; +def __powl_finite_ppcf128 : RuntimeLibcallImpl; + +def ceilf : RuntimeLibcallImpl; +def ceil : RuntimeLibcallImpl; +defm ceil : LibmLongDoubleLibCall; + +def truncf : RuntimeLibcallImpl; +def trunc : RuntimeLibcallImpl; +defm trunc : LibmLongDoubleLibCall; + +def rintf : RuntimeLibcallImpl; +def rint : RuntimeLibcallImpl; +defm rint : LibmLongDoubleLibCall; + +def nearbyintf : RuntimeLibcallImpl; +def nearbyint : RuntimeLibcallImpl; +defm nearbyint : LibmLongDoubleLibCall; + +def roundf : RuntimeLibcallImpl; +def round : RuntimeLibcallImpl; +defm round : LibmLongDoubleLibCall; + +def roundevenf : RuntimeLibcallImpl; +def roundeven : RuntimeLibcallImpl; +defm roundeven : LibmLongDoubleLibCall; + +def floorf : RuntimeLibcallImpl; +def floor : RuntimeLibcallImpl; +defm floor : LibmLongDoubleLibCall; + +def copysignf : RuntimeLibcallImpl; +def copysign : RuntimeLibcallImpl; +defm copysign : LibmLongDoubleLibCall; + +def fminf : RuntimeLibcallImpl; +def fmin : RuntimeLibcallImpl; +defm fmin : LibmLongDoubleLibCall; + +def fmaxf : RuntimeLibcallImpl; +def fmax : RuntimeLibcallImpl; +defm fmax : LibmLongDoubleLibCall; + +def fminimumf : RuntimeLibcallImpl; +def fminimum : RuntimeLibcallImpl; +defm fminimum : LibmLongDoubleLibCall; + +def fmaximumf : RuntimeLibcallImpl; +def fmaximum : RuntimeLibcallImpl; +defm fmaximum : LibmLongDoubleLibCall; + +def fminimum_numf : RuntimeLibcallImpl; +def fminimum_num : RuntimeLibcallImpl; +defm fminimum_num : LibmLongDoubleLibCall; + +def fmaximum_numf : RuntimeLibcallImpl; +def fmaximum_num : RuntimeLibcallImpl; +defm fmaximum_num : LibmLongDoubleLibCall; + +def lroundf : RuntimeLibcallImpl; +def lround : RuntimeLibcallImpl; +defm lround : LibmLongDoubleLibCall; + +def llroundf : RuntimeLibcallImpl; +def llround : RuntimeLibcallImpl; +defm llround : LibmLongDoubleLibCall; + +def lrintf : RuntimeLibcallImpl; +def lrint : RuntimeLibcallImpl; +defm lrint : LibmLongDoubleLibCall; + +def llrintf : RuntimeLibcallImpl; +def llrint : RuntimeLibcallImpl; +defm llrint : LibmLongDoubleLibCall; + +def ldexpf : RuntimeLibcallImpl; +def ldexp : RuntimeLibcallImpl; +defm ldexp : LibmLongDoubleLibCall; + +def frexpf : RuntimeLibcallImpl; +def frexp : RuntimeLibcallImpl; +defm frexp : LibmLongDoubleLibCall; + +def sincospif : RuntimeLibcallImpl; +def sincospi : RuntimeLibcallImpl; +defm sincospi : LibmLongDoubleLibCall; + +def modff : RuntimeLibcallImpl; +def modf : RuntimeLibcallImpl; +defm modf : LibmLongDoubleLibCall; + +// Floating point environment +def fegetenv : RuntimeLibcallImpl; +def fesetenv : RuntimeLibcallImpl; + +// Floating point control modes +def fegetmode : RuntimeLibcallImpl; +def fesetmode : RuntimeLibcallImpl; + +//-------------------------------------------------------------------- +// libc +//-------------------------------------------------------------------- + +// Memory +def memcpy : RuntimeLibcallImpl; +def memmove : RuntimeLibcallImpl; +def memset : RuntimeLibcallImpl; + +// DSEPass can emit calloc if it finds a pair of malloc/memset +def calloc : RuntimeLibcallImpl; + +} // End let IsDefault = true +} // End defset DefaultRuntimeLibcallImpls + +//-------------------------------------------------------------------- +// Define implementation other libcalls +//-------------------------------------------------------------------- + +// TODO: Define other custom names targets use to override + +def __exp10f : RuntimeLibcallImpl; +def __exp10 : RuntimeLibcallImpl; + +def __sincosf_stret : RuntimeLibcallImpl; +def __sincos_stret : RuntimeLibcallImpl; + +def sincosf : RuntimeLibcallImpl; +def sincos : RuntimeLibcallImpl; +defm sincos : LibmLongDoubleLibCall; + +def bzero : RuntimeLibcallImpl; +def __bzero : RuntimeLibcallImpl; +def _Unwind_SjLj_Resume : RuntimeLibcallImpl; + +//===----------------------------------------------------------------------===// +// F128 libm Runtime Libcalls +//===----------------------------------------------------------------------===// + +def logf128 : RuntimeLibcallImpl; +def log2f128 : RuntimeLibcallImpl; +def log10f128 : RuntimeLibcallImpl; +def expf128 : RuntimeLibcallImpl; +def exp2f128 : RuntimeLibcallImpl; +def exp10f128 : RuntimeLibcallImpl; +def sinf128 : RuntimeLibcallImpl; +def cosf128 : RuntimeLibcallImpl; +def tanf128 : RuntimeLibcallImpl; +def tanhf128 : RuntimeLibcallImpl; +def sincosf128 : RuntimeLibcallImpl; +def powf128 : RuntimeLibcallImpl; +def fminf128 : RuntimeLibcallImpl; +def fmaxf128 : RuntimeLibcallImpl; +def fmodf128 : RuntimeLibcallImpl; +def sqrtf128 : RuntimeLibcallImpl; +def ceilf128 : RuntimeLibcallImpl; +def floorf128 : RuntimeLibcallImpl; +def truncf128 : RuntimeLibcallImpl; +def roundf128 : RuntimeLibcallImpl; +def lroundf128 : RuntimeLibcallImpl; +def llroundf128 : RuntimeLibcallImpl; +def rintf128 : RuntimeLibcallImpl; +def lrintf128 : RuntimeLibcallImpl; +def llrintf128 : RuntimeLibcallImpl; +def nearbyintf128 : RuntimeLibcallImpl; +def fmaf128 : RuntimeLibcallImpl; +def frexpf128 : RuntimeLibcallImpl; + +def cbrtf128 : RuntimeLibcallImpl; +def fminimumf128 : RuntimeLibcallImpl; +def fmaximumf128 : RuntimeLibcallImpl; +def fminimum_numf128 : RuntimeLibcallImpl; +def fmaximum_numf128 : RuntimeLibcallImpl; +def asinf128 : RuntimeLibcallImpl; +def acosf128 : RuntimeLibcallImpl; +def atanf128 : RuntimeLibcallImpl; +def atan2f128 : RuntimeLibcallImpl; +def ldexpf128 : RuntimeLibcallImpl; +def roundevenf128 : RuntimeLibcallImpl; +def modff128 : RuntimeLibcallImpl; +def sinhf128 : RuntimeLibcallImpl; +def coshf128 : RuntimeLibcallImpl; +def copysignf128 : RuntimeLibcallImpl; + +def __logf128_finite : RuntimeLibcallImpl; +def __log2f128_finite : RuntimeLibcallImpl; +def __log10f128_finite : RuntimeLibcallImpl; +def __expf128_finite : RuntimeLibcallImpl; +def __exp2f128_finite : RuntimeLibcallImpl; +def __exp10f128_finite : RuntimeLibcallImpl; +def __powf128_finite : RuntimeLibcallImpl; + +//===----------------------------------------------------------------------===// +// PPC Runtime Libcalls +//===----------------------------------------------------------------------===// + +class PPCRuntimeLibcallImpl + : RuntimeLibcallImpl; + +// For IEEE quad-precision libcall names, PPC uses "kf" instead of "tf". +def __addkf3 : PPCRuntimeLibcallImpl; +def __subkf3 : PPCRuntimeLibcallImpl; +def __mulkf3 : PPCRuntimeLibcallImpl; +def __divkf3 : PPCRuntimeLibcallImpl; +def __powikf2 : PPCRuntimeLibcallImpl; +def __extendsfkf2 : PPCRuntimeLibcallImpl; +def __extenddfkf2 : PPCRuntimeLibcallImpl; +def __trunckfhf2 : PPCRuntimeLibcallImpl; +def __trunckfsf2 : PPCRuntimeLibcallImpl; +def __trunckfdf2 : PPCRuntimeLibcallImpl; +def __fixkfsi : PPCRuntimeLibcallImpl; +def __fixkfdi : PPCRuntimeLibcallImpl; +def __fixkfti : PPCRuntimeLibcallImpl; +def __fixunskfsi : PPCRuntimeLibcallImpl; +def __fixunskfdi : PPCRuntimeLibcallImpl; +def __fixunskfti : PPCRuntimeLibcallImpl; +def __floatsikf : PPCRuntimeLibcallImpl; +def __floatdikf : PPCRuntimeLibcallImpl; +def __floattikf : PPCRuntimeLibcallImpl; +def __floatunsikf : PPCRuntimeLibcallImpl; +def __floatundikf : PPCRuntimeLibcallImpl; +def __floatuntikf : PPCRuntimeLibcallImpl; +def __eqkf2 : PPCRuntimeLibcallImpl; +def __nekf2 : PPCRuntimeLibcallImpl; +def __gekf2 : PPCRuntimeLibcallImpl; +def __ltkf2 : PPCRuntimeLibcallImpl; +def __lekf2 : PPCRuntimeLibcallImpl; +def __gtkf2 : PPCRuntimeLibcallImpl; +def __unordkf2 : PPCRuntimeLibcallImpl; + +//===----------------------------------------------------------------------===// +// ZOS Runtime Libcalls +//===----------------------------------------------------------------------===// + +class ZOSRuntimeLibcallImpl + : RuntimeLibcallImpl; + +def zos___TRNC_B : ZOSRuntimeLibcallImpl; +def zos___FTRC_B : ZOSRuntimeLibcallImpl; +def zos___LTRC_B : ZOSRuntimeLibcallImpl; +def zos___WSQT_B : ZOSRuntimeLibcallImpl; +def zos___FSQT_B : ZOSRuntimeLibcallImpl; +def zos___LSQT_B : ZOSRuntimeLibcallImpl; +def zos___SSIN_B : ZOSRuntimeLibcallImpl; +def zos___FSIN_B : ZOSRuntimeLibcallImpl; +def zos___LSIN_B : ZOSRuntimeLibcallImpl; +def zos___ROUN_B : ZOSRuntimeLibcallImpl; +def zos___ROUNFB : ZOSRuntimeLibcallImpl; +def zos___ROUNLB : ZOSRuntimeLibcallImpl; +def zos___SRNT_B : ZOSRuntimeLibcallImpl; +def zos___RINTFB : ZOSRuntimeLibcallImpl; +def zos___RINTLB : ZOSRuntimeLibcallImpl; +def zos___WFMD_B : ZOSRuntimeLibcallImpl; +def zos___FFMD_B : ZOSRuntimeLibcallImpl; +def zos___LFMD_B : ZOSRuntimeLibcallImpl; +def zos___WPOW_B : ZOSRuntimeLibcallImpl; +def zos___FPOW_B : ZOSRuntimeLibcallImpl; +def zos___LPOW_B : ZOSRuntimeLibcallImpl; +def zos___NBYI_B : ZOSRuntimeLibcallImpl; +def zos___NBYIFB : ZOSRuntimeLibcallImpl; +def zos___NBYILB : ZOSRuntimeLibcallImpl; +def zos___ROND_B : ZOSRuntimeLibcallImpl; +def zos___FRND_B : ZOSRuntimeLibcallImpl; +def zos___LRND_B : ZOSRuntimeLibcallImpl; +def zos___LRNT_B : ZOSRuntimeLibcallImpl; +def zos___LRNTFB : ZOSRuntimeLibcallImpl; +def zos___LRNTLB : ZOSRuntimeLibcallImpl; +def zos___WLOG_B : ZOSRuntimeLibcallImpl; +def zos___FLOG_B : ZOSRuntimeLibcallImpl; +def zos___LLOG_B : ZOSRuntimeLibcallImpl; +def zos___LOG2_B : ZOSRuntimeLibcallImpl; +def zos___FLG2_B : ZOSRuntimeLibcallImpl; +def zos___LLG2_B : ZOSRuntimeLibcallImpl; +def zos___WLG1_B : ZOSRuntimeLibcallImpl; +def zos___FLG1_B : ZOSRuntimeLibcallImpl; +def zos___LLG1_B : ZOSRuntimeLibcallImpl; +def zos___LLRD_B : ZOSRuntimeLibcallImpl; +def zos___LLRDFB : ZOSRuntimeLibcallImpl; +def zos___LLRDLB : ZOSRuntimeLibcallImpl; +def zos___LLRT_B : ZOSRuntimeLibcallImpl; +def zos___LLRTFB : ZOSRuntimeLibcallImpl; +def zos___LLRTLB : ZOSRuntimeLibcallImpl; +def zos___SLXP_B : ZOSRuntimeLibcallImpl; +def zos___FLXP_B : ZOSRuntimeLibcallImpl; +def zos___LLXP_B : ZOSRuntimeLibcallImpl; +def zos___SFXP_B : ZOSRuntimeLibcallImpl; +def zos___FFXP_B : ZOSRuntimeLibcallImpl; +def zos___LFXP_B : ZOSRuntimeLibcallImpl; +def zos___FMIN_B : ZOSRuntimeLibcallImpl; +def zos___FMINFB : ZOSRuntimeLibcallImpl; +def zos___FMINLB : ZOSRuntimeLibcallImpl; +def zos___FMA_B : ZOSRuntimeLibcallImpl; +def zos___FMAFB : ZOSRuntimeLibcallImpl; +def zos___FMALB : ZOSRuntimeLibcallImpl; +def zos___FMAX_B : ZOSRuntimeLibcallImpl; +def zos___FMAXFB : ZOSRuntimeLibcallImpl; +def zos___FMAXLB : ZOSRuntimeLibcallImpl; +def zos___SFLR_B : ZOSRuntimeLibcallImpl; +def zos___FFLR_B : ZOSRuntimeLibcallImpl; +def zos___LFLR_B : ZOSRuntimeLibcallImpl; +def zos___WEXP_B : ZOSRuntimeLibcallImpl; +def zos___FEXP_B : ZOSRuntimeLibcallImpl; +def zos___LEXP_B : ZOSRuntimeLibcallImpl; +def zos___EXP2_B : ZOSRuntimeLibcallImpl; +def zos___FXP2_B : ZOSRuntimeLibcallImpl; +def zos___LXP2_B : ZOSRuntimeLibcallImpl; +def zos___SCOS_B : ZOSRuntimeLibcallImpl; +def zos___FCOS_B : ZOSRuntimeLibcallImpl; +def zos___LCOS_B : ZOSRuntimeLibcallImpl; +def zos___DCPY_B : ZOSRuntimeLibcallImpl; +def zos___FCPY_B : ZOSRuntimeLibcallImpl; +def zos___LCPY_B : ZOSRuntimeLibcallImpl; +def zos___SCEL_B : ZOSRuntimeLibcallImpl; +def zos___FCEL_B : ZOSRuntimeLibcallImpl; +def zos___LCEL_B : ZOSRuntimeLibcallImpl; +def zos___SCRT_B : ZOSRuntimeLibcallImpl; +def zos___FCBT_B : ZOSRuntimeLibcallImpl; +def zos___LCBT_B : ZOSRuntimeLibcallImpl; 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 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 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@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 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 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; + def __lshrdi3 : RuntimeLibcallImpl; +} + +// Ignore non-default in initDefaultLibCallNames. +def bzero : RuntimeLibcallImpl; + +// 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 &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 Def2RuntimeLibcall; + + const RuntimeLibcall *getRuntimeLibcall(const Record *Def) const { + return Def2RuntimeLibcall.lookup(Def); + } + + std::vector RuntimeLibcallDefList; + std::vector RuntimeLibcallImplDefList; + + DenseMap + LibCallToDefaultImpl; + + void + emitTargetOverrideFunc(raw_ostream &OS, StringRef FuncName, + ArrayRef 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 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 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 + getRuntimeLibcallImplSet(StringRef Name) const { + std::vector Result; + ArrayRef 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 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 ZOSRuntimeLibcallImplList = + getRuntimeLibcallImplSet("ZOSRuntimeLibcallImpl"); + emitTargetOverrideFunc(OS, "setZOSLibCallNameOverrides", + ZOSRuntimeLibcallImplList); + + std::vector 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 + 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",