[Clang] Add proper target checks for SwiftAsync convention.

[varungandhi-apple]

Summary

Previously, we erroneously claimed that all targets were supported.
However, at the moment, only x86_64 and ARM are known to be working.

[aschwaighofer]

Looks good to me

[rjmccall]

The TargetInfo classes are already target-architecture-specific, so it's somewhat strange for them all to funnel to a single function that then immediately switches on the target architecture.

[varungandhi-apple]

The TargetInfo classes are already target-architecture-specific, so it's somewhat strange for them all to funnel to a single function that then immediately switches on the target architecture.

IMO ideally, the whole thing would be stored as a table of Target x CallingConvention. Each entry of the table would have a CallingConvCheckResult. That way, you can quickly figure out both:

• which targets is a calling convention supported for
• what calling conventions are supported for a particular target

Certainly, that's not the state of the code right now. So I do agree with your point that it looks a bit strange. However, given that things are somewhat in flux for CC_SwiftAsync, I think it is valuable to centralize the information for it in one place instead of spreading it out over multiple files.

[varungandhi-apple]

I've updated the earlier patch https://reviews.llvm.org/D95561 to include this change, so that we don't have an in-between state where we erroneously claim that we support a bunch of targets which we don't actually support.

[rjmccall]

In D96802#2569810, @varungandhi-apple wrote:

The TargetInfo classes are already target-architecture-specific, so it's somewhat strange for them all to funnel to a single function that then immediately switches on the target architecture.

IMO ideally, the whole thing would be stored as a table of Target x CallingConvention. Each entry of the table would have a CallingConvCheckResult. That way, you can quickly figure out both:

• which targets is a calling convention supported for
• what calling conventions are supported for a particular target

Certainly, that's not the state of the code right now. So I do agree with your point that it looks a bit strange. However, given that things are somewhat in flux for CC_SwiftAsync, I think it is valuable to centralize the information for it in one place instead of spreading it out over multiple files.

I don't see why. I can't really imagine adding a second dimension to the decision here — there's no reason to ever make this OS-dependent, for example — and so the only likely evolution is adding support for a new architecture, which means adding another case to your centralized function instead of just changing how the CC is handled in the target-specific function. And for this patch, just implementing the new case as return CCCR_Error seems much more obvious than calling a centralized function which just switches out again.

clang/include/clang/Basic/Features.def

 FEATURE(nullability_on_arrays, true)
 FEATURE(nullability_nullable_result, true)
 FEATURE(memory_sanitizer,
         LangOpts.Sanitize.hasOneOf(SanitizerKind::Memory |
                                    SanitizerKind::KernelMemory))
 FEATURE(thread_sanitizer, LangOpts.Sanitize.has(SanitizerKind::Thread))
 FEATURE(dataflow_sanitizer, LangOpts.Sanitize.has(SanitizerKind::DataFlow))
 FEATURE(scudo, LangOpts.Sanitize.hasOneOf(SanitizerKind::Scudo))
+FEATURE(swiftasynccc, PP.getTargetInfo().isSwiftAsyncCCSupported())
 // Objective-C features
 FEATURE(objc_arr, LangOpts.ObjCAutoRefCount) // FIXME: REMOVE?
 FEATURE(objc_arc, LangOpts.ObjCAutoRefCount)
 FEATURE(objc_arc_fields, true)
 FEATURE(objc_arc_weak, LangOpts.ObjCWeak)
 FEATURE(objc_default_synthesize_properties, LangOpts.ObjC)
 FEATURE(objc_fixed_enum, LangOpts.ObjC)
 FEATURE(objc_instancetype, LangOpts.ObjC)

clang/include/clang/Basic/TargetInfo.h

   enum CallingConvKind {
     CCK_Default,
     CCK_ClangABI4OrPS4,
     CCK_MicrosoftWin64
   };
 
   virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const;
 
+  /// \brief Is the Swift async calling convention supported for this target.
+  bool isSwiftAsyncCCSupported() const {
+    auto &triple = getTriple();
+    return triple.getArch() == llvm::Triple::x86_64 || triple.isARM() ||
+           triple.isAArch64();
+  }
+
+  CallingConvCheckResult checkSwiftAsyncCCSupported() const {
+    return isSwiftAsyncCCSupported() ? CCCR_OK : CCCR_Error;
+  }
+
   /// Controls if __builtin_longjmp / __builtin_setjmp can be lowered to
   /// llvm.eh.sjlj.longjmp / llvm.eh.sjlj.setjmp.
   virtual bool hasSjLjLowering() const {
     return false;
   }
 
   /// Check if the target supports CFProtection branch.
   virtual bool

clang/lib/Basic/Targets/AArch64.cpp

bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
   return true;
 }
 
 TargetInfo::CallingConvCheckResult
 AArch64TargetInfo::checkCallingConvention(CallingConv CC) const {
   switch (CC) {
   case CC_C:
   case CC_Swift:
-  case CC_SwiftAsync:
   case CC_PreserveMost:
   case CC_PreserveAll:
   case CC_OpenCLKernel:
   case CC_AArch64VectorCall:
   case CC_Win64:
     return CCCR_OK;
+  case CC_SwiftAsync:
+    return checkSwiftAsyncCCSupported();
   default:
     return CCCR_Warning;
   }
 }
 
 bool AArch64TargetInfo::isCLZForZeroUndef() const { return false; }
 
 TargetInfo::BuiltinVaListKind AArch64TargetInfo::getBuiltinVaListKind() const {
WindowsARM64TargetInfo::checkCallingConvention(CallingConv CC) const {
   case CC_X86FastCall:
   case CC_X86VectorCall:
     return CCCR_Ignore;
   case CC_C:
   case CC_OpenCLKernel:
   case CC_PreserveMost:
   case CC_PreserveAll:
   case CC_Swift:
-  case CC_SwiftAsync:
   case CC_Win64:
     return CCCR_OK;
+  case CC_SwiftAsync:
+    return checkSwiftAsyncCCSupported();
   default:
     return CCCR_Warning;
   }
 }
 
 MicrosoftARM64TargetInfo::MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
                                                    const TargetOptions &Opts)
     : WindowsARM64TargetInfo(Triple, Opts) {

clang/lib/Basic/Targets/ARM.cpp

 }
 
 TargetInfo::CallingConvCheckResult
 ARMTargetInfo::checkCallingConvention(CallingConv CC) const {
   switch (CC) {
   case CC_AAPCS:
   case CC_AAPCS_VFP:
   case CC_Swift:
-  case CC_SwiftAsync:
   case CC_OpenCLKernel:
     return CCCR_OK;
+  case CC_SwiftAsync:
+    return checkSwiftAsyncCCSupported();
   default:
     return CCCR_Warning;
   }
 }
 
 int ARMTargetInfo::getEHDataRegisterNumber(unsigned RegNo) const {
   if (RegNo == 0)
     return 0;
WindowsARMTargetInfo::checkCallingConvention(CallingConv CC) const {
   case CC_X86FastCall:
   case CC_X86VectorCall:
     return CCCR_Ignore;
   case CC_C:
   case CC_OpenCLKernel:
   case CC_PreserveMost:
   case CC_PreserveAll:
   case CC_Swift:
-  case CC_SwiftAsync:
     return CCCR_OK;
+  case CC_SwiftAsync:
+    return checkSwiftAsyncCCSupported();
   default:
     return CCCR_Warning;
   }
 }
 
 // Windows ARM + Itanium C++ ABI Target
 ItaniumWindowsARMleTargetInfo::ItaniumWindowsARMleTargetInfo(
     const llvm::Triple &Triple, const TargetOptions &Opts)

clang/lib/Basic/Targets/PPC.h

if (Name == "elfv1" || Name == "elfv2") {
       return true;
     }
     return false;
   }
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     switch (CC) {
     case CC_Swift:
-    case CC_SwiftAsync:
       return CCCR_OK;
+    case CC_SwiftAsync:
+      return checkSwiftAsyncCCSupported();
     default:
       return CCCR_Warning;
     }
   }
 };
 
 class LLVM_LIBRARY_VISIBILITY DarwinPPC32TargetInfo
     : public DarwinTargetInfo<PPC32TargetInfo> {

clang/lib/Basic/Targets/SystemZ.h

public:
   }
 
   bool hasFeature(StringRef Feature) const override;
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     switch (CC) {
     case CC_C:
     case CC_Swift:
-    case CC_SwiftAsync:
     case CC_OpenCLKernel:
       return CCCR_OK;
+    case CC_SwiftAsync:
+      return checkSwiftAsyncCCSupported();
     default:
       return CCCR_Warning;
     }
   }
 
   StringRef getABI() const override {
     if (HasVector)
       return "vector";

clang/lib/Basic/Targets/WebAssembly.h

return BitWidth == 64
                ? (IsSigned ? SignedLongLong : UnsignedLongLong)
                : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
   }
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     switch (CC) {
     case CC_C:
     case CC_Swift:
-    case CC_SwiftAsync:
       return CCCR_OK;
+    case CC_SwiftAsync:
+      return checkSwiftAsyncCCSupported();
     default:
       return CCCR_Warning;
     }
   }
 
   bool hasExtIntType() const override { return true; }
 
   bool hasProtectedVisibility() const override { return false; }

clang/lib/Basic/Targets/X86.h

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     case CC_X86ThisCall:
     case CC_X86FastCall:
     case CC_X86StdCall:
     case CC_X86VectorCall:
     case CC_X86RegCall:
     case CC_C:
     case CC_PreserveMost:
     case CC_Swift:
-    case CC_SwiftAsync:
     case CC_X86Pascal:
     case CC_IntelOclBicc:
     case CC_OpenCLKernel:
       return CCCR_OK;
+    case CC_SwiftAsync:
+      return checkSwiftAsyncCCSupported();
     default:
       return CCCR_Warning;
     }
   }
 
   CallingConv getDefaultCallingConv() const override {
     return CC_C;
   }
if (RegNo == 1)
       return 1;
     return -1;
   }
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     switch (CC) {
     case CC_C:
     case CC_Swift:
-    case CC_SwiftAsync:
     case CC_X86VectorCall:
     case CC_IntelOclBicc:
     case CC_Win64:
     case CC_PreserveMost:
     case CC_PreserveAll:
     case CC_X86RegCall:
     case CC_OpenCLKernel:
       return CCCR_OK;
+    case CC_SwiftAsync:
+      return checkSwiftAsyncCCSupported();
     default:
       return CCCR_Warning;
     }
   }
 
   CallingConv getDefaultCallingConv() const override {
     return CC_C;
   }
case CC_X86FastCall:
       return CCCR_Ignore;
     case CC_C:
     case CC_X86VectorCall:
     case CC_IntelOclBicc:
     case CC_PreserveMost:
     case CC_PreserveAll:
     case CC_X86_64SysV:
     case CC_Swift:
-    case CC_SwiftAsync:
     case CC_X86RegCall:
     case CC_OpenCLKernel:
       return CCCR_OK;
+    case CC_SwiftAsync:
+      return checkSwiftAsyncCCSupported();
     default:
       return CCCR_Warning;
     }
   }
 };
 
 // x86-64 Windows Visual Studio target
 class LLVM_LIBRARY_VISIBILITY MicrosoftX86_64TargetInfo