Implement `CopyFromTarget(...)` methods.

[delcypher]

Summary

These methods provide a simple interface for getting a copy
of a AddressSpaceView data structure from a target process but
with the AddressSpaceView type replaced with RemoteAddressSpaceView.

To support these methods, all types that take AddressSpaceView
as a template parameter now provide a ThisTASVT templated alias
that allows a convenient way to construct a type with a different
AddressSpaceView from an existing type. This will also be useful
for callers of the CopyFromTarget(...) methods.

The implementations of these functions copy fields from
type Type<AddressSpaceView> to a buffer of
Type<RemoteAddressSpaceView>. A copy if performed field by field
because C++ does not guarantee that the types have the same data-layout.

For fields that have identical size in the source and destination type
(i.e. fields that are not templated on AddressSpaceView) we copy
directly.

For fields that do depend on AddressSpaceView we recursively
call CopyFromTarget(...).

This approach might not be performant as copying the outter most data
structure directly into the buffer (i.e. CombinedAllocator) but it is
correct. We can investigate faster solutions (e.g. Compute if data
layout is same using constexpr functions and do fast copy in that case)
if it becomes necessary.

The main downside to this implementation is that it requires manually
keeping track of the fields in a class which will add a maintance
burden.

rdar://problem/45284065

[vitalybuka]

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

lib/sanitizer_common/sanitizer_allocator.h

 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_lfstack.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_list.h"
 #include "sanitizer_local_address_space_view.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_procmaps.h"
+#include "sanitizer_remote_address_space_view.h"
 #include "sanitizer_type_traits.h"
 
 namespace __sanitizer {
 
 // Allows the tools to name their allocations appropriately.
 extern const char *PrimaryAllocatorName;
 extern const char *SecondaryAllocatorName;
 

 INLINE void RandomShuffle(T *a, u32 n, u32 *rand_state) {
   if (n <= 1) return;
   u32 state = *rand_state;
   for (u32 i = n - 1; i > 0; i--)
     Swap(a[i], a[RandN(&state, i + 1)]);
   *rand_state = state;
 }
 
+#define SANITIZER_COPY_FIELD(FIELD, DEST_PTR, SRC_PTR)                        \
+  {                                                                           \
+    decltype(DEST_PTR) dst_ptr = DEST_PTR;                                    \
+    decltype(SRC_PTR) src_ptr = SRC_PTR;                                      \
+    internal_memcpy(&(dst_ptr->FIELD), &(src_ptr->FIELD),                     \
+                    sizeof(decltype(dst_ptr->FIELD)));                        \
+    static_assert(                                                            \
+        sizeof(decltype(dst_ptr->FIELD)) == sizeof(decltype(src_ptr->FIELD)), \
+        "Sizes do not match for field " #FIELD);                              \
+  }
+
+template <typename DstTy, typename SrcTy>
+const SrcTy *CopyFromTargetCommon(DstTy *dst, const SrcTy *src,
+                                  bool src_needs_load, bool dst_needs_zeroing) {
+  CHECK_NE(dst, nullptr);
+  CHECK_NE(src, nullptr);
+  // Zero destination buffer so any padding gets zero-ed out.
+  if (dst_needs_zeroing)
+    internal_memset(dst, 0, sizeof(decltype(*dst)));
+  const SrcTy *src_cpy = src;
+  if (src_needs_load)
+    src_cpy = RemoteAddressSpaceView::Load(src);
+  return src_cpy;
+}
+
 #include "sanitizer_allocator_size_class_map.h"
 #include "sanitizer_allocator_stats.h"
 #include "sanitizer_allocator_primary64.h"
 #include "sanitizer_allocator_bytemap.h"
 #include "sanitizer_allocator_primary32.h"
 #include "sanitizer_allocator_local_cache.h"
 #include "sanitizer_allocator_secondary.h"
 #include "sanitizer_allocator_combined.h"
 
+#undef SANITIZER_COPY_FIELD
+
 } // namespace __sanitizer
 
 #endif // SANITIZER_ALLOCATOR_H

lib/sanitizer_common/sanitizer_allocator_bytemap.h

 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 // Maps integers in rage [0, kSize) to u8 values.
 template <u64 kSize, typename AddressSpaceViewTy = LocalAddressSpaceView>
 class FlatByteMap {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
+  template <typename OtherViewTy>
+  using ThisTASVT = FlatByteMap<kSize, OtherViewTy>;
+
   void Init() {
     internal_memset(map_, 0, sizeof(map_));
   }
 
   void set(uptr idx, u8 val) {
     CHECK_LT(idx, kSize);
     CHECK_EQ(0U, map_[idx]);
     map_[idx] = val;
   }
   u8 operator[] (uptr idx) {
     CHECK_LT(idx, kSize);
     // FIXME: CHECK may be too expensive here.
     return map_[idx];
   }
+
+  // For `CopyFromTarget(...)`.
+  template <u64, typename>
+  friend class FlatByteMap;
+
+  static void CopyFromTarget(ThisTASVT<RemoteAddressSpaceView> *dst,
+                             const ThisTASVT<AddressSpaceView> *this_ptr,
+                             bool this_ptr_is_remote = true,
+                             bool dst_needs_zeroing = true) {
+    // C++ does not guarantee that `ThisTASVT<RemoteAddressSpaceView>` and
+    // `ThisTASVT<AddressSpaceView>` will have the same data layout so copy the
+    // whole object across and then copy the fields individually into the
+    // destination buffer.
+    using ThisT = ThisTASVT<AddressSpaceView>;
+    const ThisT *this_cpy = CopyFromTargetCommon(
+        dst, this_ptr, this_ptr_is_remote, dst_needs_zeroing);
+
+    // Keep this in sync with the fields of this class!
+    SANITIZER_COPY_FIELD(map_, dst, this_cpy);
+  }
+
  private:
   u8 map_[kSize];
 };
 
 // TwoLevelByteMap maps integers in range [0, kSize1*kSize2) to u8 values.
 // It is implemented as a two-dimensional array: array of kSize1 pointers
 // to kSize2-byte arrays. The secondary arrays are mmaped on demand.
 // Each value is initially zero and can be set to something else only once.
 // Setting and getting values from multiple threads is safe w/o extra locking.
 template <u64 kSize1, u64 kSize2,
           typename AddressSpaceViewTy = LocalAddressSpaceView,
           class MapUnmapCallback = NoOpMapUnmapCallback>
 class TwoLevelByteMap {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
+  template <typename OtherViewTy>
+  using ThisTASVT =
+      TwoLevelByteMap<kSize1, kSize2, OtherViewTy, MapUnmapCallback>;
+
   void Init() {
     internal_memset(map1_, 0, sizeof(map1_));
     mu_.Init();
   }
 
   void TestOnlyUnmap() {
     for (uptr i = 0; i < kSize1; i++) {
       u8 *p = Get(i);
public:
   u8 operator[] (uptr idx) const {
     CHECK_LT(idx, kSize1 * kSize2);
     u8 *map2 = Get(idx / kSize2);
     if (!map2) return 0;
     auto value_ptr = AddressSpaceView::Load(&map2[idx % kSize2]);
     return *value_ptr;
   }
 
+  // For `CopyFromTarget(...)`.
+  template <u64, u64, typename, class>
+  friend class TwoLevelByteMap;
+
+  static void CopyFromTarget(ThisTASVT<RemoteAddressSpaceView> *dst,
+                             const ThisTASVT<AddressSpaceView> *this_ptr,
+                             bool this_ptr_is_remote = true,
+                             bool dst_needs_zeroing = true) {
+    // C++ does not guarantee that `ThisTASVT<RemoteAddressSpaceView>` and
+    // `ThisTASVT<AddressSpaceView>` will have the same data layout so copy the
+    // whole object across and then copy the fields individually into the
+    // destination buffer.
+    using ThisT = ThisTASVT<AddressSpaceView>;
+    const ThisT *this_cpy = CopyFromTargetCommon(
+        dst, this_ptr, this_ptr_is_remote, dst_needs_zeroing);
+
+    // Keep this in sync with the fields of this class!
+    SANITIZER_COPY_FIELD(map1_, dst, this_cpy);
+    SANITIZER_COPY_FIELD(mu_, dst, this_cpy);
+  }
+
  private:
   u8 *Get(uptr idx) const {
     CHECK_LT(idx, kSize1);
     return reinterpret_cast<u8 *>(
         atomic_load(&map1_[idx], memory_order_acquire));
   }
 
   u8 *GetOrCreate(uptr idx) {

lib/sanitizer_common/sanitizer_allocator_combined.h

 // PrimaryAllocator is used via a local AllocatorCache.
 // SecondaryAllocator can allocate anything, but is not efficient.
 template <class PrimaryAllocator, class AllocatorCache,
           class SecondaryAllocator,
           typename AddressSpaceViewTy = LocalAddressSpaceView>  // NOLINT
 class CombinedAllocator {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
+  template <typename OtherViewTy>
+  using ThisTASVT = CombinedAllocator<
+      typename PrimaryAllocator::template ThisTASVT<OtherViewTy>,
+      typename AllocatorCache::template ThisTASVT<OtherViewTy>,
+      typename SecondaryAllocator::template ThisTASVT<OtherViewTy>,
+      OtherViewTy>;
+
   static_assert(is_same<AddressSpaceView,
                         typename PrimaryAllocator::AddressSpaceView>::value,
                 "PrimaryAllocator is using wrong AddressSpaceView");
   static_assert(is_same<AddressSpaceView,
                         typename SecondaryAllocator::AddressSpaceView>::value,
                 "SecondaryAllocator is using wrong AddressSpaceView");
 
   void InitLinkerInitialized(s32 release_to_os_interval_ms) {
     stats_.InitLinkerInitialized();
     primary_.Init(release_to_os_interval_ms);
     secondary_.InitLinkerInitialized();
   }
 
   void Init(s32 release_to_os_interval_ms) {
     stats_.Init();
     primary_.Init(release_to_os_interval_ms);
     secondary_.Init();
   }
 
+  // For `CopyFromTarget(...)`.
+  template <class, class, class, typename>
+  friend class CombinedAllocator;
+
+  static void CopyFromTarget(ThisTASVT<RemoteAddressSpaceView> *dst,
+                             const ThisTASVT<AddressSpaceView> *this_ptr,
+                             bool this_ptr_is_remote = true,
+                             bool dst_needs_zeroing = true) {
+    // C++ does not guarantee that `ThisTASVT<RemoteAddressSpaceView>` and
+    // `ThisTASVT<AddressSpaceView>` will have the same data layout so copy the
+    // whole object across and then copy the fields individually into the
+    // destination buffer.
+    using ThisT = ThisTASVT<AddressSpaceView>;
+    const ThisT *this_cpy = CopyFromTargetCommon(
+        dst, this_ptr, this_ptr_is_remote, dst_needs_zeroing);
+
+    // Keep this in sync with the fields of this class!
+    PrimaryAllocator::CopyFromTarget(&(dst->primary_), &(this_cpy->primary_),
+                                     /*this_ptr_is_remote=*/false,
+                                     /*dst_needs_zeroing=*/false);
+    SecondaryAllocator::CopyFromTarget(&(dst->secondary_),
+                                       &(this_cpy->secondary_),
+                                       /*this_ptr_is_remote=*/false,
+                                       /*dst_needs_zeroing=*/false);
+    SANITIZER_COPY_FIELD(stats_, dst, this_cpy);
+  }
+
   void *Allocate(AllocatorCache *cache, uptr size, uptr alignment) {
     // Returning 0 on malloc(0) may break a lot of code.
     if (size == 0)
       size = 1;
     if (size + alignment < size) {
       Report("WARNING: %s: CombinedAllocator allocation overflow: "
              "0x%zx bytes with 0x%zx alignment requested\n",
              SanitizerToolName, size, alignment);

lib/sanitizer_common/sanitizer_allocator_local_cache.h

 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 // Objects of this type should be used as local caches for SizeClassAllocator64
 // or SizeClassAllocator32. Since the typical use of this class is to have one
 // object per thread in TLS, is has to be POD.
-template<class SizeClassAllocator>
-struct SizeClassAllocatorLocalCache
-    : SizeClassAllocator::AllocatorCache {};
+template <class SizeClassAllocator>
+struct SizeClassAllocatorLocalCache : SizeClassAllocator::AllocatorCache {
+  template <typename OtherViewTy>
+  using ThisTASVT = SizeClassAllocatorLocalCache<
+      typename SizeClassAllocator::template ThisTASVT<OtherViewTy>>;
+};
 
 // Cache used by SizeClassAllocator64.
 template <class SizeClassAllocator>
 struct SizeClassAllocator64LocalCache {
   typedef SizeClassAllocator Allocator;
 
+  template <typename OtherViewTy>
+  using ThisTASVT = SizeClassAllocator64LocalCache<
+      typename SizeClassAllocator::template ThisTASVT<OtherViewTy>>;
+
   void Init(AllocatorGlobalStats *s) {
     stats_.Init();
     if (s)
       s->Register(&stats_);
   }
 
   void Destroy(SizeClassAllocator *allocator, AllocatorGlobalStats *s) {
     Drain(allocator);

lib/sanitizer_common/sanitizer_allocator_primary32.h

enum {
     kUseSeparateSizeClassForBatch = 2,
   };
 };
 
 template <class Params, typename AddressSpaceViewTy = LocalAddressSpaceView>
 class SizeClassAllocator32 {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
+  template <typename OtherViewTy>
+  using ThisTASVT = SizeClassAllocator32<Params, OtherViewTy>;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const u64 kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = Params::kRegionSizeLog;
   using ByteMap = typename Params::template ByteMapASVT<AddressSpaceView>;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
public:
   typedef SizeClassAllocator32<Params> ThisT;
   typedef SizeClassAllocator32LocalCache<ThisT> AllocatorCache;
 
   void Init(s32 release_to_os_interval_ms) {
     possible_regions.Init();
     internal_memset(size_class_info_array, 0, sizeof(size_class_info_array));
   }
 
+  // For `CopyFromTarget(...)`.
+  template <class, typename>
+  friend class SizeClassAllocator32;
+
+  static void CopyFromTarget(ThisTASVT<RemoteAddressSpaceView> *dst,
+                             const ThisTASVT<AddressSpaceView> *this_ptr,
+                             bool this_ptr_is_remote = true,
+                             bool dst_needs_zeroing = true) {
+    // C++ does not guarantee that `ThisTASVT<RemoteAddressSpaceView>` and
+    // `ThisTASVT<AddressSpaceView>` will have the same data layout so copy the
+    // whole object across and then copy the fields individually into the
+    // destination buffer.
+    using ThisT = ThisTASVT<AddressSpaceView>;
+    const ThisT *this_cpy = CopyFromTargetCommon(
+        dst, this_ptr, this_ptr_is_remote, dst_needs_zeroing);
+
+    // Keep this in sync with the fields of this class!
+    ByteMap::CopyFromTarget(&(dst->possible_regions),
+                            &(this_cpy->possible_regions),
+                            /*this_ptr_is_remote=*/false,
+                            /*dst_needs_zeroing=*/false);
+    SANITIZER_COPY_FIELD(size_class_info_array, dst, this_cpy);
+  }
+
   s32 ReleaseToOSIntervalMs() const {
     return kReleaseToOSIntervalNever;
   }
 
   void SetReleaseToOSIntervalMs(s32 release_to_os_interval_ms) {
     // This is empty here. Currently only implemented in 64-bit allocator.
   }
 

lib/sanitizer_common/sanitizer_allocator_primary64.h

enum {
     kRandomShuffleChunks = 1,
   };
 };
 
 template <class Params, typename AddressSpaceViewTy = LocalAddressSpaceView>
 class SizeClassAllocator64 {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
+  template <typename OtherViewTy>
+  using ThisTASVT = SizeClassAllocator64<Params, OtherViewTy>;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const uptr kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
   static const bool kRandomShuffleChunks =
       Params::kFlags & SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
if (kUsingConstantSpaceBeg) {
       CHECK_NE(NonConstSpaceBeg, ~(uptr)0);
     }
     SetReleaseToOSIntervalMs(release_to_os_interval_ms);
     MapWithCallbackOrDie(SpaceEnd(), AdditionalSize());
     // Check that the RegionInfo array is aligned on the CacheLine size.
     DCHECK_EQ(SpaceEnd() % kCacheLineSize, 0);
   }
 
+  // For `CopyFromTarget(...)`.
+  template <class, typename>
+  friend class SizeClassAllocator64;
+
+  static void CopyFromTarget(ThisTASVT<RemoteAddressSpaceView> *dst,
+                             const ThisTASVT<AddressSpaceView> *this_ptr,
+                             bool this_ptr_is_remote = true,
+                             bool dst_needs_zeroing = true) {
+    // C++ does not guarantee that `ThisTASVT<RemoteAddressSpaceView>` and
+    // `ThisTASVT<AddressSpaceView>` will have the same data layout so copy the
+    // whole object across and then copy the fields individually into the
+    // destination buffer.
+    using ThisT = ThisTASVT<AddressSpaceView>;
+    const ThisT *this_cpy = CopyFromTargetCommon(
+        dst, this_ptr, this_ptr_is_remote, dst_needs_zeroing);
+
+    // Keep this in sync with the fields of this class!
+    SANITIZER_COPY_FIELD(address_range, dst, this_cpy);
+    SANITIZER_COPY_FIELD(NonConstSpaceBeg, dst, this_cpy);
+    SANITIZER_COPY_FIELD(release_to_os_interval_ms_, dst, this_cpy);
+  }
+
   s32 ReleaseToOSIntervalMs() const {
     return atomic_load(&release_to_os_interval_ms_, memory_order_relaxed);
   }
 
   void SetReleaseToOSIntervalMs(s32 release_to_os_interval_ms) {
     atomic_store(&release_to_os_interval_ms_, release_to_os_interval_ms,
                  memory_order_relaxed);
   }

lib/sanitizer_common/sanitizer_allocator_secondary.h

 // The main purpose of this allocator is to cover large and rare allocation
 // sizes not covered by more efficient allocators (e.g. SizeClassAllocator64).
 template <class MapUnmapCallback = NoOpMapUnmapCallback,
           class PtrArrayT = DefaultLargeMmapAllocatorPtrArray,
           class AddressSpaceViewTy = LocalAddressSpaceView>
 class LargeMmapAllocator {
  public:
   using AddressSpaceView = AddressSpaceViewTy;
+  template <typename OtherViewTy>
+  using ThisTASVT =
+      LargeMmapAllocator<MapUnmapCallback, PtrArrayT, OtherViewTy>;
+
   void InitLinkerInitialized() {
     page_size_ = GetPageSizeCached();
     chunks_ = reinterpret_cast<Header**>(ptr_array_.Init());
   }
 
   void Init() {
     internal_memset(this, 0, sizeof(*this));
     InitLinkerInitialized();
   }
 
+  // For `CopyFromTarget(...)`.
+  template <class, class, typename>
+  friend class LargeMmapAllocator;
+
+  static void CopyFromTarget(ThisTASVT<RemoteAddressSpaceView> *dst,
+                             const ThisTASVT<AddressSpaceView> *this_ptr,
+                             bool this_ptr_is_remote = true,
+                             bool dst_needs_zeroing = true) {
+    // C++ does not guarantee that `ThisTASVT<RemoteAddressSpaceView>` and
+    // `ThisTASVT<AddressSpaceView>` will have the same data layout so copy the
+    // whole object across and then copy the fields individually into the
+    // destination buffer.
+    using ThisT = ThisTASVT<AddressSpaceView>;
+    const ThisT *this_cpy = CopyFromTargetCommon(
+        dst, this_ptr, this_ptr_is_remote, dst_needs_zeroing);
+
+    // Keep this in sync with the fields of this class!
+    SANITIZER_COPY_FIELD(page_size_, dst, this_cpy);
+    SANITIZER_COPY_FIELD(chunks_, dst, this_cpy);
+    SANITIZER_COPY_FIELD(ptr_array_, dst, this_cpy);
+    SANITIZER_COPY_FIELD(n_chunks_, dst, this_cpy);
+    SANITIZER_COPY_FIELD(chunks_sorted_, dst, this_cpy);
+    SANITIZER_COPY_FIELD(stats, dst, this_cpy);
+    SANITIZER_COPY_FIELD(mutex_, dst, this_cpy);
+  }
+
   void *Allocate(AllocatorStats *stat, uptr size, uptr alignment) {
     CHECK(IsPowerOfTwo(alignment));
     uptr map_size = RoundUpMapSize(size);
     if (alignment > page_size_)
       map_size += alignment;
     // Overflow.
     if (map_size < size) {
       Report("WARNING: %s: LargeMmapAllocator allocation overflow: "