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

It is often helpful to check if a particular symbol file dumped by
dump_syms actually matches a version of a binary file we have. The
symbol output contains an ID which can be used to see if it matches
the binary file. Unfortunately, this ID is internally calculated
and not a standard hash of the binary file. Being able to output the
header information only will allow users to determine whether their
symbol file is up to date or not.

R=jochen@chromium.org
BUG=561447

Review URL: https://codereview.chromium.org/1864823002 .

Patch from David Yen <dyen@chromium.org>.

4 files changed, 158 insertions, 72 deletions

diff --git a/src/common/linux/dump_symbols.cc b/src/common/linux/dump_symbols.cc
index d31e2c2d..0000add6 100644
--- a/src/common/linux/dump_symbols.cc
+++ b/src/common/linux/dump_symbols.cc
@@ -901,19 +901,12 @@ bool SanitizeDebugFile(const typename ElfClass::Ehdr* debug_elf_header,
 }
 
 template<typename ElfClass>
-bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
-                            const string& obj_filename,
-                            const std::vector<string>& debug_dirs,
-                            const DumpOptions& options,
-                            Module** out_module) {
-  typedef typename ElfClass::Ehdr Ehdr;
-
-  *out_module = NULL;
-
+bool InitModuleForElfClass(const typename ElfClass::Ehdr* elf_header,
+                           const string& obj_filename,
+                           scoped_ptr<Module>& module) {
   PageAllocator allocator;
   wasteful_vector<uint8_t> identifier(&allocator, kDefaultBuildIdSize);
-  if (!FileID::ElfFileIdentifierFromMappedFile(elf_header,
-                                               identifier)) {
+  if (!FileID::ElfFileIdentifierFromMappedFile(elf_header, identifier)) {
     fprintf(stderr, "%s: unable to generate file identifier\n",
             obj_filename.c_str());
     return false;
@@ -926,11 +919,6 @@ bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
     return false;
   }
 
-  // Figure out what endianness this file is.
-  bool big_endian;
-  if (!ElfEndianness<ElfClass>(elf_header, &big_endian))
-    return false;
-
   string name = BaseFileName(obj_filename);
   string os = "Linux";
   // Add an extra "0" at the end.  PDB files on Windows have an 'age'
@@ -938,8 +926,32 @@ bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
   // really used or necessary on other platforms, but be consistent.
   string id = FileID::ConvertIdentifierToUUIDString(identifier) + "0";
 
+  module.reset(new Module(name, os, architecture, id));
+
+  return true;
+}
+
+template<typename ElfClass>
+bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
+                            const string& obj_filename,
+                            const std::vector<string>& debug_dirs,
+                            const DumpOptions& options,
+                            Module** out_module) {
+  typedef typename ElfClass::Ehdr Ehdr;
+
+  *out_module = NULL;
+
+  scoped_ptr<Module> module;
+  if (!InitModuleForElfClass<ElfClass>(elf_header, obj_filename, module)) {
+    return false;
+  }
+
+  // Figure out what endianness this file is.
+  bool big_endian;
+  if (!ElfEndianness<ElfClass>(elf_header, &big_endian))
+    return false;
+
   LoadSymbolsInfo<ElfClass> info(debug_dirs);
-  scoped_ptr<Module> module(new Module(name, os, architecture, id));
   if (!LoadSymbols<ElfClass>(obj_filename, big_endian, elf_header,
                              !debug_dirs.empty(), &info,
                              options, module.get())) {
@@ -954,7 +966,9 @@ bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header,
     if (!LoadELF(debuglink_file, &debug_map_wrapper,
                  reinterpret_cast<void**>(&debug_elf_header)) ||
         !SanitizeDebugFile<ElfClass>(debug_elf_header, debuglink_file,
-                                     obj_filename, architecture, big_endian)) {
+                                     obj_filename,
+                                     module->architecture().c_str(),
+                                     big_endian)) {
       return false;
     }
 
@@ -1012,6 +1026,45 @@ bool WriteSymbolFile(const string &obj_file,
   return result;
 }
 
+// Read the selected object file's debugging information, and write out the
+// header only to |stream|. Return true on success; if an error occurs, report
+// it and return false.
+bool WriteSymbolFileHeader(const string& obj_file,
+                           std::ostream &sym_stream) {
+  MmapWrapper map_wrapper;
+  void* elf_header = NULL;
+  if (!LoadELF(obj_file, &map_wrapper, &elf_header)) {
+    fprintf(stderr, "Could not load ELF file: %s\n", obj_file.c_str());
+    return false;
+  }
+
+  if (!IsValidElf(elf_header)) {
+    fprintf(stderr, "Not a valid ELF file: %s\n", obj_file.c_str());
+    return false;
+  }
+
+  int elfclass = ElfClass(elf_header);
+  scoped_ptr<Module> module;
+  if (elfclass == ELFCLASS32) {
+    if (!InitModuleForElfClass<ElfClass32>(
+        reinterpret_cast<const Elf32_Ehdr*>(elf_header), obj_file, module)) {
+      fprintf(stderr, "Failed to load ELF module: %s\n", obj_file.c_str());
+      return false;
+    }
+  } else if (elfclass == ELFCLASS64) {
+    if (!InitModuleForElfClass<ElfClass64>(
+        reinterpret_cast<const Elf64_Ehdr*>(elf_header), obj_file, module)) {
+      fprintf(stderr, "Failed to load ELF module: %s\n", obj_file.c_str());
+      return false;
+    }
+  } else {
+    fprintf(stderr, "Unsupported module file: %s\n", obj_file.c_str());
+    return false;
+  }
+
+  return module->Write(sym_stream, ALL_SYMBOL_DATA);
+}
+
 bool ReadSymbolData(const string& obj_file,
                     const std::vector<string>& debug_dirs,
                     const DumpOptions& options,
diff --git a/src/common/linux/dump_symbols.h b/src/common/linux/dump_symbols.h
index 636bb72f..1f204cba 100644
--- a/src/common/linux/dump_symbols.h
+++ b/src/common/linux/dump_symbols.h
@@ -67,6 +67,12 @@ bool WriteSymbolFile(const string &obj_file,
                      const DumpOptions& options,
                      std::ostream &sym_stream);
 
+// Read the selected object file's debugging information, and write out the
+// header only to |stream|. Return true on success; if an error occurs, report
+// it and return false.
+bool WriteSymbolFileHeader(const string& obj_file,
+                           std::ostream &sym_stream);
+
 // As above, but simply return the debugging information in MODULE
 // instead of writing it to a stream. The caller owns the resulting
 // Module object and must delete it when finished.
diff --git a/src/common/mac/dump_syms.cc b/src/common/mac/dump_syms.cc
index b86a7c26..97c3e06e 100644
--- a/src/common/mac/dump_syms.cc
+++ b/src/common/mac/dump_syms.cc
@@ -328,6 +328,65 @@ class DumpSymbols::DumperLineToModule:
   dwarf2reader::ByteReader *byte_reader_;  // WEAK
 };
 
+bool DumpSymbols::CreateEmptyModule(scoped_ptr<Module>& module) {
+  // Select an object file, if SetArchitecture hasn't been called to set one
+  // explicitly.
+  if (!selected_object_file_) {
+    // If there's only one architecture, that's the one.
+    if (object_files_.size() == 1)
+      selected_object_file_ = &object_files_[0];
+    else {
+      // Look for an object file whose architecture matches our own.
+      const NXArchInfo *local_arch = NXGetLocalArchInfo();
+      if (!SetArchitecture(local_arch->cputype, local_arch->cpusubtype)) {
+        fprintf(stderr, "%s: object file contains more than one"
+                " architecture, none of which match the current"
+                " architecture; specify an architecture explicitly"
+                " with '-a ARCH' to resolve the ambiguity\n",
+                object_filename_.c_str());
+        return false;
+      }
+    }
+  }
+
+  assert(selected_object_file_);
+
+  // Find the name of the selected file's architecture, to appear in
+  // the MODULE record and in error messages.
+  const NXArchInfo *selected_arch_info =
+      google_breakpad::BreakpadGetArchInfoFromCpuType(
+          selected_object_file_->cputype, selected_object_file_->cpusubtype);
+
+  const char *selected_arch_name = selected_arch_info->name;
+  if (strcmp(selected_arch_name, "i386") == 0)
+    selected_arch_name = "x86";
+
+  // Produce a name to use in error messages that includes the
+  // filename, and the architecture, if there is more than one.
+  selected_object_name_ = object_filename_;
+  if (object_files_.size() > 1) {
+    selected_object_name_ += ", architecture ";
+    selected_object_name_ + selected_arch_name;
+  }
+
+  // Compute a module name, to appear in the MODULE record.
+  string module_name = object_filename_;
+  module_name = basename(&module_name[0]);
+
+  // Choose an identifier string, to appear in the MODULE record.
+  string identifier = Identifier();
+  if (identifier.empty())
+    return false;
+  identifier += "0";
+
+  // Create a module to hold the debugging information.
+  module.reset(new Module(module_name,
+                          "mac",
+                          selected_arch_name,
+                          identifier));
+  return true;
+}
+
 bool DumpSymbols::ReadDwarf(google_breakpad::Module *module,
                             const mach_o::Reader &macho_reader,
                             const mach_o::SectionMap &dwarf_sections,
@@ -535,61 +594,9 @@ bool DumpSymbols::LoadCommandDumper::SymtabCommand(const ByteBuffer &entries,
 }
 
 bool DumpSymbols::ReadSymbolData(Module** out_module) {
-  // Select an object file, if SetArchitecture hasn't been called to set one
-  // explicitly.
-  if (!selected_object_file_) {
-    // If there's only one architecture, that's the one.
-    if (object_files_.size() == 1)
-      selected_object_file_ = &object_files_[0];
-    else {
-      // Look for an object file whose architecture matches our own.
-      const NXArchInfo *local_arch = NXGetLocalArchInfo();
-      if (!SetArchitecture(local_arch->cputype, local_arch->cpusubtype)) {
-        fprintf(stderr, "%s: object file contains more than one"
-                " architecture, none of which match the current"
-                " architecture; specify an architecture explicitly"
-                " with '-a ARCH' to resolve the ambiguity\n",
-                object_filename_.c_str());
-        return false;
-      }
-    }
-  }
-
-  assert(selected_object_file_);
-
-  // Find the name of the selected file's architecture, to appear in
-  // the MODULE record and in error messages.
-  const NXArchInfo *selected_arch_info =
-      google_breakpad::BreakpadGetArchInfoFromCpuType(
-          selected_object_file_->cputype, selected_object_file_->cpusubtype);
-
-  const char *selected_arch_name = selected_arch_info->name;
-  if (strcmp(selected_arch_name, "i386") == 0)
-    selected_arch_name = "x86";
-
-  // Produce a name to use in error messages that includes the
-  // filename, and the architecture, if there is more than one.
-  selected_object_name_ = object_filename_;
-  if (object_files_.size() > 1) {
-    selected_object_name_ += ", architecture ";
-    selected_object_name_ + selected_arch_name;
-  }
-
-  // Compute a module name, to appear in the MODULE record.
-  string module_name = object_filename_;
-  module_name = basename(&module_name[0]);
-
-  // Choose an identifier string, to appear in the MODULE record.
-  string identifier = Identifier();
-  if (identifier.empty())
+  scoped_ptr<Module> module;
+  if (!CreateEmptyModule(module))
     return false;
-  identifier += "0";
-
-  // Create a module to hold the debugging information.
-  scoped_ptr<Module> module(new Module(module_name,
-                                       "mac",
-                                       selected_arch_name,
-                                       identifier));
 
   // Parse the selected object file.
   mach_o::Reader::Reporter reporter(selected_object_name_);
@@ -624,4 +631,15 @@ bool DumpSymbols::WriteSymbolFile(std::ostream &stream) {
   return false;
 }
 
+// Read the selected object file's debugging information, and write out the
+// header only to |stream|. Return true on success; if an error occurs, report
+// it and return false.
+bool DumpSymbols::WriteSymbolFileHeader(std::ostream &stream) {
+  scoped_ptr<Module> module;
+  if (!CreateEmptyModule(module))
+    return false;
+
+  return module->Write(stream, symbol_data_);
+}
+
 }  // namespace google_breakpad
diff --git a/src/common/mac/dump_syms.h b/src/common/mac/dump_syms.h
index b09928c9..9463f7dc 100644
--- a/src/common/mac/dump_syms.h
+++ b/src/common/mac/dump_syms.h
@@ -112,6 +112,11 @@ class DumpSymbols {
   // return false.
   bool WriteSymbolFile(std::ostream &stream);
 
+  // Read the selected object file's debugging information, and write out the
+  // header only to |stream|. Return true on success; if an error occurs, report
+  // it and return false.
+  bool WriteSymbolFileHeader(std::ostream &stream);
+
   // As above, but simply return the debugging information in module
   // instead of writing it to a stream. The caller owns the resulting
   // module object and must delete it when finished.
@@ -130,6 +135,10 @@ class DumpSymbols {
   // Return an identifier string for the file this DumpSymbols is dumping.
   std::string Identifier();
 
+
+  // Creates an empty module object.
+  bool CreateEmptyModule(scoped_ptr<Module>& module);
+
   // Read debugging information from |dwarf_sections|, which was taken from
   // |macho_reader|, and add it to |module|. On success, return true;
   // on failure, report the problem and return false.