[llvm] Revert [VPlan] Use bitfield to store Cmp predicates and GEP wrap flags (PR #184584)

Ramkumar Ramachandra via llvm-commits llvm-commits at lists.llvm.org
Wed Mar 4 02:57:19 PST 2026


https://github.com/artagnon created https://github.com/llvm/llvm-project/pull/184584

This reverts commit 17aaa0e590a7, or #181571, due to multiple reported crashes.

>From 0a3f154c68fac0e36067ee916e0eba87c930065b Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Wed, 4 Mar 2026 10:54:38 +0000
Subject: [PATCH] Revert [VPlan] Use bitfield to store Cmp predicates and GEP
 wrap flags

This reverts commit 17aaa0e590a7, or #181571, due to multiple reported
crashes.
---
 llvm/lib/Transforms/Vectorize/VPlan.h         | 60 +++++++------------
 .../lib/Transforms/Vectorize/VPlanRecipes.cpp | 18 +++---
 2 files changed, 31 insertions(+), 47 deletions(-)

diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index 978b467521a52..5a75f28b21ba9 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -25,7 +25,6 @@
 #define LLVM_TRANSFORMS_VECTORIZE_VPLAN_H
 
 #include "VPlanValue.h"
-#include "llvm/ADT/Bitfields.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -727,7 +726,7 @@ class VPIRFlags {
   /// Holds both the predicate and fast-math flags for floating-point
   /// comparisons.
   struct FCmpFlagsTy {
-    uint8_t CmpPredStorage;
+    CmpInst::Predicate Pred;
     FastMathFlagsTy FMFs;
   };
   /// Holds reduction-specific flags: RecurKind, IsOrdered, IsInLoop, and FMFs.
@@ -749,33 +748,30 @@ class VPIRFlags {
   OperationType OpType;
 
   union {
-    uint8_t CmpPredStorage;
+    CmpInst::Predicate CmpPredicate;
     WrapFlagsTy WrapFlags;
     TruncFlagsTy TruncFlags;
     DisjointFlagsTy DisjointFlags;
     ExactFlagsTy ExactFlags;
-    uint8_t GEPFlagsStorage;
+    GEPNoWrapFlags GEPFlags;
     NonNegFlagsTy NonNegFlags;
     FastMathFlagsTy FMFs;
     FCmpFlagsTy FCmpFlags;
     ReductionFlagsTy ReductionFlags;
+    unsigned AllFlags;
   };
 
 public:
-  VPIRFlags() : OpType(OperationType::Other), CmpPredStorage(0) {}
+  VPIRFlags() : OpType(OperationType::Other), AllFlags(0) {}
 
   VPIRFlags(Instruction &I) {
     if (auto *FCmp = dyn_cast<FCmpInst>(&I)) {
       OpType = OperationType::FCmp;
-      Bitfield::set<CmpInst::PredicateField>(FCmpFlags.CmpPredStorage,
-                                             FCmp->getPredicate());
-      assert(getPredicate() == FCmp->getPredicate() && "predicate truncated");
+      FCmpFlags.Pred = FCmp->getPredicate();
       FCmpFlags.FMFs = FCmp->getFastMathFlags();
     } else if (auto *Op = dyn_cast<CmpInst>(&I)) {
       OpType = OperationType::Cmp;
-      Bitfield::set<CmpInst::PredicateField>(CmpPredStorage,
-                                             Op->getPredicate());
-      assert(getPredicate() == Op->getPredicate() && "predicate truncated");
+      CmpPredicate = Op->getPredicate();
     } else if (auto *Op = dyn_cast<PossiblyDisjointInst>(&I)) {
       OpType = OperationType::DisjointOp;
       DisjointFlags.IsDisjoint = Op->isDisjoint();
@@ -790,9 +786,7 @@ class VPIRFlags {
       ExactFlags.IsExact = Op->isExact();
     } else if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
       OpType = OperationType::GEPOp;
-      GEPFlagsStorage = GEP->getNoWrapFlags().getRaw();
-      assert(getGEPNoWrapFlags() == GEP->getNoWrapFlags() &&
-             "wrap flags truncated");
+      GEPFlags = GEP->getNoWrapFlags();
     } else if (auto *PNNI = dyn_cast<PossiblyNonNegInst>(&I)) {
       OpType = OperationType::NonNegOp;
       NonNegFlags.NonNeg = PNNI->hasNonNeg();
@@ -801,19 +795,16 @@ class VPIRFlags {
       FMFs = Op->getFastMathFlags();
     } else {
       OpType = OperationType::Other;
-      CmpPredStorage = 0;
+      AllFlags = 0;
     }
   }
 
-  VPIRFlags(CmpInst::Predicate Pred) : OpType(OperationType::Cmp) {
-    Bitfield::set<CmpInst::PredicateField>(CmpPredStorage, Pred);
-    assert(getPredicate() == Pred && "predicate truncated");
-  }
+  VPIRFlags(CmpInst::Predicate Pred)
+      : OpType(OperationType::Cmp), CmpPredicate(Pred) {}
 
   VPIRFlags(CmpInst::Predicate Pred, FastMathFlags FMFs)
       : OpType(OperationType::FCmp) {
-    Bitfield::set<CmpInst::PredicateField>(FCmpFlags.CmpPredStorage, Pred);
-    assert(getPredicate() == Pred && "predicate truncated");
+    FCmpFlags.Pred = Pred;
     FCmpFlags.FMFs = FMFs;
   }
 
@@ -835,13 +826,16 @@ class VPIRFlags {
       : OpType(OperationType::PossiblyExactOp), ExactFlags(ExactFlags) {}
 
   VPIRFlags(GEPNoWrapFlags GEPFlags)
-      : OpType(OperationType::GEPOp), GEPFlagsStorage(GEPFlags.getRaw()) {}
+      : OpType(OperationType::GEPOp), GEPFlags(GEPFlags) {}
 
   VPIRFlags(RecurKind Kind, bool IsOrdered, bool IsInLoop, FastMathFlags FMFs)
       : OpType(OperationType::ReductionOp),
         ReductionFlags(Kind, IsOrdered, IsInLoop, FMFs) {}
 
-  void transferFlags(VPIRFlags &Other) { *this = Other; }
+  void transferFlags(VPIRFlags &Other) {
+    OpType = Other.OpType;
+    AllFlags = Other.AllFlags;
+  }
 
   /// Only keep flags also present in \p Other. \p Other must have the same
   /// OpType as the current object.
@@ -867,7 +861,7 @@ class VPIRFlags {
       ExactFlags.IsExact = false;
       break;
     case OperationType::GEPOp:
-      GEPFlagsStorage = 0;
+      GEPFlags = GEPNoWrapFlags::none();
       break;
     case OperationType::FPMathOp:
     case OperationType::FCmp:
@@ -902,8 +896,7 @@ class VPIRFlags {
       I.setIsExact(ExactFlags.IsExact);
       break;
     case OperationType::GEPOp:
-      cast<GetElementPtrInst>(&I)->setNoWrapFlags(
-          GEPNoWrapFlags::fromRaw(GEPFlagsStorage));
+      cast<GetElementPtrInst>(&I)->setNoWrapFlags(GEPFlags);
       break;
     case OperationType::FPMathOp:
     case OperationType::FCmp: {
@@ -931,24 +924,19 @@ class VPIRFlags {
   CmpInst::Predicate getPredicate() const {
     assert((OpType == OperationType::Cmp || OpType == OperationType::FCmp) &&
            "recipe doesn't have a compare predicate");
-    uint8_t Storage = OpType == OperationType::FCmp ? FCmpFlags.CmpPredStorage
-                                                    : CmpPredStorage;
-    return Bitfield::get<CmpInst::PredicateField>(Storage);
+    return OpType == OperationType::FCmp ? FCmpFlags.Pred : CmpPredicate;
   }
 
   void setPredicate(CmpInst::Predicate Pred) {
     assert((OpType == OperationType::Cmp || OpType == OperationType::FCmp) &&
            "recipe doesn't have a compare predicate");
     if (OpType == OperationType::FCmp)
-      Bitfield::set<CmpInst::PredicateField>(FCmpFlags.CmpPredStorage, Pred);
+      FCmpFlags.Pred = Pred;
     else
-      Bitfield::set<CmpInst::PredicateField>(CmpPredStorage, Pred);
-    assert(getPredicate() == Pred && "predicate truncated");
+      CmpPredicate = Pred;
   }
 
-  GEPNoWrapFlags getGEPNoWrapFlags() const {
-    return GEPNoWrapFlags::fromRaw(GEPFlagsStorage);
-  }
+  GEPNoWrapFlags getGEPNoWrapFlags() const { return GEPFlags; }
 
   /// Returns true if the recipe has a comparison predicate.
   bool hasPredicate() const {
@@ -1054,8 +1042,6 @@ class VPIRFlags {
 #endif
 };
 
-static_assert(sizeof(VPIRFlags) <= 3, "VPIRFlags should not grow");
-
 /// A pure-virtual common base class for recipes defining a single VPValue and
 /// using IR flags.
 struct VPRecipeWithIRFlags : public VPSingleDefRecipe, public VPIRFlags {
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 26183f15306f1..ce64ab927182c 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -334,12 +334,12 @@ void VPIRFlags::intersectFlags(const VPIRFlags &Other) {
     ExactFlags.IsExact &= Other.ExactFlags.IsExact;
     break;
   case OperationType::GEPOp:
-    GEPFlagsStorage &= Other.GEPFlagsStorage;
+    GEPFlags &= Other.GEPFlags;
     break;
   case OperationType::FPMathOp:
   case OperationType::FCmp:
     assert((OpType != OperationType::FCmp ||
-            FCmpFlags.CmpPredStorage == Other.FCmpFlags.CmpPredStorage) &&
+            FCmpFlags.Pred == Other.FCmpFlags.Pred) &&
            "Cannot drop CmpPredicate");
     getFMFsRef().NoNaNs &= Other.getFMFsRef().NoNaNs;
     getFMFsRef().NoInfs &= Other.getFMFsRef().NoInfs;
@@ -348,8 +348,7 @@ void VPIRFlags::intersectFlags(const VPIRFlags &Other) {
     NonNegFlags.NonNeg &= Other.NonNegFlags.NonNeg;
     break;
   case OperationType::Cmp:
-    assert(CmpPredStorage == Other.CmpPredStorage &&
-           "Cannot drop CmpPredicate");
+    assert(CmpPredicate == Other.CmpPredicate && "Cannot drop CmpPredicate");
     break;
   case OperationType::ReductionOp:
     assert(ReductionFlags.Kind == Other.ReductionFlags.Kind &&
@@ -362,6 +361,7 @@ void VPIRFlags::intersectFlags(const VPIRFlags &Other) {
     getFMFsRef().NoInfs &= Other.getFMFsRef().NoInfs;
     break;
   case OperationType::Other:
+    assert(AllFlags == Other.AllFlags && "Cannot drop other flags");
     break;
   }
 }
@@ -2219,16 +2219,14 @@ void VPIRFlags::printFlags(raw_ostream &O) const {
   case OperationType::FPMathOp:
     getFastMathFlags().print(O);
     break;
-  case OperationType::GEPOp: {
-    GEPNoWrapFlags Flags = getGEPNoWrapFlags();
-    if (Flags.isInBounds())
+  case OperationType::GEPOp:
+    if (GEPFlags.isInBounds())
       O << " inbounds";
-    else if (Flags.hasNoUnsignedSignedWrap())
+    else if (GEPFlags.hasNoUnsignedSignedWrap())
       O << " nusw";
-    if (Flags.hasNoUnsignedWrap())
+    if (GEPFlags.hasNoUnsignedWrap())
       O << " nuw";
     break;
-  }
   case OperationType::NonNegOp:
     if (NonNegFlags.NonNeg)
       O << " nneg";



More information about the llvm-commits mailing list