https://github.com/xlauko created https://github.com/llvm/llvm-project/pull/240540
Stacked on #195618. The lowering patterns generated from `llvmOp` build the LLVM operation with default properties, so any CIR op whose LLVM counterpart carries a flag property had to be lowered by hand. `llvmOpProps` names the LLVM properties to set and the C++ expression that produces each value, evaluated with `op` and `adaptor` in scope; the emitter assigns them through the property setters before building the op. `cir.add`, `cir.sub` and `cir.mul` (overflow flags) and `cir.vec.reduce.fadd/fmul/fmax/fmin` (fastmath flags) switch to it, and their hand-written patterns and `lowerFPVectorReduction` go away. `convertOverflowFlags` and a `FastmathFlagsAttr`-returning `convertFastMathFlags` move into `LowerToLLVM.h` so the generated code can reach them. Left for later: `cir.fmaxnum`/`cir.fminnum` (constant `nsz` plus the fenv path) and `cir.inc`/`cir.dec`/`cir.minus` (synthesized constant operand) still need hand-written lowering. Assisted-by: Claude Code (Claude Fable 5.1). >From 599f04fe0c8ae399f346adafb6e6b0d33c9f4660 Mon Sep 17 00:00:00 2001 From: Henrich Lauko <[email protected]> Date: Mon, 9 Nov 2026 20:55:02 +0000 Subject: [PATCH] [CIR] Let llvmOp lowering set LLVM op properties The lowering patterns generated from `llvmOp` build the LLVM operation with default properties, so any CIR op whose LLVM counterpart carries a flag property had to be lowered by hand. `llvmOpProps` names the LLVM properties to set and the C++ expression that produces each value, evaluated with `op` and `adaptor` in scope; the emitter assigns them through the property setters before building the op. cir.add, cir.sub and cir.mul (overflow flags) and cir.vec.reduce.fadd/fmul/fmax/fmin (fastmath flags) switch to it, and their hand-written patterns and lowerFPVectorReduction go away. convertOverflowFlags and a FastmathFlagsAttr-returning convertFastMathFlags move into LowerToLLVM.h so the generated code can reach them. Assisted-by: Claude Code (Claude Fable 5.1). --- clang/include/clang/CIR/Dialect/IR/CIROps.td | 52 ++++++++--- .../CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 86 ++----------------- .../CIR/Lowering/DirectToLLVM/LowerToLLVM.h | 6 ++ clang/utils/TableGen/CIRLoweringEmitter.cpp | 41 ++++++--- 4 files changed, 83 insertions(+), 102 deletions(-) diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td index f75601738e2c0c..eccb3f1d65928e 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIROps.td +++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td @@ -71,6 +71,14 @@ include "mlir/Interfaces/SideEffectInterfaces.td" // } // } // +// The LLVM operation is built with default properties. `llvmOpProps` names +// the properties to set instead and the C++ expression, evaluated with `op` +// and `adaptor` in scope, that produces each value: +// +// let llvmOp = "AddOp"; +// let llvmOpProps = (ins +// "convertOverflowFlags(op.getOverflowFlags())":$overflowFlags); +// // If you want fully customized LLVM IR lowering logic, simply exclude the // `llvmOp` field from your CIR operation definition. // @@ -85,6 +93,7 @@ include "mlir/Interfaces/SideEffectInterfaces.td" // exception-behavior metadata argument. class LLVMLoweringInfo { string llvmOp = ""; + dag llvmOpProps = (ins); string constrainedLLVMIntrinsic = ""; bit constrainedLLVMIntrinsicHasRoundingMode = true; } @@ -2837,8 +2846,8 @@ class CIR_BinaryOp<string mnemonic, Type type, list<Trait> traits = [], }]; } -class CIR_BinaryOpWithOverflowFlags<string mnemonic, Type type, - list<Trait> traits = []> +class CIR_BinaryOpWithOverflowFlags<string mnemonic, string llvmOpName, + Type type, list<Trait> traits = []> : CIR_BinaryOp<mnemonic, type, traits> { let append traits = [Pure]; @@ -2850,6 +2859,10 @@ class CIR_BinaryOpWithOverflowFlags<string mnemonic, Type type, let assemblyFormat = [{ ($overflow_flags^)? $lhs `,` $rhs `:` type($lhs) attr-dict }]; + + let llvmOp = llvmOpName; + let llvmOpProps = (ins + "convertOverflowFlags(op.getOverflowFlags())":$overflowFlags); } //===----------------------------------------------------------------------===// @@ -2857,7 +2870,8 @@ class CIR_BinaryOpWithOverflowFlags<string mnemonic, Type type, //===----------------------------------------------------------------------===// def CIR_AddOp - : CIR_BinaryOpWithOverflowFlags<"add", CIR_AnyIntOrVecOrMatrixOfIntType> { + : CIR_BinaryOpWithOverflowFlags<"add", "AddOp", + CIR_AnyIntOrVecOrMatrixOfIntType> { let summary = "Integer addition"; let description = [{ The `cir.add` operation performs addition on integer operands. Both @@ -2886,7 +2900,8 @@ def CIR_AddOp //===----------------------------------------------------------------------===// def CIR_SubOp - : CIR_BinaryOpWithOverflowFlags<"sub", CIR_AnyIntOrVecOrMatrixOfIntType> { + : CIR_BinaryOpWithOverflowFlags<"sub", "SubOp", + CIR_AnyIntOrVecOrMatrixOfIntType> { let summary = "Integer subtraction"; let description = [{ The `cir.sub` operation performs subtraction on integer operands. Both @@ -2915,7 +2930,8 @@ def CIR_SubOp //===----------------------------------------------------------------------===// def CIR_MulOp - : CIR_BinaryOpWithOverflowFlags<"mul", CIR_AnyIntOrVecOrMatrixOfIntType> { + : CIR_BinaryOpWithOverflowFlags<"mul", "MulOp", + CIR_AnyIntOrVecOrMatrixOfIntType> { let summary = "Integer multiplication"; let description = [{ The `cir.mul` operation performs multiplication on integer operands. Both @@ -6559,9 +6575,9 @@ def CIR_VecReduceXorOp : CIR_VecReduceOp<"xor", CIR_VectorOfIntOrBoolType, "vector_reduce_xor">; -// Floating-point reductions use custom lowering to translate CIR fast-math -// flags to the corresponding LLVM dialect attribute. -class CIR_VecReduceFPOp<string mnemonic> +// Floating-point reductions carry fast-math flags, forwarded to the LLVM op +// through `llvmOpProps`. +class CIR_VecReduceFPOp<string mnemonic, string llvmOpName> : CIR_Op<"vec.reduce." # mnemonic, [ Pure, TypesMatchWith<"type of 'result' matches element type of 'input'", @@ -6579,12 +6595,17 @@ class CIR_VecReduceFPOp<string mnemonic> `(` $input `)` `:` functional-type(operands, results) prop-dict attr-dict }]; + + let llvmOp = llvmOpName; + let llvmOpProps = (ins + "convertFastMathFlags(op.getContext(), op.getFastmathFlags())" + :$fastmathFlags); } -def CIR_VecReduceFMaxOp : CIR_VecReduceFPOp<"fmax">; -def CIR_VecReduceFMinOp : CIR_VecReduceFPOp<"fmin">; +def CIR_VecReduceFMaxOp : CIR_VecReduceFPOp<"fmax", "vector_reduce_fmax">; +def CIR_VecReduceFMinOp : CIR_VecReduceFPOp<"fmin", "vector_reduce_fmin">; -class CIR_VecReduceAccFPOp<string mnemonic> +class CIR_VecReduceAccFPOp<string mnemonic, string llvmOpName> : CIR_Op<"vec.reduce." # mnemonic, [ Pure, TypesMatchWith<"type of 'accumulator' matches element type of 'input'", @@ -6606,10 +6627,15 @@ class CIR_VecReduceAccFPOp<string mnemonic> `(` $accumulator `,` $input `)` `:` functional-type(operands, results) prop-dict attr-dict }]; + + let llvmOp = llvmOpName; + let llvmOpProps = (ins + "convertFastMathFlags(op.getContext(), op.getFastmathFlags())" + :$fastmathFlags); } -def CIR_VecReduceFAddOp : CIR_VecReduceAccFPOp<"fadd">; -def CIR_VecReduceFMulOp : CIR_VecReduceAccFPOp<"fmul">; +def CIR_VecReduceFAddOp : CIR_VecReduceAccFPOp<"fadd", "vector_reduce_fadd">; +def CIR_VecReduceFMulOp : CIR_VecReduceAccFPOp<"fmul", "vector_reduce_fmul">; //===----------------------------------------------------------------------===// // VecCmpOp diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 4a117865cab43e..2278ec992c2494 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -727,6 +727,13 @@ mlir::LogicalResult lowerConstrainableFPOp( fastmathFlags); } +mlir::LLVM::FastmathFlagsAttr +cir::direct::convertFastMathFlags(mlir::MLIRContext *ctx, + std::optional<cir::FastMathFlags> flags) { + return mlir::LLVM::FastmathFlagsAttr::get( + ctx, flags ? convertFastMathFlags(*flags) : mlir::LLVM::FastmathFlags{}); +} + static mlir::LLVM::FastmathFlags convertFastMathFlags(cir::FastMathFlags cirFlags) { mlir::LLVM::FastmathFlags llvmFlags{}; @@ -3928,8 +3935,8 @@ static bool isIntTypeUnsigned(mlir::Type type) { // Binary Op Lowering //===----------------------------------------------------------------------===// -static mlir::LLVM::IntegerOverflowFlags -convertOverflowFlags(cir::OverflowFlags flags) { +mlir::LLVM::IntegerOverflowFlags +cir::direct::convertOverflowFlags(cir::OverflowFlags flags) { mlir::LLVM::IntegerOverflowFlags result = mlir::LLVM::IntegerOverflowFlags::none; if (bitEnumContainsAny(flags, cir::OverflowFlags::NoSignedWrap)) @@ -3939,33 +3946,6 @@ convertOverflowFlags(cir::OverflowFlags flags) { return result; } -mlir::LogicalResult CIRToLLVMAddOpLowering::matchAndRewrite( - cir::AddOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - rewriter.replaceOpWithNewOp<mlir::LLVM::AddOp>( - op, adaptor.getLhs(), adaptor.getRhs(), - convertOverflowFlags(op.getOverflowFlags())); - return mlir::success(); -} - -mlir::LogicalResult CIRToLLVMSubOpLowering::matchAndRewrite( - cir::SubOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - rewriter.replaceOpWithNewOp<mlir::LLVM::SubOp>( - op, adaptor.getLhs(), adaptor.getRhs(), - convertOverflowFlags(op.getOverflowFlags())); - return mlir::success(); -} - -mlir::LogicalResult CIRToLLVMMulOpLowering::matchAndRewrite( - cir::MulOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - rewriter.replaceOpWithNewOp<mlir::LLVM::MulOp>( - op, adaptor.getLhs(), adaptor.getRhs(), - convertOverflowFlags(op.getOverflowFlags())); - return mlir::success(); -} - /// Lower an integer op to its signed or unsigned LLVM counterpart. template <typename UIntOp, typename SIntOp, typename CIROp> static mlir::LogicalResult @@ -5720,54 +5700,6 @@ mlir::LogicalResult CIRToLLVMVecInsertOpLowering::matchAndRewrite( return mlir::success(); } -template <typename LLVMOp, typename CIROp> -static mlir::LogicalResult -lowerFPVectorReduction(CIROp op, typename CIROp::Adaptor adaptor, - const mlir::TypeConverter &typeConverter, - mlir::ConversionPatternRewriter &rewriter) { - mlir::Type resultTy = typeConverter.convertType(op.getType()); - mlir::LLVM::FastmathFlags fastmathFlags{}; - if (std::optional<cir::FastMathFlags> fastmath = op.getFastmathFlags()) - fastmathFlags = convertFastMathFlags(*fastmath); - - typename LLVMOp::Properties properties = - cir::getDefaultProperties<LLVMOp>(op.getContext()); - properties.setFastmathFlags( - mlir::LLVM::FastmathFlagsAttr::get(op.getContext(), fastmathFlags)); - rewriter.replaceOpWithNewOp<LLVMOp>(op, mlir::TypeRange{resultTy}, - adaptor.getOperands(), properties); - - return mlir::success(); -} - -mlir::LogicalResult CIRToLLVMVecReduceFAddOpLowering::matchAndRewrite( - cir::VecReduceFAddOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - return lowerFPVectorReduction<mlir::LLVM::vector_reduce_fadd>( - op, adaptor, *getTypeConverter(), rewriter); -} - -mlir::LogicalResult CIRToLLVMVecReduceFMulOpLowering::matchAndRewrite( - cir::VecReduceFMulOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - return lowerFPVectorReduction<mlir::LLVM::vector_reduce_fmul>( - op, adaptor, *getTypeConverter(), rewriter); -} - -mlir::LogicalResult CIRToLLVMVecReduceFMaxOpLowering::matchAndRewrite( - cir::VecReduceFMaxOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - return lowerFPVectorReduction<mlir::LLVM::vector_reduce_fmax>( - op, adaptor, *getTypeConverter(), rewriter); -} - -mlir::LogicalResult CIRToLLVMVecReduceFMinOpLowering::matchAndRewrite( - cir::VecReduceFMinOp op, OpAdaptor adaptor, - mlir::ConversionPatternRewriter &rewriter) const { - return lowerFPVectorReduction<mlir::LLVM::vector_reduce_fmin>( - op, adaptor, *getTypeConverter(), rewriter); -} - mlir::LogicalResult CIRToLLVMVecCmpOpLowering::matchAndRewrite( cir::VecCmpOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h index 692a424ccce5b4..06a672632faf9b 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h @@ -104,6 +104,12 @@ mlir::LogicalResult lowerConstrainableFPOp( mlir::ConversionPatternRewriter &rewriter, llvm::StringRef constrainedMnemonic, bool hasRoundingMode); +// Property conversions used by generated `llvmOpProps` lowerings. +mlir::LLVM::IntegerOverflowFlags convertOverflowFlags(cir::OverflowFlags flags); +mlir::LLVM::FastmathFlagsAttr +convertFastMathFlags(mlir::MLIRContext *ctx, + std::optional<cir::FastMathFlags> flags); + #define GET_LLVM_LOWERING_PATTERNS #include "clang/CIR/Dialect/IR/CIRLowering.inc" #undef GET_LLVM_LOWERING_PATTERNS diff --git a/clang/utils/TableGen/CIRLoweringEmitter.cpp b/clang/utils/TableGen/CIRLoweringEmitter.cpp index 285fc8d67b1483..eec77debc11ef6 100644 --- a/clang/utils/TableGen/CIRLoweringEmitter.cpp +++ b/clang/utils/TableGen/CIRLoweringEmitter.cpp @@ -11,6 +11,7 @@ //===----------------------------------------------------------------------===// #include "TableGenBackends.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/TableGen/Error.h" #include "llvm/TableGen/Record.h" #include "llvm/TableGen/TableGenBackend.h" @@ -147,14 +148,12 @@ void GenerateABILoweringPattern(llvm::StringRef OpName, CXXABILoweringPatterns.push_back(std::move(CodeBuffer)); } -void GenerateLLVMLoweringPattern(llvm::StringRef OpName, - llvm::StringRef PatternName, bool IsRecursive, - llvm::StringRef ExtraDecl, - const Record *CustomCtorRec, - llvm::StringRef LLVMOp, - llvm::StringRef ConstrainedLLVMIntrinsic, - bool ConstrainedHasRoundingMode, - bool HasFastMathFlags, bool HasZeroResult) { +void GenerateLLVMLoweringPattern( + llvm::StringRef OpName, llvm::StringRef PatternName, bool IsRecursive, + llvm::StringRef ExtraDecl, const Record *CustomCtorRec, + llvm::StringRef LLVMOp, const DagInit *LLVMOpProps, + llvm::StringRef ConstrainedLLVMIntrinsic, bool ConstrainedHasRoundingMode, + bool HasFastMathFlags, bool HasZeroResult) { std::optional<CustomLoweringCtor> CustomCtor = parseCustomLoweringCtor(CustomCtorRec); std::string CodeBuffer; @@ -232,6 +231,16 @@ void GenerateLLVMLoweringPattern(llvm::StringRef OpName, std::string Properties = "cir::getDefaultProperties<mlir::LLVM::" + LLVMOp.str() + ">(op.getContext())"; + if (LLVMOpProps->getNumArgs() != 0) { + Code << " auto props = " << Properties << ";\n"; + for (const auto &[Expr, Name] : LLVMOpProps->getArgAndNames()) { + Code << " props.set" + << llvm::convertToCamelFromSnakeCase(Name->getAsUnquotedString(), + /*capitalizeFirst=*/true) + << "(" << Expr->getAsUnquotedString() << ");\n"; + } + Properties = "props"; + } if (HasZeroResult) { Code << " rewriter.replaceOpWithNewOp<mlir::LLVM::" << LLVMOp << ">(op, mlir::TypeRange{}, adaptor.getOperands(), " << Properties @@ -283,6 +292,7 @@ void Generate(const Record *OpRecord) { OpRecord->getValueAsString("extraLLVMLoweringPatternDecl"); llvm::StringRef LLVMOp = OpRecord->getValueAsString("llvmOp"); + const DagInit *LLVMOpProps = OpRecord->getValueAsDag("llvmOpProps"); llvm::StringRef ConstrainedLLVMIntrinsic = OpRecord->getValueAsString("constrainedLLVMIntrinsic"); bool ConstrainedHasRoundingMode = @@ -305,12 +315,19 @@ void Generate(const Record *OpRecord) { "' has constrainedLLVMIntrinsic set but no llvmOp, " "which is not supported"); + if (LLVMOpProps->getNumArgs() != 0 && + (LLVMOp.empty() || !ConstrainedLLVMIntrinsic.empty())) + PrintFatalError(OpRecord->getLoc(), + "op '" + OpName + + "' has llvmOpProps, which requires llvmOp and is " + "not supported with constrainedLLVMIntrinsic"); + const DagInit *ResultsDag = OpRecord->getValueAsDag("results"); bool IsZeroResult = ResultsDag->getNumArgs() == 0; - GenerateLLVMLoweringPattern(OpName, PatternName, IsRecursive, ExtraDecl, - CustomCtor, LLVMOp, ConstrainedLLVMIntrinsic, - ConstrainedHasRoundingMode, HasFastMathFlags, - IsZeroResult); + GenerateLLVMLoweringPattern( + OpName, PatternName, IsRecursive, ExtraDecl, CustomCtor, LLVMOp, + LLVMOpProps, ConstrainedLLVMIntrinsic, ConstrainedHasRoundingMode, + HasFastMathFlags, IsZeroResult); // Only automatically register patterns that use the default constructor. // Patterns with a custom constructor must be manually registered by the // lowering pass. _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
