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 "sanitizer_platform.h"
13 #if !SANITIZER_FUCHSIA
14 #include "sancov_flags.h"
15 #include "sanitizer_allocator_internal.h"
16 #include "sanitizer_atomic.h"
17 #include "sanitizer_common.h"
18 #include "sanitizer_file.h"
19 #include "sanitizer_symbolizer.h"
21 using namespace __sanitizer;
23 using AddressRange = LoadedModule::AddressRange;
28 static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
29 static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL;
30 static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32;
32 static fd_t OpenFile(const char* path) {
34 fd_t fd = OpenFile(path, WrOnly, &err);
36 Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
41 static void GetCoverageFilename(char* path, const char* name,
42 const char* extension) {
44 internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s",
45 common_flags()->coverage_dir, name, internal_getpid(),
49 static void WriteModuleCoverage(char* file_path, const char* module_name,
50 const uptr* pcs, uptr len) {
51 GetCoverageFilename(file_path, StripModuleName(module_name), "sancov");
52 fd_t fd = OpenFile(file_path);
53 WriteToFile(fd, &Magic, sizeof(Magic));
54 WriteToFile(fd, pcs, len * sizeof(*pcs));
56 Printf("SanitizerCoverage: %s: %zd PCs written\n", file_path, len);
59 static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
62 char* file_path = static_cast<char*>(InternalAlloc(kMaxPathLength));
63 char* module_name = static_cast<char*>(InternalAlloc(kMaxPathLength));
64 uptr* pcs = static_cast<uptr*>(InternalAlloc(len * sizeof(uptr)));
66 internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr));
69 bool module_found = false;
71 uptr module_start_idx = 0;
73 for (uptr i = 0; i < len; ++i) {
74 const uptr pc = pcs[i];
77 if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
78 Printf("ERROR: unknown pc 0x%x (may happen if dlclose is used)\n", pc);
81 uptr module_base = pc - pcs[i];
83 if (module_base != last_base || !module_found) {
85 WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
86 i - module_start_idx);
89 last_base = module_base;
92 __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength,
98 WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
99 len - module_start_idx);
102 InternalFree(file_path);
103 InternalFree(module_name);
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) {
133 // we start indices from 1.
134 atomic_uintptr_t* pc_ptr =
135 reinterpret_cast<atomic_uintptr_t*>(&pc_vector[idx - 1]);
136 if (atomic_load(pc_ptr, memory_order_relaxed) == 0)
137 atomic_store(pc_ptr, pc, memory_order_relaxed);
141 internal_memset(&pc_vector[0], 0, sizeof(pc_vector[0]) * pc_vector.size());
145 if (!initialized || !common_flags()->coverage) return;
146 __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
151 InternalMmapVectorNoCtor<uptr> pc_vector;
154 static TracePcGuardController pc_guard_controller;
157 } // namespace __sancov
159 namespace __sanitizer {
160 void InitializeCoverage(bool enabled, const char *dir) {
161 static bool coverage_enabled = false;
162 if (coverage_enabled)
163 return; // May happen if two sanitizer enable coverage in the same process.
164 coverage_enabled = enabled;
165 Atexit(__sanitizer_cov_dump);
166 AddDieCallback(__sanitizer_cov_dump);
168 } // namespace __sanitizer
171 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage( // NOLINT
172 const uptr* pcs, uptr len) {
173 return __sancov::SanitizerDumpCoverage(pcs, len);
176 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32* guard) {
178 __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
181 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init,
182 u32* start, u32* end) {
183 if (start == end || *start) return;
184 __sancov::pc_guard_controller.InitTracePcGuard(start, end);
187 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
188 __sancov::pc_guard_controller.Dump();
190 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
191 __sanitizer_dump_trace_pc_guard_coverage();
193 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_reset() {
194 __sancov::pc_guard_controller.Reset();
196 // Default empty implementations (weak). Users should redefine them.
197 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) {}
198 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) {}
199 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp2, void) {}
200 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp4, void) {}
201 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp8, void) {}
202 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp1, void) {}
203 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp2, void) {}
204 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp4, void) {}
205 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp8, void) {}
206 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_switch, void) {}
207 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div4, void) {}
208 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div8, void) {}
209 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_gep, void) {}
210 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {}
211 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_8bit_counters_init, void) {}
212 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, void) {}
214 // Weak definition for code instrumented with -fsanitize-coverage=stack-depth
215 // and later linked with code containing a strong definition.
216 // E.g., -fsanitize=fuzzer-no-link
217 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
218 SANITIZER_TLS_INITIAL_EXEC_ATTRIBUTE uptr __sancov_lowest_stack;
220 #endif // !SANITIZER_FUCHSIA