Change MDCVInfoELF into something usable.

src/processor/minidump.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 1835 matching lines @@
     case MD_OS_WIN32_WINDOWS: {
       // Use the same format that the MS symbol server uses in filesystem
       // hierarchies.
       char identifier_string[17];
       snprintf(identifier_string, sizeof(identifier_string), "%08X%x",
                module_.time_date_stamp, module_.size_of_image);
       identifier = identifier_string;
       break;
     }
 
+    case MD_OS_ANDROID:
+    case MD_OS_LINUX: {
+      // If ELF CodeView data is present, return the debug id.
+      if (cv_record_ && cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+        const MDCVInfoELF* cv_record_elf =
+            reinterpret_cast<const MDCVInfoELF*>(&(*cv_record_)[0]);
+        assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+        for (unsigned int build_id_index = 0;
+             build_id_index < (cv_record_->size() - MDCVInfoELF_minsize);
+             ++build_id_index) {
+          char byte[3];

[Mark Mentovai, 2016/02/09 19:27:05]

build_id[build_id_index] is the byte, this is a string with the byte’s value. Is
there a better name?

+          snprintf(byte, sizeof(byte), "%02x",
+                   cv_record_elf->build_id[build_id_index]);
+          identifier += byte;
+        }
+        break;
+      }
+      // Otherwise fall through to the case below.
+    }
+
     case MD_OS_MAC_OS_X:
     case MD_OS_IOS:
     case MD_OS_SOLARIS:
-    case MD_OS_ANDROID:
-    case MD_OS_LINUX:
     case MD_OS_NACL:
     case MD_OS_PS3: {
       // TODO(mmentovai): support uuid extension if present, otherwise fall
       // back to version (from LC_ID_DYLIB?), otherwise fall back to something
       // else.
       identifier = "id";
       break;
     }
 
     default: {
@@ skipping 30 matching lines @@
       // GetCVRecord guarantees pdb_file_name is null-terminated.
       file = reinterpret_cast<const char*>(cv_record_70->pdb_file_name);
     } else if (cv_record_signature_ == MD_CVINFOPDB20_SIGNATURE) {
       // It's actually an MDCVInfoPDB20 structure.
       const MDCVInfoPDB20* cv_record_20 =
           reinterpret_cast<const MDCVInfoPDB20*>(&(*cv_record_)[0]);
       assert(cv_record_20->cv_header.signature == MD_CVINFOPDB20_SIGNATURE);
 
       // GetCVRecord guarantees pdb_file_name is null-terminated.
       file = reinterpret_cast<const char*>(cv_record_20->pdb_file_name);
+    } else if (cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+      // It's actually an MDCVInfoELF structure.
+      const MDCVInfoELF* cv_record_elf =
+          reinterpret_cast<const MDCVInfoELF*>(&(*cv_record_)[0]);
+      assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+      // For MDCVInfoELF, the debug file is the code file.
+      file = *name_;
     }
 
     // If there's a CodeView record but it doesn't match a known signature,
     // try the miscellaneous record.
   }
 
   if (file.empty()) {
     // No usable CodeView record.  Try the miscellaneous debug record.
     if (misc_record_) {
       const MDImageDebugMisc* misc_record =
@@ skipping 31 matching lines @@
     }
   }
 
   // Relatively common case
   BPLOG_IF(INFO, file.empty()) << "MinidumpModule could not determine "
                                   "debug_file for " << *name_;
 
   return file;
 }
 
+static string guid_and_age_to_debug_id(const MDGUID& guid,
+                                       uint32_t age) {
+  char identifier_string[41];
+  snprintf(identifier_string, sizeof(identifier_string),
+           "%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X%x",
+           guid.data1,
+           guid.data2,
+           guid.data3,
+           guid.data4[0],
+           guid.data4[1],
+           guid.data4[2],
+           guid.data4[3],
+           guid.data4[4],
+           guid.data4[5],
+           guid.data4[6],
+           guid.data4[7],
+           age);
+  return identifier_string;
+}
 
 string MinidumpModule::debug_identifier() const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpModule for debug_identifier";
     return "";
   }
 
   if (!has_debug_info_)
     return "";
 
   string identifier;
 
   // Use the CodeView record if present.
   if (cv_record_) {
     if (cv_record_signature_ == MD_CVINFOPDB70_SIGNATURE) {
       // It's actually an MDCVInfoPDB70 structure.
       const MDCVInfoPDB70* cv_record_70 =
           reinterpret_cast<const MDCVInfoPDB70*>(&(*cv_record_)[0]);
       assert(cv_record_70->cv_signature == MD_CVINFOPDB70_SIGNATURE);
 
       // Use the same format that the MS symbol server uses in filesystem
       // hierarchies.
-      char identifier_string[41];
-      snprintf(identifier_string, sizeof(identifier_string),
-               "%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X%x",
-               cv_record_70->signature.data1,
-               cv_record_70->signature.data2,
-               cv_record_70->signature.data3,
-               cv_record_70->signature.data4[0],
-               cv_record_70->signature.data4[1],
-               cv_record_70->signature.data4[2],
-               cv_record_70->signature.data4[3],
-               cv_record_70->signature.data4[4],
-               cv_record_70->signature.data4[5],
-               cv_record_70->signature.data4[6],
-               cv_record_70->signature.data4[7],
-               cv_record_70->age);
-      identifier = identifier_string;
+      identifier = guid_and_age_to_debug_id(cv_record_70->signature,
+                                            cv_record_70->age);
     } else if (cv_record_signature_ == MD_CVINFOPDB20_SIGNATURE) {
       // It's actually an MDCVInfoPDB20 structure.
       const MDCVInfoPDB20* cv_record_20 =
           reinterpret_cast<const MDCVInfoPDB20*>(&(*cv_record_)[0]);
       assert(cv_record_20->cv_header.signature == MD_CVINFOPDB20_SIGNATURE);
 
       // Use the same format that the MS symbol server uses in filesystem
       // hierarchies.
       char identifier_string[17];
       snprintf(identifier_string, sizeof(identifier_string),
                "%08X%x", cv_record_20->signature, cv_record_20->age);
       identifier = identifier_string;
+    } else if (cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+      // It's actually an MDCVInfoELF structure.
+      const MDCVInfoELF* cv_record_elf =
+          reinterpret_cast<const MDCVInfoELF*>(&(*cv_record_)[0]);
+      assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+      // For backwards-compatibility, stuff as many bytes as will fit into
+      // a MDGUID and use the MS symbol server format as MDCVInfoPDB70 does
+      // with age = 0. Historically Breakpad would do this during dump
+      // writing to fit the build id data into a MDCVInfoPDB70 struct.
+      // The full build id is available by calling code_identifier.
+      MDGUID guid = {0};
+      memcpy(&guid, &cv_record_elf->build_id,
+             cv_record_->size() - MDCVInfoELF_minsize);
+      identifier = guid_and_age_to_debug_id(guid, 0);
     }
   }
 
   // TODO(mmentovai): if there's no usable CodeView record, there might be a
   // miscellaneous debug record.  It only carries a filename, though, and no
   // identifier.  I'm not sure what the right thing to do for the identifier
   // is in that case, but I don't expect to find many modules without a
   // CodeView record (or some other Breakpad extension structure in place of
   // a CodeView record).  Treat it as an error (empty identifier) for now.
 
@@ skipping 138 matching lines @@
         // quantities.  (It's a path, is it UTF-8?)
       }
 
       // The last field of either structure is null-terminated 8-bit character
       // data.  Ensure that it's null-terminated.
       if ((*cv_record)[module_.cv_record.data_size - 1] != '\0') {
         BPLOG(ERROR) << "MindumpModule CodeView2 record string is not "
                         "0-terminated";
         return NULL;
       }
+    } else if (signature == MD_CVINFOELF_SIGNATURE) {
+      // Now that the structure type is known, recheck the size.
+      if (MDCVInfoELF_minsize > module_.cv_record.data_size) {
+        BPLOG(ERROR) << "MinidumpModule CodeViewELF record size mismatch, " <<
+                        MDCVInfoELF_minsize << " > " <<
+                        module_.cv_record.data_size;
+        return NULL;
+      }
+      // There's nothing to swap in CVInfoELF, it's just raw bytes.
     }
 
     // If the signature doesn't match something above, it's not something
     // that Breakpad can presently handle directly.  Because some modules in
     // the wild contain such CodeView records as MD_CVINFOCV50_SIGNATURE,
     // don't bail out here - allow the data to be returned to the user,
     // although byte-swapping can't be done.
 
     // Store the vector type because that's how storage was allocated, but
     // return it casted to uint8_t*.
@@ skipping 180 matching lines @@
              cv_record_20->cv_header.signature);
       printf("  (cv_record).cv_header.offset    = 0x%x\n",
              cv_record_20->cv_header.offset);
       printf("  (cv_record).signature           = 0x%x %s\n",
              cv_record_20->signature,
              TimeTToUTCString(cv_record_20->signature).c_str());
       printf("  (cv_record).age                 = %d\n",
              cv_record_20->age);
       printf("  (cv_record).pdb_file_name       = \"%s\"\n",
              cv_record_20->pdb_file_name);
+    } else if (cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+      const MDCVInfoELF* cv_record_elf =
+          reinterpret_cast<const MDCVInfoELF*>(cv_record);
+      assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+      printf("  (cv_record).cv_signature        = 0x%x\n",
+             cv_record_elf->cv_signature);
+      printf("  (cv_record).build_id            = ");
+      for (unsigned int build_id_index = 0;
+           build_id_index < (cv_record_size - MDCVInfoELF_minsize);
+           ++build_id_index) {
+        printf("%02x", cv_record_elf->build_id[build_id_index]);
+      }
+      printf("\n");
     } else {
       printf("  (cv_record)                     = ");
       for (unsigned int cv_byte_index = 0;
            cv_byte_index < cv_record_size;
            ++cv_byte_index) {
         printf("%02x", cv_record[cv_byte_index]);
       }
       printf("\n");
     }
   } else {
@@ skipping 2406 matching lines @@
     return NULL;
   }
 
   *stream = new_stream.release();
   info->stream = *stream;
   return *stream;
 }
 
 
 }  // namespace google_breakpad