[CIR][NFC] move data member pointer lowering to CXXABI (#1130)

This PR moves the lowering code for data member pointers from the
conversion patterns to the implementation of CXXABI because this part
should be ABI-specific.

Author: Lancern

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

@@ -15,9 +15,15 @@
 #define LLVM_CLANG_LIB_CIR_DIALECT_TRANSFORMS_TARGETLOWERING_CIRCXXABI_H
 
 #include "LowerFunctionInfo.h"
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
+#include "mlir/Interfaces/DataLayoutInterfaces.h"
+#include "mlir/Transforms/DialectConversion.h"
 #include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h"
+#include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDataLayout.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include "clang/CIR/Target/AArch64.h"
 
 namespace cir {
@@ -59,6 +65,26 @@ class CIRCXXABI {
   /// Returns how an argument of the given record type should be passed.
   /// FIXME(cir): This expects a CXXRecordDecl! Not any record type.
   virtual RecordArgABI getRecordArgABI(const StructType RD) const = 0;
+
+  /// Lower the given data member pointer type to its ABI type. The returned
+  /// type is also a CIR type.
+  virtual mlir::Type
+  lowerDataMemberType(cir::DataMemberType type,
+                      const mlir::TypeConverter &typeConverter) const = 0;
+
+  /// Lower the given data member pointer constant to a constant of the ABI
+  /// type. The returned constant is represented as an attribute as well.
+  virtual mlir::TypedAttr
+  lowerDataMemberConstant(cir::DataMemberAttr attr,
+                          const mlir::DataLayout &layout,
+                          const mlir::TypeConverter &typeConverter) const = 0;
+
+  /// Lower the given cir.get_runtime_member op to a sequence of more
+  /// "primitive" CIR operations that act on the ABI types.
+  virtual mlir::Operation *
+  lowerGetRuntimeMember(cir::GetRuntimeMemberOp op, mlir::Type loweredResultTy,
+                        mlir::Value loweredAddr, mlir::Value loweredMember,
+                        mlir::OpBuilder &builder) const = 0;
 };
 
 /// Creates an Itanium-family ABI.

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

@@ -23,6 +23,7 @@
 #include "../LoweringPrepareCXXABI.h"
 #include "CIRCXXABI.h"
 #include "LowerModule.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace cir {
@@ -51,6 +52,19 @@ class ItaniumCXXABI : public CIRCXXABI {
     cir_cconv_assert(!cir::MissingFeatures::recordDeclCanPassInRegisters());
     return RAA_Default;
   }
+
+  mlir::Type
+  lowerDataMemberType(cir::DataMemberType type,
+                      const mlir::TypeConverter &typeConverter) const override;
+
+  mlir::TypedAttr lowerDataMemberConstant(
+      cir::DataMemberAttr attr, const mlir::DataLayout &layout,
+      const mlir::TypeConverter &typeConverter) const override;
+
+  mlir::Operation *
+  lowerGetRuntimeMember(cir::GetRuntimeMemberOp op, mlir::Type loweredResultTy,
+                        mlir::Value loweredAddr, mlir::Value loweredMember,
+                        mlir::OpBuilder &builder) const override;
 };
 
 } // namespace
@@ -67,6 +81,54 @@ bool ItaniumCXXABI::classifyReturnType(LowerFunctionInfo &FI) const {
   return false;
 }
 
+mlir::Type ItaniumCXXABI::lowerDataMemberType(
+    cir::DataMemberType type, const mlir::TypeConverter &typeConverter) const {
+  // Itanium C++ ABI 2.3:
+  //   A pointer to data member is an offset from the base address of
+  //   the class object containing it, represented as a ptrdiff_t
+  const clang::TargetInfo &target = LM.getTarget();
+  clang::TargetInfo::IntType ptrdiffTy =
+      target.getPtrDiffType(clang::LangAS::Default);
+  return cir::IntType::get(type.getContext(), target.getTypeWidth(ptrdiffTy),
+                           target.isTypeSigned(ptrdiffTy));
+}
+
+mlir::TypedAttr ItaniumCXXABI::lowerDataMemberConstant(
+    cir::DataMemberAttr attr, const mlir::DataLayout &layout,
+    const mlir::TypeConverter &typeConverter) const {
+  uint64_t memberOffset;
+  if (attr.isNullPtr()) {
+    // Itanium C++ ABI 2.3:
+    //   A NULL pointer is represented as -1.
+    memberOffset = -1ull;
+  } else {
+    // Itanium C++ ABI 2.3:
+    //   A pointer to data member is an offset from the base address of
+    //   the class object containing it, represented as a ptrdiff_t
+    auto memberIndex = attr.getMemberIndex().value();
+    memberOffset =
+        attr.getType().getClsTy().getElementOffset(layout, memberIndex);
+  }
+
+  mlir::Type abiTy = lowerDataMemberType(attr.getType(), typeConverter);
+  return cir::IntAttr::get(abiTy, memberOffset);
+}
+
+mlir::Operation *ItaniumCXXABI::lowerGetRuntimeMember(
+    cir::GetRuntimeMemberOp op, mlir::Type loweredResultTy,
+    mlir::Value loweredAddr, mlir::Value loweredMember,
+    mlir::OpBuilder &builder) const {
+  auto byteTy = IntType::get(op.getContext(), 8, true);
+  auto bytePtrTy = PointerType::get(
+      byteTy, mlir::cast<PointerType>(op.getAddr().getType()).getAddrSpace());
+  auto objectBytesPtr = builder.create<CastOp>(op.getLoc(), bytePtrTy,
+                                               CastKind::bitcast, op.getAddr());
+  auto memberBytesPtr = builder.create<PtrStrideOp>(
+      op.getLoc(), bytePtrTy, objectBytesPtr, loweredMember);
+  return builder.create<CastOp>(op.getLoc(), op.getType(), CastKind::bitcast,
+                                memberBytesPtr);
+}
+
 CIRCXXABI *CreateItaniumCXXABI(LowerModule &LM) {
   switch (LM.getCXXABIKind()) {
   // Note that AArch64 uses the generic ItaniumCXXABI class since it doesn't

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -1521,28 +1521,6 @@ bool hasTrailingZeros(cir::ConstArrayAttr attr) {
           }));
 }
 
-static mlir::Attribute
-lowerDataMemberAttr(mlir::ModuleOp moduleOp, cir::DataMemberAttr attr,
-                    const mlir::TypeConverter &typeConverter) {
-  mlir::DataLayout layout{moduleOp};
-
-  uint64_t memberOffset;
-  if (attr.isNullPtr()) {
-    // TODO(cir): the numerical value of a null data member pointer is
-    // ABI-specific and should be queried through ABI.
-    assert(!MissingFeatures::targetCodeGenInfoGetNullPointer());
-    memberOffset = -1ull;
-  } else {
-    auto memberIndex = attr.getMemberIndex().value();
-    memberOffset =
-        attr.getType().getClsTy().getElementOffset(layout, memberIndex);
-  }
-
-  auto underlyingIntTy = mlir::IntegerType::get(
-      moduleOp->getContext(), layout.getTypeSizeInBits(attr.getType()));
-  return mlir::IntegerAttr::get(underlyingIntTy, memberOffset);
-}
-
 mlir::LogicalResult CIRToLLVMConstantOpLowering::matchAndRewrite(
     cir::ConstantOp op, OpAdaptor adaptor,
     mlir::ConversionPatternRewriter &rewriter) const {
@@ -1602,9 +1580,13 @@ mlir::LogicalResult CIRToLLVMConstantOpLowering::matchAndRewrite(
     }
     attr = op.getValue();
   } else if (mlir::isa<cir::DataMemberType>(op.getType())) {
+    assert(lowerMod && "lower module is not available");
     auto dataMember = mlir::cast<cir::DataMemberAttr>(op.getValue());
-    attr = lowerDataMemberAttr(op->getParentOfType<mlir::ModuleOp>(),
-                               dataMember, *typeConverter);
+    mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
+    mlir::TypedAttr abiValue = lowerMod->getCXXABI().lowerDataMemberConstant(
+        dataMember, layout, *typeConverter);
+    rewriter.replaceOpWithNewOp<ConstantOp>(op, abiValue);
+    return mlir::success();
   }
   // TODO(cir): constant arrays are currently just pushed into the stack using
   // the store instruction, instead of being stored as global variables and
@@ -2208,8 +2190,15 @@ mlir::LogicalResult CIRToLLVMGlobalOpLowering::matchAndRewrite(
     return mlir::success();
   } else if (auto dataMemberAttr =
                  mlir::dyn_cast<cir::DataMemberAttr>(init.value())) {
-    init = lowerDataMemberAttr(op->getParentOfType<mlir::ModuleOp>(),
-                               dataMemberAttr, *typeConverter);
+    assert(lowerMod && "lower module is not available");
+    mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
+    mlir::TypedAttr abiValue = lowerMod->getCXXABI().lowerDataMemberConstant(
+        dataMemberAttr, layout, *typeConverter);
+    auto abiOp = mlir::cast<GlobalOp>(rewriter.clone(*op.getOperation()));
+    abiOp.setInitialValueAttr(abiValue);
+    abiOp.setSymType(abiValue.getType());
+    rewriter.replaceOp(op, abiOp);
+    return mlir::success();
   } else if (const auto structAttr =
                  mlir::dyn_cast<cir::ConstStructAttr>(init.value())) {
     setupRegionInitializedLLVMGlobalOp(op, rewriter);
@@ -3237,11 +3226,11 @@ mlir::LogicalResult CIRToLLVMGetMemberOpLowering::matchAndRewrite(
 mlir::LogicalResult CIRToLLVMGetRuntimeMemberOpLowering::matchAndRewrite(
     cir::GetRuntimeMemberOp op, OpAdaptor adaptor,
     mlir::ConversionPatternRewriter &rewriter) const {
-  auto llvmResTy = getTypeConverter()->convertType(op.getType());
-  auto llvmElementTy = mlir::IntegerType::get(op.getContext(), 8);
-
-  rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(
-      op, llvmResTy, llvmElementTy, adaptor.getAddr(), adaptor.getMember());
+  assert(lowerMod && "lowering module is not available");
+  mlir::Type llvmResTy = getTypeConverter()->convertType(op.getType());
+  mlir::Operation *llvmOp = lowerMod->getCXXABI().lowerGetRuntimeMember(
+      op, llvmResTy, adaptor.getAddr(), adaptor.getMember(), rewriter);
+  rewriter.replaceOp(op, llvmOp);
   return mlir::success();
 }
 
@@ -3850,14 +3839,17 @@ mlir::LogicalResult CIRToLLVMSignBitOpLowering::matchAndRewrite(
 
 void populateCIRToLLVMConversionPatterns(
     mlir::RewritePatternSet &patterns, mlir::TypeConverter &converter,
-    mlir::DataLayout &dataLayout,
+    mlir::DataLayout &dataLayout, cir::LowerModule *lowerModule,
     llvm::StringMap<mlir::LLVM::GlobalOp> &stringGlobalsMap,
     llvm::StringMap<mlir::LLVM::GlobalOp> &argStringGlobalsMap,
     llvm::MapVector<mlir::ArrayAttr, mlir::LLVM::GlobalOp> &argsVarMap) {
   patterns.add<CIRToLLVMReturnOpLowering>(patterns.getContext());
   patterns.add<CIRToLLVMAllocaOpLowering>(converter, dataLayout,
                                           stringGlobalsMap, argStringGlobalsMap,
                                           argsVarMap, patterns.getContext());
+  patterns.add<CIRToLLVMConstantOpLowering, CIRToLLVMGlobalOpLowering,
+               CIRToLLVMGetRuntimeMemberOpLowering>(
+      converter, patterns.getContext(), lowerModule);
   patterns.add<
       // clang-format off
       CIRToLLVMAbsOpLowering,
@@ -3891,7 +3883,6 @@ void populateCIRToLLVMConversionPatterns(
       CIRToLLVMComplexImagPtrOpLowering,
       CIRToLLVMComplexRealOpLowering,
       CIRToLLVMComplexRealPtrOpLowering,
-      CIRToLLVMConstantOpLowering,
       CIRToLLVMCopyOpLowering,
       CIRToLLVMDerivedClassAddrOpLowering,
       CIRToLLVMEhInflightOpLowering,
@@ -3902,8 +3893,6 @@ void populateCIRToLLVMConversionPatterns(
       CIRToLLVMGetBitfieldOpLowering,
       CIRToLLVMGetGlobalOpLowering,
       CIRToLLVMGetMemberOpLowering,
-      CIRToLLVMGetRuntimeMemberOpLowering,
-      CIRToLLVMGlobalOpLowering,
       CIRToLLVMInlineAsmOpLowering,
       CIRToLLVMIsConstantOpLowering,
       CIRToLLVMIsFPClassOpLowering,
@@ -3990,10 +3979,13 @@ void prepareTypeConverter(mlir::LLVMTypeConverter &converter,
 
         return mlir::LLVM::LLVMPointerType::get(type.getContext(), targetAS);
       });
-  converter.addConversion([&](cir::DataMemberType type) -> mlir::Type {
-    return mlir::IntegerType::get(type.getContext(),
-                                  dataLayout.getTypeSizeInBits(type));
-  });
+  converter.addConversion(
+      [&, lowerModule](cir::DataMemberType type) -> mlir::Type {
+        assert(lowerModule && "CXXABI is not available");
+        mlir::Type abiType =
+            lowerModule->getCXXABI().lowerDataMemberType(type, converter);
+        return converter.convertType(abiType);
+      });
   converter.addConversion([&](cir::ArrayType type) -> mlir::Type {
     auto ty = converter.convertType(type.getEltType());
     return mlir::LLVM::LLVMArrayType::get(ty, type.getSize());
@@ -4328,8 +4320,8 @@ void ConvertCIRToLLVMPass::runOnOperation() {
   llvm::MapVector<mlir::ArrayAttr, mlir::LLVM::GlobalOp> argsVarMap;
 
   populateCIRToLLVMConversionPatterns(patterns, converter, dataLayout,
-                                      stringGlobalsMap, argStringGlobalsMap,
-                                      argsVarMap);
+                                      lowerModule.get(), stringGlobalsMap,
+                                      argStringGlobalsMap, argsVarMap);
   mlir::populateFuncToLLVMConversionPatterns(converter, patterns);
 
   mlir::ConversionTarget target(getContext());

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h

@@ -291,8 +291,15 @@ class CIRToLLVMStoreOpLowering
 
 class CIRToLLVMConstantOpLowering
     : public mlir::OpConversionPattern<cir::ConstantOp> {
+  cir::LowerModule *lowerMod;
+
 public:
-  using mlir::OpConversionPattern<cir::ConstantOp>::OpConversionPattern;
+  CIRToLLVMConstantOpLowering(const mlir::TypeConverter &typeConverter,
+                              mlir::MLIRContext *context,
+                              cir::LowerModule *lowerModule)
+      : OpConversionPattern(typeConverter, context), lowerMod(lowerModule) {
+    setHasBoundedRewriteRecursion();
+  }
 
   mlir::LogicalResult
   matchAndRewrite(cir::ConstantOp op, OpAdaptor,
@@ -490,8 +497,15 @@ class CIRToLLVMSwitchFlatOpLowering
 
 class CIRToLLVMGlobalOpLowering
     : public mlir::OpConversionPattern<cir::GlobalOp> {
+  cir::LowerModule *lowerMod;
+
 public:
-  using mlir::OpConversionPattern<cir::GlobalOp>::OpConversionPattern;
+  CIRToLLVMGlobalOpLowering(const mlir::TypeConverter &typeConverter,
+                            mlir::MLIRContext *context,
+                            cir::LowerModule *lowerModule)
+      : OpConversionPattern(typeConverter, context), lowerMod(lowerModule) {
+    setHasBoundedRewriteRecursion();
+  }
 
   mlir::LogicalResult
   matchAndRewrite(cir::GlobalOp op, OpAdaptor,
@@ -774,8 +788,13 @@ class CIRToLLVMGetMemberOpLowering
 
 class CIRToLLVMGetRuntimeMemberOpLowering
     : public mlir::OpConversionPattern<cir::GetRuntimeMemberOp> {
+  cir::LowerModule *lowerMod;
+
 public:
-  using mlir::OpConversionPattern<cir::GetRuntimeMemberOp>::OpConversionPattern;
+  CIRToLLVMGetRuntimeMemberOpLowering(const mlir::TypeConverter &typeConverter,
+                                      mlir::MLIRContext *context,
+                                      cir::LowerModule *lowerModule)
+      : OpConversionPattern(typeConverter, context), lowerMod(lowerModule) {}
 
   mlir::LogicalResult
   matchAndRewrite(cir::GetRuntimeMemberOp op, OpAdaptor,

clang/test/CIR/Lowering/data-member.cir

@@ -5,7 +5,10 @@
 !s64i = !cir.int<s, 64>
 !structT = !cir.struct<struct "Point" {!cir.int<s, 32>, !cir.int<s, 32>, !cir.int<s, 32>}>
 
-module @test {
+module @test attributes {
+  cir.triple = "x86_64-unknown-linux-gnu",
+  llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
+} {
   cir.global external @pt_member = #cir.data_member<1> : !cir.data_member<!s32i in !structT>
   // MLIR: llvm.mlir.global external @pt_member(4 : i64) {addr_space = 0 : i32} : i64
   // LLVM: @pt_member = global i64 4
@@ -15,8 +18,8 @@ module @test {
     cir.return %0 : !cir.data_member<!s32i in !structT>
   }
   //      MLIR: llvm.func @constant() -> i64
-  // MLIR-NEXT:   %0 = llvm.mlir.constant(4 : i64) : i64
-  // MLIR-NEXT:   llvm.return %0 : i64
+  // MLIR-NEXT:   %[[#VAL:]] = llvm.mlir.constant(4 : i64) : i64
+  // MLIR-NEXT:   llvm.return %[[#VAL]] : i64
   // MLIR-NEXT: }
 
   //      LLVM: define i64 @constant()
@@ -28,8 +31,8 @@ module @test {
     cir.return %0 : !cir.data_member<!s32i in !structT>
   }
   //      MLIR: llvm.func @null_constant() -> i64
-  // MLIR-NEXT:   %0 = llvm.mlir.constant(-1 : i64) : i64
-  // MLIR-NEXT:   llvm.return %0 : i64
+  // MLIR-NEXT:   %[[#VAL:]] = llvm.mlir.constant(-1 : i64) : i64
+  // MLIR-NEXT:   llvm.return %[[#VAL]] : i64
   // MLIR-NEXT: }
 
   //      LLVM: define i64 @null_constant() !dbg !7 {
@@ -40,13 +43,15 @@ module @test {
     %0 = cir.get_runtime_member %arg0[%arg1 : !cir.data_member<!s32i in !structT>] : !cir.ptr<!structT> -> !cir.ptr<!s32i>
     cir.return %0 : !cir.ptr<!s32i>
   }
-  //      MLIR: llvm.func @get_runtime_member(%arg0: !llvm.ptr, %arg1: i64) -> !llvm.ptr
-  // MLIR-NEXT:   %0 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr, i64) -> !llvm.ptr, i8
-  // MLIR-NEXT:   llvm.return %0 : !llvm.ptr
+  //      MLIR: llvm.func @get_runtime_member(%[[ARG0:.+]]: !llvm.ptr, %[[ARG1:.+]]: i64) -> !llvm.ptr
+  // MLIR-NEXT:   %[[#PTR:]] = llvm.bitcast %[[ARG0]] : !llvm.ptr to !llvm.ptr
+  // MLIR-NEXT:   %[[#VAL:]] = llvm.getelementptr %[[#PTR]][%[[ARG1]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8
+  // MLIR-NEXT:   %[[#RET:]] = llvm.bitcast %[[#VAL]] : !llvm.ptr to !llvm.ptr
+  // MLIR-NEXT:   llvm.return %[[#RET]] : !llvm.ptr
   // MLIR-NEXT: }
 
-  //      LLVM: define ptr @get_runtime_member(ptr %0, i64 %1)
-  // LLVM-NEXT:   %3 = getelementptr i8, ptr %0, i64 %1
-  // LLVM-NEXT:   ret ptr %3
+  //      LLVM: define ptr @get_runtime_member(ptr %[[ARG0:.+]], i64 %[[ARG1:.+]])
+  // LLVM-NEXT:   %[[#VAL:]] = getelementptr i8, ptr %[[ARG0]], i64 %[[ARG1]]
+  // LLVM-NEXT:   ret ptr %[[#VAL]]
   // LLVM-NEXT: }
 }