[SYCL][NativeCPU] Limit generic ABI to builtins. (#19564)

In #17408, NativeCPU became a target in order to be able to pick the ABI
for its own libclc functions consistently, without having targets affect
this. This was, and is, required to be able to use libclc independent of
target and target options. However, it breaks some calls into libc.
Therefore, this PR allows the calling convention to be explicitly
specified, ensures it is specified for any libclc functions, and ensures
it is not specified for any libc functions.

Fixes the SYCL-E2E acos, cmath, and exp-std-complex tests.

Author: hvdijk

clang/include/clang/Basic/Attr.td

@@ -494,6 +494,7 @@ def TargetAnyX86 : TargetArch<["x86", "x86_64"]>;
 def TargetSPIRV : TargetArch<["spirv", "spirv32", "spirv64"]>;
 def TargetWebAssembly : TargetArch<["wasm32", "wasm64"]>;
 def TargetNVPTX : TargetArch<["nvptx", "nvptx64"]>;
+def TargetNativeCPU : TargetArch<["native_cpu"]>;
 def TargetWindows : TargetSpec {
   let OSes = ["Win32"];
 }
@@ -4530,6 +4531,11 @@ def RISCVVLSCC: DeclOrTypeAttr, TargetSpecificAttr<TargetRISCV> {
  let Documentation = [RISCVVLSCCDocs];
 }
 
+def NativeCPULibclcCall : DeclOrTypeAttr, TargetSpecificAttr<TargetNativeCPU> {
+  let Spellings = [Clang<"libclc_call", 0>];
+  let Documentation = [Undocumented];
+}
+
 def Target : InheritableAttr {
   let Spellings = [GCC<"target">];
   let Args = [StringArgument<"featuresStr">];

clang/include/clang/Basic/TargetInfo.h

@@ -1711,6 +1711,11 @@ class TargetInfo : public TransferrableTargetInfo,
     return CC_C;
   }
 
+  /// Gets the calling convention for libclc built-ins for the given target.
+  virtual CallingConv getLibclcCallingConv() const {
+    return getDefaultCallingConv();
+  }
+
   /// Get the default atomic options.
   AtomicOptions getAtomicOpts() const { return AtomicOpts; }
 

clang/lib/AST/Type.cpp

@@ -4341,6 +4341,7 @@ bool AttributedType::isCallingConv() const {
   case attr::PreserveNone:
   case attr::RISCVVectorCC:
   case attr::RISCVVLSCC:
+  case attr::NativeCPULibclcCall:
     return true;
   }
   llvm_unreachable("invalid attr kind");

clang/lib/AST/TypePrinter.cpp

@@ -2125,6 +2125,9 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
   case attr::RISCVVLSCC:
     OS << "riscv_vls_cc";
     break;
+  case attr::NativeCPULibclcCall:
+    OS << "libclc_call";
+    break;
   case attr::NoDeref:
     OS << "noderef";
     break;

clang/lib/Basic/Targets/NativeCPU.h

@@ -49,7 +49,12 @@ class LLVM_LIBRARY_VISIBILITY NativeCPUTargetInfo final : public TargetInfo {
 
   void setSupportedOpenCLOpts() override { supportAllOpenCLOpts(); }
 
+  CallingConv getLibclcCallingConv() const override { return CC_SpirFunction; }
+
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
+    if (CC == CC_SpirFunction)
+      return CCCR_OK;
+
     if (HostTarget)
       return HostTarget->checkCallingConvention(CC);
 

clang/lib/CodeGen/CGCall.cpp

@@ -334,6 +334,9 @@ static CallingConv getCallingConventionForDecl(const ObjCMethodDecl *D,
     }
   }
 
+  if (D->hasAttr<NativeCPULibclcCallAttr>())
+    return CC_SpirFunction;
+
   return CC_C;
 }
 

clang/lib/CodeGen/Targets/NativeCPU.cpp

@@ -20,6 +20,8 @@ class NativeCPUABIInfo : public DefaultABIInfo {
 public:
   NativeCPUABIInfo(CodeGen::CodeGenTypes &CGT, const ABIInfo *HostABIInfo)
       : DefaultABIInfo(CGT), HostABIInfo(HostABIInfo) {}
+
+  void computeInfo(CGFunctionInfo &FI) const override;
 };
 
 class NativeCPUTargetCodeGenInfo : public TargetCodeGenInfo {
@@ -37,6 +39,17 @@ class NativeCPUTargetCodeGenInfo : public TargetCodeGenInfo {
 };
 } // namespace
 
+void NativeCPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
+  if (HostABIInfo &&
+      FI.getCallingConvention() != llvm::CallingConv::SPIR_FUNC) {
+    HostABIInfo->computeInfo(FI);
+    return;
+  }
+
+  DefaultABIInfo::computeInfo(FI);
+  FI.setEffectiveCallingConvention(llvm::CallingConv::C);
+}
+
 std::unique_ptr<TargetCodeGenInfo> CodeGen::createNativeCPUTargetCodeGenInfo(
     CodeGenModule &CGM,
     std::unique_ptr<TargetCodeGenInfo> HostTargetCodeGenInfo) {

clang/lib/Sema/SemaDeclAttr.cpp

@@ -5428,6 +5428,9 @@ static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
     D->addAttr(::new (S.Context) RISCVVLSCCAttr(S.Context, AL, VectorLength));
     return;
   }
+  case ParsedAttr::AT_NativeCPULibclcCall:
+    D->addAttr(::new (S.Context) NativeCPULibclcCallAttr(S.Context, AL));
+    return;
   default:
     llvm_unreachable("unexpected attribute kind");
   }
@@ -5699,6 +5702,9 @@ bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
     CC = CC_DeviceKernel;
     break;
   }
+  case ParsedAttr::AT_NativeCPULibclcCall:
+    CC = CC_SpirFunction;
+    break;
   default: llvm_unreachable("unexpected attribute kind");
   }
 
@@ -7700,6 +7706,7 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_PreserveNone:
   case ParsedAttr::AT_RISCVVectorCC:
   case ParsedAttr::AT_RISCVVLSCC:
+  case ParsedAttr::AT_NativeCPULibclcCall:
     handleCallConvAttr(S, D, AL);
     break;
   case ParsedAttr::AT_DeviceKernel:

clang/lib/Sema/SemaLookup.cpp

@@ -22,6 +22,7 @@
 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/Preprocessor.h"
@@ -788,7 +789,7 @@ static void GetProgModelBuiltinFctOverloads(
     std::vector<QualType> &FunctionList, SmallVector<QualType, 1> &RetTypes,
     SmallVector<SmallVector<QualType, 1>, 5> &ArgTypes, bool IsVariadic) {
   FunctionProtoType::ExtProtoInfo PI(
-      Context.getDefaultCallingConvention(false, false, true));
+      Context.getTargetInfo().getLibclcCallingConv());
   PI.Variadic = IsVariadic;
   PI.ExceptionSpec = FunctionProtoType::ExceptionSpecInfo{EST_BasicNoexcept};
 

clang/lib/Sema/SemaType.cpp

@@ -144,7 +144,8 @@ static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
   case ParsedAttr::AT_M68kRTD:                                                 \
   case ParsedAttr::AT_PreserveNone:                                            \
   case ParsedAttr::AT_RISCVVectorCC:                                           \
-  case ParsedAttr::AT_RISCVVLSCC
+  case ParsedAttr::AT_RISCVVLSCC:                                              \
+  case ParsedAttr::AT_NativeCPULibclcCall
 
 // Function type attributes.
 #define FUNCTION_TYPE_ATTRS_CASELIST                                           \
@@ -7661,6 +7662,8 @@ static Attr *getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr) {
 
     return ::new (Ctx) RISCVVLSCCAttr(Ctx, Attr, ABIVLen);
   }
+  case ParsedAttr::AT_NativeCPULibclcCall:
+    return createSimpleAttr<NativeCPULibclcCallAttr>(Ctx, Attr);
   }
   llvm_unreachable("unexpected attribute kind!");
 }