diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h
index 912715fbf6b19..d69c23753da7a 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -52,7 +52,6 @@ struct RuntimeLibcallsInfo {
       FloatABI::ABIType FloatABI = FloatABI::Default,
       EABI EABIVersion = EABI::Default) {
     initSoftFloatCmpLibcallPredicates();
-    initDefaultLibCallImpls();
     initLibcalls(TT, ExceptionModel, FloatABI, EABIVersion);
   }
 
@@ -97,6 +96,7 @@ struct RuntimeLibcallsInfo {
   /// Get the comparison predicate that's to be used to test the result of the
   /// comparison libcall against zero. This should only be used with
   /// floating-point compare libcalls.
+  // FIXME: This should be a function of RTLIB::LibcallImpl
   CmpInst::Predicate
   getSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call) const {
     return SoftFloatCompareLibcallPredicates[Call];
@@ -172,13 +172,7 @@ struct RuntimeLibcallsInfo {
   void initDefaultLibCallImpls();
 
   /// Generated by tablegen.
-  void setPPCLibCallNameOverrides();
-
-  /// Generated by tablegen.
-  void setZOSLibCallNameOverrides();
-
-  /// Generated by tablegen.
-  void setWindowsArm64LibCallNameOverrides();
+  void setTargetRuntimeLibcallSets(const Triple &TT);
 
   void initSoftFloatCmpLibcallPredicates();
 
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 1d9f02dcf8ba8..e24b4c928b421 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -891,6 +891,17 @@ def calloc : RuntimeLibcallImpl<CALLOC>;
 } // End let IsDefault = true
 } // End defset DefaultRuntimeLibcallImpls
 
+defvar DefaultLibCalls =
+    !foreach(entry, DefaultRuntimeLibcallImpls, entry.Provides);
+
+defvar DefaultRuntimeLibcallImpls_f128 =
+    !filter(entry, DefaultRuntimeLibcallImpls,
+            !match(!cast<string>(entry.Provides), "_F128"));
+
+defvar DefaultRuntimeLibcallImpls_atomic =
+    !filter(entry, DefaultRuntimeLibcallImpls,
+            !match(!cast<string>(entry.Provides), "ATOMIC"));
+
 //--------------------------------------------------------------------
 // Define implementation other libcalls
 //--------------------------------------------------------------------
@@ -915,58 +926,61 @@ def _Unwind_SjLj_Resume : RuntimeLibcallImpl<UNWIND_RESUME>;
 // F128 libm Runtime Libcalls
 //===----------------------------------------------------------------------===//
 
-def logf128 : RuntimeLibcallImpl<LOG_F128>;
-def log2f128 : RuntimeLibcallImpl<LOG2_F128>;
-def log10f128 : RuntimeLibcallImpl<LOG10_F128>;
-def expf128 : RuntimeLibcallImpl<EXP_F128>;
-def exp2f128 : RuntimeLibcallImpl<EXP2_F128>;
-def exp10f128 : RuntimeLibcallImpl<EXP10_F128>;
-def sinf128 : RuntimeLibcallImpl<SIN_F128>;
-def cosf128 : RuntimeLibcallImpl<COS_F128>;
-def tanf128 : RuntimeLibcallImpl<TAN_F128>;
-def tanhf128 : RuntimeLibcallImpl<TANH_F128>;
-def sincosf128 : RuntimeLibcallImpl<SINCOS_F128>;
-def powf128 : RuntimeLibcallImpl<POW_F128>;
-def fminf128 : RuntimeLibcallImpl<FMIN_F128>;
-def fmaxf128 : RuntimeLibcallImpl<FMAX_F128>;
-def fmodf128 : RuntimeLibcallImpl<REM_F128>;
-def sqrtf128 : RuntimeLibcallImpl<SQRT_F128>;
-def ceilf128 : RuntimeLibcallImpl<CEIL_F128>;
-def floorf128 : RuntimeLibcallImpl<FLOOR_F128>;
-def truncf128 : RuntimeLibcallImpl<TRUNC_F128>;
-def roundf128 : RuntimeLibcallImpl<ROUND_F128>;
-def lroundf128 : RuntimeLibcallImpl<LROUND_F128>;
-def llroundf128 : RuntimeLibcallImpl<LLROUND_F128>;
-def rintf128 : RuntimeLibcallImpl<RINT_F128>;
-def lrintf128 : RuntimeLibcallImpl<LRINT_F128>;
-def llrintf128 : RuntimeLibcallImpl<LLRINT_F128>;
-def nearbyintf128 : RuntimeLibcallImpl<NEARBYINT_F128>;
-def fmaf128 : RuntimeLibcallImpl<FMA_F128>;
-def frexpf128 : RuntimeLibcallImpl<FREXP_F128>;
-
-def cbrtf128 : RuntimeLibcallImpl<CBRT_F128>;
-def fminimumf128 : RuntimeLibcallImpl<FMINIMUM_F128>;
-def fmaximumf128 : RuntimeLibcallImpl<FMAXIMUM_F128>;
-def fminimum_numf128 : RuntimeLibcallImpl<FMINIMUM_NUM_F128>;
-def fmaximum_numf128 : RuntimeLibcallImpl<FMAXIMUM_NUM_F128>;
-def asinf128 : RuntimeLibcallImpl<ASIN_F128>;
-def acosf128 : RuntimeLibcallImpl<ACOS_F128>;
-def atanf128 : RuntimeLibcallImpl<ATAN_F128>;
-def atan2f128 : RuntimeLibcallImpl<ATAN2_F128>;
-def ldexpf128 : RuntimeLibcallImpl<LDEXP_F128>;
-def roundevenf128 : RuntimeLibcallImpl<ROUNDEVEN_F128>;
-def modff128 : RuntimeLibcallImpl<MODF_F128>;
-def sinhf128 : RuntimeLibcallImpl<SINH_F128>;
-def coshf128 : RuntimeLibcallImpl<COSH_F128>;
-def copysignf128 : RuntimeLibcallImpl<COPYSIGN_F128>;
-
-def __logf128_finite : RuntimeLibcallImpl<LOG_FINITE_F128>;
-def __log2f128_finite : RuntimeLibcallImpl<LOG2_FINITE_F128>;
-def __log10f128_finite : RuntimeLibcallImpl<LOG10_FINITE_F128>;
-def __expf128_finite : RuntimeLibcallImpl<EXP_FINITE_F128>;
-def __exp2f128_finite : RuntimeLibcallImpl<EXP2_FINITE_F128>;
-def __exp10f128_finite : RuntimeLibcallImpl<EXP10_FINITE_F128>;
-def __powf128_finite : RuntimeLibcallImpl<POW_FINITE_F128>;
+defset list<RuntimeLibcallImpl> LibmF128Libcalls = {
+  def logf128 : RuntimeLibcallImpl<LOG_F128>;
+  def log2f128 : RuntimeLibcallImpl<LOG2_F128>;
+  def log10f128 : RuntimeLibcallImpl<LOG10_F128>;
+  def expf128 : RuntimeLibcallImpl<EXP_F128>;
+  def exp2f128 : RuntimeLibcallImpl<EXP2_F128>;
+  def exp10f128 : RuntimeLibcallImpl<EXP10_F128>;
+  def sinf128 : RuntimeLibcallImpl<SIN_F128>;
+  def cosf128 : RuntimeLibcallImpl<COS_F128>;
+  def tanf128 : RuntimeLibcallImpl<TAN_F128>;
+  def tanhf128 : RuntimeLibcallImpl<TANH_F128>;
+  def sincosf128 : RuntimeLibcallImpl<SINCOS_F128>;
+  def powf128 : RuntimeLibcallImpl<POW_F128>;
+  def fminf128 : RuntimeLibcallImpl<FMIN_F128>;
+  def fmaxf128 : RuntimeLibcallImpl<FMAX_F128>;
+  def fmodf128 : RuntimeLibcallImpl<REM_F128>;
+  def sqrtf128 : RuntimeLibcallImpl<SQRT_F128>;
+  def ceilf128 : RuntimeLibcallImpl<CEIL_F128>;
+  def floorf128 : RuntimeLibcallImpl<FLOOR_F128>;
+  def truncf128 : RuntimeLibcallImpl<TRUNC_F128>;
+  def roundf128 : RuntimeLibcallImpl<ROUND_F128>;
+  def lroundf128 : RuntimeLibcallImpl<LROUND_F128>;
+  def llroundf128 : RuntimeLibcallImpl<LLROUND_F128>;
+  def rintf128 : RuntimeLibcallImpl<RINT_F128>;
+  def lrintf128 : RuntimeLibcallImpl<LRINT_F128>;
+  def llrintf128 : RuntimeLibcallImpl<LLRINT_F128>;
+  def nearbyintf128 : RuntimeLibcallImpl<NEARBYINT_F128>;
+  def fmaf128 : RuntimeLibcallImpl<FMA_F128>;
+  def frexpf128 : RuntimeLibcallImpl<FREXP_F128>;
+  def cbrtf128 : RuntimeLibcallImpl<CBRT_F128>;
+  def fminimumf128 : RuntimeLibcallImpl<FMINIMUM_F128>;
+  def fmaximumf128 : RuntimeLibcallImpl<FMAXIMUM_F128>;
+  def fminimum_numf128 : RuntimeLibcallImpl<FMINIMUM_NUM_F128>;
+  def fmaximum_numf128 : RuntimeLibcallImpl<FMAXIMUM_NUM_F128>;
+  def asinf128 : RuntimeLibcallImpl<ASIN_F128>;
+  def acosf128 : RuntimeLibcallImpl<ACOS_F128>;
+  def atanf128 : RuntimeLibcallImpl<ATAN_F128>;
+  def atan2f128 : RuntimeLibcallImpl<ATAN2_F128>;
+  def ldexpf128 : RuntimeLibcallImpl<LDEXP_F128>;
+  def roundevenf128 : RuntimeLibcallImpl<ROUNDEVEN_F128>;
+  def modff128 : RuntimeLibcallImpl<MODF_F128>;
+  def sinhf128 : RuntimeLibcallImpl<SINH_F128>;
+  def coshf128 : RuntimeLibcallImpl<COSH_F128>;
+  def copysignf128 : RuntimeLibcallImpl<COPYSIGN_F128>;
+}
+
+defset list<RuntimeLibcallImpl> LibmF128FiniteLibcalls = {
+  def __logf128_finite : RuntimeLibcallImpl<LOG_FINITE_F128>;
+  def __log2f128_finite : RuntimeLibcallImpl<LOG2_FINITE_F128>;
+  def __log10f128_finite : RuntimeLibcallImpl<LOG10_FINITE_F128>;
+  def __expf128_finite : RuntimeLibcallImpl<EXP_FINITE_F128>;
+  def __exp2f128_finite : RuntimeLibcallImpl<EXP2_FINITE_F128>;
+  def __exp10f128_finite : RuntimeLibcallImpl<EXP10_FINITE_F128>;
+  def __powf128_finite : RuntimeLibcallImpl<POW_FINITE_F128>;
+}
 
 //===----------------------------------------------------------------------===//
 // AArch64 Runtime Libcalls
@@ -994,16 +1008,41 @@ defset list<RuntimeLibcallImpl> AArch64LibcallImpls = {
   def __arm_sc_memcpy : RuntimeLibcallImpl<SC_MEMCPY>;
   def __arm_sc_memmove : RuntimeLibcallImpl<SC_MEMMOVE>;
   def __arm_sc_memset : RuntimeLibcallImpl<SC_MEMSET>;
-}
+} // End AArch64LibcallImpls
 
-foreach libcall = AArch64LibcallImpls in {
-  def arm64ec_#libcall : DuplicateLibcallImplWithPrefix<libcall, "#">;
-}
+def isAArch64_ExceptArm64EC
+    : RuntimeLibcallPredicate<"(TT.isAArch64() && !TT.isWindowsArm64EC())">;
+def isWindowsArm64EC : RuntimeLibcallPredicate<"TT.isWindowsArm64EC()">;
+
+def AArch64SystemLibrary : SystemRuntimeLibrary<isAArch64_ExceptArm64EC,
+                                                (add DefaultRuntimeLibcallImpls,
+                                                    AArch64LibcallImpls)>;
 
-foreach libcall = DefaultRuntimeLibcallImpls in {
-  def arm64ec_#libcall : DuplicateLibcallImplWithPrefix<libcall, "#">;
+// Prepend a # to every name
+defset list<RuntimeLibcallImpl> WinArm64ECDefaultRuntimeLibcallImpls = {
+  foreach libcall = DefaultRuntimeLibcallImpls in {
+    def arm64ec_#libcall : DuplicateLibcallImplWithPrefix<libcall, "#">;
+  }
+
+  foreach libcall = AArch64LibcallImpls in {
+    def arm64ec_#libcall : DuplicateLibcallImplWithPrefix<libcall, "#">;
+  }
 }
 
+def WindowsARM64ECSystemLibrary
+    : SystemRuntimeLibrary<isWindowsArm64EC,
+                           (add WinArm64ECDefaultRuntimeLibcallImpls)>;
+
+//===----------------------------------------------------------------------===//
+// AMDGPU Runtime Libcalls
+//===----------------------------------------------------------------------===//
+
+def isAMDGPU : RuntimeLibcallPredicate<"TT.isAMDGPU()">;
+
+// No calls, except for dummy atomic calls to avoid crashes.
+def AMDGPUSystemLibrary
+    : SystemRuntimeLibrary<isAMDGPU, (add DefaultRuntimeLibcallImpls_atomic)>;
+
 //===----------------------------------------------------------------------===//
 // ARM Runtime Libcalls
 //===----------------------------------------------------------------------===//
@@ -1227,6 +1266,30 @@ def __udivmodhi4 : RuntimeLibcallImpl<UDIVREM_I16>; // CallingConv::AVR_BUILTIN
 def avr_sin : RuntimeLibcallImpl<SIN_F32, "sin">;
 def avr_cos : RuntimeLibcallImpl<COS_F32, "cos">;
 
+def isAVR : RuntimeLibcallPredicate<"TT.getArch() == Triple::avr">;
+
+def AVRSystemLibrary
+    : SystemRuntimeLibrary<
+          isAVR,
+          (add(sub DefaultRuntimeLibcallImpls,
+
+               // Division rtlib functions (not supported), use divmod
+               // functions instead
+               __divqi3, __divhi3, __divsi3, __udivqi3, __udivhi3, __udivsi3,
+
+               // Modulus rtlib functions (not supported), use divmod functions
+               // instead
+               __modqi3, __modhi3, __modsi3, __umodqi3, __umodhi3, __umodsi3,
+
+               // Standard f64 names are replaced
+               sin, cos, sinf, cosf),
+
+              __divmodqi4, __divmodhi4, __divmodsi4, __udivmodqi4, __udivmodhi4,
+              __udivmodsi4,
+
+              // Trigonometric rtlib functions
+              avr_sin, avr_cos)>;
+
 //===----------------------------------------------------------------------===//
 // Hexagon Runtime Libcalls
 //===----------------------------------------------------------------------===//
@@ -1447,52 +1510,94 @@ def __mspabi_mpyll : RuntimeLibcallImpl<MUL_I64>;
 // setLibcallCallingConv(MUL_I64, CallingConv::MSP430_BUILTIN);
 
 //===----------------------------------------------------------------------===//
-// PPC Runtime Libcalls
+// NVPTX Runtime Libcalls
 //===----------------------------------------------------------------------===//
 
-class PPCRuntimeLibcallImpl<RuntimeLibcall P, string Name = NAME>
-    : RuntimeLibcallImpl<P, Name>;
+def isNVPTX : RuntimeLibcallPredicate<"TT.isNVPTX()">;
+
+// No calls, except for dummy atomic calls to avoid crashes.
+def NVPTXSystemLibrary
+    : SystemRuntimeLibrary<isNVPTX, (add DefaultRuntimeLibcallImpls_atomic)>;
+
+//===----------------------------------------------------------------------===//
+// PPC Runtime Libcalls
+//===----------------------------------------------------------------------===//
 
 // For IEEE quad-precision libcall names, PPC uses "kf" instead of "tf".
-def __addkf3 : PPCRuntimeLibcallImpl<ADD_F128>;
-def __subkf3 : PPCRuntimeLibcallImpl<SUB_F128>;
-def __mulkf3 : PPCRuntimeLibcallImpl<MUL_F128>;
-def __divkf3 : PPCRuntimeLibcallImpl<DIV_F128>;
-def __powikf2 : PPCRuntimeLibcallImpl<POWI_F128>;
-def __extendsfkf2 : PPCRuntimeLibcallImpl<FPEXT_F32_F128>;
-def __extenddfkf2 : PPCRuntimeLibcallImpl<FPEXT_F64_F128>;
-def __trunckfhf2 : PPCRuntimeLibcallImpl<FPROUND_F128_F16>;
-def __trunckfsf2 : PPCRuntimeLibcallImpl<FPROUND_F128_F32>;
-def __trunckfdf2 : PPCRuntimeLibcallImpl<FPROUND_F128_F64>;
-def __fixkfsi : PPCRuntimeLibcallImpl<FPTOSINT_F128_I32>;
-def __fixkfdi : PPCRuntimeLibcallImpl<FPTOSINT_F128_I64>;
-def __fixkfti : PPCRuntimeLibcallImpl<FPTOSINT_F128_I128>;
-def __fixunskfsi : PPCRuntimeLibcallImpl<FPTOUINT_F128_I32>;
-def __fixunskfdi : PPCRuntimeLibcallImpl<FPTOUINT_F128_I64>;
-def __fixunskfti : PPCRuntimeLibcallImpl<FPTOUINT_F128_I128>;
-def __floatsikf : PPCRuntimeLibcallImpl<SINTTOFP_I32_F128>;
-def __floatdikf : PPCRuntimeLibcallImpl<SINTTOFP_I64_F128>;
-def __floattikf : PPCRuntimeLibcallImpl<SINTTOFP_I128_F128>;
-def __floatunsikf : PPCRuntimeLibcallImpl<UINTTOFP_I32_F128>;
-def __floatundikf : PPCRuntimeLibcallImpl<UINTTOFP_I64_F128>;
-def __floatuntikf : PPCRuntimeLibcallImpl<UINTTOFP_I128_F128>;
-def __eqkf2 : PPCRuntimeLibcallImpl<OEQ_F128>;
-def __nekf2 : PPCRuntimeLibcallImpl<UNE_F128>;
-def __gekf2 : PPCRuntimeLibcallImpl<OGE_F128>;
-def __ltkf2 : PPCRuntimeLibcallImpl<OLT_F128>;
-def __lekf2 : PPCRuntimeLibcallImpl<OLE_F128>;
-def __gtkf2 : PPCRuntimeLibcallImpl<OGT_F128>;
-def __unordkf2 : PPCRuntimeLibcallImpl<UO_F128>;
-
-// PPC64 && Subtarget.isAIXABI()
-def ___memmove64 : RuntimeLibcallImpl<MEMCPY>;
-def ___memset64 : RuntimeLibcallImpl<MEMSET>;
-def ___bzero64 : RuntimeLibcallImpl<BZERO>;
-
-// !PPC64 && Subtarget.isAIXABI()
-def ___memmove : RuntimeLibcallImpl<MEMMOVE>;
-def ___memset : RuntimeLibcallImpl<MEMSET>;
-def ___bzero : RuntimeLibcallImpl<BZERO>;
+defset list<RuntimeLibcallImpl> PPCRuntimeLibcalls = {
+  def __addkf3 : RuntimeLibcallImpl<ADD_F128>;
+  def __subkf3 : RuntimeLibcallImpl<SUB_F128>;
+  def __mulkf3 : RuntimeLibcallImpl<MUL_F128>;
+  def __divkf3 : RuntimeLibcallImpl<DIV_F128>;
+  def __powikf2 : RuntimeLibcallImpl<POWI_F128>;
+  def __extendsfkf2 : RuntimeLibcallImpl<FPEXT_F32_F128>;
+  def __extenddfkf2 : RuntimeLibcallImpl<FPEXT_F64_F128>;
+  def __trunckfhf2 : RuntimeLibcallImpl<FPROUND_F128_F16>;
+  def __trunckfsf2 : RuntimeLibcallImpl<FPROUND_F128_F32>;
+  def __trunckfdf2 : RuntimeLibcallImpl<FPROUND_F128_F64>;
+  def __fixkfsi : RuntimeLibcallImpl<FPTOSINT_F128_I32>;
+  def __fixkfdi : RuntimeLibcallImpl<FPTOSINT_F128_I64>;
+  def __fixkfti : RuntimeLibcallImpl<FPTOSINT_F128_I128>;
+  def __fixunskfsi : RuntimeLibcallImpl<FPTOUINT_F128_I32>;
+  def __fixunskfdi : RuntimeLibcallImpl<FPTOUINT_F128_I64>;
+  def __fixunskfti : RuntimeLibcallImpl<FPTOUINT_F128_I128>;
+  def __floatsikf : RuntimeLibcallImpl<SINTTOFP_I32_F128>;
+  def __floatdikf : RuntimeLibcallImpl<SINTTOFP_I64_F128>;
+  def __floattikf : RuntimeLibcallImpl<SINTTOFP_I128_F128>;
+  def __floatunsikf : RuntimeLibcallImpl<UINTTOFP_I32_F128>;
+  def __floatundikf : RuntimeLibcallImpl<UINTTOFP_I64_F128>;
+  def __floatuntikf : RuntimeLibcallImpl<UINTTOFP_I128_F128>;
+  def __eqkf2 : RuntimeLibcallImpl<OEQ_F128>;
+  def __nekf2 : RuntimeLibcallImpl<UNE_F128>;
+  def __gekf2 : RuntimeLibcallImpl<OGE_F128>;
+  def __ltkf2 : RuntimeLibcallImpl<OLT_F128>;
+  def __lekf2 : RuntimeLibcallImpl<OLE_F128>;
+  def __gtkf2 : RuntimeLibcallImpl<OGT_F128>;
+  def __unordkf2 : RuntimeLibcallImpl<UO_F128>;
+}
+
+defset list<RuntimeLibcallImpl> PPC64AIXCallList = {
+  def ___memmove64 : RuntimeLibcallImpl<MEMCPY>;
+  def ___memset64 : RuntimeLibcallImpl<MEMSET>;
+  def ___bzero64 : RuntimeLibcallImpl<BZERO>;
+}
+
+defset list<RuntimeLibcallImpl> PPC32AIXCallList = {
+  def ___memmove : RuntimeLibcallImpl<MEMMOVE>;
+  def ___memset : RuntimeLibcallImpl<MEMSET>;
+  def ___bzero : RuntimeLibcallImpl<BZERO>;
+}
+
+defvar PPCOverrides = !foreach(entry, PPCRuntimeLibcalls, entry.Provides);
+
+defvar ToPrune = !listremove(DefaultLibCalls, PPCOverrides);
+//  DefaultLibcalls item.Provides
+//);
+
+// defvar PPCOverride = !foldl([], DefaultRuntimeLibcallImpls, acc, item,
+//     !eq(item.Provides,
+//);
+
+def isPPC : RuntimeLibcallPredicate<"TT.isPPC()">;
+def isAIX : RuntimeLibcallPredicate<"TT.isOSAIX()">;
+def isNotAIX : RuntimeLibcallPredicate<"!TT.isOSAIX()">;
+def isPPC32_AIX : RuntimeLibcallPredicate<"(TT.isPPC32() && TT.isOSAIX())">;
+def isPPC64_AIX : RuntimeLibcallPredicate<"(TT.isPPC64() && TT.isOSAIX())">;
+
+def AIX32Calls : LibcallImpls<(add PPC32AIXCallList), isPPC32_AIX>;
+def AIX64Calls : LibcallImpls<(add PPC64AIXCallList), isPPC64_AIX>;
+
+// FIXME: Current emission behavior with multiple implementations is
+// janky. We need to filter out the conflicting cases with different
+// f128 names, and then add the overrides. We should switch to
+// explicitly adding subsets of the default calls.
+def PPCSystemLibrary
+    : SystemRuntimeLibrary<isPPC, (add PPCRuntimeLibcalls,
+                                      (sub DefaultRuntimeLibcallImpls, memcpy,
+                                          DefaultRuntimeLibcallImpls_f128),
+                                      __extendkftf2, __trunctfkf2,
+                                      LibmF128Libcalls, AIX32Calls, AIX64Calls,
+                                      AvailableIf<memcpy, isNotAIX>)>;
 
 //===----------------------------------------------------------------------===//
 // SPARC Runtime Libcalls
@@ -1562,94 +1667,105 @@ def _allmul : RuntimeLibcallImpl<MUL_I64>; // CallingConv::X86_StdCall
 
 def __memcpy_4 : RuntimeLibcallImpl<MEMCPY_ALIGN_4>;
 
+def isXCore : RuntimeLibcallPredicate<"TT.getArch() == Triple::xcore">;
+def XCoreSystemLibrary
+    : SystemRuntimeLibrary<isXCore, (add DefaultRuntimeLibcallImpls,
+                                        __memcpy_4)>;
+
 //===----------------------------------------------------------------------===//
 // ZOS Runtime Libcalls
 //===----------------------------------------------------------------------===//
 
-class ZOSRuntimeLibcallImpl<RuntimeLibcall P, string Name = NAME>
-    : RuntimeLibcallImpl<P, Name>;
-
-def zos___TRNC_B : ZOSRuntimeLibcallImpl<TRUNC_F64, "@@TRNC@B">;
-def zos___FTRC_B : ZOSRuntimeLibcallImpl<TRUNC_F32, "@@FTRC@B">;
-def zos___LTRC_B : ZOSRuntimeLibcallImpl<TRUNC_F128, "@@LTRC@B">;
-def zos___WSQT_B : ZOSRuntimeLibcallImpl<SQRT_F64, "@@WSQT@B">;
-def zos___FSQT_B : ZOSRuntimeLibcallImpl<SQRT_F32, "@@FSQT@B">;
-def zos___LSQT_B : ZOSRuntimeLibcallImpl<SQRT_F128, "@@LSQT@B">;
-def zos___SSIN_B : ZOSRuntimeLibcallImpl<SIN_F64, "@@SSIN@B">;
-def zos___FSIN_B : ZOSRuntimeLibcallImpl<SIN_F32, "@@FSIN@B">;
-def zos___LSIN_B : ZOSRuntimeLibcallImpl<SIN_F128, "@@LSIN@B">;
-def zos___ROUN_B : ZOSRuntimeLibcallImpl<ROUND_F64, "@@ROUN@B">;
-def zos___ROUNFB : ZOSRuntimeLibcallImpl<ROUND_F32, "@@ROUNFB">;
-def zos___ROUNLB : ZOSRuntimeLibcallImpl<ROUND_F128, "@@ROUNLB">;
-def zos___SRNT_B : ZOSRuntimeLibcallImpl<RINT_F64, "@@SRNT@B">;
-def zos___RINTFB : ZOSRuntimeLibcallImpl<RINT_F32, "@@RINTFB">;
-def zos___RINTLB : ZOSRuntimeLibcallImpl<RINT_F128, "@@RINTLB">;
-def zos___WFMD_B : ZOSRuntimeLibcallImpl<REM_F64, "@@WFMD@B">;
-def zos___FFMD_B : ZOSRuntimeLibcallImpl<REM_F32, "@@FFMD@B">;
-def zos___LFMD_B : ZOSRuntimeLibcallImpl<REM_F128, "@@LFMD@B">;
-def zos___WPOW_B : ZOSRuntimeLibcallImpl<POW_F64, "@@WPOW@B">;
-def zos___FPOW_B : ZOSRuntimeLibcallImpl<POW_F32, "@@FPOW@B">;
-def zos___LPOW_B : ZOSRuntimeLibcallImpl<POW_F128, "@@LPOW@B">;
-def zos___NBYI_B : ZOSRuntimeLibcallImpl<NEARBYINT_F64, "@@NBYI@B">;
-def zos___NBYIFB : ZOSRuntimeLibcallImpl<NEARBYINT_F32, "@@NBYIFB">;
-def zos___NBYILB : ZOSRuntimeLibcallImpl<NEARBYINT_F128, "@@NBYILB">;
-def zos___ROND_B : ZOSRuntimeLibcallImpl<LROUND_F64, "@@ROND@B">;
-def zos___FRND_B : ZOSRuntimeLibcallImpl<LROUND_F32, "@@FRND@B">;
-def zos___LRND_B : ZOSRuntimeLibcallImpl<LROUND_F128, "@@LRND@B">;
-def zos___LRNT_B : ZOSRuntimeLibcallImpl<LRINT_F64, "@@LRNT@B">;
-def zos___LRNTFB : ZOSRuntimeLibcallImpl<LRINT_F32, "@@LRNTFB">;
-def zos___LRNTLB : ZOSRuntimeLibcallImpl<LRINT_F128, "@@LRNTLB">;
-def zos___WLOG_B : ZOSRuntimeLibcallImpl<LOG_F64, "@@WLOG@B">;
-def zos___FLOG_B : ZOSRuntimeLibcallImpl<LOG_F32, "@@FLOG@B">;
-def zos___LLOG_B : ZOSRuntimeLibcallImpl<LOG_F128, "@@LLOG@B">;
-def zos___LOG2_B : ZOSRuntimeLibcallImpl<LOG2_F64, "@@LOG2@B">;
-def zos___FLG2_B : ZOSRuntimeLibcallImpl<LOG2_F32, "@@FLG2@B">;
-def zos___LLG2_B : ZOSRuntimeLibcallImpl<LOG2_F128, "@@LLG2@B">;
-def zos___WLG1_B : ZOSRuntimeLibcallImpl<LOG10_F64, "@@WLG1@B">;
-def zos___FLG1_B : ZOSRuntimeLibcallImpl<LOG10_F32, "@@FLG1@B">;
-def zos___LLG1_B : ZOSRuntimeLibcallImpl<LOG10_F128, "@@LLG1@B">;
-def zos___LLRD_B : ZOSRuntimeLibcallImpl<LLROUND_F64, "@@LLRD@B">;
-def zos___LLRDFB : ZOSRuntimeLibcallImpl<LLROUND_F32, "@@LLRDFB">;
-def zos___LLRDLB : ZOSRuntimeLibcallImpl<LLROUND_F128, "@@LLRDLB">;
-def zos___LLRT_B : ZOSRuntimeLibcallImpl<LLRINT_F64, "@@LLRT@B">;
-def zos___LLRTFB : ZOSRuntimeLibcallImpl<LLRINT_F32, "@@LLRTFB">;
-def zos___LLRTLB : ZOSRuntimeLibcallImpl<LLRINT_F128, "@@LLRTLB">;
-def zos___SLXP_B : ZOSRuntimeLibcallImpl<LDEXP_F64, "@@SLXP@B">;
-def zos___FLXP_B : ZOSRuntimeLibcallImpl<LDEXP_F32, "@@FLXP@B">;
-def zos___LLXP_B : ZOSRuntimeLibcallImpl<LDEXP_F128, "@@LLXP@B">;
-def zos___SFXP_B : ZOSRuntimeLibcallImpl<FREXP_F64, "@@SFXP@B">;
-def zos___FFXP_B : ZOSRuntimeLibcallImpl<FREXP_F32, "@@FFXP@B">;
-def zos___LFXP_B : ZOSRuntimeLibcallImpl<FREXP_F128, "@@LFXP@B">;
-def zos___FMIN_B : ZOSRuntimeLibcallImpl<FMIN_F64, "@@FMIN@B">;
-def zos___FMINFB : ZOSRuntimeLibcallImpl<FMIN_F32, "@@FMINFB">;
-def zos___FMINLB : ZOSRuntimeLibcallImpl<FMIN_F128, "@@FMINLB">;
-def zos___FMA_B : ZOSRuntimeLibcallImpl<FMA_F64, "@@FMA@B">;
-def zos___FMAFB : ZOSRuntimeLibcallImpl<FMA_F32, "@@FMAFB">;
-def zos___FMALB : ZOSRuntimeLibcallImpl<FMA_F128, "@@FMALB">;
-def zos___FMAX_B : ZOSRuntimeLibcallImpl<FMAX_F64, "@@FMAX@B">;
-def zos___FMAXFB : ZOSRuntimeLibcallImpl<FMAX_F32, "@@FMAXFB">;
-def zos___FMAXLB : ZOSRuntimeLibcallImpl<FMAX_F128, "@@FMAXLB">;
-def zos___SFLR_B : ZOSRuntimeLibcallImpl<FLOOR_F64, "@@SFLR@B">;
-def zos___FFLR_B : ZOSRuntimeLibcallImpl<FLOOR_F32, "@@FFLR@B">;
-def zos___LFLR_B : ZOSRuntimeLibcallImpl<FLOOR_F128, "@@LFLR@B">;
-def zos___WEXP_B : ZOSRuntimeLibcallImpl<EXP_F64, "@@WEXP@B">;
-def zos___FEXP_B : ZOSRuntimeLibcallImpl<EXP_F32, "@@FEXP@B">;
-def zos___LEXP_B : ZOSRuntimeLibcallImpl<EXP_F128, "@@LEXP@B">;
-def zos___EXP2_B : ZOSRuntimeLibcallImpl<EXP2_F64, "@@EXP2@B">;
-def zos___FXP2_B : ZOSRuntimeLibcallImpl<EXP2_F32, "@@FXP2@B">;
-def zos___LXP2_B : ZOSRuntimeLibcallImpl<EXP2_F128, "@@LXP2@B">;
-def zos___SCOS_B : ZOSRuntimeLibcallImpl<COS_F64, "@@SCOS@B">;
-def zos___FCOS_B : ZOSRuntimeLibcallImpl<COS_F32, "@@FCOS@B">;
-def zos___LCOS_B : ZOSRuntimeLibcallImpl<COS_F128, "@@LCOS@B">;
-def zos___DCPY_B : ZOSRuntimeLibcallImpl<COPYSIGN_F64, "@@DCPY@B">;
-def zos___FCPY_B : ZOSRuntimeLibcallImpl<COPYSIGN_F32, "@@FCPY@B">;
-def zos___LCPY_B : ZOSRuntimeLibcallImpl<COPYSIGN_F128, "@@LCPY@B">;
-def zos___SCEL_B : ZOSRuntimeLibcallImpl<CEIL_F64, "@@SCEL@B">;
-def zos___FCEL_B : ZOSRuntimeLibcallImpl<CEIL_F32, "@@FCEL@B">;
-def zos___LCEL_B : ZOSRuntimeLibcallImpl<CEIL_F128, "@@LCEL@B">;
-def zos___SCRT_B : ZOSRuntimeLibcallImpl<CBRT_F64, "@@SCRT@B">;
-def zos___FCBT_B : ZOSRuntimeLibcallImpl<CBRT_F32, "@@FCBT@B">;
-def zos___LCBT_B : ZOSRuntimeLibcallImpl<CBRT_F128, "@@LCBT@B">;
+defset list<RuntimeLibcallImpl> ZOSRuntimeLibcalls = {
+  def zos___TRNC_B : RuntimeLibcallImpl<TRUNC_F64, "@@TRNC@B">;
+  def zos___FTRC_B : RuntimeLibcallImpl<TRUNC_F32, "@@FTRC@B">;
+  def zos___LTRC_B : RuntimeLibcallImpl<TRUNC_F128, "@@LTRC@B">;
+  def zos___WSQT_B : RuntimeLibcallImpl<SQRT_F64, "@@WSQT@B">;
+  def zos___FSQT_B : RuntimeLibcallImpl<SQRT_F32, "@@FSQT@B">;
+  def zos___LSQT_B : RuntimeLibcallImpl<SQRT_F128, "@@LSQT@B">;
+  def zos___SSIN_B : RuntimeLibcallImpl<SIN_F64, "@@SSIN@B">;
+  def zos___FSIN_B : RuntimeLibcallImpl<SIN_F32, "@@FSIN@B">;
+  def zos___LSIN_B : RuntimeLibcallImpl<SIN_F128, "@@LSIN@B">;
+  def zos___ROUN_B : RuntimeLibcallImpl<ROUND_F64, "@@ROUN@B">;
+  def zos___ROUNFB : RuntimeLibcallImpl<ROUND_F32, "@@ROUNFB">;
+  def zos___ROUNLB : RuntimeLibcallImpl<ROUND_F128, "@@ROUNLB">;
+  def zos___SRNT_B : RuntimeLibcallImpl<RINT_F64, "@@SRNT@B">;
+  def zos___RINTFB : RuntimeLibcallImpl<RINT_F32, "@@RINTFB">;
+  def zos___RINTLB : RuntimeLibcallImpl<RINT_F128, "@@RINTLB">;
+  def zos___WFMD_B : RuntimeLibcallImpl<REM_F64, "@@WFMD@B">;
+  def zos___FFMD_B : RuntimeLibcallImpl<REM_F32, "@@FFMD@B">;
+  def zos___LFMD_B : RuntimeLibcallImpl<REM_F128, "@@LFMD@B">;
+  def zos___WPOW_B : RuntimeLibcallImpl<POW_F64, "@@WPOW@B">;
+  def zos___FPOW_B : RuntimeLibcallImpl<POW_F32, "@@FPOW@B">;
+  def zos___LPOW_B : RuntimeLibcallImpl<POW_F128, "@@LPOW@B">;
+  def zos___NBYI_B : RuntimeLibcallImpl<NEARBYINT_F64, "@@NBYI@B">;
+  def zos___NBYIFB : RuntimeLibcallImpl<NEARBYINT_F32, "@@NBYIFB">;
+  def zos___NBYILB : RuntimeLibcallImpl<NEARBYINT_F128, "@@NBYILB">;
+  def zos___ROND_B : RuntimeLibcallImpl<LROUND_F64, "@@ROND@B">;
+  def zos___FRND_B : RuntimeLibcallImpl<LROUND_F32, "@@FRND@B">;
+  def zos___LRND_B : RuntimeLibcallImpl<LROUND_F128, "@@LRND@B">;
+  def zos___LRNT_B : RuntimeLibcallImpl<LRINT_F64, "@@LRNT@B">;
+  def zos___LRNTFB : RuntimeLibcallImpl<LRINT_F32, "@@LRNTFB">;
+  def zos___LRNTLB : RuntimeLibcallImpl<LRINT_F128, "@@LRNTLB">;
+  def zos___WLOG_B : RuntimeLibcallImpl<LOG_F64, "@@WLOG@B">;
+  def zos___FLOG_B : RuntimeLibcallImpl<LOG_F32, "@@FLOG@B">;
+  def zos___LLOG_B : RuntimeLibcallImpl<LOG_F128, "@@LLOG@B">;
+  def zos___LOG2_B : RuntimeLibcallImpl<LOG2_F64, "@@LOG2@B">;
+  def zos___FLG2_B : RuntimeLibcallImpl<LOG2_F32, "@@FLG2@B">;
+  def zos___LLG2_B : RuntimeLibcallImpl<LOG2_F128, "@@LLG2@B">;
+  def zos___WLG1_B : RuntimeLibcallImpl<LOG10_F64, "@@WLG1@B">;
+  def zos___FLG1_B : RuntimeLibcallImpl<LOG10_F32, "@@FLG1@B">;
+  def zos___LLG1_B : RuntimeLibcallImpl<LOG10_F128, "@@LLG1@B">;
+  def zos___LLRD_B : RuntimeLibcallImpl<LLROUND_F64, "@@LLRD@B">;
+  def zos___LLRDFB : RuntimeLibcallImpl<LLROUND_F32, "@@LLRDFB">;
+  def zos___LLRDLB : RuntimeLibcallImpl<LLROUND_F128, "@@LLRDLB">;
+  def zos___LLRT_B : RuntimeLibcallImpl<LLRINT_F64, "@@LLRT@B">;
+  def zos___LLRTFB : RuntimeLibcallImpl<LLRINT_F32, "@@LLRTFB">;
+  def zos___LLRTLB : RuntimeLibcallImpl<LLRINT_F128, "@@LLRTLB">;
+  def zos___SLXP_B : RuntimeLibcallImpl<LDEXP_F64, "@@SLXP@B">;
+  def zos___FLXP_B : RuntimeLibcallImpl<LDEXP_F32, "@@FLXP@B">;
+  def zos___LLXP_B : RuntimeLibcallImpl<LDEXP_F128, "@@LLXP@B">;
+  def zos___SFXP_B : RuntimeLibcallImpl<FREXP_F64, "@@SFXP@B">;
+  def zos___FFXP_B : RuntimeLibcallImpl<FREXP_F32, "@@FFXP@B">;
+  def zos___LFXP_B : RuntimeLibcallImpl<FREXP_F128, "@@LFXP@B">;
+  def zos___FMIN_B : RuntimeLibcallImpl<FMIN_F64, "@@FMIN@B">;
+  def zos___FMINFB : RuntimeLibcallImpl<FMIN_F32, "@@FMINFB">;
+  def zos___FMINLB : RuntimeLibcallImpl<FMIN_F128, "@@FMINLB">;
+  def zos___FMA_B : RuntimeLibcallImpl<FMA_F64, "@@FMA@B">;
+  def zos___FMAFB : RuntimeLibcallImpl<FMA_F32, "@@FMAFB">;
+  def zos___FMALB : RuntimeLibcallImpl<FMA_F128, "@@FMALB">;
+  def zos___FMAX_B : RuntimeLibcallImpl<FMAX_F64, "@@FMAX@B">;
+  def zos___FMAXFB : RuntimeLibcallImpl<FMAX_F32, "@@FMAXFB">;
+  def zos___FMAXLB : RuntimeLibcallImpl<FMAX_F128, "@@FMAXLB">;
+  def zos___SFLR_B : RuntimeLibcallImpl<FLOOR_F64, "@@SFLR@B">;
+  def zos___FFLR_B : RuntimeLibcallImpl<FLOOR_F32, "@@FFLR@B">;
+  def zos___LFLR_B : RuntimeLibcallImpl<FLOOR_F128, "@@LFLR@B">;
+  def zos___WEXP_B : RuntimeLibcallImpl<EXP_F64, "@@WEXP@B">;
+  def zos___FEXP_B : RuntimeLibcallImpl<EXP_F32, "@@FEXP@B">;
+  def zos___LEXP_B : RuntimeLibcallImpl<EXP_F128, "@@LEXP@B">;
+  def zos___EXP2_B : RuntimeLibcallImpl<EXP2_F64, "@@EXP2@B">;
+  def zos___FXP2_B : RuntimeLibcallImpl<EXP2_F32, "@@FXP2@B">;
+  def zos___LXP2_B : RuntimeLibcallImpl<EXP2_F128, "@@LXP2@B">;
+  def zos___SCOS_B : RuntimeLibcallImpl<COS_F64, "@@SCOS@B">;
+  def zos___FCOS_B : RuntimeLibcallImpl<COS_F32, "@@FCOS@B">;
+  def zos___LCOS_B : RuntimeLibcallImpl<COS_F128, "@@LCOS@B">;
+  def zos___DCPY_B : RuntimeLibcallImpl<COPYSIGN_F64, "@@DCPY@B">;
+  def zos___FCPY_B : RuntimeLibcallImpl<COPYSIGN_F32, "@@FCPY@B">;
+  def zos___LCPY_B : RuntimeLibcallImpl<COPYSIGN_F128, "@@LCPY@B">;
+  def zos___SCEL_B : RuntimeLibcallImpl<CEIL_F64, "@@SCEL@B">;
+  def zos___FCEL_B : RuntimeLibcallImpl<CEIL_F32, "@@FCEL@B">;
+  def zos___LCEL_B : RuntimeLibcallImpl<CEIL_F128, "@@LCEL@B">;
+  def zos___SCRT_B : RuntimeLibcallImpl<CBRT_F64, "@@SCRT@B">;
+  def zos___FCBT_B : RuntimeLibcallImpl<CBRT_F32, "@@FCBT@B">;
+  def zos___LCBT_B : RuntimeLibcallImpl<CBRT_F128, "@@LCBT@B">;
+}
+
+def isSystemZZOS : RuntimeLibcallPredicate<"(TT.isSystemZ() && TT.isOSzOS())">;
+def isZOS : RuntimeLibcallPredicate<"TT.isOSzOS()">;
+def SystemZZOSSystemLibrary
+    : SystemRuntimeLibrary<
+          isSystemZZOS, (add DefaultRuntimeLibcallImpls,
+                            LibcallImpls<(add ZOSRuntimeLibcalls), isZOS>)>;
 
 //===----------------------------------------------------------------------===//
 // WebAssembly Runtime Libcalls
@@ -1659,3 +1775,12 @@ def zos___LCBT_B : ZOSRuntimeLibcallImpl<CBRT_F128, "@@LCBT@B">;
 // TODO: when implementing other Wasm backends, make this generic or only do
 // this on emscripten depending on what they end up doing.
 def emscripten_return_address : RuntimeLibcallImpl<RETURN_ADDRESS>;
+
+def isWasm : RuntimeLibcallPredicate<"TT.isWasm()">;
+
+// Define the emscripten name for return address helper.
+// TODO: when implementing other Wasm backends, make this generic or only do
+// this on emscripten depending on what they end up doing.
+def WasmSystemLibrary
+    : SystemRuntimeLibrary<isWasm,
+      (add DefaultRuntimeLibcallImpls, emscripten_return_address)>;
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 9444a0a838cdd..d64e0d0adfa75 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -6,6 +6,23 @@
 //
 //===----------------------------------------------------------------------===//
 
+include "llvm/TableGen/SetTheory.td"
+
+// Predicate for whether a libcall exists for the target ABI. This is
+// a module level property that should only be computed based on the
+// triple.
+class RuntimeLibcallPredicate<code cond> {
+  // Expression of an llvm::Triple named TT for whether a libcall
+  // should exist.
+  code Cond = cond;
+}
+
+// Predicate for whether a libcall should be used for the current
+// function/subtarget.
+class LibcallLoweringPredicate<code cond> { code Cond = cond; }
+
+def AlwaysAvailable : RuntimeLibcallPredicate<[{}]>;
+
 /// 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
@@ -28,5 +45,24 @@ class RuntimeLibcall {
 class RuntimeLibcallImpl<RuntimeLibcall P, string Name = NAME> {
   RuntimeLibcall Provides = P;
   string LibCallFuncName = Name;
+  list<LibcallLoweringPredicate> LoweringPredicates;
   bit IsDefault = false;
 }
+
+class LibcallImpls<dag funcList,
+                   RuntimeLibcallPredicate Pred = AlwaysAvailable> {
+  // Function of the triple where this applies
+  RuntimeLibcallPredicate AvailabilityPredicate = Pred;
+  dag MemberList = funcList;
+}
+
+/// Convenience wrapper around LibcallImplSet to make a single libcall
+/// implementation conditionally conditionally available.
+class AvailableIf<RuntimeLibcallImpl Impl, RuntimeLibcallPredicate Pred>
+    : LibcallImpls<(add Impl), Pred>;
+
+/// Define a complete top level set of runtime libcalls for a target.
+class SystemRuntimeLibrary<RuntimeLibcallPredicate Pred, dag funcList> {
+  RuntimeLibcallPredicate TriplePred = Pred;
+  LibcallImpls MemberList = LibcallImpls<funcList>;
+}
diff --git a/llvm/include/llvm/TableGen/SetTheory.td b/llvm/include/llvm/TableGen/SetTheory.td
new file mode 100644
index 0000000000000..38b89671ee541
--- /dev/null
+++ b/llvm/include/llvm/TableGen/SetTheory.td
@@ -0,0 +1,27 @@
+//===- SetTheory.td - DAG set operator declarations --------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// FIXME: This is not used everywhere, and different files declare
+// different subsets of used operators.
+//
+// It just happens TargetSelectionDAG.td defines records with the same
+// names as the tablegen DAG operators for SelectionDAG operators.
+
+// Target.td separately declares the special set operators.
+
+def add; // Forward declare
+def sub;
+def and;
+def shl;
+// def trunc; // FIXME: Name collision
+def rotl;
+def rotr;
+
+def sequence;
+def decimate;
+def interleave;
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 67f872b4574b1..eaa2cf5100c77 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -12,51 +12,16 @@
 using namespace llvm;
 using namespace RTLIB;
 
-#define GET_INIT_RUNTIME_LIBCALL_UTILS
 #define GET_INIT_RUNTIME_LIBCALL_NAMES
+#define GET_SET_TARGET_RUNTIME_LIBCALL_SETS
 #include "llvm/IR/RuntimeLibcalls.inc"
-#undef GET_INIT_RUNTIME_LIBCALL_UTILS
 #undef GET_INIT_RUNTIME_LIBCALL_NAMES
+#undef GET_SET_TARGET_RUNTIME_LIBCALL_SETS
 
 static cl::opt<bool>
     HexagonEnableFastMathRuntimeCalls("hexagon-fast-math", cl::Hidden,
                                       cl::desc("Enable Fast Math processing"));
 
-static void setAArch64LibcallNames(RuntimeLibcallsInfo &Info,
-                                   const Triple &TT) {
-#define LCALLNAMES(A, B, N)                                                    \
-  Info.setLibcallImpl(A##N##_RELAX, B##N##_relax);                             \
-  Info.setLibcallImpl(A##N##_ACQ, B##N##_acq);                                 \
-  Info.setLibcallImpl(A##N##_REL, B##N##_rel);                                 \
-  Info.setLibcallImpl(A##N##_ACQ_REL, B##N##_acq_rel);
-#define LCALLNAME4(A, B)                                                       \
-  LCALLNAMES(A, B, 1)                                                          \
-  LCALLNAMES(A, B, 2) LCALLNAMES(A, B, 4) LCALLNAMES(A, B, 8)
-#define LCALLNAME5(A, B)                                                       \
-  LCALLNAMES(A, B, 1)                                                          \
-  LCALLNAMES(A, B, 2)                                                          \
-  LCALLNAMES(A, B, 4) LCALLNAMES(A, B, 8) LCALLNAMES(A, B, 16)
-
-  if (TT.isWindowsArm64EC()) {
-    LCALLNAME5(RTLIB::OUTLINE_ATOMIC_CAS, RTLIB::arm64ec___aarch64_cas)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_SWP, RTLIB::arm64ec___aarch64_swp)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDADD, RTLIB::arm64ec___aarch64_ldadd)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDSET, RTLIB::arm64ec___aarch64_ldset)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDCLR, RTLIB::arm64ec___aarch64_ldclr)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDEOR, RTLIB::arm64ec___aarch64_ldeor)
-  } else {
-    LCALLNAME5(RTLIB::OUTLINE_ATOMIC_CAS, RTLIB::__aarch64_cas)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_SWP, RTLIB::__aarch64_swp)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDADD, RTLIB::__aarch64_ldadd)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDSET, RTLIB::__aarch64_ldset)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDCLR, RTLIB::__aarch64_ldclr)
-    LCALLNAME4(RTLIB::OUTLINE_ATOMIC_LDEOR, RTLIB::__aarch64_ldeor)
-  }
-#undef LCALLNAMES
-#undef LCALLNAME4
-#undef LCALLNAME5
-}
-
 static void setARMLibcallNames(RuntimeLibcallsInfo &Info, const Triple &TT,
                                FloatABI::ABIType FloatABIType,
                                EABI EABIVersion) {
@@ -358,6 +323,8 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
                                        ExceptionHandling ExceptionModel,
                                        FloatABI::ABIType FloatABI,
                                        EABI EABIVersion) {
+  setTargetRuntimeLibcallSets(TT);
+
   // Use the f128 variants of math functions on x86
   if (TT.isX86() && TT.isGNUEnvironment())
     setLongDoubleIsF128Libm(*this, /*FiniteOnlyFuncs=*/true);
@@ -367,28 +334,6 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
       setLibcallImpl(RTLIB::UNWIND_RESUME, RTLIB::_Unwind_SjLj_Resume);
   }
 
-  if (TT.isPPC()) {
-    setPPCLibCallNameOverrides();
-
-    // TODO: Do the finite only functions exist?
-    setLongDoubleIsF128Libm(*this, /*FiniteOnlyFuncs=*/false);
-
-    // TODO: Tablegen predicate support
-    if (TT.isOSAIX()) {
-      if (TT.isPPC64()) {
-        setLibcallImpl(RTLIB::MEMCPY, RTLIB::Unsupported);
-        setLibcallImpl(RTLIB::MEMMOVE, RTLIB::___memmove64);
-        setLibcallImpl(RTLIB::MEMSET, RTLIB::___memset64);
-        setLibcallImpl(RTLIB::BZERO, RTLIB::___bzero64);
-      } else {
-        setLibcallImpl(RTLIB::MEMCPY, RTLIB::Unsupported);
-        setLibcallImpl(RTLIB::MEMMOVE, RTLIB::___memmove);
-        setLibcallImpl(RTLIB::MEMSET, RTLIB::___memset);
-        setLibcallImpl(RTLIB::BZERO, RTLIB::___bzero);
-      }
-    }
-  }
-
   // A few names are different on particular architectures or environments.
   if (TT.isOSDarwin()) {
     // For f16/f32 conversions, Darwin uses the standard naming scheme,
@@ -485,14 +430,6 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
     setLibcallImpl(RTLIB::FREXP_PPCF128, RTLIB::Unsupported);
   }
 
-  // Disable most libcalls on AMDGPU and NVPTX.
-  if (TT.isAMDGPU() || TT.isNVPTX()) {
-    for (RTLIB::Libcall LC : RTLIB::libcalls()) {
-      if (!isAtomicLibCall(LC))
-        setLibcallImpl(LC, RTLIB::Unsupported);
-    }
-  }
-
   if (TT.isOSMSVCRT()) {
     // MSVCRT doesn't have powi; fall back to pow
     setLibcallImpl(RTLIB::POWI_F32, RTLIB::Unsupported);
@@ -520,55 +457,14 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
     }
   }
 
-  if (TT.isAArch64()) {
-    if (TT.isWindowsArm64EC()) {
-      setWindowsArm64LibCallNameOverrides();
-      setLibcallImpl(RTLIB::SC_MEMCPY, RTLIB::arm64ec___arm_sc_memcpy);
-      setLibcallImpl(RTLIB::SC_MEMMOVE, RTLIB::arm64ec___arm_sc_memmove);
-      setLibcallImpl(RTLIB::SC_MEMSET, RTLIB::arm64ec___arm_sc_memset);
-    } else {
-      setLibcallImpl(RTLIB::SC_MEMCPY, RTLIB::__arm_sc_memcpy);
-      setLibcallImpl(RTLIB::SC_MEMMOVE, RTLIB::__arm_sc_memmove);
-      setLibcallImpl(RTLIB::SC_MEMSET, RTLIB::__arm_sc_memset);
-    }
-
-    setAArch64LibcallNames(*this, TT);
-  } else if (TT.isARM() || TT.isThumb()) {
+  if (TT.isARM() || TT.isThumb())
     setARMLibcallNames(*this, TT, FloatABI, EABIVersion);
-  } else if (TT.getArch() == Triple::ArchType::avr) {
-    // Division rtlib functions (not supported), use divmod functions instead
-    setLibcallImpl(RTLIB::SDIV_I8, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::SDIV_I16, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::SDIV_I32, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::UDIV_I8, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::UDIV_I16, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::UDIV_I32, RTLIB::Unsupported);
-
-    // Modulus rtlib functions (not supported), use divmod functions instead
-    setLibcallImpl(RTLIB::SREM_I8, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::SREM_I16, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::SREM_I32, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::UREM_I8, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::UREM_I16, RTLIB::Unsupported);
-    setLibcallImpl(RTLIB::UREM_I32, RTLIB::Unsupported);
-
-    // Division and modulus rtlib functions
-    setLibcallImpl(RTLIB::SDIVREM_I8, RTLIB::__divmodqi4);
-    setLibcallImpl(RTLIB::SDIVREM_I16, RTLIB::__divmodhi4);
-    setLibcallImpl(RTLIB::SDIVREM_I32, RTLIB::__divmodsi4);
-    setLibcallImpl(RTLIB::UDIVREM_I8, RTLIB::__udivmodqi4);
-    setLibcallImpl(RTLIB::UDIVREM_I16, RTLIB::__udivmodhi4);
-    setLibcallImpl(RTLIB::UDIVREM_I32, RTLIB::__udivmodsi4);
-
+  else if (TT.getArch() == Triple::ArchType::avr) {
     // Several of the runtime library functions use a special calling conv
     setLibcallCallingConv(RTLIB::SDIVREM_I8, CallingConv::AVR_BUILTIN);
     setLibcallCallingConv(RTLIB::SDIVREM_I16, CallingConv::AVR_BUILTIN);
     setLibcallCallingConv(RTLIB::UDIVREM_I8, CallingConv::AVR_BUILTIN);
     setLibcallCallingConv(RTLIB::UDIVREM_I16, CallingConv::AVR_BUILTIN);
-
-    // Trigonometric rtlib functions
-    setLibcallImpl(RTLIB::SIN_F32, RTLIB::avr_sin);
-    setLibcallImpl(RTLIB::COS_F32, RTLIB::avr_cos);
   }
 
   if (!TT.isWasm()) {
@@ -582,11 +478,6 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
     }
 
     setLibcallImpl(RTLIB::MULO_I128, RTLIB::Unsupported);
-  } else {
-    // Define the emscripten name for return address helper.
-    // TODO: when implementing other Wasm backends, make this generic or only do
-    // this on emscripten depending on what they end up doing.
-    setLibcallImpl(RTLIB::RETURN_ADDRESS, RTLIB::emscripten_return_address);
   }
 
   if (TT.getArch() == Triple::ArchType::hexagon) {
@@ -633,10 +524,4 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
 
   if (TT.getArch() == Triple::ArchType::msp430)
     setMSP430Libcalls(*this, TT);
-
-  if (TT.isSystemZ() && TT.isOSzOS())
-    setZOSLibCallNameOverrides();
-
-  if (TT.getArch() == Triple::ArchType::xcore)
-    setLibcallImpl(RTLIB::MEMCPY_ALIGN_4, RTLIB::__memcpy_4);
 }
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td b/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td
new file mode 100644
index 0000000000000..086edc79e3b36
--- /dev/null
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td
@@ -0,0 +1,60 @@
+// RUN: llvm-tblgen -gen-runtime-libcalls -I %p/../../include %s 2> %t.err | FileCheck %s
+// RUN: FileCheck -check-prefix=ERR %s < %t.err
+
+// Check behavior of libcall emission when multiple RuntimeLibcallImpl
+// implementations provide the same RuntimeLibcall
+
+include "llvm/IR/RuntimeLibCallsImpl.td"
+
+def SOME_FUNC : RuntimeLibcall;
+def OTHER_FUNC : RuntimeLibcall;
+def ANOTHER_DUP : RuntimeLibcall;
+
+def isTargetArchA : RuntimeLibcallPredicate<[{isTargetArchA()}]>;
+def isTargetArchB : RuntimeLibcallPredicate<[{isTargetArchB()}]>;
+def isTargetArchC : RuntimeLibcallPredicate<[{isTargetArchC()}]>;
+
+def func_a : RuntimeLibcallImpl<SOME_FUNC>;
+def func_b : RuntimeLibcallImpl<SOME_FUNC>;
+def func_c : RuntimeLibcallImpl<SOME_FUNC>;
+def other_func : RuntimeLibcallImpl<OTHER_FUNC>;
+
+def dup0 : RuntimeLibcallImpl<ANOTHER_DUP>;
+def dup1 : RuntimeLibcallImpl<ANOTHER_DUP>;
+
+// func_a and func_b both provide SOME_FUNC.
+
+// CHECK: if (isTargetArchA()) {
+// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:   {RTLIB::SOME_FUNC, RTLIB::func_b}, // func_b
+// CHECK-NEXT: };
+
+// ERR: :[[@LINE+1]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_b, func_a
+def TheSystemLibraryA : SystemRuntimeLibrary<isTargetArchA,
+  (add func_b, func_a)
+>;
+
+// CHECK: if (isTargetArchB()) {
+// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:   {RTLIB::OTHER_FUNC, RTLIB::other_func}, // other_func
+// CHECK-NEXT:  {RTLIB::SOME_FUNC, RTLIB::func_a}, // func_a
+// CHECK-NEXT: };
+
+// ERR: :[[@LINE+1]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_a, func_b
+def TheSystemLibraryB : SystemRuntimeLibrary<isTargetArchB,
+  (add func_a, other_func, func_b)
+>;
+
+// CHECK: if (isTargetArchC()) {
+// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:   {RTLIB::ANOTHER_DUP, RTLIB::dup1}, // dup1
+// CHECK-NEXT:   {RTLIB::OTHER_FUNC, RTLIB::other_func}, // other_func
+// CHECK-NEXT:   {RTLIB::SOME_FUNC, RTLIB::func_a}, // func_a
+// CHECK-NEXT: };
+
+// ERR: :[[@LINE+3]]:5: warning: conflicting implementations for libcall ANOTHER_DUP: dup1, dup0
+// ERR: :[[@LINE+2]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_a, func_b
+// ERR: :[[@LINE+1]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_a, func_c
+def TheSystemLibraryC : SystemRuntimeLibrary<isTargetArchC,
+  (add func_a, dup1, other_func, func_b, func_c, dup0)
+>;
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter-nested-predicates-error.td b/llvm/test/TableGen/RuntimeLibcallEmitter-nested-predicates-error.td
new file mode 100644
index 0000000000000..a8b33e48613c3
--- /dev/null
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter-nested-predicates-error.td
@@ -0,0 +1,18 @@
+// RUN: not llvm-tblgen -gen-runtime-libcalls -I %p/../../include %s 2>&1 | FileCheck -check-prefix=ERR %s
+
+include "llvm/IR/RuntimeLibCallsImpl.td"
+
+def FUNC0 : RuntimeLibcall;
+def FUNC1 : RuntimeLibcall;
+
+def isFoo : RuntimeLibcallPredicate<[{isFoo()}]>;
+def isBar : RuntimeLibcallPredicate<[{isBar()}]>;
+def isTargetArch : RuntimeLibcallPredicate<[{isTargetArch()}]>;
+
+def func0 : RuntimeLibcallImpl<FUNC0>;
+def func1 : RuntimeLibcallImpl<FUNC1>;
+
+// ERR: :[[@LINE+2]]:8: error: combining nested libcall set predicates currently unhandled
+def TheSystemLibrary : SystemRuntimeLibrary<isTargetArch,
+  (add LibcallImpls<(add func0, LibcallImpls<(add func1), isBar>), isFoo>)
+>;
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter.td b/llvm/test/TableGen/RuntimeLibcallEmitter.td
index d4030dd0a7e95..d810ce3787703 100644
--- a/llvm/test/TableGen/RuntimeLibcallEmitter.td
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter.td
@@ -9,6 +9,9 @@ def SRL_I64 : RuntimeLibcall;
 def SQRT_F128 : RuntimeLibcall;
 def SQRT_F80 : RuntimeLibcall;
 def BZERO : RuntimeLibcall;
+def MEMCPY : RuntimeLibcall;
+def MEMSET : RuntimeLibcall;
+def CALLOC : RuntimeLibcall;
 
 // Test default names.
 let IsDefault = true in {
@@ -22,27 +25,84 @@ let IsDefault = true in {
 // Ignore non-default in initDefaultLibCallNames.
 def bzero : RuntimeLibcallImpl<BZERO>;
 
+def ___memset : RuntimeLibcallImpl<MEMSET, "___memset">;
+def ___memcpy : RuntimeLibcallImpl<MEMCPY, "___memcpy">;
+
+def calloc  : RuntimeLibcallImpl<CALLOC, "calloc">;
+
+def CompilerRTLibcalls : LibcallImpls<(add __ashlsi3, __lshrdi3)>;
+def LibmLibcalls : LibcallImpls<(add sqrtl_f80)>;
+
+//def AllCalls : LibcallImpls<(add CompilerRTLibcalls, LibmLibcalls, __ashlsi3)>;
+
+//def MostCalls : LibcallImpls<(sub AllCalls, __ashlsi3, sqrtl_f128)>;
+
+def isSimpleArch : RuntimeLibcallPredicate<[{TT.getArch() == Triple::simple}]>;
+def isFooArch : RuntimeLibcallPredicate<[{TT.getArch() == Triple::foo}]>;
+
+
+def isZOS : RuntimeLibcallPredicate<[{TT.getOS() == Triple::zos}]>;
+def isPPC : RuntimeLibcallPredicate<[{TT.getArch().isPPC()}]>;
+def isPPC64 : RuntimeLibcallPredicate<[{TT.getArch().isPPC64()}]>;
+
+
+def isFoo : RuntimeLibcallPredicate<[{isFOO()}]>;
+def isBarOS : RuntimeLibcallPredicate<[{TT.getOS() == Triple::bar}]>;
+def isBuzzArch : RuntimeLibcallPredicate<[{TT.getArch() == Triple::buzz}]>;
+def isBlahArch : RuntimeLibcallPredicate<[{TT.getArch() == Triple::blah}]>;
+
+def hasCompilerRT : RuntimeLibcallPredicate<[{TT.hasCompilerRT()}]>;
+
+
+
+def SimpleLibrary : SystemRuntimeLibrary<isSimpleArch,
+  (add LibmLibcalls, calloc, CompilerRTLibcalls)>;
+
+
+def LibraryWithConditionalFunc : LibcallImpls<(add sqrtl_f128, bzero, AvailableIf<___memset, isBarOS>)>;
+
+def FooLibrary : SystemRuntimeLibrary<isFooArch, (add LibraryWithConditionalFunc)>;
+
+def BuzzLibrary : SystemRuntimeLibrary<isBuzzArch, (add sqrtl_f80, CompilerRTLibcalls)>;
+
+
+
+def LibraryWithConditionalSet : LibcallImpls<(add sqrtl_f128, bzero,
+  LibcallImpls<(add CompilerRTLibcalls), hasCompilerRT>)>;
+
+
+
+def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add calloc, LibraryWithConditionalSet, AvailableIf<___memset, isBarOS>)>;
+
+
+
 // 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 : unsigned short {
 // CHECK-NEXT: BZERO = 0,
-// CHECK-NEXT: SHL_I32 = 1,
-// CHECK-NEXT: SQRT_F80 = 2,
-// CHECK-NEXT: SQRT_F128 = 3,
-// CHECK-NEXT: SRL_I64 = 4,
-// CHECK-NEXT: UNKNOWN_LIBCALL = 5
+// CHECK-NEXT: CALLOC = 1,
+// CHECK-NEXT: MEMCPY = 2,
+// CHECK-NEXT: MEMSET = 3,
+// CHECK-NEXT: SHL_I32 = 4,
+// CHECK-NEXT: SQRT_F80 = 5,
+// CHECK-NEXT: SQRT_F128 = 6,
+// CHECK-NEXT: SRL_I64 = 7,
+// CHECK-NEXT: UNKNOWN_LIBCALL = 8
 // CHECK-NEXT: };
 // CHECK-EMPTY:
 // CHECK-NEXT:enum LibcallImpl : unsigned short {
 // CHECK-NEXT:  Unsupported = 0,
-// CHECK-NEXT:  __ashlsi3 = 1, // __ashlsi3
-// CHECK-NEXT:  __lshrdi3 = 2, // __lshrdi3
-// CHECK-NEXT:  bzero = 3, // bzero
-// CHECK-NEXT:  sqrtl_f80 = 4, // sqrtl
-// CHECK-NEXT:  sqrtl_f128 = 5, // sqrtl
-// CHECK-NEXT:  NumLibcallImpls = 6
+// CHECK-NEXT:  ___memcpy = 1, // ___memcpy
+// CHECK-NEXT:  ___memset = 2, // ___memset
+// CHECK-NEXT:  __ashlsi3 = 3, // __ashlsi3
+// CHECK-NEXT:  __lshrdi3 = 4, // __lshrdi3
+// CHECK-NEXT:  bzero = 5, // bzero
+// CHECK-NEXT:  calloc = 6, // calloc
+// CHECK-NEXT:  sqrtl_f80 = 7, // sqrtl
+// CHECK-NEXT:  sqrtl_f128 = 8, // sqrtl
+// CHECK-NEXT:  NumLibcallImpls = 9
 // CHECK-NEXT: };
 // CHECK-NEXT: } // End namespace RTLIB
 // CHECK-NEXT: } // End namespace llvm
@@ -51,6 +111,9 @@ def bzero : RuntimeLibcallImpl<BZERO>;
 // CHECK: #ifdef GET_INIT_RUNTIME_LIBCALL_NAMES
 // CHECK-NEXT: const RTLIB::LibcallImpl llvm::RTLIB::RuntimeLibcallsInfo::DefaultLibcallImpls[RTLIB::UNKNOWN_LIBCALL + 1] = {
 // CHECK-NEXT:   RTLIB::Unsupported, // RTLIB::BZERO
+// CHECK-NEXT:   RTLIB::Unsupported, // RTLIB::CALLOC
+// CHECK-NEXT:   RTLIB::Unsupported, // RTLIB::MEMCPY
+// CHECK-NEXT:   RTLIB::Unsupported, // RTLIB::MEMSET
 // CHECK-NEXT:   RTLIB::__ashlsi3, // RTLIB::SHL_I32
 // CHECK-NEXT:   RTLIB::sqrtl_f80, // RTLIB::SQRT_F80
 // CHECK-NEXT:   RTLIB::sqrtl_f128, // RTLIB::SQRT_F128
@@ -60,18 +123,118 @@ def bzero : RuntimeLibcallImpl<BZERO>;
 // CHECK-EMPTY:
 // CHECK-NEXT: const char *const llvm::RTLIB::RuntimeLibcallsInfo::LibCallImplNames[RTLIB::NumLibcallImpls] = {
 // CHECK-NEXT: nullptr, // RTLIB::Unsupported
+// CHECK-NEXT: "___memcpy", // RTLIB::___memcpy
+// CHECK-NEXT: "___memset", // RTLIB::___memset
 // CHECK-NEXT: "__ashlsi3", // RTLIB::__ashlsi3
 // CHECK-NEXT: "__lshrdi3", // RTLIB::__lshrdi3
 // CHECK-NEXT: "bzero", // RTLIB::bzero
+// CHECK-NEXT: "calloc", // RTLIB::calloc
 // CHECK-NEXT: "sqrtl", // RTLIB::sqrtl_f80
 // CHECK-NEXT: "sqrtl", // RTLIB::sqrtl_f128
 // CHECK-NEXT: };
 
 // CHECK: const RTLIB::Libcall llvm::RTLIB::RuntimeLibcallsInfo::ImplToLibcall[RTLIB::NumLibcallImpls] = {
 // CHECK-NEXT: RTLIB::UNKNOWN_LIBCALL, // RTLIB::Unsupported
+// CHECK-NEXT: RTLIB::MEMCPY, // RTLIB::___memcpy
+// CHECK-NEXT: RTLIB::MEMSET, // RTLIB::___memset
 // CHECK-NEXT: RTLIB::SHL_I32, // RTLIB::__ashlsi3
 // CHECK-NEXT: RTLIB::SRL_I64, // RTLIB::__lshrdi3
 // CHECK-NEXT: RTLIB::BZERO, // RTLIB::bzero
+// CHECK-NEXT: RTLIB::CALLOC, // RTLIB::calloc
 // CHECK-NEXT: RTLIB::SQRT_F80, // RTLIB::sqrtl_f80
 // CHECK-NEXT: RTLIB::SQRT_F128, // RTLIB::sqrtl_f128
 // CHECK-NEXT: };
+
+
+// CHECK: void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const llvm::Triple &TT) {
+// CHECK-NEXT:  struct LibcallImplPair {
+// CHECK-NEXT:    RTLIB::Libcall Func;
+// CHECK-NEXT:    RTLIB::LibcallImpl Impl;
+// CHECK-NEXT:  };
+// CHECK-EMPTY:
+// CHECK-NEXT: if (TT.getArch() == Triple::blah) {
+// CHECK-NEXT:     static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:         {RTLIB::BZERO, RTLIB::bzero}, // bzero
+// CHECK-NEXT:         {RTLIB::CALLOC, RTLIB::calloc}, // calloc
+// CHECK-NEXT:         {RTLIB::SQRT_F128, RTLIB::sqrtl_f128}, // sqrtl
+// CHECK-NEXT:     };
+// CHECK-EMPTY:
+// CHECK-NEXT:     for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:       setLibcallImpl(Func, Impl);
+// CHECK-NEXT:     }
+// CHECK-NEXT:    if (TT.hasCompilerRT()) {
+// CHECK-NEXT:      static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:          {RTLIB::SHL_I32, RTLIB::__ashlsi3}, // __ashlsi3
+// CHECK-NEXT:          {RTLIB::SRL_I64, RTLIB::__lshrdi3}, // __lshrdi3
+// CHECK-NEXT:      };
+// CHECK-EMPTY:
+// CHECK-NEXT:      for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:        setLibcallImpl(Func, Impl);
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-EMPTY:
+// CHECK-NEXT:    if (TT.getOS() == Triple::bar) {
+// CHECK-NEXT:      static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:          {RTLIB::MEMSET, RTLIB::___memset}, // ___memset
+// CHECK-NEXT:      };
+// CHECK-EMPTY:
+// CHECK-NEXT:      for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:        setLibcallImpl(Func, Impl);
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-EMPTY:
+// CHECK-NEXT:   return;
+// CHECK-NEXT: }
+// CHECK-EMPTY:
+// CHECK-NEXT: if (TT.getArch() == Triple::buzz) {
+// CHECK-NEXT:    static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:        {RTLIB::SHL_I32, RTLIB::__ashlsi3}, // __ashlsi3
+// CHECK-NEXT:        {RTLIB::SQRT_F80, RTLIB::sqrtl_f80}, // sqrtl
+// CHECK-NEXT:        {RTLIB::SRL_I64, RTLIB::__lshrdi3}, // __lshrdi3
+// CHECK-NEXT:    };
+// CHECK-EMPTY:
+// CHECK-NEXT:    for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:      setLibcallImpl(Func, Impl);
+// CHECK-NEXT:    }
+// CHECK-NEXT:   return;
+// CHECK-NEXT: }
+// CHECK-EMPTY:
+// CHECK-NEXT: if (TT.getArch() == Triple::foo) {
+// CHECK-NEXT:    static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:        {RTLIB::BZERO, RTLIB::bzero}, // bzero
+// CHECK-NEXT:        {RTLIB::SQRT_F128, RTLIB::sqrtl_f128}, // sqrtl
+// CHECK-NEXT:    };
+// CHECK-EMPTY:
+// CHECK-NEXT:    for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:      setLibcallImpl(Func, Impl);
+// CHECK-NEXT:    }
+// CHECK-NEXT:    if (TT.getOS() == Triple::bar) {
+// CHECK-NEXT:      static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:          {RTLIB::MEMSET, RTLIB::___memset}, // ___memset
+// CHECK-NEXT:      };
+// CHECK-EMPTY:
+// CHECK-NEXT:      for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:        setLibcallImpl(Func, Impl);
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-EMPTY:
+// CHECK-NEXT:    return;
+// CHECK-NEXT:  }
+// CHECK-EMPTY:
+// CHECK-NEXT: if (TT.getArch() == Triple::simple) {
+// CHECK-NEXT:    static const LibcallImplPair LibraryCalls[] = {
+// CHECK-NEXT:        {RTLIB::CALLOC, RTLIB::calloc}, // calloc
+// CHECK-NEXT:        {RTLIB::SHL_I32, RTLIB::__ashlsi3}, // __ashlsi3
+// CHECK-NEXT:        {RTLIB::SQRT_F80, RTLIB::sqrtl_f80}, // sqrtl
+// CHECK-NEXT:        {RTLIB::SRL_I64, RTLIB::__lshrdi3}, // __lshrdi3
+// CHECK-NEXT:    };
+// CHECK-EMPTY:
+// CHECK-NEXT:    for (const auto [Func, Impl] : LibraryCalls) {
+// CHECK-NEXT:      setLibcallImpl(Func, Impl);
+// CHECK-NEXT:    }
+// CHECK-NEXT:   return;
+// CHECK-NEXT: }
+// CHECK-NEXT:  initDefaultLibCallImpls();
+// CHECK-NEXT: }
+// CHECK-EMPTY:
+// CHECK: #endif
diff --git a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
index 9d77631862ee5..30fcca47a4706 100644
--- a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
@@ -11,17 +11,61 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/SetTheory.h"
 #include "llvm/TableGen/TableGenBackend.h"
+
 using namespace llvm;
 
 namespace {
 
+class AvailabilityPredicate {
+  const Record *TheDef;
+  StringRef PredicateString;
+
+public:
+  AvailabilityPredicate(const Record *Def) : TheDef(Def) {
+    if (TheDef)
+      PredicateString = TheDef->getValueAsString("Cond");
+  }
+
+  const Record *getDef() const { return TheDef; }
+
+  bool isAlwaysAvailable() const { return PredicateString.empty(); }
+
+  void emitIf(raw_ostream &OS) const {
+    OS << "if (" << PredicateString << ") {\n";
+  }
+
+  void emitEndIf(raw_ostream &OS) const { OS << "}\n"; }
+};
+
+class RuntimeLibcallEmitter;
+class RuntimeLibcallImpl;
+
+/// Used to apply predicates to nested sets of libcalls.
+struct LibcallPredicateExpander : SetTheory::Expander {
+  const RuntimeLibcallEmitter &LibcallEmitter;
+  DenseMap<const Record *, std::vector<const Record *>> &Func2Preds;
+
+  LibcallPredicateExpander(
+      const RuntimeLibcallEmitter &LibcallEmitter,
+      DenseMap<const Record *, std::vector<const Record *>> &Func2Preds)
+      : LibcallEmitter(LibcallEmitter), Func2Preds(Func2Preds) {}
+
+  void expand(SetTheory &ST, const Record *Def,
+              SetTheory::RecSet &Elts) override;
+};
+
 class RuntimeLibcall {
   const Record *TheDef = nullptr;
+  const size_t EnumVal;
 
 public:
   RuntimeLibcall() = delete;
-  RuntimeLibcall(const Record *Def) : TheDef(Def) { assert(Def); }
+  RuntimeLibcall(const Record *Def, size_t EnumVal)
+      : TheDef(Def), EnumVal(EnumVal) {
+    assert(Def);
+  }
 
   ~RuntimeLibcall() { assert(TheDef); }
 
@@ -29,6 +73,8 @@ class RuntimeLibcall {
 
   StringRef getName() const { return TheDef->getName(); }
 
+  size_t getEnumVal() const { return EnumVal; }
+
   void emitEnumEntry(raw_ostream &OS) const {
     OS << "RTLIB::" << TheDef->getValueAsString("Name");
   }
@@ -37,12 +83,14 @@ class RuntimeLibcall {
 class RuntimeLibcallImpl {
   const Record *TheDef;
   const RuntimeLibcall *Provides = nullptr;
+  const size_t EnumVal;
 
 public:
   RuntimeLibcallImpl(
       const Record *Def,
-      const DenseMap<const Record *, const RuntimeLibcall *> &ProvideMap)
-      : TheDef(Def) {
+      const DenseMap<const Record *, const RuntimeLibcall *> &ProvideMap,
+      size_t EnumVal)
+      : TheDef(Def), EnumVal(EnumVal) {
     if (const Record *ProvidesDef = Def->getValueAsDef("Provides"))
       Provides = ProvideMap.lookup(ProvidesDef);
   }
@@ -53,6 +101,8 @@ class RuntimeLibcallImpl {
 
   StringRef getName() const { return TheDef->getName(); }
 
+  size_t getEnumVal() const { return EnumVal; }
+
   const RuntimeLibcall *getProvides() const { return Provides; }
 
   StringRef getLibcallFuncName() const {
@@ -68,17 +118,29 @@ class RuntimeLibcallImpl {
   void emitEnumEntry(raw_ostream &OS) const {
     OS << "RTLIB::" << TheDef->getName();
   }
+
+  void emitSetImplCall(raw_ostream &OS) const {
+    OS << "setLibcallImpl(";
+    Provides->emitEnumEntry(OS);
+    OS << ", ";
+    emitEnumEntry(OS);
+    OS << "); // " << getLibcallFuncName() << '\n';
+  }
+
+  void emitTableEntry(raw_ostream &OS) const {
+    OS << '{';
+    Provides->emitEnumEntry(OS);
+    OS << ", ";
+    emitEnumEntry(OS);
+    OS << "}, // " << getLibcallFuncName() << '\n';
+  }
 };
 
 class RuntimeLibcallEmitter {
 private:
   const RecordKeeper &Records;
-
   DenseMap<const Record *, const RuntimeLibcall *> Def2RuntimeLibcall;
-
-  const RuntimeLibcall *getRuntimeLibcall(const Record *Def) const {
-    return Def2RuntimeLibcall.lookup(Def);
-  }
+  DenseMap<const Record *, const RuntimeLibcallImpl *> Def2RuntimeLibcallImpl;
 
   std::vector<RuntimeLibcall> RuntimeLibcallDefList;
   std::vector<RuntimeLibcallImpl> RuntimeLibcallImplDefList;
@@ -86,16 +148,19 @@ class RuntimeLibcallEmitter {
   DenseMap<const RuntimeLibcall *, const RuntimeLibcallImpl *>
       LibCallToDefaultImpl;
 
+private:
   void
   emitTargetOverrideFunc(raw_ostream &OS, StringRef FuncName,
                          ArrayRef<RuntimeLibcallImpl> LibCallImplList) const;
 
-  void emitGetRuntimeLibcallEnum(raw_ostream &OS) const;
+  void emitTargetOverrideFunc(raw_ostream &OS, StringRef FuncName,
+                              ArrayRef<const Record *> LibCallImplList) const;
 
-  void emitWindowsArm64LibCallNameOverrides(raw_ostream &OS) const;
+  void emitGetRuntimeLibcallEnum(raw_ostream &OS) const;
 
   void emitGetInitRuntimeLibcallNames(raw_ostream &OS) const;
-  void emitGetInitRuntimeLibcallUtils(raw_ostream &OS) const;
+
+  void emitSystemRuntimeLibrarySetCalls(raw_ostream &OS) const;
 
 public:
   RuntimeLibcallEmitter(const RecordKeeper &R) : Records(R) {
@@ -105,8 +170,9 @@ class RuntimeLibcallEmitter {
 
     RuntimeLibcallDefList.reserve(AllRuntimeLibcalls.size());
 
+    size_t CallTypeEnumVal = 0;
     for (const Record *RuntimeLibcallDef : AllRuntimeLibcalls) {
-      RuntimeLibcallDefList.emplace_back(RuntimeLibcallDef);
+      RuntimeLibcallDefList.emplace_back(RuntimeLibcallDef, CallTypeEnumVal++);
       Def2RuntimeLibcall[RuntimeLibcallDef] = &RuntimeLibcallDefList.back();
     }
 
@@ -117,12 +183,15 @@ class RuntimeLibcallEmitter {
         Records.getAllDerivedDefinitions("RuntimeLibcallImpl");
     RuntimeLibcallImplDefList.reserve(AllRuntimeLibcallImpls.size());
 
+    size_t LibCallImplEnumVal = 1;
     for (const Record *LibCallImplDef : AllRuntimeLibcallImpls) {
-      RuntimeLibcallImplDefList.emplace_back(LibCallImplDef,
-                                             Def2RuntimeLibcall);
+      RuntimeLibcallImplDefList.emplace_back(LibCallImplDef, Def2RuntimeLibcall,
+                                             LibCallImplEnumVal++);
 
       RuntimeLibcallImpl &LibCallImpl = RuntimeLibcallImplDefList.back();
 
+      Def2RuntimeLibcallImpl[LibCallImplDef] = &LibCallImpl;
+
       // const RuntimeLibcallImpl &LibCallImpl =
       // RuntimeLibcallImplDefList.back();
       if (LibCallImpl.isDefault()) {
@@ -135,16 +204,12 @@ class RuntimeLibcallEmitter {
     }
   }
 
-  std::vector<RuntimeLibcallImpl>
-  getRuntimeLibcallImplSet(StringRef Name) const {
-    std::vector<RuntimeLibcallImpl> Result;
-    ArrayRef<const Record *> ImplSet =
-        Records.getAllDerivedDefinitionsIfDefined(Name);
-    Result.reserve(ImplSet.size());
+  const RuntimeLibcall *getRuntimeLibcall(const Record *Def) const {
+    return Def2RuntimeLibcall.lookup(Def);
+  }
 
-    for (const Record *LibCallImplDef : ImplSet)
-      Result.emplace_back(LibCallImplDef, Def2RuntimeLibcall);
-    return Result;
+  const RuntimeLibcallImpl *getRuntimeLibcallImpl(const Record *Def) const {
+    return Def2RuntimeLibcallImpl.lookup(Def);
   }
 
   void run(raw_ostream &OS);
@@ -182,72 +247,36 @@ void RuntimeLibcallEmitter::emitGetRuntimeLibcallEnum(raw_ostream &OS) const {
         "namespace RTLIB {\n"
         "enum Libcall : unsigned short {\n";
 
-  size_t CallTypeEnumVal = 0;
   for (const RuntimeLibcall &LibCall : RuntimeLibcallDefList) {
     StringRef Name = LibCall.getName();
-    OS << "  " << Name << " = " << CallTypeEnumVal++ << ",\n";
+    OS << "  " << Name << " = " << LibCall.getEnumVal() << ",\n";
   }
 
   // TODO: Emit libcall names as string offset table.
 
-  OS << "  UNKNOWN_LIBCALL = " << CallTypeEnumVal
+  OS << "  UNKNOWN_LIBCALL = " << RuntimeLibcallDefList.size()
      << "\n};\n\n"
         "enum LibcallImpl : unsigned short {\n"
         "  Unsupported = 0,\n";
 
   // FIXME: Emit this in a different namespace. And maybe use enum class.
-  size_t LibCallImplEnumVal = 1;
   for (const RuntimeLibcallImpl &LibCall : RuntimeLibcallImplDefList) {
-    OS << "  " << LibCall.getName() << " = " << LibCallImplEnumVal++ << ", // "
+    OS << "  " << LibCall.getName() << " = " << LibCall.getEnumVal() << ", // "
        << LibCall.getLibcallFuncName() << '\n';
   }
 
-  OS << "  NumLibcallImpls = " << LibCallImplEnumVal
+  OS << "  NumLibcallImpls = " << RuntimeLibcallImplDefList.size() + 1
      << "\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 RTLIB::LibcallImpl "
-        "WindowsArm64RoutineImpls[RTLIB::UNKNOWN_LIBCALL + 1] = {\n";
-  for (const RuntimeLibcall &LibCall : RuntimeLibcallDefList) {
-    auto I = LibCallToDefaultImpl.find(&LibCall);
-    if (I == LibCallToDefaultImpl.end())
-      OS << "    RTLIB::Unsupported,";
-    else {
-      const RuntimeLibcallImpl *LibCallImpl = I->second;
-      assert(LibCallImpl);
-      OS << "    RTLIB::arm64ec_" << LibCallImpl->getName() << ',';
-    }
-
-    OS << " // ";
-    LibCall.emitEnumEntry(OS);
-    OS << '\n';
-  }
-
-  OS << "    RTLIB::Unsupported // RTLIB::UNKNOWN_LIBCALL\n"
-        "  };\n\n"
-        "  std::memcpy(LibcallImpls, WindowsArm64RoutineImpls,\n"
-        "              sizeof(LibcallImpls));\n"
-        "  static_assert(sizeof(LibcallImpls) == "
-        "sizeof(WindowsArm64RoutineImpls),\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 RTLIB::LibcallImpl "
+  OS << "const RTLIB::LibcallImpl "
         "llvm::RTLIB::RuntimeLibcallsInfo::"
         "DefaultLibcallImpls[RTLIB::UNKNOWN_LIBCALL + 1] = {\n";
 
@@ -259,7 +288,7 @@ void RuntimeLibcallEmitter::emitGetInitRuntimeLibcallNames(
       const RuntimeLibcallImpl *LibCallImpl = I->second;
       OS << "  ";
       LibCallImpl->emitEnumEntry(OS);
-      OS << ",";
+      OS << ',';
     }
 
     OS << " // ";
@@ -297,48 +326,182 @@ void RuntimeLibcallEmitter::emitGetInitRuntimeLibcallNames(
     OS << '\n';
   }
   OS << "};\n\n";
+}
 
-  std::vector<RuntimeLibcallImpl> ZOSRuntimeLibcallImplList =
-      getRuntimeLibcallImplSet("ZOSRuntimeLibcallImpl");
-  emitTargetOverrideFunc(OS, "setZOSLibCallNameOverrides",
-                         ZOSRuntimeLibcallImplList);
+void RuntimeLibcallEmitter::emitSystemRuntimeLibrarySetCalls(
+    raw_ostream &OS) const {
+  OS << "void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets("
+        "const llvm::Triple &TT) {\n"
+        "  struct LibcallImplPair {\n"
+        "    RTLIB::Libcall Func;\n"
+        "    RTLIB::LibcallImpl Impl;\n"
+        "  };\n";
+  ArrayRef<const Record *> AllLibs =
+      Records.getAllDerivedDefinitions("SystemRuntimeLibrary");
+
+  for (const Record *R : AllLibs) {
+    OS << '\n';
 
-  std::vector<RuntimeLibcallImpl> PPCRuntimeLibcallImplList =
-      getRuntimeLibcallImplSet("PPCRuntimeLibcallImpl");
-  emitTargetOverrideFunc(OS, "setPPCLibCallNameOverrides",
-                         PPCRuntimeLibcallImplList);
+    AvailabilityPredicate TopLevelPredicate(R->getValueAsDef("TriplePred"));
 
-  emitWindowsArm64LibCallNameOverrides(OS);
-}
+    OS << indent(2);
+    TopLevelPredicate.emitIf(OS);
+    SetTheory Sets;
 
-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";
+    DenseMap<const Record *, std::vector<const Record *>> Func2Preds;
+    Sets.addExpander(
+        "LibcallImpls",
+        std::make_unique<LibcallPredicateExpander>(*this, Func2Preds));
+
+    const SetTheory::RecVec *Elements =
+        Sets.expand(R->getValueAsDef("MemberList"));
+
+    // Sort to get deterministic output
+    SetVector<const Record *> PredicateSorter;
+    PredicateSorter.insert(nullptr); // No predicate first.
+
+    DenseMap<const Record *, std::vector<const RuntimeLibcallImpl *>>
+        Pred2Funcs;
+    for (const Record *Elt : *Elements) {
+      const RuntimeLibcallImpl *LibCallImpl = getRuntimeLibcallImpl(Elt);
+      auto It = Func2Preds.find(Elt);
+      if (It == Func2Preds.end()) {
+        Pred2Funcs[nullptr].push_back(LibCallImpl);
+        continue;
+      }
+
+      for (const Record *Pred : It->second) {
+        Pred2Funcs[Pred].push_back(LibCallImpl);
+        PredicateSorter.insert(Pred);
+      }
     }
+
+    SmallVector<const Record *, 0> SortedPredicates =
+        PredicateSorter.takeVector();
+
+    sort(SortedPredicates, [](const Record *A, const Record *B) {
+      if (!A)
+        return true;
+      if (!B)
+        return false;
+      return A->getName() < B->getName();
+    });
+
+    for (const Record *Pred : SortedPredicates) {
+      AvailabilityPredicate SubsetPredicate(Pred);
+      unsigned IndentDepth = 2;
+
+      auto It = Pred2Funcs.find(Pred);
+      if (It == Pred2Funcs.end())
+        continue;
+
+      if (!SubsetPredicate.isAlwaysAvailable()) {
+        IndentDepth = 4;
+
+        OS << indent(IndentDepth);
+        SubsetPredicate.emitIf(OS);
+      }
+
+      std::vector<const RuntimeLibcallImpl *> &Funcs = It->second;
+
+      // Ensure we only emit a unique implementation per libcall in the
+      // selection table.
+      //
+      // FIXME: We need to generate separate functions for
+      // is-libcall-available and should-libcall-be-used to avoid this.
+      //
+      // This also makes it annoying to make use of the default set, since the
+      // entries from the default set may win over the replacements unless
+      // they are explicitly removed.
+      sort(Funcs, [](const RuntimeLibcallImpl *A, const RuntimeLibcallImpl *B) {
+        return A->getProvides()->getEnumVal() < B->getProvides()->getEnumVal();
+      });
+
+      auto UniqueI = llvm::unique(
+          Funcs, [&](const RuntimeLibcallImpl *A, const RuntimeLibcallImpl *B) {
+            if (A->getProvides() == B->getProvides()) {
+              PrintWarning(R->getLoc(),
+                           Twine("conflicting implementations for libcall " +
+                                 A->getProvides()->getName() + ": " +
+                                 A->getLibcallFuncName() + ", " +
+                                 B->getLibcallFuncName()));
+              return true;
+            }
+
+            return false;
+          });
+
+      Funcs.erase(UniqueI, Funcs.end());
+
+      OS << indent(IndentDepth + 2)
+         << "static const LibcallImplPair LibraryCalls[] = {\n";
+      for (const RuntimeLibcallImpl *LibCallImpl : Funcs) {
+        OS << indent(IndentDepth + 6);
+        LibCallImpl->emitTableEntry(OS);
+      }
+
+      OS << indent(IndentDepth + 2) << "};\n\n"
+         << indent(IndentDepth + 2)
+         << "for (const auto [Func, Impl] : LibraryCalls) {\n"
+         << indent(IndentDepth + 2) << "  setLibcallImpl(Func, Impl);\n"
+         << indent(IndentDepth + 2) << "}\n";
+
+      if (!SubsetPredicate.isAlwaysAvailable()) {
+        OS << indent(IndentDepth);
+        SubsetPredicate.emitEndIf(OS);
+        OS << '\n';
+      }
+    }
+
+    OS << indent(4) << "return;\n" << indent(2);
+    TopLevelPredicate.emitEndIf(OS);
   }
 
-  OS << "    return true;\n"
-        "  default:\n"
-        "    return false;\n"
-        "  }\n\n"
-        "  llvm_unreachable(\"covered switch over libcalls\");\n"
-        "}\n#endif\n\n";
+  // Fallback to the old default set for manual table entries.
+  //
+  // TODO: Remove this when targets have switched to using generated tables by
+  // default.
+  OS << "  initDefaultLibCallImpls();\n";
+
+  OS << "}\n\n";
 }
 
 void RuntimeLibcallEmitter::run(raw_ostream &OS) {
   emitSourceFileHeader("Runtime LibCalls Source Fragment", OS, Records);
   emitGetRuntimeLibcallEnum(OS);
+
+  OS << "#ifdef GET_INIT_RUNTIME_LIBCALL_NAMES\n";
   emitGetInitRuntimeLibcallNames(OS);
-  emitGetInitRuntimeLibcallUtils(OS);
+  OS << "#endif\n\n";
+
+  OS << "#ifdef GET_SET_TARGET_RUNTIME_LIBCALL_SETS\n";
+  emitSystemRuntimeLibrarySetCalls(OS);
+  OS << "#endif\n\n";
+}
+
+void LibcallPredicateExpander::expand(SetTheory &ST, const Record *Def,
+                                      SetTheory::RecSet &Elts) {
+  assert(Def->isSubClassOf("LibcallImpls"));
+
+  SetTheory::RecSet TmpElts;
+
+  ST.evaluate(Def->getValueInit("MemberList"), TmpElts, Def->getLoc());
+
+  Elts.insert(TmpElts.begin(), TmpElts.end());
+
+  AvailabilityPredicate AP(Def->getValueAsDef("AvailabilityPredicate"));
+
+  for (const Record *LibcallImpl : TmpElts) {
+    if (!AP.isAlwaysAvailable()) {
+      auto [It, Inserted] = Func2Preds.insert({LibcallImpl, {}});
+      if (!Inserted) {
+        PrintError(
+            Def, "combining nested libcall set predicates currently unhandled");
+      }
+
+      It->second.push_back(AP.getDef());
+    }
+  }
 }
 
 static TableGen::Emitter::OptClass<RuntimeLibcallEmitter>