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: unknown pc 0x%x (may happen if dlclose is used)\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);
103 // Collects trace-pc guard coverage.
104 // This class relies on zero-initialization.
105 class TracePcGuardController {
111 InitializeSancovFlags();
113 pc_vector.Initialize(0);
116 void InitTracePcGuard(u32* start, u32* end) {
117 if (!initialized) Initialize();
119 CHECK_NE(start, end);
121 u32 i = pc_vector.size();
122 for (u32* p = start; p < end; p++) *p = ++i;
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);
130 // we start indices from 1.
131 pc_vector[idx - 1] = pc;
135 if (!initialized || !common_flags()->coverage) return;
136 __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
141 InternalMmapVectorNoCtor<uptr> pc_vector;
144 static TracePcGuardController pc_guard_controller;
147 } // namespace __sancov
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);
158 } // namespace __sanitizer
161 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage( // NOLINT
162 const uptr* pcs, uptr len) {
163 return __sancov::SanitizerDumpCoverage(pcs, len);
166 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32* guard) {
168 __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
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);
177 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
178 __sancov::pc_guard_controller.Dump();
180 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
181 __sanitizer_dump_trace_pc_guard_coverage();
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) {}