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

src/tools/mac/dump_syms/dump_syms_tool.cc

 // -*- 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 11 matching lines @@
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // 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.
 
-// dump_syms_tool.mm: Command line tool that uses the DumpSymbols class.
+// dump_syms_tool.cc: Command line tool that uses the DumpSymbols class.
 // TODO(waylonis): accept stdin
 
 #include <mach-o/arch.h>
 #include <unistd.h>
 
+#include <algorithm>
 #include <iostream>
 #include <vector>
 
 #include "common/mac/dump_syms.h"
 #include "common/mac/arch_utilities.h"
 #include "common/mac/macho_utilities.h"
 #include "common/scoped_ptr.h"
 
 using google_breakpad::DumpSymbols;
 using google_breakpad::Module;
 using google_breakpad::scoped_ptr;
 using std::vector;
 
 struct Options {
   Options()
       : srcPath(), dsymPath(), arch(), cfi(true), handle_inter_cu_refs(true) {}
-  NSString *srcPath;
-  NSString *dsymPath;
+
+  string srcPath;
+  string dsymPath;
   const NXArchInfo *arch;
   bool cfi;
   bool handle_inter_cu_refs;
 };
 
 static bool StackFrameEntryComparator(const Module::StackFrameEntry* a,
                                       const Module::StackFrameEntry* b) {
   return a->address < b->address;
 }
 
@@ skipping 41 matching lines @@
   DumpSymbols dump_symbols(symbol_data, options.handle_inter_cu_refs);
 
   // For x86_64 binaries, the CFI data is in the __TEXT,__eh_frame of the
   // Mach-O file, which is not copied into the dSYM. Whereas in i386, the CFI
   // data is in the __DWARF,__debug_frame section, which is moved into the
   // dSYM. Therefore, to get x86_64 CFI data, dump_syms needs to look at both
   // the dSYM and the Mach-O file. If both paths are present and CFI was
   // requested, then consider the Module as "split" and dump all the debug data
   // from the primary debug info file, the dSYM, and then dump additional CFI
   // data from the source Mach-O file.
-  bool split_module = options.dsymPath && options.srcPath && options.cfi;
-  NSString* primary_file = split_module ? options.dsymPath : options.srcPath;
+  bool split_module =
+    !options.dsymPath.empty() && !options.srcPath.empty() && options.cfi;
+  const string& primary_file =
+    split_module ? options.dsymPath : options.srcPath;
 
   if (!dump_symbols.Read(primary_file))
     return false;
 
   if (options.arch) {
     if (!dump_symbols.SetArchitecture(options.arch->cputype,
                                       options.arch->cpusubtype)) {
       fprintf(stderr, "%s: no architecture '%s' is present in file.\n",
-              [primary_file fileSystemRepresentation], options.arch->name);
+              primary_file.c_str(), options.arch->name);
       size_t available_size;
       const SuperFatArch *available =
         dump_symbols.AvailableArchitectures(&available_size);
       if (available_size == 1)
         fprintf(stderr, "the file's architecture is: ");
       else
         fprintf(stderr, "architectures present in the file are:\n");
       for (size_t i = 0; i < available_size; i++) {
         const SuperFatArch *arch = &available[i];
         const NXArchInfo *arch_info =
@@ skipping 69 matching lines @@
             google_breakpad::BreakpadGetArchInfoFromName(optarg);
         if (!arch_info) {
           fprintf(stderr, "%s: Invalid architecture: %s\n", argv[0], optarg);
           Usage(argc, argv);
           exit(1);
         }
         options->arch = arch_info;
         break;
       }
       case 'g':
-        options->dsymPath = [[NSFileManager defaultManager]
-            stringWithFileSystemRepresentation:optarg length:strlen(optarg)];
+        options->dsymPath = optarg;
         break;
       case 'c':
         options->cfi = false;
         break;
       case 'r':
         options->handle_inter_cu_refs = false;
         break;
       case '?':
       case 'h':
         Usage(argc, argv);
         exit(0);
         break;
     }
   }
 
   if ((argc - optind) != 1) {
     fprintf(stderr, "Must specify Mach-o file\n");
     Usage(argc, argv);
     exit(1);
   }
 
-  options->srcPath = [[NSFileManager defaultManager]
-                       stringWithFileSystemRepresentation:argv[optind]
-                       length:strlen(argv[optind])];
+  options->srcPath = argv[optind];
 }
 
 //=============================================================================
 int main (int argc, const char * argv[]) {
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   Options options;
   bool result;
 
   SetupOptions(argc, argv, &options);
   result = Start(options);
 
-  [pool release];
-
   return !result;
 }