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

Reply via email to