[DebugInfo] Support for DW_OP_implicit_pointer (salvagDebugInfo improvement).

[alok]

Summary

This patch (6/N) stems from D69787 as suggested by reviewers.

Summary:

  Whenever alloca is getting deleted, lets handle this to preserve debug info
 - Collect a variable description from corresponding llvm.dbg.declare intrinsic and pass that information to llvm.dbg.value intrinsic to create

 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
     call void @llvm.dbg.value(metadata [2 x i32]* %arr, metadata !20, metadata !DIExpression()), !dbg !24
     !16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 5, type: !17)
     !20 = !DILocalVariable(name: "ptr", scope: !12, file: !3, line: 6, type: !21)

 After Transformation
     %a = alloca [2 x i32], align 4
     call void @llvm.dbg.declare(metadata [2 x i32]* %arr, metadata !16, metadata !DIExpression()), !dbg !22
     call void @llvm.dbg.derefval(metadata !16, metadata !20, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !24
     call void @llvm.dbg.derefval(metadata !16, metadata !20, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 4)), !dbg !24

     - In case llvm.dbg.declare is getting deleted before alloca instruction, preserve variable description map to use later.
 
Testing:
   - check-llvm
   - check-debuginfo (the debug info integration tests)

[alok]

-Updated to use "git show" in place of "git diff" used earlier

[alok]

Updated to re-base due to changes in trunk and parent patches.

[Orlando]

Hi @alok. I haven't been following the DW_OP_implicit_pointer discussion too closely, so just some inline nitpick comments/questions from me.

Thanks,
Orlando

llvm/include/llvm/IR/Module.h

197

Are you using a std::map for a specific reason? Could you not use a std::unordered_map, or better yet, a DenseMap [0] or similar llvm container here instead?

[0] http://llvm.org/docs/ProgrammersManual.html#llvm-adt-densemap-h

llvm/lib/IR/DebugInfoMetadata.cpp

1000–1004

Why not unsigned numElements = getNumElements(); ?

llvm/lib/Transforms/Utils/Local.cpp

1637–1638

Please can you capitalise these variable names?

[alok]

In D70260#1758219, @Orlando wrote:

Hi @alok. I haven't been following the DW_OP_implicit_pointer discussion too closely, so just some inline nitpick comments/questions from me.

Thanks,
Orlando

Thanks for your comments. Next version would have all your comments incorporated. Please let me know if you have any more comments.

llvm/include/llvm/IR/Module.h

197

Thanks for the suggestion, It will be updated in next version to use DenseMap.

llvm/lib/IR/DebugInfoMetadata.cpp

1000–1004

Thanks for your comment. It will be updated in next version.

llvm/lib/Transforms/Utils/Local.cpp

1637–1638

Thanks for your comment. It will be updated in next version.

[alok]

Updated to incorporate comments from @Orlando .

llvm/include/llvm/IR/Module.h

 #include <cstdint>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
+class DbgVariableIntrinsic;
 class Error;
 class FunctionType;
 class GVMaterializer;
 class LLVMContext;
 class MemoryBuffer;
 class Pass;
 class RandomNumberGenerator;
 template <class PtrType> class SmallPtrSetImpl;
private:
   Materializer;                   ///< Used to materialize GlobalValues
   std::string ModuleID;           ///< Human readable identifier for the module
   std::string SourceFileName;     ///< Original source file name for module,
                                   ///< recorded in bitcode.
   std::string TargetTriple;       ///< Platform target triple Module compiled on
                                   ///< Format: (arch)(sub)-(vendor)-(sys0-(abi)
   void *NamedMDSymTab;            ///< NamedMDNode names.
   DataLayout DL;                  ///< DataLayout associated with the module
+  /// Instruction combiner optimization deletes debugdeclare intrinsic,
+  /// cases when debugdeclare instrinsic is deleted from caller while callee
+  /// is later inlined, which makes opportunity to create DW_OP_implicit_pointer
+  /// we will preserve location of variable in std::map to use later
+  std::map<Value *, Value *> VarAddrMap;
 
   friend class Constant;
 
 /// @}
 /// @name Constructors
 /// @{
 public:
   /// The Module constructor. Note that there is no default constructor. You
   /// must provide a name for the module upon construction.
   explicit Module(StringRef ModuleID, LLVMContext& C);
   /// The module destructor. This will dropAllReferences.
   ~Module();
 
+  void insertVarAddressMap(DbgVariableIntrinsic *DDI);
+
+  Value *findVarAddressMap(Value *Var);
+
 /// @}
 /// @name Module Level Accessors
 /// @{
 
   /// Get the module identifier which is, essentially, the name of the module.
   /// @returns the module identifier as a string
   const std::string &getModuleIdentifier() const { return ModuleID; }
 

llvm/lib/IR/AsmWriter.cpp

if (N->isValid()) {
     for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
       auto OpStr = dwarf::OperationEncodingString(I->getOp());
       assert(!OpStr.empty() && "Expected valid opcode");
 
       Out << FS << OpStr;
       if (I->getOp() == dwarf::DW_OP_LLVM_convert) {
         Out << FS << I->getArg(0);
         Out << FS << dwarf::AttributeEncodingString(I->getArg(1));
+      } else if (I->getOp() == dwarf::DW_OP_LLVM_implicit_pointer) {
+        Out << FS << dwarf::OperationEncodingString(I->getArg(0));
+        Out << FS << I->getArg(1);
       } else {
         for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
           Out << FS << I->getArg(A);
       }
     }
   } else {
     for (const auto &I : N->getElements())
       Out << FS << I;

llvm/lib/IR/DebugInfoMetadata.cpp

void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops,
   } else if (Offset < 0) {
     Ops.push_back(dwarf::DW_OP_constu);
     Ops.push_back(-Offset);
     Ops.push_back(dwarf::DW_OP_minus);
   }
 }
 
 bool DIExpression::extractIfOffset(int64_t &Offset) const {
-  if (getNumElements() == 0) {
+  unsigned numElements;
+  numElements = getNumElements();
+
+  if (numElements == 0) {
     Offset = 0;
     return true;
   }
 
-  if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
+  if (Elements[numElements - 1] == dwarf::DW_OP_stack_value)
+    numElements--;
+
+  if (numElements == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
     Offset = Elements[1];
     return true;
   }
 
-  if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
+  if (numElements == 3 && Elements[0] == dwarf::DW_OP_constu) {
     if (Elements[2] == dwarf::DW_OP_plus) {
       Offset = Elements[1];
       return true;
     }
     if (Elements[2] == dwarf::DW_OP_minus) {
       Offset = -Elements[1];
       return true;
     }

llvm/lib/IR/Module.cpp

 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/TypeFinder.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Pass.h"
GlobalVariable *llvm::collectUsedGlobalVariables(
 
   const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
   for (Value *Op : Init->operands()) {
     GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
     Set.insert(G);
   }
   return GV;
 }
+
+void Module::insertVarAddressMap(DbgVariableIntrinsic *DDI) {
+  if (DDI->getOperand(0) != nullptr)
+    VarAddrMap.insert(
+        std::pair<Value *, Value *>(DDI->getOperand(0), DDI->getOperand(1)));
+}
+
+Value *Module::findVarAddressMap(Value *Var) {
+  if (Var->isUsedByMetadata())
+    if (auto *L = LocalAsMetadata::getIfExists(Var))
+      if (auto *MDV = MetadataAsValue::getIfExists(Var->getContext(), L))
+        return VarAddrMap[MDV];
+
+  return nullptr;
+}

llvm/lib/Transforms/Utils/Local.cpp

 
 /// Wrap \p V in a ValueAsMetadata instance.
 static MetadataAsValue *wrapValueInMetadata(LLVMContext &C, Value *V) {
   return MetadataAsValue::get(C, ValueAsMetadata::get(V));
 }
 
 bool llvm::salvageDebugInfo(Instruction &I) {
   SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
+
+  // Return false if any of the operand is already deleted
+  for (unsigned i = 0; i < I.getNumOperands(); ++i)
+    if (!I.getOperand(i))
+      return false;
+
+  // Preserve the information we may need later when called function from
+  // current function is inlined. We need this information for
+  // DW_OP_LLVM_implicit_pointer.
+  if (auto DDI = dyn_cast<DbgVariableIntrinsic>(&I))
+    if (I.getModule()->getDwarfVersion() >= 5)
+      if (DDI->isAddressOfVariable())
+        I.getModule()->insertVarAddressMap(DDI);
+
   findDbgUsers(DbgUsers, &I);
   if (DbgUsers.empty())
     return false;
 
   return salvageDebugInfoForDbgValues(I, DbgUsers);
 }
 
 void llvm::salvageDebugInfoOrMarkUndef(Instruction &I) {
   if (!salvageDebugInfo(I))
     replaceDbgUsesWithUndef(&I);
 }
 
 bool llvm::salvageDebugInfoForDbgValues(
     Instruction &I, ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
   auto &Ctx = I.getContext();
   auto wrapMD = [&](Value *V) { return wrapValueInMetadata(Ctx, V); };
+  bool changed = false;
+  Value *debugDeclareAddress = nullptr;
+
+  if ((I.getModule()->getDwarfVersion() >= 5) && isa<AllocaInst>(I)) {
+    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 = I.getModule()->findVarAddressMap(&I);
+  }
 
   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(I, DII->getExpression(), StackValue);
 
     // salvageDebugInfoImpl should fail on examining the first element of
     // DbgUsers, or none of them.
     if (!DIExpr)
-      return false;
+      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>(I) &&
+        (!debugDeclareAddress || DII->isAddressOfVariable() ||
+         !DII->getExpression()->extractIfOffset(ExprOffset)))
+      continue;
 
+    if (isa<AllocaInst>(I)) {
+      // 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
+      //
+      // call void @llvm.dbg.value(metadata [2 x i32]* %arr, metadata !20,
+      // metadata !DIExpression()), !dbg !24
+      //
+      // call void @llvm.dbg.value(metadata [2 x i32]* %arr, metadata !20,
+      // metadata !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)),
+      // !dbg !24
+      //
+      // !16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 5,
+      // type: !17) !20 = !DILocalVariable(name: "ptr", scope: !12, file: !3,
+      // line: 6, type: !21)
+      //
+      //
+      // After transformation
+      //
+      // %a = alloca [2 x i32], align 4
+      // call void @llvm.dbg.declare(metadata [2 x i32]* %arr, metadata !16,
+      // metadata !DIExpression()), !dbg !22
+      //
+      // call void @llvm.dbg.value(metadata !16, metadata !20, metadata
+      // !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg
+      // !24
+      //
+      // call void @llvm.dbg.value(metadata !16, metadata !20, metadata
+      //  !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 4)), !dbg
+      //  !24
+      //
+      DII->setOperand(0, debugDeclareAddress);
+      SmallVector<uint64_t, 8> Ops;
+      Ops.push_back(dwarf::DW_OP_LLVM_implicit_pointer);
+      Ops.push_back(dwarf::DW_OP_LLVM_arg0);
+      Ops.push_back(ExprOffset);
+      DIExpr = DIExpression::get(DIExpr->getContext(), Ops);
+    } else
       DII->setOperand(0, wrapMD(I.getOperand(0)));
+
     DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
     LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n');
+    changed = true;
   }
 
-  return true;
+  return changed;
 }
 
 DIExpression *llvm::salvageDebugInfoImpl(Instruction &I,
                                          DIExpression *SrcDIExpr,
                                          bool WithStackValue) {
   auto &M = *I.getModule();
   auto &DL = M.getDataLayout();
 
case Instruction::AShr:
       return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shra});
     default:
       // TODO: Salvage constants from each kind of binop we know about.
       return nullptr;
     }
     // *Not* to do: we should not attempt to salvage load instructions,
     // because the validity and lifetime of a dbg.value containing
     // DW_OP_deref becomes difficult to analyze. See PR40628 for examples.
+  } else if ((M.getDwarfVersion() >= 5) && isa<AllocaInst>(&I)) {
+    return SrcDIExpr;
   }
   return nullptr;
 }
 
 /// A replacement for a dbg.value expression.
 using DbgValReplacement = Optional<DIExpression *>;
 
 /// Point debug users of \p From to \p To using exprs given by \p RewriteExpr,