[DebugInfo] Support for DW_OP_implicit_pointer (IR Verifier and Bitcode)

[alok]

Summary

This patch (4/N) stems from D69787 as suggested by @aprantl (Adrian Prantl)

Summary:
This patch adds support in IR verifier and Bitcode for DW_OP_implicit_pointer

The test case having IR with DW_OP_LLVM_implicit_pointer, will be compiled successfully

Class DwarfCompileUnit has been modified to add member ImplicitVars of vector type. Below is the usage of it.

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.

If a variable has only single DBG_VALUE then currently location list is not created instead value is used to initialized the var. In case of DW_OP_implicit_pointer, now location list will still be created.

Testing:

• Added unit test for validation thru llvm-dwarfdump
• check-llvm
• check-debuginfo (the debug info integration tests)

[aprantl]

• Can you update LangRef.rst / SourceLevelDebugging.rst to document the semantics of the DW_OP_implicit_pointer in LLVM IR. Specifically what the two arguments mean while in LLVM IR?
• You'll need to add a Verifier check that rejects DW_OP_implicit_pointer in other positions than the first one.

llvm/include/llvm/CodeGen/MachineInstr.h

484 ↗

(On Diff #228391)

I probably wouldn't surface this in MachineInstr at all and just write getDebugExpression()->isImplicitPointer(); for clarity.

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

228 ↗

(On Diff #228391)

I'm not sure this should be exposed here either.

llvm/include/llvm/IR/IntrinsicInst.h

127

Why is this necessary?

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

583

What does "later" mean in this context?
Also, please make sure to have all comments be full sentences, starting with an uppercase character and ending with a ..

[alok]

In D69999#1739404, @aprantl wrote:

• Can you update LangRef.rst / SourceLevelDebugging.rst to document the semantics of the DW_OP_implicit_pointer in LLVM IR. Specifically what the two arguments mean while in LLVM IR?

Thanks for your review. I shall update it in next revision.

• You'll need to add a Verifier check that rejects DW_OP_implicit_pointer in other positions than the first one.

I shall update it in next revision.

[alok]

llvm/include/llvm/CodeGen/MachineInstr.h

484 ↗

(On Diff #228391)

I shall update it in next revision.

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

228 ↗

(On Diff #228391)

Other option is to duplicate this function for implicit pointer only difference being the absence of first assert. Please let me know your suggestion?

llvm/include/llvm/IR/IntrinsicInst.h

127

It has call from other functions. Please let me know if i should inline the content at call-sites?

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

583

By later i meant function DwarfDebug::emitDebugLocEntry.
I shall update it in next revision.

[alok]

Updated for comments from @aprantl (Adrian Prantl)

[aprantl]

My first thought was that this might be an opportunity to finally implement explicit dbg.value arguments. (There is prior discussion of this online somewhere but I couldn't find it in my mailbox).

The idea behind a explicit dbg.value arguments is to move away from the implicit first argument of dbg.value to a format where that makes them explicit and thus more flexible.

For example, currently we would write:

call @llvm.dbg.value(%1, !DILocalVariable(name: "x"), !DIExpression(DW_OP_uconst, 4, DW_OP_plus)

which (assuming %1 compiles to reg0) may generate something like

DW_TAG_variable
  DW_AT_name("x")
  DW_AT_location(DW_OP_reg0, DW_OP_uconst, 4, DW_OP_plus)

Note the implicit first element in the DIExpression.

An explicit notation would be something like:

call @llvm.dbg.value(%1, !DILocalVariable(name: "x"), !DIExpression(DW_OP_LLVM_arg0, DW_OP_uconst, 4, DW_OP_plus)

which has the advantage that we could put DW_OP_LLVM_arg0 into places other than just the beginning of the expression.

Similarly, we could then further extend it to allow referring to more than one LLVM SSA value within an expression, using a variadic dbg.value. For example:

call @llvm.dbg.value(%1, %2, !DILocalVariable(name: "x"), !DIExpression(DW_OP_LLVM_arg0 /* %1 */ , DW_OP_uconst, DW_OP_LLVM_arg1 /* %2 */, DW_OP_plus)

This mechanism seems to apply nicely to DW_OP_implicit_pointer — applied to your testcase we'd write:

call @llvm.dbg.value(!DILocalVariable(name: "arr"), !DILocalVariable(name: "ptr"), !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 4)

I think this would make the handling of DW_OP_LLVM_implicit_pointer less magic in LLVM IR and would open the door to future features, such as the variadic dbg.value.
What do you think?
What does the debug info cabal think?

llvm/docs/LangRef.rst

4818 ↗

(On Diff #228612)

+4 is abit ambiguous. Perhaps first do a generic description, followed by an example?

4819 ↗

(On Diff #228612)

that that

4820 ↗

(On Diff #228612)

Is that an accurate description? Per DWARF5:

The DW_OP_implicit_pointer operation specifies that the object is a pointer that cannot be represented as a real pointer, even though the value it would point to can be described

llvm/docs/SourceLevelDebugging.rst

248 ↗

(On Diff #228612)

Let's move this into the paragraph in LangRef, so it's all in one place.

[dstenb]

In D69999#1741360, @aprantl wrote:

My first thought was that this might be an opportunity to finally implement explicit dbg.value arguments. (There is prior discussion of this online somewhere but I couldn't find it in my mailbox).

Perhaps https://bugs.llvm.org/show_bug.cgi?id=39141?

[aprantl]

In D69999#1741393, @dstenb wrote:

In D69999#1741360, @aprantl wrote:

My first thought was that this might be an opportunity to finally implement explicit dbg.value arguments. (There is prior discussion of this online somewhere but I couldn't find it in my mailbox).

Perhaps https://bugs.llvm.org/show_bug.cgi?id=39141?

Yes, thanks! That also explains why I didn't find it in my mailbox :-)

[alok]

In D69999#1741360, @aprantl wrote:

My first thought was that this might be an opportunity to finally implement explicit dbg.value arguments. (There is prior discussion of this online somewhere but I couldn't find it in my mailbox).

The idea behind a explicit dbg.value arguments is to move away from the implicit first argument of dbg.value to a format where that makes them explicit and thus more flexible.

For example, currently we would write:

call @llvm.dbg.value(%1, !DILocalVariable(name: "x"), !DIExpression(DW_OP_uconst, 4, DW_OP_plus)

which (assuming %1 compiles to reg0) may generate something like

DW_TAG_variable
  DW_AT_name("x")
  DW_AT_location(DW_OP_reg0, DW_OP_uconst, 4, DW_OP_plus)

Note the implicit first element in the DIExpression.

An explicit notation would be something like:

call @llvm.dbg.value(%1, !DILocalVariable(name: "x"), !DIExpression(DW_OP_LLVM_arg0, DW_OP_uconst, 4, DW_OP_plus)

which has the advantage that we could put DW_OP_LLVM_arg0 into places other than just the beginning of the expression.

Similarly, we could then further extend it to allow referring to more than one LLVM SSA value within an expression, using a variadic dbg.value. For example:

call @llvm.dbg.value(%1, %2, !DILocalVariable(name: "x"), !DIExpression(DW_OP_LLVM_arg0 /* %1 */ , DW_OP_uconst, DW_OP_LLVM_arg1 /* %2 */, DW_OP_plus)

This mechanism seems to apply nicely to DW_OP_implicit_pointer — applied to your testcase we'd write:

call @llvm.dbg.value(!DILocalVariable(name: "arr"), !DILocalVariable(name: "ptr"), !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 4)

I think this would make the handling of DW_OP_LLVM_implicit_pointer less magic in LLVM IR and would open the door to future features, such as the variadic dbg.value.
What do you think?

Your suggestion looks great. I shall include that in next revision.

What does the debug info cabal think?

llvm/docs/LangRef.rst

4818 ↗

(On Diff #228612)

Thanks, it will be updated in next revision.

4819 ↗

(On Diff #228612)

Thanks, it will be updated in next revision.

4820 ↗

(On Diff #228612)

It will be updated to incorporate your other comment to introduce DW_OP_LLVM_arg0 / DW_OP_LLVM_implicit_pointer

llvm/docs/SourceLevelDebugging.rst

248 ↗

(On Diff #228612)

It will be updated in next revision.

[alok]

Review comments from @aprantl have been incorporated.

[alok]

In D69999#1743443, @alok wrote:

Review comments from @aprantl have been incorporated.

@aprantl, do you have any more comments ?

[aprantl]

Thanks! Let's cycle back to this after the llvm-dev thread that @dblaikie started has been resolved.

[alok]

Updated to

• Rebase
• To remove trailing space
• typecasted return value of getData to uint8_t

[alok]

Updated after splitting out versions for DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_argN and llvm.dbg.derefval intrinsic.

[Orlando]

Hi @alok,

Adrian said:

Thanks! Let's cycle back to this after the llvm-dev thread that @dblaikie started has been resolved.

Reading the thread I'm not sure if it counts as having been 'resolved', so hopefully these comments are not out of place.
To help keep things running smoothly please make sure:
a) variable names are capitalised, and
b) comments are written as sentences (capitals, punctuation),

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

79

when -> When

81–82

I get what this is saying but I found it a little hard to parse, and as Adrian pointed out elsewhere 'later' is a bit vague:

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.

84

Could std::vector be llvm::SmallVector [0] here?

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

[alok]

In D69999#1758776, @Orlando wrote:

Hi @alok,

Adrian said:

Thanks! Let's cycle back to this after the llvm-dev thread that @dblaikie started has been resolved.

Reading the thread I'm not sure if it counts as having been 'resolved', so hopefully these comments are not out of place.
To help keep things running smoothly please make sure:
a) variable names are capitalised, and
b) comments are written as sentences (capitals, punctuation),

Thanks for your comments. I will update it in next version.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

79

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

81–82

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

84

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

[alok]

This is updated to incorporate review comments from @Orlando .

[StephenTozer]

llvm/include/llvm/IR/IntrinsicInst.h

128

I think this check is unnecessary - it seems like this is expected to be true for every DbgVariableIntrinsic, and this check isn't used anywhere else prior to calling getExpression().

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

45

Nit: the full stop should be replaced by a comma, and the comment immediately below should end with a full stop.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

138

The "else" can be removed, since the if block ends with a return statement.

[alok]

llvm/include/llvm/IR/IntrinsicInst.h

128

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

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

45

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

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

138

Thanks for your comment. It will be incorporated in next release.

[alok]

Updated to re-base and incorporated comments from @StephenTozer

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 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"
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();
+    }
+
     /// \name Casting methods
     /// @{
     static bool classof(const IntrinsicInst *I) {
       switch (I->getIntrinsicID()) {
       case Intrinsic::dbg_declare:
       case Intrinsic::dbg_value:
       case Intrinsic::dbg_derefval:
       case Intrinsic::dbg_addr:

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.
+  /// 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 in function DwarfDebug::emitDebugLocEntry.
+  SmallVector<const DINode *, 8> ImplicitVars;
+
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress = nullptr;
 
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
 
   /// DWO ID for correlating skeleton and split units.
public:
   DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
   }
 
   bool includeMinimalInlineScopes() const;
 
   void initStmtList();
 
+  unsigned findOrInsertImplicitVar(const DINode *Var) {
+    SmallVector<const DINode *, 8>::iterator It =
+        std::find(ImplicitVars.begin(), ImplicitVars.end(), Var);
+    if (It == ImplicitVars.end()) {
+      ImplicitVars.push_back(Var);
+      return ImplicitVars.size() - 1;
+    }
+
+    return std::distance(ImplicitVars.begin(), It);
+  }
+
+  const DINode *findImplicitVarAtIndex(unsigned Idx) const {
+    return ImplicitVars[Idx];
+  }
   /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
   void applyStmtList(DIE &D);
 
   /// 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 (Expr->isImplicitPointer()) {
+    uint64_t FirstDIEOperand = Expr->getElement(1);
+    unsigned DerefVarNum = FirstDIEOperand - dwarf::DW_OP_LLVM_arg0;
+    const DIVariable *DVI = cast<DIVariable>(MI->getOperand(DerefVarNum).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)) {
         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) {
           } 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) + (uint8_t) Data.getData()[J];
+        // get the variable and compute the actual offset
+        const DINode *ImpVar = CU->findImplicitVarAtIndex(ValOffset);
+        DIE *Die = CU->getDIE(ImpVar);
+        if (Die)
+          ValOffset = Die->getDebugSectionOffset();
+
+        // emit the actual offset
+        for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J) {
+          Streamer.EmitInt8(ValOffset & 0xff,
+                            Comment != End ? *(Comment++) : "");
+          ValOffset = ValOffset >> 8;
+        }
       } else {
         for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
           Streamer.EmitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
       }
       Offset = Op.getOperandEndOffset(I);
     }
     assert(Offset == Op.getEndOffset());
   }
 }
 
 void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                                    const DbgValueLoc &Value,
-                                   DwarfExpression &DwarfExpr) {
+                                   DwarfExpression &DwarfExpr,
+                                   DwarfCompileUnit &TheCU) {
   auto *DIExpr = Value.getExpression();
   DIExpressionCursor ExprCursor(DIExpr);
   DwarfExpr.addFragmentOffset(DIExpr);
   // Regular entry.
   if (Value.isInt()) {
     if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
                BT->getEncoding() == dwarf::DW_ATE_signed_char))
       DwarfExpr.addSignedConstant(Value.getInt());
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();
   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;
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_LLVM_implicit_pointer &&
+         "not dwarf::DW_OP_LLVM_implicit_pointer");
+
+  emitOp(dwarf::DW_OP_implicit_pointer);
+  // This is a dummy offset which will be replaced with actual offset in
+  // function DwarfDebug::emitDebugLocEntry.
+  emitAddressRef(ValOffset);
+  emitSigned(Op->getArg(1));
+  return;
+}

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/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/test/DebugInfo/implicit_pointer_fast.ll

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

llvm/test/DebugInfo/implicit_pointer_global.ll

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