[Local] Add a utility to insert replacement dbg.values, NFC

[vsk]

Summary

The purpose of this utility is to make it easier for optimizations to
insert replacement dbg.values for instructions they are deleting. This
is useful in situations where salvageDebugInfo is inapplicable, say,
because the new dbg.value cannot refer to an operand of the dying value.

The utility is called insertReplacementDbgValues.

It assumes that the instruction 'From' is going to be deleted, and
inserts replacement dbg.values for each debug user of 'From'. The
newly-inserted dbg.values refer to 'To' instead of 'From'. Each
replacement dbg.value has the same location and variable as the debug
user it replaces, has a DIExpression determined by the result of
'RewriteExpr' applied to an old debug user of 'From', and is placed
before 'InsertBefore'.

This should simplify future patches, like D48331.

[probinson]

Looks useful, especially given the context of the other patch. LGTM.

[vsk]

Thanks for the review! Landed in rL335144.

include/llvm/Transforms/Utils/Local.h

 // program.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_LOCAL_H
 #define LLVM_TRANSFORMS_UTILS_LOCAL_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/Utils/Local.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"

 void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
                               DIBuilder &Builder, int Offset = 0);
 
 /// Assuming the instruction \p I is going to be deleted, attempt to salvage any
 /// dbg.value intrinsics referring to \p I by rewriting its effect into a
 /// DIExpression.
 void salvageDebugInfo(Instruction &I);
 
+/// Assuming the instruction \p From is going to be deleted, insert replacement
+/// dbg.value intrinsics for each debug user of \p From. The newly-inserted
+/// dbg.values refer to \p To instead of \p From. Each replacement dbg.value
+/// has the same location and variable as the debug user it replaces, has a
+/// DIExpression determined by the result of \p RewriteExpr applied to an old
+/// debug user of \p From, and is placed before \p InsertBefore.
+void insertReplacementDbgValues(
+    Instruction &From, Instruction &To, Instruction &InsertBefore,
+    function_ref<DIExpression *(DbgInfoIntrinsic &OldDII)> RewriteExpr);
+
 /// Remove all instructions from a basic block other than it's terminator
 /// and any present EH pad instructions.
 unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB);
 
 /// Insert an unreachable instruction before the specified
 /// instruction, making it and the rest of the code in the block dead.
 unsigned changeToUnreachable(Instruction *I, bool UseLLVMTrap,
                              bool PreserveLCSSA = false,

lib/Transforms/InstCombine/InstCombineCasts.cpp

Instruction *InstCombiner::commonCastTransforms(CastInst &CI) {
 
   // Try to eliminate a cast of a cast.
   if (auto *CSrc = dyn_cast<CastInst>(Src)) {   // A->B->C cast
     if (Instruction::CastOps NewOpc = isEliminableCastPair(CSrc, &CI)) {
       // The first cast (CSrc) is eliminable so we need to fix up or replace
       // the second cast (CI). CSrc will then have a good chance of being dead.
       auto *Res = CastInst::Create(NewOpc, CSrc->getOperand(0), CI.getType());
 
-      // If the eliminable cast has debug users, insert a debug value after the
-      // cast pointing to the new Value.
-      SmallVector<DbgInfoIntrinsic *, 1> CSrcDbgInsts;
-      findDbgUsers(CSrcDbgInsts, CSrc);
-      if (CSrcDbgInsts.size()) {
-        DIBuilder DIB(*CI.getModule());
-        for (auto *DII : CSrcDbgInsts)
-          DIB.insertDbgValueIntrinsic(
-              Res, DII->getVariable(), DII->getExpression(),
-              DII->getDebugLoc().get(), &*std::next(CI.getIterator()));
-      }
+      // Replace debug users of the eliminable cast by emitting debug values
+      // which refer to the new cast.
+      insertReplacementDbgValues(
+          *CSrc, *Res, *std::next(CI.getIterator()),
+          [](DbgInfoIntrinsic &OldDII) { return OldDII.getExpression(); });
+
       return Res;
     }
   }
 
   if (auto *Sel = dyn_cast<SelectInst>(Src)) {
     // We are casting a select. Try to fold the cast into the select, but only
     // if the select does not have a compare instruction with matching operand
     // types. Creating a select with operands that are different sizes than its

lib/Transforms/Utils/Local.cpp

for (auto *DII : DbgUsers) {
       DIExpr = DIExpression::prepend(DIExpr, DIExpression::WithDeref);
       DII->setOperand(0, AddrMD);
       DII->setOperand(2, MetadataAsValue::get(I.getContext(), DIExpr));
       LLVM_DEBUG(dbgs() << "SALVAGE:  " << *DII << '\n');
     }
   }
 }
 
+void llvm::insertReplacementDbgValues(
+    Instruction &From, Instruction &To, Instruction &InsertBefore,
+    function_ref<DIExpression *(DbgInfoIntrinsic &OldDII)> RewriteExpr) {
+  // Collect all debug users of From.
+  SmallVector<DbgInfoIntrinsic *, 1> Users;
+  findDbgUsers(Users, &From);
+  if (Users.empty())
+    return;
+
+  // Insert a replacement debug value before each old debug user. It's assumed
+  // that the old debug users will be erased later.
+  DIBuilder DIB(*From.getModule());
+  for (auto *OldDII : Users)
+    DIB.insertDbgValueIntrinsic(&To, OldDII->getVariable(),
+                                RewriteExpr(*OldDII),
+                                OldDII->getDebugLoc().get(), &InsertBefore);
+}
+
 unsigned llvm::removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB) {
   unsigned NumDeadInst = 0;
   // Delete the instructions backwards, as it has a reduced likelihood of
   // having to update as many def-use and use-def chains.
   Instruction *EndInst = BB->getTerminator(); // Last not to be deleted.
   while (EndInst != &BB->front()) {
     // Delete the next to last instruction.
     Instruction *Inst = &*--EndInst->getIterator();