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

snapshot/mac/mach_o_image_reader.cc

 // 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 "snapshot/mac/mach_o_image_reader.h"
 
 #include <mach-o/loader.h>
 #include <mach-o/nlist.h>
 #include <string.h>
 
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "snapshot/mac/mach_o_image_segment_reader.h"
+#include "snapshot/mac/mach_o_image_symbol_table_reader.h"
+#include "snapshot/mac/process_reader.h"
 #include "util/mac/checked_mach_address_range.h"
-#include "util/mac/mach_o_image_segment_reader.h"
-#include "util/mac/mach_o_image_symbol_table_reader.h"
-#include "util/mac/process_reader.h"
 
 namespace {
 
 const uint32_t kInvalidSegmentIndex = std::numeric_limits<uint32_t>::max();
 
 }  // namespace
 
 namespace crashpad {
 
 MachOImageReader::MachOImageReader()
@@ skipping 220 matching lines @@
   for (MachOImageSegmentReader* segment : segments_) {
     segment->SetSlide(slide_);
 
     // This was already checked for the unslid values while the segments were
     // read, but now it’s possible to check the slid values too. The individual
     // sections don’t need to be checked because they were verified to be
     // contained within their respective segments when the segments were read.
     mach_vm_address_t slid_segment_address = segment->Address();
     mach_vm_size_t slid_segment_size = segment->Size();
     CheckedMachAddressRange slid_segment_range(
-        process_reader_, slid_segment_address, slid_segment_size);
+        process_reader_->Is64Bit(), slid_segment_address, slid_segment_size);
     if (!slid_segment_range.IsValid()) {
       LOG(WARNING) << base::StringPrintf(
                           "invalid slid segment range 0x%llx + 0x%llx, "
                           "segment ",
                           slid_segment_address,
                           slid_segment_size) << segment->Name() << module_info_;
       return false;
     }
   }
 
@@ skipping 127 matching lines @@
   // There, ld takes symbols that refer to anything in the mach_header[_64] and
   // marks them as being in section 1. Here, section 1 is treated in this same
   // special way as long as it’s in the __TEXT segment that begins at the start
   // of the image, which is normally the case, and as long as the symbol’s value
   // is the base of the image.
   //
   // This only happens for PIE executables, because __mh_execute_header needs
   // to slide. In non-PIE executables, __mh_execute_header is an absolute
   // symbol.
   CheckedMachAddressRange section_range(
-      process_reader_, section_address, section->size);
+      process_reader_->Is64Bit(), section_address, section->size);
   if (!section_range.ContainsValue(slid_value) &&
       !(symbol_info->section == 1 && segment->Name() == SEG_TEXT &&
         slid_value == Address())) {
     std::string section_name_full =
         MachOImageSegmentReader::SegmentAndSectionNameString(section->segname,
                                                              section->sectname);
     LOG(WARNING) << base::StringPrintf(
                         "symbol %s (0x%llx) outside of section %s (0x%llx + "
                         "0x%llx)",
                         name.c_str(),
@@ skipping 233 matching lines @@
                                  linkedit_segment,
                                  module_info_)) {
     symbol_table_.reset();
     return;
   }
 
   symbol_table_initialized_.set_valid();
 }
 
 }  // namespace crashpad