CXXABILowering.cpp

Go to the documentation of this file.

//==- CXXABILowering.cpp - lower C++ operations to target-specific ABI form -=//
//
// 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
//
//===----------------------------------------------------------------------===//
 
#include "PassDetail.h"
#include "RecordTypeConverter.h"
#include "TargetLowering/LowerModule.h"
 
#include "mlir/Dialect/OpenACC/OpenACCOpsDialect.h.inc"
#include "mlir/Dialect/OpenMP/OpenMPOpsDialect.h.inc"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Interfaces/DataLayoutInterfaces.h"
#include "mlir/Pass/Pass.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/CIRDialect.h"
#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
#include "clang/CIR/Dialect/Passes.h"
#include "clang/CIR/Dialect/Transforms/CIRTransformUtils.h"
#include "clang/CIR/MissingFeatures.h"
 
#include "llvm/ADT/TypeSwitch.h"
 
using namespace mlir;
using namespace cir;
 
namespace mlir {
#define GEN_PASS_DEF_CXXABILOWERING
#include "clang/CIR/Dialect/Passes.h.inc"
} // namespace mlir
 
namespace {
// Check an attribute for legality. An attribute is only currently potentially
// illegal if it contains a type, member pointers are our source of illegality
// in regards to attributes.
bool isCXXABIAttributeLegal(const mlir::TypeConverter &tc,
                            mlir::Attribute attr) {
  // If we don't have an attribute, it can't have a type!
  if (!attr)
    return true;
 
  // None of the OpenACC/OMP attributes contain a type of concern, so we can
  // just treat them as legal.
  if (isa<mlir::acc::OpenACCDialect, mlir::omp::OpenMPDialect>(
          attr.getDialect()))
    return true;
 
  // These attributes either don't contain a type, or don't contain a type that
  // can have a data member/method.
  if (isa<mlir::DenseArrayAttr, mlir::FloatAttr, mlir::UnitAttr,
          mlir::StringAttr, mlir::IntegerAttr, mlir::SymbolRefAttr,
          cir::AnnotationAttr>(attr))
    return true;
 
  // Tablegen'ed always-legal attributes:
  if (isa<
#define CXX_ABI_ALWAYS_LEGAL_ATTRS
#include "clang/CIR/Dialect/IR/CIRLowering.inc"
#undef CXX_ABI_ALWAYS_LEGAL_ATTRS
          >(attr))
    return true;
 
  // Data Member and method are ALWAYS illegal.
  if (isa<cir::DataMemberAttr, cir::DataMemberOffsetAttr, cir::MethodAttr>(
          attr))
    return false;
 
  return llvm::TypeSwitch<mlir::Attribute, bool>(attr)
      // These attributes just have a type, so they are legal if their type is.
      .Case<cir::ZeroAttr>(
          [&tc](cir::ZeroAttr za) { return tc.isLegal(za.getType()); })
      .Case<cir::PoisonAttr>(
          [&tc](cir::PoisonAttr pa) { return tc.isLegal(pa.getType()); })
      .Case<cir::UndefAttr>(
          [&tc](cir::UndefAttr uda) { return tc.isLegal(uda.getType()); })
      .Case<mlir::TypeAttr>(
          [&tc](mlir::TypeAttr ta) { return tc.isLegal(ta.getValue()); })
      .Case<cir::ConstPtrAttr>(
          [&tc](cir::ConstPtrAttr cpa) { return tc.isLegal(cpa.getType()); })
      .Case<cir::CXXCtorAttr>(
          [&tc](cir::CXXCtorAttr ca) { return tc.isLegal(ca.getType()); })
      .Case<cir::CXXDtorAttr>(
          [&tc](cir::CXXDtorAttr da) { return tc.isLegal(da.getType()); })
      .Case<cir::CXXAssignAttr>(
          [&tc](cir::CXXAssignAttr aa) { return tc.isLegal(aa.getType()); })
 
      // Collection attributes are legal if ALL of the attributes in them are
      // also legal.
      .Case<mlir::ArrayAttr>([&tc](mlir::ArrayAttr array) {
        return llvm::all_of(array.getValue(), [&tc](mlir::Attribute attr) {
          return isCXXABIAttributeLegal(tc, attr);
        });
      })
      .Case<mlir::DictionaryAttr>([&tc](mlir::DictionaryAttr dict) {
        return llvm::all_of(dict.getValue(), [&tc](mlir::NamedAttribute na) {
          return isCXXABIAttributeLegal(tc, na.getValue());
        });
      })
      // These attributes have sub-attributes that we should check for legality.
      .Case<cir::ConstArrayAttr>([&tc](cir::ConstArrayAttr array) {
        return tc.isLegal(array.getType()) &&
               isCXXABIAttributeLegal(tc, array.getElts());
      })
      .Case<cir::GlobalViewAttr>([&tc](cir::GlobalViewAttr gva) {
        return tc.isLegal(gva.getType()) &&
               isCXXABIAttributeLegal(tc, gva.getIndices());
      })
      .Case<cir::GlobalOffsetAttr>([&tc](cir::GlobalOffsetAttr goa) {
        return tc.isLegal(goa.getType());
      })
      .Case<cir::VTableAttr>([&tc](cir::VTableAttr vta) {
        return tc.isLegal(vta.getType()) &&
               isCXXABIAttributeLegal(tc, vta.getData());
      })
      .Case<cir::TypeInfoAttr>([&tc](cir::TypeInfoAttr tia) {
        return tc.isLegal(tia.getType()) &&
               isCXXABIAttributeLegal(tc, tia.getData());
      })
      .Case<cir::DynamicCastInfoAttr>([&tc](cir::DynamicCastInfoAttr dcia) {
        return isCXXABIAttributeLegal(tc, dcia.getSrcRtti()) &&
               isCXXABIAttributeLegal(tc, dcia.getDestRtti()) &&
               isCXXABIAttributeLegal(tc, dcia.getRuntimeFunc()) &&
               isCXXABIAttributeLegal(tc, dcia.getBadCastFunc());
      })
      .Case<cir::ConstRecordAttr>([&tc](cir::ConstRecordAttr cra) {
        return tc.isLegal(cra.getType()) &&
               isCXXABIAttributeLegal(tc, cra.getMembers());
      })
      // We did an audit of all of our attributes (both in OpenACC and CIR), so
      // it shouldn't be dangerous to consider everything we haven't considered
      // 'illegal'. Any 'new' attributes will end up asserting in
      // 'rewriteAttribute' to make sure we consider them here. Otherwise, we
      // wouldn't discover a problematic new attribute until it contains a
      // member/method.
      .Default(false);
}
 
mlir::Attribute rewriteAttribute(const mlir::TypeConverter &tc,
                                 mlir::MLIRContext *ctx, mlir::Attribute attr) {
  // If the attribute is legal, there is no reason to rewrite it. This also
  // filters out 'null' attributes.
  if (isCXXABIAttributeLegal(tc, attr))
    return attr;
 
  // This switch needs to be kept in sync with the potentially-legal type switch
  // from isCXXABIAttributeLegal. IF we miss any, this will end up causing
  // verification/transformation issues later, often in the form of
  // unrealized-conversion-casts.
 
  return llvm::TypeSwitch<mlir::Attribute, mlir::Attribute>(attr)
      // These attributes just have a type, so convert just the type.
      .Case<cir::ZeroAttr>([&tc](cir::ZeroAttr za) {
        return cir::ZeroAttr::get(tc.convertType(za.getType()));
      })
      .Case<cir::PoisonAttr>([&tc](cir::PoisonAttr pa) {
        return cir::PoisonAttr::get(tc.convertType(pa.getType()));
      })
      .Case<cir::UndefAttr>([&tc](cir::UndefAttr uda) {
        return cir::UndefAttr::get(tc.convertType(uda.getType()));
      })
      .Case<mlir::TypeAttr>([&tc](mlir::TypeAttr ta) {
        return mlir::TypeAttr::get(tc.convertType(ta.getValue()));
      })
      .Case<cir::ConstPtrAttr>([&tc](cir::ConstPtrAttr cpa) {
        return cir::ConstPtrAttr::get(tc.convertType(cpa.getType()),
                                      cpa.getValue());
      })
      .Case<cir::CXXCtorAttr>([&tc](cir::CXXCtorAttr ca) {
        return cir::CXXCtorAttr::get(tc.convertType(ca.getType()),
                                     ca.getCtorKind(), ca.getIsTrivial());
      })
      .Case<cir::CXXDtorAttr>([&tc](cir::CXXDtorAttr da) {
        return cir::CXXDtorAttr::get(tc.convertType(da.getType()),
                                     da.getIsTrivial());
      })
      .Case<cir::CXXAssignAttr>([&tc](cir::CXXAssignAttr aa) {
        return cir::CXXAssignAttr::get(tc.convertType(aa.getType()),
                                       aa.getAssignKind(), aa.getIsTrivial());
      })
      // Collection attributes need to transform all of the attributes inside of
      // them.
      .Case<mlir::ArrayAttr>([&tc, ctx](mlir::ArrayAttr array) {
        llvm::SmallVector<mlir::Attribute> elts;
        for (mlir::Attribute a : array.getValue())
          elts.push_back(rewriteAttribute(tc, ctx, a));
        return mlir::ArrayAttr::get(ctx, elts);
      })
      .Case<mlir::DictionaryAttr>([&tc, ctx](mlir::DictionaryAttr dict) {
        llvm::SmallVector<mlir::NamedAttribute> elts;
        for (mlir::NamedAttribute na : dict.getValue())
          elts.emplace_back(na.getName(),
                            rewriteAttribute(tc, ctx, na.getValue()));
 
        return mlir::DictionaryAttr::get(ctx, elts);
      })
      // These attributes have sub-attributes that need converting too.
      .Case<cir::ConstArrayAttr>([&tc, ctx](cir::ConstArrayAttr array) {
        return cir::ConstArrayAttr::get(
            ctx, tc.convertType(array.getType()),
            rewriteAttribute(tc, ctx, array.getElts()),
            array.getTrailingZerosNum());
      })
      .Case<cir::GlobalViewAttr>([&tc, ctx](cir::GlobalViewAttr gva) {
        return cir::GlobalViewAttr::get(
            tc.convertType(gva.getType()), gva.getSymbol(),
            mlir::cast<mlir::ArrayAttr>(
                rewriteAttribute(tc, ctx, gva.getIndices())),
            gva.getAddressPoint());
      })
      .Case<cir::GlobalOffsetAttr>([&tc](cir::GlobalOffsetAttr goa) {
        return cir::GlobalOffsetAttr::get(tc.convertType(goa.getType()),
                                          goa.getSymbol(), goa.getOffset());
      })
      .Case<cir::VTableAttr>([&tc, ctx](cir::VTableAttr vta) {
        return cir::VTableAttr::get(
            tc.convertType(vta.getType()),
            mlir::cast<mlir::ArrayAttr>(
                rewriteAttribute(tc, ctx, vta.getData())));
      })
      .Case<cir::TypeInfoAttr>([&tc, ctx](cir::TypeInfoAttr tia) {
        return cir::TypeInfoAttr::get(
            tc.convertType(tia.getType()),
            mlir::cast<mlir::ArrayAttr>(
                rewriteAttribute(tc, ctx, tia.getData())));
      })
      .Case<cir::DynamicCastInfoAttr>([&tc,
                                       ctx](cir::DynamicCastInfoAttr dcia) {
        return cir::DynamicCastInfoAttr::get(
            mlir::cast<cir::GlobalViewAttr>(
                rewriteAttribute(tc, ctx, dcia.getSrcRtti())),
            mlir::cast<cir::GlobalViewAttr>(
                rewriteAttribute(tc, ctx, dcia.getDestRtti())),
            dcia.getRuntimeFunc(), dcia.getBadCastFunc(), dcia.getOffsetHint());
      })
      .Case<cir::ConstRecordAttr>([&tc, ctx](cir::ConstRecordAttr cra) {
        return cir::ConstRecordAttr::get(
            ctx, tc.convertType(cra.getType()),
            mlir::cast<mlir::ArrayAttr>(
                rewriteAttribute(tc, ctx, cra.getMembers())));
      })
      .DefaultUnreachable("unrewritten illegal attribute kind");
}
 
bool areCXXABIInherentAttrsLegal(mlir::Operation *op,
                                 const mlir::TypeConverter &typeConverter) {
  bool legal = true;
  op->getName().walkInherentAttrs(
      op, [&](llvm::StringRef, mlir::Attribute &attr) {
        legal &= isCXXABIAttributeLegal(typeConverter, attr);
      });
  return legal;
}
 
#define GET_ABI_LOWERING_PATTERNS
#include "clang/CIR/Dialect/IR/CIRLowering.inc"
#undef GET_ABI_LOWERING_PATTERNS
 
struct CXXABILoweringPass
    : public impl::CXXABILoweringBase<CXXABILoweringPass> {
  CXXABILoweringPass() = default;
  void runOnOperation() override;
};
 
/// A generic ABI lowering rewrite pattern. This conversion pattern matches any
/// CIR dialect operations with at least one operand or result of an
/// ABI-dependent type. This conversion pattern rewrites the matched operation
/// by replacing all its ABI-dependent operands and results with their
/// lowered counterparts.
class CIRGenericCXXABILoweringPattern : public mlir::ConversionPattern {
public:
  CIRGenericCXXABILoweringPattern(mlir::MLIRContext *context,
                                  const mlir::TypeConverter &typeConverter)
      : mlir::ConversionPattern(typeConverter, MatchAnyOpTypeTag(),
                                /*benefit=*/1, context) {}
 
  mlir::LogicalResult
  matchAndRewrite(mlir::Operation *op, llvm::ArrayRef<mlir::Value> operands,
                  mlir::ConversionPatternRewriter &rewriter) const override {
    // Do not match on operations that have dedicated ABI lowering rewrite rules
    if (llvm::isa<cir::AllocaOp, cir::BaseDataMemberOp, cir::BaseMethodOp,
                  cir::CastOp, cir::CmpOp, cir::ConstantOp, cir::DeleteArrayOp,
                  cir::DerivedDataMemberOp, cir::DerivedMethodOp, cir::FuncOp,
                  cir::GetMethodOp, cir::GetRuntimeMemberOp, cir::GlobalOp>(op))
      return mlir::failure();
 
    const mlir::TypeConverter *typeConverter = getTypeConverter();
    assert(typeConverter &&
           "CIRGenericCXXABILoweringPattern requires a type converter");
    bool operandsAndResultsLegal = typeConverter->isLegal(op);
    bool regionsLegal =
        std::all_of(op->getRegions().begin(), op->getRegions().end(),
                    [typeConverter](mlir::Region &region) {
                      return typeConverter->isLegal(&region);
                    });
    bool attrsLegal = areCXXABIInherentAttrsLegal(op, *typeConverter);
 
    if (operandsAndResultsLegal && regionsLegal && attrsLegal) {
      // The operation does not have any CXXABI-dependent operands or results,
      // the match fails.
      return mlir::failure();
    }
 
    mlir::OperationState loweredOpState(op->getLoc(), op->getName());
    loweredOpState.addOperands(operands);
    loweredOpState.addSuccessors(op->getSuccessors());
 
    // Lower inherent attributes while preserving auxiliary metadata verbatim.
    loweredOpState.propertiesAttr = op->getPropertiesAsAttribute();
    loweredOpState.addAttributes(op->getDiscardableAttrDictionary().getValue());
 
    // Lower all result types
    llvm::SmallVector<mlir::Type> loweredResultTypes;
    loweredResultTypes.reserve(op->getNumResults());
    for (mlir::Type result : op->getResultTypes())
      loweredResultTypes.push_back(typeConverter->convertType(result));
    loweredOpState.addTypes(loweredResultTypes);
 
    // Lower all regions
    for (mlir::Region &region : op->getRegions()) {
      mlir::Region *loweredRegion = loweredOpState.addRegion();
      rewriter.inlineRegionBefore(region, *loweredRegion, loweredRegion->end());
      if (mlir::failed(
              rewriter.convertRegionTypes(loweredRegion, *getTypeConverter())))
        return mlir::failure();
    }
 
    // Clone the operation with lowered operand types and result types
    mlir::Operation *loweredOp = rewriter.create(loweredOpState);
    loweredOp->getName().walkInherentAttrs(
        loweredOp, [&](llvm::StringRef, mlir::Attribute &attr) {
          attr = rewriteAttribute(*typeConverter, op->getContext(), attr);
        });
 
    rewriter.replaceOp(op, loweredOp);
    return mlir::success();
  }
};
 
} // namespace
 
mlir::LogicalResult CIRAllocaOpABILowering::matchAndRewrite(
    cir::AllocaOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Type allocaPtrTy = op.getType();
  mlir::Type loweredAllocaPtrTy = getTypeConverter()->convertType(allocaPtrTy);
 
  cir::AllocaOp loweredOp = cir::AllocaOp::create(
      rewriter, op.getLoc(), loweredAllocaPtrTy, op.getName(),
      op.getAlignmentAttr(), /*dynAllocSize=*/adaptor.getDynAllocSize());
  loweredOp.setInit(op.getInit());
  loweredOp.setConstant(op.getConstant());
  loweredOp.setAnnotationsAttr(op.getAnnotationsAttr());
 
  rewriter.replaceOp(op, loweredOp);
  return mlir::success();
}
 
mlir::LogicalResult CIRCastOpABILowering::matchAndRewrite(
    cir::CastOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Type srcTy = op.getSrc().getType();
 
  if (mlir::isa<cir::DataMemberType, cir::MethodType>(srcTy)) {
    switch (op.getKind()) {
    case cir::CastKind::bitcast: {
      mlir::Type destTy = getTypeConverter()->convertType(op.getType());
      mlir::Value loweredResult;
      if (mlir::isa<cir::DataMemberType>(srcTy))
        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::DataMemberType>(srcTy))
        loweredResult = lowerModule->getCXXABI().lowerDataMemberToBoolCast(
            op, adaptor.getSrc(), rewriter);
      else
        loweredResult = lowerModule->getCXXABI().lowerMethodToBoolCast(
            op, adaptor.getSrc(), rewriter);
      rewriter.replaceOp(op, loweredResult);
      return mlir::success();
    }
    default:
      break;
    }
  }
 
  mlir::Value loweredResult = cir::CastOp::create(
      rewriter, op.getLoc(), getTypeConverter()->convertType(op.getType()),
      adaptor.getKind(), adaptor.getSrc());
  rewriter.replaceOp(op, loweredResult);
  return mlir::success();
}
 
// Helper function to lower a value for things like an initializer.
static mlir::TypedAttr lowerInitialValue(const LowerModule *lowerModule,
                                         const mlir::DataLayout &layout,
                                         const mlir::TypeConverter &tc,
                                         mlir::Type ty,
                                         mlir::Attribute initVal) {
  if (mlir::isa_and_present<cir::UndefAttr>(initVal))
    return cir::UndefAttr::get(tc.convertType(ty));
 
  if (mlir::isa_and_present<cir::PoisonAttr>(initVal))
    return cir::PoisonAttr::get(tc.convertType(ty));
 
  if (mlir::isa<cir::DataMemberType>(ty)) {
    // Members without a CIR field index (e.g. no_unique_address empty fields)
    // are represented by an explicit byte offset instead of a field path.
    if (auto offsetVal =
            mlir::dyn_cast_if_present<cir::DataMemberOffsetAttr>(initVal))
      return lowerModule->getCXXABI().lowerDataMemberOffsetConstant(offsetVal,
                                                                    layout, tc);
    auto dataMemberVal = mlir::cast_if_present<cir::DataMemberAttr>(initVal);
    return lowerModule->getCXXABI().lowerDataMemberConstant(dataMemberVal,
                                                            layout, tc);
  }
  if (mlir::isa<cir::MethodType>(ty)) {
    auto methodVal = mlir::cast_if_present<cir::MethodAttr>(initVal);
    return lowerModule->getCXXABI().lowerMethodConstant(methodVal, layout, tc);
  }
 
  if (auto arrTy = mlir::dyn_cast<cir::ArrayType>(ty)) {
    auto loweredArrTy = mlir::cast<cir::ArrayType>(tc.convertType(arrTy));
 
    if (!initVal)
      return {};
 
    if (auto zeroVal = mlir::dyn_cast_if_present<cir::ZeroAttr>(initVal))
      return cir::ZeroAttr::get(loweredArrTy);
 
    auto arrayVal = mlir::cast<cir::ConstArrayAttr>(initVal);
 
    // String-literal arrays store their bytes as a StringAttr in `elts`. The
    // backing i8 element type is never rewritten by the CXX ABI type
    // converter, so the attribute is already legal and can be passed through
    // unchanged.
    if (mlir::isa<mlir::StringAttr>(arrayVal.getElts())) {
      assert(loweredArrTy == arrTy &&
             "string-literal array type should not change under CXX ABI");
      return arrayVal;
    }
 
    auto arrayElts = mlir::cast<ArrayAttr>(arrayVal.getElts());
    SmallVector<mlir::Attribute> loweredElements;
    loweredElements.reserve(arrTy.getSize());
    for (const mlir::Attribute &attr : arrayElts) {
      auto typedAttr = cast<mlir::TypedAttr>(attr);
      loweredElements.push_back(lowerInitialValue(
          lowerModule, layout, tc, typedAttr.getType(), typedAttr));
    }
 
    return cir::ConstArrayAttr::get(
        loweredArrTy, mlir::ArrayAttr::get(ty.getContext(), loweredElements),
        arrayVal.getTrailingZerosNum());
  }
 
  if (auto recordTy = mlir::dyn_cast<cir::RecordType>(ty)) {
    auto convertedTy =
        mlir::dyn_cast<cir::RecordType>(tc.convertType(recordTy));
    if (!convertedTy)
      return {};
 
    if (auto recVal = mlir::dyn_cast_if_present<cir::ZeroAttr>(initVal))
      return cir::ZeroAttr::get(convertedTy);
 
    if (auto recVal =
            mlir::dyn_cast_if_present<cir::ConstRecordAttr>(initVal)) {
      auto recordMembers = mlir::cast<ArrayAttr>(recVal.getMembers());
 
      SmallVector<mlir::Attribute> loweredMembers;
      loweredMembers.reserve(recordMembers.size());
 
      for (const mlir::Attribute &attr : recordMembers) {
        auto typedAttr = cast<mlir::TypedAttr>(attr);
        loweredMembers.push_back(lowerInitialValue(
            lowerModule, layout, tc, typedAttr.getType(), typedAttr));
      }
 
      return cir::ConstRecordAttr::get(
          convertedTy, mlir::ArrayAttr::get(ty.getContext(), loweredMembers));
    }
 
    assert(!initVal && "Record init val type not handled");
    return {};
  }
 
  // Pointers can contain record types, which can change.
  if (auto ptrTy = mlir::dyn_cast<cir::PointerType>(ty)) {
    auto convertedTy = mlir::cast<cir::PointerType>(tc.convertType(ptrTy));
    // pointers don't change other than their types.
 
    if (auto gva = mlir::dyn_cast_if_present<cir::GlobalViewAttr>(initVal))
      return cir::GlobalViewAttr::get(convertedTy, gva.getSymbol(),
                                      gva.getIndices(), gva.getAddressPoint());
 
    if (auto goa = mlir::dyn_cast_if_present<cir::GlobalOffsetAttr>(initVal))
      return cir::GlobalOffsetAttr::get(convertedTy, goa.getSymbol(),
                                        goa.getOffset());
 
    if (auto blockAddr =
            mlir::dyn_cast_if_present<cir::BlockAddrInfoAttr>(initVal)) {
      assert(convertedTy == ptrTy && "BlockAddrInfo type should not change");
      return blockAddr;
    }
 
    auto constPtr = mlir::cast_if_present<cir::ConstPtrAttr>(initVal);
    if (!constPtr)
      return {};
    return cir::ConstPtrAttr::get(convertedTy, constPtr.getValue());
  }
 
  assert(ty == tc.convertType(ty) &&
         "cir.global or constant operand is not an CXXABI-dependent type");
 
  // Every other type can be left alone.
  return cast<mlir::TypedAttr>(initVal);
}
 
mlir::LogicalResult CIRConstantOpABILowering::matchAndRewrite(
    cir::ConstantOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
 
  mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
  mlir::TypedAttr newValue = lowerInitialValue(
      lowerModule, layout, *getTypeConverter(), op.getType(), op.getValue());
  rewriter.replaceOpWithNewOp<ConstantOp>(op, newValue);
  return mlir::success();
}
 
mlir::LogicalResult CIRCmpOpABILowering::matchAndRewrite(
    cir::CmpOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Type type = op.getLhs().getType();
 
  mlir::Value loweredResult;
  if (mlir::isa<cir::DataMemberType>(type))
    loweredResult = lowerModule->getCXXABI().lowerDataMemberCmp(
        op, adaptor.getLhs(), adaptor.getRhs(), rewriter);
  else if (mlir::isa<cir::MethodType>(type))
    loweredResult = lowerModule->getCXXABI().lowerMethodCmp(
        op, adaptor.getLhs(), adaptor.getRhs(), rewriter);
  else
    loweredResult = cir::CmpOp::create(
        rewriter, op.getLoc(), getTypeConverter()->convertType(op.getType()),
        adaptor.getKind(), adaptor.getLhs(), adaptor.getRhs());
 
  rewriter.replaceOp(op, loweredResult);
  return mlir::success();
}
 
mlir::LogicalResult CIRFuncOpABILowering::matchAndRewrite(
    cir::FuncOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  cir::FuncType opFuncType = op.getFunctionType();
  mlir::TypeConverter::SignatureConversion signatureConversion(
      opFuncType.getNumInputs());
 
  for (const auto &[i, argType] : llvm::enumerate(opFuncType.getInputs())) {
    mlir::Type loweredArgType = getTypeConverter()->convertType(argType);
    if (!loweredArgType)
      return mlir::failure();
    signatureConversion.addInputs(i, loweredArgType);
  }
 
  mlir::Type loweredResultType =
      getTypeConverter()->convertType(opFuncType.getReturnType());
  if (!loweredResultType)
    return mlir::failure();
 
  auto loweredFuncType =
      cir::FuncType::get(signatureConversion.getConvertedTypes(),
                         loweredResultType, /*isVarArg=*/opFuncType.isVarArg());
 
  // Create a new cir.func operation for the CXXABI-lowered function.
  cir::FuncOp loweredFuncOp = rewriter.cloneWithoutRegions(op);
  loweredFuncOp.setFunctionType(loweredFuncType);
 
  loweredFuncOp->getName().walkInherentAttrs(
      loweredFuncOp, [&](llvm::StringRef, mlir::Attribute &attr) {
        attr = rewriteAttribute(*getTypeConverter(), op->getContext(), attr);
      });
  rewriter.inlineRegionBefore(op.getBody(), loweredFuncOp.getBody(),
                              loweredFuncOp.end());
  if (mlir::failed(rewriter.convertRegionTypes(
          &loweredFuncOp.getBody(), *getTypeConverter(), &signatureConversion)))
    return mlir::failure();
 
  rewriter.eraseOp(op);
  return mlir::success();
}
 
mlir::LogicalResult CIRGlobalOpABILowering::matchAndRewrite(
    cir::GlobalOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Type ty = op.getSymType();
  mlir::Type loweredTy = getTypeConverter()->convertType(ty);
  if (!loweredTy)
    return mlir::failure();
 
  mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
 
  mlir::Attribute loweredInit = lowerInitialValue(
      lowerModule, layout, *getTypeConverter(), ty, op.getInitialValueAttr());
 
  cir::GlobalOp newOp = rewriter.cloneWithoutRegions(op);
  newOp.setInitialValueAttr(loweredInit);
  newOp.setSymType(loweredTy);
  // Regions have to be separately moved(rather than cloned), else we cause
  // multi-block regions/eh stuff to be double-referenced, and thus can't be
  // removed properly during collectUnreachable.
  rewriter.inlineRegionBefore(op.getCtorRegion(), newOp.getCtorRegion(),
                              newOp.getCtorRegion().end());
  rewriter.inlineRegionBefore(op.getDtorRegion(), newOp.getDtorRegion(),
                              newOp.getDtorRegion().end());
  rewriter.replaceOp(op, newOp);
  return mlir::success();
}
 
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 CIRDeleteArrayOpABILowering::matchAndRewrite(
    cir::DeleteArrayOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::FlatSymbolRefAttr deleteFn = op.getDeleteFnAttr();
  mlir::Location loc = op->getLoc();
  mlir::Value loweredAddress = adaptor.getAddress();
 
  cir::UsualDeleteParamsAttr deleteParams = op.getDeleteParamsAttr();
  if (!deleteParams)
    deleteParams = cir::UsualDeleteParamsAttr::get(op.getContext(), false,
                                                   std::nullopt, false, false);
  bool cookieRequired = deleteParams.getSize() || op.getElementDtorAttr();
 
  assert(!deleteParams.getDestroyingDelete() &&
         "destroying delete not legal on arrays");
  assert(!deleteParams.getTypeAwareDelete() &&
         "type-aware delete not legal on arrays");
 
  const CIRCXXABI &cxxABI = lowerModule->getCXXABI();
  CIRBaseBuilderTy cirBuilder(rewriter);
 
  // Read the array cookie (or compute the void* pointer for the
  // non-cookie case) before creating the cleanup scope. The cookie read
  // produces values that are needed by both the destruction loop in the
  // body region (numElements for the array.dtor) and the operator
  // delete[] call in the cleanup region (deletePtr / numElements for the
  // total-size computation), so it must dominate both regions.
  mlir::Value deletePtr;
  mlir::Value numElements;
  cir::PointerType ptrTy;
  clang::CharUnits cookieSize;
  mlir::DataLayout dl(op->getParentOfType<mlir::ModuleOp>());
  unsigned ptrWidth =
      lowerModule->getTarget().getPointerWidth(clang::LangAS::Default);
  cir::IntType sizeTy = cirBuilder.getUIntNTy(ptrWidth);
 
  if (cookieRequired) {
    ptrTy = mlir::cast<cir::PointerType>(loweredAddress.getType());
    clang::CharUnits elementAlign =
        clang::CharUnits::fromQuantity(op.getElementAlign());
    cxxABI.readArrayCookie(loc, loweredAddress, elementAlign, dl, cirBuilder,
                           numElements, deletePtr, cookieSize);
  } else {
    deletePtr = cir::CastOp::create(rewriter, loc, cirBuilder.getVoidPtrTy(),
                                    cir::CastKind::bitcast, loweredAddress);
  }
 
  // Create a cleanup scope to wrap the ArrayDtor operation (if needed) and
  // call the array delete operator from the cleanup region. If no exceptions
  // are thrown during the array dtor, the normal control flow will call the
  // delete operator. The ArrayDtor operation will get its own cleanup region
  // when it is expanded during LoweringPrepare. If an exception is thrown, the
  // exception handling flow will be connected to the cleanup region here to
  // call the delete operator on the exception path.
  mlir::FlatSymbolRefAttr dtorFn = op.getElementDtorAttr();
 
  // Make sure the calls and the callees agree on calling convention.
  auto getCalleeCallingConv = [&](mlir::FlatSymbolRefAttr callee) {
    if (auto fn =
            mlir::SymbolTable::lookupNearestSymbolFrom<cir::FuncOp>(op, callee))
      return fn.getCallingConv();
    return cir::CallingConv::C;
  };
 
  cir::CleanupKind cleanupKind =
      op.getDtorMayThrow() ? cir::CleanupKind::All : cir::CleanupKind::Normal;
  cir::CleanupScopeOp::create(
      rewriter, loc, cleanupKind,
      /*bodyBuilder=*/
      [&](mlir::OpBuilder &b, mlir::Location l) {
        if (dtorFn) {
          auto eltPtrTy = cir::PointerType::get(ptrTy.getPointee());
          auto arrayDtor = cir::ArrayDtor::create(
              b, l, loweredAddress, numElements,
              [&](mlir::OpBuilder &bb, mlir::Location ll) {
                mlir::Value arg =
                    bb.getInsertionBlock()->addArgument(eltPtrTy, ll);
                auto dtorCall = cir::CallOp::create(
                    bb, ll, dtorFn, cir::VoidType(), mlir::ValueRange{arg});
                dtorCall.setCallingConv(getCalleeCallingConv(dtorFn));
                if (!op.getDtorMayThrow())
                  dtorCall.setNothrowAttr(bb.getUnitAttr());
                cir::YieldOp::create(bb, ll);
              });
          if (op.getDtorMayThrow())
            arrayDtor.setDtorMayThrow(true);
        }
        cir::YieldOp::create(b, l);
      },
      /*cleanupBuilder=*/
      [&](mlir::OpBuilder &b, mlir::Location l) {
        llvm::SmallVector<mlir::Value> callArgs;
        callArgs.push_back(deletePtr);
        if (deleteParams.getSize()) {
          uint64_t eltSizeBytes = dl.getTypeSizeInBits(ptrTy.getPointee()) / 8;
          auto eltSizeVal = cir::ConstantOp::create(
              b, l, cir::IntAttr::get(sizeTy, eltSizeBytes));
          mlir::Value allocSize =
              cir::MulOp::create(b, l, sizeTy, eltSizeVal, numElements);
          auto cookieSizeVal = cir::ConstantOp::create(
              b, l, cir::IntAttr::get(sizeTy, cookieSize.getQuantity()));
          allocSize =
              cir::AddOp::create(b, l, sizeTy, allocSize, cookieSizeVal);
          callArgs.push_back(allocSize);
        }
        if (deleteParams.getAlignment()) {
          auto alignVal = cir::ConstantOp::create(
              b, l, cir::IntAttr::get(sizeTy, *deleteParams.getAlignment()));
          callArgs.push_back(alignVal);
        }
 
        auto deleteCall =
            cir::CallOp::create(b, l, deleteFn, cir::VoidType(), callArgs);
        deleteCall.setCallingConv(getCalleeCallingConv(deleteFn));
        // operator delete[] is implicitly nothrow per [basic.stc.dynamic],
        // matching classic CodeGen's `nounwind` attribute on the call.
        deleteCall.setNothrowAttr(b.getUnitAttr());
        cir::YieldOp::create(b, l);
      });
 
  rewriter.eraseOp(op);
  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 CIRDynamicCastOpABILowering::matchAndRewrite(
    cir::DynamicCastOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Value loweredResult =
      lowerModule->getCXXABI().lowerDynamicCast(op, rewriter);
  rewriter.replaceOp(op, loweredResult);
  return mlir::success();
}
 
mlir::LogicalResult CIRGetMethodOpABILowering::matchAndRewrite(
    cir::GetMethodOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Value callee;
  mlir::Value thisArg;
  lowerModule->getCXXABI().lowerGetMethod(
      op, callee, thisArg, adaptor.getMethod(), adaptor.getObject(), rewriter);
  rewriter.replaceOp(op, {callee, thisArg});
  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 *newOp = lowerModule->getCXXABI().lowerGetRuntimeMember(
      op, resTy, adaptor.getAddr(), adaptor.getMember(), rewriter);
  rewriter.replaceOp(op, newOp);
  return mlir::success();
}
 
mlir::LogicalResult CIRVTableGetTypeInfoOpABILowering::matchAndRewrite(
    cir::VTableGetTypeInfoOp op, OpAdaptor adaptor,
    mlir::ConversionPatternRewriter &rewriter) const {
  mlir::Value loweredResult =
      lowerModule->getCXXABI().lowerVTableGetTypeInfo(op, rewriter);
  rewriter.replaceOp(op, loweredResult);
  return mlir::success();
}
 
namespace {
// A small type to handle type conversion for the the CXXABILoweringPass.
// Even though this is a CIR-to-CIR pass, we are eliminating some CIR types.
// The records that contain them are rebuilt by RecordRewritingTypeConverter.
class CIRABITypeConverter : public cir::RecordRewritingTypeConverter {
public:
  CIRABITypeConverter(mlir::MLIRContext &ctx, mlir::DataLayout &dataLayout,
                      cir::LowerModule &lowerModule)
      : RecordRewritingTypeConverter(ctx) {
    addConversion([&](cir::DataMemberType type) -> mlir::Type {
      mlir::Type abiType =
          lowerModule.getCXXABI().lowerDataMemberType(type, *this);
      return convertType(abiType);
    });
    addConversion([&](cir::MethodType type) -> mlir::Type {
      mlir::Type abiType = lowerModule.getCXXABI().lowerMethodType(type, *this);
      return convertType(abiType);
    });
  }
 
protected:
  // Only member pointer types are rewritten. Records that reach none of them
  // are left alone.
  bool typeMayChange(mlir::Type type) const override {
    return mlir::isa<cir::DataMemberType, cir::MethodType>(type);
  }
};
} // namespace
 
static void
populateCXXABIConversionTarget(mlir::ConversionTarget &target,
                               const mlir::TypeConverter &typeConverter) {
  target.addLegalOp<mlir::ModuleOp>();
 
  // The ABI lowering pass is interested in CIR operations with operands or
  // results of CXXABI-dependent types, or CIR operations with regions whose
  // block arguments are of CXXABI-dependent types.
  target.addDynamicallyLegalDialect<cir::CIRDialect>(
      [&typeConverter](mlir::Operation *op) {
        if (!typeConverter.isLegal(op))
          return false;
 
        bool attrs = areCXXABIInherentAttrsLegal(op, typeConverter);
 
        return attrs &&
               std::all_of(op->getRegions().begin(), op->getRegions().end(),
                           [&typeConverter](mlir::Region &region) {
                             return typeConverter.isLegal(&region);
                           });
      });
 
  target.addDynamicallyLegalDialect<mlir::acc::OpenACCDialect>(
      [&typeConverter](mlir::Operation *op) {
        if (!typeConverter.isLegal(op))
          return false;
 
        bool attrs = areCXXABIInherentAttrsLegal(op, typeConverter);
 
        return attrs &&
               std::all_of(op->getRegions().begin(), op->getRegions().end(),
                           [&typeConverter](mlir::Region &region) {
                             return typeConverter.isLegal(&region);
                           });
      });
 
  // TargetLowering leaves same-type casts behind. Keep them illegal so the
  // conversion driver folds them away.
  target.addDynamicallyLegalOp<cir::CastOp>([&typeConverter](cir::CastOp op) {
    if (op.getSrc().getType() == op.getType()) {
      switch (op.getKind()) {
      case cir::CastKind::bitcast:
      case cir::CastKind::address_space:
      case cir::CastKind::float_complex:
      case cir::CastKind::int_complex:
        return false;
      default:
        break;
      }
    }
    if (!typeConverter.isLegal(op.getOperation()))
      return false;
    // CastOp has no regions, so operand/result types and inherent
    // attributes are the whole legality check.
    return areCXXABIInherentAttrsLegal(op, typeConverter);
  });
 
  // Some CIR ops needs special checking for legality
  target.addDynamicallyLegalOp<cir::FuncOp>([&typeConverter](cir::FuncOp op) {
    bool attrs = areCXXABIInherentAttrsLegal(op, typeConverter);
 
    return attrs && typeConverter.isLegal(op.getFunctionType());
  });
  target.addDynamicallyLegalOp<cir::GlobalOp>(
      [&typeConverter](cir::GlobalOp op) {
        return typeConverter.isLegal(op.getSymType());
      });
  // Operations that do not use any special types must be explicitly marked as
  // illegal to trigger processing here.
  target.addIllegalOp<cir::DeleteArrayOp>();
  target.addIllegalOp<cir::DynamicCastOp>();
  target.addIllegalOp<cir::VTableGetTypeInfoOp>();
}
 
//===----------------------------------------------------------------------===//
// The Pass
//===----------------------------------------------------------------------===//
 
void CXXABILoweringPass::runOnOperation() {
  auto mod = mlir::cast<mlir::ModuleOp>(getOperation());
  mlir::MLIRContext *ctx = mod.getContext();
 
  std::unique_ptr<cir::LowerModule> lowerModule = cir::createLowerModule(mod);
  // If lower module is not available, skip the ABI lowering pass.
  if (!lowerModule) {
    mod.emitWarning("Cannot create a CIR lower module, skipping the ")
        << getName() << " pass";
    return;
  }
 
  mlir::DataLayout dataLayout(mod);
  CIRABITypeConverter typeConverter(*ctx, dataLayout, *lowerModule);
 
  mlir::RewritePatternSet patterns(ctx);
  patterns.add<CIRGenericCXXABILoweringPattern>(patterns.getContext(),
                                                typeConverter);
  patterns.add<
#define GET_ABI_LOWERING_PATTERNS_LIST
#include "clang/CIR/Dialect/IR/CIRLowering.inc"
#undef GET_ABI_LOWERING_PATTERNS_LIST
      >(patterns.getContext(), typeConverter, dataLayout, *lowerModule);
 
  mlir::ConversionTarget target(*ctx);
  populateCXXABIConversionTarget(target, typeConverter);
 
  llvm::SmallVector<mlir::Operation *> ops;
  ops.push_back(mod);
  cir::collectUnreachable(mod, ops);
 
  if (failed(mlir::applyPartialConversion(ops, target, std::move(patterns))))
    signalPassFailure();
 
  typeConverter.restoreRecordTypeNames();
}
 
std::unique_ptr<Pass> mlir::createCXXABILoweringPass() {
  return std::make_unique<CXXABILoweringPass>();
}