[CIR] Simplify ConstantOp accesses and its getDefiningOp (#1764)

xlauko · lanza · commit bb81c1f3ec0d · 2025-08-10T22:49:20.000-07:00
- Replaces  dyn_cast&lt;cir::ConstantOp&gt;(v.getDefiningOp()) and similar with v.getDefiningOp&lt;cir::ConstantOp&gt;()
- Adds `getValueAttr`, `getIntValue` and `getBoolValue` methods to ConstantOp
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -459,6 +459,21 @@ def CIR_ConstantOp : CIR_Op<"const",[
        return ptrAttr.isNullValue();
       return false;
      }
+
+     template <typename T>
+     T getValueAttr() { return mlir::dyn_cast<T>(getValue()); }
+
+     llvm::APInt getIntValue() {
+       if (const auto intAttr = getValueAttr<cir::IntAttr>())
+         return intAttr.getValue();
+       llvm_unreachable("Expected an IntAttr in ConstantOp");
+     }
+
+     bool getBoolValue() {
+       if (const auto boolAttr = getValueAttr<cir::BoolAttr>())
+         return boolAttr.getValue();
+       llvm_unreachable("Expected a BoolAttr in ConstantOp");
+     }
   }];
 
   let hasFolder = 1;
diff --git a/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp b/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp
@@ -330,40 +330,41 @@ Address AtomicInfo::CreateTempAlloca() const {
   return TempAlloca;
 }
 
-// If the value comes from a ConstOp + IntAttr, retrieve and skip a series
-// of casts if necessary.
-//
-// FIXME(cir): figure out warning issue and move this to CIRBaseBuilder.h
-static cir::IntAttr getConstOpIntAttr(mlir::Value v) {
-  mlir::Operation *op = v.getDefiningOp();
-  cir::IntAttr constVal;
-  while (auto c = dyn_cast<cir::CastOp>(op))
-    op = c.getOperand().getDefiningOp();
-  if (auto c = dyn_cast<cir::ConstantOp>(op)) {
-    if (mlir::isa<cir::IntType>(c.getType()))
-      constVal = mlir::cast<cir::IntAttr>(c.getValue());
-  }
-  return constVal;
+static mlir::Value stripCasts(mlir::Value value) {
+  while (auto castOp = value.getDefiningOp<cir::CastOp>())
+    value = castOp.getOperand();
+  return value;
+}
+
+static cir::ConstantOp extractConstant(mlir::Value v) {
+  return stripCasts(v).getDefiningOp<cir::ConstantOp>();
+}
+
+// If the value comes from a ConstOp + IntAttr, retrieve and skip a series of
+// casts if necessary.
+static cir::IntAttr extractIntAttr(mlir::Value v) {
+  if (auto c = extractConstant(v))
+    return c.getValueAttr<cir::IntAttr>();
+  return {};
 }
 
 // Inspect a value that is the strong/weak flag for a compare-exchange.  If it
 // is a constant of intergral or boolean type, set `val` to the constant's
 // boolean value and return true.  Otherwise leave `val` unchanged and return
 // false.
 static bool isCstWeak(mlir::Value weakVal, bool &val) {
-  mlir::Operation *op = weakVal.getDefiningOp();
-  while (auto c = dyn_cast<cir::CastOp>(op)) {
-    op = c.getOperand().getDefiningOp();
-  }
-  if (auto c = dyn_cast<cir::ConstantOp>(op)) {
-    if (mlir::isa<cir::IntType>(c.getType())) {
-      val = mlir::cast<cir::IntAttr>(c.getValue()).getUInt() != 0;
+  if (auto c = extractConstant(weakVal)) {
+    if (auto attr = c.getValueAttr<cir::IntAttr>()) {
+      val = attr.getUInt() != 0;
       return true;
-    } else if (mlir::isa<cir::BoolType>(c.getType())) {
-      val = mlir::cast<cir::BoolAttr>(c.getValue()).getValue();
+    }
+
+    if (auto attr = c.getValueAttr<cir::BoolAttr>()) {
+      val = attr.getValue();
       return true;
     }
   }
+
   return false;
 }
 
@@ -456,7 +457,7 @@ static void emitAtomicCmpXchgFailureSet(
     cir::MemOrder SuccessOrder, cir::MemScopeKind Scope) {
 
   cir::MemOrder FailureOrder;
-  if (auto ordAttr = getConstOpIntAttr(FailureOrderVal)) {
+  if (auto ordAttr = extractIntAttr(FailureOrderVal)) {
     // We should not ever get to a case where the ordering isn't a valid CABI
     // value, but it's hard to enforce that in general.
     auto ord = ordAttr.getUInt();
@@ -805,7 +806,7 @@ static void emitAtomicOp(CIRGenFunction &CGF, AtomicExpr *Expr, Address Dest,
   }
 
   // Handle constant scope.
-  if (getConstOpIntAttr(Scope)) {
+  if (extractIntAttr(Scope)) {
     assert(!cir::MissingFeatures::syncScopeID());
     llvm_unreachable("NYI");
     return;
@@ -1208,7 +1209,7 @@ RValue CIRGenFunction::emitAtomicExpr(AtomicExpr *E) {
                 E->getOp() == AtomicExpr::AO__scoped_atomic_load ||
                 E->getOp() == AtomicExpr::AO__scoped_atomic_load_n;
 
-  if (auto ordAttr = getConstOpIntAttr(Order)) {
+  if (auto ordAttr = extractIntAttr(Order)) {
     // We should not ever get to a case where the ordering isn't a valid CABI
     // value, but it's hard to enforce that in general.
     auto ord = ordAttr.getUInt();
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
@@ -382,14 +382,11 @@ static mlir::Value makeAtomicFenceValue(CIRGenFunction &cgf,
   auto &builder = cgf.getBuilder();
   mlir::Value orderingVal = cgf.emitScalarExpr(expr->getArg(0));
 
-  auto constOrdering =
-      mlir::dyn_cast<cir::ConstantOp>(orderingVal.getDefiningOp());
+  auto constOrdering = orderingVal.getDefiningOp<cir::ConstantOp>();
   if (!constOrdering)
     llvm_unreachable("NYI: variable ordering not supported");
 
-  auto constOrderingAttr =
-      mlir::dyn_cast<cir::IntAttr>(constOrdering.getValue());
-  if (constOrderingAttr) {
+  if (auto constOrderingAttr = constOrdering.getValueAttr<cir::IntAttr>()) {
     cir::MemOrder ordering =
         static_cast<cir::MemOrder>(constOrderingAttr.getUInt());
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp
@@ -2123,10 +2123,7 @@ castVecOfFPTypeToVecOfIntWithSameWidth(CIRGenBuilderTy &builder,
 
 /// Get integer from a mlir::Value that is an int constant or a constant op.
 static int64_t getIntValueFromConstOp(mlir::Value val) {
-  auto constOp = mlir::cast<cir::ConstantOp>(val.getDefiningOp());
-  return (mlir::cast<cir::IntAttr>(constOp.getValue()))
-      .getValue()
-      .getSExtValue();
+  return val.getDefiningOp<cir::ConstantOp>().getIntValue().getSExtValue();
 }
 
 static mlir::Value emitNeonSplat(CIRGenBuilderTy &builder, mlir::Location loc,
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp
@@ -68,10 +68,7 @@ translateX86ToMsvcIntrin(unsigned BuiltinID) {
 
 /// Get integer from a mlir::Value that is an int constant or a constant op.
 static int64_t getIntValueFromConstOp(mlir::Value val) {
-  auto constOp = mlir::cast<cir::ConstantOp>(val.getDefiningOp());
-  return (mlir::cast<cir::IntAttr>(constOp.getValue()))
-      .getValue()
-      .getSExtValue();
+  return val.getDefiningOp<cir::ConstantOp>().getIntValue().getSExtValue();
 }
 
 // Convert the mask from an integer type to a vector of i1.
@@ -274,9 +271,8 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
   case X86::BI__builtin_ia32_vec_ext_v4di: {
     unsigned NumElts = cast<cir::VectorType>(Ops[0].getType()).getSize();
 
-    auto constOp = cast<cir::ConstantOp>(Ops[1].getDefiningOp());
-    auto intAttr = cast<cir::IntAttr>(constOp.getValue());
-    uint64_t index = intAttr.getValue().getZExtValue();
+    uint64_t index =
+        Ops[1].getDefiningOp<cir::ConstantOp>().getIntValue().getZExtValue();
 
     index &= NumElts - 1;
 
@@ -301,9 +297,8 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
   case X86::BI__builtin_ia32_vec_set_v4di: {
     unsigned NumElts = cast<cir::VectorType>(Ops[0].getType()).getSize();
 
-    auto constOp = cast<cir::ConstantOp>(Ops[2].getDefiningOp());
-    auto intAttr = cast<cir::IntAttr>(constOp.getValue());
-    uint64_t index = intAttr.getValue().getZExtValue();
+    uint64_t index =
+        Ops[2].getDefiningOp<cir::ConstantOp>().getIntValue().getZExtValue();
 
     index &= NumElts - 1;
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
@@ -1833,13 +1833,16 @@ void CIRGenFunction::emitCXXAggrConstructorCall(
   // llvm::BranchInst *zeroCheckBranch = nullptr;
 
   // Optimize for a constant count.
-  auto constantCount = dyn_cast<cir::ConstantOp>(numElements.getDefiningOp());
-  if (constantCount) {
-    auto constIntAttr = mlir::dyn_cast<cir::IntAttr>(constantCount.getValue());
-    // Just skip out if the constant count is zero.
-    if (constIntAttr && constIntAttr.getUInt() == 0)
-      return;
-    // Otherwise, emit the check.
+  if (auto constantCount = numElements.getDefiningOp<cir::ConstantOp>()) {
+    if (auto constIntAttr = constantCount.getValueAttr<cir::IntAttr>()) {
+      // Just skip out if the constant count is zero.
+      if (constIntAttr.getUInt() == 0)
+        return;
+      // Otherwise, emit the check.
+    }
+
+    if (constantCount.use_empty())
+      constantCount.erase();
   } else {
     llvm_unreachable("NYI");
   }
@@ -1902,9 +1905,6 @@ void CIRGenFunction::emitCXXAggrConstructorCall(
           builder.create<cir::YieldOp>(loc);
         });
   }
-
-  if (constantCount.use_empty())
-    constantCount.erase();
 }
 
 static bool canEmitDelegateCallArgs(CIRGenFunction &CGF,
diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
@@ -1154,13 +1154,16 @@ void CIRGenFunction::emitDestroy(Address addr, QualType type,
   bool checkZeroLength = true;
 
   // But if the array length is constant, we can suppress that.
-  auto constantCount = dyn_cast<cir::ConstantOp>(length.getDefiningOp());
-  if (constantCount) {
-    auto constIntAttr = mlir::dyn_cast<cir::IntAttr>(constantCount.getValue());
-    // ...and if it's constant zero, we can just skip the entire thing.
-    if (constIntAttr && constIntAttr.getUInt() == 0)
-      return;
-    checkZeroLength = false;
+  if (auto constantCount = length.getDefiningOp<cir::ConstantOp>()) {
+    if (auto constIntAttr = constantCount.getValueAttr<cir::IntAttr>()) {
+      // ...and if it's constant zero, we can just skip the entire thing.
+      if (constIntAttr.getUInt() == 0)
+        return;
+      checkZeroLength = false;
+    }
+
+    if (constantCount.use_empty())
+      constantCount.erase();
   } else {
     llvm_unreachable("NYI");
   }
@@ -1169,8 +1172,6 @@ void CIRGenFunction::emitDestroy(Address addr, QualType type,
   mlir::Value end; // Use this for future non-constant counts.
   emitArrayDestroy(begin, end, type, elementAlign, destroyer, checkZeroLength,
                    useEHCleanupForArray);
-  if (constantCount.use_empty())
-    constantCount.erase();
 }
 
 CIRGenFunction::Destroyer *
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -1676,17 +1676,16 @@ static bool isPreserveAIArrayBase(CIRGenFunction &CGF, const Expr *ArrayBase) {
 
 static mlir::IntegerAttr getConstantIndexOrNull(mlir::Value idx) {
   // TODO(cir): should we consider using MLIRs IndexType instead of IntegerAttr?
-  if (auto constantOp = dyn_cast<cir::ConstantOp>(idx.getDefiningOp()))
-    return mlir::dyn_cast<mlir::IntegerAttr>(constantOp.getValue());
+  if (auto constantOp = idx.getDefiningOp<cir::ConstantOp>())
+    return constantOp.getValueAttr<mlir::IntegerAttr>();
   return {};
 }
 
 static CharUnits getArrayElementAlign(CharUnits arrayAlign, mlir::Value idx,
                                       CharUnits eltSize) {
   // If we have a constant index, we can use the exact offset of the
   // element we're accessing.
-  auto constantIdx = getConstantIndexOrNull(idx);
-  if (constantIdx) {
+  if (auto constantIdx = getConstantIndexOrNull(idx)) {
     CharUnits offset = constantIdx.getValue().getZExtValue() * eltSize;
     return arrayAlign.alignmentAtOffset(offset);
     // Otherwise, use the worst-case alignment for any element.
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp
@@ -1099,12 +1099,12 @@ void CIRGenFunction::emitNewArrayInitializer(
 
   // If all elements have already been initialized, skip any further
   // initialization.
-  auto ConstOp = dyn_cast<cir::ConstantOp>(NumElements.getDefiningOp());
-  if (ConstOp) {
-    auto ConstIntAttr = mlir::dyn_cast<cir::IntAttr>(ConstOp.getValue());
-    // Just skip out if the constant count is zero.
-    if (ConstIntAttr && ConstIntAttr.getUInt() <= InitListElements)
-      return;
+  if (auto ConstOp = NumElements.getDefiningOp<cir::ConstantOp>()) {
+    if (auto ConstIntAttr = ConstOp.getValueAttr<cir::IntAttr>()) {
+      // Just skip out if the constant count is zero.
+      if (ConstIntAttr.getUInt() <= InitListElements)
+        return;
+    }
   }
 
   assert(Init && "have trailing elements to initialize but no initializer");
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp
@@ -2113,8 +2113,7 @@ mlir::Attribute ConstantEmitter::emitAbstract(SourceLocation loc,
 mlir::Attribute ConstantEmitter::emitNullForMemory(mlir::Location loc,
                                                    CIRGenModule &CGM,
                                                    QualType T) {
-  auto cstOp =
-      dyn_cast<cir::ConstantOp>(CGM.emitNullConstant(T, loc).getDefiningOp());
+  auto cstOp = CGM.emitNullConstant(T, loc).getDefiningOp<cir::ConstantOp>();
   assert(cstOp && "expected cir.const op");
   return emitForMemory(CGM, cstOp.getValue(), T);
 }
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -54,8 +54,8 @@ struct BinOpInfo {
   /// Check if the binop can result in integer overflow.
   bool mayHaveIntegerOverflow() const {
     // Without constant input, we can't rule out overflow.
-    auto LHSCI = dyn_cast<cir::ConstantOp>(LHS.getDefiningOp());
-    auto RHSCI = dyn_cast<cir::ConstantOp>(RHS.getDefiningOp());
+    auto LHSCI = LHS.getDefiningOp<cir::ConstantOp>();
+    auto RHSCI = RHS.getDefiningOp<cir::ConstantOp>();
     if (!LHSCI || !RHSCI)
       return true;
 
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -1025,7 +1025,7 @@ void cir::StoreOp::setAtomic(cir::MemOrder order) {
 
 OpFoldResult cir::VecCreateOp::fold(FoldAdaptor adaptor) {
   if (llvm::any_of(getElements(), [](mlir::Value value) {
-        return !mlir::isa<cir::ConstantOp>(value.getDefiningOp());
+        return !value.getDefiningOp<cir::ConstantOp>();
       }))
     return {};
 
diff --git a/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp b/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp
@@ -97,8 +97,8 @@ struct SimplifyTernary final : public OpRewritePattern<TernaryOp> {
     // Check whether the region/block contains a cir.const followed by a
     // cir.yield that yields the value.
     auto yieldOp = mlir::cast<cir::YieldOp>(onlyBlock.getTerminator());
-    auto yieldValueDefOp = mlir::dyn_cast_if_present<cir::ConstantOp>(
-        yieldOp.getArgs()[0].getDefiningOp());
+    auto yieldValueDefOp =
+        yieldOp.getArgs()[0].getDefiningOp<cir::ConstantOp>();
     return yieldValueDefOp && yieldValueDefOp->getBlock() == &onlyBlock;
   }
 };
@@ -108,18 +108,13 @@ struct SimplifySelect : public OpRewritePattern<SelectOp> {
 
   LogicalResult matchAndRewrite(SelectOp op,
                                 PatternRewriter &rewriter) const final {
-    mlir::Operation *trueValueOp = op.getTrueValue().getDefiningOp();
-    mlir::Operation *falseValueOp = op.getFalseValue().getDefiningOp();
-    auto trueValueConstOp =
-        mlir::dyn_cast_if_present<cir::ConstantOp>(trueValueOp);
-    auto falseValueConstOp =
-        mlir::dyn_cast_if_present<cir::ConstantOp>(falseValueOp);
-    if (!trueValueConstOp || !falseValueConstOp)
+    auto trueValueOp = op.getTrueValue().getDefiningOp<cir::ConstantOp>();
+    auto falseValueOp = op.getFalseValue().getDefiningOp<cir::ConstantOp>();
+    if (!trueValueOp || !falseValueOp)
       return mlir::failure();
 
-    auto trueValue = mlir::dyn_cast<cir::BoolAttr>(trueValueConstOp.getValue());
-    auto falseValue =
-        mlir::dyn_cast<cir::BoolAttr>(falseValueConstOp.getValue());
+    auto trueValue = trueValueOp.getValueAttr<cir::BoolAttr>();
+    auto falseValue = falseValueOp.getValueAttr<cir::BoolAttr>();
     if (!trueValue || !falseValue)
       return mlir::failure();
 
@@ -145,9 +140,7 @@ struct SimplifyVecSplat : public OpRewritePattern<VecSplatOp> {
   using OpRewritePattern<VecSplatOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(VecSplatOp op,
                                 PatternRewriter &rewriter) const override {
-    mlir::Value splatValue = op.getValue();
-    auto constant =
-        mlir::dyn_cast_if_present<cir::ConstantOp>(splatValue.getDefiningOp());
+    auto constant = op.getValue().getDefiningOp<cir::ConstantOp>();
     if (!constant)
       return mlir::failure();
 
diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp
@@ -1423,8 +1423,7 @@ static std::string getGlobalVarNameForConstString(cir::StoreOp op,
 void LoweringPreparePass::lowerToMemCpy(StoreOp op) {
   // Now that basic filter is done, do more checks before proceding with the
   // transformation.
-  auto cstOp =
-      dyn_cast_if_present<cir::ConstantOp>(op.getValue().getDefiningOp());
+  auto cstOp = op.getValue().getDefiningOp<cir::ConstantOp>();
   if (!cstOp)
     return;
 
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -3657,12 +3657,11 @@ mlir::LogicalResult CIRToLLVMSelectOpLowering::matchAndRewrite(
     cir::SelectOp op, OpAdaptor adaptor,
     mlir::ConversionPatternRewriter &rewriter) const {
   auto getConstantBool = [](mlir::Value value) -> std::optional<bool> {
-    auto definingOp =
-        mlir::dyn_cast_if_present<cir::ConstantOp>(value.getDefiningOp());
+    auto definingOp = value.getDefiningOp<cir::ConstantOp>();
     if (!definingOp)
       return std::nullopt;
 
-    auto constValue = mlir::dyn_cast<cir::BoolAttr>(definingOp.getValue());
+    auto constValue = definingOp.getValueAttr<cir::BoolAttr>();
     if (!constValue)
       return std::nullopt;
 
