Removed platform-specific ifdefs from sanitizer_procmaps.h

[Vurchin]

Summary

Removed platform-specific ifdefs for linux, mac, freebsd and netbsd from sanitizer_procmaps.h

[vitalybuka]

title/description are misleading. I don't see anything related to ifdefs

Why do you need to change this, it seems right now it's were it should be.

lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

17 ↗

(On Diff #116065)

This is linux file. It can contain, even in future, things incompatible with FREEBSD

[vitalybuka]

lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

17 ↗

(On Diff #116065)

Meh, it's called linux, but already has SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD

[fjricci]

We're working on getting some git issues sorted out, this isn't currently the full commit

[Vurchin]

arc again

[vitalybuka]

lib/sanitizer_common/sanitizer_procmaps.h

89 ↗

(On Diff #116079)

Instead of dynamic allocation maybe just:

#inlude <sanitizer_procmaps_linux.h>
#inlude <sanitizer_procmaps_mac.h>
... 
MemoryMappingLayoutData data_;

lib/sanitizer_common/sanitizer_procmaps_linux.cc

21 ↗

(On Diff #116079)

missalingned

[Vurchin]

having trouble with git

not finished

[Vurchin]

updated with a new version

[Vurchin]

lib/sanitizer_common/sanitizer_procmaps.h

89 ↗

(On Diff #116079)

So do you think I should create these two files?

[fjricci]

lib/sanitizer_common/sanitizer_procmaps.h

89 ↗

(On Diff #116079)

I would lean towards just using sanitizer_mac.h, like you already did for sanitizer_linux.h, since it seems silly to create a header for just one struct. But will defer to @vitalybuka

[Vurchin]

lib/sanitizer_common/sanitizer_procmaps.h

89 ↗

(On Diff #116079)

Haha, alright, I also like that idea

[vitalybuka]

lib/sanitizer_common/sanitizer_procmaps.h

89 ↗

(On Diff #116079)

sanitizer_mac.h and sanitizer_linux.h are good as well

[krytarowski]

I will test this on NetBSD after Monday.

[Vurchin]

Addressed vitaly's comments

[Vurchin]

deleted repeatedly included sanitizer_mac.h

[vitalybuka]

LGTM with few nits

lib/sanitizer_common/sanitizer_linux.h

34 ↗

(On Diff #116222)

please fix formating,
e.g with git clang-format --style file -f HEAD~1

lib/sanitizer_common/sanitizer_procmaps.h

19 ↗

(On Diff #116222)

order please

25 ↗

(On Diff #116222)

you don'e need this forward declaration as it's already included just above.

lib/sanitizer_common/sanitizer_procmaps_common.cc

20 ↗

(On Diff #116222)

unneeded include?

lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

16 ↗

(On Diff #116222)

unneeded include?

lib/sanitizer_common/sanitizer_procmaps_linux.cc

17 ↗

(On Diff #116222)

already included with sanitizer_procmaps.h

lib/sanitizer_common/sanitizer_procmaps_mac.cc

48 ↗

(On Diff #116222)

please don't make such changes unrelated code.

185 ↗

(On Diff #116222)

argument "MemoryMappedSegmentData *seg_data" is not needed

192 ↗

(On Diff #116222)

no point to CHECK here

[fjricci]

@krytarowski - how important is it for you to pre-test this on NetBSD? Does NetBSD run on buildbots? Just asking because Tuesday is a ways off, and this change seems fairly unlikely to break things given that it passes darwin/linux tests locally and is more or less NFC.

[Vurchin]

address vitaly's comments

[Vurchin]

adding whitespaces back

[Vurchin]

putting back *seg_data

[Vurchin]

I think the argument *seg_data in NextSegmentLoad is still necessary, since it is a private member and the static function has no access to it

[vitalybuka]

lib/sanitizer_common/sanitizer_procmaps.h

25 ↗

(On Diff #116222)

what about this one?

[Vurchin]

Removed forward declaration

[fjricci]

LGTM with one nit.

lib/sanitizer_common/sanitizer_procmaps_linux.cc

16 ↗

(On Diff #116254)

This shouldn't be needed anymore.

[Vurchin]

removed unneeded header

compiler-rt/trunk/lib/sanitizer_common/sanitizer_linux.h

 
 struct link_map;  // Opaque type returned by dlopen().
 
 namespace __sanitizer {
 // Dirent structure for getdents(). Note that this structure is different from
 // the one in <dirent.h>, which is used by readdir().
 struct linux_dirent;
 
+struct ProcSelfMapsBuff {
+  char *data;
+  uptr mmaped_size;
+  uptr len;
+};
+
+struct MemoryMappingLayoutData {
+  ProcSelfMapsBuff proc_self_maps;
+  const char *current;
+};
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
+
 // Syscall wrappers.
 uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count);
 uptr internal_sigaltstack(const void* ss, void* oss);
 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
     __sanitizer_sigset_t *oldset);
 
 // Linux-only syscalls.
 #if SANITIZER_LINUX

compiler-rt/trunk/lib/sanitizer_common/sanitizer_mac.h

 
 #include "sanitizer_common.h"
 #include "sanitizer_platform.h"
 #if SANITIZER_MAC
 #include "sanitizer_posix.h"
 
 namespace __sanitizer {
 
+struct MemoryMappingLayoutData {
+  int current_image;
+  u32 current_magic;
+  u32 current_filetype;
+  ModuleArch current_arch;
+  u8 current_uuid[kModuleUUIDSize];
+  int current_load_cmd_count;
+  char *current_load_cmd_addr;
+  bool current_instrumented;
+};
+
 enum MacosVersion {
   MACOS_VERSION_UNINITIALIZED = 0,
   MACOS_VERSION_UNKNOWN,
   MACOS_VERSION_LEOPARD,
   MACOS_VERSION_SNOW_LEOPARD,
   MACOS_VERSION_LION,
   MACOS_VERSION_MOUNTAIN_LION,
   MACOS_VERSION_MAVERICKS,

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps.h

 //
 // Information about the process mappings.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_PROCMAPS_H
 #define SANITIZER_PROCMAPS_H
 
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_linux.h"
+#include "sanitizer_mac.h"
 #include "sanitizer_mutex.h"
 
 namespace __sanitizer {
 
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
-struct ProcSelfMapsBuff {
-  char *data;
-  uptr mmaped_size;
-  uptr len;
-};
-
-// Reads process memory map in an OS-specific way.
-void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
-#endif  // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
 
 // Memory protection masks.
 static const uptr kProtectionRead = 1;
 static const uptr kProtectionWrite = 2;
 static const uptr kProtectionExecute = 4;
 static const uptr kProtectionShared = 8;
 
 struct MemoryMappedSegmentData;
public:
   // Adds all mapped objects into a vector.
   void DumpListOfModules(InternalMmapVector<LoadedModule> *modules);
 
  private:
   void LoadFromCache();
 
   // FIXME: Hide implementation details for different platforms in
   // platform-specific files.
-# if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
-  ProcSelfMapsBuff proc_self_maps_;
-  const char *current_;
-
-  // Static mappings cache.
-  static ProcSelfMapsBuff cached_proc_self_maps_;
-  static StaticSpinMutex cache_lock_;  // protects cached_proc_self_maps_.
-# elif SANITIZER_MAC
-  template <u32 kLCSegment, typename SegmentCommand>
-  bool NextSegmentLoad(MemoryMappedSegment *segment);
-  int current_image_;
-  u32 current_magic_;
-  u32 current_filetype_;
-  ModuleArch current_arch_;
-  u8 current_uuid_[kModuleUUIDSize];
-  int current_load_cmd_count_;
-  char *current_load_cmd_addr_;
-  bool current_instrumented_;
-# endif
+  MemoryMappingLayoutData data_;
 };
 
 typedef void (*fill_profile_f)(uptr start, uptr rss, bool file,
                                /*out*/uptr *stats, uptr stats_size);
 
 // Parse the contents of /proc/self/smaps and generate a memory profile.
 // |cb| is a tool-specific callback that fills the |stats| array containing
 // |stats_size| elements.

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps_common.cc

 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
 
 #include "sanitizer_common.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_procmaps.h"
 
 namespace __sanitizer {
 
-// Linker initialized.
-ProcSelfMapsBuff MemoryMappingLayout::cached_proc_self_maps_;
-StaticSpinMutex MemoryMappingLayout::cache_lock_;  // Linker initialized.
+static ProcSelfMapsBuff cached_proc_self_maps;
+static StaticSpinMutex cache_lock;
 
 static int TranslateDigit(char c) {
   if (c >= '0' && c <= '9')
     return c - '0';
   if (c >= 'a' && c <= 'f')
     return c - 'a' + 10;
   if (c >= 'A' && c <= 'F')
     return c - 'A' + 10;

 
 void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {
   // data_ should be unused on this platform
   CHECK(!data_);
   module->addAddressRange(start, end, IsExecutable(), IsWritable());
 }
 
 MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
-  ReadProcMaps(&proc_self_maps_);
+  ReadProcMaps(&data_.proc_self_maps);
   if (cache_enabled) {
-    if (proc_self_maps_.mmaped_size == 0) {
+    if (data_.proc_self_maps.mmaped_size == 0) {
       LoadFromCache();
-      CHECK_GT(proc_self_maps_.len, 0);
+      CHECK_GT(data_.proc_self_maps.len, 0);
     }
   } else {
-    CHECK_GT(proc_self_maps_.mmaped_size, 0);
+    CHECK_GT(data_.proc_self_maps.mmaped_size, 0);
   }
   Reset();
   // FIXME: in the future we may want to cache the mappings on demand only.
   if (cache_enabled)
     CacheMemoryMappings();
 }
 
 MemoryMappingLayout::~MemoryMappingLayout() {
   // Only unmap the buffer if it is different from the cached one. Otherwise
   // it will be unmapped when the cache is refreshed.
-  if (proc_self_maps_.data != cached_proc_self_maps_.data) {
-    UnmapOrDie(proc_self_maps_.data, proc_self_maps_.mmaped_size);
+  if (data_.proc_self_maps.data != cached_proc_self_maps.data) {
+    UnmapOrDie(data_.proc_self_maps.data, data_.proc_self_maps.mmaped_size);
   }
 }
 
-void MemoryMappingLayout::Reset() {
-  current_ = proc_self_maps_.data;
-}
+void MemoryMappingLayout::Reset() { data_.current = data_.proc_self_maps.data; }
 
 // static
 void MemoryMappingLayout::CacheMemoryMappings() {
-  SpinMutexLock l(&cache_lock_);
+  SpinMutexLock l(&cache_lock);
   // Don't invalidate the cache if the mappings are unavailable.
   ProcSelfMapsBuff old_proc_self_maps;
-  old_proc_self_maps = cached_proc_self_maps_;
-  ReadProcMaps(&cached_proc_self_maps_);
-  if (cached_proc_self_maps_.mmaped_size == 0) {
-    cached_proc_self_maps_ = old_proc_self_maps;
+  old_proc_self_maps = cached_proc_self_maps;
+  ReadProcMaps(&cached_proc_self_maps);
+  if (cached_proc_self_maps.mmaped_size == 0) {
+    cached_proc_self_maps = old_proc_self_maps;
   } else {
     if (old_proc_self_maps.mmaped_size) {
       UnmapOrDie(old_proc_self_maps.data,
                  old_proc_self_maps.mmaped_size);
     }
   }
 }
 
 void MemoryMappingLayout::LoadFromCache() {
-  SpinMutexLock l(&cache_lock_);
-  if (cached_proc_self_maps_.data) {
-    proc_self_maps_ = cached_proc_self_maps_;
+  SpinMutexLock l(&cache_lock);
+  if (cached_proc_self_maps.data) {
+    data_.proc_self_maps = cached_proc_self_maps;
   }
 }
 
 void MemoryMappingLayout::DumpListOfModules(
     InternalMmapVector<LoadedModule> *modules) {
   Reset();
   InternalScopedString module_name(kMaxPathLength);
   MemoryMappedSegment segment(module_name.data(), module_name.size());

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

#endif
   CHECK_EQ(Err, 0);
 
   proc_maps->data = (char*)VmMap;
   proc_maps->mmaped_size = MmapedSize;
   proc_maps->len = Size;
 }
 
 bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
-  char *last = proc_self_maps_.data + proc_self_maps_.len;
-  if (current_ >= last) return false;
-  struct kinfo_vmentry *VmEntry = (struct kinfo_vmentry*)current_;
+  char *last = data_.proc_self_maps.data + data_.proc_self_maps.len;
+  if (data_.current >= last) return false;
+  struct kinfo_vmentry *VmEntry = (struct kinfo_vmentry *)data_.current;
 
   segment->start = (uptr)VmEntry->kve_start;
   segment->end = (uptr)VmEntry->kve_end;
   segment->offset = (uptr)VmEntry->kve_offset;
 
   segment->protection = 0;
   if ((VmEntry->kve_protection & KVME_PROT_READ) != 0)
     segment->protection |= kProtectionRead;
   if ((VmEntry->kve_protection & KVME_PROT_WRITE) != 0)
     segment->protection |= kProtectionWrite;
   if ((VmEntry->kve_protection & KVME_PROT_EXEC) != 0)
     segment->protection |= kProtectionExecute;
 
   if (segment->filename != NULL && segment->filename_size > 0) {
     internal_snprintf(segment->filename,
                       Min(segment->filename_size, (uptr)PATH_MAX), "%s",
                       VmEntry->kve_path);
   }
 
 #if SANITIZER_FREEBSD
-  current_ += VmEntry->kve_structsize;
+  data_.current += VmEntry->kve_structsize;
 #else
-  current_ += sizeof(*VmEntry);
+  data_.current += sizeof(*VmEntry);
 #endif
 
   return true;
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FREEBSD || SANITIZER_NETBSD

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps_linux.cc

ReadFileToBuffer("/proc/self/maps", &proc_maps->data, &proc_maps->mmaped_size,
                    &proc_maps->len);
 }
 
 static bool IsOneOf(char c, char c1, char c2) {
   return c == c1 || c == c2;
 }
 
 bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
-  char *last = proc_self_maps_.data + proc_self_maps_.len;
-  if (current_ >= last) return false;
-  char *next_line = (char*)internal_memchr(current_, '\n', last - current_);
+  char *last = data_.proc_self_maps.data + data_.proc_self_maps.len;
+  if (data_.current >= last) return false;
+  char *next_line =
+      (char *)internal_memchr(data_.current, '\n', last - data_.current);
   if (next_line == 0)
     next_line = last;
   // Example: 08048000-08056000 r-xp 00000000 03:0c 64593   /foo/bar
-  segment->start = ParseHex(&current_);
-  CHECK_EQ(*current_++, '-');
-  segment->end = ParseHex(&current_);
-  CHECK_EQ(*current_++, ' ');
-  CHECK(IsOneOf(*current_, '-', 'r'));
+  segment->start = ParseHex(&data_.current);
+  CHECK_EQ(*data_.current++, '-');
+  segment->end = ParseHex(&data_.current);
+  CHECK_EQ(*data_.current++, ' ');
+  CHECK(IsOneOf(*data_.current, '-', 'r'));
   segment->protection = 0;
-  if (*current_++ == 'r') segment->protection |= kProtectionRead;
-  CHECK(IsOneOf(*current_, '-', 'w'));
-  if (*current_++ == 'w') segment->protection |= kProtectionWrite;
-  CHECK(IsOneOf(*current_, '-', 'x'));
-  if (*current_++ == 'x') segment->protection |= kProtectionExecute;
-  CHECK(IsOneOf(*current_, 's', 'p'));
-  if (*current_++ == 's') segment->protection |= kProtectionShared;
-  CHECK_EQ(*current_++, ' ');
-  segment->offset = ParseHex(&current_);
-  CHECK_EQ(*current_++, ' ');
-  ParseHex(&current_);
-  CHECK_EQ(*current_++, ':');
-  ParseHex(&current_);
-  CHECK_EQ(*current_++, ' ');
-  while (IsDecimal(*current_))
-    current_++;
+  if (*data_.current++ == 'r') segment->protection |= kProtectionRead;
+  CHECK(IsOneOf(*data_.current, '-', 'w'));
+  if (*data_.current++ == 'w') segment->protection |= kProtectionWrite;
+  CHECK(IsOneOf(*data_.current, '-', 'x'));
+  if (*data_.current++ == 'x') segment->protection |= kProtectionExecute;
+  CHECK(IsOneOf(*data_.current, 's', 'p'));
+  if (*data_.current++ == 's') segment->protection |= kProtectionShared;
+  CHECK_EQ(*data_.current++, ' ');
+  segment->offset = ParseHex(&data_.current);
+  CHECK_EQ(*data_.current++, ' ');
+  ParseHex(&data_.current);
+  CHECK_EQ(*data_.current++, ':');
+  ParseHex(&data_.current);
+  CHECK_EQ(*data_.current++, ' ');
+  while (IsDecimal(*data_.current)) data_.current++;
   // Qemu may lack the trailing space.
   // https://github.com/google/sanitizers/issues/160
-  // CHECK_EQ(*current_++, ' ');
+  // CHECK_EQ(*data_.current++, ' ');
   // Skip spaces.
-  while (current_ < next_line && *current_ == ' ')
-    current_++;
+  while (data_.current < next_line && *data_.current == ' ') data_.current++;
   // Fill in the filename.
   if (segment->filename) {
-    uptr len = Min((uptr)(next_line - current_), segment->filename_size - 1);
-    internal_strncpy(segment->filename, current_, len);
+    uptr len =
+        Min((uptr)(next_line - data_.current), segment->filename_size - 1);
+    internal_strncpy(segment->filename, data_.current, len);
     segment->filename[len] = 0;
   }
 
-  current_ = next_line + 1;
+  data_.current = next_line + 1;
   return true;
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_LINUX

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps_mac.cc

 // _dyld_get_image_vmaddr_slide() to get the actual addresses at runtime.
 
 void MemoryMappingLayout::Reset() {
   // Count down from the top.
   // TODO(glider): as per man 3 dyld, iterating over the headers with
   // _dyld_image_count is thread-unsafe. We need to register callbacks for
   // adding and removing images which will invalidate the MemoryMappingLayout
   // state.
-  current_image_ = _dyld_image_count();
-  current_load_cmd_count_ = -1;
-  current_load_cmd_addr_ = 0;
-  current_magic_ = 0;
-  current_filetype_ = 0;
-  current_arch_ = kModuleArchUnknown;
-  internal_memset(current_uuid_, 0, kModuleUUIDSize);
+  data_.current_image = _dyld_image_count();
+  data_.current_load_cmd_count = -1;
+  data_.current_load_cmd_addr = 0;
+  data_.current_magic = 0;
+  data_.current_filetype = 0;
+  data_.current_arch = kModuleArchUnknown;
+  internal_memset(data_.current_uuid, 0, kModuleUUIDSize);
 }
 
 // The dyld load address should be unchanged throughout process execution,
 // and it is expensive to compute once many libraries have been loaded,
 // so cache it here and do not reset.
 static mach_header *dyld_hdr = 0;
 static const char kDyldPath[] = "/usr/lib/dyld";
 static const int kDyldImageIdx = -1;

 // Next and NextSegmentLoad were inspired by base/sysinfo.cc in
 // Google Perftools, https://github.com/gperftools/gperftools.
 
 // NextSegmentLoad scans the current image for the next segment load command
 // and returns the start and end addresses and file offset of the corresponding
 // segment.
 // Note that the segment addresses are not necessarily sorted.
 template <u32 kLCSegment, typename SegmentCommand>
-bool MemoryMappingLayout::NextSegmentLoad(MemoryMappedSegment *segment) {
-  const char *lc = current_load_cmd_addr_;
-  current_load_cmd_addr_ += ((const load_command *)lc)->cmdsize;
+static bool NextSegmentLoad(MemoryMappedSegment *segment,
+MemoryMappedSegmentData *seg_data, MemoryMappingLayoutData &layout_data) {
+  const char *lc = layout_data.current_load_cmd_addr;
+  layout_data.current_load_cmd_addr += ((const load_command *)lc)->cmdsize;
   if (((const load_command *)lc)->cmd == kLCSegment) {
     const SegmentCommand* sc = (const SegmentCommand *)lc;
-
     uptr base_virt_addr, addr_mask;
-    if (current_image_ == kDyldImageIdx) {
+    if (layout_data.current_image == kDyldImageIdx) {
       base_virt_addr = (uptr)get_dyld_hdr();
       // vmaddr is masked with 0xfffff because on macOS versions < 10.12,
       // it contains an absolute address rather than an offset for dyld.
       // To make matters even more complicated, this absolute address
       // isn't actually the absolute segment address, but the offset portion
       // of the address is accurate when combined with the dyld base address,
       // and the mask will give just this offset.
       addr_mask = 0xfffff;
     } else {
-      base_virt_addr = (uptr)_dyld_get_image_vmaddr_slide(current_image_);
+      base_virt_addr =
+          (uptr)_dyld_get_image_vmaddr_slide(layout_data.current_image);
       addr_mask = ~0;
     }
+
     segment->start = (sc->vmaddr & addr_mask) + base_virt_addr;
     segment->end = segment->start + sc->vmsize;
-
     // Most callers don't need section information, so only fill this struct
     // when required.
-    if (segment->data_) {
-      segment->data_->nsects = sc->nsects;
-      segment->data_->current_load_cmd_addr =
+    if (seg_data) {
+      seg_data->nsects = sc->nsects;
+      seg_data->current_load_cmd_addr =
           (char *)lc + sizeof(SegmentCommand);
-      segment->data_->lc_type = kLCSegment;
-      segment->data_->base_virt_addr = base_virt_addr;
-      segment->data_->addr_mask = addr_mask;
-      internal_strncpy(segment->data_->name, sc->segname,
-                       ARRAY_SIZE(segment->data_->name));
+      seg_data->lc_type = kLCSegment;
+      seg_data->base_virt_addr = base_virt_addr;
+      seg_data->addr_mask = addr_mask;
+      internal_strncpy(seg_data->name, sc->segname,
+                       ARRAY_SIZE(seg_data->name));
     }
 
     // Return the initial protection.
     segment->protection = sc->initprot;
-    segment->offset =
-        (current_filetype_ == /*MH_EXECUTE*/ 0x2) ? sc->vmaddr : sc->fileoff;
+    segment->offset = (layout_data.current_filetype ==
+                       /*MH_EXECUTE*/ 0x2)
+                          ? sc->vmaddr
+                          : sc->fileoff;
     if (segment->filename) {
-      const char *src = (current_image_ == kDyldImageIdx)
+      const char *src = (layout_data.current_image == kDyldImageIdx)
                             ? kDyldPath
-                            : _dyld_get_image_name(current_image_);
+                            : _dyld_get_image_name(layout_data.current_image);
       internal_strncpy(segment->filename, src, segment->filename_size);
     }
-    segment->arch = current_arch_;
-    internal_memcpy(segment->uuid, current_uuid_, kModuleUUIDSize);
+    segment->arch = layout_data.current_arch;
+    internal_memcpy(segment->uuid, layout_data.current_uuid, kModuleUUIDSize);
     return true;
   }
   return false;
 }
 
 ModuleArch ModuleArchFromCpuType(cpu_type_t cputype, cpu_subtype_t cpusubtype) {
   cpusubtype = cpusubtype & ~CPU_SUBTYPE_MASK;
   switch (cputype) {
for (const load_command *lc = first_lc; lc->cmd != 0; lc = NextCommand(lc)) {
     if (dylib_name != 0 && (internal_strstr(dylib_name, "libclang_rt."))) {
       return true;
     }
   }
   return false;
 }
 
 bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
-  for (; current_image_ >= kDyldImageIdx; current_image_--) {
-    const mach_header *hdr = (current_image_ == kDyldImageIdx)
+  for (; data_.current_image >= kDyldImageIdx; data_.current_image--) {
+    const mach_header *hdr = (data_.current_image == kDyldImageIdx)
                                  ? get_dyld_hdr()
-                                 : _dyld_get_image_header(current_image_);
+                                 : _dyld_get_image_header(data_.current_image);
     if (!hdr) continue;
-    if (current_load_cmd_count_ < 0) {
+    if (data_.current_load_cmd_count < 0) {
       // Set up for this image;
-      current_load_cmd_count_ = hdr->ncmds;
-      current_magic_ = hdr->magic;
-      current_filetype_ = hdr->filetype;
-      current_arch_ = ModuleArchFromCpuType(hdr->cputype, hdr->cpusubtype);
-      switch (current_magic_) {
+      data_.current_load_cmd_count = hdr->ncmds;
+      data_.current_magic = hdr->magic;
+      data_.current_filetype = hdr->filetype;
+      data_.current_arch = ModuleArchFromCpuType(hdr->cputype, hdr->cpusubtype);
+      switch (data_.current_magic) {
 #ifdef MH_MAGIC_64
         case MH_MAGIC_64: {
-          current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header_64);
+          data_.current_load_cmd_addr = (char *)hdr + sizeof(mach_header_64);
           break;
         }
 #endif
         case MH_MAGIC: {
-          current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header);
+          data_.current_load_cmd_addr = (char *)hdr + sizeof(mach_header);
           break;
         }
         default: {
           continue;
         }
       }
-      FindUUID((const load_command *)current_load_cmd_addr_, &current_uuid_[0]);
-      current_instrumented_ =
-          IsModuleInstrumented((const load_command *)current_load_cmd_addr_);
+      FindUUID((const load_command *)data_.current_load_cmd_addr,
+               data_.current_uuid);
+      data_.current_instrumented = IsModuleInstrumented(
+          (const load_command *)data_.current_load_cmd_addr);
     }
 
-    for (; current_load_cmd_count_ >= 0; current_load_cmd_count_--) {
-      switch (current_magic_) {
-        // current_magic_ may be only one of MH_MAGIC, MH_MAGIC_64.
+    for (; data_.current_load_cmd_count >= 0; data_.current_load_cmd_count--) {
+      switch (data_.current_magic) {
+        // data_.current_magic may be only one of MH_MAGIC, MH_MAGIC_64.
 #ifdef MH_MAGIC_64
         case MH_MAGIC_64: {
           if (NextSegmentLoad<LC_SEGMENT_64, struct segment_command_64>(
-                  segment))
+          segment, segment->data_, data_))
             return true;
           break;
         }
 #endif
         case MH_MAGIC: {
-          if (NextSegmentLoad<LC_SEGMENT, struct segment_command>(segment))
+          if (NextSegmentLoad<LC_SEGMENT, struct segment_command>(
+          segment, segment->data_, data_))
             return true;
           break;
         }
       }
     }
     // If we get here, no more load_cmd's in this image talk about
     // segments.  Go on to the next image.
   }
while (Next(&segment)) {
     LoadedModule *cur_module = nullptr;
     if (!modules->empty() &&
         0 == internal_strcmp(segment.filename, modules->back().full_name())) {
       cur_module = &modules->back();
     } else {
       modules->push_back(LoadedModule());
       cur_module = &modules->back();
       cur_module->set(segment.filename, segment.start, segment.arch,
-                      segment.uuid, current_instrumented_);
+                      segment.uuid, data_.current_instrumented);
     }
     segment.AddAddressRanges(cur_module);
   }
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_MAC