Add a MappedMemory interface to TaskMemory and use it in MachOImageSymbolTableReader

util/mac/mach_o_image_symbol_table_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,
@@ skipping 86 matching lines @@
     }
 
     scoped_ptr<process_types::nlist[]> symbols(
         new process_types::nlist[symtab_command->nsyms]);
     if (!process_types::nlist::ReadArrayInto(
             process_reader_, symtab_address, symbol_count, &symbols[0])) {
       LOG(WARNING) << "could not read symbol table" << module_info_;
       return false;
     }
 
+    scoped_ptr<TaskMemory::MappedMemory> string_table;
     for (size_t symbol_index = 0; symbol_index < symbol_count; ++symbol_index) {
       const process_types::nlist& symbol = symbols[symbol_index];
       std::string symbol_info = base::StringPrintf(", symbol index %zu%s",
                                                    skip_count + symbol_index,
                                                    module_info_.c_str());
       uint8_t symbol_type = symbol.n_type & N_TYPE;
       if ((symbol.n_type & N_STAB) == 0 && (symbol.n_type & N_PEXT) == 0 &&
           (symbol_type == N_ABS || symbol_type == N_SECT) &&
           (symbol.n_type & N_EXT)) {
         if (symbol.n_strx >= strtab_size) {
           LOG(WARNING) << base::StringPrintf(
                               "string at 0x%x out of bounds (0x%llx)",
                               symbol.n_strx,
                               strtab_size) << symbol_info;
           return false;
         }
 
+        if (!string_table) {
+          string_table = process_reader_->Memory()->ReadMapped(
+              strtab_address, strtab_size);
+          if (!string_table) {
+            LOG(WARNING) << "could not read string table" << module_info_;
+            return false;
+          }
+        }
+
         std::string name;
-        if (!process_reader_->Memory()->ReadCStringSizeLimited(
-                strtab_address + symbol.n_strx,
-                strtab_size - symbol.n_strx,
-                &name)) {
+        if (!string_table->ReadCString(symbol.n_strx, &name)) {

[Robert Sesek, 2014/09/10 21:37:40]

This doesn't take into the size limiting anymore. Is that OK?

[Mark Mentovai, 2014/09/10 22:16:55]

rsesek wrote:
It still does. |strtab_size| was the size given when the string table was read
on line 127, and you can only access up to that size through this interface.
ReadCString will return false if you try to read past strtab_size.

           LOG(WARNING) << "could not read string" << symbol_info;
           return false;
         }
 
         if (symbol_type == N_ABS && symbol.n_sect != NO_SECT) {
           LOG(WARNING) << base::StringPrintf("N_ABS symbol %s in section %u",
                                              name.c_str(),
                                              symbol.n_sect) << symbol_info;
           return false;
         }
@@ skipping 119 matching lines @@
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   const auto& iterator = external_defined_symbols_.find(name);
   if (iterator == external_defined_symbols_.end()) {
     return NULL;
   }
   return &iterator->second;
 }
 
 }  // namespace crashpad