1 //===-- sanitizer_coverage_libcdep_new.cc ---------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
9 // Sanitizer Coverage Controller for Trace PC Guard.
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"
17 using namespace __sanitizer;
19 using AddressRange = LoadedModule::AddressRange;
24 static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
25 static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL;
26 static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32;
28 static fd_t OpenFile(const char* path) {
30 fd_t fd = OpenFile(path, WrOnly, &err);
32 Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
37 static void GetCoverageFilename(char* path, const char* name,
38 const char* extension) {
40 internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s",
41 common_flags()->coverage_dir, name, internal_getpid(),
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));
52 Printf("SanitizerCoverage: %s %zd PCs written\n", file_path, len);
55 static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
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)));
62 internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr));
65 bool module_found = false;
67 uptr module_start_idx = 0;
69 for (uptr i = 0; i < len; ++i) {
70 const uptr pc = pcs[i];
73 if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
74 Printf("ERROR: bad pc %x\n", pc);
77 uptr module_base = pc - pcs[i];
79 if (module_base != last_base || !module_found) {
81 WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
82 i - module_start_idx);
85 last_base = module_base;
88 __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength,
94 WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
95 len - module_start_idx);
98 InternalFree(file_path);
99 InternalFree(module_name);
102 if (sancov_flags()->symbolize) {
103 Printf("TODO(aizatsky): call sancov to symbolize\n");
107 // Collects trace-pc guard coverage.
108 // This class relies on zero-initialization.
109 class TracePcGuardController {
115 InitializeSancovFlags();
117 pc_vector.Initialize(0);
120 void InitTracePcGuard(u32* start, u32* end) {
121 if (!initialized) Initialize();
123 CHECK_NE(start, end);
125 u32 i = pc_vector.size();
126 for (u32* p = start; p < end; p++) *p = ++i;
130 void TracePcGuard(u32* guard, uptr pc) {
131 atomic_uint32_t* guard_ptr = reinterpret_cast<atomic_uint32_t*>(guard);
132 u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);
134 // we start indices from 1.
135 pc_vector[idx - 1] = pc;
139 if (!initialized || !common_flags()->coverage) return;
140 __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
145 InternalMmapVectorNoCtor<uptr> pc_vector;
148 static TracePcGuardController pc_guard_controller;
151 } // namespace __sancov
154 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage( // NOLINT
155 const uptr* pcs, uptr len) {
156 return __sancov::SanitizerDumpCoverage(pcs, len);
159 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
160 __sanitizer_cov_trace_pc_guard(u32* guard) {
162 __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
165 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
166 __sanitizer_cov_trace_pc_guard_init(u32* start, u32* end) {
167 if (start == end || *start) return;
168 __sancov::pc_guard_controller.InitTracePcGuard(start, end);
171 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
172 __sancov::pc_guard_controller.Dump();