Introduce `UnIgnoreObjectLocked` functions

[delcypher]

Summary

This patch adds implementations for LSan & ASan of new
UnIgnoreObjectLocked functions. These functions perform the inverse
of the existing IgnoreObjectLocked functions.

These new functions will be used in a later patch to temporarily ignore
a heap object and then unignore it.

rdar://problem/63537240

[vitalybuka]

compiler-rt/lib/lsan/lsan_common.h

245

maybe we need __lsan_unignore_object for consistency and a test

[delcypher]

compiler-rt/lib/lsan/lsan_common.h

245

Thanks. I considered this but IIRC we have a very conservative policy of changing the public interface of the sanitizers so I decided to not add a public interface.

I'm not against adding a public interface + a test though but because the end goal is https://reviews.llvm.org/D94210 and it looks like we may have to implement it differently I'll leave this patch as is for now until we know if using UnIgnoreObjectLocked() is the right approach.

[vitalybuka]

Still please do not submit if D94210 does not need it.

[delcypher]

This change isn't needed anymore.

compiler-rt/lib/asan/asan_allocator.cpp

IgnoreObjectResult IgnoreObjectLocked(const void *p) {
   __asan::AsanChunk *m = LookUpValidChunk(p);
   if (!m)
     return kIgnoreObjectInvalid;
   if (m->lsan_tag == kIgnored)
     return kIgnoreObjectAlreadyIgnored;
   m->lsan_tag = __lsan::kIgnored;
   return kIgnoreObjectSuccess;
 }
+
+IgnoreObjectResult UnIgnoreObjectLocked(const void *p) {
+  __asan::AsanChunk *m = LookUpValidChunk(p);
+  if (!m)
+    return kIgnoreObjectInvalid;
+  if (m->lsan_tag != kIgnored)
+    return kIgnoreObjectNotAlreadyIgnored;
+  m->lsan_tag = __lsan::kDirectlyLeaked;
+  return kIgnoreObjectSuccess;
+}
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;
 
 // ASan allocator doesn't reserve extra bytes, so normally we would
 // just return "size". We don't want to expose our redzone sizes, etc here.
 uptr __sanitizer_get_estimated_allocated_size(uptr size) {

compiler-rt/lib/lsan/lsan_allocator.cpp

IgnoreObjectResult IgnoreObjectLocked(const void *p) {
   ChunkMetadata *m = LookUpValidChunk(p);
   if (!m)
     return kIgnoreObjectInvalid;
   if (m->tag == kIgnored)
     return kIgnoreObjectAlreadyIgnored;
   m->tag = kIgnored;
   return kIgnoreObjectSuccess;
 }
+
+IgnoreObjectResult UnIgnoreObjectLocked(const void *p) {
+  ChunkMetadata *m = LookUpValidChunk(p);
+  if (!m)
+    return kIgnoreObjectInvalid;
+  if (m->tag != kIgnored)
+    return kIgnoreObjectNotAlreadyIgnored;
+  m->tag = kDirectlyLeaked;
+  return kIgnoreObjectSuccess;
+}
 } // namespace __lsan
 
 using namespace __lsan;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_current_allocated_bytes() {
   uptr stats[AllocatorStatCount];

compiler-rt/lib/lsan/lsan_common.h

 void ScanRangeForPointers(uptr begin, uptr end,
                           Frontier *frontier,
                           const char *region_type, ChunkTag tag);
 void ScanGlobalRange(uptr begin, uptr end, Frontier *frontier);
 
 enum IgnoreObjectResult {
   kIgnoreObjectSuccess,
   kIgnoreObjectAlreadyIgnored,
+  kIgnoreObjectNotAlreadyIgnored,
   kIgnoreObjectInvalid
 };
 
 // Functions called from the parent tool.
 const char *MaybeCallLsanDefaultOptions();
 void InitCommonLsan();
 void DoLeakCheck();
 void DoRecoverableLeakCheckVoid();

 // where leak checking is initiated from a non-main thread).
 void EnsureMainThreadIDIsCorrect();
 // If p points into a chunk that has been allocated to the user, returns its
 // user-visible address. Otherwise, returns 0.
 uptr PointsIntoChunk(void *p);
 // Returns address of user-visible chunk contained in this allocator chunk.
 uptr GetUserBegin(uptr chunk);
 // Helper for __lsan_ignore_object().
 IgnoreObjectResult IgnoreObjectLocked(const void *p);
+IgnoreObjectResult UnIgnoreObjectLocked(const void *p);
 
 // Return the linker module, if valid for the platform.
 LoadedModule *GetLinker();
 
 // Return true if LSan has finished leak checking and reported leaks.
 bool HasReportedLeaks();
 
 // Run platform-specific leak handlers.