[GVN] Salvage debug info from dead insts

[vsk]

Summary

This preserves an additional 581 unique source variables in a stage2
build of clang (according to llvm-dwarfdump --statistics). It
increases the size of the .debug_loc section by 0.1% (or 87139 bytes).

lib/Transforms/Scalar/GVN.cpp

for (BasicBlock::iterator BI = BB->begin(), BE = BB->end();
     if (!AtStart)
       --BI;
 
     bool InvalidateImplicitCF = false;
     const Instruction *MaybeFirstICF = FirstImplicitControlFlowInsts.lookup(BB);
     for (auto *I : InstrsToErase) {
       assert(I->getParent() == BB && "Removing instruction from wrong block?");
       DEBUG(dbgs() << "GVN removed: " << *I << '\n');
+      salvageDebugInfo(*I);
       if (MD) MD->removeInstruction(I);
       DEBUG(verifyRemoved(I));
       if (MaybeFirstICF == I) {
         // We have erased the first ICF in block. The map needs to be updated.
         InvalidateImplicitCF = true;
         // Do not keep dangling pointer on the erased instruction.
         MaybeFirstICF = nullptr;
       }
bool GVN::performScalarPRE(Instruction *CurInst) {
   }
 
   VN.add(Phi, ValNo);
   // After creating a new PHI for ValNo, the phi translate result for ValNo will
   // be changed, so erase the related stale entries in phi translate cache.
   VN.eraseTranslateCacheEntry(ValNo, *CurrentBlock);
   addToLeaderTable(ValNo, Phi, CurrentBlock);
   Phi->setDebugLoc(CurInst->getDebugLoc());
+  salvageDebugInfo(*CurInst);
   CurInst->replaceAllUsesWith(Phi);
   if (MD && Phi->getType()->isPtrOrPtrVectorTy())
     MD->invalidateCachedPointerInfo(Phi);
   VN.erase(CurInst);
   removeFromLeaderTable(ValNo, CurInst, CurrentBlock);
 
   DEBUG(dbgs() << "GVN PRE removed: " << *CurInst << '\n');
   if (MD)

test/Transforms/GVN/PRE/phi-translate-2.ll

-; RUN: opt < %s -gvn -S | FileCheck %s
+; RUN: opt < %s -debugify -gvn -S | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @a = common global [100 x i64] zeroinitializer, align 16
 @b = common global [100 x i64] zeroinitializer, align 16
 @g1 = common global i64 0, align 8
 @g2 = common global i64 0, align 8
 @g3 = common global i64 0, align 8
 declare i64 @goo(...) local_unnamed_addr #1

 ; CHECK: br i1 %cmp
 ; CHECK: if.then2:
 ; CHECK: %[[PTRTOINT:.*]] = ptrtoint i32* %add.ptr to i64
 ; CHECK: %[[SUB:.*]] = sub i64 %sub.ptr.lhs.cast, %[[PTRTOINT]]
 ; CHECK: br label %if.end3
 ; CHECK: if.end3:
 ; CHECK: %[[PREPHI:.*]] = phi i64 [ %sub.ptr.sub, %if.else ], [ %[[SUB]], %if.then2 ], [ %sub.ptr.sub, %entry ]
 ; CHECK: %[[DIV:.*]] = ashr exact i64 %[[PREPHI]], 2
+; CHECK: call void @llvm.dbg.value(metadata i32* %p.0, metadata [[var_p0:![0-9]+]], metadata !DIExpression())
+; CHECK: call void @llvm.dbg.value(metadata i32* %p.0, metadata [[var_sub_ptr:![0-9]+]], metadata !DIExpression())
 ; CHECK: ret i64 %[[DIV]]
 
 declare void @bar(...) local_unnamed_addr #1
 
 ; Function Attrs: nounwind uwtable
 define i64 @test5(i32* %start, i32* %e, i32 %n1, i32 %n2) local_unnamed_addr #0 {
 entry:
   %sub.ptr.lhs.cast = ptrtoint i32* %e to i64

 
 if.end3:                                          ; preds = %if.then2, %if.else, %entry
   %p.0 = phi i32* [ %add.ptr, %if.then2 ], [ %start, %if.else ], [ %start, %entry ]
   %sub.ptr.rhs.cast5 = ptrtoint i32* %p.0 to i64
   %sub.ptr.sub6 = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast5
   %sub.ptr.div7 = ashr exact i64 %sub.ptr.sub6, 2
   ret i64 %sub.ptr.div7
 }
+
+; CHECK: [[var_p0]] = !DILocalVariable
+; CHECK: [[var_sub_ptr]] = !DILocalVariable

test/Transforms/GVN/fence.ll

-; RUN: opt -S -basicaa -gvn < %s | FileCheck %s
+; RUN: opt -S -debugify -basicaa -gvn < %s | FileCheck %s
 
 @a = external constant i32
 ; We can value forward across the fence since we can (semantically) 
 ; reorder the following load before the fence.
 define i32 @test(i32* %addr.i) {
 ; CHECK-LABEL: @test
 ; CHECK: store
 ; CHECK: fence
 ; CHECK-NOT: load
 ; CHECK: ret
   store i32 5, i32* %addr.i, align 4
   fence release
   %a = load i32, i32* %addr.i, align 4
   ret i32 %a
 }
 
 ; Same as above
 define i32 @test2(i32* %addr.i) {
 ; CHECK-LABEL: @test2
 ; CHECK-NEXT: fence
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* %addr.i, metadata [[var_a:![0-9]+]], metadata !DIExpression(DW_OP_deref))
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* %addr.i, metadata [[var_a2:![0-9]+]], metadata !DIExpression(DW_OP_deref))
 ; CHECK-NOT: load
 ; CHECK: ret
   %a = load i32, i32* %addr.i, align 4
   fence release
   %a2 = load i32, i32* %addr.i, align 4
   %res = sub i32 %a, %a2
   ret i32 %res
 }

 ;   do {
 ;     %res = cmpxchg %p, 0, 1, monotonic monotonic
 ;   } while(!%res.success)
 ;   fence acquire;
 ; }
 ; Given we chose to forward across the release fence, we clearly can't forward
 ; across the acquire fence as well.
 
+; CHECK: [[var_a]] = !DILocalVariable
+; CHECK-NEXT: [[var_a2]] = !DILocalVariable