Refactor `AsanChunk` methods into code that supports both in-process and out-of-process examination of `AsanChunk`s.

[delcypher]

Summary

This refactors the implementations of the Beg(), UsedSize() and
AllocBeg() methods. We do not modify AddrIsInside() because
future patches do not need to use that method in an out-of-process context.

The common code is private and has the Internal suffix. Future
patches will use these new methods in an out-of-process context.

The UsedSizeInternal(...) method takes a new argument
(known_alloc_beg) which allows access to be optimized if the
result of AllocBegInternal() is already known. We will use this
in future patches.

We do not template the AsanChunk type with AddressSpaceView like we did
for the allocators (in previous patches) because it is not possible to
modify the existing methods and preserve the method parameters in
the out-of-process context because we need additional information that the
caller needs to provide. In particular:

• We need both the address of the copy of the AsanChunk in the local process and its address in the remote process. In the in-process context the this pointer provides both bits of information but this isn't the case in the out-of-process context.
• We need the address to the ASan allocator in the local process instantiated with the correct AddressSpaceView template. In the in-process context this is just &get_allocator() but in the out-of-process context only the caller knows the address of the copy of the ASan allocator that is instantiated with RemoteAddressSpaceView.

Given the above restrictions this patch refactors the methods into new
methods that take the additional parameters and then modifies the
original methods to provide these additional parameters.

This maximizes code re-use between the in-process and out-of-process use
cases and minimizes the changes required (i.e. none) to existing clients
of AsanChunk.

rdar://problem/45284065

[delcypher]

Comment tweak.

[vitalybuka]

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

lib/asan/asan_allocator.cc

 // CHUNK_QUARANTINE: the chunk was freed and put into quarantine zone.
 enum {
   CHUNK_AVAILABLE  = 0,  // 0 is the default value even if we didn't set it.
   CHUNK_ALLOCATED  = 2,
   CHUNK_QUARANTINE = 3
 };
 
 struct AsanChunk: ChunkBase {
-  uptr Beg() { return reinterpret_cast<uptr>(this) + kChunkHeaderSize; }
+  uptr Beg() { return BegInternal(reinterpret_cast<uptr>(this)); }
   uptr UsedSize(bool locked_version = false) {
-    if (user_requested_size != SizeClassMap::kMaxSize)
-      return user_requested_size;
-    return *reinterpret_cast<uptr *>(
-               get_allocator().GetMetaData(AllocBeg(locked_version)));
+    return UsedSizeInternal<LocalAddressSpaceView>(
+        reinterpret_cast<uptr>(this), locked_version,
+        reinterpret_cast<uptr>(&get_allocator()), nullptr);
   }
   void *AllocBeg(bool locked_version = false) {
-    if (from_memalign) {
-      if (locked_version)
-        return get_allocator().GetBlockBeginFastLocked(
-            reinterpret_cast<void *>(this));
-      return get_allocator().GetBlockBegin(reinterpret_cast<void *>(this));
-    }
-    return reinterpret_cast<void*>(Beg() - RZLog2Size(rz_log));
+    return AllocBegInternal<LocalAddressSpaceView>(
+        reinterpret_cast<uptr>(this), locked_version,
+        reinterpret_cast<uptr>(&get_allocator()));
   }
   bool AddrIsInside(uptr addr, bool locked_version = false) {
     return (addr >= Beg()) && (addr < Beg() + UsedSize(locked_version));
   }
+
+ private:
+  // Common code for in-process and out-of-process chunk examination.
+  //
+  // * For the in-process case `chunk_storage_addr` is the same as the `this`
+  //   pointer. For the out-of-process case it is a pointer to the
+  //   `AsanChunk` in the target process.
+  // * `allocator` is a pointer to the allocator in the local
+  //   address space, instantiated with the appropriate `AddressSpaceView`
+  //   template parameter. For the `out-of-process` case this means the client
+  //   is responsible for copying the allocator from the target process into
+  //   the local process.
+
+  uptr BegInternal(uptr chunk_storage_addr) {
+    return chunk_storage_addr + kChunkHeaderSize;
+  }
+
+  template <typename AddressSpaceView>
+  void *AllocBegInternal(uptr chunk_storage_addr, bool locked_version,
+                         uptr allocator) {
+    if (from_memalign) {
+      auto allocator_ptr =
+          reinterpret_cast<AsanAllocatorASVT<AddressSpaceView> *>(allocator);
+      if (locked_version)
+        return allocator_ptr->GetBlockBeginFastLocked(
+            reinterpret_cast<void *>(chunk_storage_addr));
+      return allocator_ptr->GetBlockBegin(
+          reinterpret_cast<void *>(chunk_storage_addr));
+    }
+    return reinterpret_cast<void *>(BegInternal(chunk_storage_addr) -
+                                    RZLog2Size(rz_log));
+  }
+
+  // `known_alloc_beg` - Address of the beginning of the underlying
+  // allocator block in the target process.
+  // If not set to zero then the following must be true `known_alloc_beg ==
+  // AllocBegInternal(chunk_storage_addr, lockec_version, allocator)`. If set to
+  // `0` then `AllocBegInternal()` will be called to determine the
+  // the address of the allocator block.
+  //
+  // This is an optimization to avoid calling `AllocBegInternal()` when
+  // the result of `AllocBegInternal(...)` is already know by the
+  // caller.
+  template <typename AddressSpaceView>
+  uptr UsedSizeInternal(uptr chunk_storage_addr, bool locked_version,
+                        uptr allocator, void *known_alloc_beg) {
+    if (user_requested_size != SizeClassMap::kMaxSize)
+      return user_requested_size;
+    if (!known_alloc_beg) {
+      known_alloc_beg = AllocBegInternal<AddressSpaceView>(
+          chunk_storage_addr, locked_version, allocator);
+    } else {
+      DCHECK_EQ(known_alloc_beg,
+                AllocBegInternal<AddressSpaceView>(chunk_storage_addr,
+                                                   locked_version, allocator));
+    }
+    return *AddressSpaceView::Load(reinterpret_cast<uptr *>(
+        reinterpret_cast<AsanAllocatorASVT<AddressSpaceView> *>(allocator)
+            ->GetMetaData(known_alloc_beg)));
+  }
 };
 
 struct QuarantineCallback {
   QuarantineCallback(AllocatorCache *cache, BufferedStackTrace *stack)
       : cache_(cache),
         stack_(stack) {
   }