[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