[DebugInfo] Support for DW_OP_implicit_pointer.

[alok]

Summary

This patch adds support for DW_OP_implicit_pointer.

This will enable debugger to show dereferenced value of optimized out pointer.
It has been validated for SROA, mem2reg and Instruction-combiner optimizations.

This also fixes PR43289

[dblaikie]

Rough first review: This looks like it touches a lot of places. I think it might make more sense as several separate patches - improving salavageDebugINfo and then separate patches for each new call-site (including appropriate test cases showing how each new call site is useful).

[aprantl]

This looks very interesting! I agree with David though that it would be nice to split this into smaller parts.

[labath]

I don't know much about the generation side of debug info in llvm.

llvm/include/llvm/CodeGen/MachineInstr.h

 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/PointerSumType.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/ArrayRecycler.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <algorithm>
 #include <cassert>
public:
   }
 
   /// Returns the number of non-implicit operands.
   unsigned getNumExplicitOperands() const;
 
   /// Returns the number of non-implicit definitions.
   unsigned getNumExplicitDefs() const;
 
+  /// Returns true if it has implicit pointer expression
+  bool isImplicitPointer() const {
+    return getDebugExpression()->isImplicitPointer();
+  }
+
   /// iterator/begin/end - Iterate over all operands of a machine instruction.
   using mop_iterator = MachineOperand *;
   using const_mop_iterator = const MachineOperand *;
 
   mop_iterator operands_begin() { return Operands; }
   mop_iterator operands_end() { return Operands + NumOperands; }
 
   const_mop_iterator operands_begin() const { return Operands; }

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

public:
 
   const MachineInstrBuilder &add(ArrayRef<MachineOperand> MOs) const {
     for (const MachineOperand &MO : MOs) {
       MI->addOperand(*MF, MO);
     }
     return *this;
   }
 
-  const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
+  const MachineInstrBuilder &addMetadata(const MDNode *MD,
+                                         bool IsImplicitPointer = false) const {
     MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
-    assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
-                               : true) &&
+    assert(((MI->isDebugValue() && !IsImplicitPointer)
+                ? static_cast<bool>(MI->getDebugVariable())
            "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 &addCFIIndex(unsigned CFIIndex) const {

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/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_implicit_pointer);
+  }
+
   /// 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 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(DIExpression *SrcDIExpr,
+                                     bool WithStackValue);
+
+  /// Implementation of salvageDebugInfo, applying only to instructions in
+  /// \p Insns, rather than all debug users of \p I.
+  bool salvageDebugInfoForDbgValues(ArrayRef<DbgVariableIntrinsic *> DbgUsers);
+
+  /// 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.
+  /// Returns true if any debug users were updated.
+  bool 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/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"
 #include "llvm/Support/Casting.h"
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 {
+      if (!isa<DIExpression>(getRawExpression()))
+        return false;
+
+      return getExpression()->isImplicitPointer();
+    }
+
     /// \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

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

llvm/include/llvm/IR/Value.h

 
 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);
     }
   }
 
+  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/Utils/Local.h

 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/DomTreeUpdater.h"
 #include "llvm/Analysis/Utils/Local.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include <cstdint>
 #include <limits>
 

 /// Finds all intrinsics declaring local variables as living in the memory that
 /// 'V' points to. This may include a mix of dbg.declare and
 /// dbg.addr intrinsics.
 TinyPtrVector<DbgVariableIntrinsic *> FindDbgAddrUses(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,
                        Instruction *InsertBefore, DIBuilder &Builder,
                        uint8_t DIExprFlags, int Offset);

 /// 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.
-/// Returns true if any debug users were updated.
-bool salvageDebugInfo(Instruction &I);
-
-/// Implementation of salvageDebugInfo, applying only to instructions in
-/// \p Insns, rather than all debug users of \p I.
-bool 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/CodeGen/AsmPrinter/DebugLocEntry.h

 class AsmPrinter;
 
 /// A single location or constant.
 class DbgValueLoc {
   /// Any complex address location expression for this DbgValueLoc.
   const DIExpression *Expression;
 
   /// Type of entry that this represents.
-  enum EntryType { E_Location, E_Integer, E_ConstantFP, E_ConstantInt };
+  enum EntryType {
+    E_Location,
+    E_Integer,
+    E_ConstantFP,
+    E_ConstantInt,
+    E_ImplicitPtr
+  };
   enum EntryType EntryKind;
 
-  /// Either a constant,
+  /// a constant,
   union {
     int64_t Int;
     const ConstantFP *CFP;
     const ConstantInt *CIP;
   } Constant;
 
   /// Or a location in the machine frame.
   MachineLocation Loc;
 
+  /// 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, const DIVariable *ImpPtr)
+      : Expression(Expr), EntryKind(E_ImplicitPtr), ImpPtr(ImpPtr) {
+    assert(cast<DIExpression>(Expr)->isValid());
+  }
 
   bool isLocation() const { return EntryKind == E_Location; }
   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; }
+  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_Location:
     return A.Loc == B.Loc;
   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 when available.
+  std::vector<const DINode *> 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) {
+    std::vector<const DINode *>::iterator it =
+        std::find(ImplicitVars.begin(), ImplicitVars.end(), var);
+    if (it == ImplicitVars.end()) {
+      ImplicitVars.push_back(var);
+      return ImplicitVars.size() - 1;
+    } else
+      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);
 
   /// A pair of GlobalVariable and DIExpression.
   struct GlobalExpr {
     const GlobalVariable *Var;
     const DIExpression *Expr;
   };

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:
   bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; }
   /// @}
 
   void addSectionLabel(const MCSymbol *Sym);
   const MCSymbol *getSectionLabel(const MCSection *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?");
if (MI->getOperand(0).isReg()) {
     return DbgValueLoc(Expr, MLoc);
   }
   if (MI->getOperand(0).isImm())
     return DbgValueLoc(Expr, MI->getOperand(0).getImm());
   if (MI->getOperand(0).isFPImm())
     return DbgValueLoc(Expr, MI->getOperand(0).getFPImm());
   if (MI->getOperand(0).isCImm())
     return DbgValueLoc(Expr, MI->getOperand(0).getCImm());
+  if (MI->getOperand(0).isMetadata()) {
+    // first operand can be metadata in case of implicit pointer
+    const DIVariable *DVI = cast<DIVariable>(MI->getOperand(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->isImplicitPointer() &&
+        (HistSize == 1 || SingleValueWithClobber)) {
       const auto *End =
           SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
       if (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);
 
     // 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->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) {
           } else {
             // Emit a reference to the 'generic type'.
             Asm->EmitULEB128(0, nullptr, 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) + 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());
if (Value.isInt()) {
 
     const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
     if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
       return;
     return DwarfExpr.addExpression(std::move(Cursor));
   } 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(std::is_sorted(Values.begin(), Values.end()) &&
            "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();
 }
 
 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
                                            const DwarfCompileUnit *CU) {
   // Emit the size.
   Asm->OutStreamer->AddComment("Loc expr size");

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;
void addExpression(DIExpressionCursor &&Expr,
                      unsigned FragmentOffsetInBits = 0);
 
   /// If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to
   /// the fragment described by \c Expr.
   void addFragmentOffset(const DIExpression *Expr);
 
   void emitLegacySExt(unsigned FromBits);
   void emitLegacyZExt(unsigned FromBits);
+  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::emitLegacyZExt(unsigned FromBits) {
   // (X & (1 << FromBits - 1))
   emitOp(dwarf::DW_OP_constu);
   emitUnsigned((1ULL << FromBits) - 1);
   emitOp(dwarf::DW_OP_and);
 }
+
+void DwarfExpression::emitImplicitPointer(DIExpressionCursor &&ExprCursor,
+                                          unsigned ValOffset) {
+  auto Op = ExprCursor.take();
+  assert(Op->getOp() == dwarf::DW_OP_implicit_pointer &&
+         "not dwarf::DW_OP_implicit_pointer");
+
+  emitOp(dwarf::DW_OP_implicit_pointer);
+  // this is a dummy offset which will later be replaced with actual offset
+  // of variable in .debug_info
+  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/LiveDebugValues.cpp

void LiveDebugValues::transferDebugValue(const MachineInstr &MI,
   if (isDbgValueDescribedByReg(MI) || MI.getOperand(0).isImm() ||
       MI.getOperand(0).isFPImm() || MI.getOperand(0).isCImm()) {
     // Use normal VarLoc constructor for registers and immediates.
     VarLoc VL(MI, LS);
     ID = VarLocIDs.insert(VL);
     OpenRanges.insert(ID, VL.Var);
   } else if (MI.hasOneMemOperand()) {
     llvm_unreachable("DBG_VALUE with mem operand encountered after regalloc?");
-  } else {
+  } else if (!MI.isImplicitPointer()) {
     // This must be an undefined location. We should leave OpenRanges closed.
     assert(MI.getOperand(0).isReg() && MI.getOperand(0).getReg() == 0 &&
            "Unexpected non-undef DBG_VALUE encountered");
   }
 }
 
 void LiveDebugValues::emitEntryValues(MachineInstr &MI,
                                       OpenRangesSet &OpenRanges,

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.addMetadata(DV, /* IsImplicitPointer */ true);
   } 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())
     Expr = DIExpression::append(Expr, {dwarf::DW_OP_deref});

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

 /// 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.
+    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.cpp

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);
bool SelectionDAGBuilder::handleDebugValue(const Value *V, DILocalVariable *Var,
   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);

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/DWARFExpression.cpp

static DescVector getDescriptions() {
   Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_addrx] = Desc(Op::Dwarf4, Op::SizeLEB);
   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_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/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_implicit_pointer:
     return 2;
   default:
     return 1;
   }
 }
 
 bool DIExpression::isValid() const {
   for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
     case dwarf::DW_OP_deref:
     case dwarf::DW_OP_deref_size:
     case dwarf::DW_OP_xderef:
     case dwarf::DW_OP_lit0:
     case dwarf::DW_OP_not:
     case dwarf::DW_OP_dup:
     case dwarf::DW_OP_regx:
     case dwarf::DW_OP_bregx:
+    case dwarf::DW_OP_implicit_pointer:
       break;
     }
   }
   return true;
 }
 
 bool DIExpression::isImplicit() const {
   if (!isValid())
void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops,
   } else if (Offset < 0) {
     Ops.push_back(dwarf::DW_OP_constu);
     Ops.push_back(-Offset);
     Ops.push_back(dwarf::DW_OP_minus);
   }
 }
 
 bool DIExpression::extractIfOffset(int64_t &Offset) const {
-  if (getNumElements() == 0) {
+  unsigned numElements;
+  numElements = getNumElements();
+
+  if (numElements == 0) {
     Offset = 0;
     return true;
   }
 
-  if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
+  if (Elements[numElements - 1] == dwarf::DW_OP_stack_value)
+    numElements--;
+
+  if (numElements == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
     Offset = Elements[1];
     return true;
   }
 
-  if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
+  if (numElements == 3 && Elements[0] == dwarf::DW_OP_constu) {
     if (Elements[2] == dwarf::DW_OP_plus) {
       Offset = Elements[1];
       return true;
     }
     if (Elements[2] == dwarf::DW_OP_minus) {
       Offset = -Elements[1];
       return true;
     }

llvm/lib/IR/Instruction.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.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);
 }

 void Instruction::setProfWeight(uint64_t W) {
   assert(isa<CallBase>(this) &&
          "Can only set weights for call like instructions");
   SmallVector<uint32_t, 1> Weights;
   Weights.push_back(W);
   MDBuilder MDB(getContext());
   setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
 }
+
+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 =
+      [&](std::initializer_list<uint64_t> Opcodes) -> DIExpression * {
+    SmallVector<uint64_t, 8> Ops(Opcodes);
+    return doSalvage(Ops);
+  };
+
+  if (auto *CI = dyn_cast<CastInst>(this)) {
+    // No-op casts and zexts are irrelevant for debug info.
+    if (CI->isNoopCast(DL) || isa<ZExtInst>(this))
+      return SrcDIExpr;
+    return nullptr;
+  } else 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;
+}
+
+bool Instruction::salvageDebugInfoForDbgValues(
+    ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
+  auto &Ctx = getContext();
+  auto wrapMD = [&](Value *V) {
+    return MetadataAsValue::get(Ctx, ValueAsMetadata::get(V));
+  };
+  Value *debugDeclareAddress = nullptr;
+
+  if ((getModule()->getDwarfVersion() >= 5) && 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);
+  }
+
+  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)
+      return false;
+
+    if (isa<AllocaInst>(*this) &&
+        (!debugDeclareAddress || DII->isAddressOfVariable()))
+      continue;
+
+    if (StackValue && debugDeclareAddress) {
+      int64_t ExprOffset = 0;
+      if (DII->getExpression()->extractIfOffset(ExprOffset)) {
+        // It will cause below transformation
+        //
+        // Before transformation
+        //
+        // %a = alloca [2 x i32], align 4
+        // call void @llvm.dbg.declare(metadata [2 x i32]* %arr, metadata !16,
+        // metadata !DIExpression()), !dbg !22
+        //
+        // call void @llvm.dbg.value(metadata [2 x i32]* %arr, metadata !20,
+        // metadata !DIExpression()), !dbg !24
+        //
+        // call void @llvm.dbg.value(metadata [2 x i32]* %arr, metadata !20,
+        // metadata !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)),
+        // !dbg !24
+        //
+        // !16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 5,
+        // type: !17) !20 = !DILocalVariable(name: "ptr", scope: !12, file: !3,
+        // line: 6, type: !21)
+        //
+        //
+        // After transformation
+        //
+        // %a = alloca [2 x i32], align 4
+        // call void @llvm.dbg.declare(metadata [2 x i32]* %arr, metadata !16,
+        // metadata !DIExpression()), !dbg !22
+        //
+        // call void @llvm.dbg.value(metadata !16, metadata !20, metadata
+        // !DIExpression(DW_OP_implicit_pointer, 0)), !dbg !24
+        //
+        // call void @llvm.dbg.value(metadata !16, metadata !20, metadata
+        //  !DIExpression(DW_OP_implicit_pointer, 4)), !dbg !24
+        //
+        DII->setOperand(0, debugDeclareAddress);
+        SmallVector<uint64_t, 8> Ops;
+        Ops.push_back(dwarf::DW_OP_implicit_pointer);
+        Ops.push_back(ExprOffset);
+        DIExpr = DIExpression::get(DIExpr->getContext(), Ops);
+      } else
+        return false;
+    } else
+      DII->setOperand(0, wrapMD(getOperand(0)));
+
+    DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
+    // LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n');
+  }
+
+  return true;
+}
+
+bool 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 false;
+
+  // 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 (DDI->isAddressOfVariable())
+      getModule()->insertVarAddressMap(DDI);
+
+  findDbgUsers(DbgUsers);
+  if (DbgUsers.empty())
+    return false;
+
+  return salvageDebugInfoForDbgValues(DbgUsers);
+}

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;
 }

llvm/lib/IR/Module.cpp

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

llvm/lib/IR/Value.cpp

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/IR/Verifier.cpp

if (HasRoundingMD) {
     Assert(FPI.getRoundingMode().hasValue(),
            "invalid rounding mode argument", &FPI);
   }
 }
 
 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII) {
   auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata();
   AssertDI(isa<ValueAsMetadata>(MD) ||
-             (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
+               (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()) ||
+               DII.isImplicitPointer(),
            "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
   AssertDI(isa<DILocalVariable>(DII.getRawVariable()),
          "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
          DII.getRawVariable());
   AssertDI(isa<DIExpression>(DII.getRawExpression()),
          "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
          DII.getRawExpression());
 
   // Ignore broken !dbg attachments; they're checked elsewhere.

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.
     if (I.getNumOperands() < 8) {
       for (Use &Operand : I.operands())
         if (auto *Inst = dyn_cast<Instruction>(Operand))
           Worklist.Add(Inst);
     }

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

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);
   for (auto *DII : reverse(DbgUsers)) {
     if (DII->getParent() == SrcBlock) {
       if (isa<DbgDeclareInst>(DII)) {
         // A dbg.declare instruction should not be cloned, since there can only be
         // one per variable fragment. It should be left in the original place since
         // sunk instruction is not an alloca(otherwise we could not be here).
         // But we need to update arguments of dbg.declare instruction, so that it
         // would not point into sunk instruction.
         if (!isa<CastInst>(I))
           continue; // dbg.declare points at something it shouldn't
 
         DII->setOperand(
             0, MetadataAsValue::get(I->getContext(),
                                     ValueAsMetadata::get(I->getOperand(0))));
         continue;
       }
 
       // dbg.value is in the same basic block as the sunk inst, see if we can
       // salvage it. Clone a new copy of the instruction: on success we need
       // both salvaged and unsalvaged copies.
       SmallVector<DbgVariableIntrinsic *, 1> TmpUser{
           cast<DbgVariableIntrinsic>(DII->clone())};
 
-      if (!salvageDebugInfoForDbgValues(*I, TmpUser)) {
+      if (!I->salvageDebugInfoForDbgValues(TmpUser)) {
         // We are unable to salvage: sink the cloned dbg.value, and mark the
         // original as undef, terminating any earlier variable location.
         LLVM_DEBUG(dbgs() << "SINK: " << *DII << '\n');
         TmpUser[0]->insertBefore(&*InsertPos);
         Value *Undef = UndefValue::get(I->getType());
         DII->setOperand(0, MetadataAsValue::get(DII->getContext(),
                                                 ValueAsMetadata::get(Undef)));
       } else {
do {
 
     for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
       Instruction *Inst = &*BBI++;
 
       // DCE instruction if trivially dead.
       if (isInstructionTriviallyDead(Inst, TLI)) {
         ++NumDeadInst;
         LLVM_DEBUG(dbgs() << "IC: DCE: " << *Inst << '\n');
-        if (!salvageDebugInfo(*Inst))
+        if (!Inst->salvageDebugInfo())
           replaceDbgUsesWithUndef(Inst);
         Inst->eraseFromParent();
         MadeIRChange = true;
         continue;
       }
 
       // ConstantProp instruction if trivially constant.
       if (!Inst->use_empty() &&

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;
     }
 
     for (Use &U : I.operands()) {
       // DemandedBits only detects dead integer uses.

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();
 
     // 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)

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

deleteDeadInstruction(Instruction *I, BasicBlock::iterator *BBI,
   BasicBlock::iterator NewIter = *BBI;
 
   // Before we touch this instruction, remove it from memdep!
   do {
     Instruction *DeadInst = NowDeadInsts.pop_back_val();
     ++NumFastOther;
 
     // Try to preserve debug information attached to the dead instruction.
-    salvageDebugInfo(*DeadInst);
+    DeadInst->salvageDebugInfo();
 
     // 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) {
       Value *Op = DeadInst->getOperand(op);

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;) {
 
     // Dead instructions should just be removed.
     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;
       }
-      if (!salvageDebugInfo(*Inst))
+      if (!Inst->salvageDebugInfo())
         replaceDbgUsesWithUndef(Inst);
       removeMSSA(Inst);
       Inst->eraseFromParent();
       Changed = true;
       ++NumSimplify;
       continue;
     }
 

llvm/lib/Transforms/Scalar/GVN.cpp

for (BasicBlock::iterator BI = BB->begin(), BE = BB->end();
     // Avoid iterator invalidation.
     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');
-      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');
-        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

llvm/lib/Transforms/Scalar/Reassociate.cpp

static bool ShouldBreakUpSubtract(Instruction *Sub) {
   Value *V0 = Sub->getOperand(0);
   if (isReassociableOp(V0, Instruction::Add, Instruction::FAdd) ||
       isReassociableOp(V0, Instruction::Sub, Instruction::FSub))
     return true;
   Value *V1 = Sub->getOperand(1);
   if (isReassociableOp(V1, Instruction::Add, Instruction::FAdd) ||
       isReassociableOp(V1, Instruction::Sub, Instruction::FSub))
     return true;
+  if (Sub->hasOneUse()) {
     Value *VB = Sub->user_back();
-  if (Sub->hasOneUse() &&
-      (isReassociableOp(VB, Instruction::Add, Instruction::FAdd) ||
-       isReassociableOp(VB, Instruction::Sub, Instruction::FSub)))
+    if (isReassociableOp(VB, Instruction::Add, Instruction::FAdd) ||
+        isReassociableOp(VB, Instruction::Sub, Instruction::FSub))
       return true;
+  }
 
   return false;
 }
 
 /// If we have (X-Y), and if either X is an add, or if this is only used by an
 /// add, transform this into (X+(0-Y)) to promote better reassociation.
 static BinaryOperator *BreakUpSubtract(Instruction *Sub,
                                        ReassociatePass::OrderedSet &ToRedo) {

llvm/lib/Transforms/Scalar/SROA.cpp

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 (DeadUser->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.
     DeadUser->replaceAllUsesWith(UndefValue::get(DeadUser->getType()));
 
     // And mark it for deletion.

 /// subsequently handed to mem2reg to promote.
 bool SROA::deleteDeadInstructions(
     SmallPtrSetImpl<AllocaInst *> &DeletedAllocas) {
   bool Changed = false;
   while (!DeadInsts.empty()) {
     Instruction *I = DeadInsts.pop_back_val();
     LLVM_DEBUG(dbgs() << "Deleting dead instruction: " << *I << "\n");
 
+    // Try to preserve debug information attached to the dead instruction.
+    if (I->getModule()->getDwarfVersion() >= 5)
+      I->salvageDebugInfo();
     // If the instruction is an alloca, find the possible dbg.declare connected
     // to it, and remove it too. We must do this before calling RAUW or we will
     // not be able to find it.
     if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) {
       DeletedAllocas.insert(AI);
       for (DbgVariableIntrinsic *OldDII : FindDbgAddrUses(AI))
         OldDII->eraseFromParent();
     }

llvm/lib/Transforms/Utils/CodeExtractor.cpp

while (BlockIt != BB.end()) {
       ++BlockIt;
       if (isa<DbgInfoIntrinsic>(Inst))
         Inst->eraseFromParent();
     }
     // Remove debug info intrinsics which refer to values in the new function
     // from the old function.
     SmallVector<DbgVariableIntrinsic *, 4> DbgUsers;
     for (Instruction &I : BB)
-      findDbgUsers(DbgUsers, &I);
+      I.findDbgUsers(DbgUsers);
     for (DbgVariableIntrinsic *DVI : DbgUsers)
       DVI->eraseFromParent();
   }
 
   // Mark the new function `noreturn` if applicable. Terminators which resume
   // exception propagation are treated as returning instructions. This is to
   // avoid inserting traps after calls to outlined functions which unwind.
   bool doesNotReturn = none_of(*newFunction, [](const BasicBlock &BB) {

llvm/lib/Transforms/Utils/Local.cpp

void llvm::RecursivelyDeleteTriviallyDeadInstructions(
   // Process the dead instruction list until empty.
   while (!DeadInsts.empty()) {
     Instruction &I = *DeadInsts.pop_back_val();
     assert(I.use_empty() && "Instructions with uses are not dead.");
     assert(isInstructionTriviallyDead(&I, TLI) &&
            "Live instruction found in dead worklist!");
 
     // Don't lose the debug info while deleting the instructions.
-    salvageDebugInfo(I);
+    I.salvageDebugInfo();
 
     // 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();
       OpU.set(nullptr);
 
       if (!OpV->use_empty())
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 (llvm::any_of(AI->users(), [](User *U) -> bool {
           if (LoadInst *LI = dyn_cast<LoadInst>(U))
             return LI->isVolatile();
           if (StoreInst *SI = dyn_cast<StoreInst>(U))
             return SI->isVolatile();
           return false;
         }))
       continue;
 
+    // Try to preserve debug information attached to the instruction.
+    if (AI->getModule()->getDwarfVersion() >= 5)
+      AI->salvageDebugInfo();
+
     for (auto &AIUse : AI->uses()) {
       User *U = AIUse.getUser();
       if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
         if (AIUse.getOperandNo() == 1)
           ConvertDebugDeclareToDebugValue(DDI, SI, DIB);
       } else if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
         ConvertDebugDeclareToDebugValue(DDI, LI, DIB);
       } else if (CallInst *CI = dyn_cast<CallInst>(U)) {
         // This is a call by-value or some other instruction that takes a
         // pointer to the variable. Insert a *value* intrinsic that describes
         // the variable by dereferencing the alloca.
         DebugLoc NewLoc = getDebugValueLoc(DDI, nullptr);
         auto *DerefExpr =
             DIExpression::append(DDI->getExpression(), dwarf::DW_OP_deref);
         DIB.insertDbgValueIntrinsic(AI, DDI->getVariable(), DerefExpr, NewLoc,
                                     CI);
       }
     }
+
     DDI->eraseFromParent();
   }
   return true;
 }
 
 /// Propagate dbg.value intrinsics through the newly inserted PHIs.
 void llvm::insertDebugValuesForPHIs(BasicBlock *BB,
                                     SmallVectorImpl<PHINode *> &InsertedPHIs) {
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,
                              Instruction *InsertBefore, 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));
 }
 
-bool llvm::salvageDebugInfo(Instruction &I) {
-  SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
-  findDbgUsers(DbgUsers, &I);
-  if (DbgUsers.empty())
-    return false;
-
-  return salvageDebugInfoForDbgValues(I, DbgUsers);
-}
-
-bool llvm::salvageDebugInfoForDbgValues(
-    Instruction &I, ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
-  auto &Ctx = I.getContext();
-  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)
-      return false;
-
-    DII->setOperand(0, wrapMD(I.getOperand(0)));
-    DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
-    LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n');
-  }
-
-  return true;
-}
-
-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 =
-      [&](std::initializer_list<uint64_t> Opcodes) -> DIExpression * {
-    SmallVector<uint64_t, 8> Ops(Opcodes);
-    return doSalvage(Ops);
-  };
-
-  if (auto *CI = dyn_cast<CastInst>(&I)) {
-    // No-op casts and zexts are irrelevant for debug info.
-    if (CI->isNoopCast(DL) || isa<ZExtInst>(&I))
-      return SrcDIExpr;
-    return nullptr;
-  } else 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/deleting 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> DeleteOrSalvage;
   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 (!DeleteOrSalvage.empty()) {
     // Try to salvage the remaining debug users.
-    Changed |= salvageDebugInfo(From);
+    Changed |= From.salvageDebugInfo();
 
     // Delete the debug users which weren't salvaged.
     for (auto *DII : DeleteOrSalvage) {
       if (DII->getVariableLocation() == &From) {
         LLVM_DEBUG(dbgs() << "Erased UseBeforeDef:  " << *DII << '\n');
         DII->eraseFromParent();
         Changed = true;
       }
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

for (auto UI = AI->user_begin(), E = AI->user_end(); UI != E;) {
     LI->eraseFromParent();
     LBI.deleteValue(LI);
   }
 
   // Finally, after the scan, check to see if the store is all that is left.
   if (!Info.UsingBlocks.empty())
     return false; // If not, we'll have to fall back for the remainder.
 
+  // Try to preserve debug information attached to the dead instruction.
+  if (AI->getModule()->getDwarfVersion() >= 5)
+    AI->salvageDebugInfo();
+
   // 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();
   }
   // Remove the (now dead) store and alloca.
if (I == StoresByIndex.begin()) {
 
       LI->replaceAllUsesWith(ReplVal);
     }
 
     LI->eraseFromParent();
     LBI.deleteValue(LI);
   }
 
+  // Try to preserve debug information attached to the dead instruction.
+  if (AI->getModule()->getDwarfVersion() >= 5)
+    AI->salvageDebugInfo();
+
   // 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/dwarfdump-implicit_pointer_instcomb.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK:  DW_AT_name    ("var")
+// CHECK:  DW_TAG_variable
+// CHECK-NEXT:  DW_AT_location
+// CHECK-NEXT:  DW_OP_implicit_pointer 0x75 +0
+
+// CHECK:  DW_TAG_formal_parameter
+// CHECK-NEXT:  DW_AT_location
+// CHECK-NEXT:  DW_OP_implicit_pointer 0x75 +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/dwarfdump-implicit_pointer_mem2reg.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK:  DW_AT_name    ("arr1")
+
+// 1. Test if More than one member location list is printed 
+//    (for pointer to scalar)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x53 +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:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x68 +0
+// CHECK-NEXT:  DW_AT_name    ("ptrptr2")
+
+// 3. Test if one member location list is printed
+//    (for pointer to pointer to array)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x98 +0
+// CHECK-NEXT:  DW_AT_name    ("ptrptr3")
+//
+// 4. Test if one member location list is printed
+//    (for pointer to pointer to scalar)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0xa4 +0
+// CHECK-NEXT:  DW_AT_name    ("ptrptr1")
+
+// 5. Test if one member location list is printed
+//    (for pointer to array)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x5c +0
+// CHECK-NEXT:  DW_AT_name    ("ptr3")
+
+// 6. Test if one member location list is printed
+//    (for pointer to scalar)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x4a +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/dwarfdump-implicit_pointer_sroa.c

+// RUN: clang %s -O2 -gdwarf-5 -o %t.o
+// RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+// CHECK:  DW_AT_name    ("arr2")
+
+// 1. Test if More than 2 member location list is printed (for pointer pointing to aggregate)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x4a +0
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x4a +4)
+// CHECK-NEXT:  DW_AT_name    ("ptr1")
+
+// 2. Test if location lists are merged to two (for pointer pointing to aggregate)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_lit0, DW_OP_stack_value
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x4a +0
+// CHECK-NEXT:  DW_AT_name    ("ptr3")
+
+// 3. Test if one member location list is not omited (for pointer pointing to aggregate)
+// CHECK:       DW_AT_location        (
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x56 +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/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
+
+// 1. 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 0x5d +0
+// CHECK-NEXT:     : DW_OP_implicit_pointer 0x5d +4)
+// CHECK-NEXT:    DW_AT_abstract_origin       (0x00000040 "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/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);
   }));