[CIR][AMDGPU] Add basic ABI implementation of AMDGPU for CIR->LLVMIR

Author: skc7

clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/AMDGPU.cpp

@@ -34,9 +34,15 @@ class AMDGPUABIInfo : public ABIInfo {
   AMDGPUABIInfo(LowerTypes &lt) : ABIInfo(lt) {}
 
 private:
-  void computeInfo(LowerFunctionInfo &fi) const override {
-    llvm_unreachable("NYI");
-  }
+  static const unsigned MaxNumRegsForArgsRet = 16;
+
+  unsigned numRegsForType(mlir::Type ty) const;
+
+  ABIArgInfo classifyReturnType(mlir::Type ty) const;
+  ABIArgInfo classifyArgumentType(mlir::Type ty, bool Variadic,
+                                  unsigned &NumRegsLeft) const;
+  ABIArgInfo classifyKernelArgumentType(mlir::Type ty) const;
+  void computeInfo(LowerFunctionInfo &fi) const override;
 };
 
 class AMDGPUTargetLoweringInfo : public TargetLoweringInfo {
@@ -63,7 +69,96 @@ class AMDGPUTargetLoweringInfo : public TargetLoweringInfo {
   }
 };
 
+// Estimate the number of registers the type will use
+unsigned AMDGPUABIInfo::numRegsForType(mlir::Type ty) const {
+  uint64_t size = getContext().getTypeSize(ty);
+  return (size + 31) / 32;
+}
+
+ABIArgInfo AMDGPUABIInfo::classifyReturnType(mlir::Type ty) const {
+  if (isAggregateTypeForABI(ty)) {
+    llvm_unreachable(
+        "classifyReturnType for aggregate types is NYI for AMDGPU");
+  }
+
+  if (isPromotableIntegerTypeForABI(ty))
+    return ABIArgInfo::getExtend(ty);
+
+  return ABIArgInfo::getDirect();
+}
+
+ABIArgInfo AMDGPUABIInfo::classifyArgumentType(mlir::Type ty, bool Variadic,
+                                               unsigned &NumRegsLeft) const {
+  assert(NumRegsLeft <= MaxNumRegsForArgsRet && "register estimate underflow");
+
+  ty = useFirstFieldIfTransparentUnion(ty);
+
+  if (isAggregateTypeForABI(ty)) {
+    llvm_unreachable(
+        "classifyArgumentType for aggregate types is NYI for AMDGPU");
+  }
+
+  // Variadic arguments are always passed by-value in a single register or on
+  // stack
+  if (Variadic) {
+    return ABIArgInfo::getDirect(/*T=*/nullptr,
+                                 /*Offset=*/0,
+                                 /*Padding=*/nullptr,
+                                 /*CanBeFlattened=*/false,
+                                 /*Align=*/0);
+  }
+
+  // Otherwise do default classification
+  ABIArgInfo ArgInfo =
+      (isPromotableIntegerTypeForABI(ty) ? ABIArgInfo::getExtend(ty)
+                                         : ABIArgInfo::getDirect());
+
+  // Track register usage
+  if (!ArgInfo.isIndirect()) {
+    unsigned NumRegs = numRegsForType(ty);
+    NumRegsLeft -= std::min(NumRegs, NumRegsLeft);
+  }
+
+  return ArgInfo;
+}
+
+ABIArgInfo AMDGPUABIInfo::classifyKernelArgumentType(mlir::Type ty) const {
+  ty = useFirstFieldIfTransparentUnion(ty);
+
+  // Aggregate types are not yet supported
+  if (isAggregateTypeForABI(ty)) {
+    llvm_unreachable("Aggregate types NYI for AMDGPU kernel arguments");
+  }
+
+  // If we set CanBeFlattened to true, CodeGen will expand the struct to its
+  // individual elements, which confuses the Clover OpenCL backend; therefore we
+  // have to set it to false here. Other args of getDirect() are just defaults.
+  return ABIArgInfo::getDirect(/*T=*/nullptr, /*Offset=*/0, /*Padding=*/nullptr,
+                               /*CanBeFlattened=*/false);
+}
+
+void AMDGPUABIInfo::computeInfo(LowerFunctionInfo &fi) const {
+  const unsigned CC = fi.getCallingConvention();
+
+  if (!getCXXABI().classifyReturnType(fi))
+    fi.getReturnInfo() = classifyReturnType(fi.getReturnType());
+
+  unsigned ArgumentIndex = 0;
+  const unsigned NumFixedArguments = fi.getNumRequiredArgs();
+
+  unsigned NumRegsLeft = MaxNumRegsForArgsRet;
+  for (auto &arg : fi.arguments()) {
+    if (CC == llvm::CallingConv::AMDGPU_KERNEL) {
+      arg.info = classifyKernelArgumentType(arg.type);
+    } else {
+      bool FixedArgument = ArgumentIndex++ < NumFixedArguments;
+      arg.info = classifyArgumentType(arg.type, !FixedArgument, NumRegsLeft);
+    }
+  }
+}
+
 } // namespace
+
 std::unique_ptr<TargetLoweringInfo>
 createAMDGPUTargetLoweringInfo(LowerModule &lowerModule) {
   return std::make_unique<AMDGPUTargetLoweringInfo>(lowerModule.getTypes());