[DebugInfo] Support for DW_OP_implicit_pointer for named and unnamed variables (second strategy).

[alok]

Summary

This is to support DWARF5 operator DW_OP_implicit_pointer, which was earlier attempted but had some objections from reviewers. This second strategy includes suggestion from David. @dblaikie please provide your views on this (design wise).
It is split into 8 separate patches for better understanding.
D84113, D84114, D84115, D84116, D84117, D84118, D84119, D84120

Example:
    c program lines--
      int var1 = 4;
      int arr[2] = {9, 10};
      int *ptr1 = &var1;
      int *ptr2 = arr;
      int ptrPtr1 = &ptr1;
      int ptrPtr2 = &ptr2;

    It'll be converted to below IR--

      call void @llvm.dbg.value(metadata i32 4, metadata !DILocalVariable(name: "ptr1"), metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
      call void @llvm.dbg.value(metadata i32 9, metadata !DILocalVariable(name: "ptr2"), metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
      call void @llvm.dbg.value(metadata i32 4, metadata !DILocalVariable(name: "ptrPtr1"), metadata !DIExpression(DW_OP_LLVM_explicit_pointer,DW_OP_LLVM_explicit_pointer))
      call void @llvm.dbg.value(metadata i32 9, metadata !DILocalVariable(name: "ptrPtr2"), metadata !DIExpression(DW_OP_LLVM_explicit_pointer,DW_OP_LLVM_explicit_pointer))

     In DWARF, DW_OP_LLVM_explicit_pointer will be converted to DW_OP_implicit_pointer using temporary variables

0x0000009c:     DW_TAG_variable
                  DW_AT_location        (indexed (0x8) loclist = 0x000000aa:
                     [0x0000000000201667, 0x0000000000201674): DW_OP_implicit_pointer 0xa5 +0)
                  DW_AT_name    ("ptrptr1")
0x000000a5:     DW_TAG_variable
                  DW_AT_location        (indexed (0x9) loclist = 0x000000b5:
                     [0x0000000000201667, 0x0000000000201674): DW_OP_implicit_pointer 0xac +0)
                  DW_AT_name    ("__implicit_ptr_tmp_4")
                  DW_AT_artificial      (true)
0x000000ac:     DW_TAG_variable
                  DW_AT_location        (indexed (0xa) loclist = 0x000000c0:
                     [0x0000000000201667, 0x0000000000201674): DW_OP_lit4, DW_OP_stack_value)
                  DW_AT_name    ("__implicit_ptr_tmp_3")
                  DW_AT_artificial      (true)

Testing:

• Added unit tests for validation thru llvm-dwarfdump
• check-llvm, and an end-to-end test using gnu GDB to debug an optimized program (LLDB need to be enhanced to support).
• check-debuginfo (the debug info integration tests)

[dblaikie]

Could you include a link to the original discussion (I have no recollection of what I might've said on the subject... ) & also link to the other code reviews sent based on this one.

And/or it might be best to continue the discussion on the original design discussion thread (assuming that's where this was discussed - if it was discussed in another code review, maybe having a separate llvm-dev design thread would be suitable), with this as an aid, rather than to start reviewing this or the other.

llvm/docs/LangRef.rst

- ``DW_OP_LLVM_entry_value, N`` can only appear at the beginning of a
   parameter.
 - ``DW_OP_breg`` (or ``DW_OP_bregx``) represents a content on the provided
   signed offset of the specified register. The opcode is only generated by the
   ``AsmPrinter`` pass to describe call site parameter value which requires an
   expression over two registers.
 - ``DW_OP_push_object_address`` pushes the address of the object which can then
   serve as a descriptor in subsequent calculation. This opcode can be used to
   calculate bounds of fortran allocatable array which has array descriptors.
+- ``DW_OP_LLVM_implicit_pointer, N`` can only appear at the
+  beginning of a ``DIExpression``, and it specifies the value of variable
+  represented by the ``DILocalVariable`` referred to by the instructions 
+  value/address operand at offset N.
+- ``DW_OP_LLVM_explicit_pointer`` it specifies the dereferenced value.
 
 DWARF specifies three kinds of simple location descriptions: Register, memory,
 and implicit location descriptions.  Note that a location description is
 defined over certain ranges of a program, i.e the location of a variable may
 change over the course of the program. Register and memory location
 descriptions describe the *concrete location* of a source variable (in the
 sense that a debugger might modify its value), whereas *implicit locations*
 describe merely the actual *value* of a source variable which might not exist

llvm/include/llvm/BinaryFormat/Dwarf.h

#include "llvm/BinaryFormat/Dwarf.def"
   DW_FORM_lo_user = 0x1f00, ///< Not specified by DWARF.
 };
 
 enum LocationAtom {
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_OP_lo_user = 0xe0,
   DW_OP_hi_user = 0xff,
-  DW_OP_LLVM_fragment = 0x1000,    ///< Only used in LLVM metadata.
-  DW_OP_LLVM_convert = 0x1001,     ///< Only used in LLVM metadata.
-  DW_OP_LLVM_tag_offset = 0x1002,  ///< Only used in LLVM metadata.
-  DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata.
+  DW_OP_LLVM_fragment = 0x1000,         ///< Only used in LLVM metadata.
+  DW_OP_LLVM_convert = 0x1001,          ///< Only used in LLVM metadata.
+  DW_OP_LLVM_tag_offset = 0x1002,       ///< Only used in LLVM metadata.
+  DW_OP_LLVM_entry_value = 0x1003,      ///< Only used in LLVM metadata.
+  DW_OP_LLVM_implicit_pointer = 0x100c, ///< Only used in LLVM metadata.
+  DW_OP_LLVM_explicit_pointer = 0x100d, ///< Only used in LLVM metadata.
 };
 
 enum TypeKind : uint8_t {
 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_ATE_lo_user = 0x80,
   DW_ATE_hi_user = 0xff
 };

llvm/include/llvm/CodeGen/GlobalISel/IRTranslator.h

 namespace llvm {
 
 class AllocaInst;
 class BasicBlock;
 class CallInst;
 class CallLowering;
 class Constant;
 class DataLayout;
+class DIBuilder;
 class FunctionLoweringInfo;
 class Instruction;
 class MachineBasicBlock;
 class MachineFunction;
 class MachineInstr;
 class MachineRegisterInfo;
 class OptimizationRemarkEmitter;
 class PHINode;

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

MachineInstrBuilder buildFIDbgValue(int FI, const MDNode *Variable,
                                       const MDNode *Expr);
 
   /// Build and insert a DBG_VALUE instructions specifying that \p Variable is
   /// given by \p C (suitably modified by \p Expr).
   MachineInstrBuilder buildConstDbgValue(const Constant &C,
                                          const MDNode *Variable,
                                          const MDNode *Expr);
 
+  /// Build and insert a DBG_VALUE instructions specifying that the dereferenced
+  /// value of \p Variable is given by \p V (suitably modified by \p Expr).
+  MachineInstrBuilder buildDerefDbgValue(const Value *V, const MDNode *Variable,
+                                         const MDNode *Expr);
+
+  /// Build and insert a DBG_VALUE instructions specifying that the dereferenced
+  /// value of \p Variable is given by \p V (suitably modified by \p Expr).
+  MachineInstrBuilder buildDerefDbgValue(const MDNode *DerefVar,
+                                         const MDNode *Variable,
+                                         const MDNode *Expr);
+
   /// Build and insert a DBG_LABEL instructions specifying that \p Label is
   /// given. Convert "llvm.dbg.label Label" to "DBG_LABEL Label".
   MachineInstrBuilder buildDbgLabel(const MDNode *Label);
 
   /// Build and insert \p Res = G_DYN_STACKALLOC \p Size, \p Align
   ///
   /// G_DYN_STACKALLOC does a dynamic stack allocation and writes the address of
   /// the allocated memory into \p Res.

llvm/include/llvm/CodeGen/MachineInstr.h

public:
   /// Return the debug variable referenced by
   /// this DBG_VALUE instruction.
   const DILocalVariable *getDebugVariable() const;
 
   /// Return the operand for the complex address expression referenced by
   /// this DBG_VALUE instruction.
   MachineOperand &getDebugExpressionOp();
 
+  /// Return the debug implicit variable referenced by
+  /// this DBG_VALUE instruction.
+  const DIVariable *getDebugImplicitVariable() const;
+
   /// Return the complex address expression referenced by
   /// this DBG_VALUE instruction.
   const DIExpression *getDebugExpression() const;
 
   /// Return the debug label referenced by
   /// this DBG_LABEL instruction.
   const DILabel *getDebugLabel() const;
 

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
                                : true) &&
            "first MDNode argument of a DBG_VALUE not a variable");
     assert((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel())
                                : true) &&
            "first MDNode argument of a DBG_LABEL not a label");
     return *this;
   }
 
+  const MachineInstrBuilder &addImplicitPtrMetadata(const MDNode *MD) const {
+    MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
+    assert(((MI->isDebugValue())
+                ? static_cast<bool>(MI->getDebugImplicitVariable())
+                : true) &&
+           "first MDNode argument of a DBG_VALUE not a DIVariable");
+    assert(
+        (MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel()) : true) &&
+        "first MDNode argument of a DBG_LABEL not a label");
+    return *this;
+  }
+
   const MachineInstrBuilder &addCFIIndex(unsigned CFIIndex) const {
     MI->addOperand(*MF, MachineOperand::CreateCFIIndex(CFIIndex));
     return *this;
   }
 
   const MachineInstrBuilder &addIntrinsicID(Intrinsic::ID ID) const {
     MI->addOperand(*MF, MachineOperand::CreateIntrinsicID(ID));
     return *this;

llvm/include/llvm/CodeGen/SelectionDAG.h

SDDbgValue *getFrameIndexDbgValue(DIVariable *Var, DIExpression *Expr,
                                     unsigned FI, bool IsIndirect,
                                     const DebugLoc &DL, unsigned O);
 
   /// Creates a VReg SDDbgValue node.
   SDDbgValue *getVRegDbgValue(DIVariable *Var, DIExpression *Expr,
                               unsigned VReg, bool IsIndirect,
                               const DebugLoc &DL, unsigned O);
 
+  /// Creates an Implicit Pointer SDDbgValue node.
+  SDDbgValue *getImpPtrDbgValue(DIVariable *Var, DIExpression *Expr,
+                                DIVariable *Val, const DebugLoc &DL,
+                                unsigned O);
+
   /// Creates a SDDbgLabel node.
   SDDbgLabel *getDbgLabel(DILabel *Label, const DebugLoc &DL, unsigned O);
 
   /// Transfer debug values from one node to another, while optionally
   /// generating fragment expressions for split-up values. If \p InvalidateDbg
   /// is set, debug values are invalidated after they are transferred.
   void transferDbgValues(SDValue From, SDValue To, unsigned OffsetInBits = 0,
                          unsigned SizeInBits = 0, bool InvalidateDbg = true);

llvm/include/llvm/IR/DIBuilder.h

public:
     /// If \c AlwaysPreserve, this variable will be referenced from its
     /// containing subprogram, and will survive some optimizations.
     DILocalVariable *
     createAutoVariable(DIScope *Scope, StringRef Name, DIFile *File,
                        unsigned LineNo, DIType *Ty, bool AlwaysPreserve = false,
                        DINode::DIFlags Flags = DINode::FlagZero,
                        uint32_t AlignInBits = 0);
 
+    DILocalVariable *createImplicitTempVariable(DIScope *Scope, DIType *Ty,
+                                                uint32_t AlignInBits);
+
     /// Create a new descriptor for an label.
     ///
     /// \c Scope must be a \a DILocalScope, and thus its scope chain eventually
     /// leads to a \a DISubprogram.
     DILabel *
     createLabel(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo,
                 bool AlwaysPreserve = false);
 

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   /// Retrieve the details of this fragment expression.
   Optional<FragmentInfo> getFragmentInfo() const {
     return getFragmentInfo(expr_op_begin(), expr_op_end());
   }
 
   /// Return whether this is a piece of an aggregate variable.
   bool isFragment() const { return getFragmentInfo().hasValue(); }
 
+  /// Return whether this is an Implicit Pointer
+  bool isImplicitPointer() const {
+    return getNumElements() > 0 &&
+           (expr_op_begin()->getOp() == dwarf::DW_OP_LLVM_implicit_pointer);
+  }
+
+  /// Return the number of indirction levels
+  unsigned explicitPointerCount() const {
+    unsigned Count = 0;
+    for (unsigned i = 0; i < getNumElements(); ++i) {
+      if (Elements[i] == dwarf::DW_OP_LLVM_explicit_pointer)
+        Count++;
+      else
+        break;
+    }
+    return Count;
+  }
+
   /// Return whether this is an implicit location description.
   bool isImplicit() const;
 
   /// Return whether the location is computed on the expression stack, meaning
   /// it cannot be a simple register location.
   bool isComplex() const;
 
   /// Append \p Ops with operations to apply the \p Offset.

llvm/include/llvm/IR/Instruction.h

 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
 class BasicBlock;
+class DbgVariableIntrinsic;
 class FastMathFlags;
 class MDNode;
 class Module;
 struct AAMDNodes;
 
 template <> struct ilist_alloc_traits<Instruction> {
   static inline void deleteNode(Instruction *V);
 };
void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2) {
     unsigned IDs[] = {ID1, ID2};
     return dropUnknownNonDebugMetadata(IDs);
   }
   /// @}
 
   /// Sets the metadata on this instruction from the AAMDNodes structure.
   void setAAMetadata(const AAMDNodes &N);
 
+  /// Given DIExpression \p DIExpr operating on this instruction, write the
+  /// effects of this instruction into the returned DIExpression, or return
+  /// nullptr if it cannot be salvaged. \p StackVal: whether DW_OP_stack_value
+  /// should be appended to the expression.
+  DIExpression *salvageDebugInfoImpl(DIExpression *SrcDIExpr,
+                                     bool WithStackValue);
+
+  /// Implementation of salvageDebugInfo, applying only to instructions in
+  /// \p DbgUsers, rather than all debug users of this instruction.
+  void salvageDebugInfoForDbgValues(ArrayRef<DbgVariableIntrinsic *> DbgUsers);
+
+  /// Assuming this instruction is going to be deleted, attempt to salvage
+  /// debug users by writing the effect of this instruction in a DIExpression.
+  /// Returns true if any debug users were updated.
+  void salvageDebugInfo();
+
   /// Retrieve the raw weight values of a conditional branch or select.
   /// Returns true on success with profile weights filled in.
   /// Returns false if no metadata or invalid metadata was found.
   bool extractProfMetadata(uint64_t &TrueVal, uint64_t &FalseVal) const;
 
   /// Retrieve total raw weight values of a branch.
   /// Returns true on success with profile total weights filled in.
   /// Returns false if no metadata was found.

llvm/include/llvm/IR/IntrinsicInst.h

 // hack working.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_INTRINSICINST_H
 #define LLVM_IR_INTRINSICINST_H
 
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/FPEnv.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Value.h"

 /// This is the common base class for debug info intrinsics for variables.
 class DbgVariableIntrinsic : public DbgInfoIntrinsic {
 public:
   /// Get the location corresponding to the variable referenced by the debug
   /// info intrinsic.  Depending on the intrinsic, this could be the
   /// variable's value or its address.
   Value *getVariableLocation(bool AllowNullOp = true) const;
 
+  Value *getDerefVariable(bool AllowNullOp = true) const;
+
   /// Does this describe the address of a local variable. True for dbg.addr
   /// and dbg.declare, but not dbg.value, which describes its value.
   bool isAddressOfVariable() const {
     return getIntrinsicID() != Intrinsic::dbg_value;
   }
 
   DILocalVariable *getVariable() const {
     return cast<DILocalVariable>(getRawVariable());
public:
   Metadata *getRawExpression() const {
     return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
   }
 
   /// Get the size (in bits) of the variable, or fragment of the variable that
   /// is described.
   Optional<uint64_t> getFragmentSizeInBits() const;
 
+  /// Returns true if it has an implicit pointer expression
+  bool isImplicitPointer() const {
+    return getExpression()->isImplicitPointer();
+  }
+
+  /// Returns true if it has an explicit pointer expression
+  unsigned explicitPointerCount() const {
+    if (!isa<DIExpression>(getRawExpression()))
+      return false;
+
+    return getExpression()->explicitPointerCount();
+  }
+
   /// \name Casting methods
   /// @{
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
     case Intrinsic::dbg_addr:
       return true;

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 ModuleSummaryIndex;
 class Pass;
 class RandomNumberGenerator;
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)
   NamedMDSymTabType 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 DenseMap to use later
+  DenseMap<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; }
 
   /// Returns the number of non-debug IR instructions in the module.
   /// This is equivalent to the sum of the IR instruction counts of each
   /// function contained in the module.

llvm/include/llvm/IR/Value.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_VALUE_H
 #define LLVM_IR_VALUE_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Use.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <iterator>
 #include <memory>
 
 namespace llvm {
 
 class APInt;
 class Argument;
 class BasicBlock;
 class Constant;
 class ConstantData;
 class ConstantAggregate;
 class DataLayout;
+class DbgVariableIntrinsic;
 class Function;
 class GlobalAlias;
 class GlobalIFunc;
 class GlobalIndirectSymbol;
 class GlobalObject;
 class GlobalValue;
 class GlobalVariable;
 class InlineAsm;
for (use_iterator UI = use_begin(), E = use_end(); UI != E;) {
       Use &U = *UI;
       ++UI;
       if (!ShouldReplace(U))
         continue;
       U.set(New);
     }
   }
 
+  /// Finds the debug info intrinsics describing this value.
+  void findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgUsers);
+
   /// replaceUsesOutsideBlock - Go through the uses list for this definition and
   /// make each use point to "V" instead of "this" when the use is outside the
   /// block. 'This's use list is expected to have at least one element.
   /// Unlike replaceAllUsesWith() this function does not support basic block
   /// values or constant users.
   void replaceUsesOutsideBlock(Value *V, BasicBlock *BB);
 
   //----------------------------------------------------------------------

llvm/include/llvm/Transforms/Scalar/SROA.h

class SROA : public PassInfoMixin<SROA> {
   /// A worklist of select instructions to speculate prior to promoting
   /// allocas.
   ///
   /// All of these select instructions have been checked for the safety of
   /// speculation and by being speculated will allow promoting allocas
   /// currently in the promotable queue.
   SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects;
 
+  /// Describes the allocas introduced by rewritePartition in order to migrate
+  /// the debug info.
+  struct Fragment {
+    AllocaInst *Alloca;
+    uint64_t Offset;
+    uint64_t Size;
+    Fragment(AllocaInst *AI, uint64_t O, uint64_t S)
+        : Alloca(AI), Offset(O), Size(S) {}
+  };
+
+  SmallVector<Fragment, 4> Fragments;
+
 public:
   SROA() = default;
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
 private:
   friend class sroa::AllocaSliceRewriter;
   friend class sroa::SROALegacyPass;
 
   /// Helper used by both the public run method and by the legacy pass.
   PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT,
                             AssumptionCache &RunAC);
 
   bool presplitLoadsAndStores(AllocaInst &AI, sroa::AllocaSlices &AS);
   AllocaInst *rewritePartition(AllocaInst &AI, sroa::AllocaSlices &AS,
                                sroa::Partition &P);
+  void salvageInstruction(Instruction *Ins);
+  void fixGEPWithSplitAllocas();
   bool splitAlloca(AllocaInst &AI, sroa::AllocaSlices &AS);
   bool runOnAlloca(AllocaInst &AI);
   void clobberUse(Use &U);
   bool deleteDeadInstructions(SmallPtrSetImpl<AllocaInst *> &DeletedAllocas);
   bool promoteAllocas(Function &F);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SROA_H

llvm/include/llvm/Transforms/Utils/Local.h

 
 /// Like \c FindDbgAddrUses, but only returns dbg.declare intrinsics, not
 /// dbg.addr.
 TinyPtrVector<DbgDeclareInst *> FindDbgDeclareUses(Value *V);
 
 /// Finds the llvm.dbg.value intrinsics describing a value.
 void findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V);
 
-/// Finds the debug info intrinsics describing a value.
-void findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgInsts, Value *V);
-
 /// Replaces llvm.dbg.declare instruction when the address it
 /// describes is replaced with a new value. If Deref is true, an
 /// additional DW_OP_deref is prepended to the expression. If Offset
 /// is non-zero, a constant displacement is added to the expression
 /// (between the optional Deref operations). Offset can be negative.
 bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder,
                        uint8_t DIExprFlags, int Offset);
 
 /// Replaces multiple llvm.dbg.value instructions when the alloca it describes
 /// is replaced with a new value. If Offset is non-zero, a constant displacement
 /// is added to the expression (after the mandatory Deref). Offset can be
 /// negative. New llvm.dbg.value instructions are inserted at the locations of
 /// the instructions they replace.
 void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
                               DIBuilder &Builder, int Offset = 0);
 
 /// Finds alloca where the value comes from.
 AllocaInst *findAllocaForValue(Value *V,
                                DenseMap<Value *, AllocaInst *> &AllocaForValue);
 
-/// Assuming the instruction \p I is going to be deleted, attempt to salvage
-/// debug users of \p I by writing the effect of \p I in a DIExpression. If it
-/// cannot be salvaged changes its debug uses to undef.
-void salvageDebugInfo(Instruction &I);
-
-
-/// Implementation of salvageDebugInfo, applying only to instructions in
-/// \p Insns, rather than all debug users from findDbgUsers( \p I).
-/// Returns true if any debug users were updated.
-/// Mark undef if salvaging cannot be completed.
-void salvageDebugInfoForDbgValues(Instruction &I,
-                                  ArrayRef<DbgVariableIntrinsic *> Insns);
-
-/// Given an instruction \p I and DIExpression \p DIExpr operating on it, write
-/// the effects of \p I into the returned DIExpression, or return nullptr if
-/// it cannot be salvaged. \p StackVal: whether DW_OP_stack_value should be
-/// appended to the expression.
-DIExpression *salvageDebugInfoImpl(Instruction &I, DIExpression *DIExpr,
-                                   bool StackVal);
-
 /// Point debug users of \p From to \p To or salvage them. Use this function
 /// only when replacing all uses of \p From with \p To, with a guarantee that
 /// \p From is going to be deleted.
 ///
 /// Follow these rules to prevent use-before-def of \p To:
 ///   . If \p To is a linked Instruction, set \p DomPoint to \p To.
 ///   . If \p To is an unlinked Instruction, set \p DomPoint to the Instruction
 ///     \p To will be inserted after.

llvm/lib/BinaryFormat/Dwarf.cpp

#include "llvm/BinaryFormat/Dwarf.def"
   case DW_OP_LLVM_convert:
     return "DW_OP_LLVM_convert";
   case DW_OP_LLVM_fragment:
     return "DW_OP_LLVM_fragment";
   case DW_OP_LLVM_tag_offset:
     return "DW_OP_LLVM_tag_offset";
   case DW_OP_LLVM_entry_value:
     return "DW_OP_LLVM_entry_value";
+  case DW_OP_LLVM_implicit_pointer:
+    return "DW_OP_LLVM_implicit_pointer";
+  case DW_OP_LLVM_explicit_pointer:
+    return "DW_OP_LLVM_explicit_pointer";
   }
 }
 
 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
   return StringSwitch<unsigned>(OperationEncodingString)
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
   .Case("DW_OP_" #NAME, DW_OP_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
       .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
       .Case("DW_OP_LLVM_entry_value", DW_OP_LLVM_entry_value)
+      .Case("DW_OP_LLVM_implicit_pointer", DW_OP_LLVM_implicit_pointer)
+      .Case("DW_OP_LLVM_explicit_pointer", DW_OP_LLVM_explicit_pointer)
       .Default(0);
 }
 
 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
   switch (Op) {
   default:
     return 0;
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
   } else if (MI->getDebugOperand(0).isImm()) {
     OS << MI->getDebugOperand(0).getImm();
   } else if (MI->getDebugOperand(0).isCImm()) {
     MI->getDebugOperand(0).getCImm()->getValue().print(OS, false /*isSigned*/);
   } else if (MI->getDebugOperand(0).isTargetIndex()) {
     auto Op = MI->getDebugOperand(0);
     OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";
     return true;
+  } else if (MI->getOperand(0).isMetadata()) {
+    OS << MI->getOperand(0).getMetadata();
   } else {
     Register Reg;
     if (MI->getDebugOperand(0).isReg()) {
       Reg = MI->getDebugOperand(0).getReg();
     } else {
       assert(MI->getDebugOperand(0).isFI() && "Unknown operand type");
       const TargetFrameLowering *TFI = AP.MF->getSubtarget().getFrameLowering();
       Offset += TFI->getFrameIndexReference(

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

class DbgValueLoc {
   const DIExpression *Expression;
 
   /// Type of entry that this represents.
   enum EntryType {
     E_Location,
     E_Integer,
     E_ConstantFP,
     E_ConstantInt,
-    E_TargetIndexLocation
+    E_TargetIndexLocation,
+    E_ImplicitPtr
   };
   enum EntryType EntryKind;
 
-  /// Either a constant,
+  /// a constant,
   union {
     int64_t Int;
     const ConstantFP *CFP;
     const ConstantInt *CIP;
   } Constant;
 
   union {
     /// Or a location in the machine frame.
     MachineLocation Loc;
     /// Or a location from target specific location.
     TargetIndexLocation TIL;
   };
 
+  /// Or an implicit pointer variable target.
+  const DIVariable *ImpPtr;
+
 public:
   DbgValueLoc(const DIExpression *Expr, int64_t i)
       : Expression(Expr), EntryKind(E_Integer) {
     Constant.Int = i;
   }
   DbgValueLoc(const DIExpression *Expr, const ConstantFP *CFP)
       : Expression(Expr), EntryKind(E_ConstantFP) {
     Constant.CFP = CFP;
   }
   DbgValueLoc(const DIExpression *Expr, const ConstantInt *CIP)
       : Expression(Expr), EntryKind(E_ConstantInt) {
     Constant.CIP = CIP;
   }
   DbgValueLoc(const DIExpression *Expr, MachineLocation Loc)
       : Expression(Expr), EntryKind(E_Location), Loc(Loc) {
     assert(cast<DIExpression>(Expr)->isValid());
   }
   DbgValueLoc(const DIExpression *Expr, TargetIndexLocation Loc)
       : Expression(Expr), EntryKind(E_TargetIndexLocation), TIL(Loc) {}
+  DbgValueLoc(const DIExpression *Expr, const DIVariable *ImpPtr)
+      : Expression(Expr), EntryKind(E_ImplicitPtr), ImpPtr(ImpPtr) {
+    assert(cast<DIExpression>(Expr)->isValid());
+  }
 
   bool isLocation() const { return EntryKind == E_Location; }
   bool isTargetIndexLocation() const {
     return EntryKind == E_TargetIndexLocation;
   }
   bool isInt() const { return EntryKind == E_Integer; }
   bool isConstantFP() const { return EntryKind == E_ConstantFP; }
   bool isConstantInt() const { return EntryKind == E_ConstantInt; }
+  bool isImplicitPtr() const { return EntryKind == E_ImplicitPtr; }
   int64_t getInt() const { return Constant.Int; }
   const ConstantFP *getConstantFP() const { return Constant.CFP; }
   const ConstantInt *getConstantInt() const { return Constant.CIP; }
   MachineLocation getLoc() const { return Loc; }
   TargetIndexLocation getTargetIndexLocation() const { return TIL; }
+  const DIVariable *getImplicitPointer() const { return ImpPtr; }
   bool isFragment() const { return getExpression()->isFragment(); }
   bool isEntryVal() const { return getExpression()->isEntryValue(); }
   const DIExpression *getExpression() const { return Expression; }
   friend bool operator==(const DbgValueLoc &, const DbgValueLoc &);
   friend bool operator<(const DbgValueLoc &, const DbgValueLoc &);
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const {
     if (isLocation()) {
inline bool operator==(const DbgValueLoc &A,
   case DbgValueLoc::E_TargetIndexLocation:
     return A.TIL == B.TIL;
   case DbgValueLoc::E_Integer:
     return A.Constant.Int == B.Constant.Int;
   case DbgValueLoc::E_ConstantFP:
     return A.Constant.CFP == B.Constant.CFP;
   case DbgValueLoc::E_ConstantInt:
     return A.Constant.CIP == B.Constant.CIP;
+  case DbgValueLoc::E_ImplicitPtr:
+    return A.ImpPtr == B.ImpPtr;
   }
   llvm_unreachable("unhandled EntryKind");
 }
 
 /// Compare two fragments based on their offset.
 inline bool operator<(const DbgValueLoc &A,
                       const DbgValueLoc &B) {
   return A.getExpression()->getFragmentInfo()->OffsetInBits <
          B.getExpression()->getFragmentInfo()->OffsetInBits;
 }
 
 }
 
 #endif

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

class DwarfCompileUnit final : public DwarfUnit {
   StringMap<const DIE *> GlobalNames;
 
   /// GlobalTypes - A map of globally visible types for this unit.
   StringMap<const DIE *> GlobalTypes;
 
   // List of ranges for a given compile unit.
   SmallVector<RangeSpan, 2> CURanges;
 
+  // First operand of DW_OP_implicit_pointer operation is a reference to a
+  // debugging information entry that describes the dereferenced object’s value.
+  // When this operation is created, the debugging information entry is not yet
+  // formed. To solve this problem, we maintain a vector of dereferenced
+  // objects. We keep index of dereferenced object's at first operand of
+  // DW_OP_implicit_pointer operation temporarily. This temporary value is
+  // later replaced by actual value in function DwarfDebug::emitDebugLocEntry.
+  SmallVector<const DINode *, 8> ImplicitVars;
+
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress = nullptr;
 
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
 
   /// DWO ID for correlating skeleton and split units.
public:
   DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
   }
 
   bool includeMinimalInlineScopes() const;
 
   void initStmtList();
 
+  unsigned findOrInsertImplicitVar(const DINode *Var) {
+    SmallVector<const DINode *, 8>::iterator It =
+        std::find(ImplicitVars.begin(), ImplicitVars.end(), Var);
+    if (It == ImplicitVars.end()) {
+      ImplicitVars.push_back(Var);
+      return ImplicitVars.size() - 1;
+    }
+
+    return std::distance(ImplicitVars.begin(), It);
+  }
+
+  const DINode *findImplicitVarAtIndex(unsigned Idx) const {
+    return ImplicitVars[Idx];
+  }
   /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
   void applyStmtList(DIE &D);
 
   /// Get line table start symbol for this unit.
   MCSymbol *getLineTableStartSym() const { return LineTableStartSym; }
 
   /// A pair of GlobalVariable and DIExpression.
   struct GlobalExpr {

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

for (const auto &Param : Params) {
     insertDIE(CallSiteDieParam);
     addAddress(*CallSiteDieParam, dwarf::DW_AT_location,
                MachineLocation(Register));
 
     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     DwarfExpr.setCallSiteParamValueFlag();
 
-    DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr);
+    DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr,
+                                  *this);
 
     addBlock(*CallSiteDieParam, getDwarf5OrGNUAttr(dwarf::DW_AT_call_value),
              DwarfExpr.finalize());
 
     CallSiteDIE.addChild(CallSiteDieParam);
   }
 }
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

public:
   /// @}
 
   void addSectionLabel(const MCSymbol *Sym);
   const MCSymbol *getSectionLabel(const MCSection *S);
   void insertSectionLabel(const MCSymbol *S);
 
   static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                                 const DbgValueLoc &Value,
-                                DwarfExpression &DwarfExpr);
+                                DwarfExpression &DwarfExpr,
+                                DwarfCompileUnit &TheCU);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DebugLocDwarfExpression::emitData1(uint8_t Value) {
   getActiveStreamer().EmitInt8(Value, Twine(Value));
 }
 
 void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
   assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit");
   getActiveStreamer().emitULEB128(Idx, Twine(Idx), ULEB128PadSize);
 }
 
+void DebugLocDwarfExpression::emitAddressRef(uint64_t Idx) {
+  uint8_t Val;
+  uint8_t NumBytes;
+
+  switch (CU.getAsmPrinter()->OutStreamer->getContext().getDwarfFormat()) {
+  case dwarf::DWARF32:
+    NumBytes = 4;
+    break;
+  case dwarf::DWARF64:
+    NumBytes = 8;
+    break;
+  }
+
+  while (NumBytes--) {
+    Val = Idx & 0xff;
+    Idx = Idx >> 8;
+    getActiveStreamer().EmitInt8(Val, Twine(Idx));
+  }
+}
+
 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                               unsigned MachineReg) {
   // This information is not available while emitting .debug_loc entries.
   return false;
 }
 
 void DebugLocDwarfExpression::enableTemporaryBuffer() {
   assert(!IsBuffering && "Already buffering?");
return DbgValueLoc(Expr,
                        TargetIndexLocation(Op.getIndex(), Op.getOffset()));
   }
   if (MI->getDebugOperand(0).isImm())
     return DbgValueLoc(Expr, MI->getDebugOperand(0).getImm());
   if (MI->getDebugOperand(0).isFPImm())
     return DbgValueLoc(Expr, MI->getDebugOperand(0).getFPImm());
   if (MI->getDebugOperand(0).isCImm())
     return DbgValueLoc(Expr, MI->getDebugOperand(0).getCImm());
+  if (Expr->isImplicitPointer()) {
+    const DIVariable *DVI =
+        cast<DIVariable>(MI->getDebugOperand(0).getMetadata());
+    return DbgValueLoc(Expr, DVI);
+  }
 
   llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
 }
 
 void DbgVariable::initializeDbgValue(const MachineInstr *DbgValue) {
   assert(FrameIndexExprs.empty() && "Already initialized?");
   assert(!ValueLoc.get() && "Already initialized?");
 
DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
                                             *Scope, LocalVar, IV.second));
 
     const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
     assert(MInsn->isDebugValue() && "History must begin with debug value");
 
     // Check if there is a single DBG_VALUE, valid throughout the var's scope.
     // If the history map contains a single debug value, there may be an
     // additional entry which clobbers the debug value.
+    // In case of implicit pointer, implicit target can not initialize
+    // variable so we need to create location list even in case of single value
     size_t HistSize = HistoryMapEntries.size();
     bool SingleValueWithClobber =
         HistSize == 2 && HistoryMapEntries[1].isClobber();
-    if (HistSize == 1 || SingleValueWithClobber) {
+    if (!MInsn->getDebugExpression()->isImplicitPointer() &&
+        (HistSize == 1 || SingleValueWithClobber)) {
       const auto *End =
           SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
       if (VeryLargeBlocks.count(MInsn->getParent()) == 0 &&
           validThroughout(LScopes, MInsn, End)) {
         RegVar->initializeDbgValue(MInsn);
         continue;
       }
     }
 
     // Do not emit location lists if .debug_loc secton is disabled.
     if (!useLocSection())
       continue;
 
     // Handle multiple DBG_VALUE instructions describing one variable.
     DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
 
     // Build the location list for this variable.
     SmallVector<DebugLocEntry, 8> Entries;
     bool isValidSingleLocation =
         buildLocationList(Entries, HistoryMapEntries, VeryLargeBlocks);
 
     // Check whether buildLocationList managed to merge all locations to one
     // that is valid throughout the variable's scope. If so, produce single
     // value location.
-    if (isValidSingleLocation) {
+    // In case of implicit pointer, implicit target can not initialize
+    // variable so we need to create location list even in case of single value
+    if (!MInsn->getDebugExpression()->isImplicitPointer() &&
+        isValidSingleLocation) {
       RegVar->initializeDbgValue(Entries[0].getValues()[0]);
       continue;
     }
 
     // If the variable has a DIBasicType, extract it.  Basic types cannot have
     // unique identifiers, so don't bother resolving the type with the
     // identifier map.
     const DIBasicType *BT = dyn_cast<DIBasicType>(
for (unsigned I = 0; I < 2; ++I) {
         uint64_t Offset =
             CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die->getOffset();
         assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
         Streamer.emitULEB128(Offset, "", ULEB128PadSize);
         // Make sure comments stay aligned.
         for (unsigned J = 0; J < ULEB128PadSize; ++J)
           if (Comment != End)
             Comment++;
+      } else if ((Op.getCode() == dwarf::DW_OP_implicit_pointer) &&
+                 (Op.getDescription().Op[I] == Encoding::SizeRefAddr)) {
+        // Till now we do not have actual offset from debug_info section
+        // all we have is index in a list of variable, we can now compute
+        // actual offset
+        unsigned ValOffset = 0;
+        // read the dummy offset (index)
+        for (uint64_t J = Op.getOperandEndOffset(I) - 1; J >= Offset; --J)
+          ValOffset = (ValOffset << 8) + (uint8_t)Data.getData()[J];
+        // get the variable and compute the actual offset
+        const DINode *ImpVar = CU->findImplicitVarAtIndex(ValOffset);
+        DIE *Die = CU->getDIE(ImpVar);
+        if (Die)
+          ValOffset = Die->getDebugSectionOffset();
+
+        // emit the actual offset
+        for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J) {
+          Streamer.EmitInt8(ValOffset & 0xff,
+                            Comment != End ? *(Comment++) : "");
+          ValOffset = ValOffset >> 8;
+        }
       } else {
         for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
           Streamer.EmitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
       }
       Offset = Op.getOperandEndOffset(I);
     }
     assert(Offset == Op.getEndOffset());
   }
 }
 
 void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                                    const DbgValueLoc &Value,
-                                   DwarfExpression &DwarfExpr) {
+                                   DwarfExpression &DwarfExpr,
+                                   DwarfCompileUnit &TheCU) {
   auto *DIExpr = Value.getExpression();
   DIExpressionCursor ExprCursor(DIExpr);
   DwarfExpr.addFragmentOffset(DIExpr);
+
   // Regular entry.
   if (Value.isInt()) {
     if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
                BT->getEncoding() == dwarf::DW_ATE_signed_char))
       DwarfExpr.addSignedConstant(Value.getInt());
     else
       DwarfExpr.addUnsignedConstant(Value.getInt());
   } else if (Value.isLocation()) {
void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
   } else if (Value.isTargetIndexLocation()) {
     TargetIndexLocation Loc = Value.getTargetIndexLocation();
     // TODO TargetIndexLocation is a target-independent. Currently only the WebAssembly-specific
     // encoding is supported.
     DwarfExpr.addWasmLocation(Loc.Index, static_cast<uint64_t>(Loc.Offset));
   } else if (Value.isConstantFP()) {
     APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
     DwarfExpr.addUnsignedConstant(RawBytes);
+  } else if (Value.isImplicitPtr()) {
+    const llvm::DIVariable *ImpVar = Value.getImplicitPointer();
+    unsigned ValOffset = TheCU.findOrInsertImplicitVar(ImpVar);
+    // This works as dummy offset in first operand of DW_OP_implicit_pointer
+    // this will later be replace by actual offset of variable in .debug_info
+    DwarfExpr.emitImplicitPointer(std::move(ExprCursor), ValOffset);
+    return;
   }
+
   DwarfExpr.addExpression(std::move(ExprCursor));
 }
 
 void DebugLocEntry::finalize(const AsmPrinter &AP,
                              DebugLocStream::ListBuilder &List,
                              const DIBasicType *BT,
                              DwarfCompileUnit &TheCU) {
   assert(!Values.empty() &&
          "location list entries without values are redundant");
   assert(Begin != End && "unexpected location list entry with empty range");
   DebugLocStream::EntryBuilder Entry(List, Begin, End);
   BufferByteStreamer Streamer = Entry.getStreamer();
   DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU);
   const DbgValueLoc &Value = Values[0];
   if (Value.isFragment()) {
     // Emit all fragments that belong to the same variable and range.
     assert(llvm::all_of(Values, [](DbgValueLoc P) {
           return P.isFragment();
         }) && "all values are expected to be fragments");
     assert(llvm::is_sorted(Values) && "fragments are expected to be sorted");
 
     for (auto Fragment : Values)
-      DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
+      DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr, TheCU);
 
   } else {
     assert(Values.size() == 1 && "only fragments may have >1 value");
-    DwarfDebug::emitDebugLocValue(AP, BT, Value, DwarfExpr);
+    DwarfDebug::emitDebugLocValue(AP, BT, Value, DwarfExpr, TheCU);
   }
   DwarfExpr.finalize();
   if (DwarfExpr.TagOffset)
     List.setTagOffset(*DwarfExpr.TagOffset);
 }
 
 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
                                            const DwarfCompileUnit *CU) {

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

protected:
 
   /// Emit a raw unsigned value.
   virtual void emitUnsigned(uint64_t Value) = 0;
 
   virtual void emitData1(uint8_t Value) = 0;
 
   virtual void emitBaseTypeRef(uint64_t Idx) = 0;
 
+  virtual void emitAddressRef(uint64_t Idx) = 0;
+
   /// Start emitting data to the temporary buffer. The data stored in the
   /// temporary buffer can be committed to the main output using
   /// commitTemporaryBuffer().
   virtual void enableTemporaryBuffer() = 0;
 
   /// Disable emission to the temporary buffer. This does not commit data
   /// in the temporary buffer to the main output.
   virtual void disableTemporaryBuffer() = 0;
public:
   void addFragmentOffset(const DIExpression *Expr);
 
   void emitLegacySExt(unsigned FromBits);
   void emitLegacyZExt(unsigned FromBits);
 
   /// Emit location information expressed via WebAssembly location + offset
   /// The Index is an identifier for locals, globals or operand stack.
   void addWasmLocation(unsigned Index, uint64_t Offset);
+
+  void emitImplicitPointer(DIExpressionCursor &&Expr, unsigned ValOffset);
 };
 
 /// DwarfExpression implementation for .debug_loc entries.
 class DebugLocDwarfExpression final : public DwarfExpression {
 
   struct TempBuffer {
     SmallString<32> Bytes;
     std::vector<std::string> Comments;
class DebugLocDwarfExpression final : public DwarfExpression {
   /// Return the byte streamer that currently is being emitted to.
   ByteStreamer &getActiveStreamer() { return IsBuffering ? TmpBuf->BS : OutBS; }
 
   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
   void emitSigned(int64_t Value) override;
   void emitUnsigned(uint64_t Value) override;
   void emitData1(uint8_t Value) override;
   void emitBaseTypeRef(uint64_t Idx) override;
+  void emitAddressRef(uint64_t Idx) override;
 
   void enableTemporaryBuffer() override;
   void disableTemporaryBuffer() override;
   unsigned getTemporaryBufferSize() override;
   void commitTemporaryBuffer() override;
 
   bool isFrameRegister(const TargetRegisterInfo &TRI,
                        unsigned MachineReg) override;
class DIEDwarfExpression final : public DwarfExpression {
   /// Return the DIE that currently is being emitted to.
   DIELoc &getActiveDIE() { return IsBuffering ? TmpDIE : OutDIE; }
 
   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
   void emitSigned(int64_t Value) override;
   void emitUnsigned(uint64_t Value) override;
   void emitData1(uint8_t Value) override;
   void emitBaseTypeRef(uint64_t Idx) override;
+  void emitAddressRef(uint64_t Idx) override{};
 
   void enableTemporaryBuffer() override;
   void disableTemporaryBuffer() override;
   unsigned getTemporaryBufferSize() override;
   void commitTemporaryBuffer() override;
 
   bool isFrameRegister(const TargetRegisterInfo &TRI,
                        unsigned MachineReg) override;

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

 
 void DwarfExpression::addWasmLocation(unsigned Index, uint64_t Offset) {
   assert(LocationKind == Implicit || LocationKind == Unknown);
   LocationKind = Implicit;
   emitOp(dwarf::DW_OP_WASM_location);
   emitUnsigned(Index);
   emitUnsigned(Offset);
 }
+
+void DwarfExpression::emitImplicitPointer(DIExpressionCursor &&ExprCursor,
+                                          unsigned ValOffset) {
+  auto Op = ExprCursor.take();
+  assert(Op->getOp() == dwarf::DW_OP_LLVM_implicit_pointer &&
+         "not dwarf::DW_OP_LLVM_implicit_pointer");
+
+  emitOp(dwarf::DW_OP_implicit_pointer);
+  // This is a dummy offset which will be replaced with actual offset in
+  // function DwarfDebug::emitDebugLocEntry.
+  emitAddressRef(ValOffset);
+  emitSigned(Op->getArg(0));
+  return;
+}

llvm/lib/CodeGen/CodeGenPrepare.cpp

for (Value::user_iterator UI = CI->user_begin(), E = CI->user_end();
     // Replace a use of the cast with a use of the new cast.
     TheUse = InsertedCast;
     MadeChange = true;
     ++NumCastUses;
   }
 
   // If we removed all uses, nuke the cast.
   if (CI->use_empty()) {
-    salvageDebugInfo(*CI);
     CI->eraseFromParent();
     MadeChange = true;
   }
 
   return MadeChange;
 }
 
 /// If the specified cast instruction is a noop copy (e.g. it's casting from
for (Value::user_iterator UI = ShiftI->user_begin(), E = ShiftI->user_end();
     }
 
     // Replace a use of the shift with a use of the new shift.
     TheUse = InsertedShift;
   }
 
   // If we removed all uses, or there are none, nuke the shift.
   if (ShiftI->use_empty()) {
-    salvageDebugInfo(*ShiftI);
     ShiftI->eraseFromParent();
     MadeChange = true;
   }
 
   return MadeChange;
 }
 
 /// If counting leading or trailing zeros is an expensive operation and a zero

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CodeGen.h"
MIRBuilder.buildInstr(TargetOpcode::G_VASTART, {}, {getOrCreateVReg(*Ptr)})
                                                 MachineMemOperand::MOStore,
                                                 ListSize, Align(1)));
     return true;
   }
   case Intrinsic::dbg_value: {
     // This form of DBG_VALUE is target-independent.
     const DbgValueInst &DI = cast<DbgValueInst>(CI);
     const Value *V = DI.getValue();
+    const DIExpression *DE = DI.getExpression();
     assert(DI.getVariable()->isValidLocationForIntrinsic(
                MIRBuilder.getDebugLoc()) &&
            "Expected inlined-at fields to agree");
+    DILocalVariable *Var = DI.getVariable();
+    DILocalVariable *PtrVar = nullptr;
+    Module *Mod = const_cast<Module *>(CI.getModule());
+
+    DIBuilder DIB(*Mod, /*AllowUnresolved*/ false);
+
+    unsigned Level = DE->explicitPointerCount();
+    SmallVector<DILocalVariable *, 1> PtrVars;
+    if (Level > 0) {
+      DIScope *Scope = DI.getDebugLoc()->getScope();
+      DIType *Type = DI.getVariable()->getType();
+      PtrVar = Var;
+      unsigned Count = Level;
+      while (Count-- > 0) {
+        if (DIDerivedType *DT = dyn_cast<DIDerivedType>(Type))
+          Type = DT->getBaseType();
+        uint32_t AlignInBits = DI.getVariable()->getAlignInBytes();
+        Var = DIB.createImplicitTempVariable(Scope, Type, AlignInBits);
+        PtrVars.push_back(Var);
+      }
+      PtrVars.push_back(PtrVar);
+      Var = PtrVars[0];
+      SmallVector<uint64_t, 3> Ops;
+      DE = DIExpression::get(DE->getContext(), Ops);
+    } else {
+      Var = DI.getVariable();
+      DE = DI.getExpression();
+    }
+
     if (!V) {
       // Currently the optimizer can produce this; insert an undef to
       // help debugging.  Probably the optimizer should not do this.
-      MIRBuilder.buildIndirectDbgValue(0, DI.getVariable(), DI.getExpression());
+      MIRBuilder.buildIndirectDbgValue(0, Var, DE);
     } else if (const auto *CI = dyn_cast<Constant>(V)) {
-      MIRBuilder.buildConstDbgValue(*CI, DI.getVariable(), DI.getExpression());
+      MIRBuilder.buildConstDbgValue(*CI, DI.getVariable(), DE);
+    } else if (DE->isImplicitPointer()) {
+      MIRBuilder.buildDerefDbgValue(V, DI.getVariable(), DI.getExpression());
     } else {
       for (Register Reg : getOrCreateVRegs(*V)) {
         // FIXME: This does not handle register-indirect values at offset 0. The
         // direct/indirect thing shouldn't really be handled by something as
         // implicit as reg+noreg vs reg+imm in the first place, but it seems
         // pretty baked in right now.
-        MIRBuilder.buildDirectDbgValue(Reg, DI.getVariable(), DI.getExpression());
+        MIRBuilder.buildDirectDbgValue(Reg, Var, DE);
       }
     }
+    unsigned Count = 0;
+    if (Count++ < Level) {
+      SmallVector<uint64_t, 3> Ops;
+      Ops.push_back(dwarf::DW_OP_LLVM_implicit_pointer);
+      Ops.push_back(0);
+      DIExpression *DIExprNew = DIExpression::get(DE->getContext(), Ops);
+
+      MIRBuilder.buildDerefDbgValue(PtrVars[Count - 1], PtrVars[Count],
+                                    DIExprNew);
+    }
     return true;
   }
   case Intrinsic::uadd_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_UADDO, MIRBuilder);
   case Intrinsic::sadd_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_SADDO, MIRBuilder);
   case Intrinsic::usub_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_USUBO, MIRBuilder);

llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

if (auto *CI = dyn_cast<ConstantInt>(&C)) {
     // Insert %noreg if we didn't find a usable constant and had to drop it.
     MIB.addReg(0U);
   }
 
   MIB.addImm(0).addMetadata(Variable).addMetadata(Expr);
   return insertInstr(MIB);
 }
 
+MachineInstrBuilder MachineIRBuilder::buildDerefDbgValue(const Value *Derefval,
+                                                         const MDNode *Variable,
+                                                         const MDNode *Expr) {
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
+  assert(
+      cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(getDL()) &&
+      "Expected inlined-at fields to agree");
+  auto MIB = buildInstr(TargetOpcode::DBG_VALUE);
+  if (const auto *MDV = dyn_cast<llvm::MetadataAsValue>(Derefval)) {
+    if (const auto *LDV = dyn_cast<llvm::DIVariable>(MDV->getMetadata())) {
+      MIB.addImplicitPtrMetadata(LDV);
+    }
+  } else if (auto *CI = dyn_cast<ConstantInt>(Derefval)) {
+    if (CI->getBitWidth() > 64)
+      MIB.addCImm(CI);
+    else
+      MIB.addImm(CI->getZExtValue());
+  } else if (auto *CFP = dyn_cast<ConstantFP>(Derefval)) {
+    MIB.addFPImm(CFP);
+  } else {
+    // Insert %noreg if we didn't find a usable constant and had to drop it.
+    MIB.addReg(0U);
+  }
+
+  return MIB.addReg(0).addMetadata(Variable).addMetadata(Expr);
+}
+
+MachineInstrBuilder MachineIRBuilder::buildDerefDbgValue(const MDNode *DerefVar,
+                                                         const MDNode *Variable,
+                                                         const MDNode *Expr) {
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
+  assert(
+      cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(getDL()) &&
+      "Expected inlined-at fields to agree");
+  auto MIB = buildInstr(TargetOpcode::DBG_VALUE);
+
+  MIB.addImplicitPtrMetadata(DerefVar);
+
+  return MIB.addReg(0).addMetadata(Variable).addMetadata(Expr);
+}
+
 MachineInstrBuilder MachineIRBuilder::buildDbgLabel(const MDNode *Label) {
   assert(isa<DILabel>(Label) && "not a label");
   assert(cast<DILabel>(Label)->isValidLocationForIntrinsic(State.DL) &&
          "Expected inlined-at fields to agree");
   auto MIB = buildInstr(TargetOpcode::DBG_LABEL);
 
   return MIB.addMetadata(Label);
 }

llvm/lib/CodeGen/LiveDebugValues.cpp

struct VarLoc {
 
     enum VarLocKind {
       InvalidKind = 0,
       RegisterKind,
       SpillLocKind,
       ImmediateKind,
       EntryValueKind,
       EntryValueBackupKind,
-      EntryValueCopyBackupKind
+      EntryValueCopyBackupKind,
+      ImplicitPtrKind
     } Kind = InvalidKind;
 
     /// The value location. Stored separately to avoid repeatedly
     /// extracting it from MI.
     union {
       uint64_t RegNo;
       SpillLoc SpillLocation;
       uint64_t Hash;
       int64_t Immediate;
       const ConstantFP *FPImm;
       const ConstantInt *CImm;
+      const DIVariable *ImplicitPtr;
     } Loc;
 
     VarLoc(const MachineInstr &MI, LexicalScopes &LS)
         : Var(MI.getDebugVariable(), MI.getDebugExpression(),
               MI.getDebugLoc()->getInlinedAt()),
           Expr(MI.getDebugExpression()), MI(MI) {
       static_assert((sizeof(Loc) == sizeof(uint64_t)),
                     "hash does not cover all members of Loc");
       assert(MI.isDebugValue() && "not a DBG_VALUE");
       assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE");
       if (int RegNo = isDbgValueDescribedByReg(MI)) {
         Kind = RegisterKind;
         Loc.RegNo = RegNo;
       } else if (MI.getDebugOperand(0).isImm()) {
         Kind = ImmediateKind;
         Loc.Immediate = MI.getDebugOperand(0).getImm();
       } else if (MI.getDebugOperand(0).isFPImm()) {
         Kind = ImmediateKind;
         Loc.FPImm = MI.getDebugOperand(0).getFPImm();
       } else if (MI.getDebugOperand(0).isCImm()) {
         Kind = ImmediateKind;
         Loc.CImm = MI.getDebugOperand(0).getCImm();
+      } else if (MI.getDebugOperand(0).isMetadata()) {
+        Kind = ImplicitPtrKind;
+        Loc.ImplicitPtr = MI.getDebugImplicitVariable();
       }
 
       // We create the debug entry values from the factory functions rather than
       // from this ctor.
       assert(Kind != EntryValueKind && !isEntryBackupLoc());
     }
 
     /// Take the variable and machine-location in DBG_VALUE MI, and build an
MachineInstr *BuildDbgValue(MachineFunction &MF) const {
             DIExpr, DIExpression::ApplyOffset, Loc.SpillLocation.SpillOffset);
         unsigned Base = Loc.SpillLocation.SpillBase;
         return BuildMI(MF, DbgLoc, IID, true, Base, Var, SpillExpr);
       }
       case ImmediateKind: {
         MachineOperand MO = MI.getDebugOperand(0);
         return BuildMI(MF, DbgLoc, IID, Indirect, MO, Var, DIExpr);
       }
+      case ImplicitPtrKind: {
+        MachineOperand MO = MI.getOperand(0);
+        return BuildMI(MF, DbgLoc, IID, Indirect, MO, Var, DIExpr);
+      }
       case EntryValueBackupKind:
       case EntryValueCopyBackupKind:
       case InvalidKind:
         llvm_unreachable(
             "Tried to produce DBG_VALUE for invalid or backup VarLoc");
       }
       llvm_unreachable("Unrecognized LiveDebugValues.VarLoc.Kind enum");
     }
void dump(const TargetRegisterInfo *TRI, raw_ostream &Out = dbgs()) const {
         break;
       case SpillLocKind:
         Out << printReg(Loc.SpillLocation.SpillBase, TRI);
         Out << "[" << Loc.SpillLocation.SpillOffset << "]";
         break;
       case ImmediateKind:
         Out << Loc.Immediate;
         break;
+      case ImplicitPtrKind:
+        dbgs() << Loc.ImplicitPtr->getName();
+        break;
       case InvalidKind:
         llvm_unreachable("Invalid VarLoc in dump method");
       }
 
       Out << ", \"" << Var.getVariable()->getName() << "\", " << *Expr << ", ";
       if (Var.getInlinedAt())
         Out << "!" << Var.getInlinedAt()->getMetadataID() << ")\n";
       else
if (removeEntryValue(MI, OpenRanges, VarLocIDs, EntryVL)) {
                  MI.print(dbgs(), /*IsStandalone*/ false,
                           /*SkipOpers*/ false, /*SkipDebugLoc*/ false,
                           /*AddNewLine*/ true, TII));
       OpenRanges.erase(EntryVL);
     }
   }
 
   if (isDbgValueDescribedByReg(MI) || MI.getDebugOperand(0).isImm() ||
-      MI.getDebugOperand(0).isFPImm() || MI.getDebugOperand(0).isCImm()) {
+      MI.getDebugOperand(0).isFPImm() || MI.getDebugOperand(0).isCImm() ||
+      MI.getOperand(0).isMetadata()) {
     // Use normal VarLoc constructor for registers and immediates.
     VarLoc VL(MI, LS);
     // End all previous ranges of VL.Var.
     OpenRanges.erase(VL);
 
     LocIndex ID = VarLocIDs.insert(VL);
     // Add the VarLoc to OpenRanges from this DBG_VALUE.
     OpenRanges.insert(ID, VL);

llvm/lib/CodeGen/MachineInstr.cpp

const DILocalVariable *MachineInstr::getDebugVariable() const {
   return cast<DILocalVariable>(getOperand(2).getMetadata());
 }
 
 MachineOperand &MachineInstr::getDebugExpressionOp() {
   assert(isDebugValue() && "not a DBG_VALUE");
   return getOperand(3);
 }
 
+const DIVariable *MachineInstr::getDebugImplicitVariable() const {
+  assert(isDebugValue() && "not a DBG_VALUE");
+  return cast<DIVariable>(getOperand(0).getMetadata());
+}
+
 const DIExpression *MachineInstr::getDebugExpression() const {
   assert(isDebugValue() && "not a DBG_VALUE");
   return cast<DIExpression>(getOperand(3).getMetadata());
 }
 
 bool MachineInstr::isDebugEntryValue() const {
   return isDebugValue() && getDebugExpression()->isEntryValue();
 }

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/InlineAsm.h"
if (Op) {
                         << " (no materialized reg for address)\n");
     }
     return true;
   }
   case Intrinsic::dbg_value: {
     // This form of DBG_VALUE is target-independent.
     const DbgValueInst *DI = cast<DbgValueInst>(II);
     const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE);
-    const Value *V = DI->getValue();
+    const DIExpression *DE = DI->getExpression();
+    DILocalVariable *Var = DI->getVariable();
+    DILocalVariable *PtrVar = nullptr;
+    unsigned Level = DE->explicitPointerCount();
+    const Value *V = (Level > 0) ? DI->getDerefVariable(false)
+                                 : DI->getVariableLocation(false);
     assert(DI->getVariable()->isValidLocationForIntrinsic(DbgLoc) &&
            "Expected inlined-at fields to agree");
+
+    Module *Mod = const_cast<Module *>(DI->getModule());
+    DIBuilder DIB(*Mod, /*AllowUnresolved*/ false);
+
+    SmallVector<DILocalVariable *, 1> PtrVars;
+    if (Level > 0) {
+      DIScope *Scope = DI->getDebugLoc()->getScope();
+      DIType *Type = DI->getVariable()->getType();
+      unsigned Count = 0;
+      while (Count++ < Level) {
+        if (DIDerivedType *DT = dyn_cast<DIDerivedType>(Type))
+          Type = DT->getBaseType();
+        uint32_t AlignInBits = DI->getVariable()->getAlignInBytes();
+
+        PtrVar = DIB.createImplicitTempVariable(Scope, Type, AlignInBits);
+        PtrVars.push_back(PtrVar);
+      }
+      PtrVars.push_back(Var);
+
+      Var = PtrVars[0];
+      SmallVector<uint64_t, 3> Ops;
+      DE = DIExpression::get(DE->getContext(), Ops);
+    } else {
+      Var = DI->getVariable();
+      DE = DI->getExpression();
+    }
+
     if (!V || isa<UndefValue>(V)) {
       // Currently the optimizer can produce this; insert an undef to
       // help debugging.
-      BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, false, 0U,
-              DI->getVariable(), DI->getExpression());
+      BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, false, 0U, Var, DE);
     } else if (const auto *CI = dyn_cast<ConstantInt>(V)) {
       if (CI->getBitWidth() > 64)
         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II)
             .addCImm(CI)
             .addImm(0U)
-            .addMetadata(DI->getVariable())
-            .addMetadata(DI->getExpression());
+            .addMetadata(Var)
+            .addMetadata(DE);
       else
         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II)
             .addImm(CI->getZExtValue())
             .addImm(0U)
-            .addMetadata(DI->getVariable())
-            .addMetadata(DI->getExpression());
+            .addMetadata(Var)
+            .addMetadata(DE);
     } else if (const auto *CF = dyn_cast<ConstantFP>(V)) {
       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II)
           .addFPImm(CF)
           .addImm(0U)
-          .addMetadata(DI->getVariable())
-          .addMetadata(DI->getExpression());
+          .addMetadata(Var)
+          .addMetadata(DE);
     } else if (Register Reg = lookUpRegForValue(V)) {
       // FIXME: This does not handle register-indirect values at offset 0.
       bool IsIndirect = false;
       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, IsIndirect, Reg,
-              DI->getVariable(), DI->getExpression());
+              Var, DE);
     } else {
       // We don't know how to handle other cases, so we drop.
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
     }
+
+    if (!PtrVars.empty()) {
+      unsigned Count = 0;
+      while (Count++ < Level) {
+        SmallVector<uint64_t, 3> Ops;
+        Ops.push_back(dwarf::DW_OP_LLVM_implicit_pointer);
+        Ops.push_back(0);
+        DIExpression *DIExprNew = DIExpression::get(DE->getContext(), Ops);
+
+        BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II)
+            .addImplicitPtrMetadata(PtrVars[Count - 1])
+            .addReg(0U)
+            .addMetadata(PtrVars[Count])
+            .addMetadata(DIExprNew);
+      }
+    }
     return true;
   }
   case Intrinsic::dbg_label: {
     const DbgLabelInst *DI = cast<DbgLabelInst>(II);
     assert(DI->getLabel() && "Missing label");
     if (!FuncInfo.MF->getMMI().hasDebugInfo()) {
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
       return true;

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

if (SD->getKind() == SDDbgValue::SDNODE) {
     } else if (isa<ConstantPointerNull>(V)) {
       // Note: This assumes that all nullptr constants are zero-valued.
       MIB.addImm(0);
     } else {
       // Could be an Undef.  In any case insert an Undef so we can see what we
       // dropped.
       MIB.addReg(0U);
     }
+  } else if (SD->getKind() == SDDbgValue::IMPPTR) {
+    const MDNode *DV = SD->getImplicitPointer();
+    // insert implicit pointer
+    MIB.addImplicitPtrMetadata(DV);
   } else {
     // Insert an Undef so we can see what we dropped.
     MIB.addReg(0U);
   }
 
   // Indirect addressing is indicated by an Imm as the second parameter.
   if (SD->isIndirect())
     MIB.addImm(0U);

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

 class Value;
 class raw_ostream;
 
 /// Holds the information from a dbg_value node through SDISel.
 /// We do not use SDValue here to avoid including its header.
 class SDDbgValue {
 public:
   enum DbgValueKind {
-    SDNODE = 0,             ///< Value is the result of an expression.
-    CONST = 1,              ///< Value is a constant.
-    FRAMEIX = 2,            ///< Value is contents of a stack location.
-    VREG = 3                ///< Value is a virtual register.
+    SDNODE = 0,  ///< Value is the result of an expression.
+    CONST = 1,   ///< Value is a constant.
+    FRAMEIX = 2, ///< Value is contents of a stack location.
+    VREG = 3,    ///< Value is a virtual register.
+    IMPPTR = 4   ///< Value is an implicit pointer.
   };
+
 private:
   union {
     struct {
       SDNode *Node;         ///< Valid for expressions.
       unsigned ResNo;       ///< Valid for expressions.
     } s;
     const Value *Const;     ///< Valid for constants.
     unsigned FrameIx;       ///< Valid for stack objects.
     unsigned VReg;          ///< Valid for registers.
+    DIVariable *ImpPtr;
   } u;
   DIVariable *Var;
   DIExpression *Expr;
   DebugLoc DL;
   unsigned Order;
   enum DbgValueKind kind;
   bool IsIndirect;
   bool Invalid = false;
assert((Kind == VREG || Kind == FRAMEIX) &&
            "Invalid SDDbgValue constructor");
     kind = Kind;
     if (kind == VREG)
       u.VReg = VRegOrFrameIdx;
     else
       u.FrameIx = VRegOrFrameIdx;
   }
 
+  /// Constructor for Implicit Pointer.
+  SDDbgValue(DIVariable *Var, DIExpression *Expr, DIVariable *Val, DebugLoc dl,
+             unsigned O)
+      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
+    kind = IMPPTR;
+    u.ImpPtr = Val;
+  }
+
   /// Returns the kind.
   DbgValueKind getKind() const { return kind; }
 
   /// Returns the DIVariable pointer for the variable.
   DIVariable *getVariable() const { return Var; }
 
   /// Returns the DIExpression pointer for the expression.
   DIExpression *getExpression() const { return Expr; }
 
   /// Returns the SDNode* for a register ref
   SDNode *getSDNode() const { assert (kind==SDNODE); return u.s.Node; }
 
   /// Returns the ResNo for a register ref
   unsigned getResNo() const { assert (kind==SDNODE); return u.s.ResNo; }
 
   /// Returns the Value* for a constant
   const Value *getConst() const { assert (kind==CONST); return u.Const; }
 
   /// Returns the FrameIx for a stack object
   unsigned getFrameIx() const { assert (kind==FRAMEIX); return u.FrameIx; }
 
   /// Returns the Virtual Register for a VReg
   unsigned getVReg() const { assert (kind==VREG); return u.VReg; }
 
+  /// Returns the implicit pointer target
+  DIVariable *getImplicitPointer() const {
+    assert(kind == IMPPTR);
+    return u.ImpPtr;
+  }
+
   /// Returns whether this is an indirect value.
   bool isIndirect() const { return IsIndirect; }
 
   /// Returns the DebugLoc.
   DebugLoc getDebugLoc() const { return DL; }
 
   /// Returns the SDNodeOrder.  This is the order of the preceding node in the
   /// input.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDDbgValue *SelectionDAG::getVRegDbgValue(DIVariable *Var,
                                           unsigned VReg, bool IsIndirect,
                                           const DebugLoc &DL, unsigned O) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
   return new (DbgInfo->getAlloc())
       SDDbgValue(Var, Expr, VReg, IsIndirect, DL, O, SDDbgValue::VREG);
 }
 
+/// Implicit pointer
+SDDbgValue *SelectionDAG::getImpPtrDbgValue(DIVariable *Var, DIExpression *Expr,
+                                            DIVariable *Val, const DebugLoc &DL,
+                                            unsigned O) {
+  assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
+         "Expected inlined-at fields to agree");
+  return new (DbgInfo->getAlloc()) SDDbgValue(Var, Expr, Val, DL, O);
+}
+
 void SelectionDAG::transferDbgValues(SDValue From, SDValue To,
                                      unsigned OffsetInBits, unsigned SizeInBits,
                                      bool InvalidateDbg) {
   SDNode *FromNode = From.getNode();
   SDNode *ToNode = To.getNode();
   assert(FromNode && ToNode && "Can't modify dbg values");
 
   // PR35338

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

public:
   /// structures now that we've seen its definition.
   void resolveDanglingDebugInfo(const Value *V, SDValue Val);
 
   /// For the given dangling debuginfo record, perform last-ditch efforts to
   /// resolve the debuginfo to something that is represented in this DAG. If
   /// this cannot be done, produce an Undef debug value record.
   void salvageUnresolvedDbgValue(DanglingDebugInfo &DDI);
 
+  bool handleDebugValueWrapper(const DbgValueInst &DI, DebugLoc dl,
+                               unsigned Order);
+
   /// For a given Value, attempt to create and record a SDDbgValue in the
   /// SelectionDAG.
   bool handleDebugValue(const Value *V, DILocalVariable *Var,
                         DIExpression *Expr, DebugLoc CurDL,
                         DebugLoc InstDL, unsigned Order);
 
   /// Evict any dangling debug information, attempting to salvage it first.
   void resolveOrClearDbgInfo();

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/InstrTypes.h"
#define HANDLE_INST(NUM, OPCODE, CLASS) \
     case Instruction::OPCODE: visit##OPCODE((const CLASS&)I); break;
 #include "llvm/IR/Instruction.def"
   }
 }
 
 void SelectionDAGBuilder::dropDanglingDebugInfo(const DILocalVariable *Variable,
                                                 const DIExpression *Expr) {
   auto isMatchingDbgValue = [&](DanglingDebugInfo &DDI) {
-    const DbgValueInst *DI = DDI.getDI();
+    const DbgVariableIntrinsic *DI = DDI.getDI();
     DIVariable *DanglingVariable = DI->getVariable();
     DIExpression *DanglingExpr = DI->getExpression();
     if (DanglingVariable == Variable && Expr->fragmentsOverlap(DanglingExpr)) {
       LLVM_DEBUG(dbgs() << "Dropping dangling debug info for " << *DI << "\n");
       return true;
     }
     return false;
   };
void SelectionDAGBuilder::salvageUnresolvedDbgValue(DanglingDebugInfo &DDI) {
   if (handleDebugValue(V, Var, Expr, DL, InstDL, SDOrder))
     return;
 
   // Attempt to salvage back through as many instructions as possible. Bail if
   // a non-instruction is seen, such as a constant expression or global
   // variable. FIXME: Further work could recover those too.
   while (isa<Instruction>(V)) {
     Instruction &VAsInst = *cast<Instruction>(V);
-    DIExpression *NewExpr = salvageDebugInfoImpl(VAsInst, Expr, StackValue);
+    DIExpression *NewExpr = VAsInst.salvageDebugInfoImpl(Expr, StackValue);
 
     // If we cannot salvage any further, and haven't yet found a suitable debug
     // expression, bail out.
     if (!NewExpr)
       break;
 
     // New value and expr now represent this debuginfo.
     V = VAsInst.getOperand(0);
void SelectionDAGBuilder::salvageUnresolvedDbgValue(DanglingDebugInfo &DDI) {
   DAG.AddDbgValue(SDV, nullptr, false);
 
   LLVM_DEBUG(dbgs() << "Dropping debug value info for:\n  " << DDI.getDI()
                     << "\n");
   LLVM_DEBUG(dbgs() << "  Last seen at:\n    " << *DDI.getDI()->getOperand(0)
                     << "\n");
 }
 
+bool SelectionDAGBuilder::handleDebugValueWrapper(const DbgValueInst &DI,
+                                                  DebugLoc dl, unsigned Order) {
+  DILocalVariable *Variable = DI.getVariable();
+  DIExpression *Expression = DI.getExpression();
+
+  const Value *V = DI.getValue();
+
+  unsigned Level = Expression->explicitPointerCount();
+  if (Level > 0) {
+    DIScope *Scope = DI.getDebugLoc()->getScope();
+    DIType *Type = DI.getVariable()->getType();
+    Module *Mod = const_cast<Module *>(DI.getModule());
+    DIBuilder DIB(*Mod, /*AllowUnresolved*/ false);
+    SmallVector<DILocalVariable *, 1> PtrVars;
+    unsigned Count = 0;
+    while (Count++ < Level) {
+      if (DIDerivedType *DT = dyn_cast<DIDerivedType>(Type))
+        Type = DT->getBaseType();
+      uint32_t AlignInBits = DI.getVariable()->getAlignInBytes();
+
+      DILocalVariable *PteVar =
+          DIB.createImplicitTempVariable(Scope, Type, AlignInBits);
+      PtrVars.push_back(PteVar);
+    }
+    PtrVars.push_back(Variable);
+
+    SmallVector<uint64_t, 3> Ops;
+    DIExpression *DE = DIExpression::get(Expression->getContext(), Ops);
+
+    if (!handleDebugValue(V, PtrVars[0], DE, dl, DI.getDebugLoc(), SDNodeOrder))
+      return false;
+
+    SDDbgValue *SDV;
+
+    Count = 0;
+    while (Count++ < Level) {
+      DE = DIExpression::get(DE->getContext(),
+                             {dwarf::DW_OP_LLVM_implicit_pointer, 0});
+
+      SDV = DAG.getImpPtrDbgValue(PtrVars[Count], DE, PtrVars[Count - 1], dl,
+                                  SDNodeOrder);
+      DAG.AddDbgValue(SDV, nullptr, false);
+    }
+    return true;
+  } else {
+    return handleDebugValue(V, Variable, Expression, dl, DI.getDebugLoc(),
+                            SDNodeOrder);
+  }
+}
+
 bool SelectionDAGBuilder::handleDebugValue(const Value *V, DILocalVariable *Var,
                                            DIExpression *Expr, DebugLoc dl,
                                            DebugLoc InstDL, unsigned Order) {
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
   SDDbgValue *SDV;
   if (isa<ConstantInt>(V) || isa<ConstantFP>(V) || isa<UndefValue>(V) ||
       isa<ConstantPointerNull>(V)) {
     SDV = DAG.getConstantDbgValue(Var, Expr, V, dl, SDNodeOrder);
     DAG.AddDbgValue(SDV, nullptr, false);
     return true;
   }
 
+  if (const llvm::MetadataAsValue *MDV = dyn_cast<llvm::MetadataAsValue>(V)) {
+    if (DILocalVariable *DLV = dyn_cast<DILocalVariable>(MDV->getMetadata())) {
+      SDV = DAG.getImpPtrDbgValue(Var, Expr, DLV, dl, SDNodeOrder);
+      DAG.AddDbgValue(SDV, nullptr, false);
+      return true;
+    }
+  }
   // If the Value is a frame index, we can create a FrameIndex debug value
   // without relying on the DAG at all.
   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
     auto SI = FuncInfo.StaticAllocaMap.find(AI);
     if (SI != FuncInfo.StaticAllocaMap.end()) {
       auto SDV =
           DAG.getFrameIndexDbgValue(Var, Expr, SI->second,
                                     /*IsIndirect*/ false, dl, SDNodeOrder);
case Intrinsic::dbg_value: {
 
     DILocalVariable *Variable = DI.getVariable();
     DIExpression *Expression = DI.getExpression();
     dropDanglingDebugInfo(Variable, Expression);
     const Value *V = DI.getValue();
     if (!V)
       return;
 
-    if (handleDebugValue(V, Variable, Expression, dl, DI.getDebugLoc(),
-        SDNodeOrder))
+    if (handleDebugValueWrapper(DI, dl, SDNodeOrder))
       return;
 
     // TODO: Dangling debug info will eventually either be resolved or produce
     // an Undef DBG_VALUE. However in the resolution case, a gap may appear
     // between the original dbg.value location and its resolved DBG_VALUE, which
     // we should ideally fill with an extra Undef DBG_VALUE.
 
     DanglingDebugInfoMap[V].emplace_back(&DI, dl, SDNodeOrder);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

case CONST:
     OS << "(CONST)";
     break;
   case FRAMEIX:
     OS << "(FRAMEIX=" << getFrameIx() << ')';
     break;
   case VREG:
     OS << "(VREG=" << getVReg() << ')';
     break;
+  case IMPPTR:
+    // implicit pointer will be printed as
+    // DbgVal(Order=1)(IMPPTR=arr):"ptr"!DIExpression(DW_OP_implicit_pointer, 0)
+    OS << "(IMPPTR=" << u.ImpPtr->getName() << ')';
+    break;
   }
   if (isIndirect()) OS << "(Indirect)";
   OS << ":\"" << Var->getName() << '"';
 #ifndef NDEBUG
   if (Expr->getNumElements())
     Expr->dump();
 #endif
 }

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

 static void dumpExpression(raw_ostream &OS, ArrayRef<uint8_t> Data,
                            bool IsLittleEndian, unsigned AddressSize,
                            const MCRegisterInfo *MRI, DWARFUnit *U) {
   DWARFDataExtractor Extractor(Data, IsLittleEndian, AddressSize);
   // Note. We do not pass any format to DWARFExpression, even if the
   // corresponding unit is known. For now, there is only one operation,
   // DW_OP_call_ref, which depends on the format; it is rarely used, and
   // is unexpected in location tables.
+  if (U)
+    DWARFExpression(Extractor, AddressSize, U->getFormParams().Format)
+        .print(OS, MRI, U);
+  else
     DWARFExpression(Extractor, AddressSize).print(OS, MRI, U);
 }
 
 bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS,
                                           Optional<SectionedAddress> BaseAddr,
                                           const MCRegisterInfo *MRI,
                                           const DWARFObject &Obj, DWARFUnit *U,
                                           DIDumpOptions DumpOpts,
                                           unsigned Indent) const {

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static DescVector getDescriptions() {
   Descriptions[DW_OP_GNU_addr_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_const_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_entry_value] = Desc(Op::Dwarf4, Op::SizeLEB);
 
   Descriptions[DW_OP_convert] = Desc(Op::Dwarf5, Op::BaseTypeRef);
   Descriptions[DW_OP_entry_value] = Desc(Op::Dwarf5, Op::SizeLEB);
   Descriptions[DW_OP_regval_type] =
       Desc(Op::Dwarf5, Op::SizeLEB, Op::BaseTypeRef);
+  Descriptions[DW_OP_implicit_pointer] =
+      Desc(Op::Dwarf5, Op::SizeRefAddr, Op::SignedSizeLEB);
 
   return Descriptions;
 }
 
 static DWARFExpression::Operation::Description getOpDesc(unsigned OpCode) {
   // FIXME: Make this constexpr once all compilers are smart enough to do it.
   static DescVector Descriptions = getDescriptions();
   // Handle possible corrupted or unsupported operation.

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 << I->getArg(0);
       } 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/DIBuilder.cpp

DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name,
                                                DIType *Ty, bool AlwaysPreserve,
                                                DINode::DIFlags Flags,
                                                uint32_t AlignInBits) {
   return createLocalVariable(VMContext, PreservedVariables, Scope, Name,
                              /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve,
                              Flags, AlignInBits);
 }
 
+DILocalVariable *DIBuilder::createImplicitTempVariable(DIScope *Scope,
+                                                       DIType *Ty,
+                                                       uint32_t AlignInBits) {
+  static unsigned TmpCount = 0;
+  std::string SName("__implicit_ptr_tmp_");
+  SName.append(std::to_string(TmpCount++));
+  llvm::StringRef Name(SName);
+
+  return createLocalVariable(VMContext, PreservedVariables, Scope, Name,
+                             /* ArgNo */ 0, nullptr, 0, Ty, false,
+                             llvm::DINode::FlagArtificial, AlignInBits);
+}
+
 DILocalVariable *DIBuilder::createParameterVariable(
     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) {
   assert(ArgNo && "Expected non-zero argument number for parameter");
   return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo,
                              File, LineNo, Ty, AlwaysPreserve, Flags,
                              /* AlignInBits */0);
 }

llvm/lib/IR/DebugInfoMetadata.cpp

case dwarf::DW_OP_bregx:
     return 3;
   case dwarf::DW_OP_constu:
   case dwarf::DW_OP_consts:
   case dwarf::DW_OP_deref_size:
   case dwarf::DW_OP_plus_uconst:
   case dwarf::DW_OP_LLVM_tag_offset:
   case dwarf::DW_OP_LLVM_entry_value:
   case dwarf::DW_OP_regx:
+  case dwarf::DW_OP_LLVM_implicit_pointer:
     return 2;
   default:
     return 1;
   }
 }
 
 bool DIExpression::isValid() const {
   for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
case dwarf::DW_OP_LLVM_entry_value: {
       // An entry value operator must appear at the beginning and the number of
       // operations it cover can currently only be 1, because we support only
       // entry values of a simple register location. One reason for this is that
       // we currently can't calculate the size of the resulting DWARF block for
       // other expressions.
       return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 &&
              getNumElements() == 2;
     }
+    case dwarf::DW_OP_LLVM_implicit_pointer: {
+      // A DW_OP_LLVM_implicit_pointer operator must appear at the beginning
+      // and it has one argument.
+      return (I == expr_op_begin()) && (getNumElements() == 2);
+    }
+    case dwarf::DW_OP_LLVM_explicit_pointer:
     case dwarf::DW_OP_LLVM_convert:
     case dwarf::DW_OP_LLVM_tag_offset:
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
     case dwarf::DW_OP_mul:
     case dwarf::DW_OP_div:
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 = 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/Instruction.cpp

 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Instruction class for the IR library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Instruction.h"
-#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/MDBuilder.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 using namespace llvm;
 
 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
                          Instruction *InsertBefore)
   : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
 
const Function *Instruction::getFunction() const {
   return getParent()->getParent();
 }
 
 void Instruction::removeFromParent() {
   getParent()->getInstList().remove(getIterator());
 }
 
 iplist<Instruction>::iterator Instruction::eraseFromParent() {
+  // Try to preserve debug information attached to the instruction.
+  salvageDebugInfo();
+
   return getParent()->getInstList().erase(getIterator());
 }
 
 /// Insert an unlinked instruction into a basic block immediately before the
 /// specified instruction.
 void Instruction::insertBefore(Instruction *InsertPos) {
   InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this);
 }

 #include "llvm/IR/Instruction.def"
 #undef HANDLE_INST
   }
 
   New->SubclassOptionalData = SubclassOptionalData;
   New->copyMetadata(*this);
   return New;
 }
+
+void Instruction::salvageDebugInfo() {
+  SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
+
+  // Return false if any of the operand is already deleted
+  for (unsigned i = 0; i < getNumOperands(); ++i)
+    if (!getOperand(i))
+      return;
+
+  // preserve the information we may need later when called function from
+  // current function is inlined. We need this information for
+  // DW_OP_implicit_pointer.
+  if (auto DDI = dyn_cast<DbgVariableIntrinsic>(this))
+    if (getModule()->getDwarfVersion() >= 5)
+      if (DDI->isAddressOfVariable())
+        getModule()->insertVarAddressMap(DDI);
+
+  findDbgUsers(DbgUsers);
+  if (DbgUsers.empty())
+    return;
+
+  salvageDebugInfoForDbgValues(DbgUsers);
+}
+
+void Instruction::salvageDebugInfoForDbgValues(
+    ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
+  auto &Ctx = getContext();
+  bool Salvaged = false;
+  auto wrapMD = [&](Value *V) {
+    return MetadataAsValue::get(Ctx, ValueAsMetadata::get(V));
+  };
+  Value *DebugDeclareAddress = nullptr;
+  SmallVector<StoreInst *, 1> StoreInsts;
+
+  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 (!StoreInsts.empty()) {
+      if (!DII->getExpression()->extractIfOffset(ExprOffset))
+        continue;
+    } else if (isa<AllocaInst>(this) &&
+               (!DebugDeclareAddress || DII->isAddressOfVariable() ||
+                !DII->getExpression()->extractIfOffset(ExprOffset)))
+      continue;
+
+    if (!StoreInsts.empty()) {
+      DIBuilder DIB(*getModule(), /*AllowUnresolved*/ false);
+
+      DIExpression *DIExpr = DII->getExpression();
+
+      for (auto *SI : StoreInsts) {
+        Value *ReplVal = SI->getOperand(0);
+        SmallVector<uint64_t, 3> Ops;
+        Ops.push_back(dwarf::DW_OP_LLVM_explicit_pointer);
+        DIExpression *DIExprNew = DIExpression::get(DIExpr->getContext(), Ops);
+
+        if (!StackValue)
+          DIB.insertDbgValueIntrinsic(ReplVal, DII->getVariable(), DIExprNew,
+                                      DII->getDebugLoc(), SI);
+        else {
+          DII->setOperand(0, wrapMD(ReplVal));
+          DII->setOperand(2, MetadataAsValue::get(Ctx, DIExprNew));
+        }
+      }
+      Salvaged = true;
+    } else if (!isa<AllocaInst>(this)) {
+      DII->setOperand(0, wrapMD(getOperand(0)));
+      DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
+      Salvaged = true;
+    }
+  }
+
+  if (Salvaged)
+    return;
+
+  for (auto *DII : DbgUsers) {
+    Value *Undef = UndefValue::get(getType());
+    DII->setOperand(0, MetadataAsValue::get(DII->getContext(),
+                                            ValueAsMetadata::get(Undef)));
+  }
+}
+
+DIExpression *Instruction::salvageDebugInfoImpl(DIExpression *SrcDIExpr,
+                                                bool WithStackValue) {
+  auto &M = *getModule();
+  auto &DL = M.getDataLayout();
+
+  // Apply a vector of opcodes to the source DIExpression.
+  auto doSalvage = [&](SmallVectorImpl<uint64_t> &Ops) -> DIExpression * {
+    DIExpression *DIExpr = SrcDIExpr;
+    if (!Ops.empty()) {
+      DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
+    }
+    return DIExpr;
+  };
+
+  // Apply the given offset to the source DIExpression.
+  auto applyOffset = [&](uint64_t Offset) -> DIExpression * {
+    SmallVector<uint64_t, 8> Ops;
+    DIExpression::appendOffset(Ops, Offset);
+    return doSalvage(Ops);
+  };
+
+  // initializer-list helper for applying operators to the source DIExpression.
+  auto applyOps = [&](ArrayRef<uint64_t> Opcodes) -> DIExpression * {
+    SmallVector<uint64_t, 8> Ops(Opcodes.begin(), Opcodes.end());
+    return doSalvage(Ops);
+  };
+
+  if (auto *CI = dyn_cast<CastInst>(this)) {
+    // No-op casts are irrelevant for debug info.
+    if (CI->isNoopCast(DL))
+      return SrcDIExpr;
+
+    Type *Type = CI->getType();
+    // Casts other than Trunc, SExt, or ZExt to scalar types cannot be salvaged.
+    if (Type->isVectorTy() ||
+        !(isa<TruncInst>(this) || isa<SExtInst>(this) || isa<ZExtInst>(this)))
+      return nullptr;
+
+    Value *FromValue = CI->getOperand(0);
+    unsigned FromTypeBitSize = FromValue->getType()->getScalarSizeInBits();
+    unsigned ToTypeBitSize = Type->getScalarSizeInBits();
+
+    return applyOps(DIExpression::getExtOps(FromTypeBitSize, ToTypeBitSize,
+                                            isa<SExtInst>(this)));
+  }
+
+  if (auto *GEP = dyn_cast<GetElementPtrInst>(this)) {
+    unsigned BitWidth =
+        M.getDataLayout().getIndexSizeInBits(GEP->getPointerAddressSpace());
+    // Rewrite a constant GEP into a DIExpression.
+    APInt Offset(BitWidth, 0);
+    if (GEP->accumulateConstantOffset(M.getDataLayout(), Offset)) {
+      return applyOffset(Offset.getSExtValue());
+    } else {
+      return nullptr;
+    }
+  } else if (auto *BI = dyn_cast<BinaryOperator>(this)) {
+    // Rewrite binary operations with constant integer operands.
+    auto *ConstInt = dyn_cast<ConstantInt>(getOperand(1));
+    if (!ConstInt || ConstInt->getBitWidth() > 64)
+      return nullptr;
+
+    uint64_t Val = ConstInt->getSExtValue();
+    switch (BI->getOpcode()) {
+    case Instruction::Add:
+      return applyOffset(Val);
+    case Instruction::Sub:
+      return applyOffset(-int64_t(Val));
+    case Instruction::Mul:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_mul});
+    case Instruction::SDiv:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_div});
+    case Instruction::SRem:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_mod});
+    case Instruction::Or:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_or});
+    case Instruction::And:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_and});
+    case Instruction::Xor:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_xor});
+    case Instruction::Shl:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shl});
+    case Instruction::LShr:
+      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shr});
+    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>(this)) {
+    return SrcDIExpr;
+  }
+  return nullptr;
+}

llvm/lib/IR/IntrinsicInst.cpp

 /// intrinsics for variables.
 ///
 
 Value *DbgVariableIntrinsic::getVariableLocation(bool AllowNullOp) const {
   Value *Op = getArgOperand(0);
   if (AllowNullOp && !Op)
     return nullptr;
 
+  if (isImplicitPointer())
+    return Op;
+
+  auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
+  if (auto *V = dyn_cast<ValueAsMetadata>(MD))
+    return V->getValue();
+
+  // When the value goes to null, it gets replaced by an empty MDNode.
+  assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
+  return nullptr;
+}
+
+Value *DbgVariableIntrinsic::getDerefVariable(bool AllowNullOp) const {
+  Value *Op = getArgOperand(0);
+  if (AllowNullOp && !Op)
+    return nullptr;
+
+  if (isImplicitPointer())
+    return Op;
+
   auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
   if (auto *V = dyn_cast<ValueAsMetadata>(MD))
     return V->getValue();
 
   // When the value goes to null, it gets replaced by an empty MDNode.
   assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
   return nullptr;
 }

llvm/lib/IR/Metadata.cpp

void ValueAsMetadata::handleDeletion(Value *V) {
   MD->replaceAllUsesWith(nullptr);
   delete MD;
 }
 
 void ValueAsMetadata::handleRAUW(Value *From, Value *To) {
   assert(From && "Expected valid value");
   assert(To && "Expected valid value");
   assert(From != To && "Expected changed value");
-  assert(From->getType() == To->getType() && "Unexpected type change");
 
   LLVMContext &Context = From->getType()->getContext();
   auto &Store = Context.pImpl->ValuesAsMetadata;
   auto I = Store.find(From);
   if (I == Store.end()) {
     assert(!From->IsUsedByMD && "Expected From not to be used by metadata");
     return;
   }

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/ModuleSummaryIndex.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"
if (ProfileSummary) {
         return;
       double Ratio = (double)BlockCount / NumCounts;
       ProfileSummary->setPartialProfileRatio(Ratio);
       setProfileSummary(ProfileSummary->getMD(getContext()),
                         ProfileSummary::PSK_Sample);
     }
   }
 }
+
+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/IR/Value.cpp

static bool contains(Value *Expr, Value *V) {
   return contains(Cache, CE, C);
 }
 #endif // NDEBUG
 
 void Value::doRAUW(Value *New, ReplaceMetadataUses ReplaceMetaUses) {
   assert(New && "Value::replaceAllUsesWith(<null>) is invalid!");
   assert(!contains(New, this) &&
          "this->replaceAllUsesWith(expr(this)) is NOT valid!");
-  assert(New->getType() == getType() &&
-         "replaceAllUses of value with new value of different type!");
 
   // Notify all ValueHandles (if present) that this value is going away.
   if (HasValueHandle)
     ValueHandleBase::ValueIsRAUWd(this, New);
   if (ReplaceMetaUses == ReplaceMetadataUses::Yes && isUsedByMetadata())
     ValueAsMetadata::handleRAUW(this, New);
 
   while (!materialized_use_empty()) {
void Value::replaceUsesOutsideBlock(Value *New, BasicBlock *BB) {
 
   replaceUsesWithIf(New, [BB](Use &U) {
     auto *I = dyn_cast<Instruction>(U.getUser());
     // Don't replace if it's an instruction in the BB basic block.
     return !I || I->getParent() != BB;
   });
 }
 
+void Value::findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgUsers) {
+  // This function is hot. Check whether the value has any metadata to avoid a
+  // DenseMap lookup.
+  if (!isUsedByMetadata())
+    return;
+  if (auto *L = LocalAsMetadata::getIfExists(this))
+    if (auto *MDV = MetadataAsValue::getIfExists(getContext(), L))
+      for (User *U : MDV->users())
+        if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
+          DbgUsers.push_back(DII);
+}
+
 namespace {
 // Various metrics for how much to strip off of pointers.
 enum PointerStripKind {
   PSK_ZeroIndices,
   PSK_ZeroIndicesAndAliases,
   PSK_ZeroIndicesSameRepresentation,
   PSK_ZeroIndicesAndInvariantGroups,
   PSK_InBoundsConstantIndices,

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

public:
   /// Combiner aware instruction erasure.
   ///
   /// When dealing with an instruction that has side effects or produces a void
   /// value, we can't rely on DCE to delete the instruction. Instead, visit
   /// methods should return the value returned by this function.
   Instruction *eraseInstFromFunction(Instruction &I) {
     LLVM_DEBUG(dbgs() << "IC: ERASE " << I << '\n');
     assert(I.use_empty() && "Cannot erase instruction that is used!");
-    salvageDebugInfo(I);
+    I.salvageDebugInfo();
 
     // Make sure that we reprocess all operands now that we reduced their
     // use counts.
     for (Use &Operand : I.operands())
       if (auto *Inst = dyn_cast<Instruction>(Operand))
         Worklist.add(Inst);
 
     Worklist.remove(&I);

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

bool InstCombiner::SimplifyDemandedBits(Instruction *I, unsigned OpNo,
                                         const APInt &DemandedMask,
                                         KnownBits &Known,
                                         unsigned Depth) {
   Use &U = I->getOperandUse(OpNo);
   Value *NewVal = SimplifyDemandedUseBits(U.get(), DemandedMask, Known,
                                           Depth, I);
   if (!NewVal) return false;
   if (Instruction* OpInst = dyn_cast<Instruction>(U))
-    salvageDebugInfo(*OpInst);
-    
+    OpInst->salvageDebugInfo();
   replaceUse(U, NewVal);
   return true;
 }
 
 
 /// This function attempts to replace V with a simpler value based on the
 /// demanded bits. When this function is called, it is known that only the bits
 /// set in DemandedMask of the result of V are ever used downstream.

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();
static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) {
   ++NumSunkInst;
 
   // Also sink all related debug uses from the source basic block. Otherwise we
   // get debug use before the def. Attempt to salvage debug uses first, to
   // maximise the range variables have location for. If we cannot salvage, then
   // mark the location undef: we know it was supposed to receive a new location
   // here, but that computation has been sunk.
   SmallVector<DbgVariableIntrinsic *, 2> DbgUsers;
-  findDbgUsers(DbgUsers, I);
+  I->findDbgUsers(DbgUsers);
 
   // Update the arguments of a dbg.declare instruction, so that it
   // does not point into a sunk instruction.
   auto updateDbgDeclare = [&I](DbgVariableIntrinsic *DII) {
     if (!isa<DbgDeclareInst>(DII))
       return false;
 
     if (isa<CastInst>(I))
if (User->getParent() != SrcBlock || updateDbgDeclare(User))
       continue;
 
     DIIClones.emplace_back(cast<DbgVariableIntrinsic>(User->clone()));
     LLVM_DEBUG(dbgs() << "CLONE: " << *DIIClones.back() << '\n');
   }
 
   // Perform salvaging without the clones, then sink the clones.
   if (!DIIClones.empty()) {
-    salvageDebugInfoForDbgValues(*I, DbgUsers);
+    I->salvageDebugInfoForDbgValues(DbgUsers);
     for (auto &DIIClone : DIIClones) {
       DIIClone->insertBefore(&*InsertPos);
       LLVM_DEBUG(dbgs() << "SINK: " << *DIIClone << '\n');
     }
   }
 
   return true;
 }
static bool prepareICWorklistFromFunction(Function &F, const DataLayout &DL,
   // some N^2 behavior in pathological cases.
   ICWorklist.reserve(InstrsForInstCombineWorklist.size());
   for (Instruction *Inst : reverse(InstrsForInstCombineWorklist)) {
     // DCE instruction if trivially dead. As we iterate in reverse program
     // order here, we will clean up whole chains of dead instructions.
     if (isInstructionTriviallyDead(Inst, TLI)) {
       ++NumDeadInst;
       LLVM_DEBUG(dbgs() << "IC: DCE: " << *Inst << '\n');
-      salvageDebugInfo(*Inst);
+      Inst->salvageDebugInfo();
       Inst->eraseFromParent();
       MadeIRChange = true;
       continue;
     }
 
     ICWorklist.push(Inst);
   }
 

llvm/lib/Transforms/Scalar/BDCE.cpp

if (I.mayHaveSideEffects() && I.use_empty())
       continue;
 
     // Remove instructions that are dead, either because they were not reached
     // during analysis or have no demanded bits.
     if (DB.isInstructionDead(&I) ||
         (I.getType()->isIntOrIntVectorTy() &&
          DB.getDemandedBits(&I).isNullValue() &&
          wouldInstructionBeTriviallyDead(&I))) {
-      salvageDebugInfo(I);
+      I.salvageDebugInfo();
       Worklist.push_back(&I);
       I.dropAllReferences();
       Changed = true;
       continue;
     }
 
     // Convert SExt into ZExt if none of the extension bits is required
     if (SExtInst *SE = dyn_cast<SExtInst>(&I)) {

llvm/lib/Transforms/Scalar/DCE.cpp

bool runOnFunction(Function &F) override {
 
     bool Changed = false;
     for (auto &BB : F) {
       for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) {
         Instruction *Inst = &*DI++;
         if (isInstructionTriviallyDead(Inst, TLI)) {
           if (!DebugCounter::shouldExecute(DCECounter))
             continue;
-          salvageDebugInfo(*Inst);
           Inst->eraseFromParent();
           Changed = true;
           ++DIEEliminated;
         }
       }
     }
     return Changed;
   }

 
 static bool DCEInstruction(Instruction *I,
                            SmallSetVector<Instruction *, 16> &WorkList,
                            const TargetLibraryInfo *TLI) {
   if (isInstructionTriviallyDead(I, TLI)) {
     if (!DebugCounter::shouldExecute(DCECounter))
       return false;
 
-    salvageDebugInfo(*I);
+    I->salvageDebugInfo();
     salvageKnowledge(I);
 
     // Null out all of the instruction's operands to see if any operand becomes
     // dead as we go.
     for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
       Value *OpV = I->getOperand(i);
       I->setOperand(i, nullptr);
 

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

do {
     Instruction *DeadInst = NowDeadInsts.pop_back_val();
     // Mark the DeadInst as dead in the list of throwable instructions.
     auto It = ThrowableInst.find(DeadInst);
     if (It != ThrowableInst.end())
       ThrowableInst[It->first] = false;
     ++NumFastOther;
 
     // Try to preserve debug information attached to the dead instruction.
-    salvageDebugInfo(*DeadInst);
+    DeadInst->salvageDebugInfo();
     salvageKnowledge(DeadInst);
 
     // This instruction is dead, zap it, in stages.  Start by removing it from
     // MemDep, which needs to know the operands and needs it to be in the
     // function.
     MD.removeInstruction(DeadInst);
 
     for (unsigned op = 0, e = DeadInst->getNumOperands(); op != e; ++op) {
void deleteDeadInstruction(Instruction *SI) {
     NowDeadInsts.push_back(SI);
     --NumFastOther;
 
     while (!NowDeadInsts.empty()) {
       Instruction *DeadInst = NowDeadInsts.pop_back_val();
       ++NumFastOther;
 
       // Try to preserve debug information attached to the dead instruction.
-      salvageDebugInfo(*DeadInst);
+      DeadInst->salvageDebugInfo();
       salvageKnowledge(DeadInst);
 
       // Remove the Instruction from MSSA.
       if (MemoryAccess *MA = MSSA.getMemoryAccess(DeadInst)) {
         if (MemoryDef *MD = dyn_cast<MemoryDef>(MA)) {
           SkipStores.insert(MD);
         }
         Updater.removeMemoryAccess(MA);

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/DebugCounter.h"
 #include "llvm/Support/RecyclingAllocator.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/GuardUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <cassert>
 #include <deque>
 #include <memory>
 #include <utility>
 
 using namespace llvm;
for (Instruction &Inst : make_early_inc_range(BB->getInstList())) {
     if (isInstructionTriviallyDead(&Inst, &TLI)) {
       LLVM_DEBUG(dbgs() << "EarlyCSE DCE: " << Inst << '\n');
       if (!DebugCounter::shouldExecute(CSECounter)) {
         LLVM_DEBUG(dbgs() << "Skipping due to debug counter\n");
         continue;
       }
 
       salvageKnowledge(&Inst, &AC);
-      salvageDebugInfo(Inst);
+      Inst.salvageDebugInfo();
       removeMSSA(Inst);
       Inst.eraseFromParent();
       Changed = true;
       ++NumSimplify;
       continue;
     }
 
     // Skip assume intrinsics, they don't really have side effects (although
bool runOnFunction(Function &F) override {
     auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
     auto *MSSA =
         UseMemorySSA ? &getAnalysis<MemorySSAWrapperPass>().getMSSA() : nullptr;
 
     EarlyCSE CSE(F.getParent()->getDataLayout(), TLI, TTI, DT, AC, MSSA);
 
-    return CSE.run();
+    auto Changed = CSE.run();
+    if (Changed) {
+      for (BasicBlock &BB : F)
+        RemoveRedundantDbgInstrs(&BB);
+    }
+    return Changed;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     if (UseMemorySSA) {

llvm/lib/Transforms/Scalar/GVN.cpp

for (BasicBlock::iterator BI = BB->begin(), BE = BB->end();
     bool AtStart = BI == BB->begin();
     if (!AtStart)
       --BI;
 
     for (auto *I : InstrsToErase) {
       assert(I->getParent() == BB && "Removing instruction from wrong block?");
       LLVM_DEBUG(dbgs() << "GVN removed: " << *I << '\n');
       salvageKnowledge(I, AC);
-      salvageDebugInfo(*I);
+      I->salvageDebugInfo();
       if (MD) MD->removeInstruction(I);
       LLVM_DEBUG(verifyRemoved(I));
       ICF->removeInstruction(I);
       I->eraseFromParent();
     }
     InstrsToErase.clear();
 
     if (AtStart)

llvm/lib/Transforms/Scalar/LICM.cpp

for (DomTreeNode *DTN : reverse(Worklist)) {
     for (BasicBlock::iterator II = BB->end(); II != BB->begin();) {
       Instruction &I = *--II;
 
       // If the instruction is dead, we would try to sink it because it isn't
       // used in the loop, instead, just delete it.
       if (isInstructionTriviallyDead(&I, TLI)) {
         LLVM_DEBUG(dbgs() << "LICM deleting dead inst: " << I << '\n');
         salvageKnowledge(&I);
-        salvageDebugInfo(I);
+        I.salvageDebugInfo();
         ++II;
         eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);
         Changed = true;
         continue;
       }
 
       // Check to see if we can sink this instruction to the exit blocks
       // of the loop.  We can do this if the all users of the instruction are
       // outside of the loop.  In this case, it doesn't even matter if the
       // operands of the instruction are loop invariant.
       //
       bool FreeInLoop = false;
       if (!I.mayHaveSideEffects() &&
           isNotUsedOrFreeInLoop(I, CurLoop, SafetyInfo, TTI, FreeInLoop) &&
           canSinkOrHoistInst(I, AA, DT, CurLoop, CurAST, MSSAU, true, &Flags,
                              ORE)) {
         if (sink(I, LI, DT, CurLoop, SafetyInfo, MSSAU, ORE)) {
           if (!FreeInLoop) {
             ++II;
-            salvageDebugInfo(I);
+            I.salvageDebugInfo();
             eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);
           }
           Changed = true;
         }
       }
     }
   }
   if (MSSAU && VerifyMemorySSA)

llvm/lib/Transforms/Scalar/Reassociate.cpp

 // Insts so they will be removed as well.
 void ReassociatePass::RecursivelyEraseDeadInsts(Instruction *I,
                                                 OrderedSet &Insts) {
   assert(isInstructionTriviallyDead(I) && "Trivially dead instructions only!");
   SmallVector<Value *, 4> Ops(I->op_begin(), I->op_end());
   ValueRankMap.erase(I);
   Insts.remove(I);
   RedoInsts.remove(I);
-  llvm::salvageDebugInfo(*I);
+  I->salvageDebugInfo();
   I->eraseFromParent();
   for (auto Op : Ops)
     if (Instruction *OpInst = dyn_cast<Instruction>(Op))
       if (OpInst->use_empty())
         Insts.insert(OpInst);
 }
 
 /// Zap the given instruction, adding interesting operands to the work list.
 void ReassociatePass::EraseInst(Instruction *I) {
   assert(isInstructionTriviallyDead(I) && "Trivially dead instructions only!");
   LLVM_DEBUG(dbgs() << "Erasing dead inst: "; I->dump());
 
   SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end());
   // Erase the dead instruction.
   ValueRankMap.erase(I);
   RedoInsts.remove(I);
-  llvm::salvageDebugInfo(*I);
+  I->salvageDebugInfo();
   I->eraseFromParent();
   // Optimize its operands.
   SmallPtrSet<Instruction *, 8> Visited; // Detect self-referential nodes.
   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
     if (Instruction *Op = dyn_cast<Instruction>(Ops[i])) {
       // If this is a node in an expression tree, climb to the expression root
       // and add that since that's where optimization actually happens.
       unsigned Opcode = Op->getOpcode();

llvm/lib/Transforms/Scalar/SROA.cpp

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
 #include <algorithm>
 #include <cassert>
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
if (Promotable) {
     // refinements exposed by splitting the current alloca. Don't iterate on an
     // alloca which didn't actually change and didn't get promoted.
     Worklist.insert(NewAI);
   }
 
   return NewAI;
 }
 
+void SROA::salvageInstruction(Instruction *Ins) {
+  SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
+  AllocaInst *AI = NULL;
+  int64_t ExprOffset = 0;
+  auto &Ctx = Ins->getContext();
+  auto wrapMD = [&](Value *V) {
+    return MetadataAsValue::get(Ctx, ValueAsMetadata::get(V));
+  };
+  auto findFragmentAlloca = [&](int64_t ExprOffset) {
+    AllocaInst *AInst = NULL;
+    for (auto Fragment : SROA::Fragments) {
+      if ((uint64_t)(ExprOffset * 8) == Fragment.Offset) {
+        return Fragment.Alloca;
+      }
+    }
+    return AInst;
+  };
+  if (isa<BitCastInst>(Ins)) {
+    for (Use &U2 : Ins->uses())
+      if (isa<GetElementPtrInst>(cast<Instruction>(U2.getUser()))) {
+        salvageInstruction(cast<Instruction>(U2.getUser()));
+      }
+  }
+  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ins)) {
+    unsigned BitWidth = GEP->getModule()->getDataLayout().getIndexSizeInBits(
+        GEP->getPointerAddressSpace());
+    APInt Offset(BitWidth, 0);
+    if (GEP->accumulateConstantOffset(GEP->getModule()->getDataLayout(),
+                                      Offset)) {
+      const uint64_t *Valptr = Offset.getRawData();
+      if ((AI = findFragmentAlloca(*Valptr))) {
+        Ins->replaceAllUsesWith(AI);
+        DeadInsts.insert(Ins);
+      }
+    }
+  }
+  Ins->findDbgUsers(DbgUsers);
+  for (auto *DII : DbgUsers) {
+    if (!isa<DbgValueInst>(DII))
+      continue;
+    if ((DII->getExpression()->explicitPointerCount() > 0 ||
+         DII->getExpression()->extractIfOffset(ExprOffset)) &&
+        (AI = findFragmentAlloca(ExprOffset))) {
+      DII->setOperand(0, wrapMD(AI));
+    }
+  }
+  for (Use &U : Ins->uses()) {
+    llvm::User *User = U.getUser();
+    SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
+    if (isa<GetElementPtrInst>(cast<Instruction>(User)) ||
+        isa<BitCastInst>(cast<Instruction>(User)))
+      salvageInstruction(cast<Instruction>(User));
+  }
+}
+
+void SROA::fixGEPWithSplitAllocas() {
+  for (auto Fragment : SROA::Fragments) {
+    uint64_t NewOffset = Fragment.Offset;
+    for (Use &U : Fragment.Alloca->uses()) {
+      Instruction *I = cast<Instruction>(U.getUser());
+      if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) {
+        unsigned BitWidth =
+            GEP->getModule()->getDataLayout().getIndexSizeInBits(
+                GEP->getPointerAddressSpace());
+        APInt Offset(BitWidth, 0);
+        if (GEP->accumulateConstantOffset(GEP->getModule()->getDataLayout(),
+                                          Offset)) {
+
+          if (*Offset.getRawData()) {
+            NewOffset += 8 * (*(Offset.getRawData()));
+            for (auto Fragment2 : SROA::Fragments) {
+              if (Fragment2.Offset == NewOffset) {
+                I->replaceAllUsesWith(Fragment2.Alloca);
+                DeadInsts.insert(I);
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 /// Walks the slices of an alloca and form partitions based on them,
 /// rewriting each of their uses.
 bool SROA::splitAlloca(AllocaInst &AI, AllocaSlices &AS) {
   if (AS.begin() == AS.end())
     return false;
 
   unsigned NumPartitions = 0;
   bool Changed = false;
for (Slice &S : AS) {
         IsSorted = false;
       }
     }
   }
 
   if (!IsSorted)
     llvm::sort(AS);
 
-  /// Describes the allocas introduced by rewritePartition in order to migrate
-  /// the debug info.
-  struct Fragment {
-    AllocaInst *Alloca;
-    uint64_t Offset;
-    uint64_t Size;
-    Fragment(AllocaInst *AI, uint64_t O, uint64_t S)
-      : Alloca(AI), Offset(O), Size(S) {}
-  };
-  SmallVector<Fragment, 4> Fragments;
-
+  SROA::Fragments.clear();
   // Rewrite each partition.
   for (auto &P : AS.partitions()) {
     if (AllocaInst *NewAI = rewritePartition(AI, AS, P)) {
       Changed = true;
       if (NewAI != &AI) {
         uint64_t SizeOfByte = 8;
         uint64_t AllocaSize =
             DL.getTypeSizeInBits(NewAI->getAllocatedType()).getFixedSize();
         // Don't include any padding.
         uint64_t Size = std::min(AllocaSize, P.size() * SizeOfByte);
-        Fragments.push_back(Fragment(NewAI, P.beginOffset() * SizeOfByte, Size));
+        SROA::Fragments.push_back(
+            Fragment(NewAI, P.beginOffset() * SizeOfByte, Size));
       }
     }
     ++NumPartitions;
   }
 
+  if (AI.getModule()->getDwarfVersion() >= 5) {
+    salvageInstruction(&AI);
+    fixGEPWithSplitAllocas();
+  }
+
   NumAllocaPartitions += NumPartitions;
   MaxPartitionsPerAlloca.updateMax(NumPartitions);
 
   // Migrate debug information from the old alloca to the new alloca(s)
   // and the individual partitions.
   TinyPtrVector<DbgVariableIntrinsic *> DbgDeclares = FindDbgAddrUses(&AI);
   if (!DbgDeclares.empty()) {
     auto *Var = DbgDeclares.front()->getVariable();
     auto *Expr = DbgDeclares.front()->getExpression();
     auto VarSize = Var->getSizeInBits();
     DIBuilder DIB(*AI.getModule(), /*AllowUnresolved*/ false);
     uint64_t AllocaSize =
         DL.getTypeSizeInBits(AI.getAllocatedType()).getFixedSize();
-    for (auto Fragment : Fragments) {
+    for (auto Fragment : SROA::Fragments) {
       // Create a fragment expression describing the new partition or reuse AI's
       // expression if there is only one partition.
       auto *FragmentExpr = Expr;
       if (Fragment.Size < AllocaSize || Expr->isFragment()) {
         // If this alloca is already a scalar replacement of a larger aggregate,
         // Fragment.Offset describes the offset inside the scalar.
         auto ExprFragment = Expr->getFragmentInfo();
         uint64_t Offset = ExprFragment ? ExprFragment->OffsetInBits : 0;
bool SROA::runOnAlloca(AllocaInst &AI) {
   // Build the slices using a recursive instruction-visiting builder.
   AllocaSlices AS(DL, AI);
   LLVM_DEBUG(AS.print(dbgs()));
   if (AS.isEscaped())
     return Changed;
 
   // Delete all the dead users of this alloca before splitting and rewriting it.
   for (Instruction *DeadUser : AS.getDeadUsers()) {
+
+    // Try to preserve debug information attached to the instruction.
+    if (AI.getModule()->getDwarfVersion() >= 5)
+      DeadUser->salvageDebugInfo();
+
     // Free up everything used by this instruction.
     for (Use &DeadOp : DeadUser->operands())
       clobberUse(DeadOp);
 
     // Now replace the uses of this instruction.
+    if (AI.getModule()->getDwarfVersion() < 5)
       DeadUser->replaceAllUsesWith(UndefValue::get(DeadUser->getType()));
 
     // And mark it for deletion.
     DeadInsts.insert(DeadUser);
     Changed = true;
   }
   for (Use *DeadOp : AS.getDeadOperands()) {
     clobberUse(*DeadOp);
     Changed = true;

 bool SROA::promoteAllocas(Function &F) {
   if (PromotableAllocas.empty())
     return false;
 
   NumPromoted += PromotableAllocas.size();
 
   LLVM_DEBUG(dbgs() << "Promoting allocas with mem2reg...\n");
   PromoteMemToReg(PromotableAllocas, *DT, AC);
+  for (BasicBlock &BB : F)
+    RemoveRedundantDbgInstrs(&BB);
   PromotableAllocas.clear();
   return true;
 }
 
 PreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT,
                                 AssumptionCache &RunAC) {
   LLVM_DEBUG(dbgs() << "SROA function: " << F.getName() << "\n");
   C = &F.getContext();

llvm/lib/Transforms/Utils/CodeExtractor.cpp

TI->setMetadata(
       MDBuilder(TI->getContext()).createBranchWeights(BranchWeights));
 }
 
 /// Erase debug info intrinsics which refer to values in \p F but aren't in
 /// \p F.
 static void eraseDebugIntrinsicsWithNonLocalRefs(Function &F) {
   for (Instruction &I : instructions(F)) {
     SmallVector<DbgVariableIntrinsic *, 4> DbgUsers;
-    findDbgUsers(DbgUsers, &I);
+    I.findDbgUsers(DbgUsers);
     for (DbgVariableIntrinsic *DVI : DbgUsers)
       if (DVI->getFunction() != &F)
         DVI->eraseFromParent();
   }
 }
 
 /// Fix up the debug info in the old and new functions by pointing line
 /// locations and debug intrinsics to the new subprogram scope, and by deleting

llvm/lib/Transforms/Utils/Local.cpp

while (!DeadInsts.empty()) {
     Instruction *I = cast_or_null<Instruction>(V);
     if (!I)
       continue;
     assert(isInstructionTriviallyDead(I, TLI) &&
            "Live instruction found in dead worklist!");
     assert(I->use_empty() && "Instructions with uses are not dead.");
 
     // Don't lose the debug info while deleting the instructions.
-    salvageDebugInfo(*I);
+    I->salvageDebugInfo();
 
     if (AboutToDeleteCallback)
       AboutToDeleteCallback(I);
 
     // Null out all of the instruction's operands to see if any operand becomes
     // dead as we go.
     for (Use &OpU : I->operands()) {
       Value *OpV = OpU.get();
if (MSSAU)
       MSSAU->removeMemoryAccess(I);
 
     I->eraseFromParent();
   }
 }
 
 bool llvm::replaceDbgUsesWithUndef(Instruction *I) {
   SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
-  findDbgUsers(DbgUsers, I);
+  I->findDbgUsers(DbgUsers);
   for (auto *DII : DbgUsers) {
     Value *Undef = UndefValue::get(I->getType());
     DII->setOperand(0, MetadataAsValue::get(DII->getContext(),
                                             ValueAsMetadata::get(Undef)));
   }
   return !DbgUsers.empty();
 }
 

 }
 
 static bool
 simplifyAndDCEInstruction(Instruction *I,
                           SmallSetVector<Instruction *, 16> &WorkList,
                           const DataLayout &DL,
                           const TargetLibraryInfo *TLI) {
   if (isInstructionTriviallyDead(I, TLI)) {
-    salvageDebugInfo(*I);
+    I->salvageDebugInfo();
 
     // Null out all of the instruction's operands to see if any operand becomes
     // dead as we go.
     for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
       Value *OpV = I->getOperand(i);
       I->setOperand(i, nullptr);
 
       if (!OpV->use_empty() || I == OpV)
if (!V->isUsedByMetadata())
     return;
   if (auto *L = LocalAsMetadata::getIfExists(V))
     if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
       for (User *U : MDV->users())
         if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
           DbgValues.push_back(DVI);
 }
 
-void llvm::findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgUsers,
-                        Value *V) {
-  // This function is hot. Check whether the value has any metadata to avoid a
-  // DenseMap lookup.
-  if (!V->isUsedByMetadata())
-    return;
-  if (auto *L = LocalAsMetadata::getIfExists(V))
-    if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
-      for (User *U : MDV->users())
-        if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
-          DbgUsers.push_back(DII);
-}
-
 bool llvm::replaceDbgDeclare(Value *Address, Value *NewAddress,
                              DIBuilder &Builder, uint8_t DIExprFlags,
                              int Offset) {
   auto DbgAddrs = FindDbgAddrUses(Address);
   for (DbgVariableIntrinsic *DII : DbgAddrs) {
     DebugLoc Loc = DII->getDebugLoc();
     auto *DIVar = DII->getVariable();
     auto *DIExpr = DII->getExpression();
if (auto *MDV = MetadataAsValue::getIfExists(AI->getContext(), L))
       }
 }
 
 /// Wrap \p V in a ValueAsMetadata instance.
 static MetadataAsValue *wrapValueInMetadata(LLVMContext &C, Value *V) {
   return MetadataAsValue::get(C, ValueAsMetadata::get(V));
 }
 
-/// Where possible to salvage debug information for \p I do so
-/// and return True. If not possible mark undef and return False.
-void llvm::salvageDebugInfo(Instruction &I) {
-  SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
-  findDbgUsers(DbgUsers, &I);
-  salvageDebugInfoForDbgValues(I, DbgUsers);
-}
-
-void llvm::salvageDebugInfoForDbgValues(
-    Instruction &I, ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
-  auto &Ctx = I.getContext();
-  bool Salvaged = false;
-  auto wrapMD = [&](Value *V) { return wrapValueInMetadata(Ctx, V); };
-
-  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)
-      break;
-
-    DII->setOperand(0, wrapMD(I.getOperand(0)));
-    DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
-    LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n');
-    Salvaged = true;
-  }
-
-  if (Salvaged)
-    return;
-
-  for (auto *DII : DbgUsers) {
-    Value *Undef = UndefValue::get(I.getType());
-    DII->setOperand(0, MetadataAsValue::get(DII->getContext(),
-                                            ValueAsMetadata::get(Undef)));
-  }
-}
-
-DIExpression *llvm::salvageDebugInfoImpl(Instruction &I,
-                                         DIExpression *SrcDIExpr,
-                                         bool WithStackValue) {
-  auto &M = *I.getModule();
-  auto &DL = M.getDataLayout();
-
-  // Apply a vector of opcodes to the source DIExpression.
-  auto doSalvage = [&](SmallVectorImpl<uint64_t> &Ops) -> DIExpression * {
-    DIExpression *DIExpr = SrcDIExpr;
-    if (!Ops.empty()) {
-      DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
-    }
-    return DIExpr;
-  };
-
-  // Apply the given offset to the source DIExpression.
-  auto applyOffset = [&](uint64_t Offset) -> DIExpression * {
-    SmallVector<uint64_t, 8> Ops;
-    DIExpression::appendOffset(Ops, Offset);
-    return doSalvage(Ops);
-  };
-
-  // initializer-list helper for applying operators to the source DIExpression.
-  auto applyOps = [&](ArrayRef<uint64_t> Opcodes) -> DIExpression * {
-    SmallVector<uint64_t, 8> Ops(Opcodes.begin(), Opcodes.end());
-    return doSalvage(Ops);
-  };
-
-  if (auto *CI = dyn_cast<CastInst>(&I)) {
-    // No-op casts are irrelevant for debug info.
-    if (CI->isNoopCast(DL))
-      return SrcDIExpr;
-
-    Type *Type = CI->getType();
-    // Casts other than Trunc, SExt, or ZExt to scalar types cannot be salvaged.
-    if (Type->isVectorTy() ||
-        !(isa<TruncInst>(&I) || isa<SExtInst>(&I) || isa<ZExtInst>(&I)))
-      return nullptr;
-
-    Value *FromValue = CI->getOperand(0);
-    unsigned FromTypeBitSize = FromValue->getType()->getScalarSizeInBits();
-    unsigned ToTypeBitSize = Type->getScalarSizeInBits();
-
-    return applyOps(DIExpression::getExtOps(FromTypeBitSize, ToTypeBitSize,
-                                            isa<SExtInst>(&I)));
-  }
-
-  if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
-    unsigned BitWidth =
-        M.getDataLayout().getIndexSizeInBits(GEP->getPointerAddressSpace());
-    // Rewrite a constant GEP into a DIExpression.
-    APInt Offset(BitWidth, 0);
-    if (GEP->accumulateConstantOffset(M.getDataLayout(), Offset)) {
-      return applyOffset(Offset.getSExtValue());
-    } else {
-      return nullptr;
-    }
-  } else if (auto *BI = dyn_cast<BinaryOperator>(&I)) {
-    // Rewrite binary operations with constant integer operands.
-    auto *ConstInt = dyn_cast<ConstantInt>(I.getOperand(1));
-    if (!ConstInt || ConstInt->getBitWidth() > 64)
-      return nullptr;
-
-    uint64_t Val = ConstInt->getSExtValue();
-    switch (BI->getOpcode()) {
-    case Instruction::Add:
-      return applyOffset(Val);
-    case Instruction::Sub:
-      return applyOffset(-int64_t(Val));
-    case Instruction::Mul:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_mul});
-    case Instruction::SDiv:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_div});
-    case Instruction::SRem:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_mod});
-    case Instruction::Or:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_or});
-    case Instruction::And:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_and});
-    case Instruction::Xor:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_xor});
-    case Instruction::Shl:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shl});
-    case Instruction::LShr:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shr});
-    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.
-  }
-  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,
 /// possibly moving/undefing users to prevent use-before-def. Returns true if
 /// changes are made.
 static bool rewriteDebugUsers(
     Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT,
     function_ref<DbgValReplacement(DbgVariableIntrinsic &DII)> RewriteExpr) {
   // Find debug users of From.
   SmallVector<DbgVariableIntrinsic *, 1> Users;
-  findDbgUsers(Users, &From);
+  From.findDbgUsers(Users);
   if (Users.empty())
     return false;
 
   // Prevent use-before-def of To.
   bool Changed = false;
   SmallPtrSet<DbgVariableIntrinsic *, 1> UndefOrSalvage;
   if (isa<Instruction>(&To)) {
     bool DomPointAfterFrom = From.getNextNonDebugInstruction() == &DomPoint;
for (auto *DII : Users) {
     DII->setOperand(0, wrapValueInMetadata(Ctx, &To));
     DII->setOperand(2, MetadataAsValue::get(Ctx, *DVR));
     LLVM_DEBUG(dbgs() << "REWRITE:  " << *DII << '\n');
     Changed = true;
   }
 
   if (!UndefOrSalvage.empty()) {
     // Try to salvage the remaining debug users.
-    salvageDebugInfo(From);
+    From.salvageDebugInfo();
     Changed = true;
   }
 
   return Changed;
 }
 
 /// Check if a bitcast between a value of type \p FromTy to type \p ToTy would
 /// losslessly preserve the bits and semantics of the value. This predicate is
void llvm::copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI,
   if (!getConstantRangeFromMetadata(*N).contains(APInt(BitWidth, 0))) {
     MDNode *NN = MDNode::get(OldLI.getContext(), None);
     NewLI.setMetadata(LLVMContext::MD_nonnull, NN);
   }
 }
 
 void llvm::dropDebugUsers(Instruction &I) {
   SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
-  findDbgUsers(DbgUsers, &I);
+  I.findDbgUsers(DbgUsers);
   for (auto *DII : DbgUsers)
     DII->eraseFromParent();
 }
 
 void llvm::hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt,
                                     BasicBlock *BB) {
   // Since we are moving the instructions out of its basic block, we do not
   // retain their original debug locations (DILocations) and debug intrinsic

llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp

class LargeBlockInfo {
   /// the block.
   DenseMap<const Instruction *, unsigned> InstNumbers;
 
 public:
 
   /// This code only looks at accesses to allocas.
   static bool isInterestingInstruction(const Instruction *I) {
     return (isa<LoadInst>(I) && isa<AllocaInst>(I->getOperand(0))) ||
+           (isa<DbgValueInst>(I)) ||
            (isa<StoreInst>(I) && isa<AllocaInst>(I->getOperand(1)));
   }
 
   /// Get or calculate the index of the specified instruction.
   unsigned getInstructionIndex(const Instruction *I) {
     assert(isInterestingInstruction(I) &&
-           "Not a load/store to/from an alloca?");
+           "Not a dbg.value or load/store to/from an alloca?");
 
     // If we already have this instruction number, return it.
     DenseMap<const Instruction *, unsigned>::iterator It = InstNumbers.find(I);
     if (It != InstNumbers.end())
       return It->second;
 
     // Scan the whole block to get the instruction.  This accumulates
     // information for every interesting instruction in the block, in order to
static bool rewriteSingleStoreAlloca(AllocaInst *AI, AllocaInfo &Info,
 
   // Record debuginfo for the store and remove the declaration's
   // debuginfo.
   for (DbgVariableIntrinsic *DII : Info.DbgDeclares) {
     DIBuilder DIB(*AI->getModule(), /*AllowUnresolved*/ false);
     ConvertDebugDeclareToDebugValue(DII, Info.OnlyStore, DIB);
     DII->eraseFromParent();
   }
+
+  if (AI->getModule()->getDwarfVersion() >= 5) {
+    SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
+    AI->findDbgUsers(DbgUsers);
+    for (auto *DII : DbgUsers) {
+      if (!isa<DbgValueInst>(DII))
+        continue;
+      DIBuilder DIB(*AI->getModule(), /*AllowUnresolved*/ false);
+      auto *DIVar = DII->getVariable();
+      auto *DIExpr = DII->getExpression();
+      SmallVector<uint64_t, 8> Ops;
+      DIExpression::expr_op_iterator Itr = DIExpr->expr_op_begin();
+      DIExpression::expr_op_iterator EndItr = DIExpr->expr_op_end();
+      if (Itr != EndItr && Itr->getOp() == dwarf::DW_OP_deref)
+        Itr++;
+      else
+        Ops.push_back(dwarf::DW_OP_LLVM_explicit_pointer);
+      for (; Itr != EndItr; Itr++) {
+        Itr->appendToVector(Ops);
+      }
+      DIExpr = DIExpression::get(DIExpr->getContext(), Ops);
+      Value *DV = Info.OnlyStore->getValueOperand();
+      DebugLoc DeclareLoc = DII->getDebugLoc();
+      MDNode *Scope = DeclareLoc.getScope();
+      DILocation *InlinedAt = DeclareLoc.getInlinedAt();
+      DebugLoc NewLoc = DebugLoc::get(0, 0, Scope, InlinedAt);
+
+      DIB.insertDbgValueIntrinsic(DV, DIVar, DIExpr, NewLoc, DII);
+      DII->eraseFromParent();
+      LBI.deleteValue(DII);
+    }
+  }
+
   // Remove the (now dead) store and alloca.
   Info.OnlyStore->eraseFromParent();
   LBI.deleteValue(Info.OnlyStore);
 
   AI->eraseFromParent();
   return true;
 }
 
if (I == StoresByIndex.begin()) {
 
       LI->replaceAllUsesWith(ReplVal);
     }
 
     LI->eraseFromParent();
     LBI.deleteValue(LI);
   }
 
+  if (AI->getModule()->getDwarfVersion() >= 5) {
+    StoresByIndex.clear();
+    LBI.clear();
+
+    for (User *U : AI->users())
+      if (StoreInst *SI = dyn_cast<StoreInst>(U))
+        StoresByIndex.push_back(
+            std::make_pair(LBI.getInstructionIndex(SI), SI));
+
+    llvm::sort(StoresByIndex, less_first());
+
+    using DbgValueByIndexTy =
+        SmallVector<std::pair<unsigned, DbgValueInst *>, 64>;
+    DbgValueByIndexTy DbgValueByIndex;
+
+    for (Instruction &I : *(AI->getParent()))
+      if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(&I))
+        DbgValueByIndex.push_back(
+            std::make_pair(LBI.getInstructionIndex(DVI), DVI));
+
+    llvm::sort(DbgValueByIndex, less_first());
+
+    for (auto User : DbgValueByIndex) {
+      DbgValueInst *DI = User.second;
+
+      if (AI != DI->getValue())
+        continue;
+
+      unsigned Idx = LBI.getInstructionIndex(DI);
+      // Find the nearest store that has a lower index than DI.
+      StoresByIndexTy::iterator I = llvm::lower_bound(
+          StoresByIndex, std::make_pair(Idx, static_cast<StoreInst *>(nullptr)),
+          less_first());
+      if (I == StoresByIndex.begin()) {
+#if 0 // do nothing
+  if (StoresByIndex.empty())
+    // If there are no stores, the load takes the undef value.
+    DI->replaceAllUsesWith(UndefValue::get(LI->getType()));
+  else
+    // There is no store before this load, bail out (load may be affected
+    // by the following stores - see main comment).
+    return false;
+#endif
+      } else {
+        // Otherwise, there was a store before this load, the load takes its
+        // value. Note, if the load was marked as nonnull we don't want to lose
+        // that information when we erase it. So we preserve it with an assume.
+        Value *ReplVal = std::prev(I)->second->getOperand(0);
+#if 0
+  if (AC && LI->getMetadata(LLVMContext::MD_nonnull) &&
+      !isKnownNonZero(ReplVal, DL, 0, AC, LI, &DT))
+    addAssumeNonNull(AC, LI);
+
+  // If the replacement value is the load, this must occur in unreachable
+  // code.
+  if (ReplVal == LI)
+    ReplVal = UndefValue::get(LI->getType());
+#endif
+        DIBuilder DIB(*AI->getModule(), /*AllowUnresolved*/ false);
+        auto *DIVar = DI->getVariable();
+        auto *DIExpr = DI->getExpression();
+        SmallVector<uint64_t, 8> Ops;
+        DIExpression::expr_op_iterator Itr = DIExpr->expr_op_begin();
+        DIExpression::expr_op_iterator EndItr = DIExpr->expr_op_end();
+        if (Itr != EndItr && Itr->getOp() == dwarf::DW_OP_deref)
+          Itr++;
+        else
+          Ops.push_back(dwarf::DW_OP_LLVM_explicit_pointer);
+        for (; Itr != EndItr; Itr++) {
+          Itr->appendToVector(Ops);
+        }
+        DIExpr = DIExpression::get(DIExpr->getContext(), Ops);
+        DebugLoc DeclareLoc = DI->getDebugLoc();
+        MDNode *Scope = DeclareLoc.getScope();
+        DILocation *InlinedAt = DeclareLoc.getInlinedAt();
+        DebugLoc NewLoc = DebugLoc::get(0, 0, Scope, InlinedAt);
+        DIB.insertDbgValueIntrinsic(ReplVal, DIVar, DIExpr, NewLoc, DI);
+
+        DbgValueByIndexTy::iterator Iter = llvm::lower_bound(
+            DbgValueByIndex,
+            std::make_pair(Idx, static_cast<DbgValueInst *>(nullptr)),
+            less_first());
+
+        StoresByIndexTy::iterator EI = StoresByIndex.end();
+        while (++Iter != DbgValueByIndex.end()) {
+          if (DI->getOperand(1) == Iter->second->getOperand(1)) {
+            EI = llvm::lower_bound(
+                StoresByIndex,
+                std::make_pair(Iter->first, static_cast<StoreInst *>(nullptr)),
+                less_first());
+            break;
+          }
+        }
+
+        DI->eraseFromParent();
+        LBI.deleteValue(DI);
+
+        while (I != EI) {
+          ReplVal = I->second->getOperand(0);
+          DIB.insertDbgValueIntrinsic(ReplVal, DIVar, DIExpr,
+                                      I->second->getDebugLoc(), I->second);
+          I++;
+        }
+      }
+    }
+  }
+
   // Remove the (now dead) stores and alloca.
   while (!AI->use_empty()) {
     StoreInst *SI = cast<StoreInst>(AI->user_back());
     // Record debuginfo for the store before removing it.
     for (DbgVariableIntrinsic *DII : Info.DbgDeclares) {
       DIBuilder DIB(*AI->getModule(), /*AllowUnresolved*/ false);
       ConvertDebugDeclareToDebugValue(DII, SI, DIB);
     }

llvm/test/DebugInfo/X86/LLVM_explicit_pointer.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; CHECK: !DIExpression(DW_OP_LLVM_explicit_pointer)
+
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;int main() {
+;  int var1 = 4;
+;  int *ptr1;
+;
+;  v++;
+;  ptr1 = &var1;
+;  v++;
+;
+;  return *ptr1 - 5;
+;}
+;---------------------------
+
+; ModuleID = 'LLVM_explicit_pointer.c'
+source_filename = "LLVM_explicit_pointer.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+; Function Attrs: nofree norecurse nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata i32 4, metadata !16, metadata !DIExpression()), !dbg !19
+  %0 = load volatile i32, i32* @v, align 4, !dbg !20, !tbaa !21
+  %inc = add nsw i32 %0, 1, !dbg !20
+  store volatile i32 %inc, i32* @v, align 4, !dbg !20, !tbaa !21
+
+  call void @llvm.dbg.value(metadata i32 4, metadata !17, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !19
+
+  %1 = load volatile i32, i32* @v, align 4, !dbg !25, !tbaa !21
+  %inc1 = add nsw i32 %1, 1, !dbg !25
+  store volatile i32 %inc1, i32* @v, align 4, !dbg !25, !tbaa !21
+  ret i32 -1, !dbg !26
+}
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 2, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "LLVM_explicit_pointer.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "218aaa8dc9f04b056b56d944d06383dd")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 7, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 3, type: !13, scopeLine: 3, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16, !17}
+!16 = !DILocalVariable(name: "var1", scope: !12, file: !3, line: 4, type: !7)
+!17 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 5, type: !18)
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!19 = !DILocation(line: 0, scope: !12)
+!20 = !DILocation(line: 7, column: 4, scope: !12)
+!21 = !{!22, !22, i64 0}
+!22 = !{!"int", !23, i64 0}
+!23 = !{!"omnipotent char", !24, i64 0}
+!24 = !{!"Simple C/C++ TBAA"}
+!25 = !DILocation(line: 9, column: 4, scope: !12)
+!26 = !DILocation(line: 11, column: 3, scope: !12)

llvm/test/DebugInfo/X86/LLVM_implicit_pointer.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; CHECK: !DIExpression(DW_OP_LLVM_implicit_pointer, 0)
+
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;int main() {
+;  int var1 = 4;
+;  int *ptr1;
+;
+;  v++;
+;  ptr1 = &var1;
+;  v++;
+;
+;  return *ptr1 - 5;
+;}
+;---------------------------
+
+; ModuleID = 'LLVM_implicit_pointer.c'
+source_filename = "LLVM_implicit_pointer.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+; Function Attrs: nofree norecurse nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata i32 4, metadata !16, metadata !DIExpression()), !dbg !19
+  %0 = load volatile i32, i32* @v, align 4, !dbg !20, !tbaa !21
+  %inc = add nsw i32 %0, 1, !dbg !20
+  store volatile i32 %inc, i32* @v, align 4, !dbg !20, !tbaa !21
+
+  call void @llvm.dbg.value(metadata i32 4, metadata !17, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, 0)), !dbg !19
+
+  %1 = load volatile i32, i32* @v, align 4, !dbg !25, !tbaa !21
+  %inc1 = add nsw i32 %1, 1, !dbg !25
+  store volatile i32 %inc1, i32* @v, align 4, !dbg !25, !tbaa !21
+  ret i32 -1, !dbg !26
+}
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 2, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "LLVM_implicit_pointer.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "218aaa8dc9f04b056b56d944d06383dd")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 7, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 3, type: !13, scopeLine: 3, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16, !17}
+!16 = !DILocalVariable(name: "var1", scope: !12, file: !3, line: 4, type: !7)
+!17 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 5, type: !18)
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!19 = !DILocation(line: 0, scope: !12)
+!20 = !DILocation(line: 7, column: 4, scope: !12)
+!21 = !{!22, !22, i64 0}
+!22 = !{!"int", !23, i64 0}
+!23 = !{!"omnipotent char", !24, i64 0}
+!24 = !{!"Simple C/C++ TBAA"}
+!25 = !DILocation(line: 9, column: 4, scope: !12)
+!26 = !DILocation(line: 11, column: 3, scope: !12)

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_instcomb.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK-LABEL:  DW_AT_name    ("__implicit_ptr_tmp_0")
+// CHECK-LABEL:  DW_TAG_variable
+// CHECK-NEXT:  DW_AT_location
+// CHECK-NEXT:  DW_OP_implicit_pointer {{0x.+}} +0
+
+// CHECK-LABEL:  DW_TAG_formal_parameter
+// CHECK-NEXT:  DW_AT_location
+// CHECK-NEXT:  DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  "ptr"
+
+volatile int gvar = 7;
+
+int func(int *ptr) {
+  gvar = *ptr;
+  return *ptr + 5;
+}
+
+int main() {
+  int var = 4;
+  int *ptrVar = &var;
+
+  int res = func(ptrVar);
+
+  return res;
+}

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_instcomb.ll

+; RUN: llc %s -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:  DW_AT_name    ("__implicit_ptr_tmp_0")
+; CHECK-LABEL:  DW_TAG_variable
+; CHECK-NEXT:  DW_AT_location
+; CHECK-NEXT:  DW_OP_implicit_pointer {{0x.+}} +0
+
+; CHECK-LABEL:  DW_TAG_formal_parameter
+; CHECK-NEXT:  DW_AT_location
+; CHECK-NEXT:  DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  "ptr"
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;volatile int gvar = 7;
+;
+;int func(int *ptr) {
+;  gvar = *ptr;
+;  return *ptr + 5;
+;}
+;
+;int main() {
+;  int var = 4;
+;  int *ptrVar = &var;
+;
+;  int res = func(ptrVar);
+;
+;  return res;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_instcomb.c'
+source_filename = "dwarfdump-implicit_pointer_instcomb.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@gvar = dso_local global i32 7, align 4, !dbg !0
+
+; Function Attrs: nofree norecurse nounwind uwtable
+define dso_local i32 @func(i32* nocapture readonly %ptr) local_unnamed_addr #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata i32* %ptr, metadata !17, metadata !DIExpression()), !dbg !18
+  %0 = load i32, i32* %ptr, align 4, !dbg !19
+  store volatile i32 %0, i32* @gvar, align 4, !dbg !24
+  %1 = load i32, i32* %ptr, align 4, !dbg !25
+  %add = add nsw i32 %1, 5, !dbg !26
+  ret i32 %add, !dbg !27
+}
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #1 !dbg !28 {
+entry:
+  call void @llvm.dbg.value(metadata i32 4, metadata !33, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !35
+  call void @llvm.dbg.value(metadata i32 4, metadata !32, metadata !DIExpression()), !dbg !35
+  call void @llvm.dbg.value(metadata i32 4, metadata !17, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !36
+  store volatile i32 4, i32* @gvar, align 4, !dbg !38
+  call void @llvm.dbg.value(metadata i32 9, metadata !34, metadata !DIExpression()), !dbg !35
+  ret i32 9, !dbg !39
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "gvar", scope: !2, file: !3, line: 14, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_instcomb.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "1c991e568deb5a6321b60bc8bf8be8d6")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 11.0.0"}
+!12 = distinct !DISubprogram(name: "func", scope: !3, file: !3, line: 16, type: !13, scopeLine: 16, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7, !15}
+!15 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!16 = !{!17}
+!17 = !DILocalVariable(name: "ptr", arg: 1, scope: !12, file: !3, line: 16, type: !15)
+!18 = !DILocation(line: 0, scope: !12)
+!19 = !DILocation(line: 17, column: 10, scope: !12)
+!20 = !{!21, !21, i64 0}
+!21 = !{!"int", !22, i64 0}
+!22 = !{!"omnipotent char", !23, i64 0}
+!23 = !{!"Simple C/C++ TBAA"}
+!24 = !DILocation(line: 17, column: 8, scope: !12)
+!25 = !DILocation(line: 18, column: 10, scope: !12)
+!26 = !DILocation(line: 18, column: 15, scope: !12)
+!27 = !DILocation(line: 18, column: 3, scope: !12)
+!28 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 21, type: !29, scopeLine: 21, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !31)
+!29 = !DISubroutineType(types: !30)
+!30 = !{!7}
+!31 = !{!32, !33, !34}
+!32 = !DILocalVariable(name: "var", scope: !28, file: !3, line: 22, type: !7)
+!33 = !DILocalVariable(name: "ptrVar", scope: !28, file: !3, line: 23, type: !15)
+!34 = !DILocalVariable(name: "res", scope: !28, file: !3, line: 25, type: !7)
+!35 = !DILocation(line: 0, scope: !28)
+!36 = !DILocation(line: 0, scope: !12, inlinedAt: !37)
+!37 = distinct !DILocation(line: 25, column: 13, scope: !28)
+!38 = !DILocation(line: 17, column: 8, scope: !12, inlinedAt: !37)
+!39 = !DILocation(line: 27, column: 3, scope: !28)

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_mem2reg.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK-LABEL:  DW_AT_name    ("arr1")
+
+// 1. Test if more than one member location list is printed
+//    (for pointer to scalar)
+// CHECK-LABEL:       DW_AT_location
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptr2")
+
+// 2. Test if More than one member location list is printed
+//    (for pointer to pointer to scalar)
+// CHECK-LABEL:       DW_AT_location
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptrptr2")
+
+// 3. Test if one member location list is printed
+//    (for pointer to pointer to array)
+// CHECK-LABEL:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptrptr3")
+//
+// CHECK-LABEL: DW_AT_name    ("__implicit_ptr_tmp_5")
+// 4. Test if one member location list is printed
+//    (for pointer to pointer to scalar)
+// CHECK-LABEL:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptrptr1")
+
+// CHECK-LABEL: DW_AT_name    ("__implicit_ptr_tmp_3")
+// 5. Test if one member location list is printed
+//    (for pointer to array)
+// CHECK-LABEL:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptr3")
+
+// CHECK-LABEL: DW_AT_name    ("__implicit_ptr_tmp_1")
+// 6. Test if one member location list is printed
+//    (for pointer to scalar)
+// CHECK-LABEL:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptr1")
+
+static const char *b = "opq";
+volatile int v;
+int main() {
+  int var1 = 4;
+  int var2 = 5;
+  int arr1[2] = {2, 3};
+  int *ptr1;
+  int *ptr2 = 0;
+  int *ptr3;
+  int **ptrptr1;
+  int **ptrptr2 = 0;
+  int **ptrptr3;
+
+  v++;
+  ptr1 = &var1;
+  ptr2 = &var2;
+  ptr3 = arr1;
+  ptrptr1 = &ptr1;
+  ptrptr2 = &ptr2;
+  ptrptr3 = &ptr3;
+  v++;
+
+  return arr1[0] + arr1[1] + *ptr1 + *ptr2 + **ptrptr1 + **ptrptr2 - 5;
+}

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_mem2reg.ll

+; RUN: llc %s -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:  DW_AT_name    ("arr1")
+
+; 1. Test if more than one member location list is printed 
+;    (for pointer to scalar)
+; CHECK-LABEL:       DW_AT_location
+; CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptr2")
+
+; 2. Test if More than one member location list is printed 
+;    (for pointer to pointer to scalar)
+; CHECK-LABEL:       DW_AT_location
+; CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptrptr2")
+
+; 3. Test if one member location list is printed
+;    (for pointer to pointer to array)
+; CHECK-LABEL:       DW_AT_location        (
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptrptr3")
+;
+; CHECK-LABEL: DW_AT_name    ("__implicit_ptr_tmp_5")
+; 4. Test if one member location list is printed
+;    (for pointer to pointer to scalar)
+; CHECK-LABEL:       DW_AT_location        (
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptrptr1")
+
+; CHECK-LABEL: DW_AT_name    ("__implicit_ptr_tmp_3")
+; 5. Test if one member location list is printed
+;    (for pointer to array)
+; CHECK-LABEL:       DW_AT_location        (
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptr3")
+
+; CHECK-LABEL: DW_AT_name    ("__implicit_ptr_tmp_1")
+; 6. Test if one member location list is printed
+;    (for pointer to scalar)
+; CHECK-LABEL:       DW_AT_location        (
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptr1")
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;int main() {
+;  int var1 = 4;
+;  int var2 = 5;
+;  int arr1[2] = {2, 3};
+;  int *ptr1;
+;  int *ptr2 = 0;
+;  int *ptr3;
+;  int **ptrptr1;
+;  int **ptrptr2 = 0;
+;  int **ptrptr3;
+;
+;  v++;
+;  ptr1 = &var1;
+;  ptr2 = &var2;
+;  ptr3 = arr1;
+;  ptrptr1 = &ptr1;
+;  ptrptr2 = &ptr2;
+;  ptrptr3 = &ptr3;
+;  v++;
+;
+;  return arr1[0] + arr1[1] + *ptr1 + *ptr2 + **ptrptr1 + **ptrptr2 - 5;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_mem2reg.c'
+source_filename = "dwarfdump-implicit_pointer_mem2reg.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: nofree norecurse nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata i32 4, metadata !16, metadata !DIExpression()), !dbg !30
+  call void @llvm.dbg.value(metadata i32 5, metadata !17, metadata !DIExpression()), !dbg !30
+  call void @llvm.dbg.value(metadata i32 2, metadata !18, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 3, metadata !18, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32)), !dbg !30
+  call void @llvm.dbg.value(metadata i32* null, metadata !24, metadata !DIExpression()), !dbg !30
+  call void @llvm.dbg.value(metadata i32** null, metadata !28, metadata !DIExpression()), !dbg !30
+  %0 = load volatile i32, i32* @v, align 4, !dbg !31, !tbaa !32
+  %inc = add nsw i32 %0, 1, !dbg !31
+  store volatile i32 %inc, i32* @v, align 4, !dbg !31, !tbaa !32
+  call void @llvm.dbg.value(metadata i32 4, metadata !22, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 5, metadata !24, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 2, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 4, metadata !26, metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 5, metadata !28, metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 2, metadata !29, metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer)), !dbg !30
+  %1 = load volatile i32, i32* @v, align 4, !dbg !36, !tbaa !32
+  %inc1 = add nsw i32 %1, 1, !dbg !36
+  store volatile i32 %inc1, i32* @v, align 4, !dbg !36, !tbaa !32
+  ret i32 18, !dbg !37
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 45, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_mem2reg.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "6ad1488ed7a007c3a33e08ec42847d87")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 46, type: !13, scopeLine: 46, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16, !17, !18, !22, !24, !25, !26, !28, !29}
+!16 = !DILocalVariable(name: "var1", scope: !12, file: !3, line: 47, type: !7)
+!17 = !DILocalVariable(name: "var2", scope: !12, file: !3, line: 48, type: !7)
+!18 = !DILocalVariable(name: "arr1", scope: !12, file: !3, line: 49, type: !19)
+!19 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !20)
+!20 = !{!21}
+!21 = !DISubrange(count: 2)
+!22 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 50, type: !23)
+!23 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!24 = !DILocalVariable(name: "ptr2", scope: !12, file: !3, line: 51, type: !23)
+!25 = !DILocalVariable(name: "ptr3", scope: !12, file: !3, line: 52, type: !23)
+!26 = !DILocalVariable(name: "ptrptr1", scope: !12, file: !3, line: 53, type: !27)
+!27 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !23, size: 64)
+!28 = !DILocalVariable(name: "ptrptr2", scope: !12, file: !3, line: 54, type: !27)
+!29 = !DILocalVariable(name: "ptrptr3", scope: !12, file: !3, line: 55, type: !27)
+!30 = !DILocation(line: 0, scope: !12)
+!31 = !DILocation(line: 57, column: 4, scope: !12)
+!32 = !{!33, !33, i64 0}
+!33 = !{!"int", !34, i64 0}
+!34 = !{!"omnipotent char", !35, i64 0}
+!35 = !{!"Simple C/C++ TBAA"}
+!36 = !DILocation(line: 64, column: 4, scope: !12)
+!37 = !DILocation(line: 66, column: 3, scope: !12)

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_sroa.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK-LABEL:  DW_AT_name    ("arr2")
+
+// 1. Test if more than 2 member location list is printed (for pointer pointing to aggregate)
+// CHECK-LABEL:       DW_AT_location
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// RCHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0)
+// CHECK-NEXT:  DW_AT_name    ("ptr1")
+
+// 2. Test if location lists are merged to two (for pointer pointing to aggregate)
+// CHECK-LABEL:       DW_AT_location
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptr3")
+
+// 3. Test if one member location list is not omited (for pointer pointing to aggregate)
+// CHECK-LABEL:      DW_AT_name    ("__implicit_ptr_tmp_1")
+// CHECK-LABEL:        DW_AT_location
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:  DW_AT_name    ("ptr2")
+
+static const char *b = "opq";
+volatile int v;
+int main() {
+  int arr1[2] = {1, 2};
+  int arr2[2] = {6, 7};
+  int *ptr1 = 0;
+  int *ptr2;
+  int *ptr3 = 0;
+
+  v++;
+  ptr1 = arr1;
+  ptr2 = arr2;
+  ptr3 = arr1;
+  (*ptr1)++;
+  (*ptr2)++;
+  (*ptr3)++;
+  v++;
+  ptr1++;
+  (*ptr1)++;
+  (*ptr2)++;
+  (*ptr3)++;
+  v++;
+  return arr1[0] + arr1[1] + arr2[0] + arr2[1] - 5;
+}

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_sroa.ll

+; RUN: llc %s -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:  DW_AT_name    ("arr2")
+
+; 1. Test if more than 2 member location list is printed (for pointer pointing to aggregate)
+; CHECK-LABEL:       DW_AT_location
+; CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0)
+; CHECK-NEXT:  DW_AT_name    ("ptr1")
+
+; 2. Test if location lists are merged to two (for pointer pointing to aggregate)
+; CHECK-LABEL:       DW_AT_location
+; CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptr3")
+
+; 3. Test if one member location list is not omited (for pointer pointing to aggregate)
+; CHECK-LABEL:      DW_AT_name    ("__implicit_ptr_tmp_2")
+; CHECK-LABEL:        DW_AT_location
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:  DW_AT_name    ("ptr2")
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;int main() {
+;  int arr1[2] = {1, 2};
+;  int arr2[2] = {6, 7};
+;  int *ptr1 = 0;
+;  int *ptr2;
+;  int *ptr3 = 0;
+;
+;  v++;
+;  ptr1 = arr1;
+;  ptr2 = arr2;
+;  ptr3 = arr1;
+;  (*ptr1)++;
+;  (*ptr2)++;
+;  (*ptr3)++;
+;  v++;
+;  ptr1++;
+;  (*ptr1)++;
+;  (*ptr2)++;
+;  (*ptr3)++;
+;  v++;
+;  return arr1[0] + arr1[1] + arr2[0] + arr2[1] - 5;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_sroa.c'
+source_filename = "dwarfdump-implicit_pointer_sroa.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: nofree norecurse nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata i32 1, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 2, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 6, metadata !20, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 7, metadata !20, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32* null, metadata !21, metadata !DIExpression()), !dbg !25
+  call void @llvm.dbg.value(metadata i32* null, metadata !24, metadata !DIExpression()), !dbg !25
+  %0 = load volatile i32, i32* @v, align 4, !dbg !26, !tbaa !27
+  %inc = add nsw i32 %0, 1, !dbg !26
+  store volatile i32 %inc, i32* @v, align 4, !dbg !26, !tbaa !27
+  call void @llvm.dbg.value(metadata i32 1, metadata !21, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 6, metadata !23, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 1, metadata !24, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 2, metadata !21, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !31
+  call void @llvm.dbg.value(metadata i32 2, metadata !24, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !31
+  call void @llvm.dbg.value(metadata i32 2, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 7, metadata !23, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !32
+  call void @llvm.dbg.value(metadata i32 7, metadata !20, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 3, metadata !24, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !33
+  call void @llvm.dbg.value(metadata i32 3, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  %1 = load volatile i32, i32* @v, align 4, !dbg !34, !tbaa !27
+  %inc6 = add nsw i32 %1, 1, !dbg !34
+  store volatile i32 %inc6, i32* @v, align 4, !dbg !34, !tbaa !27
+  call void @llvm.dbg.value(metadata i32 2, metadata !21, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 3, metadata !21, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !35
+  call void @llvm.dbg.value(metadata i32 3, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 8, metadata !23, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !36
+  call void @llvm.dbg.value(metadata i32 8, metadata !20, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 4, metadata !24, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !37
+  call void @llvm.dbg.value(metadata i32 4, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  %2 = load volatile i32, i32* @v, align 4, !dbg !38, !tbaa !27
+  %inc10 = add nsw i32 %2, 1, !dbg !38
+  store volatile i32 %inc10, i32* @v, align 4, !dbg !38, !tbaa !27
+  ret i32 17, !dbg !39
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 25, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_sroa.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "955d25ccee581cfd1dc4cfad0d994e8f")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 26, type: !13, scopeLine: 26, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16, !20, !21, !23, !24}
+!16 = !DILocalVariable(name: "arr1", scope: !12, file: !3, line: 27, type: !17)
+!17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !18)
+!18 = !{!19}
+!19 = !DISubrange(count: 2)
+!20 = !DILocalVariable(name: "arr2", scope: !12, file: !3, line: 28, type: !17)
+!21 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 29, type: !22)
+!22 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!23 = !DILocalVariable(name: "ptr2", scope: !12, file: !3, line: 30, type: !22)
+!24 = !DILocalVariable(name: "ptr3", scope: !12, file: !3, line: 31, type: !22)
+!25 = !DILocation(line: 0, scope: !12)
+!26 = !DILocation(line: 33, column: 4, scope: !12)
+!27 = !{!28, !28, i64 0}
+!28 = !{!"int", !29, i64 0}
+!29 = !{!"omnipotent char", !30, i64 0}
+!30 = !{!"Simple C/C++ TBAA"}
+!31 = !DILocation(line: 18, column: 10, scope: !12)
+!32 = !DILocation(line: 19, column: 10, scope: !12)
+!33 = !DILocation(line: 20, column: 10, scope: !12)
+!34 = !DILocation(line: 24, column: 4, scope: !12)
+!35 = !DILocation(line: 26, column: 10, scope: !12)
+!36 = !DILocation(line: 27, column: 10, scope: !12)
+!37 = !DILocation(line: 28, column: 10, scope: !12)
+!38 = !DILocation(line: 32, column: 4, scope: !12)
+!39 = !DILocation(line: 33, column: 3, scope: !12)

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_sroa_inline.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK:       DW_TAG_inlined_subroutine
+
+// Test if More than 2 member location list is printed (for pointer pointing to aggregate)
+// CHECK:       DW_TAG_formal_parameter
+// CHECK-NEXT:    DW_AT_location
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+// CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0)
+// CHECK-NEXT:    DW_AT_abstract_origin       ({{0x.+}} "ptr")
+
+static const char *b = "opq";
+volatile int v;
+static inline void foo(int *ptr) {
+  (*ptr)++;
+  v++;
+  ptr++;
+  (*ptr)++;
+  v++;
+}
+
+int main() {
+  int arr[2] = {1, 2};
+  v++;
+  foo(arr);
+  return arr[0] + arr[1] - 5;
+}

llvm/test/DebugInfo/X86/dwarfdump-implicit_pointer_sroa_inline.ll

+; RUN: llc %s -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK:       DW_TAG_inlined_subroutine
+
+; Test if More than 2 member location list is printed (for pointer pointing to aggregate)
+; CHECK:       DW_TAG_formal_parameter
+; CHECK-NEXT:    DW_AT_location
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer {{0x.+}} +0)
+; CHECK-NEXT:    DW_AT_abstract_origin       ({{0x.+}} "ptr")
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;static inline void foo(int *ptr) {
+;  (*ptr)++;
+;  v++;
+;  ptr++;
+;  (*ptr)++;
+;  v++;
+;}
+;
+;int main() {
+;  int arr[2] = {1, 2};
+;  v++;
+;  foo(arr);
+;  return arr[0] + arr[1] - 5;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_sroa_inline.c'
+source_filename = "dwarfdump-implicit_pointer_sroa_inline.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !12 {
+entry:
+  %0 = load volatile i32, i32* @v, align 4, !dbg !21, !tbaa !22
+  %inc = add nsw i32 %0, 1, !dbg !21
+  store volatile i32 %inc, i32* @v, align 4, !dbg !21, !tbaa !22
+  call void @llvm.dbg.value(metadata i32 2, metadata !26, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !32
+  %1 = load volatile i32, i32* @v, align 4, !dbg !34, !tbaa !22
+  %inc1.i = add nsw i32 %1, 1, !dbg !34
+  store volatile i32 %inc1.i, i32* @v, align 4, !dbg !34, !tbaa !22
+  call void @llvm.dbg.value(metadata i32 3, metadata !26, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !35
+  %2 = load volatile i32, i32* @v, align 4, !dbg !36, !tbaa !22
+  %inc3.i = add nsw i32 %2, 1, !dbg !36
+  store volatile i32 %inc3.i, i32* @v, align 4, !dbg !36, !tbaa !22
+  ret i32 0, !dbg !37
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 14, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_sroa_inline.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "f9bbaee6b152b3bc05125796b573408a")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 11.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 23, type: !13, scopeLine: 23, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 24, type: !17)
+!17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !18)
+!18 = !{!19}
+!19 = !DISubrange(count: 2)
+!20 = !DILocation(line: 24, column: 7, scope: !12)
+!21 = !DILocation(line: 25, column: 4, scope: !12)
+!22 = !{!23, !23, i64 0}
+!23 = !{!"int", !24, i64 0}
+!24 = !{!"omnipotent char", !25, i64 0}
+!25 = !{!"Simple C/C++ TBAA"}
+!26 = !DILocalVariable(name: "ptr", arg: 1, scope: !27, file: !3, line: 15, type: !30)
+!27 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 15, type: !28, scopeLine: 15, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !31)
+!28 = !DISubroutineType(types: !29)
+!29 = !{null, !30}
+!30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!31 = !{!26}
+!32 = !DILocation(line: 16, column: 9, scope: !27, inlinedAt: !33)
+!33 = distinct !DILocation(line: 26, column: 3, scope: !12)
+!34 = !DILocation(line: 17, column: 4, scope: !27, inlinedAt: !33)
+!35 = !DILocation(line: 19, column: 9, scope: !27, inlinedAt: !33)
+!36 = !DILocation(line: 20, column: 4, scope: !27, inlinedAt: !33)
+!37 = !DILocation(line: 27, column: 3, scope: !12)

llvm/test/DebugInfo/X86/implicit_pointer_fast.ll

+; RUN: llc %s -fast-isel -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:       DW_TAG_inlined_subroutine
+
+; Test if More than 2 member location list is printed (for pointer pointing to aggregate)
+; CHECK-LABEL:   DW_TAG_formal_parameter
+; CHECK-NEXT:    DW_AT_location
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE1:0x.+]] +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE2:0x.+]] +0)
+; CHECK-NEXT:    DW_AT_abstract_origin       ({{0x.+}} "ptr")
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;static inline void foo(int *ptr) {
+;  (*ptr)++;
+;  v++;
+;  ptr++;
+;  (*ptr)++;
+;  v++;
+;}
+;
+;int main() {
+;  int arr[2] = {1, 2};
+;  v++;
+;  foo(arr);
+;  return arr[0] + arr[1] - 5;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_sroa_inline.c'
+source_filename = "dwarfdump-implicit_pointer_sroa_inline.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !12 {
+entry:
+  %0 = load volatile i32, i32* @v, align 4, !dbg !20
+  %inc = add nsw i32 %0, 1, !dbg !20
+  store volatile i32 %inc, i32* @v, align 4, !dbg !20
+  call void @llvm.dbg.value(metadata i32 2, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !31
+  %1 = load volatile i32, i32* @v, align 4, !dbg !33
+  %inc1.i = add nsw i32 %1, 1, !dbg !33
+  store volatile i32 %inc1.i, i32* @v, align 4, !dbg !33
+  call void @llvm.dbg.value(metadata i32 3, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !34
+  %2 = load volatile i32, i32* @v, align 4, !dbg !34
+  %inc3.i = add nsw i32 %2, 1, !dbg !34
+  store volatile i32 %inc3.i, i32* @v, align 4, !dbg !34
+  ret i32 0, !dbg !35
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 14, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_sroa_inline.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "f9bbaee6b152b3bc05125796b573408a")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 23, type: !13, scopeLine: 23, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 24, type: !17)
+!17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !18)
+!18 = !{!19}
+!19 = !DISubrange(count: 2)
+!20 = !DILocation(line: 25, column: 4, scope: !12)
+!21 = !{!22, !22, i64 0}
+!22 = !{!"int", !23, i64 0}
+!23 = !{!"omnipotent char", !24, i64 0}
+!24 = !{!"Simple C/C++ TBAA"}
+!25 = !DILocalVariable(name: "ptr", arg: 1, scope: !26, file: !3, line: 15, type: !29)
+!26 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 15, type: !27, scopeLine: 15, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !30)
+!27 = !DISubroutineType(types: !28)
+!28 = !{null, !29}
+!29 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!30 = !{!25}
+!31 = !DILocation(line: 0, scope: !26, inlinedAt: !32)
+!32 = distinct !DILocation(line: 26, column: 3, scope: !12)
+!33 = !DILocation(line: 17, column: 4, scope: !26, inlinedAt: !32)
+!34 = !DILocation(line: 20, column: 4, scope: !26, inlinedAt: !32)
+!35 = !DILocation(line: 27, column: 3, scope: !12)

llvm/test/DebugInfo/X86/implicit_pointer_global.ll

+; RUN: llc %s -global-isel -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:       DW_TAG_inlined_subroutine
+
+; Test if More than 2 member location list is printed (for pointer pointing to aggregate)
+; CHECK-LABEL:   DW_TAG_formal_parameter
+; CHECK-NEXT:    DW_AT_location
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE1:0x.+]] +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE2:0x.+]] +0)
+; CHECK-NEXT:    DW_AT_abstract_origin       ({{0x.+}} "ptr")
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;static inline void foo(int *ptr) {
+;  (*ptr)++;
+;  v++;
+;  ptr++;
+;  (*ptr)++;
+;  v++;
+;}
+;
+;int main() {
+;  int arr[2] = {1, 2};
+;  v++;
+;  foo(arr);
+;  return arr[0] + arr[1] - 5;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_sroa_inline.c'
+source_filename = "dwarfdump-implicit_pointer_sroa_inline.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !12 {
+entry:
+  %0 = load volatile i32, i32* @v, align 4, !dbg !20
+  %inc = add nsw i32 %0, 1, !dbg !20
+  store volatile i32 %inc, i32* @v, align 4, !dbg !20
+  call void @llvm.dbg.value(metadata i32 2, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !31
+  %1 = load volatile i32, i32* @v, align 4, !dbg !33
+  %inc1.i = add nsw i32 %1, 1, !dbg !33
+  store volatile i32 %inc1.i, i32* @v, align 4, !dbg !33
+  call void @llvm.dbg.value(metadata i32 3, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !34
+  %2 = load volatile i32, i32* @v, align 4, !dbg !34
+  %inc3.i = add nsw i32 %2, 1, !dbg !34
+  store volatile i32 %inc3.i, i32* @v, align 4, !dbg !34
+  ret i32 0, !dbg !35
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 14, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_sroa_inline.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "f9bbaee6b152b3bc05125796b573408a")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 23, type: !13, scopeLine: 23, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 24, type: !17)
+!17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !18)
+!18 = !{!19}
+!19 = !DISubrange(count: 2)
+!20 = !DILocation(line: 25, column: 4, scope: !12)
+!21 = !{!22, !22, i64 0}
+!22 = !{!"int", !23, i64 0}
+!23 = !{!"omnipotent char", !24, i64 0}
+!24 = !{!"Simple C/C++ TBAA"}
+!25 = !DILocalVariable(name: "ptr", arg: 1, scope: !26, file: !3, line: 15, type: !29)
+!26 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 15, type: !27, scopeLine: 15, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !30)
+!27 = !DISubroutineType(types: !28)
+!28 = !{null, !29}
+!29 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!30 = !{!25}
+!31 = !DILocation(line: 0, scope: !26, inlinedAt: !32)
+!32 = distinct !DILocation(line: 26, column: 3, scope: !12)
+!33 = !DILocation(line: 17, column: 4, scope: !26, inlinedAt: !32)
+!34 = !DILocation(line: 20, column: 4, scope: !26, inlinedAt: !32)
+!35 = !DILocation(line: 27, column: 3, scope: !12)

llvm/test/DebugInfo/X86/implicit_pointer_instcomb.c

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+volatile int gvar = 7;
+
+int func(int *ptr) {
+  gvar = *ptr;
+  return *ptr + 5;
+}
+
+int main() {
+  int var = 4;
+  int *ptrVar = &var;
+
+  // CHECK:  call void @llvm.dbg.value(metadata i32 4, metadata [[MD1:!.*]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK:  call void @llvm.dbg.value(metadata i32 4, metadata [[MD2:!.*]], metadata !DIExpression())
+  // CHECK:  call void @llvm.dbg.value(metadata i32 4, metadata [[MD3:!.*]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  int res = func(ptrVar);
+
+  return res;
+}
+// CHECK: [[MD3]] = !DILocalVariable(name: "ptr"
+// CHECK: [[MD2]] = !DILocalVariable(name: "var"
+// CHECK: [[MD1]] = !DILocalVariable(name: "ptrVar"

llvm/test/DebugInfo/X86/implicit_pointer_mem2reg.c

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+static const char *b = "opq";
+volatile int v;
+int main() {
+  int var1 = 4;
+  int var2 = 5;
+  int arr1[2] = {2, 3};
+  int *ptr1;
+  int *ptr2 = 0;
+  int *ptr3;
+  int **ptrptr1;
+  int **ptrptr2 = 0;
+  int **ptrptr3;
+
+  v++;
+  ptr1 = &var1;
+  ptr2 = &var2;
+  ptr3 = arr1;
+  // CHECK: call void @llvm.dbg.value(metadata i32 4, metadata [[MD1:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK: call void @llvm.dbg.value(metadata i32 5, metadata [[MD2:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK: call void @llvm.dbg.value(metadata i32 2, metadata [[MD3:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  ptrptr1 = &ptr1;
+  ptrptr2 = &ptr2;
+  ptrptr3 = &ptr3;
+  // CHECK: call void @llvm.dbg.value(metadata i32 4, metadata [[MD4:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer))
+  // CHECK: call void @llvm.dbg.value(metadata i32 5, metadata [[MD5:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer))
+  // CHECK: call void @llvm.dbg.value(metadata i32 2, metadata [[MD6:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer))
+
+  v++;
+
+  return arr1[0] + arr1[1] + *ptr1 + *ptr2 + **ptrptr1 + **ptrptr2 - 5;
+}
+// CHECK: [[MD1]] = !DILocalVariable(name: "ptr1"
+// CHECK: [[MD2]] = !DILocalVariable(name: "ptr2"
+// CHECK: [[MD3]] = !DILocalVariable(name: "ptr3"
+// CHECK: [[MD4]] = !DILocalVariable(name: "ptrptr1"
+// CHECK: [[MD5]] = !DILocalVariable(name: "ptrptr2"
+// CHECK: [[MD6]] = !DILocalVariable(name: "ptrptr3"

llvm/test/DebugInfo/X86/implicit_pointer_promote2reg.c

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+static const char *b = "opq";
+volatile int v;
+int main() {
+  int var1 = 4;
+  int var2 = 5;
+  int arr1[2] = {2, 3};
+  int *ptr1;
+  int *ptr2 = 0;
+  int **ptrptr1;
+  int **ptrptr2 = 0;
+
+  v++;
+  ptr1 = &var1;
+  ptr2 = &var2;
+  // CHECK: call void @llvm.dbg.value(metadata i32 4, metadata [[MD1:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK: call void @llvm.dbg.value(metadata i32 5, metadata [[MD2:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  ptrptr1 = &ptr1;
+  ptrptr2 = &ptr2;
+  // CHECK: call void @llvm.dbg.value(metadata i32 4, metadata [[MD3:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer))
+  // CHECK: call void @llvm.dbg.value(metadata i32 5, metadata [[MD4:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_explicit_pointer))
+
+  v++;
+
+  return arr1[0] + arr1[1] + *ptr1 + *ptr2 + **ptrptr1 + **ptrptr2 - 5;
+}
+// CHECK: [[MD1]] = !DILocalVariable(name: "ptr1"
+// CHECK: [[MD2]] = !DILocalVariable(name: "ptr2"
+// CHECK: [[MD3]] = !DILocalVariable(name: "ptrptr1"
+// CHECK: [[MD4]] = !DILocalVariable(name: "ptrptr2"

llvm/test/DebugInfo/X86/implicit_pointer_sroa.c

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+static const char *b = "opq";
+volatile int v;
+int main() {
+  int arr1[2] = {1, 2};
+  int arr2[2] = {6, 7};
+  int *ptr1 = 0;
+  int *ptr2;
+  int *ptr3 = 0;
+  // CHECK: call void @llvm.dbg.value(metadata i32* null, metadata [[MD1:!.+]], metadata !DIExpression())
+  // CHECK: call void @llvm.dbg.value(metadata i32* null, metadata [[MD3:!.+]], metadata !DIExpression())
+  v++;
+  ptr1 = arr1;
+  ptr2 = arr2;
+  ptr3 = arr1;
+  (*ptr1)++;
+  (*ptr2)++;
+  (*ptr3)++;
+  // CHECK:  call void @llvm.dbg.value(metadata i32 7, metadata [[MD2:!.*]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK:  call void @llvm.dbg.value(metadata i32 3, metadata [[MD1]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK:  call void @llvm.dbg.value(metadata i32 3, metadata [[MD3]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  v++;
+  ptr1++;
+  (*ptr1)++;
+  (*ptr2)++;
+  (*ptr3)++;
+  // CHECK:  call void @llvm.dbg.value(metadata i32 8, metadata [[MD2]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK:  call void @llvm.dbg.value(metadata i32 4, metadata [[MD3]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  v++;
+  return arr1[0] + arr1[1] + arr2[0] + arr2[1] - 5;
+}
+// CHECK: [[MD1]] = !DILocalVariable(name: "ptr1"
+// CHECK: [[MD2]] = !DILocalVariable(name: "ptr2"
+// CHECK: [[MD3]] = !DILocalVariable(name: "ptr3"

llvm/test/DebugInfo/X86/implicit_pointer_sroa_inline.c

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+static const char *b = "opq";
+volatile int v;
+static inline void foo(int *ptr) {
+  (*ptr)++;
+  // CHECK:  call void @llvm.dbg.value(metadata i32 2, metadata [[MD:!.*]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  v++;
+  ptr++;
+  (*ptr)++;
+  // CHECK:  call void @llvm.dbg.value(metadata i32 3, metadata [[MD:!.*]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  v++;
+}
+
+int main() {
+  int arr[2] = {1, 2};
+  v++;
+  foo(arr);
+  return arr[0] + arr[1] - 5;
+}
+// CHECK: [[MD]] = !DILocalVariable(name: "ptr"

llvm/test/DebugInfo/X86/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
+
+int main() {
+  int *i = new int(3);
+  int *j = new int(4);
+  // CHECK:  call void @llvm.dbg.value(metadata i32 3, metadata [[MD1:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  // CHECK:  call void @llvm.dbg.value(metadata i32 4, metadata [[MD2:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  delete i;
+  delete j;
+
+  return 0;
+}
+// CHECK: [[MD1]] = !DILocalVariable(name: "i"
+// CHECK: [[MD2]] = !DILocalVariable(name: "j"

llvm/test/DebugInfo/X86/implicit_pointer_temp_reference.cc

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+__attribute__((optnone)) int source() {
+  return 3;
+}
+__attribute__((optnone)) void f(int i) {
+}
+inline void sink(const int &p) {
+  f(p);
+}
+int main() {
+  // CHECK:  call void @llvm.dbg.value(metadata i32 3, metadata [[MD:!.+]], metadata !DIExpression(DW_OP_LLVM_explicit_pointer))
+  sink(source());
+}
+// CHECK: [[MD]] = !DILocalVariable(name: "p"

llvm/unittests/IR/DebugInfoTest.cpp

)");
 
   // Find %b = add ...
   Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
 
   // Find the dbg.value using %b.
   SmallVector<DbgValueInst *, 1> DVIs;
   findDbgValues(DVIs, &I);
 
-  // Delete %b. The dbg.value should now point to undef.
+  // Delete %b. The dbg.value should now point to %a.
   I.eraseFromParent();
-  EXPECT_TRUE(isa<UndefValue>(DVIs[0]->getValue()));
+  EXPECT_FALSE(isa<UndefValue>(DVIs[0]->getValue()));
 }
 
 } // end namespace

llvm/unittests/Transforms/Utils/LocalTest.cpp

TEST(Local, ReplaceAllDbgUsesWith) {
   // Simulate i32 <-> <2 x i16> conversion. This is unsupported.
   EXPECT_FALSE(replaceAllDbgUsesWith(E, A, A, DT));
   EXPECT_FALSE(replaceAllDbgUsesWith(A, E, E, DT));
 
   // Simulate i32* <-> i64* conversion.
   EXPECT_TRUE(replaceAllDbgUsesWith(D, C, C, DT));
 
   SmallVector<DbgVariableIntrinsic *, 2> CDbgVals;
-  findDbgUsers(CDbgVals, &C);
+  C.findDbgUsers(CDbgVals);
   EXPECT_EQ(2U, CDbgVals.size());
   EXPECT_TRUE(any_of(CDbgVals, [](DbgVariableIntrinsic *DII) {
     return isa<DbgAddrIntrinsic>(DII);
   }));
   EXPECT_TRUE(any_of(CDbgVals, [](DbgVariableIntrinsic *DII) {
     return isa<DbgDeclareInst>(DII);
   }));
 
   EXPECT_TRUE(replaceAllDbgUsesWith(C, D, D, DT));
 
   SmallVector<DbgVariableIntrinsic *, 2> DDbgVals;
-  findDbgUsers(DDbgVals, &D);
+  D.findDbgUsers(DDbgVals);
   EXPECT_EQ(2U, DDbgVals.size());
   EXPECT_TRUE(any_of(DDbgVals, [](DbgVariableIntrinsic *DII) {
     return isa<DbgAddrIntrinsic>(DII);
   }));
   EXPECT_TRUE(any_of(DDbgVals, [](DbgVariableIntrinsic *DII) {
     return isa<DbgDeclareInst>(DII);
   }));