[DebugInfo] Support for DW_OP_implicit_pointer (for temp references & dynamic allocations)

[alok]

Summary

This is a POC patch. Before review, it needs more maturity.

This patch (10/N) stems from D69787

This enables debugger (using DW_OP_implicit_pointer) to display de-referenced value of pointer in case temporary is optimized out. It happens in case of reference or dynamic allocation.

Testing:

-Added unit test for validation thru llvm IR
-check-llvm (LLDB need to be modifed to support this)
-check-debuginfo (the debug info integration tests)

[alok]

Re-based and updated.

[alok]

Re-based and cleanup.

llvm/lib/IR/Instruction.cpp

 bool Instruction::salvageDebugInfoForDbgValues(
     ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
   auto &Ctx = getContext();
   auto wrapMD = [&](Value *V) {
     return MetadataAsValue::get(Ctx, ValueAsMetadata::get(V));
   };
   bool Changed = false;
   Value *DebugDeclareAddress = nullptr;
+  SmallVector<StoreInst *, 1> StoreInsts;
+  DenseMap<DIScope *, DILocalVariable *> ScopeTmpMap;
+  static unsigned TmpCount = 0;
 
-  if ((getModule()->getDwarfVersion() >= 5) && isa<AllocaInst>(*this)) {
+  if (getModule()->getDwarfVersion() >= 5) {
+    if(isa<AllocaInst>(*this)) {
       for (auto *DII : DbgUsers) {
         if (DII->isAddressOfVariable()) {
           if (const llvm::MetadataAsValue *MDV =
                   dyn_cast<llvm::MetadataAsValue>(DII->getOperand(1)))
             if (isa<DILocalVariable>(MDV->getMetadata())) {
               DebugDeclareAddress = DII->getOperand(1);
             }
           break;
         }
       }
+    }
+
     if (!DebugDeclareAddress)
       DebugDeclareAddress = getModule()->findVarAddressMap(this);
+
+    if (!DebugDeclareAddress) {
+      StoreInst *SI;
+      for (auto &AIUse : uses()) {
+        User *U = AIUse.getUser();
+        if ((SI = dyn_cast<StoreInst>(U)) && SI->getOperand(1) == this)
+          StoreInsts.push_back(SI);
+      }
+    }
   }
 
   for (auto *DII : DbgUsers) {
     // Do not add DW_OP_stack_value for DbgDeclare and DbgAddr, because they
     // are implicitly pointing out the value as a DWARF memory location
     // description.
     bool StackValue = isa<DbgValueInst>(DII);
 
     DIExpression *DIExpr =
         salvageDebugInfoImpl(DII->getExpression(), StackValue);
 
     // salvageDebugInfoImpl should fail on examining the first element of
     // DbgUsers, or none of them.
     if (!DIExpr)
       continue;
 
     int64_t ExprOffset = 0;
 
     // It is AllocaInst and either of below is true then continue
     //   - We failed to get the variable description, or
     //   - Current instruction is not llvm.dbg.value, or
     //   - Current instruction doesnt have constant offset
-    if (isa<AllocaInst>(this) &&
+    if (!StoreInsts.empty()) {
+      if(!DII->getExpression()->extractIfOffset(ExprOffset))
+        continue;
+    } else if (isa<AllocaInst>(this) &&
         (!DebugDeclareAddress || DII->isAddressOfVariable() ||
          !DII->getExpression()->extractIfOffset(ExprOffset)))
       continue;
 
-    if (isa<AllocaInst>(this)) {
+    if (!StoreInsts.empty()) {
+      DIBuilder DIB(*getModule(), /*AllowUnresolved*/ false);
+
+      DIExpression *DIExpr = DII->getExpression();
+      DIScope *Scope = DII->getDebugLoc()->getScope();
+    
+      // If this is new Scope lets insert dbg.value before Store Inst
+      if (ScopeTmpMap.find(Scope) == ScopeTmpMap.end()) {
+        std::string SName("__implicit_ptr_tmp_");
+        SName.append(std::to_string(TmpCount++));
+        llvm::StringRef Name(SName);
+        uint32_t AlignInBits = DII->getVariable()->getAlignInBytes();
+        DIType *Type = DII->getVariable()->getType();
+        if (DIDerivedType *DT = dyn_cast<DIDerivedType>(Type))
+          Type = DT->getBaseType();
+
+        ScopeTmpMap[Scope] = DIB.createAutoVariable(Scope, Name, nullptr, 0,
+                                                   Type, false,
+                                                   llvm::DINode::FlagArtificial,
+                                                   AlignInBits);
+
+        for (auto *SI : StoreInsts) {
+          Value *ReplVal = SI->getOperand(0);
+          DIB.insertDbgValueIntrinsic(ReplVal, ScopeTmpMap[Scope],
+                                   DIExpression::get(DIExpr->getContext(), {}),
+                                   DII->getDebugLoc(), SI);
+        }
+      }
+
+      // lets replace dbg.value with dbg.derefval
+      SmallVector<uint64_t, 3> Ops;
+      Ops.push_back(dwarf::DW_OP_LLVM_implicit_pointer);
+      Ops.push_back(dwarf::DW_OP_LLVM_arg0);
+      Ops.push_back(ExprOffset);
+      DIExpression *DIExprNew = DIExpression::get(DIExpr->getContext(), Ops);
+
+      DIB.insertDbgDerefValueIntrinsic(ScopeTmpMap[Scope],
+                                       DII->getVariable(), DIExprNew,
+                                       DII->getDebugLoc(), DII);
+
+      DII->eraseFromParent();
+      Changed = true;
+    } else if (isa<AllocaInst>(this)) {
       // It will cause below transformation
       //
       // Before transformation
       //
       // %a = alloca [2 x i32], align 4
       // call void @llvm.dbg.declare(metadata [2 x i32]* %arr, metadata !16,
       // metadata !DIExpression()), !dbg !22
       //

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

for (unsigned i = 0, e = Users.size(); i != e; ++i) {
                             ConstantInt::get(Type::getInt1Ty(C->getContext()),
                                              C->isFalseWhenEqual()));
       } else if (auto *SI = dyn_cast<StoreInst>(I)) {
         for (auto *DII : DIIs)
           ConvertDebugDeclareToDebugValue(DII, SI, *DIB);
       } else {
         // Casts, GEP, or anything else: we're about to delete this instruction,
         // so it can not have any valid uses.
+        I->salvageDebugInfo();
         replaceInstUsesWith(*I, UndefValue::get(I->getType()));
       }
       eraseInstFromFunction(*I);
     }
 
     if (InvokeInst *II = dyn_cast<InvokeInst>(&MI)) {
       // Replace invoke with a NOP intrinsic to maintain the original CFG
       Module *M = II->getModule();

llvm/test/DebugInfo/implicit_pointer_temp_dyn_alloc.cc

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+// CHECK:  !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)
+// CHECK:  !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)
+
+int main() {
+  int *i = new int(3);
+  int *j = new int(4);
+  delete i;
+  delete j;
+
+  return 0;
+}

llvm/test/DebugInfo/implicit_pointer_temp_reference.cc

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+// CHECK:  !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)
+
+__attribute__((optnone)) int source() {
+  return 3;
+}
+__attribute__((optnone)) void f(int i) {
+}
+inline void sink(const int& p) {
+  f(p);
+}
+int main() {
+  sink(source());
+}