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

18

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

[vitalybuka]

lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

18

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

82

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

missalingned

[Vurchin]

having trouble with git

not finished

[Vurchin]

updated with a new version

[Vurchin]

lib/sanitizer_common/sanitizer_procmaps.h

82

So do you think I should create these two files?

[fjricci]

lib/sanitizer_common/sanitizer_procmaps.h

82

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

82

Haha, alright, I also like that idea

[vitalybuka]

lib/sanitizer_common/sanitizer_procmaps.h

82

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

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

lib/sanitizer_common/sanitizer_procmaps.h

19

order please

23

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

lib/sanitizer_common/sanitizer_procmaps_common.cc

20

unneeded include?

lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

16

unneeded include?

lib/sanitizer_common/sanitizer_procmaps_linux.cc

17

already included with sanitizer_procmaps.h

lib/sanitizer_common/sanitizer_procmaps_mac.cc

48

please don't make such changes unrelated code.

200

argument "MemoryMappedSegmentData *seg_data" is not needed

207–208

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

23

what about this one?

[Vurchin]

Removed forward declaration

[fjricci]

LGTM with one nit.

lib/sanitizer_common/sanitizer_procmaps_linux.cc

16

This shouldn't be needed anymore.

[Vurchin]

removed unneeded header

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

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_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
+struct MemoryMappingLayoutData;
 
 // 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.
 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size);

lib/sanitizer_common/sanitizer_procmaps_common.cc

 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
 
 #include "sanitizer_common.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_procmaps.h"
+#include "sanitizer_linux.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_);
+  data_ = static_cast<MemoryMappingLayoutData *>
+  (MmapOrDie(sizeof(MemoryMappingLayoutData), "MemoryMappingLayoutData", 0));
+  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);
   }
+  UnmapOrDie(data_, sizeof(MemoryMappingLayoutData));
 }
 
 void MemoryMappingLayout::Reset() {
-  current_ = proc_self_maps_.data;
+  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());

lib/sanitizer_common/sanitizer_procmaps_freebsd.cc

 //===-- sanitizer_procmaps_freebsd.cc -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Information about the process mappings (FreeBSD and NetBSD-specific parts).
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
 #include "sanitizer_common.h"
+#include "sanitizer_linux.h"
 #if SANITIZER_FREEBSD
 #include "sanitizer_freebsd.h"
 #endif
 #include "sanitizer_procmaps.h"
 
 #include <unistd.h>
 #include <sys/sysctl.h>
 #if SANITIZER_FREEBSD
 #include <sys/user.h>
 #endif
#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

lib/sanitizer_common/sanitizer_procmaps_linux.cc

 //===-- sanitizer_procmaps_linux.cc ---------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Information about the process mappings (Linux-specific parts).
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_LINUX
 #include "sanitizer_common.h"
 #include "sanitizer_procmaps.h"
+#include "sanitizer_linux.h"
 
 namespace __sanitizer {
 
+
 void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
   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

lib/sanitizer_common/sanitizer_procmaps_mac.cc

 #define CPU_SUBTYPE_ARM_V7K   ((cpu_subtype_t)12)
 #endif
 #ifndef CPU_TYPE_ARM64
 #define CPU_TYPE_ARM64        (CPU_TYPE_ARM | CPU_ARCH_ABI64)
 #endif
 
 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;
+  };
 // Contains information used to iterate through sections.
 struct MemoryMappedSegmentData {
   char name[kMaxSegName];
   uptr nsects;
   char *current_load_cmd_addr;
   u32 lc_type;
   uptr base_virt_addr;
   uptr addr_mask;
 };
-
 template <typename Section>
 static void NextSectionLoad(LoadedModule *module, MemoryMappedSegmentData *data,
                             bool isWritable) {
   const Section *sc = (const Section *)data->current_load_cmd_addr;
   data->current_load_cmd_addr += sizeof(Section);
 
   uptr sec_start = (sc->addr & data->addr_mask) + data->base_virt_addr;
   uptr sec_end = sec_start + sc->size;
#ifdef MH_MAGIC_64
     } else if (data_->lc_type == LC_SEGMENT_64) {
       NextSectionLoad<struct section_64>(module, data_, IsWritable());
 #endif
     }
   } while (--data_->nsects);
 }
 
 MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
+  data_ = static_cast<MemoryMappingLayoutData *>
+  (MmapOrDie(sizeof(MemoryMappingLayoutData), "MemoryMappingLayoutData", 0));
   Reset();
 }
 
 MemoryMappingLayout::~MemoryMappingLayout() {
+  UnmapOrDie(data_, sizeof(MemoryMappingLayoutData));
 }
 
 // More information about Mach-O headers can be found in mach-o/loader.h
 // Each Mach-O image has a header (mach_header or mach_header_64) starting with
 // a magic number, and a list of linker load commands directly following the
 // header.
 // A load command is at least two 32-bit words: the command type and the
 // command size in bytes. We're interested only in segment load commands
 // (LC_SEGMENT and LC_SEGMENT_64), which tell that a part of the file is mapped
 // into the task's address space.
 // The |vmaddr|, |vmsize| and |fileoff| fields of segment_command or
 // segment_command_64 correspond to the memory address, memory size and the
 // file offset of the current memory segment.
 // Because these fields are taken from the images as is, one needs to add
 // _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);
+  CHECK(data_);
+  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) {
+    CHECK(layout_data);
+    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;
+        (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))
+          if (NextSegmentLoad<LC_SEGMENT_64, struct segment_command_64>
+          (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