[profile][Fuchsia] Use build ID for the raw profile name

[phosek]

Summary

This is uniquely identifies the profile just like the module signature,
but unlike module signature it also allows easily mapping the profile
back to the corresponding binary.

[mcgrathr]

Even with the bugs fixed, I'm not very sanguine about truncating to 31 chars.

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

114

There can be multiple PT_NOTE entries.

119

Both n_namesz and n_descsz need to be rounded up to 4.

122

here too

125

The bound can go negative if descsz > N/2.
Also, the return value of snprintf will always be 2, even if the bound constrains it from writing.
So this will always yield L=descsz*2 and the caller will overrun the buffer.

168

The name limit is only 32, while common build ID algorithms like sha1 will need 40 chars.
(By spec there is no bound on build ID size, but in other places we've capped it at 256 bits, which needs 64 chars of hex.)

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

  * exported globals so that exactly one definition will be shared across all
  * modules. Each module has its own independent runtime that registers its own
  * atexit hook to append its own data into the shared VMO which is published
  * via the data sink hook provided by Fuchsia's dynamic linker.
  */
 
 #if defined(__Fuchsia__)
 
+#include <elf.h>
 #include <inttypes.h>
+#include <link.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdlib.h>
 
 #include <zircon/process.h>
 #include <zircon/sanitizer.h>
 #include <zircon/status.h>
 #include <zircon/syscalls.h>
static uint32_t lprofVMOWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
   return 0;
 }
 
 static void initVMOWriter(ProfDataWriter *This, struct lprofVMOWriterCtx *Ctx) {
   This->Write = lprofVMOWriter;
   This->WriterCtx = Ctx;
 }
 
+extern const ElfW(Ehdr) __ehdr_start __attribute__((visibility("hidden")));
+
+static size_t getBuildId(char *Buffer, size_t N) {
+  const ElfW(Ehdr) *Ehdr = &__ehdr_start;
+  const ElfW(Phdr) *Phdr =
+      (const ElfW(Phdr) *)((uintptr_t)Ehdr + Ehdr->e_phoff);
+  while (Phdr->p_type != PT_NOTE)
+    ++Phdr;
+  const ElfW(Nhdr) *Nhdr =
+      (const ElfW(Nhdr) *)((uintptr_t)Ehdr + Phdr->p_offset);
+  while (Nhdr->n_type != NT_GNU_BUILD_ID)
+    Nhdr = (const ElfW(Nhdr) *)((uintptr_t)Nhdr + sizeof(ElfW(Nhdr)) +
+                                Nhdr->n_namesz + Nhdr->n_descsz);
+  uint8_t *BuildId =
+      (uint8_t *)((uintptr_t)Nhdr + sizeof(ElfW(Nhdr)) + Nhdr->n_namesz);
+  int L = 0;
+  for (size_t I = 0; I < Nhdr->n_descsz; I++)
+    L += snprintf(Buffer + (I * 2), N - (I * 2), "%02x", BuildId[I]);
+  return L;
+}
+
 /* This method is invoked by the runtime initialization hook
  * InstrProfilingRuntime.o if it is linked in. */
 COMPILER_RT_VISIBILITY
 void __llvm_profile_initialize(void) {
   /* Check if there is llvm/runtime version mismatch. */
   if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) {
     lprofWrite("LLVM Profile: runtime and instrumentation version mismatch: "
                "expected %d, but got %d\n",
void __llvm_profile_initialize(void) {
   Status = _zx_vmo_create(0, ZX_VMO_RESIZABLE, &Vmo);
   if (Status != ZX_OK) {
     lprofWrite("LLVM Profile: cannot create VMO: %s\n",
                _zx_status_get_string(Status));
     return;
   }
 
   /* Give the VMO a name that includes the module signature. */
   char VmoName[ZX_MAX_NAME_LEN];
-  snprintf(VmoName, sizeof(VmoName), "%" PRIu64 ".profraw",
-           lprofGetLoadModuleSignature());
+  size_t BuildIdLen = getBuildId(VmoName, ZX_MAX_NAME_LEN);
+  snprintf(VmoName + BuildIdLen, sizeof(VmoName) - BuildIdLen, ".profraw");
   _zx_object_set_property(Vmo, ZX_PROP_NAME, VmoName, strlen(VmoName));
 
   /* Write the profile data into the mapped region. */
   ProfDataWriter VMOWriter;
   struct lprofVMOWriterCtx Ctx = {.Vmo = Vmo, .Offset = 0};
   initVMOWriter(&VMOWriter, &Ctx);
   if (lprofWriteData(&VMOWriter, 0, 0) != 0) {
     lprofWrite("LLVM Profile: failed to write data\n");