Create snapshot/mac and move some files from snapshot and util to there

util/mac/mach_o_image_reader_test.cc

Index: util/mac/mach_o_image_reader_test.cc
diff --git a/util/mac/mach_o_image_reader_test.cc b/util/mac/mach_o_image_reader_test.cc
deleted file mode 100644
index b7485dca3f5d7d38a1573c187b3f42be58f391bf..0000000000000000000000000000000000000000
--- a/util/mac/mach_o_image_reader_test.cc
+++ /dev/null
@@ -1,640 +0,0 @@
-// Copyright 2014 The Crashpad Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "util/mac/mach_o_image_reader.h"
-
-#include <AvailabilityMacros.h>
-#include <dlfcn.h>
-#include <mach-o/dyld.h>
-#include <mach-o/dyld_images.h>
-#include <mach-o/getsect.h>
-#include <mach-o/ldsyms.h>
-#include <mach-o/loader.h>
-#include <mach-o/nlist.h>
-#include <stdint.h>
-
-#include "base/strings/stringprintf.h"
-#include "build/build_config.h"
-#include "gtest/gtest.h"
-#include "util/mac/mach_o_image_segment_reader.h"
-#include "util/mac/process_reader.h"
-#include "util/mac/process_types.h"
-#include "util/misc/uuid.h"
-#include "util/test/mac/dyld.h"
-
-// This file is responsible for testing MachOImageReader,
-// MachOImageSegmentReader, and MachOImageSymbolTableReader.
-
-namespace crashpad {
-namespace test {
-namespace {
-
-// Native types and constants, in cases where the 32-bit and 64-bit versions
-// are different.
-#if defined(ARCH_CPU_64_BITS)
-typedef mach_header_64 MachHeader;
-const uint32_t kMachMagic = MH_MAGIC_64;
-typedef segment_command_64 SegmentCommand;
-const uint32_t kSegmentCommand = LC_SEGMENT_64;
-typedef section_64 Section;
-typedef nlist_64 Nlist;
-#else
-typedef mach_header MachHeader;
-const uint32_t kMachMagic = MH_MAGIC;
-typedef segment_command SegmentCommand;
-const uint32_t kSegmentCommand = LC_SEGMENT;
-typedef section Section;
-
-// This needs to be called “struct nlist” because “nlist” without the struct
-// refers to the nlist() function.
-typedef struct nlist Nlist;
-#endif
-
-#if defined(ARCH_CPU_X86_64)
-const int kCPUType = CPU_TYPE_X86_64;
-#elif defined(ARCH_CPU_X86)
-const int kCPUType = CPU_TYPE_X86;
-#endif
-
-// Verifies that |expect_section| and |actual_section| agree.
-void ExpectSection(const Section* expect_section,
-                   const process_types::section* actual_section) {
-  ASSERT_TRUE(expect_section);
-  ASSERT_TRUE(actual_section);
-
-  EXPECT_EQ(
-      MachOImageSegmentReader::SectionNameString(expect_section->sectname),
-      MachOImageSegmentReader::SectionNameString(actual_section->sectname));
-  EXPECT_EQ(
-      MachOImageSegmentReader::SegmentNameString(expect_section->segname),
-      MachOImageSegmentReader::SegmentNameString(actual_section->segname));
-  EXPECT_EQ(expect_section->addr, actual_section->addr);
-  EXPECT_EQ(expect_section->size, actual_section->size);
-  EXPECT_EQ(expect_section->offset, actual_section->offset);
-  EXPECT_EQ(expect_section->align, actual_section->align);
-  EXPECT_EQ(expect_section->reloff, actual_section->reloff);
-  EXPECT_EQ(expect_section->nreloc, actual_section->nreloc);
-  EXPECT_EQ(expect_section->flags, actual_section->flags);
-  EXPECT_EQ(expect_section->reserved1, actual_section->reserved1);
-  EXPECT_EQ(expect_section->reserved2, actual_section->reserved2);
-}
-
-// Verifies that |expect_segment| is a valid Mach-O segment load command for the
-// current system by checking its |cmd| field. Then, verifies that the
-// information in |actual_segment| matches that in |expect_segment|. The
-// |segname|, |vmaddr|, |vmsize|, and |fileoff| fields are examined. Each
-// section within the segment is also examined by calling ExpectSection().
-// Access to each section via both MachOImageSegmentReader::GetSectionByName()
-// and MachOImageReader::GetSectionByName() is verified, expecting that each
-// call produces the same section. Segment and section data addresses are
-// verified against data obtained by calling getsegmentdata() and
-// getsectiondata(). The segment is checked to make sure that it behaves
-// correctly when attempting to look up a nonexistent section by name.
-// |section_index| is used to track the last-used section index in an image on
-// entry, and is reset to the last-used section index on return after the
-// sections are processed. This is used to test that
-// MachOImageReader::GetSectionAtIndex() returns the correct result.
-void ExpectSegmentCommand(const SegmentCommand* expect_segment,
-                          const MachHeader* expect_image,
-                          const MachOImageSegmentReader* actual_segment,
-                          const MachOImageReader* actual_image,
-                          size_t* section_index) {
-  ASSERT_TRUE(expect_segment);
-  ASSERT_TRUE(actual_segment);
-
-  EXPECT_EQ(kSegmentCommand, expect_segment->cmd);
-
-  std::string segment_name = actual_segment->Name();
-  EXPECT_EQ(MachOImageSegmentReader::SegmentNameString(expect_segment->segname),
-            segment_name);
-  EXPECT_EQ(expect_segment->vmaddr, actual_segment->vmaddr());
-  EXPECT_EQ(expect_segment->vmsize, actual_segment->vmsize());
-  EXPECT_EQ(expect_segment->fileoff, actual_segment->fileoff());
-
-  if (actual_segment->SegmentSlides()) {
-    EXPECT_EQ(actual_segment->Address(),
-              actual_segment->vmaddr() + actual_image->Slide());
-
-    unsigned long expect_segment_size;
-    const uint8_t* expect_segment_data = getsegmentdata(
-        expect_image, segment_name.c_str(), &expect_segment_size);
-    mach_vm_address_t expect_segment_address =
-        reinterpret_cast<mach_vm_address_t>(expect_segment_data);
-    EXPECT_EQ(expect_segment_address, actual_segment->Address());
-    EXPECT_EQ(expect_segment_size, actual_segment->vmsize());
-    EXPECT_EQ(actual_segment->vmsize(), actual_segment->Size());
-  } else {
-    // getsegmentdata() doesn’t return appropriate data for the __PAGEZERO
-    // segment because getsegmentdata() always adjusts for slide, but the
-    // __PAGEZERO segment never slides, it just grows. Skip the getsegmentdata()
-    // check for that segment according to the same rules that the kernel uses
-    // to identify __PAGEZERO. See 10.9.4 xnu-2422.110.17/bsd/kern/mach_loader.c
-    // load_segment().
-    EXPECT_EQ(actual_segment->Address(), actual_segment->vmaddr());
-    EXPECT_EQ(actual_segment->vmsize() + actual_image->Slide(),
-              actual_segment->Size());
-  }
-
-  ASSERT_EQ(expect_segment->nsects, actual_segment->nsects());
-
-  // Make sure that the expected load command is big enough for the number of
-  // sections that it claims to have, and set up a pointer to its first section
-  // structure.
-  ASSERT_EQ(sizeof(*expect_segment) + expect_segment->nsects * sizeof(Section),
-            expect_segment->cmdsize);
-  const Section* expect_sections =
-      reinterpret_cast<const Section*>(&expect_segment[1]);
-
-  for (size_t index = 0; index < actual_segment->nsects(); ++index) {
-    const Section* expect_section = &expect_sections[index];
-    const process_types::section* actual_section =
-        actual_segment->GetSectionAtIndex(index, nullptr);
-    ASSERT_NO_FATAL_FAILURE(
-        ExpectSection(&expect_sections[index], actual_section));
-
-    // Make sure that the section is accessible by GetSectionByName as well.
-    std::string section_name =
-        MachOImageSegmentReader::SectionNameString(expect_section->sectname);
-    const process_types::section* actual_section_by_name =
-        actual_segment->GetSectionByName(section_name, nullptr);
-    EXPECT_EQ(actual_section, actual_section_by_name);
-
-    // Make sure that the section is accessible by the parent MachOImageReader’s
-    // GetSectionByName.
-    mach_vm_address_t actual_section_address;
-    const process_types::section* actual_section_from_image_by_name =
-        actual_image->GetSectionByName(
-            segment_name, section_name, &actual_section_address);
-    EXPECT_EQ(actual_section, actual_section_from_image_by_name);
-
-    if (actual_segment->SegmentSlides()) {
-      EXPECT_EQ(actual_section_address,
-                actual_section->addr + actual_image->Slide());
-
-      unsigned long expect_section_size;
-      const uint8_t* expect_section_data = getsectiondata(expect_image,
-                                                          segment_name.c_str(),
-                                                          section_name.c_str(),
-                                                          &expect_section_size);
-      mach_vm_address_t expect_section_address =
-          reinterpret_cast<mach_vm_address_t>(expect_section_data);
-      EXPECT_EQ(expect_section_address, actual_section_address);
-      EXPECT_EQ(expect_section_size, actual_section->size);
-    } else {
-      EXPECT_EQ(actual_section_address, actual_section->addr);
-    }
-
-    // Test the parent MachOImageReader’s GetSectionAtIndex as well.
-    const MachOImageSegmentReader* containing_segment;
-    mach_vm_address_t actual_section_address_at_index;
-    const process_types::section* actual_section_from_image_at_index =
-        actual_image->GetSectionAtIndex(++(*section_index),
-                                        &containing_segment,
-                                        &actual_section_address_at_index);
-    EXPECT_EQ(actual_section, actual_section_from_image_at_index);
-    EXPECT_EQ(actual_segment, containing_segment);
-    EXPECT_EQ(actual_section_address, actual_section_address_at_index);
-  }
-
-  EXPECT_EQ(nullptr,
-            actual_segment->GetSectionByName("NoSuchSection", nullptr));
-}
-
-// Walks through the load commands of |expect_image|, finding all of the
-// expected segment commands. For each expected segment command, calls
-// actual_image->GetSegmentByName() to obtain an actual segment command, and
-// calls ExpectSegmentCommand() to compare the expected and actual segments. A
-// series of by-name lookups is also performed on the segment to ensure that it
-// behaves correctly when attempting to look up segment and section names that
-// are not present. |test_section_indices| should be true to test
-// MachOImageReader::GetSectionAtIndex() using out-of-range section indices.
-// This should be tested for at least one module, but it’s very noisy in terms
-// of logging output, so this knob is provided to suppress this portion of the
-// test when looping over all modules.
-void ExpectSegmentCommands(const MachHeader* expect_image,
-                           const MachOImageReader* actual_image,
-                           bool test_section_index_bounds) {
-  ASSERT_TRUE(expect_image);
-  ASSERT_TRUE(actual_image);
-
-  // &expect_image[1] points right past the end of the mach_header[_64], to the
-  // start of the load commands.
-  const char* commands_base = reinterpret_cast<const char*>(&expect_image[1]);
-  uint32_t position = 0;
-  size_t section_index = 0;
-  for (uint32_t index = 0; index < expect_image->ncmds; ++index) {
-    ASSERT_LT(position, expect_image->sizeofcmds);
-    const load_command* command =
-        reinterpret_cast<const load_command*>(&commands_base[position]);
-    ASSERT_LE(position + command->cmdsize, expect_image->sizeofcmds);
-    if (command->cmd == kSegmentCommand) {
-      ASSERT_GE(command->cmdsize, sizeof(SegmentCommand));
-      const SegmentCommand* expect_segment =
-          reinterpret_cast<const SegmentCommand*>(command);
-      std::string segment_name =
-          MachOImageSegmentReader::SegmentNameString(expect_segment->segname);
-      const MachOImageSegmentReader* actual_segment =
-          actual_image->GetSegmentByName(segment_name);
-      ASSERT_NO_FATAL_FAILURE(ExpectSegmentCommand(expect_segment,
-                                                   expect_image,
-                                                   actual_segment,
-                                                   actual_image,
-                                                   &section_index));
-    }
-    position += command->cmdsize;
-  }
-  EXPECT_EQ(expect_image->sizeofcmds, position);
-
-  if (test_section_index_bounds) {
-    // GetSectionAtIndex uses a 1-based index. Make sure that the range is
-    // correct.
-    EXPECT_EQ(nullptr, actual_image->GetSectionAtIndex(0, nullptr, nullptr));
-    EXPECT_EQ(
-        nullptr,
-        actual_image->GetSectionAtIndex(section_index + 1, nullptr, nullptr));
-  }
-
-  // Make sure that by-name lookups for names that don’t exist work properly:
-  // they should return nullptr.
-  EXPECT_FALSE(actual_image->GetSegmentByName("NoSuchSegment"));
-  EXPECT_FALSE(actual_image->GetSectionByName(
-      "NoSuchSegment", "NoSuchSection", nullptr));
-
-  // Make sure that there’s a __TEXT segment so that this can do a valid test of
-  // a section that doesn’t exist within a segment that does.
-  EXPECT_TRUE(actual_image->GetSegmentByName(SEG_TEXT));
-  EXPECT_FALSE(
-      actual_image->GetSectionByName(SEG_TEXT, "NoSuchSection", nullptr));
-
-  // Similarly, make sure that a section name that exists in one segment isn’t
-  // accidentally found during a lookup for that section in a different segment.
-  //
-  // If the image has no sections (unexpected), then any section lookup should
-  // fail, and these initial values of test_segment and test_section are fine
-  // for the EXPECT_FALSE checks on GetSectionByName() below.
-  std::string test_segment = SEG_DATA;
-  std::string test_section = SECT_TEXT;
-
-  const process_types::section* section =
-      actual_image->GetSectionAtIndex(1, nullptr, nullptr);
-  if (section) {
-    // Use the name of the first section in the image as the section that
-    // shouldn’t appear in a different segment. If the first section is in the
-    // __TEXT segment (as it is normally), then a section by the same name
-    // wouldn’t be expected in the __DATA segment. But if the first section is
-    // in any other segment, then it wouldn’t be expected in the __TEXT segment.
-    if (MachOImageSegmentReader::SegmentNameString(section->segname) ==
-            SEG_TEXT) {
-      test_segment = SEG_DATA;
-    } else {
-      test_segment = SEG_TEXT;
-    }
-    test_section =
-        MachOImageSegmentReader::SectionNameString(section->sectname);
-
-    // It should be possible to look up the first section by name.
-    EXPECT_EQ(section,
-              actual_image->GetSectionByName(
-                  section->segname, section->sectname, nullptr));
-  }
-  EXPECT_FALSE(
-      actual_image->GetSectionByName("NoSuchSegment", test_section, nullptr));
-  EXPECT_FALSE(
-      actual_image->GetSectionByName(test_segment, test_section, nullptr));
-
-  // The __LINKEDIT segment normally does exist but doesn’t have any sections.
-  EXPECT_FALSE(
-      actual_image->GetSectionByName(SEG_LINKEDIT, "NoSuchSection", nullptr));
-  EXPECT_FALSE(
-      actual_image->GetSectionByName(SEG_LINKEDIT, SECT_TEXT, nullptr));
-}
-
-// In some cases, the expected slide value for an image is unknown, because no
-// reasonable API to return it is provided. When this happens, use kSlideUnknown
-// to avoid checking the actual slide value against anything.
-const mach_vm_size_t kSlideUnknown = std::numeric_limits<mach_vm_size_t>::max();
-
-// Verifies that |expect_image| is a vaild Mach-O header for the current system
-// by checking its |magic| and |cputype| fields. Then, verifies that the
-// information in |actual_image| matches that in |expect_image|. The |filetype|
-// field is examined, actual_image->Address() is compared to
-// |expect_image_address|, and actual_image->Slide() is compared to
-// |expect_image_slide|, unless |expect_image_slide| is kSlideUnknown. Various
-// other attributes of |actual_image| are sanity-checked depending on the Mach-O
-// file type. Finally, ExpectSegmentCommands() is called to verify all that all
-// of the segments match; |test_section_index_bounds| is used as an argument to
-// that function.
-void ExpectMachImage(const MachHeader* expect_image,
-                     mach_vm_address_t expect_image_address,
-                     mach_vm_size_t expect_image_slide,
-                     const MachOImageReader* actual_image,
-                     bool test_section_index_bounds) {
-  ASSERT_TRUE(expect_image);
-  ASSERT_TRUE(actual_image);
-
-  EXPECT_EQ(kMachMagic, expect_image->magic);
-  EXPECT_EQ(kCPUType, expect_image->cputype);
-
-  EXPECT_EQ(expect_image->filetype, actual_image->FileType());
-  EXPECT_EQ(expect_image_address, actual_image->Address());
-  if (expect_image_slide != kSlideUnknown) {
-    EXPECT_EQ(expect_image_slide, actual_image->Slide());
-  }
-
-  const MachOImageSegmentReader* actual_text_segment =
-      actual_image->GetSegmentByName(SEG_TEXT);
-  ASSERT_TRUE(actual_text_segment);
-  EXPECT_EQ(expect_image_address, actual_text_segment->Address());
-  EXPECT_EQ(actual_image->Size(), actual_text_segment->Size());
-  EXPECT_EQ(expect_image_address - actual_text_segment->vmaddr(),
-            actual_image->Slide());
-
-  uint32_t file_type = actual_image->FileType();
-  EXPECT_TRUE(file_type == MH_EXECUTE || file_type == MH_DYLIB ||
-              file_type == MH_DYLINKER || file_type == MH_BUNDLE);
-
-  if (file_type == MH_EXECUTE || file_type == MH_DYLINKER) {
-    EXPECT_EQ("/usr/lib/dyld", actual_image->DylinkerName());
-  }
-
-  // For these, just don’t crash or anything.
-  if (file_type == MH_DYLIB) {
-    actual_image->DylibVersion();
-  }
-  actual_image->SourceVersion();
-  UUID uuid;
-  actual_image->UUID(&uuid);
-
-  ASSERT_NO_FATAL_FAILURE(ExpectSegmentCommands(
-      expect_image, actual_image, test_section_index_bounds));
-}
-
-// Verifies the symbol whose Nlist structure is |entry| and whose name is |name|
-// matches the value of a symbol by the same name looked up in |actual_image|.
-// MachOImageReader::LookUpExternalDefinedSymbol() is used for this purpose.
-// Only external defined symbols are considered, other types of symbols are
-// excluded because LookUpExternalDefinedSymbol() only deals with external
-// defined symbols.
-void ExpectSymbol(const Nlist* entry,
-                  const char* name,
-                  const MachOImageReader* actual_image) {
-  SCOPED_TRACE(name);
-
-  uint32_t entry_type = entry->n_type & N_TYPE;
-  if ((entry->n_type & N_STAB) == 0 && (entry->n_type & N_PEXT) == 0 &&
-      entry_type != N_UNDF && entry_type != N_PBUD &&
-      (entry->n_type & N_EXT) == 1) {
-    // Note that this catches more symbols than MachOImageSymbolTableReader
-    // does. This test looks for all external defined symbols, but the
-    // implementation excludes indirect (N_INDR) symbols. This is intentional,
-    // because indirect symbols are currently not seen in the wild, but if they
-    // begin to be used more widely, this test is expected to catch them so that
-    // a decision can be made regarding whether support ought to be implemented.
-    mach_vm_address_t actual_address;
-    ASSERT_TRUE(
-        actual_image->LookUpExternalDefinedSymbol(name, &actual_address));
-
-    // Since the nlist interface was used to read the symbol, use it to compute
-    // the symbol address too. This isn’t perfect, and it should be possible in
-    // theory to use dlsym() to get the expected address of a symbol. In
-    // practice, dlsym() is difficult to use when only a MachHeader* is
-    // available as in this function, as opposed to a void* opaque handle. It is
-    // possible to get a void* handle by using dladdr() to find the file name
-    // corresponding to the MachHeader*, and using dlopen() again on that name,
-    // assuming it hasn’t changed on disk since being loaded. However, even with
-    // that being done, dlsym() can only deal with symbols whose names begin
-    // with an underscore (and requires that the leading underscore be trimmed).
-    // dlsym() will also return different addresses for symbols that are
-    // resolved via symbol resolver.
-    mach_vm_address_t expect_address = entry->n_value;
-    if (entry_type == N_SECT) {
-      EXPECT_GE(entry->n_sect, 1u);
-      expect_address += actual_image->Slide();
-    } else {
-      EXPECT_EQ(NO_SECT, entry->n_sect);
-    }
-
-    EXPECT_EQ(expect_address, actual_address);
-  }
-
-  // You’d think that it might be a good idea to verify that if the conditions
-  // above weren’t met, that the symbol didn’t show up in actual_image’s symbol
-  // table at all. Unfortunately, it’s possible for the same name to show up as
-  // both an external defined symbol and as something else, so it’s not possible
-  // to verify this reliably.
-}
-
-// Locates the symbol table in |expect_image| and verifies that all of the
-// external defined symbols found there are also present and have the same
-// values in |actual_image|. ExpectSymbol() is used to verify the actual symbol.
-void ExpectSymbolTable(const MachHeader* expect_image,
-                       const MachOImageReader* actual_image) {
-  // This intentionally consults only LC_SYMTAB and not LC_DYSYMTAB so that it
-  // can look at the larger set of all symbols. The actual implementation being
-  // tested is free to consult LC_DYSYMTAB, but that’s considered an
-  // optimization. It’s not necessary for the test, and it’s better for the test
-  // to expose bugs in that optimization rather than duplicate them.
-  const char* commands_base = reinterpret_cast<const char*>(&expect_image[1]);
-  uint32_t position = 0;
-  const symtab_command* symtab = nullptr;
-  const SegmentCommand* linkedit = nullptr;
-  for (uint32_t index = 0; index < expect_image->ncmds; ++index) {
-    ASSERT_LT(position, expect_image->sizeofcmds);
-    const load_command* command =
-        reinterpret_cast<const load_command*>(&commands_base[position]);
-    ASSERT_LE(position + command->cmdsize, expect_image->sizeofcmds);
-    if (command->cmd == LC_SYMTAB) {
-      ASSERT_FALSE(symtab);
-      ASSERT_EQ(sizeof(symtab_command), command->cmdsize);
-      symtab = reinterpret_cast<const symtab_command*>(command);
-    } else if (command->cmd == kSegmentCommand) {
-      ASSERT_GE(command->cmdsize, sizeof(SegmentCommand));
-      const SegmentCommand* segment =
-          reinterpret_cast<const SegmentCommand*>(command);
-      std::string segment_name =
-          MachOImageSegmentReader::SegmentNameString(segment->segname);
-      if (segment_name == SEG_LINKEDIT) {
-        ASSERT_FALSE(linkedit);
-        linkedit = segment;
-      }
-    }
-    position += command->cmdsize;
-  }
-
-  if (symtab) {
-    ASSERT_TRUE(linkedit);
-
-    const char* linkedit_base =
-        reinterpret_cast<const char*>(linkedit->vmaddr + actual_image->Slide());
-    const Nlist* nlist = reinterpret_cast<const Nlist*>(
-        linkedit_base + symtab->symoff - linkedit->fileoff);
-    const char* strtab = linkedit_base + symtab->stroff - linkedit->fileoff;
-
-    for (uint32_t index = 0; index < symtab->nsyms; ++index) {
-      const Nlist* entry = nlist + index;
-      const char* name = strtab + entry->n_un.n_strx;
-      ASSERT_NO_FATAL_FAILURE(ExpectSymbol(entry, name, actual_image));
-    }
-  }
-
-  mach_vm_address_t ignore;
-  EXPECT_FALSE(actual_image->LookUpExternalDefinedSymbol("", &ignore));
-  EXPECT_FALSE(
-      actual_image->LookUpExternalDefinedSymbol("NoSuchSymbolName", &ignore));
-  EXPECT_FALSE(
-      actual_image->LookUpExternalDefinedSymbol("_NoSuchSymbolName", &ignore));
-}
-
-TEST(MachOImageReader, Self_MainExecutable) {
-  ProcessReader process_reader;
-  ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
-
-  const MachHeader* mh_execute_header =
-      reinterpret_cast<MachHeader*>(dlsym(RTLD_MAIN_ONLY, MH_EXECUTE_SYM));
-  ASSERT_NE(nullptr, mh_execute_header);
-  mach_vm_address_t mh_execute_header_address =
-      reinterpret_cast<mach_vm_address_t>(mh_execute_header);
-
-  MachOImageReader image_reader;
-  ASSERT_TRUE(image_reader.Initialize(
-      &process_reader, mh_execute_header_address, "executable"));
-
-  EXPECT_EQ(static_cast<uint32_t>(MH_EXECUTE), image_reader.FileType());
-
-  // The main executable has image index 0.
-  intptr_t image_slide = _dyld_get_image_vmaddr_slide(0);
-
-  ASSERT_NO_FATAL_FAILURE(ExpectMachImage(mh_execute_header,
-                                          mh_execute_header_address,
-                                          image_slide,
-                                          &image_reader,
-                                          true));
-
-  // This symbol, __mh_execute_header, is known to exist in all MH_EXECUTE
-  // Mach-O files.
-  mach_vm_address_t symbol_address;
-  ASSERT_TRUE(image_reader.LookUpExternalDefinedSymbol(_MH_EXECUTE_SYM,
-                                                       &symbol_address));
-  EXPECT_EQ(mh_execute_header_address, symbol_address);
-
-  ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mh_execute_header, &image_reader));
-}
-
-TEST(MachOImageReader, Self_DyldImages) {
-  ProcessReader process_reader;
-  ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
-
-  uint32_t count = _dyld_image_count();
-  ASSERT_GE(count, 1u);
-
-  for (uint32_t index = 0; index < count; ++index) {
-    const char* image_name = _dyld_get_image_name(index);
-    SCOPED_TRACE(base::StringPrintf("index %u, image %s", index, image_name));
-
-    // _dyld_get_image_header() is poorly-declared: it’s declared as returning
-    // const mach_header* in both 32-bit and 64-bit environments, but in the
-    // 64-bit environment, it should be const mach_header_64*.
-    const MachHeader* mach_header =
-        reinterpret_cast<const MachHeader*>(_dyld_get_image_header(index));
-    mach_vm_address_t image_address =
-        reinterpret_cast<mach_vm_address_t>(mach_header);
-
-    MachOImageReader image_reader;
-    ASSERT_TRUE(
-        image_reader.Initialize(&process_reader, image_address, image_name));
-
-    uint32_t file_type = image_reader.FileType();
-    if (index == 0) {
-      EXPECT_EQ(static_cast<uint32_t>(MH_EXECUTE), file_type);
-    } else {
-      EXPECT_TRUE(file_type == MH_DYLIB || file_type == MH_BUNDLE);
-    }
-
-    intptr_t image_slide = _dyld_get_image_vmaddr_slide(index);
-    ASSERT_NO_FATAL_FAILURE(ExpectMachImage(
-        mach_header, image_address, image_slide, &image_reader, false));
-
-    ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mach_header, &image_reader));
-  }
-
-  // Now that all of the modules have been verified, make sure that dyld itself
-  // can be read properly too.
-  const struct dyld_all_image_infos* dyld_image_infos =
-      _dyld_get_all_image_infos();
-  ASSERT_GE(dyld_image_infos->version, 1u);
-  EXPECT_EQ(count, dyld_image_infos->infoArrayCount);
-
-  if (dyld_image_infos->version >= 2) {
-    SCOPED_TRACE("dyld");
-
-    // dyld_all_image_infos::dyldImageLoadAddress is poorly-declared too.
-    const MachHeader* mach_header = reinterpret_cast<const MachHeader*>(
-        dyld_image_infos->dyldImageLoadAddress);
-    mach_vm_address_t image_address =
-        reinterpret_cast<mach_vm_address_t>(mach_header);
-
-    MachOImageReader image_reader;
-    ASSERT_TRUE(
-        image_reader.Initialize(&process_reader, image_address, "dyld"));
-
-    EXPECT_EQ(static_cast<uint32_t>(MH_DYLINKER), image_reader.FileType());
-
-    // There’s no good API to get dyld’s slide, so don’t bother checking it.
-    ASSERT_NO_FATAL_FAILURE(ExpectMachImage(
-        mach_header, image_address, kSlideUnknown, &image_reader, false));
-
-    ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mach_header, &image_reader));
-  }
-
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
-  // If dyld is new enough to record UUIDs, check the UUID of any module that
-  // it says has one. Note that dyld doesn’t record UUIDs of anything that
-  // loaded out of the shared cache, but it should at least have a UUID for the
-  // main executable if it has one.
-  if (dyld_image_infos->version >= 8 && dyld_image_infos->uuidArray) {
-    for (uint32_t index = 0;
-         index < dyld_image_infos->uuidArrayCount;
-         ++index) {
-      const dyld_uuid_info* dyld_image = &dyld_image_infos->uuidArray[index];
-      SCOPED_TRACE(base::StringPrintf("uuid index %u", index));
-
-      // dyld_uuid_info::imageLoadAddress is poorly-declared too.
-      const MachHeader* mach_header =
-          reinterpret_cast<const MachHeader*>(dyld_image->imageLoadAddress);
-      mach_vm_address_t image_address =
-          reinterpret_cast<mach_vm_address_t>(mach_header);
-
-      MachOImageReader image_reader;
-      ASSERT_TRUE(
-          image_reader.Initialize(&process_reader, image_address, "uuid"));
-
-      // There’s no good way to get the image’s slide here, although the image
-      // should have already been checked along with its slide above, in the
-      // loop through all images.
-      ExpectMachImage(
-          mach_header, image_address, kSlideUnknown, &image_reader, false);
-
-      UUID expected_uuid;
-      expected_uuid.InitializeFromBytes(dyld_image->imageUUID);
-      UUID actual_uuid;
-      image_reader.UUID(&actual_uuid);
-      EXPECT_EQ(expected_uuid, actual_uuid);
-    }
-  }
-#endif
-}
-
-}  // namespace
-}  // namespace test
-}  // namespace crashpad