Added an option (-i) to have dump_syms output header information only.

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 33 matching lines @@
 #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) {}
+      : srcPath(), dsymPath(), arch(), header_only(false),
+        cfi(true), handle_inter_cu_refs(true) {}
 
   string srcPath;
   string dsymPath;
   const NXArchInfo *arch;
+  bool header_only;
   bool cfi;
   bool handle_inter_cu_refs;
 };
 
 static bool StackFrameEntryComparator(const Module::StackFrameEntry* a,
                                       const Module::StackFrameEntry* b) {
   return a->address < b->address;
 }
 
 // Copy the CFI data from |from_module| into |to_module|, for any non-
@@ skipping 75 matching lines @@
         if (arch_info)
           fprintf(stderr, "%s (%s)\n", arch_info->name, arch_info->description);
         else
           fprintf(stderr, "unrecognized cpu type 0x%x, subtype 0x%x\n",
                   arch->cputype, arch->cpusubtype);
       }
       return false;
     }
   }
 
+  if (options.header_only)
+    return dump_symbols.WriteSymbolFileHeader(std::cout);
+
   // Read the primary file into a Breakpad Module.
   Module* module = NULL;
   if (!dump_symbols.ReadSymbolData(&module))
     return false;
   scoped_ptr<Module> scoped_module(module);
 
   // If this is a split module, read the secondary Mach-O file, from which the
   // CFI data will be extracted.
   if (split_module && primary_file == options.dsymPath) {
     if (!dump_symbols.Read(options.srcPath))
@@ skipping 18 matching lines @@
   }
 
   return module->Write(std::cout, symbol_data);
 }
 
 //=============================================================================
 static void Usage(int argc, const char *argv[]) {
   fprintf(stderr, "Output a Breakpad symbol file from a Mach-o file.\n");
   fprintf(stderr, "Usage: %s [-a ARCHITECTURE] [-c] [-g dSYM path] "
                   "<Mach-o file>\n", argv[0]);
+  fprintf(stderr, "\t-i: Output module header information only.\n");
   fprintf(stderr, "\t-a: Architecture type [default: native, or whatever is\n");
   fprintf(stderr, "\t    in the file, if it contains only one architecture]\n");
   fprintf(stderr, "\t-g: Debug symbol file (dSYM) to dump in addition to the "
                   "Mach-o file\n");
   fprintf(stderr, "\t-c: Do not generate CFI section\n");
   fprintf(stderr, "\t-r: Do not handle inter-compilation unit references\n");
   fprintf(stderr, "\t-h: Usage\n");
   fprintf(stderr, "\t-?: Usage\n");
 }
 
 //=============================================================================
 static void SetupOptions(int argc, const char *argv[], Options *options) {
   extern int optind;
   signed char ch;
 
-  while ((ch = getopt(argc, (char * const *)argv, "a:g:chr?")) != -1) {
+  while ((ch = getopt(argc, (char * const *)argv, "ia:g:chr?")) != -1) {
     switch (ch) {
+      case 'i':
+        options->header_only = true;
+        break;
       case 'a': {
         const NXArchInfo *arch_info =
             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;
@@ skipping 27 matching lines @@
 //=============================================================================
 int main (int argc, const char * argv[]) {
   Options options;
   bool result;
 
   SetupOptions(argc, argv, &options);
   result = Start(options);
 
   return !result;
 }