[Assignment Tracking][5.1/*] Add deleteAssignmentMarkers function

[Orlando]

Summary

deleteAssignmentMarkers(const Instruction *Inst) does exactly as you'd expect - it deletes any dbg.assign intrinsics linked to Inst.

I'll fold this into the previous patch (D132224) when landing them, but I wanted to keep the review separate as that one has already been accepted.

[Orlando]

note to self: add unittest

[Orlando]

+ Add unittest
+ Fix review title

[jmorse]

LGTM with nit

llvm/include/llvm/IR/DebugInfo.h

215

[Orlando]

I'll fold this into the previous patch (D132224) when landing them

As it happens I forgot to do this. I'll be landing these separately.

[rastogishubham]

I am sorry for reverting this patch, but I have to revert it because I need to revert 171f7024cc82e8702abebdedb699d37b50574be7 due to the cyclic dependency that was introduced in the modules build

[Orlando]

Re-landed in 26382a4412d29e1c31fc3cda5071d5d60832b69c, folded into D132224.

llvm/include/llvm/IR/DebugInfo.h

 /// Iterators invalidated by deleting an intrinsic contained in this range.
 inline AssignmentMarkerRange getAssignmentMarkers(const Instruction *Inst) {
   if (auto *ID = Inst->getMetadata(LLVMContext::MD_DIAssignID))
     return getAssignmentMarkers(cast<DIAssignID>(ID));
   else
     return make_range(Value::user_iterator(), Value::user_iterator());
 }
 
+/// Delete the llvm.dbg.assign intrinsics linked to \p Inst.
+void deleteAssignmentMarkers(const Instruction *Inst);
+
 /// Replace all uses (and attachments) of \p Old with \p New.
 void RAUW(DIAssignID *Old, DIAssignID *New);
 
 /// Remove all Assignment Tracking related intrinsics and metadata from \p F.
 void deleteAll(Function *F);
 
 } // end namespace at
 
 /// Return true if assignment tracking is enabled.
 bool getEnableAssignmentTracking();
 } // end namespace llvm
 
 #endif // LLVM_IR_DEBUGINFO_H

llvm/lib/IR/DebugInfo.cpp

AssignmentMarkerRange at::getAssignmentMarkers(DIAssignID *ID) {
   // The ID is only used wrapped in MetadataAsValue(ID), so lets check that
   // one of those already exists first.
   if (!IDAsValue)
     return make_range(Value::user_iterator(), Value::user_iterator());
 
   return make_range(IDAsValue->user_begin(), IDAsValue->user_end());
 }
 
+void at::deleteAssignmentMarkers(const Instruction *Inst) {
+  auto Range = getAssignmentMarkers(Inst);
+  if (Range.empty())
+    return;
+  SmallVector<DbgAssignIntrinsic *> ToDelete(Range.begin(), Range.end());
+  for (auto *DAI : ToDelete)
+    DAI->eraseFromParent();
+}
+
 void at::RAUW(DIAssignID *Old, DIAssignID *New) {
   // Replace MetadataAsValue uses.
   if (auto *OldIDAsValue =
           MetadataAsValue::getIfExists(Old->getContext(), Old)) {
     auto *NewIDAsValue = MetadataAsValue::get(Old->getContext(), New);
     OldIDAsValue->replaceAllUsesWith(NewIDAsValue);
   }
 

llvm/unittests/IR/DebugInfoTest.cpp

std::unique_ptr<Module> M = parseIR(C, R"(
 
     define dso_local void @fun2() !dbg !17 {
     entry:
       %local = alloca i32, align 4, !DIAssignID !20
       call void @llvm.dbg.assign(metadata i32 undef, metadata !18, metadata !DIExpression(), metadata !20, metadata i32 undef, metadata !DIExpression()), !dbg !19
       ret void, !dbg !19
     }
 
+    define dso_local void @fun3() !dbg !21 {
+    entry:
+      %local = alloca i32, align 4, !DIAssignID !24
+      call void @llvm.dbg.assign(metadata i32 undef, metadata !22, metadata !DIExpression(), metadata !24, metadata i32* undef, metadata !DIExpression()), !dbg !23
+      ret void
+    }
+
     declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
     !llvm.dbg.cu = !{!0}
     !llvm.module.flags = !{!3, !4, !5}
     !llvm.ident = !{!6}
 
     !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
     !1 = !DIFile(filename: "test.c", directory: "/")
std::unique_ptr<Module> M = parseIR(C, R"(
     !13 = !DILocation(line: 5, column: 1, scope: !14, inlinedAt: !15)
     !14 = distinct !DISubprogram(name: "inline", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
     !15 = !DILocation(line: 3, column: 1, scope: !7)
     !16 = !DILocalVariable(name: "local1", scope: !7, file: !1, line: 2, type: !11)
     !17 = distinct !DISubprogram(name: "fun2", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
     !18 = !DILocalVariable(name: "local2", scope: !17, file: !1, line: 2, type: !11)
     !19 = !DILocation(line: 4, column: 1, scope: !17)
     !20 = distinct !DIAssignID()
+    !21 = distinct !DISubprogram(name: "fun3", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+    !22 = !DILocalVariable(name: "local4", scope: !21, file: !1, line: 2, type: !11)
+    !23 = !DILocation(line: 4, column: 1, scope: !21)
+    !24 = distinct !DIAssignID()
     )");
 
   // Check the test IR isn't malformed.
   ASSERT_TRUE(M);
 
   Function &Fun1 = *M->getFunction("fun1");
   Instruction &Alloca = *Fun1.getEntryBlock().getFirstNonPHIOrDbg();
 
DIAssignID *Fun2ID = cast_or_null<DIAssignID>(
       Fun2Alloca.getMetadata(LLVMContext::MD_DIAssignID));
   EXPECT_NE(New, Fun2ID);
   auto Fun2Markers = at::getAssignmentMarkers(&Fun2Alloca);
   ASSERT_TRUE(std::distance(Fun2Markers.begin(), Fun2Markers.end()) == 1);
   auto Fun2Insts = at::getAssignmentInsts(*Fun2Markers.begin());
   ASSERT_TRUE(std::distance(Fun2Insts.begin(), Fun2Insts.end()) == 1);
   EXPECT_EQ(*Fun2Insts.begin(), &Fun2Alloca);
 
-  // 3. Check that deleting works and applies only to the target function.
+  // 3. Check that deleting dbg.assigns from a specific instruction works.
+  Instruction &Fun3Alloca =
+      *M->getFunction("fun3")->getEntryBlock().getFirstNonPHIOrDbg();
+  auto Fun3Markers = at::getAssignmentMarkers(&Fun3Alloca);
+  ASSERT_TRUE(std::distance(Fun3Markers.begin(), Fun3Markers.end()) == 1);
+  at::deleteAssignmentMarkers(&Fun3Alloca);
+  Fun3Markers = at::getAssignmentMarkers(&Fun3Alloca);
+  EXPECT_EQ(Fun3Markers.empty(), true);
+
+  // 4. Check that deleting works and applies only to the target function.
   at::deleteAll(&Fun1);
   // There should now only be the alloca and ret in fun1.
   EXPECT_EQ(Fun1.begin()->size(), 2u);
   // fun2's alloca should have the same DIAssignID and remain linked to its
   // llvm.dbg.assign.
   EXPECT_EQ(Fun2ID, cast_or_null<DIAssignID>(
                         Fun2Alloca.getMetadata(LLVMContext::MD_DIAssignID)));
   EXPECT_FALSE(at::getAssignmentMarkers(&Fun2Alloca).empty());
 }
 
 } // end namespace