Keeping track of modules without symbols during crash report processing

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 315 matching lines @@
              kOutputSeparator,  // empty function name
              kOutputSeparator,  // empty source file
              kOutputSeparator,  // empty source line
              kOutputSeparator,
              instruction_address);
     }
     printf("\n");
   }
 }
 
-static void PrintModules(const CodeModules *modules) {
+// IsModuleMissingSymbols checks whether a given |module| is in
+// |modules_without_symbols|.
+static bool IsModuleMissingSymbols(
+    const CodeModule *module,
+    const vector<const CodeModule*> *modules_without_symbols) {
+  assert(module);
+  assert(modules_without_symbols);
+  if (module->debug_file().empty() || module->debug_identifier().empty()) {
+    // Not enough information to identify the module
+    return false;
+  }
+  vector<const CodeModule*>::const_iterator iter;
+  for (iter = modules_without_symbols->begin();
+       iter != modules_without_symbols->end();
+       ++iter) {
+    if (module->debug_file().compare((*iter)->debug_file()) == 0 &&
+        module->debug_identifier().compare((*iter)->debug_identifier()) == 0) {
+      // Stackwalker reported that this module is missing symbols
+      return true;
+    }
+  }
+  // Either symbols for this module were present or they were not required at
+  // all.
+  return false;
+}
+
+// PrintModule prints a single |module| to stdout.
+// |modules_without_symbols| should contain the list of modules that were
+// confrimed to be missing their symbols during the stack walk.

[Jess, 2013/03/05 01:39:43]

confrimed -> confirmed 

[Ivan Penkov, 2013/03/05 02:29:23]

Done.

+static void PrintModule(
+    const CodeModule *module,
+    const vector<const CodeModule*> *modules,
+    u_int64_t main_address) {
+  string missing_symbols;
+  if (IsModuleMissingSymbols(module, modules)) {
+    missing_symbols = "(WARNING: No symbols, " +
+        PathnameStripper::File(module->debug_file()) + ", " +
+        module->debug_identifier() + ")";
+  }
+  u_int64_t base_address = module->base_address();
+  printf("0x%08" PRIx64 " - 0x%08" PRIx64 "  %s  %s%s  %s\n",
+         base_address, base_address + module->size() - 1,
+         PathnameStripper::File(module->code_file()).c_str(),
+         module->version().empty() ? "???" : module->version().c_str(),
+         main_address != 0 && base_address == main_address ? "  (main)" : "",
+         missing_symbols.c_str());
+}
+
+// PrintModules prints the list of all loaded |modules| to stdout.
+// |modules_without_symbols| should contain the list of modules that were
+// confrimed to be missing their symbols during the stack walk.

[Jess, 2013/03/05 01:39:43]

Ditto

[Ivan Penkov, 2013/03/05 02:29:23]

Done.

+static void PrintModules(
+    const CodeModules *modules,
+    const vector<const CodeModule*> *modules_without_symbols) {
   if (!modules)
     return;
 
   printf("\n");
   printf("Loaded modules:\n");
 
   u_int64_t main_address = 0;
   const CodeModule *main_module = modules->GetMainModule();
   if (main_module) {
     main_address = main_module->base_address();
   }
 
   unsigned int module_count = modules->module_count();
   for (unsigned int module_sequence = 0;
        module_sequence < module_count;
        ++module_sequence) {
     const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
-    u_int64_t base_address = module->base_address();
-    printf("0x%08" PRIx64 " - 0x%08" PRIx64 "  %s  %s%s\n",
-           base_address, base_address + module->size() - 1,
-           PathnameStripper::File(module->code_file()).c_str(),
-           module->version().empty() ? "???" : module->version().c_str(),
-           main_module != NULL && base_address == main_address ?
-               "  (main)" : "");
+    PrintModule(module, modules_without_symbols, main_address);
   }
 }
 
 // PrintModulesMachineReadable outputs a list of loaded modules,
 // one per line, in the following machine-readable pipe-delimited
 // text format:
 // Module|{Module Filename}|{Version}|{Debug Filename}|{Debug Identifier}|
 // {Base Address}|{Max Address}|{Main}
 static void PrintModulesMachineReadable(const CodeModules *modules) {
   if (!modules)
@@ skipping 71 matching lines @@
   int thread_count = process_state.threads()->size();
   for (int thread_index = 0; thread_index < thread_count; ++thread_index) {
     if (thread_index != requesting_thread) {
       // Don't print the crash thread again, it was already printed.
       printf("\n");
       printf("Thread %d\n", thread_index);
       PrintStack(process_state.threads()->at(thread_index), cpu);
     }
   }
 
-  PrintModules(process_state.modules());
+  PrintModules(process_state.modules(),
+               process_state.modules_without_symbols());
 }
 
 static void PrintProcessStateMachineReadable(const ProcessState& process_state)
 {
   // Print OS and CPU information.
   // OS|{OS Name}|{OS Version}
   // CPU|{CPU Name}|{CPU Info}|{Number of CPUs}
   printf("OS%c%s%c%s\n", kOutputSeparator,
          StripSeparator(process_state.system_info()->os).c_str(),
          kOutputSeparator,
@@ skipping 133 matching lines @@
   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) ? 0 : 1;
 }