[WebAssembly] Use MachineInstr::setDebugValueUndef

[aheejin]

Summary

When making DBG_VALUE/DBG_VALUE_LIST instructions undefined, there
is a method that takes care of it so we don't need to do it manually.
This changes the test because previously we are converting
DBG_VALUE_LISTs into DBG_VALUE $noreg but now we leave
DBG_VALUE_LIST but set it to undef by turning all its register
operands $noreg. The effect is the same.

[dschuff]

When making DBG_VALUE/DBG_VALUE_INST instructions undefined

Did you mean "DBG_VALUE/DBG_VALUE_LIST" ?

[aheejin]

Yes correct.

llvm/lib/Target/WebAssembly/WebAssemblyDebugFixup.cpp

 }
 
 // At this very end of the compilation pipeline, if any DBG_VALUEs with
 // registers remain, it means they are dangling info which we failed to update
 // when their corresponding def instruction was transformed/moved/splitted etc.
 // Because Wasm cannot access values in LLVM virtual registers in the debugger,
 // these dangling DBG_VALUEs in effect kill the effect of any previous DBG_VALUE
 // associated with the variable, which will appear as "optimized out".
-static void nullifyDanglingDebugValues(MachineBasicBlock &MBB,
+static void setDanglingDebugValuesUndef(MachineBasicBlock &MBB,
                                         const TargetInstrInfo *TII) {
   for (auto &MI : llvm::make_early_inc_range(MBB)) {
     if (MI.isDebugValue() && MI.getDebugOperand(0).isReg() &&
         !MI.isUndefDebugValue()) {
-      LLVM_DEBUG(dbgs() << "Warning: dangling DBG_VALUE nullified: " << MI
+      LLVM_DEBUG(dbgs() << "Warning: dangling DBG_VALUE set to undef: " << MI
                         << "\n");
-      MI.getDebugOperand(0).setReg(Register());
+      MI.setDebugValueUndef();
     }
   }
 }
 
 bool WebAssemblyDebugFixup::runOnMachineFunction(MachineFunction &MF) {
   LLVM_DEBUG(dbgs() << "********** Debug Fixup **********\n"
                        "********** Function: "
                     << MF.getName() << '\n');
for (auto MII = MBB.begin(); MII != MBB.end(); ++MII) {
             Stack.push_back({MO.getReg(), nullptr});
           }
         }
       }
     }
     assert(Stack.empty() &&
            "WebAssemblyDebugFixup: Stack not empty at end of basic block!");
 
-    nullifyDanglingDebugValues(MBB, TII);
+    setDanglingDebugValuesUndef(MBB, TII);
   }
 
   return true;
 }

llvm/lib/Target/WebAssembly/WebAssemblyNullifyDebugValueLists.cpp

FunctionPass *llvm::createWebAssemblyNullifyDebugValueLists() {
   return new WebAssemblyNullifyDebugValueLists();
 }
 
 bool WebAssemblyNullifyDebugValueLists::runOnMachineFunction(
     MachineFunction &MF) {
   LLVM_DEBUG(dbgs() << "********** Nullify DBG_VALUE_LISTs **********\n"
                        "********** Function: "
                     << MF.getName() << '\n');
-  const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
-  SmallVector<MachineInstr *, 2> DbgValueLists;
-  for (auto &MBB : MF)
-    for (auto &MI : MBB)
-      if (MI.getOpcode() == TargetOpcode::DBG_VALUE_LIST)
-        DbgValueLists.push_back(&MI);
-
+  bool Changed = false;
   // Our backend, including WebAssemblyDebugValueManager, currently cannot
-  // handle DBG_VALUE_LISTs correctly. So this converts DBG_VALUE_LISTs to
-  // "DBG_VALUE $noreg", which will appear as "optimized out".
-  for (auto *DVL : DbgValueLists) {
-    BuildMI(*DVL->getParent(), DVL, DVL->getDebugLoc(),
-            TII.get(TargetOpcode::DBG_VALUE), false, Register(),
-            DVL->getOperand(0).getMetadata(), DVL->getOperand(1).getMetadata());
-    DVL->eraseFromParent();
+  // handle DBG_VALUE_LISTs correctly. So this makes them undefined, which will
+  // appear as "optimized out".
+  for (auto &MBB : MF) {
+    for (auto &MI : MBB) {
+      if (MI.getOpcode() == TargetOpcode::DBG_VALUE_LIST) {
+        MI.setDebugValueUndef();
+        Changed = true;
       }
-
-  return !DbgValueLists.empty();
+    }
+  }
+  return Changed;
 }

llvm/test/DebugInfo/WebAssembly/dbg-value-list.ll

 ; RUN: llc %s -stop-before wasm-nullify-dbg-value-lists -o - | FileCheck %s --check-prefix=BEFORE
 ; RUN: llc %s -stop-after wasm-nullify-dbg-value-lists -o - | FileCheck %s --check-prefix=AFTER
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; WebAssembly backend does not currently handle DBG_VALUE_LIST instructions
-; correctly. In the meantime, they are converted to 'DBG_VALUE $noreg's in
+; correctly. In the meantime, they are converted to undefs in
 ; WebAssemblyNullifyDebugValueLists pass.
 
-; BEFORE: DBG_VALUE_LIST
-; AFTER-NOT: DBG_VALUE_LIST
-; AFTER: DBG_VALUE $noreg, $noreg
+; BEFORE: DBG_VALUE_LIST !{{[0-9]+}}, !DIExpression(), %{{[0-9]+}}, %{{[0-9]+}}
+; AFTER: DBG_VALUE_LIST !{{[0-9]+}}, !DIExpression(), $noreg, $noreg
 define i32 @dbg_value_list_test() !dbg !6 {
 entry:
   %0 = call i32 @foo(), !dbg !9
   %1 = call i32 @foo(), !dbg !10
   %2 = add i32 %0, %1, !dbg !11
   ; This DIArgList operand generates a DBG_VALUE_LIST instruction
   call void @llvm.dbg.value(metadata !DIArgList(i32 %0, i32 %1), metadata !8, metadata !DIExpression()), !dbg !11
   ret i32 %2, !dbg !12