[DebugInfo] Support for DW_OP_implicit_pointer (CodeGen phase)

[alok]

Summary

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

The original patch is being divided as described below.

CodeGen / DwarfInfo-emission phase of the implementation works on IR with DW_OP_implicit_pointer operation to emit debug info. this will have two patch (PATCH 1-2). PATCH-1 has changes for IR Verify and Bitcode changes. The current patch (PATCH-2) will complete the modification for Codegen. It also contains test cases with IR generated with future patches.

IR transformation phase of the implementation deals with preserving debug info while instruction is being erased (optimized out) in IR transformation phase. In this phase all the opportunities to generate DW_OP_implicit_pointer operation in IR, are found and handled appropriately. For this phase multiple patches will be submitted.

PATCH 3) Enhance salvaging implementation to generate DW_OP_implicit_pointer operation
PATCH 4-N) All the opportunities to preserve debug info are dealt with (to support various optimizations)

Current PATCH is PATCH-2. Once this gets accepted, PATCH-3 will be submitted.
After PATCH-3 gets accepted, PATCH 4-N can be submitted independently.

 Summary:

  This patch completes the back-end support for DW_OP_implicit_pointer operation. When it receives IR with DW_OP_LLVM_implicit_pointer operator, it processes that to generate proper debug-info. It generates location lists having DW_OP_implicit_pointer operations.

Testing:
 
   - Added unit tests (with IR generated from future patches) for validation thru llvm-dwarfdump
   - check-llvm, and an end-to-end test using gnu GDB to debug an optimized program (LLDB need to be enhanced to support).
   - check-debuginfo (the debug info integration tests)

[jmorse]

Hi Alok,

Thanks for splitting up the patch and tests; I'm not very familiar with implicit pointers and I'm still working it through my mind, so I have a couple of questions if you'll bear with me. At the moment though, it looks like implicit-pointer dbg.value insts refer directly to DILocalVariables -- this will become a problem if the same function is inlined twice, as there's nothing to distinguish which inlining instance the dbg.value refers to. You can probably make a metadata pair of {DILocalVariable, DILocation} where the DILocation is the inlining location, and use that as the operand of the dbg.value instead. There should also be a test for multiple inlining instances too.

Looking at the tests, am I right in thinking that the "target" of the implicit pointer can change throughout the function? For example

int a = 0, b = 1, c = 2;
int *foo = &a;
call();
foo = &b;
call();
foo = &c;

Is it (theoretically) possible to describe promoted non-local variables with implicit pointers? LLVM will occasionally promote an in-memory value into a register, after which there's no way for current debuginfo to describe where it is.

The code looks like a good start, although I don't know anything about the DWARF backend.

llvm/test/DebugInfo/dwarfdump-implicit_pointer_instcomb.ll

2

I don't believe running clang in an internal LLVM test is supported, this should probably be running llc -O2 -filetype=obj instead? Same with the other tests.

47

Assuming these attributes are un-necessary, they should be dropped as they can be an extra maintenance burden.

[alok]

In D69886#1735632, @jmorse wrote:

Hi Alok,

Thanks for splitting up the patch and tests; I'm not very familiar with implicit pointers and I'm still working it through my mind, so I have a couple of questions if you'll bear with me. At the moment though, it looks like implicit-pointer dbg.value insts refer directly to DILocalVariables -- this will become a problem if the same function is inlined twice, as there's nothing to distinguish which inlining instance the dbg.value refers to. You can probably make a metadata pair of {DILocalVariable, DILocation} where the DILocation is the inlining location, and use that as the operand of the dbg.value instead. There should also be a test for multiple inlining instances too.

Thanks a lot for taking your time to review this, let me try to answer this, actually the functionality of DW_OP_implicit_pointer is to preserve the dereferenced values of optimized out variables, it doesnt preserve the location information. Our interest is to emit first operand which is offset of target variable within debuginfo dwarf section. We preserve DILocalVariable (temporarily) until debug info section is formed and variable's offset within it is known. Please let me know in case I misunderstood the question.

Sure, I shall add a test case.

Looking at the tests, am I right in thinking that the "target" of the implicit pointer can change throughout the function? For example

int a = 0, b = 1, c = 2;
int *foo = &a;
call();
foo = &b;
call();
foo = &c;

Yes, it is possible.

Is it (theoretically) possible to describe promoted non-local variables with implicit pointers? LLVM will occasionally promote an in-memory value into a register, after which there's no way for current debuginfo to describe where it is.

If a variable is a pointer and is eligible to have DW_AT_location attribute (in dwarf), then theoretically it should be possible to describe this attribute using DW_OP_implicit_pointer. Current patch covers for local variables only, we can investigate for non local variables later

The code looks like a good start, although I don't know anything about the DWARF backend.

Thanks again for your comments.

llvm/test/DebugInfo/dwarfdump-implicit_pointer_instcomb.ll

2

Thanks for pointing it out. I shall incorporate this comment.

47

Thanks. I shall incorporate this comment.

[alok]

This is to incorporate review comments.

• To use llc in place of clang in tests
• To delete unnecessary attributes from tests

[vsk]

Hey @alok, thanks for working on this.

Currently, the operands of dbg.value constitute a {value, variable, expression} tuple. This patch seems to change that to {value | variable-to-be-deref'd, variable, expression | expression-with-implicit-pointer}. What alternatives have you considered? While reading your tests, I found it hard to reason about how implicit pointer values are referenced & defined. This made me concerned about the amount of hidden state that the current approach would introduce into IR. Further, I'm not really convinced this does the right thing in the presence of inlining (at least, not yet). And I'm keen to avoid extending SelectionDAG to represent implicit pointer debug values, as that presumably creates work on the GlobalISel side as well.

One possible alternative (haven't fully thought this through yet, but here goes!) might be to have dbg.value(value, variable, expr) return a token value, instead of void. That token could then be referenced later, like: dbg.value(%implicit_pointer_token, <variable>, DIExpression(DW_OP_implicit_pointer(<offset>))). The main advantage of this is that it makes the link between a description of the implicit pointer and its dereference explicit. I think this will be a lot easier to reason about. But there are more concrete benefits. E.g., if a pass were to move the DW_OP_implicit_pointer dbg.value before the def of its implicit pointer token, we'd detect the use-before-def instead of silently emitting the wrong value.

p.s: Could you number your patches (e.g. [1/3], [2/3], etc) to make them easier to find? Could you also make the tests for each patch independent so that they can be landed incrementally?

llvm/test/DebugInfo/dwarfdump-implicit_pointer_instcomb.ll

2

Please include the original C source when applicable, so that future authors have steps to regenerate the test if needed.

llvm/test/DebugInfo/dwarfdump-implicit_pointer_mem2reg.ll

8

Please only capitalize words where necessary.

10

"arr1" is metadata !18, right? Where does lit0 come from?

12

Please structure your checks as:

; <description of test 1>
; CHECK-LABEL: DW_AT_name  (<variable name>)
; CHECK-NEXT: ...

; <description of test 2>
...

llvm/test/DebugInfo/dwarfdump-implicit_pointer_sroa_inline.ll

10

Please avoid hardcoding constants in check lines. If the specific constant isn't important, don't match it. Otherwise, you can capture it with a filecheck variable, e.g.:

DW_OP_implicit_pointer [[DIE:0x.+]] +0
DW_OP_implicit_pointer [[DIE]] +4

[dblaikie]

Apologies for not having enough time to review this in more detail at the moment, so this feedback is shorting from the hip slightly based on reading the existing conversations and patch description

Broadly:

I'd expect more than 3 patches and in this order:

1. Backend/DWARF emission support for new debug info IR/metadata/intrinsic usage/DW_OP operators. This should include tests with hand-crafted IR (or generated from future patches - but I think this should be narrow enough that a small example could be given mostly with IR generated from clang/LLVM, and only a minor edit to use the new feature)

2-N) Individual patches, one for each optimization that generates this new representation where possible/useful - each one of these patches should be independent and include tests for the change (tests that are IR->IR tests, testing only the specific optimization)

(the 2-N patches can't come before (1) or the trunk would be broken by passes generating IR that the DWARF backend could not handle)

@probinson @aprantl - do you folks know why implicit_pointer needs to point to another DIE, rather than describing bytes directly? I guess it's intended to handle void*, for instance? (where the type information for the pointee isn't present in the pointer type) But for something like int* if the int isn't in memory (so can't be pointed to) - say, it's in a register, I'd expect to describe the value of the int without any extra DIE references, etc? (who knows if the DIE is in a variable/described by any other DIE). I'm pretty confused by the way this DWARF feature is spec'd & wondering if we should avoid implementing it/instead implement a better extension? But quite possible there's things about the design that I don't understand.

[probinson]

In D69886#1736266, @dblaikie wrote:

I'd expect more than 3 patches and in this order:

+1.

@probinson @aprantl - do you folks know why implicit_pointer needs to point to another DIE, rather than describing bytes directly? I guess it's intended to handle void*, for instance? (where the type information for the pointee isn't present in the pointer type) But for something like int* if the int isn't in memory (so can't be pointed to) - say, it's in a register, I'd expect to describe the value of the int without any extra DIE references, etc? (who knows if the DIE is in a variable/described by any other DIE). I'm pretty confused by the way this DWARF feature is spec'd & wondering if we should avoid implementing it/instead implement a better extension? But quite possible there's things about the design that I don't understand.

I think the main use-case was for when a pointed-to object is optimized into registers (which don't have addresses), but the pointed-to values are easily found. For example if you have a function that takes a pointer-to-object, and is then inlined, and the optimizer decides it doesn't need the object to be in memory after all. If values from the "pointed-to" object are still findable, you probably know what object that was originally, and so implicit_pointer can refer to that object's DIE. Among other things, this indirection has an advantage if the "pointed-to" object moves around; the pointed-to object's locations are tracked in the pointed-to object's DIE, and the pointer DIE just says "ask that DIE where it is right now."

It might possibly be helpful to read the proposal (http://dwarfstd.org/ShowIssue.php?issue=100831.1) where the first example is a bit more compelling than the examples that made it into the spec, unfortunately.

Note that I have not read this patch, or the others.

[alok]

In D69886#1736266, @dblaikie wrote:

Apologies for not having enough time to review this in more detail at the moment, so this feedback is shorting from the hip slightly based on reading the existing conversations and patch description

Broadly:

I'd expect more than 3 patches and in this order:

1. Backend/DWARF emission support for new debug info IR/metadata/intrinsic usage/DW_OP operators. This should include tests with hand-crafted IR (or generated from future patches - but I think this should be narrow enough that a small example could be given mostly with IR generated from clang/LLVM, and only a minor edit to use the new feature)

Agree. Fortunately the current patch (submitted first) contains support for DWARF emission. The current patch also has the testcases with IR generated from future patches.

2-N) Individual patches, one for each optimization that generates this new representation where possible/useful - each one of these patches should be independent and include tests for the change (tests that are IR->IR tests, testing only the specific optimization)

Agree. I am working on splitting this way. I plan to submit second patch (after first patch gets place in trunk) which will include enhanced salvaging debug info utilities to be used (called) in different optimizations. once this second patch goes thru. the remaining individual patches for each optimization will be posted for review.
Please let me know if it sounds good. Thanks for your suggestions @dblaikie.

(the 2-N patches can't come before (1) or the trunk would be broken by passes generating IR that the DWARF backend could not handle)

Agree. I will hold other patches till (1) gets approved.

@probinson @aprantl - do you folks know why implicit_pointer needs to point to another DIE, rather than describing bytes directly? I guess it's intended to handle void*, for instance? (where the type information for the pointee isn't present in the pointer type) But for something like int* if the int isn't in memory (so can't be pointed to) - say, it's in a register, I'd expect to describe the value of the int without any extra DIE references, etc? (who knows if the DIE is in a variable/described by any other DIE). I'm pretty confused by the way this DWARF feature is spec'd & wondering if we should avoid implementing it/instead implement a better extension? But quite possible there's things about the design that I don't understand.

[alok]

llvm/test/DebugInfo/dwarfdump-implicit_pointer_mem2reg.ll

8

Sure. I shall incorporate this in next version.

10

In the source program -

int *ptr2 = 0;

In IR it is represented as -

call void @llvm.dbg.value(metadata i32* null, metadata !24, metadata !DIExpression()), !dbg !30
!24 = !DILocalVariable(name: "ptr2", scope: !12, file: !3, line: 51, type: !23)

Without current patch DIE for ptr2 would look like -

0x00000068: DW_TAG_variable

DW_AT_const_value     (0)
DW_AT_name    ("ptr2")
DW_AT_decl_file       ("/home/alok/mem2reg.c")
DW_AT_decl_line       (8)
DW_AT_type    (0x000000ab "int*")

• Please note that ptr2 is initialized to null (DW_AT_const_value (0))

With current patch -

0x00000068: DW_TAG_variable

DW_AT_location        (0x00000019
   [0x0000000000400480, 0x0000000000400487): DW_OP_lit0, DW_OP_stack_value
   [0x0000000000400487, 0x0000000000400494): DW_OP_implicit_pointer 0x53 +0)
DW_AT_name    ("ptr2")
DW_AT_decl_file       ("Inputs/dwarfdump-implicit_pointer_mem2reg.c")
DW_AT_decl_line       (8)
DW_AT_type    (0x000000c1 "int*")

• Please note that, now DIE has two values (in different code ranges), so in place of initializing it uses Location list.

12

Thanks for the input, I will incorporate this in next version.

llvm/test/DebugInfo/dwarfdump-implicit_pointer_sroa_inline.ll

10

Thanks for the input. I shall incorporate this in next version.

[alok]

This update includes incorporation of review comments from Vedant Kumar (@vsk)

[alok]

llvm/test/DebugInfo/dwarfdump-implicit_pointer_instcomb.ll

2

Incorporated this comment.

llvm/test/DebugInfo/dwarfdump-implicit_pointer_mem2reg.ll

8

Incorporated this comment.

[djtodoro]

@alok Thanks for doing this. I just put advices on how to make your tests shorter, so please address them in the other tests as well.

llvm/test/DebugInfo/dwarfdump-implicit_pointer_instcomb.ll

39

TBAA metadata are usually unnecessary as well, so I think you can delete it.

45

Since you dropped the attributes, we can delete those '#2' (#N) from the testcase.

53

producer: "clang version 10.0.0" is enough.

54

We usually make tests as short as possible, so my advice is to avoid your exact path from local PC here, you can just put "/dir".

62

producer: "clang version 10.0.0" is enough.

[alok]

llvm/test/DebugInfo/dwarfdump-implicit_pointer_instcomb.ll

39

Thanks for your tricks. I will incorporate this in next version.

45

I shall incorporate this in next version.

53

I shall incorporate this in next version.

54

I shall incorporate this in next version.

62

I shall incorporate this in next version.

[alok]

In D69886#1736660, @djtodoro wrote:

@alok Thanks for doing this. I just put advices on how to make your tests shorter, so please address them in the other tests as well.

Thanks a lot for your time and tricks as well. I shall be apply those in next version.

[alok]

Updated for comments from @djtodoro (Djordje Todorovic) to apply tricks to shorten the tests

[dstenb]

Thanks for adding the source reproducers; however, they are typically not stored as separate files (with one exception being tests operating on binary files). Feel free to inline the C code as comments in the IR files though!

[aprantl]

Could you please split off a patch just adds the IR, Bitcode and verifier support from this review into a separate one? That one should be very straightforward to review & land and it will make the rest easier.

[alok]

This version is updated for comment of David Stenberg (@dstenb)
(removed original reproducer c programs and added those in test cases itself as comments)

[alok]

In D69886#1736833, @dstenb wrote:

Thanks for adding the source reproducers; however, they are typically not stored as separate files (with one exception being tests operating on binary files). Feel free to inline the C code as comments in the IR files though!

Thanks for your comment. I have incorporated your comment.

[alok]

In D69886#1736182, @vsk wrote:

Hey @alok, thanks for working on this.

Thanks Vedant for your time in reviewing this.

Currently, the operands of dbg.value constitute a {value, variable, expression} tuple. This patch seems to change that to {value | variable-to-be-deref'd, variable, expression | expression-with-implicit-pointer}. What alternatives have you considered? While reading your tests, I found it hard to reason about how implicit pointer values are referenced & defined. This made me concerned about the amount of hidden state that the current approach would introduce into IR. Further,

While implementing this, my priority was to avoid changing the interface of dbg.value which is

declare void @llvm.dbg.value(metadata, metadata, metadata)

Which permits to have another variable metadata at first argument. Since DW_OP_implicit_pointer suggests that check the value of (optimized out) variable at another variable. Last argument is expression, which can be used to identify that first argument is redirection variable (using isImplicitPointer()). For example

call void @llvm.dbg.value(metadata !16, metadata !25, metadata !DIExpression(DW_OP_implicit_pointer, 0)), !dbg !31
!16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 24, type: !17)
!25 = !DILocalVariable(name: "ptr", arg: 1, scope: !26, file: !3, line: 15, type: !29)

which suggests, "ptr" is optimized out but its value is same as "arr", check "arr"

I'm not really convinced this does the right thing in the presence of inlining (at least, not yet).

Currently I have two test cases which test the implementation for inlining. Handling of inilining is done in future patch (IR transformation phase). I can explain it later once I submit that patch. Please do share any scenario which you think should be considered.

And I'm keen to avoid extending SelectionDAG to represent implicit pointer debug values, as that presumably creates work on the GlobalISel side as well.

One possible alternative (haven't fully thought this through yet, but here goes!) might be to have dbg.value(value, variable, expr) return a token value, instead of void. That token could then be referenced later, like: dbg.value(%implicit_pointer_token, <variable>, DIExpression(DW_OP_implicit_pointer(<offset>))). The main advantage of this is that it makes the link between a description of the implicit pointer and its dereference explicit. I think this will be a lot easier to reason about. But there are more concrete benefits. E.g., if a pass were to move the DW_OP_implicit_pointer dbg.value before the def of its implicit pointer token, we'd detect the use-before-def instead of silently emitting the wrong value.

Alternatively, what approach i have taken is to identify the kind of first argument based on third argument, and that solves the same purpose (using function isImplicitPointer()). Code movement part is handled in IR transformation phase (future patch). Please let me know if you have any scenario that should be considered. please let me know in case i did not understand anything.

p.s: Could you number your patches (e.g. [1/3], [2/3], etc) to make them easier to find? Could you also make the tests for each patch independent so that they can be landed incrementally?

Sure I shall keep this in mind.

[alok]

In D69886#1738047, @aprantl wrote:

Could you please split off a patch just adds the IR, Bitcode and verifier support from this review into a separate one? That one should be very straightforward to review & land and it will make the rest easier.

Thank you @aprantl for you suggestion. I have raised D69999 for this.

[alok]

This patch is updated post split. part of it went to D69999, which is also the dependency for current patch. (for current patch to work, D69999 is needed)

[alok]

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

[alok]

Updated to re-base and included some changes separated from D70644 to keep similar changes together as suggested by @jmorse.

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/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())
     Expr = DIExpression::append(Expr, {dwarf::DW_OP_deref});

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

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

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

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

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

class SelectionDAGBuilder {
   DenseMap<const Value*, SDValue> NodeMap;
 
   /// Maps argument value for unused arguments. This is used
   /// to preserve debug information for incoming arguments.
   DenseMap<const Value*, SDValue> UnusedArgNodeMap;
 
   /// Helper type for DanglingDebugInfoMap.
   class DanglingDebugInfo {
-    const DbgValueInst* DI = nullptr;
+    const DbgVariableIntrinsic *DI = nullptr;
     DebugLoc dl;
     unsigned SDNodeOrder = 0;
 
   public:
     DanglingDebugInfo() = default;
-    DanglingDebugInfo(const DbgValueInst *di, DebugLoc DL, unsigned SDNO)
+    DanglingDebugInfo(const DbgVariableIntrinsic *di, DebugLoc DL,
+                      unsigned SDNO)
         : DI(di), dl(std::move(DL)), SDNodeOrder(SDNO) {}
 
-    const DbgValueInst* getDI() { return DI; }
+    const DbgVariableIntrinsic *getDI() { return DI; }
     DebugLoc getdl() { return dl; }
     unsigned getSDNodeOrder() { return SDNodeOrder; }
   };
 
   /// Helper type for DanglingDebugInfoMap.
   typedef std::vector<DanglingDebugInfo> DanglingDebugInfoVector;
 
   /// Keeps track of dbg_values for which we have not yet seen the referent.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

#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::resolveDanglingDebugInfo(const Value *V,
                                                    SDValue Val) {
   auto DanglingDbgInfoIt = DanglingDebugInfoMap.find(V);
   if (DanglingDbgInfoIt == DanglingDebugInfoMap.end())
     return;
 
   DanglingDebugInfoVector &DDIV = DanglingDbgInfoIt->second;
   for (auto &DDI : DDIV) {
-    const DbgValueInst *DI = DDI.getDI();
+    const DbgVariableIntrinsic *DI = DDI.getDI();
     assert(DI && "Ill-formed DanglingDebugInfo");
     DebugLoc dl = DDI.getdl();
     unsigned ValSDNodeOrder = Val.getNode()->getIROrder();
     unsigned DbgSDNodeOrder = DDI.getSDNodeOrder();
     DILocalVariable *Variable = DI->getVariable();
     DIExpression *Expr = DI->getExpression();
     assert(Variable->isValidLocationForIntrinsic(dl) &&
            "Expected inlined-at fields to agree");
if (Val.getNode()) {
           DAG.getConstantDbgValue(Variable, Expr, Undef, dl, DbgSDNodeOrder);
       DAG.AddDbgValue(SDV, nullptr, false);
     }
   }
   DDIV.clear();
 }
 
 void SelectionDAGBuilder::salvageUnresolvedDbgValue(DanglingDebugInfo &DDI) {
-  Value *V = DDI.getDI()->getValue();
+  const DbgVariableIntrinsic *DVI = DDI.getDI();
+
+  // Currently we consider only dbg.value intrinsics -- we tell the salvager
+  // that DW_OP_stack_value is desired.
+  assert(isa<DbgValueInst>(DVI) || isa<DbgDerefValueInst>(DVI));
+
+  Value *V = isa<DbgValueInst>(DVI) ? cast<DbgValueInst>(DVI)->getValue()
+                                    : cast<DbgDerefValueInst>(DVI)->getValue();
+
   DILocalVariable *Var = DDI.getDI()->getVariable();
   DIExpression *Expr = DDI.getDI()->getExpression();
   DebugLoc DL = DDI.getdl();
   DebugLoc InstDL = DDI.getDI()->getDebugLoc();
   unsigned SDOrder = DDI.getSDNodeOrder();
 
-  // Currently we consider only dbg.value intrinsics -- we tell the salvager
-  // that DW_OP_stack_value is desired.
-  assert(isa<DbgValueInst>(DDI.getDI()));
   bool StackValue = true;
 
   // Can this Value can be encoded without any further work?
   if (handleDebugValue(V, Var, Expr, DL, InstDL, SDOrder))
     return;
 
   // Attempt to salvage back through as many instructions as possible. Bail if
   // a non-instruction is seen, such as a constant expression or global
bool SelectionDAGBuilder::handleDebugValue(const Value *V, DILocalVariable *Var,
   SDDbgValue *SDV;
   if (isa<ConstantInt>(V) || isa<ConstantFP>(V) || isa<UndefValue>(V) ||
       isa<ConstantPointerNull>(V)) {
     SDV = DAG.getConstantDbgValue(Var, Expr, V, dl, SDNodeOrder);
     DAG.AddDbgValue(SDV, nullptr, false);
     return true;
   }
 
+  if (const llvm::MetadataAsValue *MDV = dyn_cast<llvm::MetadataAsValue>(V)) {
+    if (DILocalVariable *DLV = dyn_cast<DILocalVariable>(MDV->getMetadata())) {
+      SDV = DAG.getImpPtrDbgValue(Var, Expr, DLV, dl, SDNodeOrder);
+      DAG.AddDbgValue(SDV, nullptr, false);
+      return true;
+    }
+  }
   // If the Value is a frame index, we can create a FrameIndex debug value
   // without relying on the DAG at all.
   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
     auto SI = FuncInfo.StaticAllocaMap.find(AI);
     if (SI != FuncInfo.StaticAllocaMap.end()) {
       auto SDV =
           DAG.getFrameIndexDbgValue(Var, Expr, SI->second,
                                     /*IsIndirect*/ false, dl, SDNodeOrder);
case Intrinsic::dbg_value: {
     // 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);
     return;
   }
+  case Intrinsic::dbg_derefval: {
+    const DbgDerefValueInst &DI = cast<DbgDerefValueInst>(I);
+    assert(DI.getVariable() && "Missing variable");
+
+    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))
+      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);
+    return;
+  }
 
   case Intrinsic::eh_typeid_for: {
     // Find the type id for the given typeinfo.
     GlobalValue *GV = ExtractTypeInfo(I.getArgOperand(0));
     unsigned TypeID = DAG.getMachineFunction().getTypeIDFor(GV);
     Res = DAG.getConstant(TypeID, sdl, MVT::i32);
     setValue(&I, Res);
     return;

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

+; RUN: llc %s -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:  DW_AT_name    ("var")
+; CHECK-LABEL:  DW_TAG_variable
+; CHECK-NEXT:  DW_AT_location
+; CHECK-NEXT:  DW_OP_implicit_pointer [[DIE:0x.+]] +0
+
+; CHECK-LABEL:  DW_TAG_formal_parameter
+; CHECK-NEXT:  DW_AT_location
+; CHECK-NEXT:  DW_OP_implicit_pointer [[DIE]] +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 !32, metadata !DIExpression()), !dbg !35
+  call void @llvm.dbg.derefval(metadata !32, metadata !33, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !35
+  call void @llvm.dbg.derefval(metadata !32, metadata !17, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !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)
+
+; 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: "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 10.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/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")
+;
+; 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")
+
+; 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")
+
+; 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
+  %inc = add nsw i32 %0, 1, !dbg !31
+  store volatile i32 %inc, i32* @v, align 4, !dbg !31
+  call void @llvm.dbg.derefval(metadata !16, metadata !22, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !30
+  call void @llvm.dbg.derefval(metadata !17, metadata !24, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !30
+  call void @llvm.dbg.derefval(metadata !18, metadata !25, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !30
+  call void @llvm.dbg.derefval(metadata !22, metadata !26, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !30
+  call void @llvm.dbg.derefval(metadata !24, metadata !28, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !30
+  call void @llvm.dbg.derefval(metadata !25, metadata !29, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !30
+  %1 = load volatile i32, i32* @v, align 4, !dbg !36
+  %inc1 = add nsw i32 %1, 1, !dbg !36
+  store volatile i32 %inc1, i32* @v, align 4, !dbg !36
+  ret i32 18, !dbg !37
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+; 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: 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/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 [[DIE:0x.+]] +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE]] +4)
+; 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 [[DIE]] +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_location        (
+; 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
+  %inc = add nsw i32 %0, 1, !dbg !26
+  store volatile i32 %inc, i32* @v, align 4, !dbg !26
+  call void @llvm.dbg.derefval(metadata !16, metadata !21, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !25
+  call void @llvm.dbg.derefval(metadata !20, metadata !23, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !25
+  call void @llvm.dbg.derefval(metadata !16, metadata !24, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !25
+  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 !20, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  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 !31
+  %inc6 = add nsw i32 %1, 1, !dbg !31
+  store volatile i32 %inc6, i32* @v, align 4, !dbg !31
+  call void @llvm.dbg.derefval(metadata !16, metadata !21, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 4)), !dbg !25
+  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 !20, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !25
+  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 !32
+  %inc10 = add nsw i32 %2, 1, !dbg !32
+  store volatile i32 %inc10, i32* @v, align 4, !dbg !32
+  ret i32 17, !dbg !33
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+; 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: 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: 40, column: 4, scope: !12)
+!32 = !DILocation(line: 45, column: 4, scope: !12)
+!33 = !DILocation(line: 46, column: 3, scope: !12)

llvm/test/DebugInfo/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 [[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.value(metadata, metadata, metadata)
+
+; 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)