[clang] [CIR][NFC] Use TableGen to generate LLVM lowering patterns (PR #159390)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Sep 17 08:58:43 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clangir
Author: Sirui Mu (Lancern)
<details>
<summary>Changes</summary>
Most lowering patterns have exactly the same class declaration with different names and different `matchAndRewrite` implementations, yet their declaration occupies near 1000 lines of code in `LowerToLLVM.h`, making this file difficult to read and boring to maintain. In this patch, I migrate their declarations to be generated from `CIROps.td` using `clang-tblgen`. Some extra `CIR_Op` TableGen fields are introduced to help this:
- The `CIR_Op` class now defines a `bit` field `hasLLVMLowering` which defaults to `true`. If its value is `true`, `clang-tblgen` would generate an LLVM lowering pattern declaration for the operation.
- Some LLVM lowering patterns has bounded recursion. This could be enabled by setting the `isLLVMLoweringRecursive` field in a `CIR_Op` record to `true`.
- Some LLVM lowering patterns have defined additional class members. They could be listed in the `extraLLVMLoweringPatternDecl` field.
Note that in the incubator we have a similar TableGen code generator that generates LLVM lowering code for CIR builtin ops which has a one-to-one correspondence to LLVM dialect operations. This patch does NOT try to upstream it.
Some additional noticeable changes made by this patch:
- This patch adds the `dataLayout` member to every LLVM lowering pattern class to make the job easier for a code generator. In the future we might want to add more members to the lowering patterns, and we will need to update the code generator to make such changes.
---
Patch is 47.18 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/159390.diff
8 Files Affected:
- (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+79-1)
- (modified) clang/include/clang/CIR/Dialect/IR/CMakeLists.txt (+4)
- (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp (+4-80)
- (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h (+3-795)
- (added) clang/utils/TableGen/CIRLoweringEmitter.cpp (+125)
- (modified) clang/utils/TableGen/CMakeLists.txt (+1)
- (modified) clang/utils/TableGen/TableGen.cpp (+6)
- (modified) clang/utils/TableGen/TableGenBackends.h (+1)
``````````diff
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 38c4a87f69d6d..f80c9faf708ef 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -78,7 +78,15 @@ class LLVMLoweringInfo {
}
class CIR_Op<string mnemonic, list<Trait> traits = []> :
- Op<CIR_Dialect, mnemonic, traits>, LLVMLoweringInfo;
+ Op<CIR_Dialect, mnemonic, traits>, LLVMLoweringInfo {
+ // Should we generate an LLVM lowering pattern for this op?
+ bit hasLLVMLowering = true;
+ // Is the LLVM lowering pattern for this operation recursive?
+ bit isLLVMLoweringRecursive = false;
+ // Extra class declarations to be included in the generated LLVM lowering
+ // pattern.
+ code extraLLVMLoweringPatternDecl = "";
+}
//===----------------------------------------------------------------------===//
// CastOp
@@ -218,6 +226,10 @@ def CIR_CastOp : CIR_Op<"cast", [
// The input and output types should match the cast kind.
let hasVerifier = 1;
let hasFolder = 1;
+
+ let extraLLVMLoweringPatternDecl = [{
+ mlir::Type convertTy(mlir::Type ty) const;
+ }];
}
@@ -297,6 +309,8 @@ def CIR_ConstantOp : CIR_Op<"const", [
}];
let hasFolder = 1;
+
+ let isLLVMLoweringRecursive = true;
}
//===----------------------------------------------------------------------===//
@@ -613,6 +627,8 @@ def CIR_IfOp : CIR_Op<"if", [
CArg<"BuilderCallbackRef", "buildTerminatedBody">:$thenBuilder,
CArg<"BuilderCallbackRef", "nullptr">:$elseBuilder)>
];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -659,6 +675,7 @@ def CIR_ConditionOp : CIR_Op<"condition", [
let arguments = (ins CIR_BoolType:$condition);
let assemblyFormat = " `(` $condition `)` attr-dict ";
let hasVerifier = 1;
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -726,6 +743,8 @@ def CIR_YieldOp : CIR_Op<"yield", [
let builders = [
OpBuilder<(ins), [{ /* nothing to do */ }]>,
];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -741,6 +760,7 @@ def CIR_BreakOp : CIR_Op<"break", [Terminator]> {
}];
let assemblyFormat = "attr-dict";
let hasVerifier = 1;
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -756,6 +776,7 @@ def CIR_ContinueOp : CIR_Op<"continue", [Terminator]> {
}];
let assemblyFormat = "attr-dict";
let hasVerifier = 1;
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -814,6 +835,8 @@ def CIR_ScopeOp : CIR_Op<"scope", [
// Scopes without yielding values.
OpBuilder<(ins "llvm::function_ref<void(mlir::OpBuilder &, mlir::Location)>":$scopeBuilder)>
];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -860,6 +883,8 @@ def CIR_CaseOp : CIR_Op<"case", [
"CaseOpKind":$kind,
"mlir::OpBuilder::InsertPoint &":$insertPoint)>
];
+
+ let hasLLVMLowering = false;
}
def CIR_SwitchOp : CIR_Op<"switch", [
@@ -1025,6 +1050,8 @@ def CIR_SwitchOp : CIR_Op<"switch", [
// This is an expensive and need to be used with caution.
bool isSimpleForm(llvm::SmallVectorImpl<CaseOp> &cases);
}];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -1170,6 +1197,8 @@ def CIR_GotoOp : CIR_Op<"goto", [Terminator]> {
}];
let arguments = (ins StrAttr:$label);
let assemblyFormat = [{ $label attr-dict }];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -1185,6 +1214,8 @@ def CIR_LabelOp : CIR_Op<"label", [AlwaysSpeculatable]> {
let arguments = (ins StrAttr:$label);
let assemblyFormat = [{ $label attr-dict }];
let hasVerifier = 1;
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -1349,6 +1380,8 @@ def CIR_WhileOp : CIR_WhileOpBase<"while"> {
}
```
}];
+
+ let hasLLVMLowering = false;
}
def CIR_DoWhileOp : CIR_WhileOpBase<"do"> {
@@ -1375,6 +1408,8 @@ def CIR_DoWhileOp : CIR_WhileOpBase<"do"> {
}
```
}];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -1442,6 +1477,8 @@ def CIR_ForOp : CIR_LoopOpBase<"for"> {
return llvm::SmallVector<mlir::Region *, 3>{&getCond(), &getBody(), &getStep()};
}
}];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -1480,6 +1517,8 @@ def CIR_CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
let assemblyFormat = [{
`(` $kind `,` $lhs `,` $rhs `)` `:` type($lhs) `,` type($result) attr-dict
}];
+
+ let isLLVMLoweringRecursive = true;
}
//===----------------------------------------------------------------------===//
@@ -1550,6 +1589,10 @@ def CIR_BinOp : CIR_Op<"binop", [
}];
let hasVerifier = 1;
+
+ let extraLLVMLoweringPatternDecl = [{
+ mlir::LLVM::IntegerOverflowFlags getIntOverflowFlag(cir::BinOp op) const;
+ }];
}
//===----------------------------------------------------------------------===//
@@ -1687,6 +1730,8 @@ def CIR_TernaryOp : CIR_Op<"ternary", [
`false` $falseRegion
`)` `:` functional-type(operands, results) attr-dict
}];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
@@ -1790,6 +1835,20 @@ def CIR_GlobalOp : CIR_Op<"global", [
"cir::GlobalLinkageKind::ExternalLinkage">:$linkage)>];
let hasVerifier = 1;
+
+ let isLLVMLoweringRecursive = true;
+ let extraLLVMLoweringPatternDecl = [{
+ mlir::LogicalResult matchAndRewriteRegionInitializedGlobal(
+ cir::GlobalOp op, mlir::Attribute init,
+ mlir::ConversionPatternRewriter &rewriter) const;
+
+ void setupRegionInitializedLLVMGlobalOp(
+ cir::GlobalOp op, mlir::ConversionPatternRewriter &rewriter) const;
+
+ mutable mlir::LLVM::ComdatOp comdatOp = nullptr;
+ mlir::SymbolRefAttr getComdatAttr(cir::GlobalOp &op,
+ mlir::OpBuilder &builder) const;
+ }];
}
//===----------------------------------------------------------------------===//
@@ -2340,6 +2399,19 @@ def CIR_FuncOp : CIR_Op<"func", [
let hasCustomAssemblyFormat = 1;
let hasVerifier = 1;
+
+ let extraLLVMLoweringPatternDecl = [{
+ static mlir::StringRef getLinkageAttrNameString() { return "linkage"; }
+
+ void lowerFuncAttributes(
+ cir::FuncOp func, bool filterArgAndResAttrs,
+ mlir::SmallVectorImpl<mlir::NamedAttribute> &result) const;
+
+ mlir::LogicalResult
+ matchAndRewriteAlias(cir::FuncOp op, llvm::StringRef aliasee, mlir::Type ty,
+ OpAdaptor adaptor,
+ mlir::ConversionPatternRewriter &rewriter) const;
+ }];
}
//===----------------------------------------------------------------------===//
@@ -2761,6 +2833,8 @@ class CIR_ArrayInitDestroy<string mnemonic> : CIR_Op<mnemonic> {
regionBuilder($_builder, $_state.location);
}]>
];
+
+ let hasLLVMLowering = false;
}
def CIR_ArrayCtor : CIR_ArrayInitDestroy<"array.ctor"> {
@@ -3380,6 +3454,8 @@ def CIR_ComplexMulOp : CIR_Op<"complex.mul", [
let assemblyFormat = [{
$lhs `,` $rhs `range` `(` $range `)` `:` qualified(type($result)) attr-dict
}];
+
+ let hasLLVMLowering = false;
}
def CIR_ComplexDivOp : CIR_Op<"complex.div", [
@@ -3422,6 +3498,8 @@ def CIR_ComplexDivOp : CIR_Op<"complex.div", [
let assemblyFormat = [{
$lhs `,` $rhs `range` `(` $range `)` `:` qualified(type($result)) attr-dict
}];
+
+ let hasLLVMLowering = false;
}
//===----------------------------------------------------------------------===//
diff --git a/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt b/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt
index 6e7f3da4add3e..870f9e3f5d052 100644
--- a/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt
+++ b/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt
@@ -20,6 +20,10 @@ mlir_tablegen(CIROpsAttributes.h.inc -gen-attrdef-decls)
mlir_tablegen(CIROpsAttributes.cpp.inc -gen-attrdef-defs)
add_public_tablegen_target(MLIRCIREnumsGen)
+clang_tablegen(CIRLowering.inc -gen-cir-lowering
+ SOURCE CIROps.td
+ TARGET CIRLowering)
+
set(LLVM_TARGET_DEFINITIONS CIRTypeConstraints.td)
mlir_tablegen(CIRTypeConstraints.h.inc -gen-type-constraint-decls)
mlir_tablegen(CIRTypeConstraints.cpp.inc -gen-type-constraint-defs)
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
index 1d7e3df1430ac..e18149a61abd0 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -2463,87 +2463,11 @@ void ConvertCIRToLLVMPass::runOnOperation() {
mlir::RewritePatternSet patterns(&getContext());
- patterns.add<CIRToLLVMReturnOpLowering>(patterns.getContext());
- // This could currently be merged with the group below, but it will get more
- // arguments later, so we'll keep it separate for now.
- patterns.add<CIRToLLVMAllocaOpLowering>(converter, patterns.getContext(), dl);
- patterns.add<CIRToLLVMLoadOpLowering>(converter, patterns.getContext(), dl);
- patterns.add<CIRToLLVMStoreOpLowering>(converter, patterns.getContext(), dl);
- patterns.add<CIRToLLVMGlobalOpLowering>(converter, patterns.getContext(), dl);
- patterns.add<CIRToLLVMCastOpLowering>(converter, patterns.getContext(), dl);
- patterns.add<CIRToLLVMPtrStrideOpLowering>(converter, patterns.getContext(),
- dl);
- patterns.add<CIRToLLVMInlineAsmOpLowering>(converter, patterns.getContext(),
- dl);
patterns.add<
- // clang-format off
- CIRToLLVMACosOpLowering,
- CIRToLLVMASinOpLowering,
- CIRToLLVMAssumeOpLowering,
- CIRToLLVMAssumeAlignedOpLowering,
- CIRToLLVMAssumeSepStorageOpLowering,
- CIRToLLVMAtomicCmpXchgLowering,
- CIRToLLVMBaseClassAddrOpLowering,
- CIRToLLVMATanOpLowering,
- CIRToLLVMBinOpLowering,
- CIRToLLVMBitClrsbOpLowering,
- CIRToLLVMBitClzOpLowering,
- CIRToLLVMBitCtzOpLowering,
- CIRToLLVMBitFfsOpLowering,
- CIRToLLVMBitParityOpLowering,
- CIRToLLVMBitPopcountOpLowering,
- CIRToLLVMBitReverseOpLowering,
- CIRToLLVMBrCondOpLowering,
- CIRToLLVMBrOpLowering,
- CIRToLLVMByteSwapOpLowering,
- CIRToLLVMCallOpLowering,
- CIRToLLVMCmpOpLowering,
- CIRToLLVMComplexAddOpLowering,
- CIRToLLVMComplexCreateOpLowering,
- CIRToLLVMComplexImagOpLowering,
- CIRToLLVMComplexImagPtrOpLowering,
- CIRToLLVMComplexRealOpLowering,
- CIRToLLVMComplexRealPtrOpLowering,
- CIRToLLVMComplexSubOpLowering,
- CIRToLLVMCopyOpLowering,
- CIRToLLVMCosOpLowering,
- CIRToLLVMConstantOpLowering,
- CIRToLLVMExpectOpLowering,
- CIRToLLVMFAbsOpLowering,
- CIRToLLVMFrameAddrOpLowering,
- CIRToLLVMFuncOpLowering,
- CIRToLLVMGetBitfieldOpLowering,
- CIRToLLVMGetGlobalOpLowering,
- CIRToLLVMGetMemberOpLowering,
- CIRToLLVMReturnAddrOpLowering,
- CIRToLLVMRotateOpLowering,
- CIRToLLVMSelectOpLowering,
- CIRToLLVMSetBitfieldOpLowering,
- CIRToLLVMShiftOpLowering,
- CIRToLLVMStackRestoreOpLowering,
- CIRToLLVMStackSaveOpLowering,
- CIRToLLVMSwitchFlatOpLowering,
- CIRToLLVMThrowOpLowering,
- CIRToLLVMTrapOpLowering,
- CIRToLLVMUnaryOpLowering,
- CIRToLLVMUnreachableOpLowering,
- CIRToLLVMVAArgOpLowering,
- CIRToLLVMVAEndOpLowering,
- CIRToLLVMVAStartOpLowering,
- CIRToLLVMVecCmpOpLowering,
- CIRToLLVMVecCreateOpLowering,
- CIRToLLVMVecExtractOpLowering,
- CIRToLLVMVecInsertOpLowering,
- CIRToLLVMVecShuffleDynamicOpLowering,
- CIRToLLVMVecShuffleOpLowering,
- CIRToLLVMVecSplatOpLowering,
- CIRToLLVMVecTernaryOpLowering,
- CIRToLLVMVTableAddrPointOpLowering,
- CIRToLLVMVTableGetVPtrOpLowering,
- CIRToLLVMVTableGetVirtualFnAddrOpLowering,
- CIRToLLVMVTTAddrPointOpLowering
- // clang-format on
- >(converter, patterns.getContext());
+#define GET_LLVM_LOWERING_PATTERNS_LIST
+#include "clang/CIR/Dialect/IR/CIRLowering.inc"
+#undef GET_LLVM_LOWERING_PATTERNS_LIST
+ >(converter, patterns.getContext(), dl);
processCIRAttrs(module);
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h
index 09ff7a0901c69..0591de545b81d 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h
@@ -34,801 +34,9 @@ void convertSideEffectForCall(mlir::Operation *callOp, bool isNothrow,
mlir::LLVM::MemoryEffectsAttr &memoryEffect,
bool &noUnwind, bool &willReturn);
-class CIRToLLVMAssumeOpLowering
- : public mlir::OpConversionPattern<cir::AssumeOp> {
-public:
- using mlir::OpConversionPattern<cir::AssumeOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::AssumeOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMAssumeAlignedOpLowering
- : public mlir::OpConversionPattern<cir::AssumeAlignedOp> {
-public:
- using mlir::OpConversionPattern<cir::AssumeAlignedOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::AssumeAlignedOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMAssumeSepStorageOpLowering
- : public mlir::OpConversionPattern<cir::AssumeSepStorageOp> {
-public:
- using mlir::OpConversionPattern<cir::AssumeSepStorageOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::AssumeSepStorageOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitClrsbOpLowering
- : public mlir::OpConversionPattern<cir::BitClrsbOp> {
-public:
- using mlir::OpConversionPattern<cir::BitClrsbOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitClrsbOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitClzOpLowering
- : public mlir::OpConversionPattern<cir::BitClzOp> {
-public:
- using mlir::OpConversionPattern<cir::BitClzOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitClzOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitCtzOpLowering
- : public mlir::OpConversionPattern<cir::BitCtzOp> {
-public:
- using mlir::OpConversionPattern<cir::BitCtzOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitCtzOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitFfsOpLowering
- : public mlir::OpConversionPattern<cir::BitFfsOp> {
-public:
- using mlir::OpConversionPattern<cir::BitFfsOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitFfsOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitParityOpLowering
- : public mlir::OpConversionPattern<cir::BitParityOp> {
-public:
- using mlir::OpConversionPattern<cir::BitParityOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitParityOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitPopcountOpLowering
- : public mlir::OpConversionPattern<cir::BitPopcountOp> {
-public:
- using mlir::OpConversionPattern<cir::BitPopcountOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitPopcountOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBitReverseOpLowering
- : public mlir::OpConversionPattern<cir::BitReverseOp> {
-public:
- using mlir::OpConversionPattern<cir::BitReverseOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BitReverseOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMAtomicCmpXchgLowering
- : public mlir::OpConversionPattern<cir::AtomicCmpXchg> {
-public:
- using mlir::OpConversionPattern<cir::AtomicCmpXchg>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::AtomicCmpXchg op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMBrCondOpLowering
- : public mlir::OpConversionPattern<cir::BrCondOp> {
-public:
- using mlir::OpConversionPattern<cir::BrCondOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::BrCondOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMByteSwapOpLowering
- : public mlir::OpConversionPattern<cir::ByteSwapOp> {
-public:
- using mlir::OpConversionPattern<cir::ByteSwapOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::ByteSwapOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMCastOpLowering : public mlir::OpConversionPattern<cir::CastOp> {
- mlir::DataLayout const &dataLayout;
-
- mlir::Type convertTy(mlir::Type ty) const;
-
-public:
- CIRToLLVMCastOpLowering(const mlir::TypeConverter &typeConverter,
- mlir::MLIRContext *context,
- mlir::DataLayout const &dataLayout)
- : OpConversionPattern(typeConverter, context), dataLayout(dataLayout) {}
-
- mlir::LogicalResult
- matchAndRewrite(cir::CastOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMCopyOpLowering : public mlir::OpConversionPattern<cir::CopyOp> {
-public:
- using mlir::OpConversionPattern<cir::CopyOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::CopyOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMCosOpLowering : public mlir::OpConversionPattern<cir::CosOp> {
-public:
- using mlir::OpConversionPattern<cir::CosOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::CosOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMExpectOpLowering
- : public mlir::OpConversionPattern<cir::ExpectOp> {
-public:
- using mlir::OpConversionPattern<cir::ExpectOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::ExpectOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMReturnOpLowering
- : public mlir::OpConversionPattern<cir::ReturnOp> {
-public:
- using mlir::OpConversionPattern<cir::ReturnOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::ReturnOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const override;
-};
-
-class CIRToLLVMRotateOpLowering
- : public mlir::OpConversionPattern<cir::RotateOp> {
-public:
- using mlir::OpConversionPattern<cir::RotateOp>::OpConversionPattern;
-
- mlir::LogicalResult
- matchAndRewrite(cir::RotateOp op, OpAdaptor,
- mlir::ConversionPatternRewriter &) const overri...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/159390
More information about the cfe-commits
mailing list