[WebAssembly] Do nothing when sinking to same place

[aheejin]

Summary

In DebugValueManager, if a Def is requested to be sunk to the same
place (i.e., Insert is right after Def, not counting DBG_VALUEs)
currently we still do the sink. This can result in unnecessary creation
of DBG_VALUE $noreg. See comments for details. This CL detects this
case and do nothing and return, so we don't end up creating unnecessary
undef DBG_VALUEs.

llvm/lib/Target/WebAssembly/WebAssemblyDebugValueManager.h

 class MachineInstr;
 
 class WebAssemblyDebugValueManager {
   MachineInstr *Def;
   SmallVector<MachineInstr *, 1> DbgValues;
   Register CurrentReg;
   SmallVector<MachineInstr *>
   getSinkableDebugValues(MachineInstr *Insert) const;
+  bool isInsertSamePlace(MachineInstr *Insert) const;
 
 public:
   WebAssemblyDebugValueManager(MachineInstr *Def);
 
   // Sink 'Def', and also sink its eligible DBG_VALUEs to the place before
   // 'Insert'. Convert the original DBG_VALUEs into undefs.
   void sink(MachineInstr *Insert);
   // Clone 'Def' (optionally), and also clone its eligible DBG_VALUEs to the

llvm/lib/Target/WebAssembly/WebAssemblyDebugValueManager.cpp

for (auto *OverlappingDV : OverlappingDbgValues) {
       }
     }
     if (Sinkable)
       SinkableDbgValues.push_back(DV);
   }
   return SinkableDbgValues;
 }
 
+// Returns true if the insertion point is the same as the current place.
+// Following DBG_VALUEs for 'Def' are ignored.
+bool WebAssemblyDebugValueManager::isInsertSamePlace(
+    MachineInstr *Insert) const {
+  if (Def->getParent() != Insert->getParent())
+    return false;
+  for (MachineBasicBlock::iterator MI = std::next(Def->getIterator()),
+                                   ME = Insert;
+       MI != ME; ++MI) {
+    if (std::find(DbgValues.begin(), DbgValues.end(), MI) == DbgValues.end()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // Sink 'Def', and also sink its eligible DBG_VALUEs to the place before
 // 'Insert'. Convert the original DBG_VALUEs into undefs.
 //
 // For DBG_VALUEs to sink properly, if 'Def' and 'Insert' are within the same
 // BB, 'Insert' should be below 'Def'; if they are in different BBs, 'Insert'
 // should be in one of 'Def's BBs successors. Def will be sunk regardless of the
 // location.
 //
 // This DebugValueManager's new Def and DbgValues will be updated to the newly
 // sinked Def + DBG_VALUEs.
 void WebAssemblyDebugValueManager::sink(MachineInstr *Insert) {
+  // In case Def is requested to be sunk to
+  // the same place, we don't need to do anything. If we actually do the sink,
+  // it will create unnecessary undef DBG_VALUEs. For example, if the original
+  // code is:
+  //   %0 = someinst           // Def
+  //   DBG_VALUE %0, ...
+  //   %1 = anotherinst        // Insert
+  //
+  // If we actually sink %0 and the following DBG_VALUE and setting the original
+  // DBG_VALUE undef, the result will be:
+  //   DBG_VALUE %noreg, ...   // Unnecessary!
+  //   %0 = someinst           // Def
+  //   DBG_VALUE %0, ...
+  //   %1 = anotherinst        // Insert
+  if (isInsertSamePlace(Insert))
+    return;
+
   MachineBasicBlock *MBB = Insert->getParent();
   MachineFunction *MF = MBB->getParent();
 
   // Get the list of sinkable DBG_VALUEs. This should be done before sinking
   // Def, because we need to examine instructions between Def and Insert.
   SmallVector<MachineInstr *, 1> SinkableDbgValues =
       getSinkableDebugValues(Insert);
 

llvm/test/DebugInfo/WebAssembly/dbg-value-reg-stackify.mir

body: |
   bb.0:
     liveins: $arguments
     %0:i32 = CONST_I32 1, implicit-def $arguments
     DBG_VALUE %0:i32, $noreg, !5, !DIExpression(), debug-location !10
     DBG_VALUE %0:i32, $noreg, !11, !DIExpression(), debug-location !10
     CALL @use, %0:i32, implicit-def $arguments
     RETURN implicit-def $arguments
 
-  ; CHECK:      DBG_VALUE $noreg, $noreg, ![[VAR_A]], !DIExpression()
-  ; CHECK-NEXT: DBG_VALUE $noreg, $noreg, ![[VAR_B]], !DIExpression()
-  ; CHECK-NEXT: %0:i32 = CONST_I32 1, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack
+  ; CHECK:      %0:i32 = CONST_I32 1, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack
   ; CHECK-NEXT: DBG_VALUE %0, $noreg, ![[VAR_A]], !DIExpression()
   ; CHECK-NEXT: DBG_VALUE %0, $noreg, ![[VAR_B]], !DIExpression()
   ; CHECK-NEXT: CALL @use, %0, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack
   ; CHECK-NEXT: RETURN implicit-def $arguments
 ...
 
 ---
 # A DBG_VALUE cannot be sunk across another DBG_VALUE that has the same