contrib/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cc

   1 //===-- sanitizer_coverage_libcdep_new.cc ---------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 // Sanitizer Coverage Controller for Trace PC Guard.
  10
  11 #include "sancov_flags.h"
  12 #include "sanitizer_allocator_internal.h"
  13 #include "sanitizer_atomic.h"
  14 #include "sanitizer_common.h"
  15 #include "sanitizer_symbolizer.h"
  16
  17 using namespace __sanitizer;
  18
  19 using AddressRange = LoadedModule::AddressRange;
  20
  21 namespace __sancov {
  22 namespace {
  23
  24 static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
  25 static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL;
  26 static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32;
  27
  28 static fd_t OpenFile(const char* path) {
  29   error_t err;
  30   fd_t fd = OpenFile(path, WrOnly, &err);
  31   if (fd == kInvalidFd)
  32     Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
  33            path, err);
  34   return fd;
  35 }
  36
  37 static void GetCoverageFilename(char* path, const char* name,
  38                                 const char* extension) {
  39   CHECK(name);
  40   internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s",
  41                     common_flags()->coverage_dir, name, internal_getpid(),
  42                     extension);
  43 }
  44
  45 static void WriteModuleCoverage(char* file_path, const char* module_name,
  46                                 const uptr* pcs, uptr len) {
  47   GetCoverageFilename(file_path, StripModuleName(module_name), "sancov");
  48   fd_t fd = OpenFile(file_path);
  49   WriteToFile(fd, &Magic, sizeof(Magic));
  50   WriteToFile(fd, pcs, len * sizeof(*pcs));
  51   CloseFile(fd);
  52   Printf("SanitizerCoverage: %s: %zd PCs written\n", file_path, len);
  53 }
  54
  55 static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
  56   if (!len) return;
  57
  58   char* file_path = static_cast<char*>(InternalAlloc(kMaxPathLength));
  59   char* module_name = static_cast<char*>(InternalAlloc(kMaxPathLength));
  60   uptr* pcs = static_cast<uptr*>(InternalAlloc(len * sizeof(uptr)));
  61
  62   internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr));
  63   SortArray(pcs, len);
  64
  65   bool module_found = false;
  66   uptr last_base = 0;
  67   uptr module_start_idx = 0;
  68
  69   for (uptr i = 0; i < len; ++i) {
  70     const uptr pc = pcs[i];
  71     if (!pc) continue;
  72
  73     if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
  74       Printf("ERROR: unknown pc 0x%x (may happen if dlclose is used)\n", pc);
  75       continue;
  76     }
  77     uptr module_base = pc - pcs[i];
  78
  79     if (module_base != last_base || !module_found) {
  80       if (module_found) {
  81         WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
  82                             i - module_start_idx);
  83       }
  84
  85       last_base = module_base;
  86       module_start_idx = i;
  87       module_found = true;
  88       __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength,
  89                                                &pcs[i]);
  90     }
  91   }
  92
  93   if (module_found) {
  94     WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
  95                         len - module_start_idx);
  96   }
  97
  98   InternalFree(file_path);
  99   InternalFree(module_name);
 100   InternalFree(pcs);
 101 }
 102
 103 // Collects trace-pc guard coverage.
 104 // This class relies on zero-initialization.
 105 class TracePcGuardController {
 106  public:
 107   void Initialize() {
 108     CHECK(!initialized);
 109
 110     initialized = true;
 111     InitializeSancovFlags();
 112
 113     pc_vector.Initialize(0);
 114   }
 115
 116   void InitTracePcGuard(u32* start, u32* end) {
 117     if (!initialized) Initialize();
 118     CHECK(!*start);
 119     CHECK_NE(start, end);
 120
 121     u32 i = pc_vector.size();
 122     for (u32* p = start; p < end; p++) *p = ++i;
 123     pc_vector.resize(i);
 124   }
 125
 126   void TracePcGuard(u32* guard, uptr pc) {
 127     atomic_uint32_t* guard_ptr = reinterpret_cast<atomic_uint32_t*>(guard);
 128     u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);
 129     if (!idx) return;
 130     // we start indices from 1.
 131     pc_vector[idx - 1] = pc;
 132   }
 133
 134   void Dump() {
 135     if (!initialized || !common_flags()->coverage) return;
 136     __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
 137   }
 138
 139  private:
 140   bool initialized;
 141   InternalMmapVectorNoCtor<uptr> pc_vector;
 142 };
 143
 144 static TracePcGuardController pc_guard_controller;
 145
 146 }  // namespace
 147 }  // namespace __sancov
 148
 149 namespace __sanitizer {
 150 void InitializeCoverage(bool enabled, const char *dir) {
 151   static bool coverage_enabled = false;
 152   if (coverage_enabled)
 153     return;  // May happen if two sanitizer enable coverage in the same process.
 154   coverage_enabled = enabled;
 155   Atexit(__sanitizer_cov_dump);
 156   AddDieCallback(__sanitizer_cov_dump);
 157 }
 158 } // namespace __sanitizer
 159
 160 extern "C" {
 161 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(  // NOLINT
 162     const uptr* pcs, uptr len) {
 163   return __sancov::SanitizerDumpCoverage(pcs, len);
 164 }
 165
 166 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32* guard) {
 167   if (!*guard) return;
 168   __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
 169 }
 170
 171 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init,
 172                              u32* start, u32* end) {
 173   if (start == end || *start) return;
 174   __sancov::pc_guard_controller.InitTracePcGuard(start, end);
 175 }
 176
 177 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
 178   __sancov::pc_guard_controller.Dump();
 179 }
 180 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
 181   __sanitizer_dump_trace_pc_guard_coverage();
 182 }
 183 // Default empty implementations (weak). Users should redefine them.
 184 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) {}
 185 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) {}
 186 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp2, void) {}
 187 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp4, void) {}
 188 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp8, void) {}
 189 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_switch, void) {}
 190 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div4, void) {}
 191 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div8, void) {}
 192 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_gep, void) {}
 193 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {}
 194 }  // extern "C"