Support for saving an ordered list of compilation units

[lszekeres]

Summary

This patch supports the reconstruction of an IR level trace from the "events" file generated by the current tracer. This can be done if we know the ordered list of compilation units. This patch extends the tracer runtime to dump this list along with the "events" file. The LLVM half of the patch is submitted separately.

[kcc]

LGTM with two nits.
You don't have commit access, do you?
I'll commit this and D7702 once we are done.

lib/sanitizer_common/sanitizer_coverage_libcdep.cc

85

module_name

113

period at the end.

[lszekeres]

Addressed comments.

[lszekeres]

No, I don't have commit access.. Thanks a lot!

[kcc]

done, r229940.
One of the lines was > 80 chars: please use 'ninja check-all' for testing

[lszekeres]

OK! Thanks!

lib/sanitizer_common/sanitizer_coverage_libcdep.cc

void IndirCall(uptr caller, uptr callee, uptr callee_cache[],
                  uptr cache_size);
   void DumpCallerCalleePairs();
   void DumpTrace();
 
   ALWAYS_INLINE
   void TraceBasicBlock(s32 *id);
 
   void InitializeGuardArray(s32 *guards);
-  void InitializeGuards(s32 *guards, uptr n);
+  void InitializeGuards(s32 *guards, uptr n, const char *module_name);
   void ReinitializeGuards();
 
   uptr *data();
   uptr size();
 
  private:
   // Maximal size pc array may ever grow.
   // We MmapNoReserve this space to ensure that the array is contiguous.
private:
   // Current file mapped size of the pc array.
   uptr pc_array_mapped_size;
   // Descriptor of the file mapped pc array.
   int pc_fd;
 
   // Vector of coverage guard arrays, protected by mu.
   InternalMmapVectorNoCtor<s32*> guard_array_vec;
 
+  // Vector of module (compilation unit) names.
+  InternalMmapVectorNoCtor<const char*> comp_unit_name_vec;
+
   // Caller-Callee (cc) array, size and current index.
   static const uptr kCcArrayMaxSize = FIRST_32_SECOND_64(1 << 18, 1 << 24);
   uptr **cc_array;
   atomic_uintptr_t cc_array_index;
   atomic_uintptr_t cc_array_size;
 
   // Tracing event array, size and current pointer.
   // We record all events (basic block entries) in a global buffer of u32
void *p = MapWritableFileToMemory((void *)next_map_base,
                                       pc_fd, pc_array_mapped_size);
     CHECK_EQ((uptr)p, next_map_base);
     pc_array_mapped_size = new_mapped_size;
   }
 
   atomic_store(&pc_array_size, size, memory_order_release);
 }
 
-void CoverageData::InitializeGuards(s32 *guards, uptr n) {
+void CoverageData::InitializeGuards(s32 *guards, uptr n, const char *module_name) {
   // The array 'guards' has n+1 elements, we use the element zero
   // to store 'n'.
   CHECK_LT(n, 1 << 30);
   guards[0] = static_cast<s32>(n);
   InitializeGuardArray(guards);
   SpinMutexLock l(&mu);
+  comp_unit_name_vec.push_back(module_name);
   guard_array_vec.push_back(guards);
 }
 
 // If guard is negative, atomically set it to -guard and store the PC in
 // pc_array.
 void CoverageData::Add(uptr pc, u32 *guard) {
   atomic_uint32_t *atomic_guard = reinterpret_cast<atomic_uint32_t*>(guard);
   s32 guard_value = atomic_load(atomic_guard, memory_order_relaxed);
sym->GetModuleNameAndOffsetForPC(pc_array[i], &module_name,
                                      &module_address);
     out.append("%s 0x%zx\n", module_name, module_address);
   }
   int fd = CovOpenFile(false, "trace-points");
   if (fd < 0) return;
   internal_write(fd, out.data(), out.length());
   internal_close(fd);
 
+  fd = CovOpenFile(false, "trace-compunits");
+  if (fd < 0) return;
+  out.clear();
+  for (uptr i = 0; i < comp_unit_name_vec.size(); i++)
+    out.append("%s\n", comp_unit_name_vec[i]);
+  internal_write(fd, out.data(), out.length());
+  internal_close(fd);
+
   fd = CovOpenFile(false, "trace-events");
   if (fd < 0) return;
   uptr bytes_to_write = max_idx * sizeof(tr_event_array[0]);
   u8 *event_bytes = reinterpret_cast<u8*>(tr_event_array);
   // The trace file could be huge, and may not be written with a single syscall.
   while (bytes_to_write) {
     uptr actually_written = internal_write(fd, event_bytes, bytes_to_write);
     if (actually_written <= bytes_to_write) {
coverage_data.IndirCall(StackTrace::GetPreviousInstructionPc(GET_CALLER_PC()),
                           callee, callee_cache16, 16);
 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_init() {
   coverage_enabled = true;
   coverage_dir = common_flags()->coverage_dir;
   coverage_data.Init();
 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() { CovDump(); }
-SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_module_init(s32 *guards,
-                                                               uptr npcs) {
-  coverage_data.InitializeGuards(guards, npcs);
+SANITIZER_INTERFACE_ATTRIBUTE void
+__sanitizer_cov_module_init(s32 *guards, uptr npcs, const char *module_name) {
+  coverage_data.InitializeGuards(guards, npcs, module_name);
   if (!common_flags()->coverage_direct) return;
   if (SANITIZER_ANDROID && coverage_enabled) {
     // dlopen/dlclose interceptors do not work on Android, so we rely on
     // Extend() calls to update .sancov.map.
     CovUpdateMapping(coverage_dir, GET_CALLER_PC());
   }
   coverage_data.Extend(npcs);
 }