[MS] Emit S_HEAPALLOCSITE debug info in SelectionDAG

[akhuang]

Summary

This emits labels around heapallocsite calls in SelectionDAG.

[rnk]

+@efriedma @bogner Is this SDNode map a good idea? It was the least invasive way we could think of to pass the call site markers down to the MachineInstr.

IIRC @bogner you ran into issues with SDNode replacement and reuse. Is this map keyed by SDNode reasonable, or are we asking for ABA problems? Apologies if I'm misremembering where I heard this story.

[efriedma]

Is this SDNode map a good idea?

It's not ideal. I mean, if possible, it would be more clear to store the information as a property of the call node itself. And it's generally not setting a good example to use a map with SDNode pointers rather than some sort of handle. Could you use an MDNodeSDNode here as an operand to the CALL? (You can create one with SelectionDAG::getMDNode().)

The address of an X86ISD::CALL is likely stable, but there isn't really any guarantee; it's just incidental due to the way call nodes are constructed.

[akhuang]

Could you use an MDNodeSDNode here as an operand to the CALL? (You can create one with SelectionDAG::getMDNode().)

I tried adding the MDNodeSDNode as an operand, but was running into cases where the MDNode operand disappears (such as when the function has parameters). Is there a good way to deal with this?

[rnk]

After discussing this for the last few days, I realize that we're skating on the thin ice that the X86ISD::CALL SDNode doesn't get replaced, but I'm OK relying on that for this feature. In the worst case, some debug info is dropped and we'll have to come back and investigate it later.

[efriedma]

the MDNode operand disappears

Disappears at what point, exactly? I can't think of any pass that would drop the node, unless isel itself is dropping it somehow.

we're skating on the thin ice

Yes.

[akhuang]

I think it's being dropped in isel as an unused node.

[efriedma]

It's getting dropped by isel? Assuming it's still around when Select() is called, you might need to do a little work at that point to attach it to the ScheduleDAG node, I guess?

[rnk]

llvm/include/llvm/CodeGen/SelectionDAG.h

1678–1680

You should avoid doing two hash lookups: put the result of .find in a variable, and then return the value from the map iterator (Iter->second).

[akhuang]

I made some changes to keep the MDNodeSDNode attached to the call, which I mostly did by adding some special cases when operands are MDNodeSDNodes. Since call operands are currently all registers, it seems like it would be less invasive to use a map than to change the convention to include this specific MDNodeSDNode as an operand.

We also want the metadata to be dropped during tail call optimization, which would require some extra work to do here, but works with the map since the call gets replaced there.

[akhuang]

• Avoid doing two hash lookups

[akhuang]

There is now a new patch that attaches the metadata to a call operand-- https://reviews.llvm.org/D65023.

[akhuang]

It seems there is now an SDNode map in SelectionDAG for CallSiteInfo.
I merged the HeapAllocSite map with the CallSiteInfo map so that we don't have
two maps that use SDNodes as keys.

[rnk]

One issue, but otherwise this looks good to me.

llvm/include/llvm/CodeGen/SelectionDAG.h

275

Use = nullptr here so that any default constructed entries don't appear to have heap alloc sites. This would happen when there is CallSiteInfo for a call site, but no heap alloc site.

[akhuang]

Add nullptr to struct declaration

[mstorsjo]

This change caused build errors when building Qt with clang-cl, see https://bugs.llvm.org/show_bug.cgi?id=43479 for a reproduction sample.

llvm/include/llvm/CodeGen/SelectionDAG.h

class SelectionDAG {
   /// Pool allocation for misc. objects that are created once per SelectionDAG.
   BumpPtrAllocator Allocator;
 
   /// Tracks dbg_value and dbg_label information through SDISel.
   SDDbgInfo *DbgInfo;
 
   using CallSiteInfo = MachineFunction::CallSiteInfo;
   using CallSiteInfoImpl = MachineFunction::CallSiteInfoImpl;
-  DenseMap<const SDNode *, CallSiteInfo> SDCallSiteInfo;
+
+  struct CallSiteDbgInfo {
+    CallSiteInfo CSInfo;
+    MDNode *HeapAllocSite;
+  };
+
+  DenseMap<const SDNode *, CallSiteDbgInfo> SDCallSiteDbgInfo;
 
   uint16_t NextPersistentId = 0;
 
 public:
   /// Clients of various APIs that cause global effects on
   /// the DAG can optionally implement this interface.  This allows the clients
   /// to handle the various sorts of updates that happen.
   ///
public:
   /// \returns true if \p N is any kind of constant or build_vector of
   /// constants, int or float. If a vector, it may not necessarily be a splat.
   inline bool isConstantValueOfAnyType(SDValue N) {
     return isConstantIntBuildVectorOrConstantInt(N) ||
            isConstantFPBuildVectorOrConstantFP(N);
   }
 
   void addCallSiteInfo(const SDNode *CallNode, CallSiteInfoImpl &&CallInfo) {
-    SDCallSiteInfo[CallNode] = std::move(CallInfo);
+    SDCallSiteDbgInfo[CallNode].CSInfo = std::move(CallInfo);
   }
 
   CallSiteInfo getSDCallSiteInfo(const SDNode *CallNode) {
-    auto I = SDCallSiteInfo.find(CallNode);
-    if (I != SDCallSiteInfo.end())
-      return std::move(I->second);
+    auto I = SDCallSiteDbgInfo.find(CallNode);
+    if (I != SDCallSiteDbgInfo.end())
+      return std::move(I->second).CSInfo;
     return CallSiteInfo();
   }
 
+  void addHeapAllocSite(const SDNode *Node, MDNode *MD) {
+    SDCallSiteDbgInfo[Node].HeapAllocSite = MD;
+  }
+
+  /// Return the HeapAllocSite type associated with the SDNode, if it exists.
+  MDNode *getHeapAllocSite(const SDNode* Node) {
+    auto It = SDCallSiteDbgInfo.find(Node);
+    if (It == SDCallSiteDbgInfo.end())
+      return nullptr;
+    return It->second.HeapAllocSite;
+  }
+
 private:
   void InsertNode(SDNode *N);
   bool RemoveNodeFromCSEMaps(SDNode *N);
   void AddModifiedNodeToCSEMaps(SDNode *N);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2,
                                void *&InsertPos);
   SDNode *FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
     for (SDNode *N = SU->getNode()->getGluedNode(); N; N = N->getGluedNode())
       GluedNodes.push_back(N);
     while (!GluedNodes.empty()) {
       SDNode *N = GluedNodes.back();
       auto NewInsn = EmitNode(N, SU->OrigNode != SU, SU->isCloned, VRBaseMap);
       // Remember the source order of the inserted instruction.
       if (HasDbg)
         ProcessSourceNode(N, DAG, Emitter, VRBaseMap, Orders, Seen, NewInsn);
+
+      if (MDNode* MD = DAG->getHeapAllocSite(N))
+        MF.addCodeViewHeapAllocSite(NewInsn, MD);
+
       GluedNodes.pop_back();
     }
     auto NewInsn =
         EmitNode(SU->getNode(), SU->OrigNode != SU, SU->isCloned, VRBaseMap);
     // Remember the source order of the inserted instruction.
     if (HasDbg)
       ProcessSourceNode(SU->getNode(), DAG, Emitter, VRBaseMap, Orders, Seen,
                         NewInsn);
+    if (MDNode* MD = DAG->getHeapAllocSite(SU->getNode()))
+      MF.addCodeViewHeapAllocSite(NewInsn, MD);
   }
 
   // Insert all the dbg_values which have not already been inserted in source
   // order sequence.
   if (HasDbg) {
     MachineBasicBlock::iterator BBBegin = BB->getFirstNonPHI();
 
     // Sort the source order instructions and use the order to insert debug

llvm/lib/Target/X86/X86ISelLowering.cpp

if (isTailCall) {
     //// If this is the first return lowered for this function, add the regs
     //// to the liveout set for the function.
     // This isn't right, although it's probably harmless on x86; liveouts
     // should be computed from returns not tail calls.  Consider a void
     // function making a tail call to a function returning int.
     MF.getFrameInfo().setHasTailCall();
     SDValue Ret = DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, Ops);
     DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
+    if (CLI.CS && CLI.CS->getMetadata("heapallocsite")) {
+      DAG.addHeapAllocSite(Chain.getNode(),
+                           CLI.CS->getMetadata("heapallocsite"));
+    }
+
     return Ret;
   }
 
   if (HasNoCfCheck && IsCFProtectionSupported) {
     Chain = DAG.getNode(X86ISD::NT_CALL, dl, NodeTys, Ops);
   } else {
     Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, Ops);
   }
   InFlag = Chain.getValue(1);
   DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
 
+  // Save heapallocsite metadata.
+  if (CLI.CS && CLI.CS->getMetadata("heapallocsite")) {
+    DAG.addHeapAllocSite(Chain.getNode(),
+                         CLI.CS->getMetadata("heapallocsite"));
+  }
+
   // Create the CALLSEQ_END node.
   unsigned NumBytesForCalleeToPop;
   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
                        DAG.getTarget().Options.GuaranteedTailCallOpt))
     NumBytesForCalleeToPop = NumBytes;    // Callee pops everything
   else if (!Is64Bit && !canGuaranteeTCO(CallConv) &&
            !Subtarget.getTargetTriple().isOSMSVCRT() &&
            SR == StackStructReturn)

llvm/test/CodeGen/X86/label-heapallocsite.ll

-; RUN: llc -O0 < %s | FileCheck %s
-; FIXME: Add test for llc with optimizations once it is implemented.
+; RUN: llc < %s | FileCheck --check-prefixes=DAG,CHECK %s
+; RUN: llc -O0 < %s | FileCheck --check-prefixes=FAST,CHECK %s
 
 ; Source to regenerate:
-; $ clang --target=x86_64-windows-msvc -S heapallocsite.cpp -g -gcodeview -o t.ll \
-;      -emit-llvm -O0 -Xclang -disable-llvm-passes -fms-extensions
+; $ clang -cc1 -triple x86_64-windows-msvc t.cpp -debug-info-kind=limited \
+;      -gcodeview -O2 -fms-extensions -emit-llvm -o t.ll
 ;
-; struct Foo {
+; extern "C" struct Foo {
 ;   __declspec(allocator) virtual void *alloc();
 ; };
-;
 ; extern "C" __declspec(allocator) Foo *alloc_foo();
+; extern "C" void use_result(void *);
 ;
-; extern "C" void use_alloc(void*);
-; extern "C" void call_virtual(Foo *p) {
-;   use_alloc(p->alloc());
+; extern "C" int call_tail() {
+;   use_result(alloc_foo());
 ; }
-;
-; extern "C" void call_multiple() {
-;   use_alloc(alloc_foo());
-;   use_alloc(alloc_foo());
+; extern "C" int call_virtual(Foo *p) {
+;   use_result(p->alloc());
+;   return 0;
+; }
+; extern "C" int call_multiple() {
+;   use_result(alloc_foo());
+;   use_result(alloc_foo());
+;   return 0;
 ; }
 
+; ModuleID = 'label.cpp'
+source_filename = "label.cpp"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-windows-msvc"
 
 %struct.Foo = type { i32 (...)** }
 
-; Function Attrs: noinline optnone uwtable
-define dso_local void @call_virtual(%struct.Foo* %p) #0 !dbg !8 {
+; Function Attrs: nounwind
+define dso_local void @call_tail() local_unnamed_addr #0 !dbg !7 {
 entry:
-  %p.addr = alloca %struct.Foo*, align 8
-  store %struct.Foo* %p, %struct.Foo** %p.addr, align 8
-  call void @llvm.dbg.declare(metadata %struct.Foo** %p.addr, metadata !13, metadata !DIExpression()), !dbg !14
-  %0 = load %struct.Foo*, %struct.Foo** %p.addr, align 8, !dbg !15
-  %1 = bitcast %struct.Foo* %0 to i8* (%struct.Foo*)***, !dbg !15
-  %vtable = load i8* (%struct.Foo*)**, i8* (%struct.Foo*)*** %1, align 8, !dbg !15
-  %vfn = getelementptr inbounds i8* (%struct.Foo*)*, i8* (%struct.Foo*)** %vtable, i64 0, !dbg !15
-  %2 = load i8* (%struct.Foo*)*, i8* (%struct.Foo*)** %vfn, align 8, !dbg !15
-  %call = call i8* %2(%struct.Foo* %0), !dbg !15, !heapallocsite !2
-  call void @use_alloc(i8* %call), !dbg !15
-  ret void, !dbg !16
+  %call = tail call %struct.Foo* @alloc_foo() #3, !dbg !11, !heapallocsite !12
+  %0 = bitcast %struct.Foo* %call to i8*, !dbg !11
+  tail call void @use_result(i8* %0) #3, !dbg !11
+  ret void, !dbg !13
 }
 
-; Function Attrs: nounwind readnone speculatable
-declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+declare dso_local void @use_result(i8*) local_unnamed_addr #1
+
+declare dso_local %struct.Foo* @alloc_foo() local_unnamed_addr #1
 
-declare dso_local void @use_alloc(i8*) #2
+; Function Attrs: nounwind
+define dso_local i32 @call_virtual(%struct.Foo* %p) local_unnamed_addr #0 !dbg !14 {
+entry:
+  call void @llvm.dbg.value(metadata %struct.Foo* %p, metadata !20, metadata !DIExpression()), !dbg !21
+  %0 = bitcast %struct.Foo* %p to i8* (%struct.Foo*)***, !dbg !22
+  %vtable = load i8* (%struct.Foo*)**, i8* (%struct.Foo*)*** %0, align 8, !dbg !22, !tbaa !23
+  %1 = load i8* (%struct.Foo*)*, i8* (%struct.Foo*)** %vtable, align 8, !dbg !22
+  %call = tail call i8* %1(%struct.Foo* %p) #3, !dbg !22, !heapallocsite !2
+  tail call void @use_result(i8* %call) #3, !dbg !22
+  ret i32 0, !dbg !26
+}
 
-; Function Attrs: noinline optnone uwtable
-define dso_local void @call_multiple() #0 !dbg !17 {
+; Function Attrs: nounwind
+define dso_local i32 @call_multiple() local_unnamed_addr #0 !dbg !27 {
 entry:
-  %call = call %struct.Foo* @alloc_foo(), !dbg !20, !heapallocsite !12
-  %0 = bitcast %struct.Foo* %call to i8*, !dbg !20
-  call void @use_alloc(i8* %0), !dbg !20
-  %call1 = call %struct.Foo* @alloc_foo(), !dbg !21, !heapallocsite !12
-  %1 = bitcast %struct.Foo* %call1 to i8*, !dbg !21
-  call void @use_alloc(i8* %1), !dbg !21
-  ret void, !dbg !22
+  %call = tail call %struct.Foo* @alloc_foo() #3, !dbg !30, !heapallocsite !12
+  %0 = bitcast %struct.Foo* %call to i8*, !dbg !30
+  tail call void @use_result(i8* %0) #3, !dbg !30
+  %call1 = tail call %struct.Foo* @alloc_foo() #3, !dbg !31, !heapallocsite !12
+  %1 = bitcast %struct.Foo* %call1 to i8*, !dbg !31
+  tail call void @use_result(i8* %1) #3, !dbg !31
+  ret i32 0, !dbg !32
 }
 
-declare dso_local %struct.Foo* @alloc_foo() #2
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
 
-; CHECK-LABEL: call_virtual: # @call_virtual
+; CHECK-LABEL: call_tail:         # @call_tail
 ; CHECK: .Lheapallocsite0:
-; CHECK: callq *(%rax)
+; CHECK: callq alloc_foo
 ; CHECK: .Lheapallocsite1:
-; CHECK: retq
+
+; CHECK-LABEL: call_virtual:      # @call_virtual
+; CHECK: .Lheapallocsite2:
+; CHECK: callq *{{.*}}%rax{{.*}}
+; CHECK: .Lheapallocsite3:
 
-; CHECK-LABEL: call_multiple: # @call_multiple
-; CHECK: .Lheapallocsite4:
+; CHECK-LABEL: call_multiple:     # @call_multiple
+; FastISel emits instructions in a different order.
+; DAG:   .Lheapallocsite4:
+; FAST:  .Lheapallocsite6:
 ; CHECK: callq alloc_foo
-; CHECK: .Lheapallocsite5:
-; CHECK: .Lheapallocsite2:
+; DAG:   .Lheapallocsite5:
+; FAST:  .Lheapallocsite7:
+; DAG:   .Lheapallocsite8:
+; FAST:  .Lheapallocsite4:
 ; CHECK: callq alloc_foo
-; CHECK: .Lheapallocsite3:
-; CHECK: retq
+; DAG:   .Lheapallocsite9:
+; FAST:  .Lheapallocsite5:
 
 ; CHECK-LABEL: .short  4423                    # Record kind: S_GPROC32_ID
 ; CHECK:       .short  4446                    # Record kind: S_HEAPALLOCSITE
 ; CHECK-NEXT:  .secrel32 .Lheapallocsite0
 ; CHECK-NEXT:  .secidx .Lheapallocsite0
 ; CHECK-NEXT:  .short .Lheapallocsite1-.Lheapallocsite0
-; CHECK-NEXT:  .long 3
-; CHECK-NEXT:  .p2align 2
-; CHECK-LABEL: .short  4431                    # Record kind: S_PROC_ID_END
+; CHECK-NEXT:  .long 4099
 
 ; CHECK-LABEL: .short  4423                    # Record kind: S_GPROC32_ID
 ; CHECK:       .short  4446                    # Record kind: S_HEAPALLOCSITE
 ; CHECK-NEXT:  .secrel32 .Lheapallocsite2
 ; CHECK-NEXT:  .secidx .Lheapallocsite2
 ; CHECK-NEXT:  .short .Lheapallocsite3-.Lheapallocsite2
-; CHECK-NEXT:  .long 4096
-; CHECK-NEXT:  .p2align 2
-
+; CHECK-NEXT:  .long 3
 ; CHECK:       .short  4446                    # Record kind: S_HEAPALLOCSITE
 ; CHECK-NEXT:  .secrel32 .Lheapallocsite4
 ; CHECK-NEXT:  .secidx .Lheapallocsite4
 ; CHECK-NEXT:  .short .Lheapallocsite5-.Lheapallocsite4
-; CHECK-NEXT:  .long 4096
-; CHECK-NEXT:  .p2align 2
-; CHECK-LABEL: .short  4431                    # Record kind: S_PROC_ID_END
+; CHECK-NEXT:  .long 4099
+; CHECK:       .short  4446                    # Record kind: S_HEAPALLOCSITE
+; FAST-NEXT:  .secrel32 .Lheapallocsite6
+; FAST-NEXT:  .secidx .Lheapallocsite6
+; FAST-NEXT:  .short .Lheapallocsite7-.Lheapallocsite6
+; DAG-NEXT:  .secrel32 .Lheapallocsite8
+; DAG-NEXT:  .secidx .Lheapallocsite8
+; DAG-NEXT:  .short .Lheapallocsite9-.Lheapallocsite8
+; CHECK-NEXT:  .long 4099
+
+attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nounwind readnone speculatable }
+attributes #3 = { nounwind }
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5, !6}
-!llvm.ident = !{!7}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 9.0.0 (https://github.com/llvm/llvm-project.git 9c8073f44f786fbf47335e53f20abe64429e8e47)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)!1 = !DIFile(filename: "filename", directory: "directory", checksumkind: CSK_MD5, checksum: "096443b661a0af36da9006330c08f97e")
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 10.0.0 (https://github.com/llvm/llvm-project.git ebca9d67ffca71c9a996bd89844425ee13141f47)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "<stdin>", directory: "/usr/local/google/home/akhuang/testing/heapallocsite", checksumkind: CSK_MD5, checksum: "68a8ba93f37944165cfe76612a7073fd")
 !2 = !{}
 !3 = !{i32 2, !"CodeView", i32 1}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 2}
-!6 = !{i32 7, !"PIC Level", i32 2}
-!7 = !{!"clang version 9.0.0 (https://github.com/llvm/llvm-project.git 9c8073f44f786fbf47335e53f20abe64429e8e47)"}
-!8 = distinct !DISubprogram(name: "call_virtual", scope: !1, file: !1, line: 8, type: !9, scopeLine: 8, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!6 = !{!"clang version 10.0.0 (https://github.com/llvm/llvm-project.git ebca9d67ffca71c9a996bd89844425ee13141f47)"}
+!7 = distinct !DISubprogram(name: "call_tail", scope: !8, file: !8, line: 7, type: !9, scopeLine: 7, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!8 = !DIFile(filename: "label.cpp", directory: "/usr/local/google/home/akhuang/testing/heapallocsite", checksumkind: CSK_MD5, checksum: "68a8ba93f37944165cfe76612a7073fd")
 !9 = !DISubroutineType(types: !10)
-!10 = !{null, !11}
-!11 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
-!12 = !DICompositeType(tag: DW_TAG_structure_type, name: "Foo", file: !1, line: 1, flags: DIFlagFwdDecl, identifier: ".?AUFoo@@")
-!13 = !DILocalVariable(name: "p", arg: 1, scope: !8, file: !1, line: 8, type: !11)
-!14 = !DILocation(line: 8, scope: !8)
-!15 = !DILocation(line: 9, scope: !8)
-!16 = !DILocation(line: 10, scope: !8)
-!17 = distinct !DISubprogram(name: "call_multiple", scope: !1, file: !1, line: 12, type: !18, scopeLine: 12, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
-!18 = !DISubroutineType(types: !19)
-!19 = !{null}
-!20 = !DILocation(line: 13, scope: !17)
-!21 = !DILocation(line: 14, scope: !17)
-!22 = !DILocation(line: 15, scope: !17)
+!10 = !{null}
+!11 = !DILocation(line: 8, scope: !7)
+!12 = !DICompositeType(tag: DW_TAG_structure_type, name: "Foo", file: !8, line: 1, flags: DIFlagFwdDecl, identifier: ".?AUFoo@@")
+!13 = !DILocation(line: 9, scope: !7)
+!14 = distinct !DISubprogram(name: "call_virtual", scope: !8, file: !8, line: 10, type: !15, scopeLine: 10, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !19)
+!15 = !DISubroutineType(types: !16)
+!16 = !{!17, !18}
+!17 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!19 = !{!20}
+!20 = !DILocalVariable(name: "p", arg: 1, scope: !14, file: !8, line: 10, type: !18)
+!21 = !DILocation(line: 0, scope: !14)
+!22 = !DILocation(line: 11, scope: !14)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"vtable pointer", !25, i64 0}
+!25 = !{!"Simple C++ TBAA"}
+!26 = !DILocation(line: 12, scope: !14)
+!27 = distinct !DISubprogram(name: "call_multiple", scope: !8, file: !8, line: 14, type: !28, scopeLine: 14, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!28 = !DISubroutineType(types: !29)
+!29 = !{!17}
+!30 = !DILocation(line: 15, scope: !27)
+!31 = !DILocation(line: 16, scope: !27)
+!32 = !DILocation(line: 17, scope: !27)