[DebugInfo] Fix incorrect updating of SDNode dependencies for variadic debug values

[StephenTozer]

Summary

This patch fixes an issue observed upon applying D91722 to current main (previously contained in another patch, but now separated out here):

SelectionDAG::transferDebugValues incorrectly updates the SDDbgValue's dependencies list. Specifically, this class maintains two closely related lists; the list of SDDbgOperands(which, for nodes, consist of an SDNode and a result number, (Node, ResNo)), and the list of SDNodes that it depends on (this list contains duplicates, which is important here). The latter list is derived from the former (this isn't true for all SDDbgValues, but it is true for all variadic cases), so we can expect each node operand to have a corresponding dependency. When we transfer debug values, currently we replace each operand that matches the (Node, ResNo) with the target node and result number, but we then replace every dependency of Node with the target node as well. This is incorrect if we have operands [(Node1, 0), (Node1, 1)], as the dependencies will be [Node1, Node1], so when we want to replace (Node1, 0) with (Node2, 0), we end up with operands [(Node2, 0), (Node1, 1)] (correct), and dependencies [Node2, Node2] (incorrect).

My current approach to fixing this is to change the dependency handling in SDDbgValue so that we derive the dependencies from the operands where possible. This is done by keeping a list of AdditionalDependencies, which contains all of the debug value's dependencies that aren't used directly as operands. When we fetch the list of dependencies, we fetch a combination of the nodes used by location operands and the additional dependencies; this means that we can freely update the debug operands without worrying about keeping the dependencies array in sync. Technically this approach could be taken further, as all the additional dependencies actually come from frame index location operands, but this kind of tracking isn't handled even for the existing cases; as this is currently holding up the main variadic patch, it seemed prudent to stick to the simple case for now.

[djtodoro]

LGTM overall (as @jmorse pointed out, if possible, I'd like to see a test case)

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1345

so this is relevant for stack objects only?

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1345

Correct; when calculating dependencies for an SDDbgValue, this patch will automatically include any SDNodes that are used directly as operands, so we no longer need to add (and should not add) the SDNodes as dependencies for every argument; because frame index operands do not hold a direct reference the SDNode they depend on, we manually add it for those operands and only those operands.

[StephenTozer]

Added simple test case, which triggers a build error without the fix (so no use of FileCheck).

[StephenTozer]

Sanitizer builds were failing due to memory leaks; these were caused by the fact that SDDbgValues are allocated under a BumpPtrAllocator, which does not call destructors. SDDbgValues contained SmallVectors which did not use this allocator, so when the SDDbgValues were cleared they would not call the SmallVector destructor.

This has been resolved by replacing each SmallVector with a std::shared_ptr that uses the BumpPtrAllocator, so there will be no memory allocated outside of this allocator and hence no leaks.

[StephenTozer]

Reopening review, as non-trivial changes have been added following buildbot failure (see comment above for details).

[Orlando]

In D99423#2679569, @StephenTozer wrote:

Sanitizer builds were failing due to memory leaks; these were caused by the fact that SDDbgValues are allocated under a BumpPtrAllocator, which does not call destructors. SDDbgValues contained SmallVectors which did not use this allocator, so when the SDDbgValues were cleared they would not call the SmallVector destructor.

This has been resolved by replacing each SmallVector with a std::shared_ptr that uses the BumpPtrAllocator, so there will be no memory allocated outside of this allocator and hence no leaks.

Nice! imo it would be nice to have a comment somewhere explaining this, otherwise LGTM but please wait for someone else to +1 it.

[StephenTozer]

Fixed deletion lambdas in shared_ptrs, which were previously missing the size of the array.

[Orlando]

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

166

I don't think you should call Deallocate when using a BumpPtrAllocator?

include/llvm/Support/Allocator.h

210   // Bump pointer allocators are expected to never free their storage; and
211   // clients expect pointers to remain valid for non-dereferencing uses even
212   // after deallocation.
213   void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) {
214     __asan_poison_memory_region(Ptr, Size);
215   }

IIUC the memory will be freed by the BumpPtrAllocator with everything else all at once.

[StephenTozer]

Replace shared_ptr usage with raw pointers, as neither a copy constructor nor the destructor for SDDbgValue are ever called, making memory management a non-issue.

[Orlando]

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

166

I totally misunderstood what __asan_poison_memory_region(Ptr, Size); was doing here, ignore my comment above. Sorry for the noise!

[StephenTozer]

Small update: explicitly deleted the copy constructors and destructor for SDDbgValue with an explanatory comment, to ensure that if we ever start copy constructing or destroying instances of SDDbgValue there will be notice that the raw pointers need to be managed.

[jmorse]

LGTM with latest memory jiggery pokery.

[StephenTozer]

The updated patch was reapplied in aa3e78a59fdf.

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

else
       u.FrameIx = VRegOrFrameIdx;
   }
 };
 
 /// Holds the information from a dbg_value node through SDISel.
 /// We do not use SDValue here to avoid including its header.
 class SDDbgValue {
 public:
-  // FIXME: These SmallVector sizes were chosen without any kind of performance
-  // testing.
-  using LocOpVector = SmallVector<SDDbgOperand, 2>;
-  using SDNodeVector = SmallVector<SDNode *, 2>;
 
 private:
-  LocOpVector LocationOps;
-  SDNodeVector SDNodes;
+  // SDDbgValues are allocated by a BumpPtrAllocator, which means the destructor
+  // may not be called; therefore all member arrays must also be allocated by
+  // that BumpPtrAllocator, to ensure that they are correctly freed.
+  size_t NumLocationOps;
+  SDDbgOperand *LocationOps;
+  // SDNode dependencies will be calculated as SDNodes that appear in
+  // LocationOps plus these AdditionalDependencies.
+  size_t NumAdditionalDependencies;
+  SDNode **AdditionalDependencies;
   DIVariable *Var;
   DIExpression *Expr;
   DebugLoc DL;
   unsigned Order;
   bool IsIndirect;
   bool IsVariadic;
   bool Invalid = false;
   bool Emitted = false;
 
 public:
-  SDDbgValue(DIVariable *Var, DIExpression *Expr, ArrayRef<SDDbgOperand> L,
-             ArrayRef<SDNode *> Dependencies, bool IsIndirect, DebugLoc DL,
-             unsigned O, bool IsVariadic)
-      : LocationOps(L.begin(), L.end()),
-        SDNodes(Dependencies.begin(), Dependencies.end()), Var(Var), Expr(Expr),
-        DL(DL), Order(O), IsIndirect(IsIndirect), IsVariadic(IsVariadic) {
+  SDDbgValue(BumpPtrAllocator &Alloc, DIVariable *Var, DIExpression *Expr,
+             ArrayRef<SDDbgOperand> L, ArrayRef<SDNode *> Dependencies,
+             bool IsIndirect, DebugLoc DL, unsigned O, bool IsVariadic)
+      : NumLocationOps(L.size()),
+        LocationOps(Alloc.Allocate<SDDbgOperand>(L.size())),
+        NumAdditionalDependencies(Dependencies.size()),
+        AdditionalDependencies(Alloc.Allocate<SDNode *>(Dependencies.size())),
+        Var(Var), Expr(Expr), DL(DL), Order(O), IsIndirect(IsIndirect),
+        IsVariadic(IsVariadic) {
     assert(IsVariadic || L.size() == 1);
     assert(!(IsVariadic && IsIndirect));
+    std::copy(L.begin(), L.end(), LocationOps);
+    std::copy(Dependencies.begin(), Dependencies.end(), AdditionalDependencies);
   }
 
+  // We allocate arrays with the BumpPtrAllocator and never free or copy them,
+  // for LocationOps and AdditionalDependencies, as we never expect to copy or
+  // destroy an SDDbgValue. If we ever start copying or destroying instances, we
+  // should manage the allocated memory appropriately.
+  SDDbgValue(const SDDbgValue &Other) = delete;
+  SDDbgValue &operator=(const SDDbgValue &Other) = delete;
+  ~SDDbgValue() = delete;
+
   /// Returns the DIVariable pointer for the variable.
   DIVariable *getVariable() const { return Var; }
 
   /// Returns the DIExpression pointer for the expression.
   DIExpression *getExpression() const { return Expr; }
 
-  ArrayRef<SDDbgOperand> getLocationOps() const { return LocationOps; }
+  ArrayRef<SDDbgOperand> getLocationOps() const {
+    return ArrayRef<SDDbgOperand>(LocationOps, NumLocationOps);
+  }
 
-  LocOpVector copyLocationOps() const { return LocationOps; }
+  SmallVector<SDDbgOperand> copyLocationOps() const {
+    return SmallVector<SDDbgOperand>(LocationOps, LocationOps + NumLocationOps);
+  }
 
   // Returns the SDNodes which this SDDbgValue depends on.
-  ArrayRef<SDNode *> getSDNodes() const { return SDNodes; }
+  SmallVector<SDNode *> getSDNodes() const {
+    SmallVector<SDNode *> Dependencies;
+    for (SDDbgOperand DbgOp : getLocationOps())
+      if (DbgOp.getKind() == SDDbgOperand::SDNODE)
+        Dependencies.push_back(DbgOp.getSDNode());
+    for (SDNode *Node : getAdditionalDependencies())
+      Dependencies.push_back(Node);
+    return Dependencies;
+  }
 
-  SDNodeVector copySDNodes() const { return SDNodes; }
+  ArrayRef<SDNode *> getAdditionalDependencies() const {
+    return ArrayRef<SDNode *>(AdditionalDependencies,
+                              NumAdditionalDependencies);
+  }
 
   /// Returns whether this is an indirect value.
   bool isIndirect() const { return IsIndirect; }
 
   bool isVariadic() const { return IsVariadic; }
 
   /// Returns the DebugLoc.
   DebugLoc getDebugLoc() const { return DL; }

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 ///
 /// SDNode
 SDDbgValue *SelectionDAG::getDbgValue(DIVariable *Var, DIExpression *Expr,
                                       SDNode *N, unsigned R, 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, SDDbgOperand::fromNode(N, R), N, IsIndirect, DL, O,
+      SDDbgValue(DbgInfo->getAlloc(), Var, Expr, SDDbgOperand::fromNode(N, R),
+                 {}, IsIndirect, DL, O,
                  /*IsVariadic=*/false);
 }
 
 /// Constant
 SDDbgValue *SelectionDAG::getConstantDbgValue(DIVariable *Var,
                                               DIExpression *Expr,
                                               const Value *C,
                                               const DebugLoc &DL, unsigned O) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
-  return new (DbgInfo->getAlloc()) SDDbgValue(
-      Var, Expr, SDDbgOperand::fromConst(C), {}, /*IsIndirect=*/false, DL, O,
+  return new (DbgInfo->getAlloc())
+      SDDbgValue(DbgInfo->getAlloc(), Var, Expr, SDDbgOperand::fromConst(C), {},
+                 /*IsIndirect=*/false, DL, O,
                  /*IsVariadic=*/false);
 }
 
 /// FrameIndex
 SDDbgValue *SelectionDAG::getFrameIndexDbgValue(DIVariable *Var,
                                                 DIExpression *Expr, unsigned FI,
                                                 bool IsIndirect,
                                                 const DebugLoc &DL,
                                                 unsigned O) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
   return getFrameIndexDbgValue(Var, Expr, FI, {}, IsIndirect, DL, O);
 }
 
 /// FrameIndex with dependencies
 SDDbgValue *SelectionDAG::getFrameIndexDbgValue(DIVariable *Var,
                                                 DIExpression *Expr, unsigned FI,
                                                 ArrayRef<SDNode *> Dependencies,
                                                 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, SDDbgOperand::fromFrameIdx(FI), Dependencies,
-                 IsIndirect, DL, O,
+      SDDbgValue(DbgInfo->getAlloc(), Var, Expr, SDDbgOperand::fromFrameIdx(FI),
+                 Dependencies, IsIndirect, DL, O,
                  /*IsVariadic=*/false);
 }
 
 /// VReg
 SDDbgValue *SelectionDAG::getVRegDbgValue(DIVariable *Var, DIExpression *Expr,
                                           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, SDDbgOperand::fromVReg(VReg), {}, IsIndirect, DL, O,
+      SDDbgValue(DbgInfo->getAlloc(), Var, Expr, SDDbgOperand::fromVReg(VReg),
+                 {}, IsIndirect, DL, O,
                  /*IsVariadic=*/false);
 }
 
 SDDbgValue *SelectionDAG::getDbgValueList(DIVariable *Var, DIExpression *Expr,
                                           ArrayRef<SDDbgOperand> Locs,
                                           ArrayRef<SDNode *> Dependencies,
                                           bool IsIndirect, const DebugLoc &DL,
                                           unsigned O, bool IsVariadic) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
   return new (DbgInfo->getAlloc())
-      SDDbgValue(Var, Expr, Locs, Dependencies, IsIndirect, DL, O, IsVariadic);
+      SDDbgValue(DbgInfo->getAlloc(), Var, Expr, Locs, Dependencies, IsIndirect,
+                 DL, O, IsVariadic);
 }
 
 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");
if (SizeInBits) {
           continue;
       auto Fragment = DIExpression::createFragmentExpression(Expr, OffsetInBits,
                                                              SizeInBits);
       if (!Fragment)
         continue;
       Expr = *Fragment;
     }
 
-    auto NewDependencies = Dbg->copySDNodes();
-    std::replace(NewDependencies.begin(), NewDependencies.end(), FromNode,
-                 ToNode);
+    auto AdditionalDependencies = Dbg->getAdditionalDependencies();
     // Clone the SDDbgValue and move it to To.
     SDDbgValue *Clone = getDbgValueList(
-        Var, Expr, NewLocOps, NewDependencies, Dbg->isIndirect(),
+        Var, Expr, NewLocOps, AdditionalDependencies, Dbg->isIndirect(),
         Dbg->getDebugLoc(), std::max(ToNode->getIROrder(), Dbg->getOrder()),
         Dbg->isVariadic());
     ClonedDVs.push_back(Clone);
 
     if (InvalidateDbg) {
       // Invalidate value and indicate the SDDbgValue should not be emitted.
       Dbg->setIsInvalidated();
       Dbg->setIsEmitted();
case ISD::ADD:
           SmallVector<uint64_t, 3> ExprOps;
           DIExpression::appendOffset(ExprOps, Offset);
           DIExpr = DIExpression::appendOpsToArg(DIExpr, ExprOps, i, true);
           Changed = true;
         }
         (void)Changed;
         assert(Changed && "Salvage target doesn't use N");
 
-        auto NewDependencies = DV->copySDNodes();
-        std::replace(NewDependencies.begin(), NewDependencies.end(), &N,
-                     N0.getNode());
+        auto AdditionalDependencies = DV->getAdditionalDependencies();
         SDDbgValue *Clone = getDbgValueList(DV->getVariable(), DIExpr,
-                                            NewLocOps, NewDependencies,
+                                            NewLocOps, AdditionalDependencies,
                                             DV->isIndirect(), DV->getDebugLoc(),
                                             DV->getOrder(), DV->isVariadic());
         ClonedDVs.push_back(Clone);
         DV->setIsInvalidated();
         DV->setIsEmitted();
         LLVM_DEBUG(dbgs() << "SALVAGE: Rewriting";
                    N0.getNode()->dumprFull(this);
                    dbgs() << " into " << *DIExpr << '\n');

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 
 bool SelectionDAGBuilder::handleDebugValue(ArrayRef<const Value *> Values,
                                            DILocalVariable *Var,
                                            DIExpression *Expr, DebugLoc dl,
                                            DebugLoc InstDL, unsigned Order,
                                            bool IsVariadic) {
   if (Values.empty())
     return true;
-  SDDbgValue::LocOpVector LocationOps;
-  SDDbgValue::SDNodeVector Dependencies;
+  SmallVector<SDDbgOperand> LocationOps;
+  SmallVector<SDNode *> Dependencies;
   for (const Value *V : Values) {
     // Constant value.
     if (isa<ConstantInt>(V) || isa<ConstantFP>(V) || isa<UndefValue>(V) ||
         isa<ConstantPointerNull>(V)) {
       LocationOps.emplace_back(SDDbgOperand::fromConst(V));
       continue;
     }
 
for (const Value *V : Values) {
     // this point if it hasn't been done yet.
     SDValue N = NodeMap[V];
     if (!N.getNode() && isa<Argument>(V)) // Check unused arguments map.
       N = UnusedArgNodeMap[V];
     if (N.getNode()) {
       // Only emit func arg dbg value for non-variadic dbg.values for now.
       if (!IsVariadic && EmitFuncArgumentDbgValue(V, Var, Expr, dl, false, N))
         return true;
-      Dependencies.push_back(N.getNode());
       if (auto *FISDN = dyn_cast<FrameIndexSDNode>(N.getNode())) {
         // Construct a FrameIndexDbgValue for FrameIndexSDNodes so we can
         // describe stack slot locations.
         //
         // Consider "int x = 0; int *px = &x;". There are two kinds of
         // interesting debug values here after optimization:
         //
         //   dbg.value(i32* %px, !"int *px", !DIExpression()), and
         //   dbg.value(i32* %px, !"int x", !DIExpression(DW_OP_deref))
         //
         // Both describe the direct values of their associated variables.
+        Dependencies.push_back(N.getNode());
         LocationOps.emplace_back(SDDbgOperand::fromFrameIdx(FISDN->getIndex()));
         continue;
       }
       LocationOps.emplace_back(
           SDDbgOperand::fromNode(N.getNode(), N.getResNo()));
       continue;
     }
 

llvm/test/CodeGen/X86/dbg-list-dependencies.ll

+; RUN: llc --stop-after=finalize-isel < %s
+
+; Tests that files with multiple SDNode dependencies are correctly handled by
+; SelectionDAG; dependencies that are incorrectly updated for an SDDbgValue
+; throughout SelectionDAG will result in errors.
+
+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"
+
+%class.anon = type { i8 }
+%class.D = type { %class.f }
+%class.f = type { i32, i32 }
+%class.l = type { i8*, i64 }
+%class.d = type { i8 }
+
+@q = internal global %class.anon zeroinitializer, align 1, !dbg !0
+
+define void @_Z1rv() local_unnamed_addr !dbg !30 {
+entry:
+  %t = alloca %class.D, align 4
+  %call = tail call { i8*, i64 } @"_ZN3$_05m_fn3Ev"(%class.anon* nonnull dereferenceable(1) @q), !dbg !60
+  %0 = extractvalue { i8*, i64 } %call, 0, !dbg !60
+  call void @llvm.dbg.value(metadata i8* %0, metadata !34, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg !61
+  %1 = extractvalue { i8*, i64 } %call, 1, !dbg !60
+  call void @llvm.dbg.value(metadata i64 %1, metadata !34, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg !61
+  %2 = bitcast %class.D* %t to i8*, !dbg !62
+  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %2) #4, !dbg !62
+  call void @llvm.dbg.declare(metadata %class.D* %t, metadata !35, metadata !DIExpression()), !dbg !63
+  call void @llvm.dbg.value(metadata i8* %0, metadata !64, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg !69
+  call void @llvm.dbg.value(metadata i64 %1, metadata !64, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg !69
+  call void @llvm.dbg.value(metadata %class.D* %t, metadata !67, metadata !DIExpression()), !dbg !69
+  call void @llvm.dbg.value(metadata %class.l* undef, metadata !71, metadata !DIExpression()), !dbg !75
+  call void @llvm.dbg.value(metadata %class.D* %t, metadata !77, metadata !DIExpression()), !dbg !91
+  call void @llvm.dbg.value(metadata i8* %0, metadata !86, metadata !DIExpression()), !dbg !91
+  call void @llvm.dbg.value(metadata !DIArgList(i8* %0, i64 %1), metadata !87, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_constu, 1, DW_OP_mul, DW_OP_plus, DW_OP_stack_value)), !dbg !91
+  %3 = bitcast %class.D* %t to %class.d*, !dbg !93
+  call void @_ZN1dC2EPvl(%class.d* nonnull dereferenceable(1) %3, i8* nonnull %2, i64 8), !dbg !94
+  call void @llvm.dbg.value(metadata !DIArgList(i8* %0, i8* %0, i64 %1), metadata !88, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 2, DW_OP_constu, 1, DW_OP_mul, DW_OP_plus, DW_OP_LLVM_arg, 1, DW_OP_minus, DW_OP_stack_value)), !dbg !95
+  %tobool.not.i.i = icmp eq i64 %1, 0, !dbg !96
+  br i1 %tobool.not.i.i, label %_ZN1DILi8EEC2E1l.exit, label %if.then.i.i, !dbg !98
+
+if.then.i.i:                                      ; preds = %entry
+  %add.ptr.i.i = getelementptr inbounds i8, i8* %0, i64 %1, !dbg !99
+  call void @llvm.dbg.value(metadata i8* %add.ptr.i.i, metadata !87, metadata !DIExpression()), !dbg !91
+  call void @llvm.dbg.value(metadata !DIArgList(i8* %add.ptr.i.i, i8* %0), metadata !88, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_minus, DW_OP_stack_value)), !dbg !95
+  call void @llvm.dbg.value(metadata %class.D* %t, metadata !77, metadata !DIExpression()), !dbg !91
+  %k.i.i = getelementptr inbounds %class.D, %class.D* %t, i64 0, i32 0, i32 1, !dbg !100
+  %4 = load i32, i32* %k.i.i, align 4, !dbg !100, !tbaa !101
+  call void @_Z1cIPKciEvT_S2_T0_(i8* %0, i8* nonnull %add.ptr.i.i, i32 %4), !dbg !106
+  br label %_ZN1DILi8EEC2E1l.exit, !dbg !106
+
+_ZN1DILi8EEC2E1l.exit:                            ; preds = %entry, %if.then.i.i
+  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %2) #4, !dbg !107
+  ret void, !dbg !107
+}
+
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+declare { i8*, i64 } @"_ZN3$_05m_fn3Ev"(%class.anon* nonnull dereferenceable(1)) local_unnamed_addr
+
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
+
+declare void @_ZN1dC2EPvl(%class.d* nonnull dereferenceable(1), i8*, i64) unnamed_addr
+
+declare !dbg !108 void @_Z1cIPKciEvT_S2_T0_(i8*, i8*, i32) local_unnamed_addr
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!26, !27, !28}
+!llvm.ident = !{!29}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "q", scope: !2, file: !3, line: 32, type: !6, isLocal: true, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 13.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "dbg-list-dependencies.cpp", directory: "/")
+!4 = !{}
+!5 = !{!0}
+!6 = distinct !DICompositeType(tag: DW_TAG_class_type, file: !3, line: 29, size: 8, flags: DIFlagTypePassByValue, elements: !7)
+!7 = !{!8}
+!8 = !DISubprogram(name: "m_fn3", linkageName: "_ZN3$_05m_fn3Ev", scope: !6, file: !3, line: 31, type: !9, scopeLine: 31, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagLocalToUnit | DISPFlagOptimized)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !25}
+!11 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "l", file: !3, line: 17, size: 128, flags: DIFlagTypePassByValue, elements: !12, identifier: "_ZTS1l")
+!12 = !{!13, !16, !18, !24}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "m", scope: !11, file: !3, line: 18, baseType: !14, size: 64)
+!14 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !15, size: 64)
+!15 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "n", scope: !11, file: !3, line: 19, baseType: !17, size: 64, offset: 64)
+!17 = !DIBasicType(name: "long int", size: 64, encoding: DW_ATE_signed)
+!18 = !DISubprogram(name: "p", linkageName: "_ZN1l1pEv", scope: !11, file: !3, line: 22, type: !19, scopeLine: 22, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagOptimized)
+!19 = !DISubroutineType(types: !20)
+!20 = !{!21, !23}
+!21 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !22, size: 64)
+!22 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !15)
+!23 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!24 = !DISubprogram(name: "m_fn2", linkageName: "_ZN1l5m_fn2Ev", scope: !11, file: !3, line: 23, type: !19, scopeLine: 23, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagOptimized)
+!25 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!26 = !{i32 7, !"Dwarf Version", i32 4}
+!27 = !{i32 2, !"Debug Info Version", i32 3}
+!28 = !{i32 1, !"wchar_size", i32 4}
+!29 = !{!"clang version 13.0.0"}
+!30 = distinct !DISubprogram(name: "r", linkageName: "_Z1rv", scope: !3, file: !3, line: 33, type: !31, scopeLine: 33, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !33)
+!31 = !DISubroutineType(types: !32)
+!32 = !{null}
+!33 = !{!34, !35}
+!34 = !DILocalVariable(name: "s", scope: !30, file: !3, line: 34, type: !11)
+!35 = !DILocalVariable(name: "t", scope: !30, file: !3, line: 35, type: !36)
+!36 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "D<8>", file: !3, line: 25, size: 64, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !37, templateParams: !58, identifier: "_ZTS1DILi8EE")
+!37 = !{!38, !54}
+!38 = !DIDerivedType(tag: DW_TAG_inheritance, scope: !36, baseType: !39, extraData: i32 0)
+!39 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "f<8>", file: !3, line: 6, size: 64, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !40, templateParams: !52, identifier: "_ZTS1fILi8EE")
+!40 = !{!41, !49, !51}
+!41 = !DIDerivedType(tag: DW_TAG_inheritance, scope: !39, baseType: !42, extraData: i32 0)
+!42 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "d", file: !3, line: 2, size: 8, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !43, identifier: "_ZTS1d")
+!43 = !{!44}
+!44 = !DISubprogram(name: "d", scope: !42, file: !3, line: 4, type: !45, scopeLine: 4, flags: DIFlagProtected | DIFlagPrototyped, spFlags: DISPFlagOptimized)
+!45 = !DISubroutineType(types: !46)
+!46 = !{null, !47, !48, !17}
+!47 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !42, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!48 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 64)
+!49 = !DIDerivedType(tag: DW_TAG_member, name: "g", scope: !39, file: !3, line: 7, baseType: !50, size: 32)
+!50 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!51 = !DIDerivedType(tag: DW_TAG_member, name: "k", scope: !39, file: !3, line: 15, baseType: !50, size: 32, offset: 32, flags: DIFlagPublic)
+!52 = !{!53}
+!53 = !DITemplateValueParameter(name: "e", type: !50, value: i32 8)
+!54 = !DISubprogram(name: "D", scope: !36, file: !3, line: 27, type: !55, scopeLine: 27, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagOptimized)
+!55 = !DISubroutineType(types: !56)
+!56 = !{null, !57, !11}
+!57 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !36, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!58 = !{!59}
+!59 = !DITemplateValueParameter(name: "o", type: !50, value: i32 8)
+!60 = !DILocation(line: 34, column: 9, scope: !30)
+!61 = !DILocation(line: 0, scope: !30)
+!62 = !DILocation(line: 35, column: 3, scope: !30)
+!63 = !DILocation(line: 35, column: 8, scope: !30)
+!64 = !DILocalVariable(name: "h", arg: 2, scope: !65, file: !3, line: 27, type: !11)
+!65 = distinct !DISubprogram(name: "D", linkageName: "_ZN1DILi8EEC2E1l", scope: !36, file: !3, line: 27, type: !55, scopeLine: 27, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, declaration: !54, retainedNodes: !66)
+!66 = !{!67, !64}
+!67 = !DILocalVariable(name: "this", arg: 1, scope: !65, type: !68, flags: DIFlagArtificial | DIFlagObjectPointer)
+!68 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !36, size: 64)
+!69 = !DILocation(line: 0, scope: !65, inlinedAt: !70)
+!70 = distinct !DILocation(line: 35, column: 8, scope: !30)
+!71 = !DILocalVariable(name: "this", arg: 1, scope: !72, type: !74, flags: DIFlagArtificial | DIFlagObjectPointer)
+!72 = distinct !DISubprogram(name: "m_fn2", linkageName: "_ZN1l5m_fn2Ev", scope: !11, file: !3, line: 23, type: !19, scopeLine: 23, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, declaration: !24, retainedNodes: !73)
+!73 = !{!71}
+!74 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
+!75 = !DILocation(line: 0, scope: !72, inlinedAt: !76)
+!76 = distinct !DILocation(line: 27, column: 26, scope: !65, inlinedAt: !70)
+!77 = !DILocalVariable(name: "this", arg: 1, scope: !78, type: !90, flags: DIFlagArtificial | DIFlagObjectPointer)
+!78 = distinct !DISubprogram(name: "f<const char *>", linkageName: "_ZN1fILi8EEC2IPKcEET_S4_", scope: !39, file: !3, line: 10, type: !79, scopeLine: 10, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, templateParams: !83, declaration: !82, retainedNodes: !85)
+!79 = !DISubroutineType(types: !80)
+!80 = !{null, !81, !21, !21}
+!81 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !39, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!82 = !DISubprogram(name: "f<const char *>", scope: !39, file: !3, line: 10, type: !79, scopeLine: 10, flags: DIFlagPublic | DIFlagPrototyped, spFlags: DISPFlagOptimized, templateParams: !83)
+!83 = !{!84}
+!84 = !DITemplateTypeParameter(name: "a", type: !21)
+!85 = !{!77, !86, !87, !88}
+!86 = !DILocalVariable(name: "h", arg: 2, scope: !78, file: !3, line: 10, type: !21)
+!87 = !DILocalVariable(name: "i", arg: 3, scope: !78, file: !3, line: 10, type: !21)
+!88 = !DILocalVariable(name: "j", scope: !89, file: !3, line: 11, type: !17)
+!89 = distinct !DILexicalBlock(scope: !78, file: !3, line: 10, column: 48)
+!90 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !39, size: 64)
+!91 = !DILocation(line: 0, scope: !78, inlinedAt: !92)
+!92 = distinct !DILocation(line: 27, column: 12, scope: !65, inlinedAt: !70)
+!93 = !DILocation(line: 10, column: 48, scope: !78, inlinedAt: !92)
+!94 = !DILocation(line: 10, column: 39, scope: !78, inlinedAt: !92)
+!95 = !DILocation(line: 0, scope: !89, inlinedAt: !92)
+!96 = !DILocation(line: 12, column: 9, scope: !97, inlinedAt: !92)
+!97 = distinct !DILexicalBlock(scope: !89, file: !3, line: 12, column: 9)
+!98 = !DILocation(line: 12, column: 9, scope: !89, inlinedAt: !92)
+!99 = !DILocation(line: 23, column: 34, scope: !72, inlinedAt: !76)
+!100 = !DILocation(line: 13, column: 15, scope: !97, inlinedAt: !92)
+!101 = !{!102, !103, i64 4}
+!102 = !{!"_ZTS1fILi8EE", !103, i64 0, !103, i64 4}
+!103 = !{!"int", !104, i64 0}
+!104 = !{!"omnipotent char", !105, i64 0}
+!105 = !{!"Simple C++ TBAA"}
+!106 = !DILocation(line: 13, column: 7, scope: !97, inlinedAt: !92)
+!107 = !DILocation(line: 36, column: 1, scope: !30)
+!108 = !DISubprogram(name: "c<const char *, int>", linkageName: "_Z1cIPKciEvT_S2_T0_", scope: !3, file: !3, line: 1, type: !109, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, templateParams: !111, retainedNodes: !4)
+!109 = !DISubroutineType(types: !110)
+!110 = !{null, !21, !21, !50}
+!111 = !{!84, !112}
+!112 = !DITemplateTypeParameter(name: "b", type: !50)