[llvm] StructurizeCFG: Optimize phi insertion during ssa reconstruction (PR #101301)

[Matt Arsenault via llvm-commits]

================
@@ -710,10 +717,104 @@ void StructurizeCFG::findUndefBlocks(
   }
 }
 
+// If two PHI nodes have compatible incoming values (for each
+// incoming block, either they have the same incoming value or only one PHI
+// node has a incoming value), let them share the merged incoming values.
+void StructurizeCFG::mergeIfCompatible(PHINode *A, PHINode *B) {
+
+  auto ItA = MergedPHIMap.find(A);
+  auto ItB = MergedPHIMap.find(B);
+  bool FoundA = ItA != MergedPHIMap.end();
+  bool FoundB = ItB != MergedPHIMap.end();
+
+  // Skip phis that were both already merged with others.
+  if (FoundA && FoundB)
+    return;
+
+  const auto &IncomingA =
+      FoundA ? BBValuesPool[ItA->second] : DeletedPhis[A->getParent()][A];
+  const auto &IncomingB =
+      FoundB ? BBValuesPool[ItB->second] : DeletedPhis[B->getParent()][B];
+
+  DenseMap<BasicBlock *, Value *> Mergeable(IncomingA.begin(), IncomingA.end());
+  for (auto &[BB, V] : IncomingB) {
+    if (Mergeable.contains(BB) && Mergeable[BB] != V)
+      return;
+    // Either IncomingA does not have this value or IncomingA has the same
+    // value.
+    Mergeable.insert({BB, V});
+  }
+
+  unsigned PoolIndex;
+
+  if (FoundA || FoundB) {
+    PoolIndex = FoundA ? ItA->second : ItB->second;
+    BBValuesPool[PoolIndex].clear();
+    BBValuesPool[PoolIndex].append(Mergeable.begin(), Mergeable.end());
+  } else {
+    PoolIndex = BBValuesPool.size();
+    BBValuesPool.emplace_back(Mergeable.begin(), Mergeable.end());
+  }
+
+  // Skip insertion if Phi was already merged with other phi node.
+  if (!FoundA)
+    MergedPHIMap.insert({A, PoolIndex});
+
+  if (!FoundB)
+    MergedPHIMap.insert({B, PoolIndex});
+
+  return;
+}
+
 /// Add the real PHI value as soon as everything is set up
 void StructurizeCFG::setPhiValues() {
   SmallVector<PHINode *, 8> InsertedPhis;
   SSAUpdater Updater(&InsertedPhis);
+
+  // Find out phi nodes that have compatible incoming values (either they have
+  // the same value for the same block or one have undefined value, see example
+  // below). We only search again the phi's that are referenced by another phi,
+  // which is the cases we care.
+  //
+  // For example (-- means no incoming value):
+  // phi1 : BB1:phi2   BB2:v  BB3:--
+  // phi2:  BB1:--     BB2:v  BB3:w
+  //
+  // Then we can merge these incoming values and let phi1, phi2 use the
+  // same set of incoming values:
+  //
+  // phi1&phi2: BB1:phi2  BB2:v  BB3:w
+  //
+  // By doing this, phi1 and phi2 would share more intermediate phi nodes.
+  // This would help reducing number of phi nodes during SSA reconstruction and
+  // get less COPY instructions finally.
+  //
+  // This should be correct, because if a phi node does not have incoming
+  // value from certain block, this means the block is not the predecessor
+  // of the parent block, so we actually don't care its incoming value.
----------------
arsenm wrote:

```suggestion
  // of the parent block, so we actually don't care about its incoming value.
```

https://github.com/llvm/llvm-project/pull/101301