[ValueTracking] Adjust hash table structure

Author: dtcxzyw

llvm/include/llvm/Analysis/DomConditionCache.h

@@ -34,6 +34,7 @@ enum class DomConditionFlag : uint8_t {
   KnownFPClass = 1 << 1,
   PowerOfTwo = 1 << 2,
   ICmp = 1 << 3,
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ICmp),
 };
 
 LLVM_DECLARE_ENUM_AS_BITMASK(
@@ -43,23 +44,26 @@ LLVM_DECLARE_ENUM_AS_BITMASK(
 class DomConditionCache {
 private:
   /// A map of values about which a branch might be providing information.
-  using AffectedValuesMap =
-      DenseMap<Value *,
-               SmallVector<std::pair<BranchInst *, DomConditionFlag>, 1>>;
-  AffectedValuesMap AffectedValues;
+  using AffectedValuesMap = DenseMap<Value *, SmallVector<BranchInst *, 1>>;
+  AffectedValuesMap AffectedValues[BitWidth<DomConditionFlag>];
 
 public:
   /// Add a branch condition to the cache.
   void registerBranch(BranchInst *BI);
 
   /// Remove a value from the cache, e.g. because it will be erased.
-  void removeValue(Value *V) { AffectedValues.erase(V); }
+  void removeValue(Value *V) {
+    for (auto &Table : AffectedValues)
+      Table.erase(V);
+  }
 
   /// Access the list of branches which affect this value.
-  ArrayRef<std::pair<BranchInst *, DomConditionFlag>>
-  conditionsFor(const Value *V) const {
-    auto AVI = AffectedValues.find_as(const_cast<Value *>(V));
-    if (AVI == AffectedValues.end())
+  ArrayRef<BranchInst *> conditionsFor(const Value *V,
+                                       DomConditionFlag Filter) const {
+    assert(has_single_bit(to_underlying(Filter)));
+    auto &Values = AffectedValues[countr_zero(to_underlying(Filter))];
+    auto AVI = Values.find_as(const_cast<Value *>(V));
+    if (AVI == Values.end())
       return {};
 
     return AVI->second;

llvm/lib/Analysis/DomConditionCache.cpp

@@ -24,16 +24,13 @@ void DomConditionCache::registerBranch(BranchInst *BI) {
   SmallVector<std::pair<Value *, DomConditionFlag>, 16> Affected;
   findAffectedValues(BI->getCondition(), Affected);
   for (auto [V, Flags] : Affected) {
-    auto &AV = AffectedValues[V];
-    bool Exist = false;
-    for (auto &[OtherBI, OtherFlags] : AV) {
-      if (OtherBI == BI) {
-        OtherFlags |= Flags;
-        Exist = true;
-        break;
-      }
+    uint32_t Underlying = to_underlying(Flags);
+    while (Underlying) {
+      uint32_t LSB = Underlying & -Underlying;
+      auto &AV = AffectedValues[countr_zero(LSB)][V];
+      if (llvm::none_of(AV, [&](BranchInst *Elem) { return Elem == BI; }))
+        AV.push_back(BI);
+      Underlying -= LSB;
     }
-    if (!Exist)
-      AV.push_back({BI, Flags});
   }
 }

llvm/lib/Analysis/ValueTracking.cpp

@@ -790,9 +790,7 @@ void llvm::computeKnownBitsFromContext(const Value *V, KnownBits &Known,
 
   if (Q.DC && Q.DT) {
     // Handle dominating conditions.
-    for (auto [BI, Flag] : Q.DC->conditionsFor(V)) {
-      if (!any(Flag & DomConditionFlag::KnownBits))
-        continue;
+    for (BranchInst *BI : Q.DC->conditionsFor(V, DomConditionFlag::KnownBits)) {
       BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));
       if (Q.DT->dominates(Edge0, Q.CxtI->getParent()))
         computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
@@ -2301,9 +2299,8 @@ bool llvm::isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth,
 
   // Handle dominating conditions.
   if (Q.DC && Q.CxtI && Q.DT) {
-    for (auto [BI, Flag] : Q.DC->conditionsFor(V)) {
-      if (!any(Flag & DomConditionFlag::PowerOfTwo))
-        continue;
+    for (BranchInst *BI :
+         Q.DC->conditionsFor(V, DomConditionFlag::PowerOfTwo)) {
       Value *Cond = BI->getCondition();
 
       BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));
@@ -4934,9 +4931,8 @@ static KnownFPClass computeKnownFPClassFromContext(const Value *V,
 
   if (Q.DC && Q.DT) {
     // Handle dominating conditions.
-    for (auto [BI, Flag] : Q.DC->conditionsFor(V)) {
-      if (!any(Flag & DomConditionFlag::KnownFPClass))
-        continue;
+    for (BranchInst *BI :
+         Q.DC->conditionsFor(V, DomConditionFlag::KnownFPClass)) {
       Value *Cond = BI->getCondition();
 
       BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

@@ -1385,9 +1385,7 @@ Instruction *InstCombinerImpl::foldICmpWithDominatingICmp(ICmpInst &Cmp) {
     return nullptr;
   };
 
-  for (auto [BI, Flags] : DC.conditionsFor(X)) {
-    if (!any(Flags & DomConditionFlag::ICmp))
-      continue;
+  for (BranchInst *BI : DC.conditionsFor(X, DomConditionFlag::ICmp)) {
     ICmpInst::Predicate DomPred;
     const APInt *DomC;
     if (!match(BI->getCondition(),