sanitizer_coverage_libcdep_new.cpp | Explore in Territory

//===-- sanitizer_coverage_libcdep_new.cpp --------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// Sanitizer Coverage Controller for Trace PC Guard.

#include "sanitizer_platform.h"

#if !SANITIZER_FUCHSIA
#  include "sancov_flags.h"
#  include "sanitizer_allocator_internal.h"
#  include "sanitizer_atomic.h"
#  include "sanitizer_common.h"
#  include "sanitizer_common/sanitizer_stacktrace.h"
#  include "sanitizer_file.h"
#  include "sanitizer_interface_internal.h"

usingnamespace__sanitizer;

AddressRange;

namespace __sancov {
namespace {

static const u64 Magic64 = …;
static const u64 Magic32 = …;
static const u64 Magic = …;

static fd_t OpenFile(const char* path) { … }

static void GetCoverageFilename(char* path, const char* name,
                                const char* extension) { … }

static void WriteModuleCoverage(char* file_path, const char* module_name,
                                const uptr* pcs, uptr len) { … }

static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) { … }

// Collects trace-pc guard coverage.
// This class relies on zero-initialization.
class TracePcGuardController { … };

static TracePcGuardController pc_guard_controller;

// A basic default implementation of callbacks for
// -fsanitize-coverage=inline-8bit-counters,pc-table.
// Use TOOL_OPTIONS (UBSAN_OPTIONS, etc) to dump the coverage data:
// * cov_8bit_counters_out=PATH to dump the 8bit counters.
// * cov_pcs_out=PATH to dump the pc table.
//
// Most users will still need to define their own callbacks for greater
// flexibility.
namespace SingletonCounterCoverage {

static char *counters_beg, *counters_end;
static const uptr *pcs_beg, *pcs_end;

static void DumpCoverage() { … }

static void Cov8bitCountersInit(char* beg, char* end) { … }

static void CovPcsInit(const uptr* beg, const uptr* end) { … }

}  // namespace SingletonCounterCoverage

}  // namespace
}  // namespace __sancov

namespace __sanitizer {
void InitializeCoverage(bool enabled, const char *dir) { … }
} // namespace __sanitizer

extern "C" {
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(const uptr* pcs,
                                                             uptr len) { … }

SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32* guard) { … }

SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init,
                             u32* start, u32* end) { … }

SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() { … }
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() { … }
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_reset() { … }
// Default implementations (weak).
// Either empty or very simple.
// Most users should redefine them.
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp2, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp4, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp8, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp1, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp2, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp4, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp8, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_switch, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div4, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div8, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_gep, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_load1, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_load2, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_load4, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_load8, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_load16, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_store1, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_store2, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_store4, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_store8, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_store16, void){ … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_8bit_counters_init,
                             char* start, char* end) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_bool_flag_init, void) { … }
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, const uptr* beg,
                             const uptr* end) { … }
}  // extern "C"
// Weak definition for code instrumented with -fsanitize-coverage=stack-depth
// and later linked with code containing a strong definition.
// E.g., -fsanitize=fuzzer-no-link
// FIXME: Update Apple deployment target so that thread_local is always
// supported, and remove the #if.
// FIXME: Figure out how this should work on Windows, exported thread_local
// symbols are not supported:
// "data with thread storage duration may not have dll interface"
#if !SANITIZER_APPLE && !SANITIZER_WINDOWS
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
thread_local uptr __sancov_lowest_stack;
#endif

#endif  // !SANITIZER_FUCHSIA
llvm/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp
