[NFC] Refactor `IgnoreObjectLocked`

[delcypher]

Summary

This refactors the chunk look up code into a static inlined function
called LookUpValidChunk().

This is in preparation for introducing functions that are the inverse
of the IgnoreObjectLocked() functions. These will be added in
a subsequent patch.

rdar://problem/63537240

[vitalybuka]

compiler-rt/lib/asan/asan_allocator.cpp

1172

do we need ALWAYS_INLINE?

[delcypher]

compiler-rt/lib/asan/asan_allocator.cpp

1172

Technically, no. I put it there because I thought it should probably be inlined (I wasn't sure if static would be a strong enough hint) but this is probably premature optimization on my part.

Please let me know if you'd like me to remove it.

[vitalybuka]

Please remove and let compiler decide.
ALWAYS_INLINE may confuse future readers

[delcypher]

This change isn't needed anymore.

compiler-rt/lib/asan/asan_allocator.cpp

u32 LsanMetadata::stack_trace_id() const {
   m->GetAllocContext(tid, stack);
   return stack;
 }
 
 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
   __asan::get_allocator().ForEachChunk(callback, arg);
 }
 
-IgnoreObjectResult IgnoreObjectLocked(const void *p) {
+static ALWAYS_INLINE __asan::AsanChunk *LookUpValidChunk(const void *p) {
   uptr addr = reinterpret_cast<uptr>(p);
   __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddr(addr);
   if (!m ||
       (atomic_load(&m->chunk_state, memory_order_acquire) !=
        __asan::CHUNK_ALLOCATED) ||
       !m->AddrIsInside(addr)) {
-    return kIgnoreObjectInvalid;
-  }
+    return nullptr;
+  }
+  return m;
+
+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;
 }
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1

compiler-rt/lib/lsan/lsan_allocator.cpp

 u32 LsanMetadata::stack_trace_id() const {
   return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
 }
 
 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
   allocator.ForEachChunk(callback, arg);
 }
 
-IgnoreObjectResult IgnoreObjectLocked(const void *p) {
+static ALWAYS_INLINE ChunkMetadata *LookUpValidChunk(const void *p) {
   void *chunk = allocator.GetBlockBegin(p);
-  if (!chunk || p < chunk) return kIgnoreObjectInvalid;
+  if (!chunk || p < chunk)
+    return nullptr;
   ChunkMetadata *m = Metadata(chunk);
   CHECK(m);
   if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) {
-    if (m->tag == kIgnored)
-      return kIgnoreObjectAlreadyIgnored;
-    m->tag = kIgnored;
-    return kIgnoreObjectSuccess;
-  } else {
-    return kIgnoreObjectInvalid;
-  }
+    return m;
+  }
+  return nullptr;
+}
+
+IgnoreObjectResult IgnoreObjectLocked(const void *p) {
+  ChunkMetadata *m = LookUpValidChunk(p);
+  if (!m)
+    return kIgnoreObjectInvalid;
 }
 } // namespace __lsan
 
 using namespace __lsan;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_current_allocated_bytes() {