[WebAssembly] Handle debug information and virtual registers without crashing

[ddcc]

Summary

Currently, enabling debug information when compiling for WebAssembly crashes the backend. This commit fixes these by skipping debug values in backend passes.

[MatzeB]

lib/CodeGen/LiveIntervalAnalysis.cpp

1316–1326 ↗

(On Diff #62120)

This is a strange change, MRI.use_nodbg_operands() should not return operands of DebugValues (hence the _nodbg_ in the name). Why do you still need to skip them?

lib/CodeGen/LiveRangeCalc.cpp

187–188 ↗

(On Diff #62120)

This is a strange change, MRI.use_nodbg_operands() should not return operands of DebugValues (hence the _nodbg_ in the name). Why do you still need to skip them?

[ddcc]

Set isDebug on MachineOperand's

[ddcc]

You're right, it looks like the isDebug parameter wasn't being set correctly on MachineOperand's, so the nodbg iterator didn't do anything. The updated patch sets that parameter now, but I'm not sure if it's in the correct place, or if the other parameters (e.g. isUse, isKill, etc) also need to be set.

[MatzeB]

With no regalloc bits left I leave the rest of the review to webassembly people.

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

260–261

This situation should still be impossible.

lib/Target/WebAssembly/WebAssemblyStoreResults.cpp

102–103

wouldn't it be easier to use a use_nodbg iterator instead of doing extra checks here?

[MatzeB]

In D21808#469407, @ddcc wrote:

You're right, it looks like the isDebug parameter wasn't being set correctly on MachineOperand's, so the nodbg iterator didn't do anything. The updated patch sets that parameter now, but I'm not sure if it's in the correct place, or if the other parameters (e.g. isUse, isKill, etc) also need to be set.

DebugValue only has inputs so MachineOperand::IsDebug==1 should imply IsUse. Debug values should be excluded from any liveness calculation, so IsKill/IsDead/IsUndef should have no effect.

[jfb]

The examples are pretty wordy, could you trim them so they have less code while preserving the same checks?

[jfb]

The examples are pretty wordy, could you trim them so they have less code while preserving the same checks?

[ddcc]

Reduce testcase, simplify code

[ddcc]

Simplify one more iterator

[jfb]

lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp

92

This is the part that was missing for use_nodbg_iterands to skip?

[ddcc]

lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp

92

Yeah, but I'm not sure if this is the right way to do it.

[sunfish]

I'm concerned about the changes in DbgValueHistoryCalculator.cpp. WebAssembly is currently using virtual registers essentially in the way other architectures use physical registers at this point, so it's not obvious that, eg., just skipping clobberRegisterUses for virtual registers is the right approach.

[dschuff]

I think this suggested change would make DVHC "do the right thing" for vregs. Obviously that's just part of the way and we haven't solved any of the potential MC issues, etc. but it would serve the same purpose of not crashing, and be probably correct under the current usage.
Dan, what do you think?

lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp

168 ↗

(On Diff #62250)

I think it's probably safe to assume that all vregs are changing in the function, because vregs are essentially function-scoped. So that probably means we don't use ChangingRegs for vregs, and this bit is OK.

195 ↗

(On Diff #62250)

I think we do want to make this actually do the right thing (i.e. call clobberRegisterUses appropriately rather than not at all) for virtual registers.

The code in lines 197-200 (on the left side) accounts for he fact that clobbering a preg P will also clobber any other preg that aliases P, and the code on 201-212 handles a special kind of operand called a register mask that clobbers multiple pregs.

For vregs, there's no aliasing, and only one clobber is needed.

So maybe here we could just add another conditional inside the one on line 195, that handles the vreg case (i.e. calls clobberRegisterUses), and put the existing code inside its else clause.

244 ↗

(On Diff #62250)

I guess then this case would be that clobberRegisterUses would be called if the reg is virtual or in the ChangingRegs set.

[ddcc]

Modify DbgValueHistoryCalculator to clobber virtual registers without checking aliasing

[sunfish]

The changes to WebAssembly-specific code here look fine to me.

Concerning the changes to lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp, I don't have a clear picture of how virtual registers will be handled in debug info yet, so I'm not confident in reviewing changes to target-independent code myself.

That said, for present purposes it may be sufficient to just make codegen not crash. That may be sufficient to motivate the patch, however if that's the case, I'd like to get it reviewed from someone who isn't also a WebAssembly developer, since this is changing code shared by all backends.

[ddcc]

Drop changes to DbgValueHistoryCalculator

[ddcc]

Since this patch touches both wasm and other portions of LLVM, I will split off the changes to DbgValueHistoryCalculator into a separate patch.

[dschuff]

I tried this locally by itself, and it looks like it broke test/Codegen/WebAssembly/offset.ll, userstack.ll, cfg-stackify.ll, mem-intrinsics.ll, and byval.ll (I'm guessing it just perturbs the codegen but it's not obvious why). Also the new tests crash; presumably we should mark this patch as dependent on D22590; I'll try to push that forward.

[ddcc]

Yeah, it's affecting the wasm codegen, which shouldn't be happening. Let me take a look.

[ddcc]

Fix iterator invalidation

[ddcc]

Style fixup

[aprantl]

Sorry for being late to the party... Is my assumption correct that WebAssembly used only virtual registers (because it's an SSA-based representation with an infinite register file)?

[dschuff]

@aprantl
Yes, that's correct. (well, it's not an SSA-based representation but it does have the infinite register file). Backends are expected by various target-independent lowering code to have a few particular physical registers (primarily SP/FP), but after lowering to MachineInstr we actually replace those with virtual registers too and use vregs through all the common backend passes. Right before we emit, we actually do a re-numbering and coloring step (to try to reduce the total number of registers and map them into a 0-indexed number space).

Codegen-wise it's gone pretty smoothly; I did some refactoring on PrologEpilogInserter a couple months ago (which reminds me, I still owe a cleanup on that) but most of the passes do just fine. We will need some more work though for dealing with debug info and MC.

[dschuff]

@aprantl
Oh, I just realized that this is probably no longer the review that you care about; Dominic has split the target-independent changes out into D22590

[ddcc]

Move one test to dependent commit

[ddcc]

Fix test failure

[ddcc]

Please take a look.

[dschuff]

lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp

34 ↗

(On Diff #67716)

This is the stuff that was committed in rL278371, right? Can you rebase?

[ddcc]

Rebase

[dschuff]

test/DebugInfo/WebAssembly/live-intervals.ll

2

Does this work with fast-isel too?

2

I think the name of the test should refer to debug values somehow since that's why it exists.

test/DebugInfo/WebAssembly/wasm.ll

2

Likewise with fast-isel and the name of the test could be more descriptive.

[ddcc]

Rename, drop duplicate test

[ddcc]

No, it doesn't work with fast-isel; I believe there is a special fastLowerIntrinsicCall() hook that needs to implemented and a case for Intrinsic::dbg_declare. Since the two tests have overlapping functionality, I kept the more complex one.

[echristo]

In D21808#516149, @ddcc wrote:

No, it doesn't work with fast-isel; I believe there is a special fastLowerIntrinsicCall() hook that needs to implemented and a case for Intrinsic::dbg_declare. Since the two tests have overlapping functionality, I kept the more complex one.

Does need to work with fast-isel as well if that's on at O0 by default please.

Thanks!

-eric

[ddcc]

Add test for fast-isel

[ddcc]

To clarify, this patch fixes crashes in the backend for WebAssembly with debug information enabled. But this doesn't mean that the debug information is correct or usable, since we haven't decided on a debug format yet.

[dschuff]

LGTM. The fast-isel check at least ensures that we don't regress from where we are now with this patch (don't crash, even if the debug info isn't right).

[echristo]

Seems reasonable to me. Since Matthias had some concerns originally you should let him ack it as well.

-eric

[dschuff]

@MatzeB previously resigned because @ddcc got rid of all the regalloc-related changes in lib/CodeGen

[echristo]

Ah, I missed that. No worries then. LGTM.

-eric

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

static bool HasOneUse(unsigned Reg, MachineInstr *Def,
   if (MRI.hasOneUse(Reg))
     return true;
 
   bool HasOne = false;
   const LiveInterval &LI = LIS.getInterval(Reg);
   const VNInfo *DefVNI = LI.getVNInfoAt(
       LIS.getInstructionIndex(*Def).getRegSlot());
   assert(DefVNI);
-  for (auto I : MRI.use_nodbg_operands(Reg)) {
+  for (auto &I : MRI.use_nodbg_operands(Reg)) {
     const auto &Result = LI.Query(LIS.getInstructionIndex(*I.getParent()));
     if (Result.valueIn() == DefVNI) {
       if (!Result.isKill())
         return false;
       if (HasOne)
         return false;
       HasOne = true;
     }
   }
   return HasOne;
if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
       if (!MRI.isPhysRegModified(Reg))
         continue;
       // Otherwise, it's a physical register with unknown liveness.
       return false;
     }
 
     // Ask LiveIntervals whether moving this virtual register use or def to
     // Insert will change which value numbers are seen.
-    // 
+    //
     // If the operand is a use of a register that is also defined in the same
     // instruction, test that the newly defined value reaches the insert point,
     // since the operand will be moving along with the def.
     const LiveInterval &LI = LIS.getInterval(Reg);
     VNInfo *DefVNI =
         (MO.isDef() || Def->definesRegister(Reg)) ?
         LI.getVNInfoAt(LIS.getInstructionIndex(*Def).getRegSlot()) :
         LI.getVNInfoBefore(LIS.getInstructionIndex(*Def));
static bool OneUseDominatesOtherUses(unsigned Reg, const MachineOperand &OneUse,
                                      const MachineDominatorTree &MDT,
                                      LiveIntervals &LIS,
                                      WebAssemblyFunctionInfo &MFI) {
   const LiveInterval &LI = LIS.getInterval(Reg);
 
   const MachineInstr *OneUseInst = OneUse.getParent();
   VNInfo *OneUseVNI = LI.getVNInfoBefore(LIS.getInstructionIndex(*OneUseInst));
 
-  for (const MachineOperand &Use : MRI.use_operands(Reg)) {
+  for (const MachineOperand &Use : MRI.use_nodbg_operands(Reg)) {
     if (&Use == &OneUse)
       continue;
 
     const MachineInstr *UseInst = Use.getParent();
     VNInfo *UseVNI = LI.getVNInfoBefore(LIS.getInstructionIndex(*UseInst));
 
     if (UseVNI != OneUseVNI)
       continue;
 
     const MachineInstr *OneUseInst = OneUse.getParent();
     if (UseInst == OneUseInst) {
       // Another use in the same instruction. We need to ensure that the one
       // selected use happens "before" it.
       if (&OneUse > &Use)
         return false;
     } else {
       // Test that the use is dominated by the one selected use.
       while (!MDT.dominates(OneUseInst, UseInst)) {
         // Actually, dominating is over-conservative. Test that the use would
         // happen after the one selected use in the stack evaluation order.
         //
         // This is needed as a consequence of using implicit get_locals for
         // uses and implicit set_locals for defs.
-        if (UseInst->getDesc().getNumDefs() == 0) 
+        if (UseInst->getDesc().getNumDefs() == 0)
           return false;
         const MachineOperand &MO = UseInst->getOperand(0);
         if (!MO.isReg())
           return false;
         unsigned DefReg = MO.getReg();
         if (!TargetRegisterInfo::isVirtualRegister(DefReg) ||
             !MFI.isVRegStackified(DefReg))
           return false;

lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp

for (unsigned PReg = WebAssembly::NoRegister + 1;
     const TargetRegisterClass *RC = TRI.getMinimalPhysRegClass(PReg);
     unsigned VReg = WebAssembly::NoRegister;
     for (auto I = MRI.reg_begin(PReg), E = MRI.reg_end(); I != E; ) {
       MachineOperand &MO = *I++;
       if (!MO.isImplicit()) {
         if (VReg == WebAssembly::NoRegister)
           VReg = MRI.createVirtualRegister(RC);
         MO.setReg(VReg);
+        if (MO.getParent()->isDebugValue())
+          MO.setIsDebug();
         Changed = true;
       }
     }
   }
 
   return Changed;
 }

lib/Target/WebAssembly/WebAssemblyStoreResults.cpp

static bool ReplaceDominatedUses(MachineBasicBlock &MBB, MachineInstr &MI,
   LiveInterval *FromLI = &LIS.getInterval(FromReg);
   LiveInterval *ToLI = &LIS.getInterval(ToReg);
 
   SlotIndex FromIdx = LIS.getInstructionIndex(MI).getRegSlot();
   VNInfo *FromVNI = FromLI->getVNInfoAt(FromIdx);
 
   SmallVector<SlotIndex, 4> Indices;
 
-  for (auto I = MRI.use_begin(FromReg), E = MRI.use_end(); I != E;) {
+  for (auto I = MRI.use_nodbg_begin(FromReg), E = MRI.use_nodbg_end(); I != E;) {
     MachineOperand &O = *I++;
     MachineInstr *Where = O.getParent();
 
     // Check that MI dominates the instruction in the normal way.
     if (&MI == Where || !MDT.dominates(&MI, Where))
       continue;
 
     // If this use gets a different value, skip it.
     SlotIndex WhereIdx = LIS.getInstructionIndex(*Where);
     VNInfo *WhereVNI = FromLI->getVNInfoAt(WhereIdx);
     if (WhereVNI && WhereVNI != FromVNI)
       continue;
 
     // Make sure ToReg isn't clobbered before it gets there.
     VNInfo *ToVNI = ToLI->getVNInfoAt(WhereIdx);
     if (ToVNI && ToVNI != FromVNI)
       continue;
 

test/DebugInfo/WebAssembly/live-intervals.ll

+; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown | FileCheck %s
+; CHECK: #DEBUG_VALUE: decode:i <- [%vreg25+12]
+; CHECK: #DEBUG_VALUE: decode:v <- [%vreg25+11]
+; CHECK: DW_TAG_variable
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+%0 = type opaque
+
+@key = external global [15 x i8], align 1
+
+; Function Attrs: nounwind
+define internal zeroext i8 @0(i32, i8 zeroext)  !dbg !14 !type !19 {
+  %3 = alloca i32, align 4
+  %4 = alloca i8, align 1
+  store i32 %0, i32* %3, align 4
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !20, metadata !21), !dbg !22
+  store i8 %1, i8* %4, align 1
+  call void @llvm.dbg.declare(metadata i8* %4, metadata !23, metadata !21), !dbg !24
+  %5 = load i8, i8* %4, align 1, !dbg !25
+  %6 = zext i8 %5 to i32, !dbg !25
+  %7 = load i32, i32* %3, align 4, !dbg !26
+  %8 = urem i32 %7, 15, !dbg !27
+  %9 = getelementptr inbounds [15 x i8], [15 x i8]* @key, i32 0, i32 %8, !dbg !28
+  %10 = load i8, i8* %9, align 1, !dbg !28
+  %11 = zext i8 %10 to i32, !dbg !28
+  %12 = xor i32 %6, %11, !dbg !29
+  %13 = trunc i32 %12 to i8, !dbg !30
+  ret i8 %13, !dbg !31
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12}
+!llvm.ident = !{!13}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "crash.c", directory: "wasm/tests")
+!2 = !{}
+!3 = !{!4}
+!4 = distinct !DIGlobalVariable(name: "key", scope: !0, file: !1, line: 7, type: !5, isLocal: false, isDefinition: true, variable: [15 x i8]* @key)
+!5 = !DICompositeType(tag: DW_TAG_array_type, baseType: !6, size: 120, align: 8, elements: !9)
+!6 = !DIDerivedType(tag: DW_TAG_typedef, name: "uint8_t", file: !7, line: 185, baseType: !8)
+!7 = !DIFile(filename: "wasm/emscripten/system/include/libc/bits/alltypes.h", directory: "wasm/tests")
+!8 = !DIBasicType(name: "unsigned char", size: 8, align: 8, encoding: DW_ATE_unsigned_char)
+!9 = !{!10}
+!10 = !DISubrange(count: 15)
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{!"clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)"}
+!14 = distinct !DISubprogram(name: "decode", scope: !1, file: !1, line: 11, type: !15, isLocal: false, isDefinition: true, scopeLine: 11, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!15 = !DISubroutineType(types: !16)
+!16 = !{!6, !17, !6}
+!17 = !DIDerivedType(tag: DW_TAG_typedef, name: "size_t", file: !7, line: 124, baseType: !18)
+!18 = !DIBasicType(name: "long unsigned int", size: 32, align: 32, encoding: DW_ATE_unsigned)
+!19 = !{i64 0, !"_ZTSFhmhE"}
+!20 = !DILocalVariable(name: "i", arg: 1, scope: !14, file: !1, line: 11, type: !17)
+!21 = !DIExpression()
+!22 = !DILocation(line: 11, column: 23, scope: !14)
+!23 = !DILocalVariable(name: "v", arg: 2, scope: !14, file: !1, line: 11, type: !6)
+!24 = !DILocation(line: 11, column: 34, scope: !14)
+!25 = !DILocation(line: 12, column: 11, scope: !14)
+!26 = !DILocation(line: 12, column: 19, scope: !14)
+!27 = !DILocation(line: 12, column: 21, scope: !14)
+!28 = !DILocation(line: 12, column: 15, scope: !14)
+!29 = !DILocation(line: 12, column: 13, scope: !14)
+!30 = !DILocation(line: 12, column: 10, scope: !14)
+!31 = !DILocation(line: 12, column: 3, scope: !14)

test/DebugInfo/WebAssembly/variable.ll

+; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown | FileCheck %s
+; CHECK: #DEBUG_VALUE: usage:self <- %vreg0
+; CHECK: DW_TAG_variable
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+%0 = type opaque
+
+@key = external local_unnamed_addr global [15 x i8], align 1
+@.str = external unnamed_addr constant [33 x i8], align 1
+
+; Function Attrs: nounwind
+define internal i32 @0(i8*) local_unnamed_addr !dbg !14 !type !22 {
+  tail call void @llvm.dbg.value(metadata i8* %0, i64 0, metadata !21, metadata !23), !dbg !24
+  %2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i32 0, i32 0), i8* %0), !dbg !25
+  ret i32 1, !dbg !26
+}
+
+; Function Attrs: nounwind
+declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12}
+!llvm.ident = !{!13}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "crash.c", directory: "wasm/tests")
+!2 = !{}
+!3 = !{!4}
+!4 = distinct !DIGlobalVariable(name: "key", scope: !0, file: !1, line: 7, type: !5, isLocal: false, isDefinition: true, variable: [15 x i8]* @key)
+!5 = !DICompositeType(tag: DW_TAG_array_type, baseType: !6, size: 120, align: 8, elements: !9)
+!6 = !DIDerivedType(tag: DW_TAG_typedef, name: "uint8_t", file: !7, line: 185, baseType: !8)
+!7 = !DIFile(filename: "wasm/emscripten/system/include/libc/bits/alltypes.h", directory: "wasm/tests")
+!8 = !DIBasicType(name: "unsigned char", size: 8, align: 8, encoding: DW_ATE_unsigned_char)
+!9 = !{!10}
+!10 = !DISubrange(count: 15)
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{!"clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)"}
+!14 = distinct !DISubprogram(name: "usage", scope: !1, file: !1, line: 15, type: !15, isLocal: false, isDefinition: true, scopeLine: 15, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !20)
+!15 = !DISubroutineType(types: !16)
+!16 = !{!17, !18}
+!17 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !19, size: 32, align: 32)
+!19 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!20 = !{!21}
+!21 = !DILocalVariable(name: "self", arg: 1, scope: !14, file: !1, line: 15, type: !18)
+!22 = !{i64 0, !"_ZTSFiPcE"}
+!23 = !DIExpression()
+!24 = !DILocation(line: 15, column: 17, scope: !14)
+!25 = !DILocation(line: 16, column: 3, scope: !14)
+!26 = !DILocation(line: 17, column: 3, scope: !14)

test/DebugInfo/WebAssembly/wasm.ll

+; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown | FileCheck %s
+; CHECK: #DEBUG_VALUE: main:argv <- [%vreg20+12]
+; CHECK: __stack_pointer
+; CHECK: DW_TAG_variable
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+%0 = type opaque
+
+@.str = external unnamed_addr constant [33 x i8], align 1
+@.str.1 = external unnamed_addr constant [2 x i8], align 1
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+; Function Attrs: nounwind
+define hidden i32 @main(i32, i8**) !dbg !14 !type !21 {
+  %3 = alloca i8**, align 4
+  %4 = alloca %0*, align 4
+  store i8** %1, i8*** %3, align 4
+  call void @llvm.dbg.declare(metadata i8*** %3, metadata !22, metadata !23), !dbg !24
+  store %0* null, %0** %4, align 4, !dbg !25
+  %5 = call i32 @getopt(i32 undef, i8** undef, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0)), !dbg !26
+  unreachable
+}
+
+declare i32 @getopt(i32, i8**, i8*)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12}
+!llvm.ident = !{!13}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "crash.c", directory: "wasm/tests")
+!2 = !{}
+!3 = !{!4}
+!4 = distinct !DIGlobalVariable(name: "key", scope: !0, file: !1, line: 7, type: !5, isLocal: false, isDefinition: true)
+!5 = !DICompositeType(tag: DW_TAG_array_type, baseType: !6, size: 120, align: 8, elements: !9)
+!6 = !DIDerivedType(tag: DW_TAG_typedef, name: "uint8_t", file: !7, line: 185, baseType: !8)
+!7 = !DIFile(filename: "wasm/emscripten/system/include/libc/bits/alltypes.h", directory: "wasm/tests")
+!8 = !DIBasicType(name: "unsigned char", size: 8, align: 8, encoding: DW_ATE_unsigned_char)
+!9 = !{!10}
+!10 = !DISubrange(count: 15)
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{!"clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)"}
+!14 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 20, type: !15, isLocal: false, isDefinition: true, scopeLine: 20, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!15 = !DISubroutineType(types: !16)
+!16 = !{!17, !17, !18}
+!17 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !19, size: 32, align: 32)
+!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 32, align: 32)
+!20 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!21 = !{i64 0, !"_ZTSFiiPPcE"}
+!22 = !DILocalVariable(name: "argv", arg: 2, scope: !14, file: !1, line: 20, type: !18)
+!23 = !DIExpression()
+!24 = !DILocation(line: 20, column: 27, scope: !14)
+!25 = !DILocation(line: 21, column: 21, scope: !14)
+!26 = !DILocation(line: 26, column: 15, scope: !27)
+!27 = !DILexicalBlockFile(scope: !14, file: !1, discriminator: 1)