Refactor `GetAsanChunk()` method so it can be used in an in-process and out-of-process context.

[delcypher]

Summary

Refactor GetAsanChunk() method so it can be used in an in-process and out-of-process context.

rdar://problem/45284065

[vitalybuka]

Removing stale patches from the "Ready to Review" list.

lib/asan/asan_allocator.cc

void AllocatorOptions::CopyTo(Flags *f, CommonFlags *cf) {
   f->thread_local_quarantine_size_kb = thread_local_quarantine_size_kb;
   f->redzone = min_redzone;
   f->max_redzone = max_redzone;
   cf->allocator_may_return_null = may_return_null;
   f->alloc_dealloc_mismatch = alloc_dealloc_mismatch;
   cf->allocator_release_to_os_interval_ms = release_to_os_interval_ms;
 }
 
+// Returns a pointer to the `AsanChunk` in the target process.
+//
+// `alloc_beg` - Pointer to the beginning of the allocation in the target
+//               process, i.e.
+//               `allocator_view.GetBlockBegin(alloc_beg) == alloc_beg`.
+//
+// `allocator` - Pointer to the allocator in the local process.
+template <typename AddressSpaceView>
+static AsanChunk *GetAsanChunkInternal(uptr alloc_beg, uptr allocator) {
+  if (!alloc_beg)
+    return nullptr;
+  auto allocator_view =
+      reinterpret_cast<AsanAllocatorASVT<AddressSpaceView> *>(allocator);
+
+  if (!allocator_view->FromPrimary(reinterpret_cast<void *>(alloc_beg))) {
+    const uptr *meta = AddressSpaceView::Load(
+        reinterpret_cast<uptr *>(
+            allocator_view->GetMetaData(reinterpret_cast<void *>(alloc_beg))),
+        2);
+    AsanChunk *m = reinterpret_cast<AsanChunk *>(meta[1]);
+    return m;
+  }
+  const uptr *alloc_magic =
+      AddressSpaceView::Load(reinterpret_cast<uptr *>(alloc_beg), 2);
+  if (alloc_magic[0] == kAllocBegMagic)
+    return reinterpret_cast<AsanChunk *>(alloc_magic[1]);
+  return reinterpret_cast<AsanChunk *>(alloc_beg);
+}
+
 struct Allocator {
   static const uptr kMaxAllowedMallocSize =
       FIRST_32_SECOND_64(3UL << 30, 1ULL << 40);
 
   AsanAllocator allocator;
   AsanQuarantine quarantine;
   StaticSpinMutex fallback_mutex;
   AllocatorCache fallback_allocator_cache;
void CommitBack(AsanThreadLocalMallocStorage *ms, BufferedStackTrace *stack) {
     quarantine.Drain(GetQuarantineCache(ms), QuarantineCallback(ac, stack));
     allocator.SwallowCache(ac);
   }
 
   // -------------------------- Chunk lookup ----------------------
 
   // Assumes alloc_beg == allocator.GetBlockBegin(alloc_beg).
   AsanChunk *GetAsanChunk(void *alloc_beg) {
-    if (!alloc_beg) return nullptr;
-    if (!allocator.FromPrimary(alloc_beg)) {
-      uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(alloc_beg));
-      AsanChunk *m = reinterpret_cast<AsanChunk *>(meta[1]);
-      return m;
-    }
-    uptr *alloc_magic = reinterpret_cast<uptr *>(alloc_beg);
-    if (alloc_magic[0] == kAllocBegMagic)
-      return reinterpret_cast<AsanChunk *>(alloc_magic[1]);
-    return reinterpret_cast<AsanChunk *>(alloc_beg);
+    return GetAsanChunkInternal<LocalAddressSpaceView>(
+        reinterpret_cast<uptr>(alloc_beg), reinterpret_cast<uptr>(&allocator));
   }
 
   AsanChunk *GetAsanChunkByAddr(uptr p) {
     void *alloc_beg = allocator.GetBlockBegin(reinterpret_cast<void *>(p));
     return GetAsanChunk(alloc_beg);
   }
 
   // Allocator must be locked when this function is called.