Fix Mac Breakpad host tools to build in Linux cross-compile

src/common/mac/dump_syms.h

 // -*- mode: c++ -*-
 
 // Copyright (c) 2011, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
@@ skipping 17 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
 
 // dump_syms.h: Declaration of google_breakpad::DumpSymbols, a class for
 // reading debugging information from Mach-O files and writing it out as a
 // Breakpad symbol file.
 
-#include <Foundation/Foundation.h>
 #include <mach-o/loader.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "common/byte_cursor.h"
 #include "common/mac/macho_reader.h"
 #include "common/mac/super_fat_arch.h"
 #include "common/module.h"
 #include "common/symbol_data.h"
 
 namespace google_breakpad {
 
 class DumpSymbols {
  public:
   DumpSymbols(SymbolData symbol_data, bool handle_inter_cu_refs)
       : symbol_data_(symbol_data),
         handle_inter_cu_refs_(handle_inter_cu_refs),
         input_pathname_(),
         object_filename_(),
         contents_(),
         object_files_(),
         selected_object_file_(),
         selected_object_name_() { }
   ~DumpSymbols() {
-    [input_pathname_ release];
-    [object_filename_ release];
-    [contents_ release];
   }
 
   // Prepare to read debugging information from |filename|. |filename| may be
   // the name of a universal binary, a Mach-O file, or a dSYM bundle
   // containing either of the above. On success, return true; if there is a
   // problem reading |filename|, report it and return false.
-  //
-  // (This class uses NSString for filenames and related values,
-  // because the Mac Foundation framework seems to support
-  // filename-related operations more fully on NSString values.)
-  bool Read(NSString *filename);
+  bool Read(const std::string &filename);
 
   // If this dumper's file includes an object file for |cpu_type| and
   // |cpu_subtype|, then select that object file for dumping, and return
   // true. Otherwise, return false, and leave this dumper's selected
   // architecture unchanged.
   //
   // By default, if this dumper's file contains only one object file, then
   // the dumper will dump those symbols; and if it contains more than one
   // object file, then the dumper will dump the object file whose
   // architecture matches that of this dumper program.
@@ skipping 65 matching lines @@
                bool eh_frame) const;
 
   // The selection of what type of symbol data to read/write.
   const SymbolData symbol_data_;
 
   // Whether to handle references between compilation units.
   const bool handle_inter_cu_refs_;
 
   // The name of the file or bundle whose symbols this will dump.
   // This is the path given to Read, for use in error messages.
-  NSString *input_pathname_;
+  std::string input_pathname_;
 
   // The name of the file this DumpSymbols will actually read debugging
   // information from. Normally, this is the same as input_pathname_, but if
   // filename refers to a dSYM bundle, then this is the resource file
   // within that bundle.
-  NSString *object_filename_;
+  std::string object_filename_;
 
   // The complete contents of object_filename_, mapped into memory.
-  NSData *contents_;
+  vector<uint8_t> contents_;

[Mark Mentovai, 2015/09/11 15:49:50]

vector<> always initializes each element when it grows, which is undesirable
when reading a large file into it immediately afterwards. A scoped_ptr_malloc or
something else that doesn’t do initialization may be more appropriate.

[Ted Mielczarek, 2015/09/15 12:58:36]

Done.

 
   // A vector of SuperFatArch structures describing the object files
   // object_filename_ contains. If object_filename_ refers to a fat binary,
   // this may have more than one element; if it refers to a Mach-O file, this
   // has exactly one element.
   vector<SuperFatArch> object_files_;
 
   // The object file in object_files_ selected to dump, or NULL if
   // SetArchitecture hasn't been called yet.
   const SuperFatArch *selected_object_file_;
 
   // A string that identifies the selected object file, for use in error
   // messages.  This is usually object_filename_, but if that refers to a
   // fat binary, it includes an indication of the particular architecture
   // within that binary.
   string selected_object_name_;
 };
 
 }  // namespace google_breakpad