[CIR][WIP] Add ABI lowering pass

Lancern · Lancern · commit 352959fdf2ba · 2025-03-12T22:25:42.000+08:00
This patch adds a new pass cir-abi-lowering to the CIR dialect. This pass runs
before the CallConvLowering pass, and it expands all ABI-dependent types and
operations inside a function to their ABI-independent equivalences according to
the ABI specification.

This patch also moves the lowering code of the following types and operations
from the LLVM lowering conversion to the new pass:
  - The pointer-to-data-member type `cir.data_member`;
  - The pointer-to-member-function type `cir.method`;
  - All operations working on operands of the above types.
diff --git a/clang/include/clang/CIR/Dialect/Passes.h b/clang/include/clang/CIR/Dialect/Passes.h
@@ -40,6 +40,9 @@ std::unique_ptr<Pass> createFlattenCFGPass();
 std::unique_ptr<Pass> createHoistAllocasPass();
 std::unique_ptr<Pass> createGotoSolverPass();
 
+/// Create a pass to expand ABI-dependent types and operations.
+std::unique_ptr<Pass> createABILoweringPass();
+
 /// Create a pass to lower ABI-independent function definitions/calls.
 std::unique_ptr<Pass> createCallConvLoweringPass();
 
diff --git a/clang/include/clang/CIR/Dialect/Passes.td b/clang/include/clang/CIR/Dialect/Passes.td
@@ -180,6 +180,27 @@ def LibOpt : Pass<"cir-lib-opt"> {
   ];
 }
 
+def ABILowering : Pass<"cir-abi-lowering"> {
+  let summary = "Expands ABI-dependent types and operations";
+  let description = [{
+    This pass expands ABI-dependent CIR types and operations to more "primitive"
+    ABI-independent CIR types and operations according to the target ABI
+    specification.
+
+    Some CIR types, such as pointers to members, may have different layouts and
+    representations under different target ABIs. This pass expands these types
+    to their underlying representations as specified by the target ABI. For
+    example, when targeting Itanium ABI, this pass will replace pointers to
+    member functions with a struct with two ptrdiff_t fields.
+
+    Similarly, some CIR operations may also behave differently under different
+    target ABIs. This pass also expands these operations to more "primitive"
+    CIR operations as specified by the target ABI.
+  }];
+  let constructor = "mlir::createABILoweringPass()";
+  let dependentDialects = ["cir::CIRDialect"];
+}
+
 def CallConvLowering : Pass<"cir-call-conv-lowering"> {
   let summary = "Handle calling conventions for CIR functions";
   let description = [{
diff --git a/clang/lib/CIR/CodeGen/CIRPasses.cpp b/clang/lib/CIR/CodeGen/CIRPasses.cpp
@@ -97,6 +97,7 @@ mlir::LogicalResult runCIRToCIRPasses(
 namespace mlir {
 
 void populateCIRPreLoweringPasses(OpPassManager &pm, bool useCCLowering) {
+  pm.addPass(createABILoweringPass());
   if (useCCLowering)
     pm.addPass(createCallConvLoweringPass());
   pm.addPass(createHoistAllocasPass());
diff --git a/clang/lib/CIR/Dialect/Transforms/ABILowering.cpp b/clang/lib/CIR/Dialect/Transforms/ABILowering.cpp
@@ -0,0 +1,305 @@
+//===- ABILowering.cpp - Expands ABI-dependent types and operations -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the CIR ABI lowering pass which expands ABI-dependent
+// types and operations to equivalent ABI-independent types and operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TargetLowering/LowerModule.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/DataLayoutInterfaces.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "clang/CIR/Dialect/IR/CIRDialect.h"
+#include "clang/CIR/Dialect/Passes.h"
+
+#define GEN_PASS_DEF_ABILOWERING
+#include "clang/CIR/Dialect/Passes.h.inc"
+
+namespace cir {
+namespace {
+
+template <typename Op>
+class CIROpABILoweringPattern : public mlir::OpConversionPattern<Op> {
+protected:
+  mlir::DataLayout *dataLayout;
+  cir::LowerModule *lowerModule;
+
+public:
+  CIROpABILoweringPattern(mlir::MLIRContext *context,
+                          const mlir::TypeConverter &typeConverter,
+                          mlir::DataLayout &dataLayout,
+                          cir::LowerModule &lowerModule)
+      : mlir::OpConversionPattern<Op>(typeConverter, context),
+        dataLayout(&dataLayout), lowerModule(&lowerModule) {}
+};
+
+#define CIR_ABI_LOWERING_PATTERN(name, operation)                              \
+  struct name : CIROpABILoweringPattern<operation> {                           \
+    using CIROpABILoweringPattern<operation>::CIROpABILoweringPattern;         \
+                                                                               \
+    mlir::LogicalResult                                                        \
+    matchAndRewrite(operation op, OpAdaptor adaptor,                           \
+                    mlir::ConversionPatternRewriter &rewriter) const override; \
+  };
+CIR_ABI_LOWERING_PATTERN(CIRCastOpABILowering, cir::CastOp)
+CIR_ABI_LOWERING_PATTERN(CIRGlobalOpABILowering, cir::GlobalOp)
+CIR_ABI_LOWERING_PATTERN(CIRConstantOpABILowering, cir::ConstantOp)
+CIR_ABI_LOWERING_PATTERN(CIRBaseDataMemberOpABILowering, cir::BaseDataMemberOp)
+CIR_ABI_LOWERING_PATTERN(CIRBaseMethodOpABILowering, cir::BaseMethodOp)
+CIR_ABI_LOWERING_PATTERN(CIRCmpOpABILowering, cir::CmpOp)
+CIR_ABI_LOWERING_PATTERN(CIRDerivedDataMemberOpABILowering,
+                         cir::DerivedDataMemberOp)
+CIR_ABI_LOWERING_PATTERN(CIRDerivedMethodOpABILowering, cir::DerivedMethodOp)
+CIR_ABI_LOWERING_PATTERN(CIRGetMethodOpABILowering, cir::GetMethodOp)
+CIR_ABI_LOWERING_PATTERN(CIRGetRuntimeMemberOpABILowering,
+                         cir::GetRuntimeMemberOp)
+#undef CIR_ABI_LOWERING_PATTERN
+
+mlir::LogicalResult CIRCastOpABILowering::matchAndRewrite(
+    cir::CastOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  switch (op.getKind()) {
+  case cir::CastKind::bitcast: {
+    if (!mlir::isa<cir::DataMemberType, cir::MethodType>(op.getSrc().getType()))
+      break;
+
+    mlir::Type destTy = getTypeConverter()->convertType(op.getType());
+    mlir::Value loweredResult;
+    if (mlir::isa<cir::DataMemberType>(op.getSrc().getType()))
+      loweredResult = lowerModule->getCXXABI().lowerDataMemberBitcast(
+          op, destTy, adaptor.getSrc(), rewriter);
+    else
+      loweredResult = lowerModule->getCXXABI().lowerMethodBitcast(
+          op, destTy, adaptor.getSrc(), rewriter);
+    rewriter.replaceOp(op, loweredResult);
+    return mlir::success();
+  }
+  case cir::CastKind::member_ptr_to_bool: {
+    mlir::Value loweredResult;
+    if (mlir::isa<cir::MethodType>(op.getSrc().getType()))
+      loweredResult = lowerModule->getCXXABI().lowerMethodToBoolCast(
+          op, adaptor.getSrc(), rewriter);
+    else
+      loweredResult = lowerModule->getCXXABI().lowerDataMemberToBoolCast(
+          op, adaptor.getSrc(), rewriter);
+    rewriter.replaceOp(op, loweredResult);
+    return mlir::success();
+  }
+  default:
+    break;
+  }
+
+  return mlir::failure();
+}
+
+mlir::LogicalResult CIRGlobalOpABILowering::matchAndRewrite(
+    cir::GlobalOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  std::optional<mlir::Attribute> init = op.getInitialValue();
+  if (!init.has_value())
+    return mlir::failure();
+
+  if (auto dataMemberAttr = mlir::dyn_cast<cir::DataMemberAttr>(*init)) {
+    mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
+    mlir::TypedAttr abiValue = lowerModule->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();
+  }
+
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRConstantOpABILowering::matchAndRewrite(
+    cir::ConstantOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  if (mlir::isa<cir::DataMemberType>(op.getType())) {
+    auto dataMember = mlir::cast<cir::DataMemberAttr>(op.getValue());
+    mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
+    mlir::TypedAttr abiValue = lowerModule->getCXXABI().lowerDataMemberConstant(
+        dataMember, layout, *typeConverter);
+    rewriter.replaceOpWithNewOp<ConstantOp>(op, abiValue);
+    return mlir::success();
+  }
+  if (mlir::isa<cir::MethodType>(op.getType())) {
+    auto method = mlir::cast<cir::MethodAttr>(op.getValue());
+    mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
+    mlir::TypedAttr abiValue = lowerModule->getCXXABI().lowerMethodConstant(
+        method, layout, *typeConverter);
+    rewriter.replaceOpWithNewOp<ConstantOp>(op, abiValue);
+    return mlir::success();
+  }
+
+  return mlir::failure();
+}
+
+mlir::LogicalResult CIRBaseDataMemberOpABILowering::matchAndRewrite(
+    cir::BaseDataMemberOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Value loweredResult = lowerModule->getCXXABI().lowerBaseDataMember(
+      op, adaptor.getSrc(), rewriter);
+  rewriter.replaceOp(op, loweredResult);
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRBaseMethodOpABILowering::matchAndRewrite(
+    cir::BaseMethodOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Value loweredResult =
+      lowerModule->getCXXABI().lowerBaseMethod(op, adaptor.getSrc(), rewriter);
+  rewriter.replaceOp(op, loweredResult);
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRCmpOpABILowering::matchAndRewrite(
+    cir::CmpOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  auto type = op.getLhs().getType();
+  if (!mlir::isa<cir::DataMemberType, cir::MethodType>(type))
+    return mlir::failure();
+
+  mlir::Value loweredResult;
+  if (mlir::isa<cir::DataMemberType>(type))
+    loweredResult = lowerModule->getCXXABI().lowerDataMemberCmp(
+        op, adaptor.getLhs(), adaptor.getRhs(), rewriter);
+  else
+    loweredResult = lowerModule->getCXXABI().lowerMethodCmp(
+        op, adaptor.getLhs(), adaptor.getRhs(), rewriter);
+
+  rewriter.replaceOp(op, loweredResult);
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRDerivedDataMemberOpABILowering::matchAndRewrite(
+    cir::DerivedDataMemberOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Value loweredResult = lowerModule->getCXXABI().lowerDerivedDataMember(
+      op, adaptor.getSrc(), rewriter);
+  rewriter.replaceOp(op, loweredResult);
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRDerivedMethodOpABILowering::matchAndRewrite(
+    cir::DerivedMethodOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Value loweredResult = lowerModule->getCXXABI().lowerDerivedMethod(
+      op, adaptor.getSrc(), rewriter);
+  rewriter.replaceOp(op, loweredResult);
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRGetMethodOpABILowering::matchAndRewrite(
+    cir::GetMethodOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Value loweredResults[2];
+  lowerModule->getCXXABI().lowerGetMethod(
+      op, loweredResults, adaptor.getMethod(), adaptor.getObject(), rewriter);
+  rewriter.replaceOp(op, loweredResults);
+  return mlir::success();
+}
+
+mlir::LogicalResult CIRGetRuntimeMemberOpABILowering::matchAndRewrite(
+    cir::GetRuntimeMemberOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Type resTy = getTypeConverter()->convertType(op.getType());
+  mlir::Operation *llvmOp = lowerModule->getCXXABI().lowerGetRuntimeMember(
+      op, resTy, adaptor.getAddr(), adaptor.getMember(), rewriter);
+  rewriter.replaceOp(op, llvmOp);
+  return mlir::success();
+}
+
+static void prepareABITypeConverter(mlir::TypeConverter &converter,
+                                    mlir::DataLayout &dataLayout,
+                                    cir::LowerModule &lowerModule) {
+  converter.addConversion([&](mlir::Type type) -> mlir::Type { return type; });
+  converter.addConversion([&](cir::DataMemberType type) -> mlir::Type {
+    mlir::Type abiType =
+        lowerModule.getCXXABI().lowerDataMemberType(type, converter);
+    return converter.convertType(abiType);
+  });
+  converter.addConversion([&](cir::MethodType type) -> mlir::Type {
+    mlir::Type abiType =
+        lowerModule.getCXXABI().lowerMethodType(type, converter);
+    return converter.convertType(abiType);
+  });
+}
+
+static void populateABILoweringPatterns(mlir::RewritePatternSet &patterns,
+                                        mlir::TypeConverter &converter,
+                                        mlir::DataLayout &dataLayout,
+                                        cir::LowerModule &lowerModule) {
+  patterns.add<
+      // clang-format off
+    CIRBaseDataMemberOpABILowering,
+    CIRBaseMethodOpABILowering,
+    CIRCastOpABILowering,
+    CIRCmpOpABILowering,
+    CIRConstantOpABILowering,
+    CIRDerivedDataMemberOpABILowering,
+    CIRDerivedMethodOpABILowering,
+    CIRGetMethodOpABILowering,
+    CIRGetRuntimeMemberOpABILowering,
+    CIRGlobalOpABILowering
+      // clang-format on
+      >(patterns.getContext(), converter, dataLayout, lowerModule);
+}
+
+//===----------------------------------------------------------------------===//
+// The Pass
+//===----------------------------------------------------------------------===//
+
+struct ABILoweringPass : ::impl::ABILoweringBase<ABILoweringPass> {
+  using ABILoweringBase::ABILoweringBase;
+
+  void runOnOperation() override;
+  llvm::StringRef getArgument() const override { return "cir-abi-lowering"; };
+};
+
+void ABILoweringPass::runOnOperation() {
+  auto module = mlir::cast<mlir::ModuleOp>(getOperation());
+  mlir::MLIRContext *ctx = module.getContext();
+
+  mlir::PatternRewriter rewriter(ctx);
+  std::unique_ptr<cir::LowerModule> lowerModule =
+      cir::createLowerModule(module, rewriter);
+
+  mlir::DataLayout dataLayout(module);
+  mlir::TypeConverter converter;
+  prepareABITypeConverter(converter, dataLayout, *lowerModule);
+
+  mlir::RewritePatternSet patterns(ctx);
+  populateABILoweringPatterns(patterns, converter, dataLayout, *lowerModule);
+
+  mlir::ConversionTarget target(*ctx);
+  target.addLegalOp<mlir::ModuleOp>();
+  target.addLegalDialect<cir::CIRDialect>();
+
+  // TODO: mark operations working on member pointers as illegal
+
+  // Illegal: base-to-derived and derived-to-base conversions on member pointers
+  target.addIllegalOp<cir::BaseDataMemberOp, cir::BaseMethodOp,
+                      cir::DerivedDataMemberOp, cir::DerivedMethodOp>();
+  // Illegal: indirection on member pointers
+  target.addIllegalOp<cir::GetRuntimeMemberOp, cir::GetMethodOp>();
+
+  if (failed(mlir::applyPartialConversion(module, target, std::move(patterns))))
+    signalPassFailure();
+}
+
+} // namespace
+} // namespace cir
+
+std::unique_ptr<mlir::Pass> mlir::createABILoweringPass() {
+  return std::make_unique<cir::ABILoweringPass>();
+}
diff --git a/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt b/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt
@@ -12,6 +12,7 @@ add_clang_library(MLIRCIRTransforms
   FlattenCFG.cpp
   GotoSolver.cpp
   SCFPrepare.cpp
+  ABILowering.cpp
   CallConvLowering.cpp
   HoistAllocas.cpp
 
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h
