WIP: [mem2reg] Refactor load of uninitialized memory to poison semantics

[jmciver]

Summary

Part of a sequence of exploratory patches using poison semantics for
uninitialized memory.

This commit adds freeze_bits metadata support to mem2reg.

Regression test changes will be added in a future WIP patch.

[jmciver]

Remove extra call to replaceAllUsesWith.

[jmciver]

Add conditional check to prevent the freezing of a load with freeze_bits metadata

llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp

 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
 #include <algorithm>
for (User *U : make_early_inc_range(AI->users())) {
 
     // Find the nearest store that has a lower index than this load.
     StoresByIndexTy::iterator I = llvm::lower_bound(
         StoresByIndex,
         std::make_pair(LoadIdx, static_cast<StoreInst *>(nullptr)),
         less_first());
     Value *ReplVal;
     if (I == StoresByIndex.begin()) {
-      if (StoresByIndex.empty())
-        // If there are no stores, the load takes the undef value.
-        ReplVal = getInitialValueOfAllocation(AI, nullptr, LI->getType()).second;
-      else
+      if (StoresByIndex.empty()) {
+        // If there are no stores, the load may take a poison or freeze poison
+        // value value.
+        auto [QueryEnum, QueryReplVal] =
+            getInitialValueOfAllocation(AI, nullptr, LI->getType(), LI);
+        switch (QueryEnum) {
+        case InitializationCategory::Unknown:
+          return false;
+          break;
+        case InitializationCategory::Constant:
+          ReplVal = QueryReplVal;
+          break;
+        case InitializationCategory::FreezePoison:
+          IRBuilder<> Builder(LI);
+          ReplVal =
+              Builder.CreateFreeze(PoisonValue::get(LI->getType()), "freeze");
+          break;
+        }
+      } else {
         // There is no store before this load, bail out (load may be affected
         // by the following stores - see main comment).
         return false;
+      }
     } else {
       // Otherwise, there was a store before this load, the load takes its
       // value.
       ReplVal = std::prev(I)->second->getOperand(0);
+      if (!loadHasFreezeBits(dyn_cast<LoadInst>(ReplVal)) &&
+          loadHasFreezeBits(LI)) {
+        IRBuilder<> Builder(LI);
+        ReplVal = Builder.CreateFreeze(ReplVal, "freeze");
+      }
     }
 
     convertMetadataToAssumes(LI, ReplVal, DL, AC, &DT);
 
     // If the replacement value is the load, this must occur in unreachable
     // code.
     if (ReplVal == LI)
       ReplVal = PoisonValue::get(LI->getType());
void PromoteMem2Reg::run() {
   }
   LBI.clear();
 
   // Set the incoming values for the basic block to be null values for all of
   // the alloca's.  We do this in case there is a load of a value that has not
   // been stored yet.  In this case, it will get this null value.
   RenamePassData::ValVector Values(Allocas.size());
   for (unsigned i = 0, e = Allocas.size(); i != e; ++i)
-    Values[i] = UndefValue::get(Allocas[i]->getAllocatedType());
+    Values[i] = PoisonValue::get(Allocas[i]->getAllocatedType());
 
   // When handling debug info, treat all incoming values as if they have unknown
   // locations until proven otherwise.
   RenamePassData::LocationVector Locations(Allocas.size());
 
   // Walks all basic blocks in the function performing the SSA rename algorithm
   // and inserting the phi nodes we marked as necessary
   std::vector<RenamePassData> RenamePassWorkList;
if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
       DenseMap<AllocaInst *, unsigned>::iterator AI = AllocaLookup.find(Src);
       if (AI == AllocaLookup.end())
         continue;
 
       Value *V = IncomingVals[AI->second];
       convertMetadataToAssumes(LI, V, SQ.DL, AC, &DT);
 
       // Anything using the load now uses the current value.
+      if (loadHasFreezeBits(LI)) {
+        IRBuilder<> Builder(LI);
+        V = Builder.CreateFreeze(V, "freeze.load");
+      }
       LI->replaceAllUsesWith(V);
       LI->eraseFromParent();
     } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
       // Delete this instruction and mark the name as the current holder of the
       // value
       AllocaInst *Dest = dyn_cast<AllocaInst>(SI->getPointerOperand());
       if (!Dest)
         continue;