Added a switch to dump minidump modules in minidump_stackwalk.

src/processor/minidump_stackwalk.cc

 // Copyright (c) 2010 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
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 53 matching lines @@
 // is specified, it is made available for use by the MinidumpProcessor.
 //
 // Returns the value of MinidumpProcessor::Process.  If processing succeeds,
 // prints identifying OS and CPU information from the minidump, crash
 // information if the minidump was produced as a result of a crash, and
 // call stacks for each thread contained in the minidump.  All information
 // is printed to stdout.
 bool PrintMinidumpProcess(const string &minidump_file,
                           const std::vector<string> &symbol_paths,
                           bool machine_readable,
-                          bool output_stack_contents) {
+                          bool output_stack_contents,
+                          bool output_modules_only) {
   scoped_ptr<SimpleSymbolSupplier> symbol_supplier;
   if (!symbol_paths.empty()) {
     // TODO(mmentovai): check existence of symbol_path if specified?
     symbol_supplier.reset(new SimpleSymbolSupplier(symbol_paths));
   }
 
   BasicSourceLineResolver resolver;
   MinidumpProcessor minidump_processor(symbol_supplier.get(), &resolver);
 
   // Process the minidump.
   Minidump dump(minidump_file);
   if (!dump.Read()) {
      BPLOG(ERROR) << "Minidump " << dump.path() << " could not be read";
      return false;
   }
   ProcessState process_state;
   if (minidump_processor.Process(&dump, &process_state) !=
       google_breakpad::PROCESS_OK) {
     BPLOG(ERROR) << "MinidumpProcessor::Process failed";
     return false;
   }
 
-  if (machine_readable) {
+  if (output_modules_only) {
+    PrintProcessModules(process_state);
+  } else if (machine_readable) {
     PrintProcessStateMachineReadable(process_state);
   } else {
     PrintProcessState(process_state, output_stack_contents, &resolver);
   }
 
   return true;
 }
 
 void usage(const char *program_name) {
-  fprintf(stderr, "usage: %s [-m|-s] <minidump-file> [symbol-path ...]\n"
+  fprintf(stderr, "usage: %s [-m|-s|-b] <minidump-file> [symbol-path ...]\n"
           "    -m : Output in machine-readable format\n"
-          "    -s : Output stack contents\n",
+          "    -s : Output stack contents\n"
+          "    -b : Output contained full module paths\n",
           program_name);
 }
 
 }  // namespace
 
 int main(int argc, char **argv) {
   BPLOG_INIT(&argc, &argv);
 
   if (argc < 2) {
     usage(argv[0]);
     return 1;
   }
 
   const char *minidump_file;
   bool machine_readable = false;
   bool output_stack_contents = false;
+  bool output_modules_only = false;
   int symbol_path_arg;
 
   if (strcmp(argv[1], "-m") == 0) {
     if (argc < 3) {
       usage(argv[0]);
       return 1;
     }
 
     machine_readable = true;
     minidump_file = argv[2];
     symbol_path_arg = 3;
   } else if (strcmp(argv[1], "-s") == 0) {
     if (argc < 3) {
       usage(argv[0]);
       return 1;
     }
 
     output_stack_contents = true;
     minidump_file = argv[2];
     symbol_path_arg = 3;
+  } else if (strcmp(argv[1], "-b") == 0) {
+    if (argc < 3) {
+      usage(argv[0]);
+      return 1;
+    }
+
+    output_modules_only = true;
+    minidump_file = argv[2];
+    symbol_path_arg = 3;
   } else {
     minidump_file = argv[1];
     symbol_path_arg = 2;
   }
 
   // extra arguments are symbol paths
   std::vector<string> symbol_paths;
   if (argc > symbol_path_arg) {
     for (int argi = symbol_path_arg; argi < argc; ++argi)
       symbol_paths.push_back(argv[argi]);
   }
 
   return PrintMinidumpProcess(minidump_file,
                               symbol_paths,
                               machine_readable,
-                              output_stack_contents) ? 0 : 1;
+                              output_stack_contents,
+                              output_modules_only) ? 0 : 1;
 }