[WebAssembly] Ignore DBG_VALUE in WebAssemblyCFGStackify pass when looking for block start

[yurydelendik]

Summary

Fixes https://bugs.llvm.org/show_bug.cgi?id=39158 and regression caused by
D49034. Though it is possible the problem was existed before and was exposed by
additional DBG_VALUEs.

[aheejin]

Why should we skip debug instructions when searching for block start?

[yurydelendik]

In D52837#1254005, @aheejin wrote:

Why should we skip debug instructions when searching for block start?

debug instructions can interleaved between any instruction, e.g. i32.wrap/i64 and i32.eqz in this case. Which causes block to start from i32.eqz and causing the validation error as mentioned in https://bugs.llvm.org/show_bug.cgi?id=39158

[aheejin]

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

313

How about if (std::prev(I)->isDebugInstr() || std::prev(I)->isPosition()) ? The same for the TRY placement. Because labels also can go anywhere and are not stackified.

[yurydelendik]

Skipping labels

[yurydelendik]

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

313

Added "std::prev(I)->isPosition()". Thanks.

[aheejin]

test/CodeGen/WebAssembly/cfg-stackify-dbg-skip.ll

8

Maybe a little comment about what this test is about would be good for future readers..? Like, why block should be placed there and where a debug instruction was in MIR. (Speaking of which, an MIR test would probably be better, but I guess this is also fine)

[yurydelendik]

Add test comment

[sbc100]

Is there any way to we can make this test case more focused?

How does the output of the test differ without this fix?

[yurydelendik]

In D52837#1254381, @sbc100 wrote:

How does the output of the test differ without this fix?

It inserts "block" between "i32.wrap/i64" and "i32.eqz", because there DBG_VALUE after "i32.wrap/i64"

[aheejin]

In D52837#1254381, @sbc100 wrote:

Is there any way to we can make this test case more focused?

How does the output of the test differ without this fix?

In MIR tests,

before (wrong):

%18:i32 = I32_WRAP_I64 ...  ; defines %18
DBG_VALUE ...
BLOCK
BR_UNLESS ... %18 ...      ; uses %18

after (right):

BLOCK
%18:i32 = I32_WRAP_I64 ...  ; defines %18
DBG_VALUE ...
BR_UNLESS ... %18 ...      ; uses %18

So I32_WRAP_I64 is a child of BR_UNLESS in the stackified form, but the loop stops at DBG_VALUE without checking I32_WRAP_I64 and places BLOCK in the middle of the stackified instruction sequence.

I think the way we can make this test case clearer or more focused is do an MIR test, which would show the instruction sequence containing DBG_VALUE, which disappears in .s file, as I suggested above.

[aheejin]

Maybe it's better to do an MIR test anyway.

[yurydelendik]

Add mir test

[aheejin]

I'm sorry, it turns out this MIR test doesn't work for now, because the target-specific state in the target-specific MachineFunctionInfo subclasses isn’t serialized at the moment. Continuing our discussion from IRC, the reason why this MIR test succeeds even without your patch is, [[ https://github.com/llvm-mirror/llvm/blob/f590076c467cd7ea2a349c81ae02bafe71591496/lib/Target/WebAssembly/WebAssemblyUtilities.cpp#L102 | MFI.isVRegStackified(Reg) ]] in [[ https://github.com/llvm-mirror/llvm/blob/f590076c467cd7ea2a349c81ae02bafe71591496/lib/Target/WebAssembly/WebAssemblyUtilities.cpp#L93-L103 | WebAssembly::isChild ]] always returns false, because [[ https://github.com/llvm-mirror/llvm/blob/f590076c467cd7ea2a349c81ae02bafe71591496/lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h#L38-L44 | VRegStackified ]] variable accessed in [[ https://github.com/llvm-mirror/llvm/blob/f590076c467cd7ea2a349c81ae02bafe71591496/lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h#L96-L101 | WebAssemblyFunctionInfo::isVRegStackified ]] is now empty. This is supposed to be populated in RegStackify pass, but MIR file cannot serialize information in target-dependent subclasses of MachineFunctionInfo, so we can't pass that info to CFGStackify here.

The serialization of target-dependent MachineFunctionInfo is something I'd like to implement someday for my own purpose unless someone does that by then, but I don't think this patch should be blocked on it anyway. One way we possibly still do an MIR test is to pass multiple passes to llc. AFAIK you can pass multiple -run-pass flags to llc, like llc -run-pass wasm-reg-stackify -run-pass wasm-reg-coloring .... Maybe we can start from mir just before the RegStackify pass and make llc run all passes from RegStackify to CFGStackify. I think it's worth trying. If this fails for some other reason, we can bring back .ll test case...

Either way, could you minimize the test case and elaborate little more on 'before' and 'after' results? I'm sorry for the hassle. Thank you.

[yurydelendik]

Revert test to .ll form, but ensure valid input before wasm-cfg-stackify pass

[yurydelendik]

In D52837#1255219, @aheejin wrote:

.. you can pass multiple -run-pass flags to llc, like llc -run-pass wasm-reg-stackify -run-pass wasm-reg-coloring .... Maybe we can start from mir just before the RegStackify pass and make llc run all passes from RegStackify to CFGStackify. I think it's worth trying. If this fails for some other reason, we can bring back .ll test case...

I had not luck with making a mir test this way: it fails at wasm-explicit-locals pass. Locks like I need to list all passes starting from basic one -- the same thing running .ll would do.

I reverted back to the .ll test, though I start checking MIR before and after wasm-cfg-stackify pass and location of the DBG_VALUE.

[aheejin]

Thank you. Could you minimize the test so it becomes something like a unit test..? This test looks rather like generated. And I'm not sure we need all those debug values either..

test/CodeGen/WebAssembly/cfg-stackify-dbg-skip.ll

7

How about 'stackified expression' instead of 'logical expression'?

[sbc100]

Would bugpoint help here? Its specifically designed to minimize test case I think although I don't have a lot of experience with it myself.

[yurydelendik]

Minimize test case; fix its comment

[yurydelendik]

In D52837#1255388, @sbc100 wrote:

Would bugpoint help here? Its specifically designed to minimize test case I think although I don't have a lot of experience with it myself.

I run delta tool -- it took 20 lines off. I need to figure out what is encoded in the DIDerivedType's to further reduce the test.

[yurydelendik]

Further reduction of cfg-stackify-dbg-skip.ll

[aheejin]

Thank you! From what you uploaded, I tried to tidy it a bit more. What do you think?
This is basically the same as what you uploaded, but I simplified variable names a bit, and deleted a few more unused lines, and added a bit more comments.
And I don't think we need the BEFORE check... what I meant by the 'before' check in the comment above was, before your fix, the wrong code sequence generated was like that. I wasn't suggesting to compare before and after CFGStackify.

; RUN: llc %s -stop-after wasm-cfg-stackify -o - | FileCheck %s

; The test ensures "block" instruction is not inserted in the middle of a group
; of instructions that form a stackified expression when DBG_VALUE is present
; among them.

; CHECK: body:
; CHECK: BLOCK
;                       <-- Stackified expression starts
; CHECK-NEXT: GET_LOCAL_I64
; CHECK-NEXT: I32_WRAP_I64
; CHECK-NEXT: DBG_VALUE
;                       <-- BLOCK should NOT be placed here!
; CHECK-NEXT: BR_UNLESS
;                       <-- Stackified expression ends

target triple = "wasm32-unknown-unknown"

define void @foo(i64 %arg) {
start:
  %val = trunc i64 %arg to i32
  %cmp = icmp eq i32 %val, 0
  call void @llvm.dbg.value(metadata i32 %val, metadata !46, metadata !DIExpression()), !dbg !105
  br i1 %cmp, label %bb2, label %bb1
bb1:                                              ; preds = %start
  call void @bar()
  br label %bb2
bb2:                                              ; preds = %bb1, start
  ret void
}

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

!llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!33}
!0 = distinct !DICompileUnit(language: DW_LANG_Rust, file: !6, producer: "clang LLVM (rustc version 1.30.0-dev)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !2)
!2 = !{}
!6 = !DIFile(filename: "<unknown>", directory: "")
!22 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "&str", file: !6, size: 64, align: 32, elements: !{}, identifier: "111094d970b097647de579f9c509ef08")
!33 = !{i32 2, !"Debug Info Version", i32 3}
!35 = distinct !DILexicalBlock(scope: !37, file: !6, line: 357, column: 8)
!37 = distinct !DISubprogram(name: "foobar", linkageName: "_fooba", scope: !38, file: !6, line: 353, type: !39, isLocal: true, isDefinition: true, scopeLine: 353, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !2, retainedNodes: !42)
!38 = !DINamespace(name: "ptr", scope: null)
!39 = !DISubroutineType(types: !2)
!42 = !{!46}
!46 = !DILocalVariable(name: "z", scope: !35, file: !6, line: 357, type: !22, align: 4)
!105 = !DILocation(line: 357, column: 12, scope: !35)

[yurydelendik]

And I don't think we need the BEFORE check... what I meant by the 'before' check in the comment above was, before your fix, the wrong code sequence generated was like that.

CHECK-BEFORE is a sanity check in case if some of the passes decide to rearrange the instructions or remove DBG_VALUE. Maybe it was an overkill.

Thank you for the reduced test case.

[yurydelendik]

Further reduced by @aheejin test case

[aheejin]

This comment was removed by aheejin.

[aheejin]

Thank you!

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

#endif
     // Terminators should go after the BLOCK.
     if (MI.isTerminator())
       AfterSet.insert(&MI);
   }
 
   // Local expression tree should go after the BLOCK.
   for (auto I = Header->getFirstTerminator(), E = Header->begin(); I != E;
        --I) {
+    if (std::prev(I)->isDebugInstr() || std::prev(I)->isPosition())
+      continue;
     if (WebAssembly::isChild(*std::prev(I), MFI))
       AfterSet.insert(&*std::prev(I));
     else
       break;
   }
 
   // Add the BLOCK.
   auto InsertPos = GetLatestInsertPos(Header, BeforeSet, AfterSet);
#endif
     // Terminators should go after the TRY.
     if (MI.isTerminator())
       AfterSet.insert(&MI);
   }
 
   // Local expression tree should go after the TRY.
   for (auto I = Header->getFirstTerminator(), E = Header->begin(); I != E;
        --I) {
+    if (std::prev(I)->isDebugInstr() || std::prev(I)->isPosition())
+      continue;
     if (WebAssembly::isChild(*std::prev(I), MFI))
       AfterSet.insert(&*std::prev(I));
     else
       break;
   }
 
   // If Header unwinds to MBB (= Header contains 'invoke'), the try block should
   // contain the call within it. So the call should go after the TRY. The

test/CodeGen/WebAssembly/cfg-stackify-dbg-skip.ll

+; RUN: llc %s -O2 -filetype=asm -o - | FileCheck %s
+
+; The test checks if "block" instruction was not inserted inside group of
+; of instructions that form a logical expression. In this case, the test
+; instructions contain DBG_VALUE between them.
+; CHECK: foo:
+; CHECK: block
+; CHECK: get_local
+; CHECK: i32.wrap/i64
+; CHECK: i32.eqz
+
+; ModuleID = 'foo.ll'
+source_filename = "foo.3a1fbbbh-cgu.0"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+; Function Attrs: nounwind
+define {}* @foo({ i8*, i32 }* nocapture, i32, i64) local_unnamed_addr #0 {
+start:
+  %tmp.sroa.0.0.extract.trunc.i.i.i.i.i = trunc i64 %2 to i32
+  %.sroa_cast1.i.i = bitcast { i8*, i32 }* %0 to i32*, !dbg !34
+  store i32 0, i32* %.sroa_cast1.i.i, align 4
+  %3 = icmp eq i32 %tmp.sroa.0.0.extract.trunc.i.i.i.i.i, 0
+  br i1 %3, label %bb9, label %bb2
+
+bb2:                                              ; preds = %start
+  %tmp.sroa.4.0.extract.shift.i.i.i.i.i = lshr i64 %2, 32
+  %tmp.sroa.4.0.extract.trunc.i.i.i.i.i = trunc i64 %tmp.sroa.4.0.extract.shift.i.i.i.i.i to i32
+  call void @llvm.dbg.value(metadata i32 %tmp.sroa.0.0.extract.trunc.i.i.i.i.i, metadata !46, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !105
+  %4 = tail call i8* @malloc(i32 8)
+  %5 = getelementptr inbounds i8, i8* %4, i32 4
+  %6 = bitcast i8* %5 to i32*
+  store i32 %tmp.sroa.4.0.extract.trunc.i.i.i.i.i, i32* %6, align 4
+  %7 = bitcast i8* %4 to {}*
+  br label %bb9
+
+bb9:                                              ; preds = %bb2, %start
+  %data.sroa.0.0 = phi {}* [ %7, %bb2 ], [ inttoptr (i32 1 to {}*), %start ]
+  ret {}* %data.sroa.0.0
+}
+
+; Function Attrs: nounwind
+declare noalias i8* @malloc(i32) unnamed_addr #0
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!33}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_Rust, file: !1, producer: "clang LLVM (rustc version 1.30.0-dev)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "foo.rs", directory: "/misc/coresimd")
+!2 = !{}
+!3 = !{!4, !29, !31}
+!4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
+!5 = distinct !DIGlobalVariable(name: "vtable", scope: null, file: !6, type: !7, isLocal: true, isDefinition: true)
+!6 = !DIFile(filename: "<unknown>", directory: "")
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "vtable", file: !6, align: 32, flags: DIFlagArtificial, elements: !2, vtableHolder: !8, identifier: "vtable")
+!8 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "PanicPayload<&str>", scope: !9, file: !6, size: 64, align: 32, elements: !12, identifier: "f20029ab88f79681a6fb4031dc880864")
+!9 = !DINamespace(name: "begin_panic", scope: !10)
+!10 = !DINamespace(name: "panicking", scope: !11)
+!11 = !DINamespace(name: "std", scope: null)
+!12 = !{!13}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "inner", scope: !8, file: !6, baseType: !14, size: 64, align: 32)
+!14 = distinct !DICompositeType(tag: DW_TAG_union_type, name: "Option<&str>", scope: !15, file: !6, size: 64, align: 32, elements: !17, identifier: "fa309c24fa29eafa7eabc3e820fdb228")
+!15 = !DINamespace(name: "option", scope: !16)
+!16 = !DINamespace(name: "core", scope: null)
+!17 = !{!18}
+!18 = !DIDerivedType(tag: DW_TAG_member, name: "RUST$ENCODED$ENUM$0$None", scope: !14, file: !6, baseType: !19, size: 64, align: 32)
+!19 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Some", scope: !15, file: !6, size: 64, align: 32, elements: !20, identifier: "fa309c24fa29eafa7eabc3e820fdb228::Some")
+!20 = !{!21}
+!21 = !DIDerivedType(tag: DW_TAG_member, name: "__0", scope: !19, file: !6, baseType: !22, size: 64, align: 32)
+!22 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "&str", file: !6, size: 64, align: 32, elements: !23, identifier: "111094d970b097647de579f9c509ef08")
+!23 = !{!24, !27}
+!24 = !DIDerivedType(tag: DW_TAG_member, name: "data_ptr", scope: !22, file: !6, baseType: !25, size: 32, align: 32)
+!25 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "*const u8", baseType: !26, size: 32, align: 32)
+!26 = !DIBasicType(name: "u8", size: 8, encoding: DW_ATE_unsigned)
+!27 = !DIDerivedType(tag: DW_TAG_member, name: "length", scope: !22, file: !6, baseType: !28, size: 32, align: 32, offset: 32)
+!28 = !DIBasicType(name: "usize", size: 32, encoding: DW_ATE_unsigned)
+!29 = !DIGlobalVariableExpression(var: !30, expr: !DIExpression())
+!30 = distinct !DIGlobalVariable(name: "vtable", scope: null, file: !6, type: !7, isLocal: true, isDefinition: true)
+!31 = !DIGlobalVariableExpression(var: !32, expr: !DIExpression())
+!32 = distinct !DIGlobalVariable(name: "vtable", scope: null, file: !6, type: !7, isLocal: true, isDefinition: true)
+!33 = !{i32 2, !"Debug Info Version", i32 3}
+!34 = !DILocation(line: 358, column: 8, scope: !35, inlinedAt: !49)
+!35 = distinct !DILexicalBlock(scope: !37, file: !36, line: 357, column: 8)
+!36 = !DIFile(filename: "/misc/libcore/ptr.rs", directory: "")
+!37 = distinct !DISubprogram(name: "swap_nonoverlapping_one<core::option::Option<&str>>", linkageName: "_ZN4core3ptr23swap_nonoverlapping_one17h9b13106d1b81ade4E", scope: !38, file: !36, line: 353, type: !39, isLocal: true, isDefinition: true, scopeLine: 353, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !47, retainedNodes: !42)
+!38 = !DINamespace(name: "ptr", scope: !16)
+!39 = !DISubroutineType(types: !40)
+!40 = !{null, !41, !41}
+!41 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "*mut core::option::Option<&str>", baseType: !14, size: 32, align: 32)
+!42 = !{!43, !45, !46}
+!43 = !DILocalVariable(name: "x", arg: 1, scope: !37, file: !44, line: 1, type: !41)
+!44 = !DIFile(filename: "foo.rs", directory: "")
+!45 = !DILocalVariable(name: "y", arg: 2, scope: !37, file: !44, line: 1, type: !41)
+!46 = !DILocalVariable(name: "z", scope: !35, file: !36, line: 357, type: !14, align: 4)
+!47 = !{!48}
+!48 = !DITemplateTypeParameter(name: "T", type: !14)
+!49 = distinct !DILocation(line: 637, column: 8, scope: !50, inlinedAt: !60)
+!50 = distinct !DILexicalBlock(scope: !52, file: !51, line: 636, column: 4)
+!51 = !DIFile(filename: "/misc/libcore/mem.rs", directory: "")
+!52 = distinct !DISubprogram(name: "swap<core::option::Option<&str>>", linkageName: "_ZN4core3mem4swap17hf525fca8ad6e588dE", scope: !53, file: !51, line: 635, type: !54, isLocal: true, isDefinition: true, scopeLine: 635, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !47, retainedNodes: !57)
+!53 = !DINamespace(name: "mem", scope: !16)
+!54 = !DISubroutineType(types: !55)
+!55 = !{null, !56, !56}
+!56 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "&mut core::option::Option<&str>", baseType: !14, size: 32, align: 32)
+!57 = !{!58, !59}
+!58 = !DILocalVariable(name: "x", arg: 1, scope: !52, file: !44, line: 1, type: !56)
+!59 = !DILocalVariable(name: "y", arg: 2, scope: !52, file: !44, line: 1, type: !56)
+!60 = distinct !DILocation(line: 695, column: 4, scope: !61, inlinedAt: !67)
+!61 = distinct !DISubprogram(name: "replace<core::option::Option<&str>>", linkageName: "_ZN4core3mem7replace17he6f7041b81a6d845E", scope: !53, file: !51, line: 694, type: !62, isLocal: true, isDefinition: true, scopeLine: 694, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !47, retainedNodes: !64)
+!62 = !DISubroutineType(types: !63)
+!63 = !{!14, !56, !14}
+!64 = !{!65, !66}
+!65 = !DILocalVariable(name: "dest", arg: 1, scope: !61, file: !44, line: 1, type: !56)
+!66 = !DILocalVariable(name: "src", arg: 2, scope: !61, file: !44, line: 1, type: !14)
+!67 = distinct !DILocation(line: 858, column: 8, scope: !68, inlinedAt: !76)
+!68 = distinct !DISubprogram(name: "take<&str>", linkageName: "_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17ha569a64f962bb285E", scope: !14, file: !69, line: 857, type: !70, isLocal: true, isDefinition: true, scopeLine: 857, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !74, retainedNodes: !72)
+!69 = !DIFile(filename: "/misc/libcore/option.rs", directory: "")
+!70 = !DISubroutineType(types: !71)
+!71 = !{!14, !56}
+!72 = !{!73}
+!73 = !DILocalVariable(name: "self", arg: 1, scope: !68, file: !44, line: 1, type: !56)
+!74 = !{!75}
+!75 = !DITemplateTypeParameter(name: "T", type: !22)
+!76 = distinct !DILocation(line: 425, column: 29, scope: !77)
+!77 = distinct !DISubprogram(name: "box_me_up<&str>", linkageName: "_ZN91_$LT$std..panicking..begin_panic..PanicPayload$LT$A$GT$$u20$as$u20$core..panic..BoxMeUp$GT$9box_me_up17h0db1ddc6159c8fb6E", scope: !79, file: !78, line: 424, type: !80, isLocal: true, isDefinition: true, scopeLine: 424, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !103, retainedNodes: !93)
+!78 = !DIFile(filename: "/misc/libstd/panicking.rs", directory: "")
+!79 = !DINamespace(name: "{{impl}}", scope: !9)
+!80 = !DISubroutineType(types: !81)
+!81 = !{!82, !92}
+!82 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "*mut Any", scope: !83, file: !6, size: 64, align: 32, elements: !84, identifier: "53372fa6cb48d0d4ed09ef2b1dc9567c")
+!83 = !DINamespace(name: "any", scope: !16)
+!84 = !{!85, !87}
+!85 = !DIDerivedType(tag: DW_TAG_member, name: "pointer", scope: !82, file: !6, baseType: !86, size: 32, align: 32, flags: DIFlagArtificial)
+!86 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "*mut u8", baseType: !26, size: 32, align: 32)
+!87 = !DIDerivedType(tag: DW_TAG_member, name: "vtable", scope: !82, file: !6, baseType: !88, size: 32, align: 32, offset: 32, flags: DIFlagArtificial)
+!88 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "&[usize; 3]", baseType: !89, size: 32, align: 32)
+!89 = !DICompositeType(tag: DW_TAG_array_type, baseType: !28, size: 96, align: 32, elements: !90)
+!90 = !{!91}
+!91 = !DISubrange(count: 3)
+!92 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "&mut std::panicking::begin_panic::PanicPayload<&str>", baseType: !8, size: 32, align: 32)
+!93 = !{!94, !95, !101}
+!94 = !DILocalVariable(name: "self", arg: 1, scope: !77, file: !44, line: 1, type: !92)
+!95 = !DILocalVariable(name: "data", scope: !96, file: !78, line: 425, type: !97, align: 4)
+!96 = distinct !DILexicalBlock(scope: !77, file: !78, line: 425, column: 12)
+!97 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Box<Any>", scope: !83, file: !6, size: 64, align: 32, elements: !98, identifier: "9e5777c3b641846cf0b3f45ae396cc20")
+!98 = !{!99, !100}
+!99 = !DIDerivedType(tag: DW_TAG_member, name: "pointer", scope: !97, file: !6, baseType: !86, size: 32, align: 32, flags: DIFlagArtificial)
+!100 = !DIDerivedType(tag: DW_TAG_member, name: "vtable", scope: !97, file: !6, baseType: !88, size: 32, align: 32, offset: 32, flags: DIFlagArtificial)
+!101 = !DILocalVariable(name: "a", scope: !102, file: !78, line: 426, type: !22, align: 4)
+!102 = distinct !DILexicalBlock(scope: !77, file: !78, line: 426, column: 27)
+!103 = !{!104}
+!104 = !DITemplateTypeParameter(name: "A", type: !22)
+!105 = !DILocation(line: 357, column: 12, scope: !35, inlinedAt: !49)