[mlir][LLVM] drop `llvm.intr.dbg.value` when promoting in `SROA` or `mem2reg`

[zero9178]

Summary

This has previously been done for llvm.intr.dbg.declare, which is a common occurrence when the debug info points to the variable through the pointer, but may also occur when the alloca itself is a local variable in debug info.

Not doing so prevents SROA and mem2reg from promoting e.g. an alloca. We simply drop the value completetly, since there is no meaninful debug info that can be constructed instead as the pointer value is removed.

[gysit]

LGTM!

[jmorse]

Drive-by comment as my email filters picked this up -- please note that deleting dbg.value intrinsics usually causes important information to be lost. Each dbg.value intrinsic is effectively a variable assignment (sort of). Deleting one is like a variable assignment ceasing to occur in the source program, earlier variable values might appear later in the function than they should do. LLVM replaces dbg.value operands with undef whenever values go away, indicating a variable assignment of a value that has been optimised out.

I've zero familiarity with MLIR, so this might be completely irrelevant, but I figured I'd point this out.

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

 }
 
 def LLVM_DbgDeclareOp : LLVM_DbgIntrOp<"dbg.declare", "addr",
     [DeclareOpInterfaceMethods<PromotableOpInterface>]> {
   let summary = "Describes how the address relates to a source language variable.";
   let arguments = (ins LLVM_AnyPointer:$addr, LLVM_DILocalVariableAttr:$varInfo);
 }
 
-def LLVM_DbgValueOp : LLVM_DbgIntrOp<"dbg.value", "value"> {
+def LLVM_DbgValueOp : LLVM_DbgIntrOp<"dbg.value", "value",
+    [DeclareOpInterfaceMethods<PromotableOpInterface>]> {
   let summary = "Describes how the value relates to a source language variable.";
   let arguments = (ins LLVM_Type:$value, LLVM_DILocalVariableAttr:$varInfo);
 }
 
 def LLVM_DbgLabelOp : LLVM_IntrOp<"dbg.label", [], [], [], 0> {
   let summary = "Relates the program to a debug information label.";
   let arguments = (ins LLVM_DILabelAttr:$label);
   let llvmBuilder = [{

mlir/lib/Dialect/LLVMIR/IR/LLVMMemorySlot.cpp

bool LLVM::DbgDeclareOp::canUsesBeRemoved(
   return true;
 }
 
 DeletionKind LLVM::DbgDeclareOp::removeBlockingUses(
     const SmallPtrSetImpl<OpOperand *> &blockingUses, RewriterBase &rewriter) {
   return DeletionKind::Delete;
 }
 
+bool LLVM::DbgValueOp::canUsesBeRemoved(
+    const SmallPtrSetImpl<OpOperand *> &blockingUses,
+    SmallVectorImpl<OpOperand *> &newBlockingUses) {
+  return true;
+}
+
+DeletionKind LLVM::DbgValueOp::removeBlockingUses(
+    const SmallPtrSetImpl<OpOperand *> &blockingUses, RewriterBase &rewriter) {
+  return DeletionKind::Delete;
+}
+
 //===----------------------------------------------------------------------===//
 // Interfaces for GEPOp
 //===----------------------------------------------------------------------===//
 
 static bool hasAllZeroIndices(LLVM::GEPOp gepOp) {
   return llvm::all_of(gepOp.getIndices(), [](auto index) {
     auto indexAttr = llvm::dyn_cast_if_present<IntegerAttr>(index);
     return indexAttr && indexAttr.getValue() == 0;

mlir/test/Dialect/LLVMIR/mem2reg-dbginfo.mlir

 // CHECK: ^{{.*}}(%[[BLOCKARG2:.*]]: i64):
 ^bb2:
   // CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[BLOCKARG2]]
   llvm.br ^bb1
 }
 
 // CHECK-LABEL: llvm.func @always_drop_promoted_declare
 // CHECK-NOT: = llvm.alloca
-// CHECK-NOT: llvm.intr.dbg.
+// CHECK-NOT: llvm.intr.dbg.declare
+// CHECK-NOT: llvm.intr.dbg.value
 llvm.func @always_drop_promoted_declare() {
   %0 = llvm.mlir.constant(1 : i32) : i32
   %1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
   llvm.intr.dbg.declare #di_local_variable = %1 : !llvm.ptr
+  llvm.intr.dbg.value #di_local_variable = %1 : !llvm.ptr
   llvm.return
 }
 
 // CHECK-LABEL: llvm.func @keep_dbg_if_not_promoted
 llvm.func @keep_dbg_if_not_promoted() {
   %0 = llvm.mlir.constant(1 : i32) : i32
   // CHECK: %[[ALLOCA:.*]] = llvm.alloca
   %1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr