[RewriteStatepoints] Fix phis with different incoming Loads for the same incoming blocks

[yrouban]

Summary

In relocationViaAlloca()

for each given pair (Alloca, Def) 
  for each Phi use of the Def 
    for each its incoming value
      the incoming value is substituted with a new Load Alloca instruction generated at the end of the incoming block.

Phi is allowed to have several incoming (value, block) pairs with the same block only if their values are the same. So, we must not generate a new Load for an incoming block if we have already generated one Load for this block.

This patch keeps a Block->Load map to reuse generated Loads for their incoming block.

[dneilson]

Please add a test case that demonstrates the patch in action (and would prevent regressions).

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

for (auto Pair : AllocaMap) {
 
     std::sort(Uses.begin(), Uses.end());
     auto Last = std::unique(Uses.begin(), Uses.end());
     Uses.erase(Last, Uses.end());
 
     for (Instruction *Use : Uses) {
       if (isa<PHINode>(Use)) {
         PHINode *Phi = cast<PHINode>(Use);
+        DenseMap<BasicBlock *, LoadInst *> NewLoads;
         for (unsigned i = 0; i < Phi->getNumIncomingValues(); i++) {
           if (Def == Phi->getIncomingValue(i)) {
-            LoadInst *Load = new LoadInst(
+            auto Found = NewLoads.find(Phi->getIncomingBlock(i));
+            LoadInst *Load;
+            if (Found != NewLoads.end()) {
+              Load = Found->second;
+            } else {
+              Load = new LoadInst(
                 Alloca, "", Phi->getIncomingBlock(i)->getTerminator());
+              NewLoads[Phi->getIncomingBlock(i)] = Load;
+            }
             Phi->setIncomingValue(i, Load);
           }
         }
       } else {
         LoadInst *Load = new LoadInst(Alloca, "", Use);
         Use->replaceUsesOfWith(Def, Load);
       }
     }