In Mac dump_syms, allow reading debug data out of both the Mach-O file and the dSYM.

This adds a new |-g <dSYM path>| flag to dump_syms, to specify the dSYM path for
the target Mach-O argument. The UUIDs and architectures of the two paths must
match in order to dump symbols for this "split module."

This reason for this is that for x86_64 binaries on OS X, the CFI data is stored
in the __TEXT,__eh_frame segment of the Mach-O file, and the data is not copied
into the dSYM by dsymutil.  Therefore, just dumping the dSYM doesn't yield CFI
data for x86_64 files, and both the dSYM and the Mach-O file must be dumped in
order to produce a complete Breakpad symbol file. For i386 binaries, the CFI data
is stored in the __DWARF,__debug_frame segment, which is part of the dSYM, so
this isn't necessary.

BUG=https://code.google.com/p/chromium/issues/detail?id=393594
R=mark@chromium.org

Review URL: https://breakpad.appspot.com/6704002

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1359 4c0a9323-5329-0410-9bdc-e9ce6186880e

src/common/module.cc

@@ -155,7 +155,7 @@ void Module::GetFiles(vector<File *> *vec) {
     vec->push_back(it->second);
 }
 
-void Module::GetStackFrameEntries(vector<StackFrameEntry *> *vec) {
+void Module::GetStackFrameEntries(vector<StackFrameEntry *> *vec) const {
   *vec = stack_frame_entries_;
 }
 

src/common/module.h

@@ -247,7 +247,7 @@ class Module {
   // effectively a copy of the stack frame entry list, this is mostly
   // useful for testing; other uses should probably get
   // a more appropriate interface.)
-  void GetStackFrameEntries(vector<StackFrameEntry *> *vec);
+  void GetStackFrameEntries(vector<StackFrameEntry *> *vec) const;
 
   // Find those files in this module that are actually referred to by
   // functions' line number data, and assign them source id numbers.
@@ -270,6 +270,11 @@ class Module {
   // established by SetLoadAddress.
   bool Write(std::ostream &stream, SymbolData symbol_data);
 
+  string name() const { return name_; }
+  string os() const { return os_; }
+  string architecture() const { return architecture_; }
+  string identifier() const { return id_; }
+
  private:
   // Report an error that has occurred writing the symbol file, using
   // errno to find the appropriate cause.  Return false.

src/tools/mac/dump_syms/dump_syms_tool.mm

@@ -41,31 +41,89 @@
 #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(), arch(), cfi(true), handle_inter_cu_refs(true) { }
   NSString *srcPath;
+  NSString *dsymPath;
   const NXArchInfo *arch;
   bool cfi;
   bool handle_inter_cu_refs;
 };
 
-//=============================================================================
+static bool StackFrameEntryComparator(const Module::StackFrameEntry* a,
-static bool Start(const Options &options) {
+                                      const Module::StackFrameEntry* b) {
-  DumpSymbols dump_symbols(options.cfi ? ALL_SYMBOL_DATA : NO_CFI,
+  return a->address < b->address;
-                           options.handle_inter_cu_refs);
+}
 
-  if (!dump_symbols.Read(options.srcPath))
+// Copy the CFI data from |from_module| into |to_module|, for any non-
+// overlapping ranges.
+static void CopyCFIDataBetweenModules(Module* to_module,
+                                      const Module* from_module) {
+  typedef vector<Module::StackFrameEntry*>::const_iterator Iterator;
+
+  // Get the CFI data from both the source and destination modules and ensure
+  // it is sorted by start address.
+  vector<Module::StackFrameEntry*> from_data;
+  from_module->GetStackFrameEntries(&from_data);
+  std::sort(from_data.begin(), from_data.end(), &StackFrameEntryComparator);
+
+  vector<Module::StackFrameEntry*> to_data;
+  to_module->GetStackFrameEntries(&to_data);
+  std::sort(to_data.begin(), to_data.end(), &StackFrameEntryComparator);
+
+  Iterator to_it = to_data.begin();
+
+  for (Iterator it = from_data.begin(); it != from_data.end(); ++it) {
+    Module::StackFrameEntry* from_entry = *it;
+    Module::Address from_entry_end = from_entry->address + from_entry->size;
+
+    // Find the first CFI record in the |to_module| that does not have an
+    // address less than the entry to be copied.
+    while (to_it != to_data.end()) {
+      if (from_entry->address > (*to_it)->address)
+        ++to_it;
+      else
+        break;
+    }
+
+    // If the entry does not overlap, then it is safe to copy to |to_module|.
+    if (to_it == to_data.end() || (from_entry->address < (*to_it)->address &&
+            from_entry_end < (*to_it)->address)) {
+      to_module->AddStackFrameEntry(new Module::StackFrameEntry(*from_entry));
+    }
+  }
+}
+
+static bool Start(const Options &options) {
+  SymbolData symbol_data = options.cfi ? ALL_SYMBOL_DATA : NO_CFI;
+  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;
+
+  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",
-              [options.srcPath fileSystemRepresentation], options.arch->name);
+              [primary_file fileSystemRepresentation], options.arch->name);
       size_t available_size;
       const struct fat_arch *available =
         dump_symbols.AvailableArchitectures(&available_size);
@@ -88,16 +146,48 @@ static bool Start(const Options &options) {
     }
   }
 
-  return dump_symbols.WriteSymbolFile(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))
+      return false;
+
+    Module* cfi_module = NULL;
+    if (!dump_symbols.ReadSymbolData(&cfi_module))
+      return false;
+    scoped_ptr<Module> scoped_cfi_module(cfi_module);
+
+    // Ensure that the modules are for the same debug code file.
+    if (cfi_module->name() != module->name() ||
+        cfi_module->os() != module->os() ||
+        cfi_module->architecture() != module->architecture() ||
+        cfi_module->identifier() != module->identifier()) {
+      fprintf(stderr, "Cannot generate a symbol file from split sources that do"
+                      " not match.\n");
+      return false;
+    }
+
+    CopyCFIDataBetweenModules(module, cfi_module);
+  }
+
+  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] <Mach-o file>\n",
+  fprintf(stderr, "Usage: %s [-a ARCHITECTURE] [-c] [-g dSYM path] "
-          argv[0]);
+                  "<Mach-o file>\n", argv[0]);
   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");
@@ -109,7 +199,7 @@ static void SetupOptions(int argc, const char *argv[], Options *options) {
   extern int optind;
   signed char ch;
 
-  while ((ch = getopt(argc, (char * const *)argv, "a:chr?")) != -1) {
+  while ((ch = getopt(argc, (char * const *)argv, "a:g:chr?")) != -1) {
     switch (ch) {
       case 'a': {
         const NXArchInfo *arch_info =
@@ -122,6 +212,10 @@ static void SetupOptions(int argc, const char *argv[], Options *options) {
         options->arch = arch_info;
         break;
       }
+      case 'g':
+        options->dsymPath = [[NSFileManager defaultManager]
+            stringWithFileSystemRepresentation:optarg length:strlen(optarg)];
+        break;
       case 'c':
         options->cfi = false;
         break;