[CIR][CodeGen][NFC] Replace the calling convention in CodeGen with the one in dialect (#772)

This PR remove the header `CIR/CodeGen/CallingConv.h` and migrates all
`::cir::CallingConv` stuff to `::mlir::cir::CallingConv` in
`CIRGenTypes` and `CIRGenFunctionInfo`.

In TargetLowering library, LowerTypes and LowerFunctionInfo basically
have the same clangCallConvToLLVMCallConv stuff. The CC there is the
LLVM one. But those changes are not included because of the potential
conflicts. We can still easily switch to the dialect when it's needed.

Author: seven-mile

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -39,7 +39,7 @@ using namespace cir;
 using namespace clang;
 
 CIRGenFunctionInfo *CIRGenFunctionInfo::create(
-    unsigned cirCC, bool instanceMethod, bool chainCall,
+    mlir::cir::CallingConv cirCC, bool instanceMethod, bool chainCall,
     const FunctionType::ExtInfo &info,
     llvm::ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType,
     llvm::ArrayRef<CanQualType> argTypes, RequiredArgs required) {

clang/lib/CIR/CodeGen/CIRGenFunctionInfo.h

@@ -88,11 +88,11 @@ class CIRGenFunctionInfo final
   typedef clang::FunctionProtoType::ExtParameterInfo ExtParameterInfo;
 
   /// The cir::CallingConv to use for this function (as specified by the user).
-  unsigned CallingConvention : 8;
+  mlir::cir::CallingConv CallingConvention : 8;
 
   /// The cir::CallingConv to actually use for this function, which may depend
   /// on the ABI.
-  unsigned EffectiveCallingConvention : 8;
+  mlir::cir::CallingConv EffectiveCallingConvention : 8;
 
   /// The clang::CallingConv that this was originally created with.
   unsigned ASTCallingConvention : 6;
@@ -150,7 +150,7 @@ class CIRGenFunctionInfo final
   CIRGenFunctionInfo() : Required(RequiredArgs::All) {}
 
 public:
-  static CIRGenFunctionInfo *create(unsigned cirCC, bool instanceMethod,
+  static CIRGenFunctionInfo *create(mlir::cir::CallingConv cirCC, bool instanceMethod,
                                     bool chainCall,
                                     const clang::FunctionType::ExtInfo &extInfo,
                                     llvm::ArrayRef<ExtParameterInfo> paramInfos,
@@ -252,7 +252,7 @@ class CIRGenFunctionInfo final
 
   /// getCallingConvention - REturn the user specified calling convention, which
   /// has been translated into a CIR CC.
-  unsigned getCallingConvention() const { return CallingConvention; }
+  mlir::cir::CallingConv getCallingConvention() const { return CallingConvention; }
 
   clang::CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
 

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -2,12 +2,12 @@
 #include "CIRGenCall.h"
 #include "CIRGenFunctionInfo.h"
 #include "CIRGenModule.h"
-#include "CallingConv.h"
 #include "TargetInfo.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "clang/CIR/Dialect/IR/CIRAttrs.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
@@ -24,12 +24,14 @@
 using namespace clang;
 using namespace cir;
 
-unsigned CIRGenTypes::ClangCallConvToCIRCallConv(clang::CallingConv CC) {
+mlir::cir::CallingConv CIRGenTypes::ClangCallConvToCIRCallConv(clang::CallingConv CC) {
   switch (CC) {
   case CC_C:
-    return cir::CallingConv::C;
+    return mlir::cir::CallingConv::C;
   case CC_OpenCLKernel:
     return CGM.getTargetCIRGenInfo().getOpenCLKernelCallingConv();
+  case CC_SpirFunction:
+    return mlir::cir::CallingConv::SpirFunction;
   default:
     llvm_unreachable("No other calling conventions implemented.");
   }
@@ -761,7 +763,7 @@ const CIRGenFunctionInfo &CIRGenTypes::arrangeCIRFunctionInfo(
   if (FI)
     return *FI;
 
-  unsigned CC = ClangCallConvToCIRCallConv(info.getCC());
+  mlir::cir::CallingConv CC = ClangCallConvToCIRCallConv(info.getCC());
 
   // Construction the function info. We co-allocate the ArgInfos.
   FI = CIRGenFunctionInfo::create(CC, instanceMethod, chainCall, info,

clang/lib/CIR/CodeGen/CIRGenTypes.h

@@ -126,8 +126,8 @@ class CIRGenTypes {
   bool isFuncTypeConvertible(const clang::FunctionType *FT);
   bool isFuncParamTypeConvertible(clang::QualType Ty);
 
-  /// Convert clang calling convention to LLVM calling convention.
-  unsigned ClangCallConvToCIRCallConv(clang::CallingConv CC);
+  /// Convert clang calling convention to CIR calling convention.
+  mlir::cir::CallingConv ClangCallConvToCIRCallConv(clang::CallingConv CC);
 
   /// Derives the 'this' type for CIRGen purposes, i.e. ignoring method CVR
   /// qualification.

clang/lib/CIR/CodeGen/CallingConv.h

@@ -241,15 +241,15 @@ class SPIRVABIInfo : public CommonSPIRABIInfo {
   void computeInfo(CIRGenFunctionInfo &FI) const override {
     // The logic is same as in DefaultABIInfo with an exception on the kernel
     // arguments handling.
-    llvm::CallingConv::ID CC = FI.getCallingConvention();
+    mlir::cir::CallingConv CC = FI.getCallingConvention();
 
     bool cxxabiHit = getCXXABI().classifyReturnType(FI);
     assert(!cxxabiHit && "C++ ABI not considered");
 
     FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
 
     for (auto &I : FI.arguments()) {
-      if (CC == llvm::CallingConv::SPIR_KERNEL) {
+      if (CC == mlir::cir::CallingConv::SpirKernel) {
         I.info = classifyKernelArgumentType(I.type);
       } else {
         I.info = classifyArgumentType(I.type);
@@ -277,8 +277,8 @@ class CommonSPIRTargetCIRGenInfo : public TargetCIRGenInfo {
         mlir::cir::AddressSpaceAttr::Kind::offload_private);
   }
 
-  unsigned getOpenCLKernelCallingConv() const override {
-    return llvm::CallingConv::SPIR_KERNEL;
+  mlir::cir::CallingConv getOpenCLKernelCallingConv() const override {
+    return mlir::cir::CallingConv::SpirKernel;
   }
 };
 

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -81,8 +81,8 @@ class TargetCIRGenInfo {
                                            mlir::Type DestTy,
                                            bool IsNonNull = false) const;
 
-  /// Get LLVM calling convention for OpenCL kernel.
-  virtual unsigned getOpenCLKernelCallingConv() const {
+  /// Get CIR calling convention for OpenCL kernel.
+  virtual mlir::cir::CallingConv getOpenCLKernelCallingConv() const {
     // OpenCL kernels are called via an explicit runtime API with arguments
     // set with clSetKernelArg(), not as normal sub-functions.
     // Return SPIR_KERNEL by default as the kernel calling convention to
@@ -93,7 +93,7 @@ class TargetCIRGenInfo {
     // clSetKernelArg() might break depending on the target-specific
     // conventions; different targets might split structs passed as values
     // to multiple function arguments etc.
-    return llvm::CallingConv::SPIR_KERNEL;
+    return mlir::cir::CallingConv::SpirKernel;
   }
 
   virtual ~TargetCIRGenInfo() {}