[WebAssembly] Handle debug information and virtual registers without crashing (reland r278967)

[ddcc]

Summary

Reland of r278967 (reverted in r278973), added lit.local.cfg to prevent test failures on non-WebAssembly builds.

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

[dexonsmith]

Assuming this is the same as r278967 but with the shiny new lit.local.cfg, this LGTM!

[dexonsmith]

But note: the commit message should really mention the old commit (and the revert) and say what you fixed.

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;
     }
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;

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.

test/DebugInfo/WebAssembly/dbg-declare.ll

+; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown | FileCheck %s
+; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown -fast-isel | FileCheck --check-prefix=CHECK-FAST %s
+; CHECK: #DEBUG_VALUE: decode:i <- [%vreg
+; CHECK: #DEBUG_VALUE: decode:v <- [%vreg
+; CHECK: DW_TAG_variable
+; CHECK-FAST: DW_TAG_variable
+
+; Test that llvm.dbg.declare() instrinsics do not crash the backend
+
+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/lit.local.cfg

+if not 'WebAssembly' in config.root.targets:
+    config.unsupported = True