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

[alok]

Summary

This patch stems from D84112.
This patch includes changes for SROA optimization.

[jmorse]

I see what seem to be changes to codegen here (see inline comments), is that intentional? And if so, why is that needed for DW_OP_LLVM_explicit_pointer to work?

llvm/lib/IR/Metadata.cpp

395

Why is this now permitted behaviour?

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

1648–1654

Is this necessary for the implicit pointer work?

llvm/lib/Transforms/Scalar/SROA.cpp

4419–4503

Again, this block of code will need comments about its purpose adding.

4449–4453

This part looks like it's changing the code generated, replacing a GEP with an alloca. If that's the case, IMO this should be split out into a different patch (one for codegen, one for debuginfo), as any codegen change will need an independent argument as to why it's a good idea.

Plus, this would only be a codegen change for people building with dwarf-5, which would mean you get different code with and without the -g option to clang.

llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp

424 ↗

(On Diff #279045)

This should be folded into the previous patch (7?)

[alok]

Updated to re-base.

[phosek]

This change was brought up in https://github.com/llvm/llvm-project/issues/54290, @alok is this still active? Is there a way we can help to get this patch stack reviewed and landed?

[dblaikie]

In D84120#3373968, @phosek wrote:

This change was brought up in https://github.com/llvm/llvm-project/issues/54290, @alok is this still active? Is there a way we can help to get this patch stack reviewed and landed?

Looks like there was some further discussion here: https://reviews.llvm.org/D84112 and an alluded to llvm-dev thread that might be worth finding.

Also, I really wonder if it might be worth proposing a more flexible DWARF form/operator for this encoding. Currently the implicit_pointer only allows describing the pointer as pointing to another variable described by a variable DIE - I think it'd be nice to be able to avoid that indirection and creating synthetic variables to describe this in its full generality - and instead being able to describe the location (& maybe you need to point to a type too, but not a whole variable) directly in this variable location, maybe. It'd more closely model how I was leaning towards/pushing for this to be implemented in LLVM (LLVM_explicit_pointer was the prototype name) & I think makes more sense in general (in many cases you wouldn't be pointing to a known/named variable anyway - you could be pointing to a value in the calling frame that could be a composite itself, maybe several levels of indirection have been removed, etc)

[phosek]

In D84120#3375997, @dblaikie wrote:

In D84120#3373968, @phosek wrote:

This change was brought up in https://github.com/llvm/llvm-project/issues/54290, @alok is this still active? Is there a way we can help to get this patch stack reviewed and landed?

Looks like there was some further discussion here: https://reviews.llvm.org/D84112 and an alluded to llvm-dev thread that might be worth finding.

I believe the corresponding discussion is https://discourse.llvm.org/t/dw-op-implicit-pointer-design-implementation-in-general/53698

[phosek]

In D84120#3408371, @phosek wrote:

In D84120#3375997, @dblaikie wrote:

In D84120#3373968, @phosek wrote:

This change was brought up in https://github.com/llvm/llvm-project/issues/54290, @alok is this still active? Is there a way we can help to get this patch stack reviewed and landed?

Looks like there was some further discussion here: https://reviews.llvm.org/D84112 and an alluded to llvm-dev thread that might be worth finding.

I believe the corresponding discussion is https://discourse.llvm.org/t/dw-op-implicit-pointer-design-implementation-in-general/53698

It seems like not all the content was transferred over to Discourse, the original thread is https://lists.llvm.org/pipermail/llvm-dev/2019-November/136798.html

[alok]

In D84120#3408379, @phosek wrote:

In D84120#3408371, @phosek wrote:

In D84120#3375997, @dblaikie wrote:

In D84120#3373968, @phosek wrote:

This change was brought up in https://github.com/llvm/llvm-project/issues/54290, @alok is this still active? Is there a way we can help to get this patch stack reviewed and landed?

Looks like there was some further discussion here: https://reviews.llvm.org/D84112 and an alluded to llvm-dev thread that might be worth finding.

I believe the corresponding discussion is https://discourse.llvm.org/t/dw-op-implicit-pointer-design-implementation-in-general/53698

It seems like not all the content was transferred over to Discourse, the original thread is https://lists.llvm.org/pipermail/llvm-dev/2019-November/136798.html

Thanks for your interest. I hope to re-activate it soon.

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

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

llvm/lib/IR/Metadata.cpp

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

llvm/lib/IR/Value.cpp

static bool contains(Value *Expr, Value *V) {
   return contains(Cache, CE, C);
 }
 #endif // NDEBUG
 
 void Value::doRAUW(Value *New, ReplaceMetadataUses ReplaceMetaUses) {
   assert(New && "Value::replaceAllUsesWith(<null>) is invalid!");
   assert(!contains(New, this) &&
          "this->replaceAllUsesWith(expr(this)) is NOT valid!");
-  assert(New->getType() == getType() &&
-         "replaceAllUses of value with new value of different type!");
 
   // Notify all ValueHandles (if present) that this value is going away.
   if (HasValueHandle)
     ValueHandleBase::ValueIsRAUWd(this, New);
   if (ReplaceMetaUses == ReplaceMetadataUses::Yes && isUsedByMetadata())
     ValueAsMetadata::handleRAUW(this, New);
 
   while (!materialized_use_empty()) {

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/DebugCounter.h"
 #include "llvm/Support/RecyclingAllocator.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/GuardUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <cassert>
 #include <deque>
 #include <memory>
 #include <utility>
 
 using namespace llvm;
bool runOnFunction(Function &F) override {
     auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
     auto *MSSA =
         UseMemorySSA ? &getAnalysis<MemorySSAWrapperPass>().getMSSA() : nullptr;
 
     EarlyCSE CSE(F.getParent()->getDataLayout(), TLI, TTI, DT, AC, MSSA);
 
-    return CSE.run();
+    auto Changed = CSE.run();
+    if (Changed) {
+      for (BasicBlock &BB : F)
+        RemoveRedundantDbgInstrs(&BB);
+    }
+    return Changed;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     if (UseMemorySSA) {
       AU.addRequired<AAResultsWrapperPass>();

llvm/lib/Transforms/Scalar/SROA.cpp

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

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

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

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

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

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

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

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

llvm/test/DebugInfo/X86/implicit_pointer_mem2reg.c

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

llvm/test/DebugInfo/X86/implicit_pointer_sroa.c

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

llvm/test/DebugInfo/X86/implicit_pointer_sroa_inline.c

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