[vm] Attempt to retrieve build ID or UUID from the loaded snapshot.

For direct-to-ELF snapshots, the story remains the same as before,
as we use the information from the Image header if available.

If it isn't, then we fall back to dladdr to get the dynamic shared
object containing the app snapshot and then walk the ELF or Mach-O
headers to find the build ID or UUID information.

TEST=vm/dart/use_dwarf_stack_traces_flag

Issue: #51941
Change-Id: I3705ed244d1b4a1255e75fffd238a29fc2a60800
Cq-Include-Trybots: luci.dart.try:vm-aot-dwarf-linux-product-x64-try,vm-aot-linux-debug-simarm_x64-try,vm-aot-linux-debug-x64-try,vm-aot-linux-release-x64-try,vm-aot-mac-product-arm64-try,vm-aot-mac-release-arm64-try,vm-aot-mac-release-x64-try,vm-aot-linux-product-x64-try,vm-aot-win-release-x64-try,vm-aot-win-product-x64-try,vm-aot-win-debug-x64c-try,vm-aot-android-release-arm_x64-try,vm-aot-android-release-arm64c-try,vm-fuchsia-release-x64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/306640
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Tess Strickland <[email protected]>

Author: sstrickl

runtime/tests/vm/dart/use_dwarf_stack_traces_flag_test.dart

@@ -268,6 +268,15 @@ Future<void> compareTraces(List<String> nonDwarfTrace, DwarfTestOutput output1,
     Expect.isFalse(buildId2.isEmpty);
     print('Trace 2 build ID: "${buildId2}"');
     Expect.equals(dwarfBuildId, buildId2);
+  } else {
+    // Just check that the build IDs exist in the traces and are the same.
+    final buildId1 = buildId(output1.trace);
+    Expect.isFalse(buildId1.isEmpty, 'Could not find build ID in first trace');
+    print('Trace 1 build ID: "${buildId1}"');
+    final buildId2 = buildId(output2.trace);
+    Expect.isFalse(buildId2.isEmpty, 'Could not find build ID in second trace');
+    print('Trace 2 build ID: "${buildId2}"');
+    Expect.equals(buildId1, buildId2);
   }
 
   final decoder = DwarfStackTraceDecoder(dwarf!);

runtime/tests/vm/dart_2/use_dwarf_stack_traces_flag_test.dart

@@ -270,6 +270,15 @@ Future<void> compareTraces(List<String> nonDwarfTrace, DwarfTestOutput output1,
     Expect.isFalse(buildId2.isEmpty);
     print('Trace 2 build ID: "${buildId2}"');
     Expect.equals(dwarfBuildId, buildId2);
+  } else {
+    // Just check that the build IDs exist in the traces and are the same.
+    final buildId1 = buildId(output1.trace);
+    Expect.isFalse(buildId1.isEmpty, 'Could not find build ID in first trace');
+    print('Trace 1 build ID: "${buildId1}"');
+    final buildId2 = buildId(output2.trace);
+    Expect.isFalse(buildId2.isEmpty, 'Could not find build ID in second trace');
+    print('Trace 2 build ID: "${buildId2}"');
+    Expect.equals(buildId1, buildId2);
   }
 
   final decoder = DwarfStackTraceDecoder(dwarf);

runtime/vm/object.cc

@@ -52,6 +52,7 @@
 #include "vm/native_symbol.h"
 #include "vm/object_graph.h"
 #include "vm/object_store.h"
+#include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/profiler.h"
 #include "vm/regexp.h"
@@ -26615,11 +26616,13 @@ const char* StackTrace::ToCString() const {
     buffer.Printf("os: %s arch: %s comp: %s sim: %s\n",
                   kHostOperatingSystemName, kTargetArchitectureName,
                   kCompressedPointers, kUsingSimulator);
-    if (auto const build_id = isolate_instructions_image.build_id()) {
-      const intptr_t length = isolate_instructions_image.build_id_length();
+    const OS::BuildId& build_id =
+        OS::GetAppBuildId(T->isolate_group()->source()->snapshot_instructions);
+    if (build_id.data != nullptr) {
+      ASSERT(build_id.len > 0);
       buffer.Printf("build_id: '");
-      for (intptr_t i = 0; i < length; i++) {
-        buffer.Printf("%2.2x", build_id[i]);
+      for (intptr_t i = 0; i < build_id.len; i++) {
+        buffer.Printf("%2.2x", build_id.data[i]);
       }
       buffer.Printf("'\n");
     }

runtime/vm/os.h

@@ -119,6 +119,16 @@ class OS {
   DART_NORETURN static void Abort();
 
   DART_NORETURN static void Exit(int code);
+
+  struct BuildId {
+    intptr_t len;
+    const uint8_t* data;
+  };
+
+  // Retrieves the build ID information for the current application isolate.
+  // If found, returns a BuildId with the length of the build ID and a pointer
+  // to its contents, otherwise returns a BuildId with contents {0, nullptr}.
+  static BuildId GetAppBuildId(const uint8_t* snapshot_instructions);
 };
 
 }  // namespace dart

runtime/vm/os_android.cc

@@ -8,6 +8,8 @@
 #include "vm/os.h"
 
 #include <android/log.h>   // NOLINT
+#include <dlfcn.h>         // NOLINT
+#include <elf.h>           // NOLINT
 #include <errno.h>         // NOLINT
 #include <limits.h>        // NOLINT
 #include <malloc.h>        // NOLINT
@@ -20,6 +22,7 @@
 #include "platform/utils.h"
 #include "vm/code_observers.h"
 #include "vm/dart.h"
+#include "vm/image_snapshot.h"
 #include "vm/isolate.h"
 #include "vm/timeline.h"
 #include "vm/zone.h"
@@ -342,6 +345,50 @@ void OS::Exit(int code) {
   exit(code);
 }
 
+// Used to choose between Elf32/Elf64 types based on host archotecture bitsize.
+#if defined(ARCH_IS_64_BIT)
+#define ElfW(Type) Elf64_##Type
+#else
+#define ElfW(Type) Elf32_##Type
+#endif
+
+OS::BuildId OS::GetAppBuildId(const uint8_t* snapshot_instructions) {
+  // First return the build ID information from the instructions image if
+  // available.
+  const Image instructions_image(snapshot_instructions);
+  if (auto* const image_build_id = instructions_image.build_id()) {
+    return {instructions_image.build_id_length(), image_build_id};
+  }
+  Dl_info snapshot_info;
+  if (dladdr(snapshot_instructions, &snapshot_info) == 0) {
+    return {0, nullptr};
+  }
+  const uint8_t* dso_base =
+      static_cast<const uint8_t*>(snapshot_info.dli_fbase);
+  const ElfW(Ehdr)& elf_header = *reinterpret_cast<const ElfW(Ehdr)*>(dso_base);
+  const ElfW(Phdr)* const phdr_array =
+      reinterpret_cast<const ElfW(Phdr)*>(dso_base + elf_header.e_phoff);
+  for (intptr_t i = 0; i < elf_header.e_phnum; i++) {
+    const ElfW(Phdr)& header = phdr_array[i];
+    if (header.p_type != PT_NOTE) continue;
+    if ((header.p_flags & PF_R) != PF_R) continue;
+    const uint8_t* const note_addr = dso_base + header.p_vaddr;
+    const Elf32_Nhdr& note_header =
+        *reinterpret_cast<const Elf32_Nhdr*>(note_addr);
+    if (note_header.n_type != NT_GNU_BUILD_ID) continue;
+    const char* const note_contents =
+        reinterpret_cast<const char*>(note_addr + sizeof(Elf32_Nhdr));
+    // The note name contains the null terminator as well.
+    if (note_header.n_namesz != strlen(ELF_NOTE_GNU) + 1) continue;
+    if (strncmp(ELF_NOTE_GNU, note_contents, note_header.n_namesz) == 0) {
+      return {static_cast<intptr_t>(note_header.n_descsz),
+              reinterpret_cast<const uint8_t*>(note_contents +
+                                               note_header.n_namesz)};
+    }
+  }
+  return {0, nullptr};
+}
+
 }  // namespace dart
 
 #endif  // defined(DART_HOST_OS_ANDROID)

runtime/vm/os_fuchsia.cc

@@ -7,6 +7,8 @@
 
 #include "vm/os.h"
 
+#include <dlfcn.h>
+#include <elf.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdint.h>
@@ -37,6 +39,7 @@
 #include "platform/assert.h"
 #include "platform/syslog.h"
 #include "platform/utils.h"
+#include "vm/image_snapshot.h"
 #include "vm/lockers.h"
 #include "vm/os_thread.h"
 #include "vm/zone.h"
@@ -622,6 +625,50 @@ void OS::Exit(int code) {
   exit(code);
 }
 
+// Used to choose between Elf32/Elf64 types based on host archotecture bitsize.
+#if defined(ARCH_IS_64_BIT)
+#define ElfW(Type) Elf64_##Type
+#else
+#define ElfW(Type) Elf32_##Type
+#endif
+
+OS::BuildId OS::GetAppBuildId(const uint8_t* snapshot_instructions) {
+  // First return the build ID information from the instructions image if
+  // available.
+  const Image instructions_image(snapshot_instructions);
+  if (auto* const image_build_id = instructions_image.build_id()) {
+    return {instructions_image.build_id_length(), image_build_id};
+  }
+  Dl_info snapshot_info;
+  if (dladdr(snapshot_instructions, &snapshot_info) == 0) {
+    return {0, nullptr};
+  }
+  const uint8_t* dso_base =
+      static_cast<const uint8_t*>(snapshot_info.dli_fbase);
+  const ElfW(Ehdr)& elf_header = *reinterpret_cast<const ElfW(Ehdr)*>(dso_base);
+  const ElfW(Phdr)* const phdr_array =
+      reinterpret_cast<const ElfW(Phdr)*>(dso_base + elf_header.e_phoff);
+  for (intptr_t i = 0; i < elf_header.e_phnum; i++) {
+    const ElfW(Phdr)& header = phdr_array[i];
+    if (header.p_type != PT_NOTE) continue;
+    if ((header.p_flags & PF_R) != PF_R) continue;
+    const uint8_t* const note_addr = dso_base + header.p_vaddr;
+    const Elf32_Nhdr& note_header =
+        *reinterpret_cast<const Elf32_Nhdr*>(note_addr);
+    if (note_header.n_type != NT_GNU_BUILD_ID) continue;
+    const char* const note_contents =
+        reinterpret_cast<const char*>(note_addr + sizeof(Elf32_Nhdr));
+    // The note name contains the null terminator as well.
+    if (note_header.n_namesz != strlen(ELF_NOTE_GNU) + 1) continue;
+    if (strncmp(ELF_NOTE_GNU, note_contents, note_header.n_namesz) == 0) {
+      return {static_cast<intptr_t>(note_header.n_descsz),
+              reinterpret_cast<const uint8_t*>(note_contents +
+                                               note_header.n_namesz)};
+    }
+  }
+  return {0, nullptr};
+}
+
 }  // namespace dart
 
 #endif  // defined(DART_HOST_OS_FUCHSIA)

runtime/vm/os_linux.cc

@@ -7,6 +7,8 @@
 
 #include "vm/os.h"
 
+#include <dlfcn.h>         // NOLINT
+#include <elf.h>           // NOLINT
 #include <errno.h>         // NOLINT
 #include <fcntl.h>         // NOLINT
 #include <limits.h>        // NOLINT
@@ -26,6 +28,7 @@
 #include "vm/code_observers.h"
 #include "vm/dart.h"
 #include "vm/flags.h"
+#include "vm/image_snapshot.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/os_thread.h"
@@ -34,6 +37,13 @@
 
 namespace dart {
 
+// Used to choose between Elf32/Elf64 types based on host archotecture bitsize.
+#if defined(ARCH_IS_64_BIT)
+#define ElfW(Type) Elf64_##Type
+#else
+#define ElfW(Type) Elf32_##Type
+#endif
+
 #ifndef PRODUCT
 
 DEFINE_FLAG(bool,
@@ -271,14 +281,6 @@ class JitDumpCodeObserver : public CodeObserver {
     // Followed by nul-terminated name.
   };
 
-  // ELF machine architectures
-  // From linux/include/uapi/linux/elf-em.h
-  static constexpr uint32_t EM_386 = 3;
-  static constexpr uint32_t EM_X86_64 = 62;
-  static constexpr uint32_t EM_ARM = 40;
-  static constexpr uint32_t EM_AARCH64 = 183;
-  static constexpr uint32_t EM_RISCV = 243;
-
   static uint32_t GetElfMachineArchitecture() {
 #if TARGET_ARCH_IA32
     return EM_386;
@@ -296,12 +298,6 @@ class JitDumpCodeObserver : public CodeObserver {
 #endif
   }
 
-#if ARCH_IS_64_BIT
-  static constexpr int kElfHeaderSize = 0x40;
-#else
-  static constexpr int kElfHeaderSize = 0x34;
-#endif
-
   void WriteDebugInfo(uword base, const CodeComments* comments) {
     if (comments == nullptr || comments->Length() == 0) {
       return;
@@ -349,7 +345,7 @@ class JitDumpCodeObserver : public CodeObserver {
         i++;
       }
       DebugInfoEntry entry;
-      entry.address = base + pc_offset + kElfHeaderSize;
+      entry.address = base + pc_offset + sizeof(ElfW(Ehdr));
       entry.line_number = line_number;
       entry.column = 0;
       WriteFully(&entry, sizeof(entry));
@@ -657,6 +653,43 @@ void OS::Exit(int code) {
   exit(code);
 }
 
+OS::BuildId OS::GetAppBuildId(const uint8_t* snapshot_instructions) {
+  // First return the build ID information from the instructions image if
+  // available.
+  const Image instructions_image(snapshot_instructions);
+  if (auto* const image_build_id = instructions_image.build_id()) {
+    return {instructions_image.build_id_length(), image_build_id};
+  }
+  Dl_info snapshot_info;
+  if (dladdr(snapshot_instructions, &snapshot_info) == 0) {
+    return {0, nullptr};
+  }
+  const uint8_t* dso_base =
+      static_cast<const uint8_t*>(snapshot_info.dli_fbase);
+  const ElfW(Ehdr)& elf_header = *reinterpret_cast<const ElfW(Ehdr)*>(dso_base);
+  const ElfW(Phdr)* const phdr_array =
+      reinterpret_cast<const ElfW(Phdr)*>(dso_base + elf_header.e_phoff);
+  for (intptr_t i = 0; i < elf_header.e_phnum; i++) {
+    const ElfW(Phdr)& header = phdr_array[i];
+    if (header.p_type != PT_NOTE) continue;
+    if ((header.p_flags & PF_R) != PF_R) continue;
+    const uint8_t* const note_addr = dso_base + header.p_vaddr;
+    const Elf32_Nhdr& note_header =
+        *reinterpret_cast<const Elf32_Nhdr*>(note_addr);
+    if (note_header.n_type != NT_GNU_BUILD_ID) continue;
+    const char* const note_contents =
+        reinterpret_cast<const char*>(note_addr + sizeof(Elf32_Nhdr));
+    // The note name contains the null terminator as well.
+    if (note_header.n_namesz != strlen(ELF_NOTE_GNU) + 1) continue;
+    if (strncmp(ELF_NOTE_GNU, note_contents, note_header.n_namesz) == 0) {
+      return {static_cast<intptr_t>(note_header.n_descsz),
+              reinterpret_cast<const uint8_t*>(note_contents +
+                                               note_header.n_namesz)};
+    }
+  }
+  return {0, nullptr};
+}
+
 }  // namespace dart
 
 #endif  // defined(DART_HOST_OS_LINUX)

runtime/vm/os_macos.cc

@@ -7,8 +7,10 @@
 
 #include "vm/os.h"
 
+#include <dlfcn.h>           // NOLINT
 #include <errno.h>           // NOLINT
 #include <limits.h>          // NOLINT
+#include <mach-o/loader.h>   // NOLINT
 #include <mach/clock.h>      // NOLINT
 #include <mach/mach.h>       // NOLINT
 #include <mach/mach_time.h>  // NOLINT
@@ -20,6 +22,7 @@
 #endif
 
 #include "platform/utils.h"
+#include "vm/image_snapshot.h"
 #include "vm/isolate.h"
 #include "vm/timeline.h"
 #include "vm/zone.h"
@@ -307,6 +310,43 @@ void OS::Exit(int code) {
   exit(code);
 }
 
+OS::BuildId OS::GetAppBuildId(const uint8_t* snapshot_instructions) {
+  // First return the build ID information from the instructions image if
+  // available.
+  const Image instructions_image(snapshot_instructions);
+  if (auto* const image_build_id = instructions_image.build_id()) {
+    return {instructions_image.build_id_length(), image_build_id};
+  }
+  Dl_info snapshot_info;
+  if (dladdr(snapshot_instructions, &snapshot_info) == 0) {
+    return {0, nullptr};
+  }
+  const uint8_t* dso_base =
+      static_cast<const uint8_t*>(snapshot_info.dli_fbase);
+  const auto& macho_header =
+      *reinterpret_cast<const struct mach_header*>(dso_base);
+  // We assume host endianness in the Mach-O file.
+  if (macho_header.magic != MH_MAGIC && macho_header.magic != MH_MAGIC_64) {
+    return {0, nullptr};
+  }
+  const size_t macho_header_size = macho_header.magic == MH_MAGIC
+                                       ? sizeof(struct mach_header)
+                                       : sizeof(struct mach_header_64);
+  const uint8_t* it = dso_base + macho_header_size;
+  const uint8_t* end = it + macho_header.sizeofcmds;
+  while (it < end) {
+    const auto& current_cmd = *reinterpret_cast<const struct load_command*>(it);
+    if ((current_cmd.cmd & ~LC_REQ_DYLD) == LC_UUID) {
+      const auto& uuid_cmd = *reinterpret_cast<const struct uuid_command*>(it);
+      return {
+          static_cast<intptr_t>(uuid_cmd.cmdsize - sizeof(struct load_command)),
+          uuid_cmd.uuid};
+    }
+    it += current_cmd.cmdsize;
+  }
+  return {0, nullptr};
+}
+
 }  // namespace dart
 
 #endif  // defined(DART_HOST_OS_MACOS)