[CIR] [Lowering] [X86_64] Support VAArg in shape (#1100)

This patch implements transformations for VAArg in X86_64 ABI **in
shape**. `In shape` means it can't work properly due to the dependent
X86_64 ABI is not robust. e.g., when we want to use VAArg with `long
double`, we need #1087.

This patch literally implement
https://github.com/llvm/llvm-project/blob/d233fedfb0de882353c348cd1ac57dab619efa6d/clang/lib/CodeGen/Targets/X86.cpp#L3015-L3240
in CIR.

There some differences due to the traditional pipeline are converting
AST to LLVM and we're transforming CIR to CIR. And also to get the ABI
Info, I moved `X86_64ABIInfo` to the header.

Author: ChuanqiXu9

clang/include/clang/CIR/ABIArgInfo.h

@@ -252,6 +252,8 @@ class ABIArgInfo {
   bool isExpand() const { return TheKind == Expand; }
   bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; }
 
+  bool isIgnore() const { return TheKind == Ignore; }
+
   bool isSignExt() const {
     assert(isExtend() && "Invalid kind!");
     return SignExt;

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -48,6 +48,17 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return create<cir::ConstantOp>(loc, ty, getAttr<cir::IntAttr>(ty, val));
   }
 
+  mlir::Value getSignedInt(mlir::Location loc, int64_t val, unsigned numBits) {
+    return getConstAPSInt(
+        loc, llvm::APSInt(llvm::APInt(numBits, val), /*isUnsigned=*/false));
+  }
+
+  mlir::Value getUnsignedInt(mlir::Location loc, uint64_t val,
+                             unsigned numBits) {
+    return getConstAPSInt(
+        loc, llvm::APSInt(llvm::APInt(numBits, val), /*isUnsigned=*/true));
+  }
+
   mlir::Value getConstAPInt(mlir::Location loc, mlir::Type typ,
                             const llvm::APInt &val) {
     return create<cir::ConstantOp>(loc, typ, getAttr<cir::IntAttr>(typ, val));

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -4494,6 +4494,26 @@ def AssumeSepStorageOp : CIR_Op<"assume.separate_storage", [SameTypeOperands]> {
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// PtrMask Operations
+//===----------------------------------------------------------------------===//
+
+def PtrMaskOp : CIR_Op<"ptr_mask", [AllTypesMatch<["ptr", "result"]>]> {
+  let summary = "Masks out bits of the pointer according to a mask";
+  let description = [{
+    The `cir.ptr_mask` operation takes a pointer and an interger `mask` as its
+    argument and return the masked pointer type according to the `mask`.
+  }];
+
+  let arguments = (ins CIR_PointerType:$ptr,
+                       CIR_IntType:$mask);
+  let results = (outs CIR_PointerType:$result);
+
+  let assemblyFormat = [{
+    `(` $ptr `,` $mask `:` type($mask) `)` `:` qualified(type($result)) attr-dict
+  }];
+}
+
 //===----------------------------------------------------------------------===//
 // Branch Probability Operations
 //===----------------------------------------------------------------------===//

clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp

@@ -124,9 +124,16 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> {
 
   void setASTContext(clang::ASTContext *c) {
     astCtx = c;
-    auto abiStr = c->getTargetInfo().getABI();
+    const clang::TargetInfo &target = c->getTargetInfo();
+    auto abiStr = target.getABI();
     switch (c->getCXXABIKind()) {
     case clang::TargetCXXABI::GenericItanium:
+      if (target.getTriple().getArch() == llvm::Triple::x86_64) {
+        cxxABI.reset(
+            cir::LoweringPrepareCXXABI::createX86ABI(/*is64bit=*/true));
+        break;
+      }
+
       cxxABI.reset(cir::LoweringPrepareCXXABI::createItaniumABI());
       break;
     case clang::TargetCXXABI::GenericAArch64:

clang/lib/CIR/Dialect/Transforms/LoweringPrepareCXXABI.h

@@ -28,6 +28,7 @@ class LoweringPrepareCXXABI {
 public:
   static LoweringPrepareCXXABI *createItaniumABI();
   static LoweringPrepareCXXABI *createAArch64ABI(cir::AArch64ABIKind k);
+  static LoweringPrepareCXXABI *createX86ABI(bool is64Bit);
 
   virtual mlir::Value lowerVAArg(CIRBaseBuilderTy &builder, cir::VAArgOp op,
                                  const cir::CIRDataLayout &datalayout) = 0;

clang/lib/CIR/Dialect/Transforms/LoweringPrepareX86ABI.h

@@ -36,6 +36,18 @@ bool isAggregateTypeForABI(mlir::Type T) {
   return !LowerFunction::hasScalarEvaluationKind(T);
 }
 
+mlir::Value emitRoundPointerUpToAlignment(cir::CIRBaseBuilderTy &builder,
+                                          mlir::Value ptr, unsigned alignment) {
+  // OverflowArgArea = (OverflowArgArea + Align - 1) & -Align;
+  mlir::Location loc = ptr.getLoc();
+  mlir::Value roundUp = builder.createPtrStride(
+      loc, builder.createPtrBitcast(ptr, builder.getUIntNTy(8)),
+      builder.getUnsignedInt(loc, alignment - 1, /*width=*/32));
+  return builder.create<cir::PtrMaskOp>(
+      loc, roundUp.getType(), roundUp,
+      builder.getSignedInt(loc, -alignment, /*width=*/32));
+}
+
 mlir::Type useFirstFieldIfTransparentUnion(mlir::Type Ty) {
   if (auto RT = mlir::dyn_cast<StructType>(Ty)) {
     if (RT.isUnion())

clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.cpp

@@ -25,6 +25,9 @@ bool classifyReturnType(const CIRCXXABI &CXXABI, LowerFunctionInfo &FI,
 
 bool isAggregateTypeForABI(mlir::Type T);
 
+mlir::Value emitRoundPointerUpToAlignment(cir::CIRBaseBuilderTy &builder,
+                                          mlir::Value ptr, unsigned alignment);
+
 /// Pass transparent unions as if they were the type of the first element. Sema
 /// should ensure that all elements of the union have the same "machine type".
 mlir::Type useFirstFieldIfTransparentUnion(mlir::Type Ty);

clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.h

@@ -66,23 +66,4 @@ CIRCXXABI *CreateItaniumCXXABI(LowerModule &CGM);
 
 } // namespace cir
 
-// FIXME(cir): Merge this into the CIRCXXABI class above. To do so, this code
-// should be updated to follow some level of codegen parity.
-namespace cir {
-
-class LoweringPrepareCXXABI {
-public:
-  static LoweringPrepareCXXABI *createItaniumABI();
-  static LoweringPrepareCXXABI *createAArch64ABI(cir::AArch64ABIKind k);
-
-  virtual mlir::Value lowerVAArg(CIRBaseBuilderTy &builder, cir::VAArgOp op,
-                                 const cir::CIRDataLayout &datalayout) = 0;
-  virtual ~LoweringPrepareCXXABI() {}
-
-  virtual mlir::Value lowerDynamicCast(CIRBaseBuilderTy &builder,
-                                       clang::ASTContext &astCtx,
-                                       cir::DynamicCastOp op) = 0;
-};
-} // namespace cir
-
 #endif // LLVM_CLANG_LIB_CIR_DIALECT_TRANSFORMS_TARGETLOWERING_CIRCXXABI_H

clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRCXXABI.h

@@ -17,6 +17,7 @@ add_clang_library(TargetLowering
   Targets/X86.cpp
   Targets/LoweringPrepareAArch64CXXABI.cpp
   Targets/LoweringPrepareItaniumCXXABI.cpp
+  Targets/LoweringPrepareX86CXXABI.cpp
 
   DEPENDS
   clangBasic