[Debuginfo][Codegen] (2/7) Support for DW_OP_implicit_pointer for named and unnamed variables (second strategy).

[alok]

Summary

This patch stems from D84112.
This patch includes changes for CodeGen phase.

[jmorse]

I sense this is the bulk of the work; and it looks good. I've posted on llvm-dev asking whether the creation of artificial variables could instead be deferred til DWARF emission. That'll avoid anything having to deal with a new form of DBG_VALUE, and us having to think about their lifetimes. Plus, there's greater scope for de-duplication, as I understand it this patch will generate a new artificial variable for each dbg.value, for each level of indirection.

On that topic -- do we need to give the artificial variable a name? I'm no DWARF expert, but can we just not attach a DW_AT_name to the DIE?

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

250–252

I think the preferred form is !MI->isDebugValue() || static_cast...., i.e., the assertion always passes if the MI isn't a DBG_VALUE, or if it is, the getDebugImplicitVariable() part is tested. This avoids the reader having to consider an un-necessary ternary operator.

254–256

(Same as above)

llvm/include/llvm/IR/DIBuilder.h

647–654

This'll want a docu-comment as to createImplicitTempVariable's purpose.

llvm/include/llvm/IR/DebugInfoMetadata.h

2705

nit: Full stops at ends of comments, here and elsewhere.

2711

"indirection"

llvm/include/llvm/IR/IntrinsicInst.h

131

Doc comment needed too please.

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

69–71

Shouldn't this be in the union?

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

83–85

86

Would it be possible to use a subtype of DINode instead, such as DIVariable? That'll increase type safety and make it clearer what's going on.

135

I'd suggest the return type can be auto here.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2477

I reckon it's better to assert(Die);, there should be no scenarios where the implicit pointer DIE isn't emitted, right? Otherwise, if this if condition is false, you'll write the unmodified ValOffset into the output dwarf, which could be misleading.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1260–1261

NB: this function definitely needs some comments in it as to what's going on.

1268

Better to test for Level==0 and have the normal-dbg-value case return early; then the rest of this function doesn't need an extra level of indentation / scope.

1328

Correct me if I'm wrong, but isn't generation of DW_OP_LLVM_implicit_pointer only done during instruction selection? If so, can we not reject implicit_pointer expressions at this stage as being illegal IR?

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

114–121

It looks like this contradicts the immediately preceeding comment, could you update the comment please?

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

5–13

Don't both ptr and ptrVar become implicit pointers? Does this lead to two implicit_ptr_tmp variables being created?

It'd also be good to capture/compare the operand to DW_OP_implicit_pointer to the DIE address that it refers to, to confirm that it points to the correct place.

8

CHECK-NEXT: DW_AT_name "ptrVar"?

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

6

Again, in this test it would be good to ensure that DW_OP_implicit_pointer points at the correct DIE. If the intention here is to only test for multiple levels of implicit pointer, it's probably sufficient to only check one variable.

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

4

It'd be good to test for non-zero offsets into an implicit variable -- i.e., in the original C, have ptr3 something like:

ptr3 = &arr1[1];

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

8–12

So, there'll be a DW_OP_implicit_pointer for each value a pointer-variable can point at, rather than one DW_OP_implicit_pointer and two entries in the variable/location-list it refers to?

(This might not be the most efficient way of doing it; maybe it's sufficient for now though).

[alok]

Updated to re-base and include many comments from @jmorse .

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

680

Can we add support for GNU extension as well in getDwarf5OrGNULocationAtom() ?

[djtodoro]

llvm/include/llvm/IR/DebugInfoMetadata.h

2715

early continue?

llvm/include/llvm/IR/IntrinsicInst.h

163

true/false but the return val is unsigned?

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

53

intentional change?

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

142

static_cast might be better

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1835

missing . at the end

2469

same here

2471

please refactor these comments

[alok]

Updated to incorporate comments from @djtodoro .

[jmorse]

A few more comments inline. I think everything in this patch works; there's still an open question in my mind of why we need to create the implicit variables so early, during instruction selection. Isn't it sufficient to leave a:

dbg.value(0, !123, !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_implicit_pointer)

In exactly the same form through the MIR phases:

DBG_VALUE 0, $noreg, !123, !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_implicit_pointer)

And then create the implicit variables at a later stage? That would avoids a number of SelectionDAG changes, plus global and fast isel too.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

86

Thinking about it, would UniqueVector be a more appropriate data structure? It's more heavy weight, but contains a map for quick lookup of elements. findOrInsertImplicitVar below uses std::find which is O(n), which isn't going to scale well.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

264–265

getDebugImplicitVariable?

llvm/lib/CodeGen/CodeGenPrepare.cpp

1222

Not clear why this is here -- slipped in by accident? If not, is there a reason why we shouldn't be salvaging these casts? Same below.

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

49

Doxygen for this field please

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1260–1261

Comment-ping on this :)

1287–1295

An illegal input to this loop would be a multi-level implicit pointer expression, and a variable type that has less indirection. IMO, there should be an assertion that this doesn't happen, to avoid it being silently accepted. Not sure where to put it though -- assert that Type is a DIDerivedType each time?

[dblaikie]

In D84115#2184545, @jmorse wrote:

I sense this is the bulk of the work; and it looks good. I've posted on llvm-dev asking whether the creation of artificial variables could instead be deferred til DWARF emission. That'll avoid anything having to deal with a new form of DBG_VALUE, and us having to think about their lifetimes. Plus, there's greater scope for de-duplication, as I understand it this patch will generate a new artificial variable for each dbg.value, for each level of indirection.

On that topic -- do we need to give the artificial variable a name? I'm no DWARF expert, but can we just not attach a DW_AT_name to the DIE?

I haven't looked closely at the code - but "do it later" sounds like the right theory to me. I believe the absence of a name is probably OK - there are unnamed types, for instance, so unnamed variables seem fine too. But some testing with real debuggers would be useful.

[jryans]

@alok, I know it's been a while here... Do you plan to resume working on this feature at some point?

The current status is a bit confusing, given that only the IR side has landed. I was going to start a Discourse thread about the feature's status in general, but I couldn't find your username over there, so I thought I would check in here first.

[alok]

In D84115#4607280, @jryans wrote:

@alok, I know it's been a while here... Do you plan to resume working on this feature at some point?

The current status is a bit confusing, given that only the IR side has landed. I was going to start a Discourse thread about the feature's status in general, but I couldn't find your username over there, so I thought I would check in here first.

In D84115#4607280, @jryans wrote:

@alok, I know it's been a while here... Do you plan to resume working on this feature at some point?

The current status is a bit confusing, given that only the IR side has landed. I was going to start a Discourse thread about the feature's status in general, but I couldn't find your username over there, so I thought I would check in here first.

Yes, I plan to resume on this once I get some time to address concerns.

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())) &&
+           "first MDNode argument of a DBG_VALUE not a DIVariable");
+    assert((!MI->isDebugLabel() || static_cast<bool>(MI->getDebugLabel())) &&
+           "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);
 
+    /// Create a temporary variable.
+    ///
+    /// \c Scope must be a \a DILocalScope, and thus its scope chain eventually
+    /// leads to a \a DISubprogram.
+    DILocalVariable *createImplicitTempVariable(DIScope *Scope, DIType *Ty,
+                                                uint32_t AlignInBits = 0);
+
     /// 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 indirection levels.
+  unsigned implicitPointerCount() const {
+    unsigned Count = 0;
+    for (unsigned i = 0; i < getNumElements(); ++i) {
+      if (Elements[i] == dwarf::DW_OP_LLVM_implicit_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/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;
 
   /// 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 implicitPointerCount() const {
+    if (!isa<DIExpression>(getRawExpression()))
+      return false;
+
+    return getExpression()->implicitPointerCount();
+  }
+
   /// \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/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 the index of dereferenced object's at first operand of
+  // DW_OP_implicit_pointer operation temporarily. This temporary value is later
+  // replaced by the actual value in function DwarfDebug::emitDebugLocEntry.
+  SmallVector<const DIVariable *, 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();
 
+  auto findOrInsertImplicitVar(const DIVariable *Var) {
+    SmallVector<const DIVariable *, 8>::iterator It =
+        std::find(ImplicitVars.begin(), ImplicitVars.end(), Var);
+    if (It == ImplicitVars.end()) {
+      ImplicitVars.push_back(Var);
+      return ImplicitVars.size() - 1;
+    }
+
+    return (long unsigned)std::distance(ImplicitVars.begin(), It);
+  }
+
+  const DIVariable *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);
 
   /// If the \p File has an MD5 checksum, return it as an MD5Result
   /// allocated in the MCContext.
   Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const;
 };
 
 } // 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,
                                               llvm::Register 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 (validThroughout(LScopes, MInsn, End, getInstOrdering())) {
         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->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 DIVariable *ImpVar = CU->findImplicitVarAtIndex(ValOffset);
+        DIE *Die = CU->getDIE(ImpVar);
+        assert(Die && "Die can not be NULL");
+        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()) {
if (AP.getDwarfVersion() >= 4 && !AP.getDwarfDebug()->tuneForSCE()) {
       DwarfExpr.addUnsignedConstant(
           Value.getConstantFP()->getValueAPF().bitcastToAPInt());
     else
       LLVM_DEBUG(
           dbgs()
           << "Skipped DwarfExpression creation for ConstantFP of size"
           << Value.getConstantFP()->getValueAPF().bitcastToAPInt().getBitWidth()
           << " bits\n");
+  } else if (Value.isImplicitPtr()) {
+    const llvm::DIVariable *ImpVar = Value.getImplicitPointer();
+    unsigned long 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 (const 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,
                        llvm::Register 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,
                        llvm::Register 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(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/VarLocBasedImpl.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 VarLocBasedLDV.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() || isDebugRef()) && "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() || isDebugRef()) && "not a DBG_VALUE");
   return cast<DIExpression>(getOperand(3).getMetadata());
 }
 
 bool MachineInstr::isDebugEntryValue() const {
   return isDebugValue() && getDebugExpression()->isEntryValue();
 }

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/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.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) {
   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->implicitPointerCount();
+  if (Level == 0) {
+    return handleDebugValue(V, Variable, Expression, dl, DI.getDebugLoc(),
+                            SDNodeOrder);
+  }
+
+  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;
+
+  PtrVars.push_back(Variable);
+  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);
+  }
+
+  SmallVector<uint64_t, 3> Ops;
+  DIExpression *DE = DIExpression::get(Expression->getContext(), Ops);
+
+  if (!handleDebugValue(V, PtrVars[Level], DE, dl, DI.getDebugLoc(),
+                        SDNodeOrder))
+    return false;
+
+  Count = Level;
+  while (Count-- > 0) {
+    DE = DIExpression::get(DE->getContext(),
+                           {dwarf::DW_OP_LLVM_implicit_pointer});
+
+    SDDbgValue *SDV = DAG.getImpPtrDbgValue(
+        PtrVars[Count], DE, PtrVars[Count + 1], dl, SDNodeOrder);
+    DAG.AddDbgValue(SDV, nullptr, false);
+  }
+
+  return true;
+}
+
 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 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);
       // Do not attach the SDNodeDbgValue to an SDNode: this variable location
       // is still available even if the SDNode gets optimized out.
       DAG.AddDbgValue(SDV, nullptr, false);
       return true;
     }
   }
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

DWARFLocationInterpreter::Interpret(const DWARFLocationEntry &E) {
   }
 }
 
 static void dumpExpression(raw_ostream &OS, DIDumpOptions DumpOpts,
                            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.
+  // In case (DWARFUnit) U is non NULL lets deduce the format and pass
+  // to DWARFExpression
+  if (U)
+    DWARFExpression(Extractor, AddressSize, U->getFormParams().Format)
+        .print(OS, DumpOpts, MRI, U);
+  else
     DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, 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 {
   DWARFLocationInterpreter Interp(

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/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/test/DebugInfo/X86/dwarfdump-implicit_pointer_instcomb.ll

+; RUN: llc %s -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL: DW_AT_name      ("func")
+; CHECK-LABEL:  DW_TAG_formal_parameter
+; CHECK: 0x000000[[IMPLICITDIE2:[0-9a-f]+]]:     DW_TAG_variable
+
+; CHECK-LABEL: DW_TAG_subprogram
+; CHECK-LABEL: DW_AT_name      ("main")
+; CHECK: 0x000000[[IMPLICITDIE1:[0-9a-f]+]]:     DW_TAG_variable
+; CHECK: DW_AT_const_value     (4)
+; CHECK-LABEL: DW_AT_artificial
+; CHECK:  DW_AT_location
+; CHECK-NEXT:  DW_OP_implicit_pointer 0x[[IMPLICITDIE1]] +0
+; CHECK-NEXT:  DW_AT_name ("ptrVar")
+
+; CHECK-LABEL: DW_TAG_inlined_subroutine
+; CHECK:  DW_TAG_formal_parameter
+; CHECK-NEXT:  DW_AT_location
+; CHECK-NEXT:  DW_OP_implicit_pointer 0x[[IMPLICITDIE2]] +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_implicit_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_implicit_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.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_6")
+; 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_4")
+; 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_implicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 5, metadata !24, metadata !DIExpression(DW_OP_LLVM_implicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 2, metadata !25, metadata !DIExpression(DW_OP_LLVM_implicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 4, metadata !26, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_implicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 5, metadata !28, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_implicit_pointer)), !dbg !30
+  call void @llvm.dbg.value(metadata i32 2, metadata !29, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_implicit_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.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_implicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 6, metadata !23, metadata !DIExpression(DW_OP_LLVM_implicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 1, metadata !24, metadata !DIExpression(DW_OP_LLVM_implicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 2, metadata !21, metadata !DIExpression(DW_OP_LLVM_implicit_pointer)), !dbg !31
+  call void @llvm.dbg.value(metadata i32 2, metadata !24, metadata !DIExpression(DW_OP_LLVM_implicit_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_implicit_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_implicit_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_implicit_pointer)), !dbg !25
+  call void @llvm.dbg.value(metadata i32 3, metadata !21, metadata !DIExpression(DW_OP_LLVM_implicit_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_implicit_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_implicit_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.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_implicit_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_implicit_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)