forked from OSchip/llvm-project
Move Runtime libcall definitions to a .def file
This will allow eliminating the duplication of the names, and allow adding extra information such as signatures in a future commit. Differential Revision: https://reviews.llvm.org/D35522 llvm-svn: 308531
This commit is contained in:
Derek Schuff
parent
2c748cc756
commit
36454afab5
|
|
@ -0,0 +1,492 @@
|
|||
//===-- llvm/RuntimeLibcalls.def - File that describes libcalls -*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 InitLibcallNames() 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, nullptr)
|
||||
HANDLE_LIBCALL(SDIVREM_I16, nullptr)
|
||||
HANDLE_LIBCALL(SDIVREM_I32, nullptr)
|
||||
HANDLE_LIBCALL(SDIVREM_I64, nullptr)
|
||||
HANDLE_LIBCALL(SDIVREM_I128, nullptr)
|
||||
HANDLE_LIBCALL(UDIVREM_I8, nullptr)
|
||||
HANDLE_LIBCALL(UDIVREM_I16, nullptr)
|
||||
HANDLE_LIBCALL(UDIVREM_I32, nullptr)
|
||||
HANDLE_LIBCALL(UDIVREM_I64, nullptr)
|
||||
HANDLE_LIBCALL(UDIVREM_I128, nullptr)
|
||||
HANDLE_LIBCALL(NEG_I32, "__negsi2")
|
||||
HANDLE_LIBCALL(NEG_I64, "__negdi2")
|
||||
|
||||
// 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(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(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(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(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(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(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(SINCOS_F32, nullptr)
|
||||
HANDLE_LIBCALL(SINCOS_F64, nullptr)
|
||||
HANDLE_LIBCALL(SINCOS_F80, nullptr)
|
||||
HANDLE_LIBCALL(SINCOS_F128, nullptr)
|
||||
HANDLE_LIBCALL(SINCOS_PPCF128, nullptr)
|
||||
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(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(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")
|
||||
|
||||
// Conversion
|
||||
HANDLE_LIBCALL(FPEXT_F32_PPCF128, "__gcc_stoq")
|
||||
HANDLE_LIBCALL(FPEXT_F64_PPCF128, "__gcc_dtoq")
|
||||
HANDLE_LIBCALL(FPEXT_F64_F128, "__extenddftf2")
|
||||
HANDLE_LIBCALL(FPEXT_F32_F128, "__extendsftf2")
|
||||
HANDLE_LIBCALL(FPEXT_F32_F64, "__extendsfdf2")
|
||||
HANDLE_LIBCALL(FPEXT_F16_F32, "__gnu_h2f_ieee")
|
||||
HANDLE_LIBCALL(FPROUND_F32_F16, "__gnu_f2h_ieee")
|
||||
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_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(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_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_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_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_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_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_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_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")
|
||||
|
||||
// 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")
|
||||
HANDLE_LIBCALL(O_F32, "__unordsf2")
|
||||
HANDLE_LIBCALL(O_F64, "__unorddf2")
|
||||
HANDLE_LIBCALL(O_F128, "__unordtf2")
|
||||
HANDLE_LIBCALL(O_PPCF128, "__gcc_qunord")
|
||||
|
||||
// Memory
|
||||
HANDLE_LIBCALL(MEMCPY, "memcpy")
|
||||
HANDLE_LIBCALL(MEMMOVE, "memmove")
|
||||
HANDLE_LIBCALL(MEMSET, "memset")
|
||||
|
||||
// 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")
|
||||
|
||||
// Note: there are two sets of atomics libcalls; see
|
||||
// <https://llvm.org/docs/Atomics.html> for more info on the
|
||||
// difference between them.
|
||||
|
||||
// Atomic '__sync_*' libcalls.
|
||||
HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_1, "__sync_val_compare_and_swap_1")
|
||||
HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_2, "__sync_val_compare_and_swap_2")
|
||||
HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_4, "__sync_val_compare_and_swap_4")
|
||||
HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_8, "__sync_val_compare_and_swap_8")
|
||||
HANDLE_LIBCALL(SYNC_VAL_COMPARE_AND_SWAP_16, "__sync_val_compare_and_swap_16")
|
||||
HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_1, "__sync_lock_test_and_set_1")
|
||||
HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_2, "__sync_lock_test_and_set_2")
|
||||
HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_4, "__sync_lock_test_and_set_4")
|
||||
HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_8, "__sync_lock_test_and_set_8")
|
||||
HANDLE_LIBCALL(SYNC_LOCK_TEST_AND_SET_16, "__sync_lock_test_and_set_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_1, "__sync_fetch_and_add_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_2, "__sync_fetch_and_add_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_4, "__sync_fetch_and_add_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_8, "__sync_fetch_and_add_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_ADD_16, "__sync_fetch_and_add_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_1, "__sync_fetch_and_sub_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_2, "__sync_fetch_and_sub_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_4, "__sync_fetch_and_sub_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_8, "__sync_fetch_and_sub_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_SUB_16, "__sync_fetch_and_sub_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_AND_1, "__sync_fetch_and_and_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_AND_2, "__sync_fetch_and_and_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_AND_4, "__sync_fetch_and_and_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_AND_8, "__sync_fetch_and_and_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_AND_16, "__sync_fetch_and_and_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_OR_1, "__sync_fetch_and_or_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_OR_2, "__sync_fetch_and_or_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_OR_4, "__sync_fetch_and_or_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_OR_8, "__sync_fetch_and_or_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_OR_16, "__sync_fetch_and_or_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_1, "__sync_fetch_and_xor_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_2, "__sync_fetch_and_xor_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_4, "__sync_fetch_and_xor_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_8, "__sync_fetch_and_xor_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_XOR_16, "__sync_fetch_and_xor_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_1, "__sync_fetch_and_nand_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_2, "__sync_fetch_and_nand_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_4, "__sync_fetch_and_nand_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_8, "__sync_fetch_and_nand_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_NAND_16, "__sync_fetch_and_nand_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_1, "__sync_fetch_and_max_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_2, "__sync_fetch_and_max_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_4, "__sync_fetch_and_max_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_8, "__sync_fetch_and_max_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MAX_16, "__sync_fetch_and_max_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_1, "__sync_fetch_and_umax_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_2, "__sync_fetch_and_umax_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_4, "__sync_fetch_and_umax_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_8, "__sync_fetch_and_umax_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMAX_16, "__sync_fetch_and_umax_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_1, "__sync_fetch_and_min_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_2, "__sync_fetch_and_min_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_4, "__sync_fetch_and_min_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_8, "__sync_fetch_and_min_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_MIN_16, "__sync_fetch_and_min_16")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_1, "__sync_fetch_and_umin_1")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_2, "__sync_fetch_and_umin_2")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_4, "__sync_fetch_and_umin_4")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_8, "__sync_fetch_and_umin_8")
|
||||
HANDLE_LIBCALL(SYNC_FETCH_AND_UMIN_16, "__sync_fetch_and_umin_16")
|
||||
|
||||
// Atomic `__atomic_*' libcalls.
|
||||
HANDLE_LIBCALL(ATOMIC_LOAD, "__atomic_load")
|
||||
HANDLE_LIBCALL(ATOMIC_LOAD_1, "__atomic_load_1")
|
||||
HANDLE_LIBCALL(ATOMIC_LOAD_2, "__atomic_load_2")
|
||||
HANDLE_LIBCALL(ATOMIC_LOAD_4, "__atomic_load_4")
|
||||
HANDLE_LIBCALL(ATOMIC_LOAD_8, "__atomic_load_8")
|
||||
HANDLE_LIBCALL(ATOMIC_LOAD_16, "__atomic_load_16")
|
||||
|
||||
HANDLE_LIBCALL(ATOMIC_STORE, "__atomic_store")
|
||||
HANDLE_LIBCALL(ATOMIC_STORE_1, "__atomic_store_1")
|
||||
HANDLE_LIBCALL(ATOMIC_STORE_2, "__atomic_store_2")
|
||||
HANDLE_LIBCALL(ATOMIC_STORE_4, "__atomic_store_4")
|
||||
HANDLE_LIBCALL(ATOMIC_STORE_8, "__atomic_store_8")
|
||||
HANDLE_LIBCALL(ATOMIC_STORE_16, "__atomic_store_16")
|
||||
|
||||
HANDLE_LIBCALL(ATOMIC_EXCHANGE, "__atomic_exchange")
|
||||
HANDLE_LIBCALL(ATOMIC_EXCHANGE_1, "__atomic_exchange_1")
|
||||
HANDLE_LIBCALL(ATOMIC_EXCHANGE_2, "__atomic_exchange_2")
|
||||
HANDLE_LIBCALL(ATOMIC_EXCHANGE_4, "__atomic_exchange_4")
|
||||
HANDLE_LIBCALL(ATOMIC_EXCHANGE_8, "__atomic_exchange_8")
|
||||
HANDLE_LIBCALL(ATOMIC_EXCHANGE_16, "__atomic_exchange_16")
|
||||
|
||||
HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE, "__atomic_compare_exchange")
|
||||
HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_1, "__atomic_compare_exchange_1")
|
||||
HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_2, "__atomic_compare_exchange_2")
|
||||
HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_4, "__atomic_compare_exchange_4")
|
||||
HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_8, "__atomic_compare_exchange_8")
|
||||
HANDLE_LIBCALL(ATOMIC_COMPARE_EXCHANGE_16, "__atomic_compare_exchange_16")
|
||||
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_ADD_1, "__atomic_fetch_add_1")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_ADD_2, "__atomic_fetch_add_2")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_ADD_4, "__atomic_fetch_add_4")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_ADD_8, "__atomic_fetch_add_8")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_ADD_16, "__atomic_fetch_add_16")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_SUB_1, "__atomic_fetch_sub_1")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_SUB_2, "__atomic_fetch_sub_2")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_SUB_4, "__atomic_fetch_sub_4")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_SUB_8, "__atomic_fetch_sub_8")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_SUB_16, "__atomic_fetch_sub_16")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_AND_1, "__atomic_fetch_and_1")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_AND_2, "__atomic_fetch_and_2")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_AND_4, "__atomic_fetch_and_4")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_AND_8, "__atomic_fetch_and_8")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_AND_16, "__atomic_fetch_and_16")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_OR_1, "__atomic_fetch_or_1")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_OR_2, "__atomic_fetch_or_2")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_OR_4, "__atomic_fetch_or_4")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_OR_8, "__atomic_fetch_or_8")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_OR_16, "__atomic_fetch_or_16")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_XOR_1, "__atomic_fetch_xor_1")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_XOR_2, "__atomic_fetch_xor_2")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_XOR_4, "__atomic_fetch_xor_4")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_XOR_8, "__atomic_fetch_xor_8")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_XOR_16, "__atomic_fetch_xor_16")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_NAND_1, "__atomic_fetch_nand_1")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_NAND_2, "__atomic_fetch_nand_2")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_NAND_4, "__atomic_fetch_nand_4")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_NAND_8, "__atomic_fetch_nand_8")
|
||||
HANDLE_LIBCALL(ATOMIC_FETCH_NAND_16, "__atomic_fetch_nand_16")
|
||||
|
||||
// Stack Protector Fail
|
||||
HANDLE_LIBCALL(STACKPROTECTOR_CHECK_FAIL, "__stack_chk_fail")
|
||||
|
||||
// Deoptimization
|
||||
HANDLE_LIBCALL(DEOPTIMIZE, "__llvm_deoptimize")
|
||||
|
||||
HANDLE_LIBCALL(UNKNOWN_LIBCALL, nullptr)
|
||||
|
||||
#undef HANDLE_LIBCALL
|
||||
|
|
@ -28,471 +28,9 @@ namespace RTLIB {
|
|||
/// PPCISelLowering.cpp.
|
||||
///
|
||||
enum Libcall {
|
||||
// Integer
|
||||
SHL_I16,
|
||||
SHL_I32,
|
||||
SHL_I64,
|
||||
SHL_I128,
|
||||
SRL_I16,
|
||||
SRL_I32,
|
||||
SRL_I64,
|
||||
SRL_I128,
|
||||
SRA_I16,
|
||||
SRA_I32,
|
||||
SRA_I64,
|
||||
SRA_I128,
|
||||
MUL_I8,
|
||||
MUL_I16,
|
||||
MUL_I32,
|
||||
MUL_I64,
|
||||
MUL_I128,
|
||||
MULO_I32,
|
||||
MULO_I64,
|
||||
MULO_I128,
|
||||
SDIV_I8,
|
||||
SDIV_I16,
|
||||
SDIV_I32,
|
||||
SDIV_I64,
|
||||
SDIV_I128,
|
||||
UDIV_I8,
|
||||
UDIV_I16,
|
||||
UDIV_I32,
|
||||
UDIV_I64,
|
||||
UDIV_I128,
|
||||
SREM_I8,
|
||||
SREM_I16,
|
||||
SREM_I32,
|
||||
SREM_I64,
|
||||
SREM_I128,
|
||||
UREM_I8,
|
||||
UREM_I16,
|
||||
UREM_I32,
|
||||
UREM_I64,
|
||||
UREM_I128,
|
||||
SDIVREM_I8,
|
||||
SDIVREM_I16,
|
||||
SDIVREM_I32,
|
||||
SDIVREM_I64,
|
||||
SDIVREM_I128,
|
||||
UDIVREM_I8,
|
||||
UDIVREM_I16,
|
||||
UDIVREM_I32,
|
||||
UDIVREM_I64,
|
||||
UDIVREM_I128,
|
||||
NEG_I32,
|
||||
NEG_I64,
|
||||
|
||||
// FLOATING POINT
|
||||
ADD_F32,
|
||||
ADD_F64,
|
||||
ADD_F80,
|
||||
ADD_F128,
|
||||
ADD_PPCF128,
|
||||
SUB_F32,
|
||||
SUB_F64,
|
||||
SUB_F80,
|
||||
SUB_F128,
|
||||
SUB_PPCF128,
|
||||
MUL_F32,
|
||||
MUL_F64,
|
||||
MUL_F80,
|
||||
MUL_F128,
|
||||
MUL_PPCF128,
|
||||
DIV_F32,
|
||||
DIV_F64,
|
||||
DIV_F80,
|
||||
DIV_F128,
|
||||
DIV_PPCF128,
|
||||
REM_F32,
|
||||
REM_F64,
|
||||
REM_F80,
|
||||
REM_F128,
|
||||
REM_PPCF128,
|
||||
FMA_F32,
|
||||
FMA_F64,
|
||||
FMA_F80,
|
||||
FMA_F128,
|
||||
FMA_PPCF128,
|
||||
POWI_F32,
|
||||
POWI_F64,
|
||||
POWI_F80,
|
||||
POWI_F128,
|
||||
POWI_PPCF128,
|
||||
SQRT_F32,
|
||||
SQRT_F64,
|
||||
SQRT_F80,
|
||||
SQRT_F128,
|
||||
SQRT_PPCF128,
|
||||
LOG_F32,
|
||||
LOG_F64,
|
||||
LOG_F80,
|
||||
LOG_F128,
|
||||
LOG_PPCF128,
|
||||
LOG2_F32,
|
||||
LOG2_F64,
|
||||
LOG2_F80,
|
||||
LOG2_F128,
|
||||
LOG2_PPCF128,
|
||||
LOG10_F32,
|
||||
LOG10_F64,
|
||||
LOG10_F80,
|
||||
LOG10_F128,
|
||||
LOG10_PPCF128,
|
||||
EXP_F32,
|
||||
EXP_F64,
|
||||
EXP_F80,
|
||||
EXP_F128,
|
||||
EXP_PPCF128,
|
||||
EXP2_F32,
|
||||
EXP2_F64,
|
||||
EXP2_F80,
|
||||
EXP2_F128,
|
||||
EXP2_PPCF128,
|
||||
SIN_F32,
|
||||
SIN_F64,
|
||||
SIN_F80,
|
||||
SIN_F128,
|
||||
SIN_PPCF128,
|
||||
COS_F32,
|
||||
COS_F64,
|
||||
COS_F80,
|
||||
COS_F128,
|
||||
COS_PPCF128,
|
||||
SINCOS_F32,
|
||||
SINCOS_F64,
|
||||
SINCOS_F80,
|
||||
SINCOS_F128,
|
||||
SINCOS_PPCF128,
|
||||
POW_F32,
|
||||
POW_F64,
|
||||
POW_F80,
|
||||
POW_F128,
|
||||
POW_PPCF128,
|
||||
CEIL_F32,
|
||||
CEIL_F64,
|
||||
CEIL_F80,
|
||||
CEIL_F128,
|
||||
CEIL_PPCF128,
|
||||
TRUNC_F32,
|
||||
TRUNC_F64,
|
||||
TRUNC_F80,
|
||||
TRUNC_F128,
|
||||
TRUNC_PPCF128,
|
||||
RINT_F32,
|
||||
RINT_F64,
|
||||
RINT_F80,
|
||||
RINT_F128,
|
||||
RINT_PPCF128,
|
||||
NEARBYINT_F32,
|
||||
NEARBYINT_F64,
|
||||
NEARBYINT_F80,
|
||||
NEARBYINT_F128,
|
||||
NEARBYINT_PPCF128,
|
||||
ROUND_F32,
|
||||
ROUND_F64,
|
||||
ROUND_F80,
|
||||
ROUND_F128,
|
||||
ROUND_PPCF128,
|
||||
FLOOR_F32,
|
||||
FLOOR_F64,
|
||||
FLOOR_F80,
|
||||
FLOOR_F128,
|
||||
FLOOR_PPCF128,
|
||||
COPYSIGN_F32,
|
||||
COPYSIGN_F64,
|
||||
COPYSIGN_F80,
|
||||
COPYSIGN_F128,
|
||||
COPYSIGN_PPCF128,
|
||||
FMIN_F32,
|
||||
FMIN_F64,
|
||||
FMIN_F80,
|
||||
FMIN_F128,
|
||||
FMIN_PPCF128,
|
||||
FMAX_F32,
|
||||
FMAX_F64,
|
||||
FMAX_F80,
|
||||
FMAX_F128,
|
||||
FMAX_PPCF128,
|
||||
|
||||
// CONVERSION
|
||||
FPEXT_F32_PPCF128,
|
||||
FPEXT_F64_PPCF128,
|
||||
FPEXT_F64_F128,
|
||||
FPEXT_F32_F128,
|
||||
FPEXT_F32_F64,
|
||||
FPEXT_F16_F32,
|
||||
FPROUND_F32_F16,
|
||||
FPROUND_F64_F16,
|
||||
FPROUND_F80_F16,
|
||||
FPROUND_F128_F16,
|
||||
FPROUND_PPCF128_F16,
|
||||
FPROUND_F64_F32,
|
||||
FPROUND_F80_F32,
|
||||
FPROUND_F128_F32,
|
||||
FPROUND_PPCF128_F32,
|
||||
FPROUND_F80_F64,
|
||||
FPROUND_F128_F64,
|
||||
FPROUND_PPCF128_F64,
|
||||
FPTOSINT_F32_I32,
|
||||
FPTOSINT_F32_I64,
|
||||
FPTOSINT_F32_I128,
|
||||
FPTOSINT_F64_I32,
|
||||
FPTOSINT_F64_I64,
|
||||
FPTOSINT_F64_I128,
|
||||
FPTOSINT_F80_I32,
|
||||
FPTOSINT_F80_I64,
|
||||
FPTOSINT_F80_I128,
|
||||
FPTOSINT_F128_I32,
|
||||
FPTOSINT_F128_I64,
|
||||
FPTOSINT_F128_I128,
|
||||
FPTOSINT_PPCF128_I32,
|
||||
FPTOSINT_PPCF128_I64,
|
||||
FPTOSINT_PPCF128_I128,
|
||||
FPTOUINT_F32_I32,
|
||||
FPTOUINT_F32_I64,
|
||||
FPTOUINT_F32_I128,
|
||||
FPTOUINT_F64_I32,
|
||||
FPTOUINT_F64_I64,
|
||||
FPTOUINT_F64_I128,
|
||||
FPTOUINT_F80_I32,
|
||||
FPTOUINT_F80_I64,
|
||||
FPTOUINT_F80_I128,
|
||||
FPTOUINT_F128_I32,
|
||||
FPTOUINT_F128_I64,
|
||||
FPTOUINT_F128_I128,
|
||||
FPTOUINT_PPCF128_I32,
|
||||
FPTOUINT_PPCF128_I64,
|
||||
FPTOUINT_PPCF128_I128,
|
||||
SINTTOFP_I32_F32,
|
||||
SINTTOFP_I32_F64,
|
||||
SINTTOFP_I32_F80,
|
||||
SINTTOFP_I32_F128,
|
||||
SINTTOFP_I32_PPCF128,
|
||||
SINTTOFP_I64_F32,
|
||||
SINTTOFP_I64_F64,
|
||||
SINTTOFP_I64_F80,
|
||||
SINTTOFP_I64_F128,
|
||||
SINTTOFP_I64_PPCF128,
|
||||
SINTTOFP_I128_F32,
|
||||
SINTTOFP_I128_F64,
|
||||
SINTTOFP_I128_F80,
|
||||
SINTTOFP_I128_F128,
|
||||
SINTTOFP_I128_PPCF128,
|
||||
UINTTOFP_I32_F32,
|
||||
UINTTOFP_I32_F64,
|
||||
UINTTOFP_I32_F80,
|
||||
UINTTOFP_I32_F128,
|
||||
UINTTOFP_I32_PPCF128,
|
||||
UINTTOFP_I64_F32,
|
||||
UINTTOFP_I64_F64,
|
||||
UINTTOFP_I64_F80,
|
||||
UINTTOFP_I64_F128,
|
||||
UINTTOFP_I64_PPCF128,
|
||||
UINTTOFP_I128_F32,
|
||||
UINTTOFP_I128_F64,
|
||||
UINTTOFP_I128_F80,
|
||||
UINTTOFP_I128_F128,
|
||||
UINTTOFP_I128_PPCF128,
|
||||
|
||||
// COMPARISON
|
||||
OEQ_F32,
|
||||
OEQ_F64,
|
||||
OEQ_F128,
|
||||
OEQ_PPCF128,
|
||||
UNE_F32,
|
||||
UNE_F64,
|
||||
UNE_F128,
|
||||
UNE_PPCF128,
|
||||
OGE_F32,
|
||||
OGE_F64,
|
||||
OGE_F128,
|
||||
OGE_PPCF128,
|
||||
OLT_F32,
|
||||
OLT_F64,
|
||||
OLT_F128,
|
||||
OLT_PPCF128,
|
||||
OLE_F32,
|
||||
OLE_F64,
|
||||
OLE_F128,
|
||||
OLE_PPCF128,
|
||||
OGT_F32,
|
||||
OGT_F64,
|
||||
OGT_F128,
|
||||
OGT_PPCF128,
|
||||
UO_F32,
|
||||
UO_F64,
|
||||
UO_F128,
|
||||
UO_PPCF128,
|
||||
O_F32,
|
||||
O_F64,
|
||||
O_F128,
|
||||
O_PPCF128,
|
||||
|
||||
// MEMORY
|
||||
MEMCPY,
|
||||
MEMSET,
|
||||
MEMMOVE,
|
||||
|
||||
// ELEMENT-WISE UNORDERED-ATOMIC MEMORY of different element sizes
|
||||
MEMCPY_ELEMENT_UNORDERED_ATOMIC_1,
|
||||
MEMCPY_ELEMENT_UNORDERED_ATOMIC_2,
|
||||
MEMCPY_ELEMENT_UNORDERED_ATOMIC_4,
|
||||
MEMCPY_ELEMENT_UNORDERED_ATOMIC_8,
|
||||
MEMCPY_ELEMENT_UNORDERED_ATOMIC_16,
|
||||
|
||||
MEMMOVE_ELEMENT_UNORDERED_ATOMIC_1,
|
||||
MEMMOVE_ELEMENT_UNORDERED_ATOMIC_2,
|
||||
MEMMOVE_ELEMENT_UNORDERED_ATOMIC_4,
|
||||
MEMMOVE_ELEMENT_UNORDERED_ATOMIC_8,
|
||||
MEMMOVE_ELEMENT_UNORDERED_ATOMIC_16,
|
||||
|
||||
MEMSET_ELEMENT_UNORDERED_ATOMIC_1,
|
||||
MEMSET_ELEMENT_UNORDERED_ATOMIC_2,
|
||||
MEMSET_ELEMENT_UNORDERED_ATOMIC_4,
|
||||
MEMSET_ELEMENT_UNORDERED_ATOMIC_8,
|
||||
MEMSET_ELEMENT_UNORDERED_ATOMIC_16,
|
||||
|
||||
// EXCEPTION HANDLING
|
||||
UNWIND_RESUME,
|
||||
|
||||
// Note: there's two sets of atomics libcalls; see
|
||||
// <http://llvm.org/docs/Atomics.html> for more info on the
|
||||
// difference between them.
|
||||
|
||||
// Atomic '__sync_*' libcalls.
|
||||
SYNC_VAL_COMPARE_AND_SWAP_1,
|
||||
SYNC_VAL_COMPARE_AND_SWAP_2,
|
||||
SYNC_VAL_COMPARE_AND_SWAP_4,
|
||||
SYNC_VAL_COMPARE_AND_SWAP_8,
|
||||
SYNC_VAL_COMPARE_AND_SWAP_16,
|
||||
SYNC_LOCK_TEST_AND_SET_1,
|
||||
SYNC_LOCK_TEST_AND_SET_2,
|
||||
SYNC_LOCK_TEST_AND_SET_4,
|
||||
SYNC_LOCK_TEST_AND_SET_8,
|
||||
SYNC_LOCK_TEST_AND_SET_16,
|
||||
SYNC_FETCH_AND_ADD_1,
|
||||
SYNC_FETCH_AND_ADD_2,
|
||||
SYNC_FETCH_AND_ADD_4,
|
||||
SYNC_FETCH_AND_ADD_8,
|
||||
SYNC_FETCH_AND_ADD_16,
|
||||
SYNC_FETCH_AND_SUB_1,
|
||||
SYNC_FETCH_AND_SUB_2,
|
||||
SYNC_FETCH_AND_SUB_4,
|
||||
SYNC_FETCH_AND_SUB_8,
|
||||
SYNC_FETCH_AND_SUB_16,
|
||||
SYNC_FETCH_AND_AND_1,
|
||||
SYNC_FETCH_AND_AND_2,
|
||||
SYNC_FETCH_AND_AND_4,
|
||||
SYNC_FETCH_AND_AND_8,
|
||||
SYNC_FETCH_AND_AND_16,
|
||||
SYNC_FETCH_AND_OR_1,
|
||||
SYNC_FETCH_AND_OR_2,
|
||||
SYNC_FETCH_AND_OR_4,
|
||||
SYNC_FETCH_AND_OR_8,
|
||||
SYNC_FETCH_AND_OR_16,
|
||||
SYNC_FETCH_AND_XOR_1,
|
||||
SYNC_FETCH_AND_XOR_2,
|
||||
SYNC_FETCH_AND_XOR_4,
|
||||
SYNC_FETCH_AND_XOR_8,
|
||||
SYNC_FETCH_AND_XOR_16,
|
||||
SYNC_FETCH_AND_NAND_1,
|
||||
SYNC_FETCH_AND_NAND_2,
|
||||
SYNC_FETCH_AND_NAND_4,
|
||||
SYNC_FETCH_AND_NAND_8,
|
||||
SYNC_FETCH_AND_NAND_16,
|
||||
SYNC_FETCH_AND_MAX_1,
|
||||
SYNC_FETCH_AND_MAX_2,
|
||||
SYNC_FETCH_AND_MAX_4,
|
||||
SYNC_FETCH_AND_MAX_8,
|
||||
SYNC_FETCH_AND_MAX_16,
|
||||
SYNC_FETCH_AND_UMAX_1,
|
||||
SYNC_FETCH_AND_UMAX_2,
|
||||
SYNC_FETCH_AND_UMAX_4,
|
||||
SYNC_FETCH_AND_UMAX_8,
|
||||
SYNC_FETCH_AND_UMAX_16,
|
||||
SYNC_FETCH_AND_MIN_1,
|
||||
SYNC_FETCH_AND_MIN_2,
|
||||
SYNC_FETCH_AND_MIN_4,
|
||||
SYNC_FETCH_AND_MIN_8,
|
||||
SYNC_FETCH_AND_MIN_16,
|
||||
SYNC_FETCH_AND_UMIN_1,
|
||||
SYNC_FETCH_AND_UMIN_2,
|
||||
SYNC_FETCH_AND_UMIN_4,
|
||||
SYNC_FETCH_AND_UMIN_8,
|
||||
SYNC_FETCH_AND_UMIN_16,
|
||||
|
||||
// Atomic '__atomic_*' libcalls.
|
||||
ATOMIC_LOAD,
|
||||
ATOMIC_LOAD_1,
|
||||
ATOMIC_LOAD_2,
|
||||
ATOMIC_LOAD_4,
|
||||
ATOMIC_LOAD_8,
|
||||
ATOMIC_LOAD_16,
|
||||
|
||||
ATOMIC_STORE,
|
||||
ATOMIC_STORE_1,
|
||||
ATOMIC_STORE_2,
|
||||
ATOMIC_STORE_4,
|
||||
ATOMIC_STORE_8,
|
||||
ATOMIC_STORE_16,
|
||||
|
||||
ATOMIC_EXCHANGE,
|
||||
ATOMIC_EXCHANGE_1,
|
||||
ATOMIC_EXCHANGE_2,
|
||||
ATOMIC_EXCHANGE_4,
|
||||
ATOMIC_EXCHANGE_8,
|
||||
ATOMIC_EXCHANGE_16,
|
||||
|
||||
ATOMIC_COMPARE_EXCHANGE,
|
||||
ATOMIC_COMPARE_EXCHANGE_1,
|
||||
ATOMIC_COMPARE_EXCHANGE_2,
|
||||
ATOMIC_COMPARE_EXCHANGE_4,
|
||||
ATOMIC_COMPARE_EXCHANGE_8,
|
||||
ATOMIC_COMPARE_EXCHANGE_16,
|
||||
|
||||
ATOMIC_FETCH_ADD_1,
|
||||
ATOMIC_FETCH_ADD_2,
|
||||
ATOMIC_FETCH_ADD_4,
|
||||
ATOMIC_FETCH_ADD_8,
|
||||
ATOMIC_FETCH_ADD_16,
|
||||
|
||||
ATOMIC_FETCH_SUB_1,
|
||||
ATOMIC_FETCH_SUB_2,
|
||||
ATOMIC_FETCH_SUB_4,
|
||||
ATOMIC_FETCH_SUB_8,
|
||||
ATOMIC_FETCH_SUB_16,
|
||||
|
||||
ATOMIC_FETCH_AND_1,
|
||||
ATOMIC_FETCH_AND_2,
|
||||
ATOMIC_FETCH_AND_4,
|
||||
ATOMIC_FETCH_AND_8,
|
||||
ATOMIC_FETCH_AND_16,
|
||||
|
||||
ATOMIC_FETCH_OR_1,
|
||||
ATOMIC_FETCH_OR_2,
|
||||
ATOMIC_FETCH_OR_4,
|
||||
ATOMIC_FETCH_OR_8,
|
||||
ATOMIC_FETCH_OR_16,
|
||||
|
||||
ATOMIC_FETCH_XOR_1,
|
||||
ATOMIC_FETCH_XOR_2,
|
||||
ATOMIC_FETCH_XOR_4,
|
||||
ATOMIC_FETCH_XOR_8,
|
||||
ATOMIC_FETCH_XOR_16,
|
||||
|
||||
ATOMIC_FETCH_NAND_1,
|
||||
ATOMIC_FETCH_NAND_2,
|
||||
ATOMIC_FETCH_NAND_4,
|
||||
ATOMIC_FETCH_NAND_8,
|
||||
ATOMIC_FETCH_NAND_16,
|
||||
|
||||
// Stack Protector Fail.
|
||||
STACKPROTECTOR_CHECK_FAIL,
|
||||
|
||||
// Deoptimization.
|
||||
DEOPTIMIZE,
|
||||
|
||||
UNKNOWN_LIBCALL
|
||||
#define HANDLE_LIBCALL(code, name) code,
|
||||
#include "RuntimeLibcalls.def"
|
||||
#undef HANDLE_LIBCALL
|
||||
};
|
||||
|
||||
/// getFPEXT - Return the FPEXT_*_* value for the given types, or
|
||||
|
|
|
|||
|
|
@ -80,184 +80,12 @@ static cl::opt<int> MinPercentageForPredictableBranch(
|
|||
/// InitLibcallNames - Set default libcall names.
|
||||
///
|
||||
static void InitLibcallNames(const char **Names, const Triple &TT) {
|
||||
Names[RTLIB::SHL_I16] = "__ashlhi3";
|
||||
Names[RTLIB::SHL_I32] = "__ashlsi3";
|
||||
Names[RTLIB::SHL_I64] = "__ashldi3";
|
||||
Names[RTLIB::SHL_I128] = "__ashlti3";
|
||||
Names[RTLIB::SRL_I16] = "__lshrhi3";
|
||||
Names[RTLIB::SRL_I32] = "__lshrsi3";
|
||||
Names[RTLIB::SRL_I64] = "__lshrdi3";
|
||||
Names[RTLIB::SRL_I128] = "__lshrti3";
|
||||
Names[RTLIB::SRA_I16] = "__ashrhi3";
|
||||
Names[RTLIB::SRA_I32] = "__ashrsi3";
|
||||
Names[RTLIB::SRA_I64] = "__ashrdi3";
|
||||
Names[RTLIB::SRA_I128] = "__ashrti3";
|
||||
Names[RTLIB::MUL_I8] = "__mulqi3";
|
||||
Names[RTLIB::MUL_I16] = "__mulhi3";
|
||||
Names[RTLIB::MUL_I32] = "__mulsi3";
|
||||
Names[RTLIB::MUL_I64] = "__muldi3";
|
||||
Names[RTLIB::MUL_I128] = "__multi3";
|
||||
Names[RTLIB::MULO_I32] = "__mulosi4";
|
||||
Names[RTLIB::MULO_I64] = "__mulodi4";
|
||||
Names[RTLIB::MULO_I128] = "__muloti4";
|
||||
Names[RTLIB::SDIV_I8] = "__divqi3";
|
||||
Names[RTLIB::SDIV_I16] = "__divhi3";
|
||||
Names[RTLIB::SDIV_I32] = "__divsi3";
|
||||
Names[RTLIB::SDIV_I64] = "__divdi3";
|
||||
Names[RTLIB::SDIV_I128] = "__divti3";
|
||||
Names[RTLIB::UDIV_I8] = "__udivqi3";
|
||||
Names[RTLIB::UDIV_I16] = "__udivhi3";
|
||||
Names[RTLIB::UDIV_I32] = "__udivsi3";
|
||||
Names[RTLIB::UDIV_I64] = "__udivdi3";
|
||||
Names[RTLIB::UDIV_I128] = "__udivti3";
|
||||
Names[RTLIB::SREM_I8] = "__modqi3";
|
||||
Names[RTLIB::SREM_I16] = "__modhi3";
|
||||
Names[RTLIB::SREM_I32] = "__modsi3";
|
||||
Names[RTLIB::SREM_I64] = "__moddi3";
|
||||
Names[RTLIB::SREM_I128] = "__modti3";
|
||||
Names[RTLIB::UREM_I8] = "__umodqi3";
|
||||
Names[RTLIB::UREM_I16] = "__umodhi3";
|
||||
Names[RTLIB::UREM_I32] = "__umodsi3";
|
||||
Names[RTLIB::UREM_I64] = "__umoddi3";
|
||||
Names[RTLIB::UREM_I128] = "__umodti3";
|
||||
#define HANDLE_LIBCALL(code, name) \
|
||||
Names[RTLIB::code] = name;
|
||||
#include "llvm/CodeGen/RuntimeLibcalls.def"
|
||||
#undef HANDLE_LIBCALL
|
||||
|
||||
Names[RTLIB::NEG_I32] = "__negsi2";
|
||||
Names[RTLIB::NEG_I64] = "__negdi2";
|
||||
Names[RTLIB::ADD_F32] = "__addsf3";
|
||||
Names[RTLIB::ADD_F64] = "__adddf3";
|
||||
Names[RTLIB::ADD_F80] = "__addxf3";
|
||||
Names[RTLIB::ADD_F128] = "__addtf3";
|
||||
Names[RTLIB::ADD_PPCF128] = "__gcc_qadd";
|
||||
Names[RTLIB::SUB_F32] = "__subsf3";
|
||||
Names[RTLIB::SUB_F64] = "__subdf3";
|
||||
Names[RTLIB::SUB_F80] = "__subxf3";
|
||||
Names[RTLIB::SUB_F128] = "__subtf3";
|
||||
Names[RTLIB::SUB_PPCF128] = "__gcc_qsub";
|
||||
Names[RTLIB::MUL_F32] = "__mulsf3";
|
||||
Names[RTLIB::MUL_F64] = "__muldf3";
|
||||
Names[RTLIB::MUL_F80] = "__mulxf3";
|
||||
Names[RTLIB::MUL_F128] = "__multf3";
|
||||
Names[RTLIB::MUL_PPCF128] = "__gcc_qmul";
|
||||
Names[RTLIB::DIV_F32] = "__divsf3";
|
||||
Names[RTLIB::DIV_F64] = "__divdf3";
|
||||
Names[RTLIB::DIV_F80] = "__divxf3";
|
||||
Names[RTLIB::DIV_F128] = "__divtf3";
|
||||
Names[RTLIB::DIV_PPCF128] = "__gcc_qdiv";
|
||||
Names[RTLIB::REM_F32] = "fmodf";
|
||||
Names[RTLIB::REM_F64] = "fmod";
|
||||
Names[RTLIB::REM_F80] = "fmodl";
|
||||
Names[RTLIB::REM_F128] = "fmodl";
|
||||
Names[RTLIB::REM_PPCF128] = "fmodl";
|
||||
Names[RTLIB::FMA_F32] = "fmaf";
|
||||
Names[RTLIB::FMA_F64] = "fma";
|
||||
Names[RTLIB::FMA_F80] = "fmal";
|
||||
Names[RTLIB::FMA_F128] = "fmal";
|
||||
Names[RTLIB::FMA_PPCF128] = "fmal";
|
||||
Names[RTLIB::POWI_F32] = "__powisf2";
|
||||
Names[RTLIB::POWI_F64] = "__powidf2";
|
||||
Names[RTLIB::POWI_F80] = "__powixf2";
|
||||
Names[RTLIB::POWI_F128] = "__powitf2";
|
||||
Names[RTLIB::POWI_PPCF128] = "__powitf2";
|
||||
Names[RTLIB::SQRT_F32] = "sqrtf";
|
||||
Names[RTLIB::SQRT_F64] = "sqrt";
|
||||
Names[RTLIB::SQRT_F80] = "sqrtl";
|
||||
Names[RTLIB::SQRT_F128] = "sqrtl";
|
||||
Names[RTLIB::SQRT_PPCF128] = "sqrtl";
|
||||
Names[RTLIB::LOG_F32] = "logf";
|
||||
Names[RTLIB::LOG_F64] = "log";
|
||||
Names[RTLIB::LOG_F80] = "logl";
|
||||
Names[RTLIB::LOG_F128] = "logl";
|
||||
Names[RTLIB::LOG_PPCF128] = "logl";
|
||||
Names[RTLIB::LOG2_F32] = "log2f";
|
||||
Names[RTLIB::LOG2_F64] = "log2";
|
||||
Names[RTLIB::LOG2_F80] = "log2l";
|
||||
Names[RTLIB::LOG2_F128] = "log2l";
|
||||
Names[RTLIB::LOG2_PPCF128] = "log2l";
|
||||
Names[RTLIB::LOG10_F32] = "log10f";
|
||||
Names[RTLIB::LOG10_F64] = "log10";
|
||||
Names[RTLIB::LOG10_F80] = "log10l";
|
||||
Names[RTLIB::LOG10_F128] = "log10l";
|
||||
Names[RTLIB::LOG10_PPCF128] = "log10l";
|
||||
Names[RTLIB::EXP_F32] = "expf";
|
||||
Names[RTLIB::EXP_F64] = "exp";
|
||||
Names[RTLIB::EXP_F80] = "expl";
|
||||
Names[RTLIB::EXP_F128] = "expl";
|
||||
Names[RTLIB::EXP_PPCF128] = "expl";
|
||||
Names[RTLIB::EXP2_F32] = "exp2f";
|
||||
Names[RTLIB::EXP2_F64] = "exp2";
|
||||
Names[RTLIB::EXP2_F80] = "exp2l";
|
||||
Names[RTLIB::EXP2_F128] = "exp2l";
|
||||
Names[RTLIB::EXP2_PPCF128] = "exp2l";
|
||||
Names[RTLIB::SIN_F32] = "sinf";
|
||||
Names[RTLIB::SIN_F64] = "sin";
|
||||
Names[RTLIB::SIN_F80] = "sinl";
|
||||
Names[RTLIB::SIN_F128] = "sinl";
|
||||
Names[RTLIB::SIN_PPCF128] = "sinl";
|
||||
Names[RTLIB::COS_F32] = "cosf";
|
||||
Names[RTLIB::COS_F64] = "cos";
|
||||
Names[RTLIB::COS_F80] = "cosl";
|
||||
Names[RTLIB::COS_F128] = "cosl";
|
||||
Names[RTLIB::COS_PPCF128] = "cosl";
|
||||
Names[RTLIB::POW_F32] = "powf";
|
||||
Names[RTLIB::POW_F64] = "pow";
|
||||
Names[RTLIB::POW_F80] = "powl";
|
||||
Names[RTLIB::POW_F128] = "powl";
|
||||
Names[RTLIB::POW_PPCF128] = "powl";
|
||||
Names[RTLIB::CEIL_F32] = "ceilf";
|
||||
Names[RTLIB::CEIL_F64] = "ceil";
|
||||
Names[RTLIB::CEIL_F80] = "ceill";
|
||||
Names[RTLIB::CEIL_F128] = "ceill";
|
||||
Names[RTLIB::CEIL_PPCF128] = "ceill";
|
||||
Names[RTLIB::TRUNC_F32] = "truncf";
|
||||
Names[RTLIB::TRUNC_F64] = "trunc";
|
||||
Names[RTLIB::TRUNC_F80] = "truncl";
|
||||
Names[RTLIB::TRUNC_F128] = "truncl";
|
||||
Names[RTLIB::TRUNC_PPCF128] = "truncl";
|
||||
Names[RTLIB::RINT_F32] = "rintf";
|
||||
Names[RTLIB::RINT_F64] = "rint";
|
||||
Names[RTLIB::RINT_F80] = "rintl";
|
||||
Names[RTLIB::RINT_F128] = "rintl";
|
||||
Names[RTLIB::RINT_PPCF128] = "rintl";
|
||||
Names[RTLIB::NEARBYINT_F32] = "nearbyintf";
|
||||
Names[RTLIB::NEARBYINT_F64] = "nearbyint";
|
||||
Names[RTLIB::NEARBYINT_F80] = "nearbyintl";
|
||||
Names[RTLIB::NEARBYINT_F128] = "nearbyintl";
|
||||
Names[RTLIB::NEARBYINT_PPCF128] = "nearbyintl";
|
||||
Names[RTLIB::ROUND_F32] = "roundf";
|
||||
Names[RTLIB::ROUND_F64] = "round";
|
||||
Names[RTLIB::ROUND_F80] = "roundl";
|
||||
Names[RTLIB::ROUND_F128] = "roundl";
|
||||
Names[RTLIB::ROUND_PPCF128] = "roundl";
|
||||
Names[RTLIB::FLOOR_F32] = "floorf";
|
||||
Names[RTLIB::FLOOR_F64] = "floor";
|
||||
Names[RTLIB::FLOOR_F80] = "floorl";
|
||||
Names[RTLIB::FLOOR_F128] = "floorl";
|
||||
Names[RTLIB::FLOOR_PPCF128] = "floorl";
|
||||
Names[RTLIB::FMIN_F32] = "fminf";
|
||||
Names[RTLIB::FMIN_F64] = "fmin";
|
||||
Names[RTLIB::FMIN_F80] = "fminl";
|
||||
Names[RTLIB::FMIN_F128] = "fminl";
|
||||
Names[RTLIB::FMIN_PPCF128] = "fminl";
|
||||
Names[RTLIB::FMAX_F32] = "fmaxf";
|
||||
Names[RTLIB::FMAX_F64] = "fmax";
|
||||
Names[RTLIB::FMAX_F80] = "fmaxl";
|
||||
Names[RTLIB::FMAX_F128] = "fmaxl";
|
||||
Names[RTLIB::FMAX_PPCF128] = "fmaxl";
|
||||
Names[RTLIB::ROUND_F32] = "roundf";
|
||||
Names[RTLIB::ROUND_F64] = "round";
|
||||
Names[RTLIB::ROUND_F80] = "roundl";
|
||||
Names[RTLIB::ROUND_F128] = "roundl";
|
||||
Names[RTLIB::ROUND_PPCF128] = "roundl";
|
||||
Names[RTLIB::COPYSIGN_F32] = "copysignf";
|
||||
Names[RTLIB::COPYSIGN_F64] = "copysign";
|
||||
Names[RTLIB::COPYSIGN_F80] = "copysignl";
|
||||
Names[RTLIB::COPYSIGN_F128] = "copysignl";
|
||||
Names[RTLIB::COPYSIGN_PPCF128] = "copysignl";
|
||||
Names[RTLIB::FPEXT_F32_PPCF128] = "__gcc_stoq";
|
||||
Names[RTLIB::FPEXT_F64_PPCF128] = "__gcc_dtoq";
|
||||
Names[RTLIB::FPEXT_F64_F128] = "__extenddftf2";
|
||||
Names[RTLIB::FPEXT_F32_F128] = "__extendsftf2";
|
||||
Names[RTLIB::FPEXT_F32_F64] = "__extendsfdf2";
|
||||
// A few names are different on particular architectures or environments.
|
||||
if (TT.isOSDarwin()) {
|
||||
// For f16/f32 conversions, Darwin uses the standard naming scheme, instead
|
||||
// of the gnueabi-style __gnu_*_ieee.
|
||||
|
|
@ -268,262 +96,6 @@ static void InitLibcallNames(const char **Names, const Triple &TT) {
|
|||
Names[RTLIB::FPEXT_F16_F32] = "__gnu_h2f_ieee";
|
||||
Names[RTLIB::FPROUND_F32_F16] = "__gnu_f2h_ieee";
|
||||
}
|
||||
Names[RTLIB::FPROUND_F64_F16] = "__truncdfhf2";
|
||||
Names[RTLIB::FPROUND_F80_F16] = "__truncxfhf2";
|
||||
Names[RTLIB::FPROUND_F128_F16] = "__trunctfhf2";
|
||||
Names[RTLIB::FPROUND_PPCF128_F16] = "__trunctfhf2";
|
||||
Names[RTLIB::FPROUND_F64_F32] = "__truncdfsf2";
|
||||
Names[RTLIB::FPROUND_F80_F32] = "__truncxfsf2";
|
||||
Names[RTLIB::FPROUND_F128_F32] = "__trunctfsf2";
|
||||
Names[RTLIB::FPROUND_PPCF128_F32] = "__gcc_qtos";
|
||||
Names[RTLIB::FPROUND_F80_F64] = "__truncxfdf2";
|
||||
Names[RTLIB::FPROUND_F128_F64] = "__trunctfdf2";
|
||||
Names[RTLIB::FPROUND_PPCF128_F64] = "__gcc_qtod";
|
||||
Names[RTLIB::FPTOSINT_F32_I32] = "__fixsfsi";
|
||||
Names[RTLIB::FPTOSINT_F32_I64] = "__fixsfdi";
|
||||
Names[RTLIB::FPTOSINT_F32_I128] = "__fixsfti";
|
||||
Names[RTLIB::FPTOSINT_F64_I32] = "__fixdfsi";
|
||||
Names[RTLIB::FPTOSINT_F64_I64] = "__fixdfdi";
|
||||
Names[RTLIB::FPTOSINT_F64_I128] = "__fixdfti";
|
||||
Names[RTLIB::FPTOSINT_F80_I32] = "__fixxfsi";
|
||||
Names[RTLIB::FPTOSINT_F80_I64] = "__fixxfdi";
|
||||
Names[RTLIB::FPTOSINT_F80_I128] = "__fixxfti";
|
||||
Names[RTLIB::FPTOSINT_F128_I32] = "__fixtfsi";
|
||||
Names[RTLIB::FPTOSINT_F128_I64] = "__fixtfdi";
|
||||
Names[RTLIB::FPTOSINT_F128_I128] = "__fixtfti";
|
||||
Names[RTLIB::FPTOSINT_PPCF128_I32] = "__gcc_qtou";
|
||||
Names[RTLIB::FPTOSINT_PPCF128_I64] = "__fixtfdi";
|
||||
Names[RTLIB::FPTOSINT_PPCF128_I128] = "__fixtfti";
|
||||
Names[RTLIB::FPTOUINT_F32_I32] = "__fixunssfsi";
|
||||
Names[RTLIB::FPTOUINT_F32_I64] = "__fixunssfdi";
|
||||
Names[RTLIB::FPTOUINT_F32_I128] = "__fixunssfti";
|
||||
Names[RTLIB::FPTOUINT_F64_I32] = "__fixunsdfsi";
|
||||
Names[RTLIB::FPTOUINT_F64_I64] = "__fixunsdfdi";
|
||||
Names[RTLIB::FPTOUINT_F64_I128] = "__fixunsdfti";
|
||||
Names[RTLIB::FPTOUINT_F80_I32] = "__fixunsxfsi";
|
||||
Names[RTLIB::FPTOUINT_F80_I64] = "__fixunsxfdi";
|
||||
Names[RTLIB::FPTOUINT_F80_I128] = "__fixunsxfti";
|
||||
Names[RTLIB::FPTOUINT_F128_I32] = "__fixunstfsi";
|
||||
Names[RTLIB::FPTOUINT_F128_I64] = "__fixunstfdi";
|
||||
Names[RTLIB::FPTOUINT_F128_I128] = "__fixunstfti";
|
||||
Names[RTLIB::FPTOUINT_PPCF128_I32] = "__fixunstfsi";
|
||||
Names[RTLIB::FPTOUINT_PPCF128_I64] = "__fixunstfdi";
|
||||
Names[RTLIB::FPTOUINT_PPCF128_I128] = "__fixunstfti";
|
||||
Names[RTLIB::SINTTOFP_I32_F32] = "__floatsisf";
|
||||
Names[RTLIB::SINTTOFP_I32_F64] = "__floatsidf";
|
||||
Names[RTLIB::SINTTOFP_I32_F80] = "__floatsixf";
|
||||
Names[RTLIB::SINTTOFP_I32_F128] = "__floatsitf";
|
||||
Names[RTLIB::SINTTOFP_I32_PPCF128] = "__gcc_itoq";
|
||||
Names[RTLIB::SINTTOFP_I64_F32] = "__floatdisf";
|
||||
Names[RTLIB::SINTTOFP_I64_F64] = "__floatdidf";
|
||||
Names[RTLIB::SINTTOFP_I64_F80] = "__floatdixf";
|
||||
Names[RTLIB::SINTTOFP_I64_F128] = "__floatditf";
|
||||
Names[RTLIB::SINTTOFP_I64_PPCF128] = "__floatditf";
|
||||
Names[RTLIB::SINTTOFP_I128_F32] = "__floattisf";
|
||||
Names[RTLIB::SINTTOFP_I128_F64] = "__floattidf";
|
||||
Names[RTLIB::SINTTOFP_I128_F80] = "__floattixf";
|
||||
Names[RTLIB::SINTTOFP_I128_F128] = "__floattitf";
|
||||
Names[RTLIB::SINTTOFP_I128_PPCF128] = "__floattitf";
|
||||
Names[RTLIB::UINTTOFP_I32_F32] = "__floatunsisf";
|
||||
Names[RTLIB::UINTTOFP_I32_F64] = "__floatunsidf";
|
||||
Names[RTLIB::UINTTOFP_I32_F80] = "__floatunsixf";
|
||||
Names[RTLIB::UINTTOFP_I32_F128] = "__floatunsitf";
|
||||
Names[RTLIB::UINTTOFP_I32_PPCF128] = "__gcc_utoq";
|
||||
Names[RTLIB::UINTTOFP_I64_F32] = "__floatundisf";
|
||||
Names[RTLIB::UINTTOFP_I64_F64] = "__floatundidf";
|
||||
Names[RTLIB::UINTTOFP_I64_F80] = "__floatundixf";
|
||||
Names[RTLIB::UINTTOFP_I64_F128] = "__floatunditf";
|
||||
Names[RTLIB::UINTTOFP_I64_PPCF128] = "__floatunditf";
|
||||
Names[RTLIB::UINTTOFP_I128_F32] = "__floatuntisf";
|
||||
Names[RTLIB::UINTTOFP_I128_F64] = "__floatuntidf";
|
||||
Names[RTLIB::UINTTOFP_I128_F80] = "__floatuntixf";
|
||||
Names[RTLIB::UINTTOFP_I128_F128] = "__floatuntitf";
|
||||
Names[RTLIB::UINTTOFP_I128_PPCF128] = "__floatuntitf";
|
||||
Names[RTLIB::OEQ_F32] = "__eqsf2";
|
||||
Names[RTLIB::OEQ_F64] = "__eqdf2";
|
||||
Names[RTLIB::OEQ_F128] = "__eqtf2";
|
||||
Names[RTLIB::OEQ_PPCF128] = "__gcc_qeq";
|
||||
Names[RTLIB::UNE_F32] = "__nesf2";
|
||||
Names[RTLIB::UNE_F64] = "__nedf2";
|
||||
Names[RTLIB::UNE_F128] = "__netf2";
|
||||
Names[RTLIB::UNE_PPCF128] = "__gcc_qne";
|
||||
Names[RTLIB::OGE_F32] = "__gesf2";
|
||||
Names[RTLIB::OGE_F64] = "__gedf2";
|
||||
Names[RTLIB::OGE_F128] = "__getf2";
|
||||
Names[RTLIB::OGE_PPCF128] = "__gcc_qge";
|
||||
Names[RTLIB::OLT_F32] = "__ltsf2";
|
||||
Names[RTLIB::OLT_F64] = "__ltdf2";
|
||||
Names[RTLIB::OLT_F128] = "__lttf2";
|
||||
Names[RTLIB::OLT_PPCF128] = "__gcc_qlt";
|
||||
Names[RTLIB::OLE_F32] = "__lesf2";
|
||||
Names[RTLIB::OLE_F64] = "__ledf2";
|
||||
Names[RTLIB::OLE_F128] = "__letf2";
|
||||
Names[RTLIB::OLE_PPCF128] = "__gcc_qle";
|
||||
Names[RTLIB::OGT_F32] = "__gtsf2";
|
||||
Names[RTLIB::OGT_F64] = "__gtdf2";
|
||||
Names[RTLIB::OGT_F128] = "__gttf2";
|
||||
Names[RTLIB::OGT_PPCF128] = "__gcc_qgt";
|
||||
Names[RTLIB::UO_F32] = "__unordsf2";
|
||||
Names[RTLIB::UO_F64] = "__unorddf2";
|
||||
Names[RTLIB::UO_F128] = "__unordtf2";
|
||||
Names[RTLIB::UO_PPCF128] = "__gcc_qunord";
|
||||
Names[RTLIB::O_F32] = "__unordsf2";
|
||||
Names[RTLIB::O_F64] = "__unorddf2";
|
||||
Names[RTLIB::O_F128] = "__unordtf2";
|
||||
Names[RTLIB::O_PPCF128] = "__gcc_qunord";
|
||||
Names[RTLIB::MEMCPY] = "memcpy";
|
||||
Names[RTLIB::MEMMOVE] = "memmove";
|
||||
Names[RTLIB::MEMSET] = "memset";
|
||||
Names[RTLIB::MEMCPY_ELEMENT_UNORDERED_ATOMIC_1] =
|
||||
"__llvm_memcpy_element_unordered_atomic_1";
|
||||
Names[RTLIB::MEMCPY_ELEMENT_UNORDERED_ATOMIC_2] =
|
||||
"__llvm_memcpy_element_unordered_atomic_2";
|
||||
Names[RTLIB::MEMCPY_ELEMENT_UNORDERED_ATOMIC_4] =
|
||||
"__llvm_memcpy_element_unordered_atomic_4";
|
||||
Names[RTLIB::MEMCPY_ELEMENT_UNORDERED_ATOMIC_8] =
|
||||
"__llvm_memcpy_element_unordered_atomic_8";
|
||||
Names[RTLIB::MEMCPY_ELEMENT_UNORDERED_ATOMIC_16] =
|
||||
"__llvm_memcpy_element_unordered_atomic_16";
|
||||
Names[RTLIB::MEMMOVE_ELEMENT_UNORDERED_ATOMIC_1] =
|
||||
"__llvm_memmove_element_unordered_atomic_1";
|
||||
Names[RTLIB::MEMMOVE_ELEMENT_UNORDERED_ATOMIC_2] =
|
||||
"__llvm_memmove_element_unordered_atomic_2";
|
||||
Names[RTLIB::MEMMOVE_ELEMENT_UNORDERED_ATOMIC_4] =
|
||||
"__llvm_memmove_element_unordered_atomic_4";
|
||||
Names[RTLIB::MEMMOVE_ELEMENT_UNORDERED_ATOMIC_8] =
|
||||
"__llvm_memmove_element_unordered_atomic_8";
|
||||
Names[RTLIB::MEMMOVE_ELEMENT_UNORDERED_ATOMIC_16] =
|
||||
"__llvm_memmove_element_unordered_atomic_16";
|
||||
Names[RTLIB::MEMSET_ELEMENT_UNORDERED_ATOMIC_1] =
|
||||
"__llvm_memset_element_unordered_atomic_1";
|
||||
Names[RTLIB::MEMSET_ELEMENT_UNORDERED_ATOMIC_2] =
|
||||
"__llvm_memset_element_unordered_atomic_2";
|
||||
Names[RTLIB::MEMSET_ELEMENT_UNORDERED_ATOMIC_4] =
|
||||
"__llvm_memset_element_unordered_atomic_4";
|
||||
Names[RTLIB::MEMSET_ELEMENT_UNORDERED_ATOMIC_8] =
|
||||
"__llvm_memset_element_unordered_atomic_8";
|
||||
Names[RTLIB::MEMSET_ELEMENT_UNORDERED_ATOMIC_16] =
|
||||
"__llvm_memset_element_unordered_atomic_16";
|
||||
Names[RTLIB::UNWIND_RESUME] = "_Unwind_Resume";
|
||||
Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_1] = "__sync_val_compare_and_swap_1";
|
||||
Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_2] = "__sync_val_compare_and_swap_2";
|
||||
Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_4] = "__sync_val_compare_and_swap_4";
|
||||
Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_8] = "__sync_val_compare_and_swap_8";
|
||||
Names[RTLIB::SYNC_VAL_COMPARE_AND_SWAP_16] = "__sync_val_compare_and_swap_16";
|
||||
Names[RTLIB::SYNC_LOCK_TEST_AND_SET_1] = "__sync_lock_test_and_set_1";
|
||||
Names[RTLIB::SYNC_LOCK_TEST_AND_SET_2] = "__sync_lock_test_and_set_2";
|
||||
Names[RTLIB::SYNC_LOCK_TEST_AND_SET_4] = "__sync_lock_test_and_set_4";
|
||||
Names[RTLIB::SYNC_LOCK_TEST_AND_SET_8] = "__sync_lock_test_and_set_8";
|
||||
Names[RTLIB::SYNC_LOCK_TEST_AND_SET_16] = "__sync_lock_test_and_set_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_ADD_1] = "__sync_fetch_and_add_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_ADD_2] = "__sync_fetch_and_add_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_ADD_4] = "__sync_fetch_and_add_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_ADD_8] = "__sync_fetch_and_add_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_ADD_16] = "__sync_fetch_and_add_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_SUB_1] = "__sync_fetch_and_sub_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_SUB_2] = "__sync_fetch_and_sub_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_SUB_4] = "__sync_fetch_and_sub_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_SUB_8] = "__sync_fetch_and_sub_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_SUB_16] = "__sync_fetch_and_sub_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_AND_1] = "__sync_fetch_and_and_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_AND_2] = "__sync_fetch_and_and_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_AND_4] = "__sync_fetch_and_and_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_AND_8] = "__sync_fetch_and_and_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_AND_16] = "__sync_fetch_and_and_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_OR_1] = "__sync_fetch_and_or_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_OR_2] = "__sync_fetch_and_or_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_OR_4] = "__sync_fetch_and_or_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_OR_8] = "__sync_fetch_and_or_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_OR_16] = "__sync_fetch_and_or_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_XOR_1] = "__sync_fetch_and_xor_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_XOR_2] = "__sync_fetch_and_xor_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_XOR_4] = "__sync_fetch_and_xor_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_XOR_8] = "__sync_fetch_and_xor_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_XOR_16] = "__sync_fetch_and_xor_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_NAND_1] = "__sync_fetch_and_nand_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_NAND_2] = "__sync_fetch_and_nand_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_NAND_4] = "__sync_fetch_and_nand_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_NAND_8] = "__sync_fetch_and_nand_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_NAND_16] = "__sync_fetch_and_nand_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MAX_1] = "__sync_fetch_and_max_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MAX_2] = "__sync_fetch_and_max_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MAX_4] = "__sync_fetch_and_max_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MAX_8] = "__sync_fetch_and_max_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MAX_16] = "__sync_fetch_and_max_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMAX_1] = "__sync_fetch_and_umax_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMAX_2] = "__sync_fetch_and_umax_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMAX_4] = "__sync_fetch_and_umax_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMAX_8] = "__sync_fetch_and_umax_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMAX_16] = "__sync_fetch_and_umax_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MIN_1] = "__sync_fetch_and_min_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MIN_2] = "__sync_fetch_and_min_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MIN_4] = "__sync_fetch_and_min_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MIN_8] = "__sync_fetch_and_min_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_MIN_16] = "__sync_fetch_and_min_16";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMIN_1] = "__sync_fetch_and_umin_1";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMIN_2] = "__sync_fetch_and_umin_2";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMIN_4] = "__sync_fetch_and_umin_4";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMIN_8] = "__sync_fetch_and_umin_8";
|
||||
Names[RTLIB::SYNC_FETCH_AND_UMIN_16] = "__sync_fetch_and_umin_16";
|
||||
|
||||
Names[RTLIB::ATOMIC_LOAD] = "__atomic_load";
|
||||
Names[RTLIB::ATOMIC_LOAD_1] = "__atomic_load_1";
|
||||
Names[RTLIB::ATOMIC_LOAD_2] = "__atomic_load_2";
|
||||
Names[RTLIB::ATOMIC_LOAD_4] = "__atomic_load_4";
|
||||
Names[RTLIB::ATOMIC_LOAD_8] = "__atomic_load_8";
|
||||
Names[RTLIB::ATOMIC_LOAD_16] = "__atomic_load_16";
|
||||
|
||||
Names[RTLIB::ATOMIC_STORE] = "__atomic_store";
|
||||
Names[RTLIB::ATOMIC_STORE_1] = "__atomic_store_1";
|
||||
Names[RTLIB::ATOMIC_STORE_2] = "__atomic_store_2";
|
||||
Names[RTLIB::ATOMIC_STORE_4] = "__atomic_store_4";
|
||||
Names[RTLIB::ATOMIC_STORE_8] = "__atomic_store_8";
|
||||
Names[RTLIB::ATOMIC_STORE_16] = "__atomic_store_16";
|
||||
|
||||
Names[RTLIB::ATOMIC_EXCHANGE] = "__atomic_exchange";
|
||||
Names[RTLIB::ATOMIC_EXCHANGE_1] = "__atomic_exchange_1";
|
||||
Names[RTLIB::ATOMIC_EXCHANGE_2] = "__atomic_exchange_2";
|
||||
Names[RTLIB::ATOMIC_EXCHANGE_4] = "__atomic_exchange_4";
|
||||
Names[RTLIB::ATOMIC_EXCHANGE_8] = "__atomic_exchange_8";
|
||||
Names[RTLIB::ATOMIC_EXCHANGE_16] = "__atomic_exchange_16";
|
||||
|
||||
Names[RTLIB::ATOMIC_COMPARE_EXCHANGE] = "__atomic_compare_exchange";
|
||||
Names[RTLIB::ATOMIC_COMPARE_EXCHANGE_1] = "__atomic_compare_exchange_1";
|
||||
Names[RTLIB::ATOMIC_COMPARE_EXCHANGE_2] = "__atomic_compare_exchange_2";
|
||||
Names[RTLIB::ATOMIC_COMPARE_EXCHANGE_4] = "__atomic_compare_exchange_4";
|
||||
Names[RTLIB::ATOMIC_COMPARE_EXCHANGE_8] = "__atomic_compare_exchange_8";
|
||||
Names[RTLIB::ATOMIC_COMPARE_EXCHANGE_16] = "__atomic_compare_exchange_16";
|
||||
|
||||
Names[RTLIB::ATOMIC_FETCH_ADD_1] = "__atomic_fetch_add_1";
|
||||
Names[RTLIB::ATOMIC_FETCH_ADD_2] = "__atomic_fetch_add_2";
|
||||
Names[RTLIB::ATOMIC_FETCH_ADD_4] = "__atomic_fetch_add_4";
|
||||
Names[RTLIB::ATOMIC_FETCH_ADD_8] = "__atomic_fetch_add_8";
|
||||
Names[RTLIB::ATOMIC_FETCH_ADD_16] = "__atomic_fetch_add_16";
|
||||
Names[RTLIB::ATOMIC_FETCH_SUB_1] = "__atomic_fetch_sub_1";
|
||||
Names[RTLIB::ATOMIC_FETCH_SUB_2] = "__atomic_fetch_sub_2";
|
||||
Names[RTLIB::ATOMIC_FETCH_SUB_4] = "__atomic_fetch_sub_4";
|
||||
Names[RTLIB::ATOMIC_FETCH_SUB_8] = "__atomic_fetch_sub_8";
|
||||
Names[RTLIB::ATOMIC_FETCH_SUB_16] = "__atomic_fetch_sub_16";
|
||||
Names[RTLIB::ATOMIC_FETCH_AND_1] = "__atomic_fetch_and_1";
|
||||
Names[RTLIB::ATOMIC_FETCH_AND_2] = "__atomic_fetch_and_2";
|
||||
Names[RTLIB::ATOMIC_FETCH_AND_4] = "__atomic_fetch_and_4";
|
||||
Names[RTLIB::ATOMIC_FETCH_AND_8] = "__atomic_fetch_and_8";
|
||||
Names[RTLIB::ATOMIC_FETCH_AND_16] = "__atomic_fetch_and_16";
|
||||
Names[RTLIB::ATOMIC_FETCH_OR_1] = "__atomic_fetch_or_1";
|
||||
Names[RTLIB::ATOMIC_FETCH_OR_2] = "__atomic_fetch_or_2";
|
||||
Names[RTLIB::ATOMIC_FETCH_OR_4] = "__atomic_fetch_or_4";
|
||||
Names[RTLIB::ATOMIC_FETCH_OR_8] = "__atomic_fetch_or_8";
|
||||
Names[RTLIB::ATOMIC_FETCH_OR_16] = "__atomic_fetch_or_16";
|
||||
Names[RTLIB::ATOMIC_FETCH_XOR_1] = "__atomic_fetch_xor_1";
|
||||
Names[RTLIB::ATOMIC_FETCH_XOR_2] = "__atomic_fetch_xor_2";
|
||||
Names[RTLIB::ATOMIC_FETCH_XOR_4] = "__atomic_fetch_xor_4";
|
||||
Names[RTLIB::ATOMIC_FETCH_XOR_8] = "__atomic_fetch_xor_8";
|
||||
Names[RTLIB::ATOMIC_FETCH_XOR_16] = "__atomic_fetch_xor_16";
|
||||
Names[RTLIB::ATOMIC_FETCH_NAND_1] = "__atomic_fetch_nand_1";
|
||||
Names[RTLIB::ATOMIC_FETCH_NAND_2] = "__atomic_fetch_nand_2";
|
||||
Names[RTLIB::ATOMIC_FETCH_NAND_4] = "__atomic_fetch_nand_4";
|
||||
Names[RTLIB::ATOMIC_FETCH_NAND_8] = "__atomic_fetch_nand_8";
|
||||
Names[RTLIB::ATOMIC_FETCH_NAND_16] = "__atomic_fetch_nand_16";
|
||||
|
||||
if (TT.isGNUEnvironment()) {
|
||||
Names[RTLIB::SINCOS_F32] = "sincosf";
|
||||
|
|
@ -533,11 +105,9 @@ static void InitLibcallNames(const char **Names, const Triple &TT) {
|
|||
Names[RTLIB::SINCOS_PPCF128] = "sincosl";
|
||||
}
|
||||
|
||||
if (!TT.isOSOpenBSD()) {
|
||||
Names[RTLIB::STACKPROTECTOR_CHECK_FAIL] = "__stack_chk_fail";
|
||||
if (TT.isOSOpenBSD()) {
|
||||
Names[RTLIB::STACKPROTECTOR_CHECK_FAIL] = nullptr;
|
||||
}
|
||||
|
||||
Names[RTLIB::DEOPTIMIZE] = "__llvm_deoptimize";
|
||||
}
|
||||
|
||||
/// Set default libcall CallingConvs.
|
||||
|
|
|
|||
Loading…
Reference in New Issue