[compiler-rt] ef83c25 - [nsan] Fix style issue
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jun 20 00:46:14 PDT 2024
Author: Fangrui Song
Date: 2024-06-20T00:46:10-07:00
New Revision: ef83c25b0e56438d1697138915273dc71b8acf82
URL: https://github.com/llvm/llvm-project/commit/ef83c25b0e56438d1697138915273dc71b8acf82
DIFF: https://github.com/llvm/llvm-project/commit/ef83c25b0e56438d1697138915273dc71b8acf82.diff
LOG: [nsan] Fix style issue
The initial check-in of compiler-rt/lib/nsan #94322 has a lot of style
issues. Fix them before the history becomes more useful.
Pull Request: https://github.com/llvm/llvm-project/pull/96142
Added:
compiler-rt/lib/nsan/nsan.cpp
compiler-rt/lib/nsan/nsan_flags.cpp
compiler-rt/lib/nsan/nsan_interceptors.cpp
compiler-rt/lib/nsan/nsan_stats.cpp
compiler-rt/lib/nsan/nsan_suppressions.cpp
Modified:
compiler-rt/lib/nsan/CMakeLists.txt
compiler-rt/lib/nsan/nsan.h
compiler-rt/lib/nsan/nsan_stats.h
compiler-rt/lib/nsan/tests/NSanUnitTest.cpp
Removed:
compiler-rt/lib/nsan/nsan.cc
compiler-rt/lib/nsan/nsan_flags.cc
compiler-rt/lib/nsan/nsan_interceptors.cc
compiler-rt/lib/nsan/nsan_stats.cc
compiler-rt/lib/nsan/nsan_suppressions.cc
################################################################################
diff --git a/compiler-rt/lib/nsan/CMakeLists.txt b/compiler-rt/lib/nsan/CMakeLists.txt
index ae94c96d60727..36c7b2b9dfada 100644
--- a/compiler-rt/lib/nsan/CMakeLists.txt
+++ b/compiler-rt/lib/nsan/CMakeLists.txt
@@ -3,11 +3,11 @@ add_compiler_rt_component(nsan)
include_directories(..)
set(NSAN_SOURCES
- nsan.cc
- nsan_flags.cc
- nsan_interceptors.cc
- nsan_stats.cc
- nsan_suppressions.cc
+ nsan.cpp
+ nsan_flags.cpp
+ nsan_interceptors.cpp
+ nsan_stats.cpp
+ nsan_suppressions.cpp
)
set(NSAN_HEADERS
diff --git a/compiler-rt/lib/nsan/nsan.cc b/compiler-rt/lib/nsan/nsan.cpp
similarity index 73%
rename from compiler-rt/lib/nsan/nsan.cc
rename to compiler-rt/lib/nsan/nsan.cpp
index d0d29ddfba0e3..f7b2ce2048290 100644
--- a/compiler-rt/lib/nsan/nsan.cc
+++ b/compiler-rt/lib/nsan/nsan.cpp
@@ -51,16 +51,16 @@
using namespace __sanitizer;
using namespace __nsan;
-static constexpr const int kMaxVectorWidth = 8;
+constexpr int kMaxVectorWidth = 8;
// When copying application memory, we also copy its shadow and shadow type.
// FIXME: We could provide fixed-size versions that would nicely
// vectorize for known sizes.
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
__nsan_copy_values(const u8 *daddr, const u8 *saddr, uptr size) {
- internal_memmove((void *)getShadowTypeAddrFor(daddr),
- getShadowTypeAddrFor(saddr), size);
- internal_memmove((void *)getShadowAddrFor(daddr), getShadowAddrFor(saddr),
+ internal_memmove((void *)GetShadowTypeAddrFor(daddr),
+ GetShadowTypeAddrFor(saddr), size);
+ internal_memmove((void *)GetShadowAddrFor(daddr), GetShadowAddrFor(saddr),
size * kShadowScale);
}
@@ -68,10 +68,9 @@ __nsan_copy_values(const u8 *daddr, const u8 *saddr, uptr size) {
// vectorize for known sizes.
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
__nsan_set_value_unknown(const u8 *addr, uptr size) {
- internal_memset((void *)getShadowTypeAddrFor(addr), 0, size);
+ internal_memset((void *)GetShadowTypeAddrFor(addr), 0, size);
}
-namespace __nsan {
const char *FTInfo<float>::kCppTypeName = "float";
const char *FTInfo<double>::kCppTypeName = "double";
@@ -82,27 +81,29 @@ const char FTInfo<float>::kTypePattern[sizeof(float)];
const char FTInfo<double>::kTypePattern[sizeof(double)];
const char FTInfo<long double>::kTypePattern[sizeof(long double)];
-// Helper for __nsan_dump_shadow_mem: Reads the value at address `Ptr`,
+// Helper for __nsan_dump_shadow_mem: Reads the value at address `ptr`,
// identified by its type id.
-template <typename ShadowFT> __float128 readShadowInternal(const u8 *Ptr) {
+template <typename ShadowFT>
+static __float128 ReadShadowInternal(const u8 *ptr) {
ShadowFT Shadow;
- __builtin_memcpy(&Shadow, Ptr, sizeof(Shadow));
+ __builtin_memcpy(&Shadow, ptr, sizeof(Shadow));
return Shadow;
}
-__float128 readShadow(const u8 *Ptr, const char ShadowTypeId) {
+static __float128 ReadShadow(const u8 *ptr, const char ShadowTypeId) {
switch (ShadowTypeId) {
case 'd':
- return readShadowInternal<double>(Ptr);
+ return ReadShadowInternal<double>(ptr);
case 'l':
- return readShadowInternal<long double>(Ptr);
+ return ReadShadowInternal<long double>(ptr);
case 'q':
- return readShadowInternal<__float128>(Ptr);
+ return ReadShadowInternal<__float128>(ptr);
default:
return 0.0;
}
}
+namespace {
class Decorator : public __sanitizer::SanitizerCommonDecorator {
public:
Decorator() : SanitizerCommonDecorator() {}
@@ -111,8 +112,6 @@ class Decorator : public __sanitizer::SanitizerCommonDecorator {
const char *End() { return Default(); }
};
-namespace {
-
// Workaround for the fact that Printf() does not support floats.
struct PrintBuffer {
char Buffer[64];
@@ -120,30 +119,30 @@ struct PrintBuffer {
template <typename FT> struct FTPrinter {};
template <> struct FTPrinter<double> {
- static PrintBuffer dec(double Value) {
- PrintBuffer Result;
- snprintf(Result.Buffer, sizeof(Result.Buffer) - 1, "%.20f", Value);
- return Result;
+ static PrintBuffer dec(double value) {
+ PrintBuffer result;
+ snprintf(result.Buffer, sizeof(result.Buffer) - 1, "%.20f", value);
+ return result;
}
- static PrintBuffer hex(double Value) {
- PrintBuffer Result;
- snprintf(Result.Buffer, sizeof(Result.Buffer) - 1, "%.20a", Value);
- return Result;
+ static PrintBuffer hex(double value) {
+ PrintBuffer result;
+ snprintf(result.Buffer, sizeof(result.Buffer) - 1, "%.20a", value);
+ return result;
}
};
template <> struct FTPrinter<float> : FTPrinter<double> {};
template <> struct FTPrinter<long double> {
- static PrintBuffer dec(long double Value) {
- PrintBuffer Result;
- snprintf(Result.Buffer, sizeof(Result.Buffer) - 1, "%.20Lf", Value);
- return Result;
+ static PrintBuffer dec(long double value) {
+ PrintBuffer result;
+ snprintf(result.Buffer, sizeof(result.Buffer) - 1, "%.20Lf", value);
+ return result;
}
- static PrintBuffer hex(long double Value) {
- PrintBuffer Result;
- snprintf(Result.Buffer, sizeof(Result.Buffer) - 1, "%.20La", Value);
- return Result;
+ static PrintBuffer hex(long double value) {
+ PrintBuffer result;
+ snprintf(result.Buffer, sizeof(result.Buffer) - 1, "%.20La", value);
+ return result;
}
};
@@ -151,15 +150,15 @@ template <> struct FTPrinter<long double> {
template <> struct FTPrinter<__float128> : FTPrinter<long double> {};
// This is a template so that there are no implicit conversions.
-template <typename FT> inline FT ftAbs(FT V);
+template <typename FT> inline FT ftAbs(FT v);
-template <> inline long double ftAbs(long double V) { return fabsl(V); }
-template <> inline double ftAbs(double V) { return fabs(V); }
+template <> inline long double ftAbs(long double v) { return fabsl(v); }
+template <> inline double ftAbs(double v) { return fabs(v); }
// We don't care about nans.
// std::abs(__float128) code is suboptimal and generates a function call to
// __getf2().
-template <typename FT> inline FT ftAbs(FT V) { return V >= FT{0} ? V : -V; }
+template <typename FT> inline FT ftAbs(FT v) { return v >= FT{0} ? v : -v; }
template <typename FT1, typename FT2, bool Enable> struct LargestFTImpl {
using type = FT2;
@@ -177,8 +176,6 @@ template <typename T> T max(T a, T b) { return a < b ? b : a; }
} // end anonymous namespace
-} // end namespace __nsan
-
void __sanitizer::BufferedStackTrace::UnwindImpl(uptr pc, uptr bp,
void *context,
bool request_fast,
@@ -189,10 +186,10 @@ void __sanitizer::BufferedStackTrace::UnwindImpl(uptr pc, uptr bp,
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_print_accumulated_stats() {
if (nsan_stats)
- nsan_stats->print();
+ nsan_stats->Print();
}
-static void nsanAtexit() {
+static void NsanAtexit() {
Printf("Numerical Sanitizer exit stats:\n");
__nsan_print_accumulated_stats();
nsan_stats = nullptr;
@@ -204,13 +201,13 @@ static void nsanAtexit() {
// around long double being the same for nsan and the target application.
// We have to have 3 versions because we need to know which type we are storing
// since we are setting the type shadow memory.
-template <typename FT> static u8 *getShadowPtrForStore(u8 *StoreAddr, uptr N) {
- unsigned char *ShadowType = getShadowTypeAddrFor(StoreAddr);
- for (uptr I = 0; I < N; ++I) {
- __builtin_memcpy(ShadowType + I * sizeof(FT), FTInfo<FT>::kTypePattern,
+template <typename FT> static u8 *getShadowPtrForStore(u8 *store_addr, uptr n) {
+ unsigned char *shadow_type = GetShadowTypeAddrFor(store_addr);
+ for (uptr i = 0; i < n; ++i) {
+ __builtin_memcpy(shadow_type + i * sizeof(FT), FTInfo<FT>::kTypePattern,
sizeof(FTInfo<FT>::kTypePattern));
}
- return getShadowAddrFor(StoreAddr);
+ return GetShadowAddrFor(store_addr);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE u8 *
@@ -228,48 +225,48 @@ __nsan_get_shadow_ptr_for_longdouble_store(u8 *store_addr, uptr n) {
return getShadowPtrForStore<long double>(store_addr, n);
}
-template <typename FT> static bool isValidShadowType(const u8 *ShadowType) {
- return __builtin_memcmp(ShadowType, FTInfo<FT>::kTypePattern, sizeof(FT)) ==
+template <typename FT> static bool IsValidShadowType(const u8 *shadow_type) {
+ return __builtin_memcmp(shadow_type, FTInfo<FT>::kTypePattern, sizeof(FT)) ==
0;
}
-template <int kSize, typename T> static bool isZero(const T *Ptr) {
+template <int kSize, typename T> static bool IsZero(const T *ptr) {
constexpr const char kZeros[kSize] = {}; // Zero initialized.
- return __builtin_memcmp(Ptr, kZeros, kSize) == 0;
+ return __builtin_memcmp(ptr, kZeros, kSize) == 0;
}
-template <typename FT> static bool isUnknownShadowType(const u8 *ShadowType) {
- return isZero<sizeof(FTInfo<FT>::kTypePattern)>(ShadowType);
+template <typename FT> static bool IsUnknownShadowType(const u8 *shadow_type) {
+ return IsZero<sizeof(FTInfo<FT>::kTypePattern)>(shadow_type);
}
// The three folowing functions check that the address stores a complete
// shadow value of the given type and return a pointer for loading.
// They return nullptr if the type of the value is unknown or incomplete.
template <typename FT>
-static const u8 *getShadowPtrForLoad(const u8 *LoadAddr, uptr N) {
- const u8 *const ShadowType = getShadowTypeAddrFor(LoadAddr);
- for (uptr I = 0; I < N; ++I) {
- if (!isValidShadowType<FT>(ShadowType + I * sizeof(FT))) {
+static const u8 *getShadowPtrForLoad(const u8 *load_addr, uptr n) {
+ const u8 *const shadow_type = GetShadowTypeAddrFor(load_addr);
+ for (uptr i = 0; i < n; ++i) {
+ if (!IsValidShadowType<FT>(shadow_type + i * sizeof(FT))) {
// If loadtracking stats are enabled, log loads with invalid types
// (tampered with through type punning).
if (flags().enable_loadtracking_stats) {
- if (isUnknownShadowType<FT>(ShadowType + I * sizeof(FT))) {
+ if (IsUnknownShadowType<FT>(shadow_type + i * sizeof(FT))) {
// Warn only if the value is non-zero. Zero is special because
// applications typically initialize large buffers to zero in an
// untyped way.
- if (!isZero<sizeof(FT)>(LoadAddr)) {
+ if (!IsZero<sizeof(FT)>(load_addr)) {
GET_CALLER_PC_BP;
- nsan_stats->addUnknownLoadTrackingEvent(pc, bp);
+ nsan_stats->AddUnknownLoadTrackingEvent(pc, bp);
}
} else {
GET_CALLER_PC_BP;
- nsan_stats->addInvalidLoadTrackingEvent(pc, bp);
+ nsan_stats->AddInvalidLoadTrackingEvent(pc, bp);
}
}
return nullptr;
}
}
- return getShadowAddrFor(LoadAddr);
+ return GetShadowAddrFor(load_addr);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE const u8 *
@@ -291,14 +288,14 @@ __nsan_get_shadow_ptr_for_longdouble_load(const u8 *load_addr, uptr n) {
// opaque.
extern "C" SANITIZER_INTERFACE_ATTRIBUTE u8 *
__nsan_internal_get_raw_shadow_ptr(const u8 *addr) {
- return getShadowAddrFor(const_cast<u8 *>(addr));
+ return GetShadowAddrFor(const_cast<u8 *>(addr));
}
// Returns the raw shadow type pointer. The returned pointer should be
// considered opaque.
extern "C" SANITIZER_INTERFACE_ATTRIBUTE u8 *
__nsan_internal_get_raw_shadow_type_ptr(const u8 *addr) {
- return reinterpret_cast<u8 *>(getShadowTypeAddrFor(const_cast<u8 *>(addr)));
+ return reinterpret_cast<u8 *>(GetShadowTypeAddrFor(const_cast<u8 *>(addr)));
}
static ValueType getValueType(u8 c) { return static_cast<ValueType>(c & 0x3); }
@@ -308,14 +305,14 @@ static int getValuePos(u8 c) { return c >> kValueSizeSizeBits; }
// Checks the consistency of the value types at the given type pointer.
// If the value is inconsistent, returns ValueType::kUnknown. Else, return the
// consistent type.
-template <typename FT> static bool checkValueConsistency(const u8 *ShadowType) {
- const int Pos = getValuePos(*ShadowType);
+template <typename FT>
+static bool checkValueConsistency(const u8 *shadow_type) {
+ const int pos = getValuePos(*shadow_type);
// Check that all bytes from the start of the value are ordered.
- for (uptr I = 0; I < sizeof(FT); ++I) {
- const u8 T = *(ShadowType - Pos + I);
- if (!(getValueType(T) == FTInfo<FT>::kValueType && getValuePos(T) == I)) {
+ for (uptr i = 0; i < sizeof(FT); ++i) {
+ const u8 T = *(shadow_type - pos + i);
+ if (!(getValueType(T) == FTInfo<FT>::kValueType && getValuePos(T) == i))
return false;
- }
}
return true;
}
@@ -325,15 +322,14 @@ template <typename FT> static bool checkValueConsistency(const u8 *ShadowType) {
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
__nsan_dump_shadow_mem(const u8 *addr, size_t size_bytes, size_t bytes_per_line,
size_t shadow_value_type_ids) {
- const u8 *const ShadowType = getShadowTypeAddrFor(addr);
- const u8 *const Shadow = getShadowAddrFor(addr);
+ const u8 *const shadow_type = GetShadowTypeAddrFor(addr);
+ const u8 *const shadow = GetShadowAddrFor(addr);
constexpr int kMaxNumDecodedValues = 16;
- __float128 DecodedValues[kMaxNumDecodedValues];
- int NumDecodedValues = 0;
- if (bytes_per_line > 4 * kMaxNumDecodedValues) {
+ __float128 decoded_values[kMaxNumDecodedValues];
+ int num_decoded_values = 0;
+ if (bytes_per_line > 4 * kMaxNumDecodedValues)
bytes_per_line = 4 * kMaxNumDecodedValues;
- }
// We keep track of the current type and position as we go.
ValueType LastValueTy = kUnknownValueType;
@@ -343,8 +339,8 @@ __nsan_dump_shadow_mem(const u8 *addr, size_t size_bytes, size_t bytes_per_line,
++R) {
printf("%p: ", (void *)(addr + R * bytes_per_line));
for (size_t C = 0; C < bytes_per_line && Offset < size_bytes; ++C) {
- const ValueType ValueTy = getValueType(ShadowType[Offset]);
- const int pos = getValuePos(ShadowType[Offset]);
+ const ValueType ValueTy = getValueType(shadow_type[Offset]);
+ const int pos = getValuePos(shadow_type[Offset]);
if (ValueTy == LastValueTy && pos == LastPos + 1) {
++LastPos;
} else {
@@ -359,64 +355,59 @@ __nsan_dump_shadow_mem(const u8 *addr, size_t size_bytes, size_t bytes_per_line,
case kFloatValueType:
printf("f%x ", pos);
if (LastPos == sizeof(float) - 1) {
- DecodedValues[NumDecodedValues] =
- readShadow(Shadow + kShadowScale * (Offset + 1 - sizeof(float)),
+ decoded_values[num_decoded_values] =
+ ReadShadow(shadow + kShadowScale * (Offset + 1 - sizeof(float)),
static_cast<char>(shadow_value_type_ids & 0xff));
- ++NumDecodedValues;
+ ++num_decoded_values;
}
break;
case kDoubleValueType:
printf("d%x ", pos);
if (LastPos == sizeof(double) - 1) {
- DecodedValues[NumDecodedValues] = readShadow(
- Shadow + kShadowScale * (Offset + 1 - sizeof(double)),
+ decoded_values[num_decoded_values] = ReadShadow(
+ shadow + kShadowScale * (Offset + 1 - sizeof(double)),
static_cast<char>((shadow_value_type_ids >> 8) & 0xff));
- ++NumDecodedValues;
+ ++num_decoded_values;
}
break;
case kFp80ValueType:
printf("l%x ", pos);
if (LastPos == sizeof(long double) - 1) {
- DecodedValues[NumDecodedValues] = readShadow(
- Shadow + kShadowScale * (Offset + 1 - sizeof(long double)),
+ decoded_values[num_decoded_values] = ReadShadow(
+ shadow + kShadowScale * (Offset + 1 - sizeof(long double)),
static_cast<char>((shadow_value_type_ids >> 16) & 0xff));
- ++NumDecodedValues;
+ ++num_decoded_values;
}
break;
}
++Offset;
}
- for (int I = 0; I < NumDecodedValues; ++I) {
- printf(" (%s)", FTPrinter<__float128>::dec(DecodedValues[I]).Buffer);
+ for (int i = 0; i < num_decoded_values; ++i) {
+ printf(" (%s)", FTPrinter<__float128>::dec(decoded_values[i]).Buffer);
}
- NumDecodedValues = 0;
+ num_decoded_values = 0;
printf("\n");
}
}
SANITIZER_INTERFACE_ATTRIBUTE
-ALIGNED(16)
-THREADLOCAL
-uptr __nsan_shadow_ret_tag = 0;
+alignas(16) thread_local uptr __nsan_shadow_ret_tag = 0;
SANITIZER_INTERFACE_ATTRIBUTE
-ALIGNED(16)
-THREADLOCAL
-char __nsan_shadow_ret_ptr[kMaxVectorWidth * sizeof(__float128)];
+alignas(16) thread_local char __nsan_shadow_ret_ptr[kMaxVectorWidth *
+ sizeof(__float128)];
SANITIZER_INTERFACE_ATTRIBUTE
-ALIGNED(16)
-THREADLOCAL
-uptr __nsan_shadow_args_tag = 0;
+alignas(16) thread_local uptr __nsan_shadow_args_tag = 0;
// Maximum number of args. This should be enough for anyone (tm). An alternate
// scheme is to have the generated code create an alloca and make
// __nsan_shadow_args_ptr point ot the alloca.
constexpr const int kMaxNumArgs = 128;
SANITIZER_INTERFACE_ATTRIBUTE
-ALIGNED(16)
-THREADLOCAL
-char __nsan_shadow_args_ptr[kMaxVectorWidth * kMaxNumArgs * sizeof(__float128)];
+alignas(
+ 16) thread_local char __nsan_shadow_args_ptr[kMaxVectorWidth * kMaxNumArgs *
+ sizeof(__float128)];
enum ContinuationType { // Keep in sync with instrumentation pass.
kContinueWithShadow = 0,
@@ -428,36 +419,36 @@ enum ContinuationType { // Keep in sync with instrumentation pass.
// rather than the shadow value. This prevents one error to propagate to all
// subsequent operations. This behaviour is tunable with flags.
template <typename FT, typename ShadowFT>
-int32_t checkFT(const FT Value, ShadowFT Shadow, CheckTypeT CheckType,
+int32_t checkFT(const FT value, ShadowFT Shadow, CheckTypeT CheckType,
uptr CheckArg) {
// We do all comparisons in the InternalFT domain, which is the largest FT
// type.
using InternalFT = LargestFT<FT, ShadowFT>;
- const InternalFT CheckValue = Value;
- const InternalFT CheckShadow = Shadow;
+ const InternalFT check_value = value;
+ const InternalFT check_shadow = Shadow;
// See this article for an interesting discussion of how to compare floats:
// https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
static constexpr const FT Eps = FTInfo<FT>::kEpsilon;
- const InternalFT AbsErr = ftAbs(CheckValue - CheckShadow);
+ const InternalFT abs_err = ftAbs(check_value - check_shadow);
if (flags().enable_check_stats) {
GET_CALLER_PC_BP;
- // We are re-computing `Largest` here because this is a cold branch, and we
- // want to avoid having to move the computation of `Largest` before the
+ // We are re-computing `largest` here because this is a cold branch, and we
+ // want to avoid having to move the computation of `largest` before the
// absolute value check when this branch is not taken.
- const InternalFT Largest = max(ftAbs(CheckValue), ftAbs(CheckShadow));
- nsan_stats->addCheck(CheckType, pc, bp, AbsErr / Largest);
+ const InternalFT largest = max(ftAbs(check_value), ftAbs(check_shadow));
+ nsan_stats->AddCheck(CheckType, pc, bp, abs_err / largest);
}
- // Note: writing the comparison that way ensures that when `AbsErr` is Nan
+ // Note: writing the comparison that way ensures that when `abs_err` is Nan
// (value and shadow are inf or -inf), we pass the test.
- if (!(AbsErr >= flags().cached_absolute_error_threshold))
+ if (!(abs_err >= flags().cached_absolute_error_threshold))
return kContinueWithShadow;
- const InternalFT Largest = max(ftAbs(CheckValue), ftAbs(CheckShadow));
- if (AbsErr * (1ull << flags().log2_max_relative_error) <= Largest)
+ const InternalFT largest = max(ftAbs(check_value), ftAbs(check_shadow));
+ if (abs_err * (1ull << flags().log2_max_relative_error) <= largest)
return kContinueWithShadow; // No problem here.
if (!flags().disable_warnings) {
@@ -474,22 +465,22 @@ int32_t checkFT(const FT Value, ShadowFT Shadow, CheckTypeT CheckType,
Printf("%s", D.Warning());
// Printf does not support float formatting.
char RelErrBuf[64] = "inf";
- if (Largest > Eps) {
+ if (largest > Eps) {
snprintf(RelErrBuf, sizeof(RelErrBuf) - 1, "%.20Lf%% (2^%.0Lf epsilons)",
- static_cast<long double>(100.0 * AbsErr / Largest),
- log2l(static_cast<long double>(AbsErr / Largest / Eps)));
+ static_cast<long double>(100.0 * abs_err / largest),
+ log2l(static_cast<long double>(abs_err / largest / Eps)));
}
- char UlpErrBuf[128] = "";
- const double ShadowUlpDiff = getULPDiff(CheckValue, CheckShadow);
- if (ShadowUlpDiff != kMaxULPDiff) {
+ char ulp_err_buf[128] = "";
+ const double shadow_ulp_
diff = GetULPDiff(check_value, check_shadow);
+ if (shadow_ulp_
diff != kMaxULPDiff) {
// This is the ULP
diff in the internal domain. The user actually cares
// about that in the original domain.
- const double UlpDiff =
- ShadowUlpDiff / (u64{1} << (FTInfo<InternalFT>::kMantissaBits -
- FTInfo<FT>::kMantissaBits));
- snprintf(UlpErrBuf, sizeof(UlpErrBuf) - 1,
- "(%.0f ULPs == %.1f digits == %.1f bits)", UlpDiff,
- log10(UlpDiff), log2(UlpDiff));
+ const double ulp_
diff =
+ shadow_ulp_
diff / (u64{1} << (FTInfo<InternalFT>::kMantissaBits -
+ FTInfo<FT>::kMantissaBits));
+ snprintf(ulp_err_buf, sizeof(ulp_err_buf) - 1,
+ "(%.0f ULPs == %.1f digits == %.1f bits)", ulp_
diff ,
+ log10(ulp_
diff ), log2(ulp_
diff ));
}
Printf("WARNING: NumericalStabilitySanitizer: inconsistent shadow results");
switch (CheckType) {
@@ -529,18 +520,18 @@ int32_t checkFT(const FT Value, ShadowFT Shadow, CheckTypeT CheckType,
"Relative error: %s\n"
"Absolute error: %s\n"
"%s\n",
- FTInfo<FT>::kCppTypeName, ValuePrinter::dec(Value).Buffer,
- ValuePrinter::hex(Value).Buffer, FTInfo<ShadowFT>::kCppTypeName,
+ FTInfo<FT>::kCppTypeName, ValuePrinter::dec(value).Buffer,
+ ValuePrinter::hex(value).Buffer, FTInfo<ShadowFT>::kCppTypeName,
ShadowPrinter::dec(Shadow).Buffer, ShadowPrinter::hex(Shadow).Buffer,
FTInfo<FT>::kCppTypeName, ValuePrinter::dec(Shadow).Buffer,
ValuePrinter::hex(Shadow).Buffer, RelErrBuf,
- ValuePrinter::hex(AbsErr).Buffer, UlpErrBuf);
+ ValuePrinter::hex(abs_err).Buffer, ulp_err_buf);
stack.Print();
}
if (flags().enable_warning_stats) {
GET_CALLER_PC_BP;
- nsan_stats->addWarning(CheckType, pc, bp, AbsErr / Largest);
+ nsan_stats->AddWarning(CheckType, pc, bp, abs_err / largest);
}
if (flags().halt_on_error) {
@@ -571,10 +562,10 @@ __nsan_internal_check_longdouble_q(long double value, __float128 shadow,
return checkFT(value, shadow, static_cast<CheckTypeT>(check_type), check_arg);
}
-static const char *getTruthValueName(bool v) { return v ? "true" : "false"; }
+static const char *GetTruthValueName(bool v) { return v ? "true" : "false"; }
// This uses the same values as CmpInst::Predicate.
-static const char *getPredicateName(int v) {
+static const char *GetPredicateName(int v) {
switch (v) {
case 0:
return "(false)";
@@ -614,9 +605,9 @@ static const char *getPredicateName(int v) {
template <typename FT, typename ShadowFT>
void fCmpFailFT(const FT Lhs, const FT Rhs, ShadowFT LhsShadow,
- ShadowFT RhsShadow, int Predicate, bool Result,
+ ShadowFT RhsShadow, int Predicate, bool result,
bool ShadowResult) {
- if (Result == ShadowResult) {
+ if (result == ShadowResult) {
// When a vector comparison fails, we fail each element of the comparison
// to simplify instrumented code. Skip elements where the shadow comparison
// gave the same result as the original one.
@@ -624,21 +615,19 @@ void fCmpFailFT(const FT Lhs, const FT Rhs, ShadowFT LhsShadow,
}
GET_CALLER_PC_BP;
- BufferedStackTrace Stack;
- Stack.Unwind(pc, bp, nullptr, false);
+ BufferedStackTrace stack;
+ stack.Unwind(pc, bp, nullptr, false);
- if (GetSuppressionForStack(&Stack, CheckKind::Fcmp)) {
+ if (GetSuppressionForStack(&stack, CheckKind::Fcmp)) {
// FIXME: optionally print.
return;
}
- if (flags().enable_warning_stats) {
- nsan_stats->addWarning(CheckTypeT::kFcmp, pc, bp, 0.0);
- }
+ if (flags().enable_warning_stats)
+ nsan_stats->AddWarning(CheckTypeT::kFcmp, pc, bp, 0.0);
- if (flags().disable_warnings) {
+ if (flags().disable_warnings)
return;
- }
// FIXME: ideally we would print the shadow value as FP128. Right now because
// we truncate to long double we can sometimes see stuff like:
@@ -646,7 +635,7 @@ void fCmpFailFT(const FT Lhs, const FT Rhs, ShadowFT LhsShadow,
using ValuePrinter = FTPrinter<FT>;
using ShadowPrinter = FTPrinter<ShadowFT>;
Decorator D;
- const char *const PredicateName = getPredicateName(Predicate);
+ const char *const PredicateName = GetPredicateName(Predicate);
Printf("%s", D.Warning());
Printf("WARNING: NumericalStabilitySanitizer: floating-point comparison "
"results depend on precision\n"
@@ -657,20 +646,20 @@ void fCmpFailFT(const FT Lhs, const FT Rhs, ShadowFT LhsShadow,
"%s",
// Native, decimal.
FTInfo<FT>::kCppTypeName, ValuePrinter::dec(Lhs).Buffer, PredicateName,
- ValuePrinter::dec(Rhs).Buffer, getTruthValueName(Result),
+ ValuePrinter::dec(Rhs).Buffer, GetTruthValueName(result),
// Shadow, decimal
FTInfo<ShadowFT>::kCppTypeName, ShadowPrinter::dec(LhsShadow).Buffer,
PredicateName, ShadowPrinter::dec(RhsShadow).Buffer,
- getTruthValueName(ShadowResult),
+ GetTruthValueName(ShadowResult),
// Native, hex.
FTInfo<FT>::kCppTypeName, ValuePrinter::hex(Lhs).Buffer, PredicateName,
- ValuePrinter::hex(Rhs).Buffer, getTruthValueName(Result),
+ ValuePrinter::hex(Rhs).Buffer, GetTruthValueName(result),
// Shadow, hex
FTInfo<ShadowFT>::kCppTypeName, ShadowPrinter::hex(LhsShadow).Buffer,
PredicateName, ShadowPrinter::hex(RhsShadow).Buffer,
- getTruthValueName(ShadowResult), D.End());
+ GetTruthValueName(ShadowResult), D.End());
Printf("%s", D.Default());
- Stack.Print();
+ stack.Print();
if (flags().halt_on_error) {
Printf("Exiting\n");
Die();
@@ -709,77 +698,77 @@ __nsan_fcmp_fail_longdouble_q(long double lhs, long double rhs,
shadow_result);
}
-template <typename FT> void checkFTFromShadowStack(const FT Value) {
+template <typename FT> void checkFTFromShadowStack(const FT value) {
// Get the shadow 2FT value from the shadow stack. Note that
// __nsan_check_{float,double,long double} is a function like any other, so
// the instrumentation will have placed the shadow value on the shadow stack.
using ShadowFT = typename FTInfo<FT>::shadow_type;
ShadowFT Shadow;
__builtin_memcpy(&Shadow, __nsan_shadow_args_ptr, sizeof(ShadowFT));
- checkFT(Value, Shadow, CheckTypeT::kUser, 0);
+ checkFT(value, Shadow, CheckTypeT::kUser, 0);
}
// FIXME: Add suffixes and let the instrumentation pass automatically add
// suffixes.
-extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_check_float(float Value) {
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_check_float(float value) {
assert(__nsan_shadow_args_tag == (uptr)&__nsan_check_float &&
"__nsan_check_float called from non-instrumented function");
- checkFTFromShadowStack(Value);
+ checkFTFromShadowStack(value);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
-__nsan_check_double(double Value) {
+__nsan_check_double(double value) {
assert(__nsan_shadow_args_tag == (uptr)&__nsan_check_double &&
"__nsan_check_double called from non-instrumented function");
- checkFTFromShadowStack(Value);
+ checkFTFromShadowStack(value);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
-__nsan_check_longdouble(long double Value) {
+__nsan_check_longdouble(long double value) {
assert(__nsan_shadow_args_tag == (uptr)&__nsan_check_longdouble &&
"__nsan_check_longdouble called from non-instrumented function");
- checkFTFromShadowStack(Value);
+ checkFTFromShadowStack(value);
}
-template <typename FT> static void dumpFTFromShadowStack(const FT Value) {
+template <typename FT> static void dumpFTFromShadowStack(const FT value) {
// Get the shadow 2FT value from the shadow stack. Note that
// __nsan_dump_{float,double,long double} is a function like any other, so
// the instrumentation will have placed the shadow value on the shadow stack.
using ShadowFT = typename FTInfo<FT>::shadow_type;
- ShadowFT Shadow;
- __builtin_memcpy(&Shadow, __nsan_shadow_args_ptr, sizeof(ShadowFT));
+ ShadowFT shadow;
+ __builtin_memcpy(&shadow, __nsan_shadow_args_ptr, sizeof(ShadowFT));
using ValuePrinter = FTPrinter<FT>;
using ShadowPrinter = FTPrinter<typename FTInfo<FT>::shadow_type>;
printf("value dec:%s hex:%s\n"
"shadow dec:%s hex:%s\n",
- ValuePrinter::dec(Value).Buffer, ValuePrinter::hex(Value).Buffer,
- ShadowPrinter::dec(Shadow).Buffer, ShadowPrinter::hex(Shadow).Buffer);
+ ValuePrinter::dec(value).Buffer, ValuePrinter::hex(value).Buffer,
+ ShadowPrinter::dec(shadow).Buffer, ShadowPrinter::hex(shadow).Buffer);
}
-extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_dump_float(float Value) {
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_dump_float(float value) {
assert(__nsan_shadow_args_tag == (uptr)&__nsan_dump_float &&
"__nsan_dump_float called from non-instrumented function");
- dumpFTFromShadowStack(Value);
+ dumpFTFromShadowStack(value);
}
-extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_dump_double(double Value) {
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_dump_double(double value) {
assert(__nsan_shadow_args_tag == (uptr)&__nsan_dump_double &&
"__nsan_dump_double called from non-instrumented function");
- dumpFTFromShadowStack(Value);
+ dumpFTFromShadowStack(value);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
-__nsan_dump_longdouble(long double Value) {
+__nsan_dump_longdouble(long double value) {
assert(__nsan_shadow_args_tag == (uptr)&__nsan_dump_longdouble &&
"__nsan_dump_longdouble called from non-instrumented function");
- dumpFTFromShadowStack(Value);
+ dumpFTFromShadowStack(value);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_dump_shadow_ret() {
printf("ret tag: %lx\n", __nsan_shadow_ret_tag);
- double V;
- __builtin_memcpy(&V, __nsan_shadow_ret_ptr, sizeof(double));
- printf("double Value: %f\n", V);
+ double v;
+ __builtin_memcpy(&v, __nsan_shadow_ret_ptr, sizeof(double));
+ printf("double value: %f\n", v);
// FIXME: float128 value.
}
@@ -787,16 +776,14 @@ extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_dump_shadow_args() {
printf("args tag: %lx\n", __nsan_shadow_args_tag);
}
-namespace __nsan {
-bool NsanInitialized = false;
-bool NsanInitIsRunning;
-} // end namespace __nsan
+bool __nsan::nsan_initialized;
+bool __nsan::nsan_init_is_running;
extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_init() {
- CHECK(!NsanInitIsRunning);
- if (NsanInitialized)
+ CHECK(!nsan_init_is_running);
+ if (nsan_initialized)
return;
- NsanInitIsRunning = true;
+ nsan_init_is_running = true;
InitializeFlags();
InitializeSuppressions();
@@ -805,14 +792,14 @@ extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_init() {
if (!MmapFixedNoReserve(TypesAddr(), UnusedAddr() - TypesAddr()))
Die();
- initializeInterceptors();
+ InitializeInterceptors();
- initializeStats();
+ InitializeStats();
if (flags().print_stats_on_exit)
- Atexit(nsanAtexit);
+ Atexit(NsanAtexit);
- NsanInitIsRunning = false;
- NsanInitialized = true;
+ nsan_init_is_running = false;
+ nsan_initialized = true;
}
#if SANITIZER_CAN_USE_PREINIT_ARRAY
diff --git a/compiler-rt/lib/nsan/nsan.h b/compiler-rt/lib/nsan/nsan.h
index 6ab64d3aecb38..896e5379dfc37 100644
--- a/compiler-rt/lib/nsan/nsan.h
+++ b/compiler-rt/lib/nsan/nsan.h
@@ -51,32 +51,32 @@ __nsan_default_options();
namespace __nsan {
-extern bool NsanInitialized;
-extern bool NsanInitIsRunning;
+extern bool nsan_initialized;
+extern bool nsan_init_is_running;
-void initializeInterceptors();
+void InitializeInterceptors();
// See notes in nsan_platform.
// printf-free (see comment in nsan_interceptors.cc).
-inline u8 *getShadowAddrFor(u8 *Ptr) {
+inline u8 *GetShadowAddrFor(u8 *Ptr) {
uptr AppOffset = ((uptr)Ptr) & ShadowMask();
return (u8 *)(AppOffset * kShadowScale + ShadowAddr());
}
// printf-free (see comment in nsan_interceptors.cc).
-inline const u8 *getShadowAddrFor(const u8 *Ptr) {
- return getShadowAddrFor(const_cast<u8 *>(Ptr));
+inline const u8 *GetShadowAddrFor(const u8 *Ptr) {
+ return GetShadowAddrFor(const_cast<u8 *>(Ptr));
}
// printf-free (see comment in nsan_interceptors.cc).
-inline u8 *getShadowTypeAddrFor(u8 *Ptr) {
+inline u8 *GetShadowTypeAddrFor(u8 *Ptr) {
uptr AppOffset = ((uptr)Ptr) & ShadowMask();
return (u8 *)(AppOffset + TypesAddr());
}
// printf-free (see comment in nsan_interceptors.cc).
-inline const u8 *getShadowTypeAddrFor(const u8 *Ptr) {
- return getShadowTypeAddrFor(const_cast<u8 *>(Ptr));
+inline const u8 *GetShadowTypeAddrFor(const u8 *Ptr) {
+ return GetShadowTypeAddrFor(const_cast<u8 *>(Ptr));
}
// Information about value types and their shadow counterparts.
@@ -164,60 +164,60 @@ template <> struct FTInfo<__float128> {
constexpr double kMaxULPDiff = INFINITY;
// Helper for getULPDiff that works on bit representations.
-template <typename BT> double getULPDiffBits(BT V1Bits, BT V2Bits) {
+template <typename BT> double GetULPDiffBits(BT v1_bits, BT v2_bits) {
// If the integer representations of two same-sign floats are subtracted then
// the absolute value of the result is equal to one plus the number of
// representable floats between them.
- return V1Bits >= V2Bits ? V1Bits - V2Bits : V2Bits - V1Bits;
+ return v1_bits >= v2_bits ? v1_bits - v2_bits : v2_bits - v1_bits;
}
-// Returns the the number of floating point values between V1 and V2, capped to
+// Returns the the number of floating point values between v1 and v2, capped to
// u64max. Return 0 for (-0.0,0.0).
-template <typename FT> double getULPDiff(FT V1, FT V2) {
- if (V1 == V2) {
+template <typename FT> double GetULPDiff(FT v1, FT v2) {
+ if (v1 == v2) {
return 0; // Typically, -0.0 and 0.0
}
using BT = typename FTInfo<FT>::orig_bits_type;
static_assert(sizeof(FT) == sizeof(BT), "not implemented");
static_assert(sizeof(BT) <= 64, "not implemented");
- BT V1Bits;
- __builtin_memcpy(&V1Bits, &V1, sizeof(BT));
- BT V2Bits;
- __builtin_memcpy(&V2Bits, &V2, sizeof(BT));
+ BT v1_bits;
+ __builtin_memcpy(&v1_bits, &v1, sizeof(BT));
+ BT v2_bits;
+ __builtin_memcpy(&v2_bits, &v2, sizeof(BT));
// Check whether the signs
diff er. IEEE-754 float types always store the sign
// in the most significant bit. NaNs and infinities are handled by the calling
// code.
constexpr BT kSignMask = BT{1} << (CHAR_BIT * sizeof(BT) - 1);
- if ((V1Bits ^ V2Bits) & kSignMask) {
+ if ((v1_bits ^ v2_bits) & kSignMask) {
// Signs
diff er. We can get the ULPs as `getULPDiff(negative_number, -0.0)
// + getULPDiff(0.0, positive_number)`.
- if (V1Bits & kSignMask) {
- return getULPDiffBits<BT>(V1Bits, kSignMask) +
- getULPDiffBits<BT>(0, V2Bits);
+ if (v1_bits & kSignMask) {
+ return GetULPDiffBits<BT>(v1_bits, kSignMask) +
+ GetULPDiffBits<BT>(0, v2_bits);
} else {
- return getULPDiffBits<BT>(V2Bits, kSignMask) +
- getULPDiffBits<BT>(0, V1Bits);
+ return GetULPDiffBits<BT>(v2_bits, kSignMask) +
+ GetULPDiffBits<BT>(0, v1_bits);
}
}
- return getULPDiffBits(V1Bits, V2Bits);
+ return GetULPDiffBits(v1_bits, v2_bits);
}
// FIXME: This needs mor work: Because there is no 80-bit integer type, we have
// to go through __uint128_t. Therefore the assumptions about the sign bit do
// not hold.
-template <> inline double getULPDiff(long double V1, long double V2) {
+template <> inline double GetULPDiff(long double v1, long double v2) {
using BT = __uint128_t;
- BT V1Bits = 0;
- __builtin_memcpy(&V1Bits, &V1, sizeof(long double));
- BT V2Bits = 0;
- __builtin_memcpy(&V2Bits, &V2, sizeof(long double));
- if ((V1Bits ^ V2Bits) & (BT{1} << (CHAR_BIT * sizeof(BT) - 1)))
- return (V1 == V2) ? __sanitizer::u64{0} : kMaxULPDiff; // Signs
diff er.
+ BT v1_bits = 0;
+ __builtin_memcpy(&v1_bits, &v1, sizeof(long double));
+ BT v2_bits = 0;
+ __builtin_memcpy(&v2_bits, &v2, sizeof(long double));
+ if ((v1_bits ^ v2_bits) & (BT{1} << (CHAR_BIT * sizeof(BT) - 1)))
+ return v1 == v2 ? __sanitizer::u64{0} : kMaxULPDiff; // Signs
diff er.
// If the integer representations of two same-sign floats are subtracted then
// the absolute value of the result is equal to one plus the number of
// representable floats between them.
- BT Diff = V1Bits >= V2Bits ? V1Bits - V2Bits : V2Bits - V1Bits;
- return Diff >= kMaxULPDiff ? kMaxULPDiff : Diff;
+ BT
diff = v1_bits >= v2_bits ? v1_bits - v2_bits : v2_bits - v1_bits;
+ return
diff >= kMaxULPDiff ? kMaxULPDiff :
diff ;
}
} // end namespace __nsan
diff --git a/compiler-rt/lib/nsan/nsan_flags.cc b/compiler-rt/lib/nsan/nsan_flags.cpp
similarity index 95%
rename from compiler-rt/lib/nsan/nsan_flags.cc
rename to compiler-rt/lib/nsan/nsan_flags.cpp
index 09a9dad7ce041..94e3a187c8e6c 100644
--- a/compiler-rt/lib/nsan/nsan_flags.cc
+++ b/compiler-rt/lib/nsan/nsan_flags.cpp
@@ -15,15 +15,14 @@
#include "sanitizer_common/sanitizer_flag_parser.h"
#include "sanitizer_common/sanitizer_flags.h"
-namespace __nsan {
+using namespace __sanitizer;
+using namespace __nsan;
SANITIZER_INTERFACE_WEAK_DEF(const char *, __nsan_default_options, void) {
return "";
}
-using namespace __sanitizer;
-
-Flags flags_data;
+Flags __nsan::flags_data;
void Flags::SetDefaults() {
#define NSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
@@ -47,7 +46,7 @@ static const char *MaybeCallNsanDefaultOptions() {
return (&__nsan_default_options) ? __nsan_default_options() : "";
}
-void InitializeFlags() {
+void __nsan::InitializeFlags() {
SetCommonFlagsDefaults();
{
CommonFlags cf;
@@ -74,5 +73,3 @@ void InitializeFlags() {
flags().PopulateCache();
}
-
-} // namespace __nsan
diff --git a/compiler-rt/lib/nsan/nsan_interceptors.cc b/compiler-rt/lib/nsan/nsan_interceptors.cc
deleted file mode 100644
index 394d788888268..0000000000000
--- a/compiler-rt/lib/nsan/nsan_interceptors.cc
+++ /dev/null
@@ -1,364 +0,0 @@
-//===-- nsan_interceptors.cc ----------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Interceptors for standard library functions.
-//
-// A note about `printf`: Make sure none of the interceptor code calls any
-// part of the nsan framework that can call `printf`, since this could create
-// a loop (`printf` itself uses the libc). printf-free functions are documented
-// as such in nsan.h.
-//
-//===----------------------------------------------------------------------===//
-
-#include "interception/interception.h"
-#include "nsan/nsan.h"
-#include "sanitizer_common/sanitizer_common.h"
-
-#include <wchar.h>
-
-#if SANITIZER_LINUX
-extern "C" int mallopt(int param, int value);
-#endif
-
-using namespace __sanitizer;
-using __nsan::NsanInitialized;
-using __nsan::NsanInitIsRunning;
-
-static constexpr uptr kEarlyAllocBufSize = 16384;
-static uptr AllocatedBytes;
-static char EarlyAllocBuf[kEarlyAllocBufSize];
-
-static bool isInEarlyAllocBuf(const void *Ptr) {
- return ((uptr)Ptr >= (uptr)EarlyAllocBuf &&
- ((uptr)Ptr - (uptr)EarlyAllocBuf) < sizeof(EarlyAllocBuf));
-}
-
-static u8 *toU8Ptr(wchar_t *ptr) { return reinterpret_cast<u8 *>(ptr); }
-
-static const u8 *toU8Ptr(const wchar_t *ptr) {
- return reinterpret_cast<const u8 *>(ptr);
-}
-
-template <typename T> T min(T a, T b) { return a < b ? a : b; }
-
-// Handle allocation requests early (before all interceptors are setup). dlsym,
-// for example, calls calloc.
-static void *handleEarlyAlloc(uptr Size) {
- void *Mem = (void *)&EarlyAllocBuf[AllocatedBytes];
- AllocatedBytes += Size;
- CHECK_LT(AllocatedBytes, kEarlyAllocBufSize);
- return Mem;
-}
-
-INTERCEPTOR(void *, memset, void *Dst, int V, uptr Size) {
- // NOTE: This guard is needed because nsan's initialization code might call
- // memset.
- if (!NsanInitialized && REAL(memset) == nullptr)
- return internal_memset(Dst, V, Size);
-
- void *Res = REAL(memset)(Dst, V, Size);
- __nsan_set_value_unknown(static_cast<u8 *>(Dst), Size);
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wmemset, wchar_t *Dst, wchar_t V, uptr Size) {
- wchar_t *Res = REAL(wmemset)(Dst, V, Size);
- __nsan_set_value_unknown(toU8Ptr(Dst), sizeof(wchar_t) * Size);
- return Res;
-}
-
-INTERCEPTOR(void *, memmove, void *Dst, const void *Src, uptr Size) {
- // NOTE: This guard is needed because nsan's initialization code might call
- // memmove.
- if (!NsanInitialized && REAL(memmove) == nullptr)
- return internal_memmove(Dst, Src, Size);
-
- void *Res = REAL(memmove)(Dst, Src, Size);
- __nsan_copy_values(static_cast<u8 *>(Dst), static_cast<const u8 *>(Src),
- Size);
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wmemmove, wchar_t *Dst, const wchar_t *Src, uptr Size) {
- wchar_t *Res = REAL(wmemmove)(Dst, Src, Size);
- __nsan_copy_values(toU8Ptr(Dst), toU8Ptr(Src), sizeof(wchar_t) * Size);
- return Res;
-}
-
-INTERCEPTOR(void *, memcpy, void *Dst, const void *Src, uptr Size) {
- // NOTE: This guard is needed because nsan's initialization code might call
- // memcpy.
- if (!NsanInitialized && REAL(memcpy) == nullptr) {
- // memmove is used here because on some platforms this will also
- // intercept the memmove implementation.
- return internal_memmove(Dst, Src, Size);
- }
-
- void *Res = REAL(memcpy)(Dst, Src, Size);
- __nsan_copy_values(static_cast<u8 *>(Dst), static_cast<const u8 *>(Src),
- Size);
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wmemcpy, wchar_t *Dst, const wchar_t *Src, uptr Size) {
- wchar_t *Res = REAL(wmemcpy)(Dst, Src, Size);
- __nsan_copy_values(toU8Ptr(Dst), toU8Ptr(Src), sizeof(wchar_t) * Size);
- return Res;
-}
-
-INTERCEPTOR(void *, malloc, uptr Size) {
- // NOTE: This guard is needed because nsan's initialization code might call
- // malloc.
- if (NsanInitIsRunning && REAL(malloc) == nullptr)
- return handleEarlyAlloc(Size);
-
- void *Res = REAL(malloc)(Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(void *, realloc, void *Ptr, uptr Size) {
- void *Res = REAL(realloc)(Ptr, Size);
- // FIXME: We might want to copy the types from the original allocation
- // (although that would require that we know its size).
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(void *, calloc, uptr Nmemb, uptr Size) {
- // NOTE: This guard is needed because nsan's initialization code might call
- // calloc.
- if (NsanInitIsRunning && REAL(calloc) == nullptr) {
- // Note: EarlyAllocBuf is initialized with zeros.
- return handleEarlyAlloc(Nmemb * Size);
- }
-
- void *Res = REAL(calloc)(Nmemb, Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Nmemb * Size);
- return Res;
-}
-
-INTERCEPTOR(void, free, void *P) {
- // There are only a few early allocation requests, so we simply skip the free.
- if (isInEarlyAllocBuf(P))
- return;
- REAL(free)(P);
-}
-
-INTERCEPTOR(void *, valloc, uptr Size) {
- void *const Res = REAL(valloc)(Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(void *, memalign, uptr Alignment, uptr Size) {
- void *const Res = REAL(memalign)(Alignment, Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(void *, __libc_memalign, uptr Alignment, uptr Size) {
- void *const Res = REAL(__libc_memalign)(Alignment, Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(void *, pvalloc, uptr Size) {
- void *const Res = REAL(pvalloc)(Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(void *, aligned_alloc, uptr Alignment, uptr Size) {
- void *const Res = REAL(aligned_alloc)(Alignment, Size);
- if (Res)
- __nsan_set_value_unknown(static_cast<u8 *>(Res), Size);
- return Res;
-}
-
-INTERCEPTOR(int, posix_memalign, void **Memptr, uptr Alignment, uptr Size) {
- int Res = REAL(posix_memalign)(Memptr, Alignment, Size);
- if (Res == 0 && *Memptr)
- __nsan_set_value_unknown(static_cast<u8 *>(*Memptr), Size);
- return Res;
-}
-
-INTERCEPTOR(char *, strfry, char *S) {
- const auto Len = internal_strlen(S);
- char *Res = REAL(strfry)(S);
- if (Res)
- __nsan_set_value_unknown(reinterpret_cast<u8 *>(S), Len);
- return Res;
-}
-
-INTERCEPTOR(char *, strsep, char **Stringp, const char *Delim) {
- char *OrigStringp = REAL(strsep)(Stringp, Delim);
- if (Stringp != nullptr) {
- // The previous character has been overwritten with a '\0' char.
- __nsan_set_value_unknown(reinterpret_cast<u8 *>(*Stringp) - 1, 1);
- }
- return OrigStringp;
-}
-
-INTERCEPTOR(char *, strtok, char *Str, const char *Delim) {
- // This is overly conservative, but the probability that modern code is using
- // strtok on double data is essentially zero anyway.
- if (Str)
- __nsan_set_value_unknown(reinterpret_cast<u8 *>(Str), internal_strlen(Str));
- return REAL(strtok)(Str, Delim);
-}
-
-static void nsanCopyZeroTerminated(char *Dst, const char *Src, uptr N) {
- __nsan_copy_values(reinterpret_cast<u8 *>(Dst),
- reinterpret_cast<const u8 *>(Src), N); // Data.
- __nsan_set_value_unknown(reinterpret_cast<u8 *>(Dst) + N, 1); // Terminator.
-}
-
-static void nsanWCopyZeroTerminated(wchar_t *Dst, const wchar_t *Src, uptr N) {
- __nsan_copy_values(toU8Ptr(Dst), toU8Ptr(Src), sizeof(wchar_t) * N);
- __nsan_set_value_unknown(toU8Ptr(Dst + N), sizeof(wchar_t));
-}
-
-INTERCEPTOR(char *, strdup, const char *S) {
- char *Res = REAL(strdup)(S);
- if (Res) {
- nsanCopyZeroTerminated(Res, S, internal_strlen(S));
- }
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wcsdup, const wchar_t *S) {
- wchar_t *Res = REAL(wcsdup)(S);
- if (Res) {
- nsanWCopyZeroTerminated(Res, S, wcslen(S));
- }
- return Res;
-}
-
-INTERCEPTOR(char *, strndup, const char *S, uptr Size) {
- char *Res = REAL(strndup)(S, Size);
- if (Res) {
- nsanCopyZeroTerminated(Res, S, min(internal_strlen(S), Size));
- }
- return Res;
-}
-
-INTERCEPTOR(char *, strcpy, char *Dst, const char *Src) {
- char *Res = REAL(strcpy)(Dst, Src);
- nsanCopyZeroTerminated(Dst, Src, internal_strlen(Src));
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wcscpy, wchar_t *Dst, const wchar_t *Src) {
- wchar_t *Res = REAL(wcscpy)(Dst, Src);
- nsanWCopyZeroTerminated(Dst, Src, wcslen(Src));
- return Res;
-}
-
-INTERCEPTOR(char *, strncpy, char *Dst, const char *Src, uptr Size) {
- char *Res = REAL(strncpy)(Dst, Src, Size);
- nsanCopyZeroTerminated(Dst, Src, min(Size, internal_strlen(Src)));
- return Res;
-}
-
-INTERCEPTOR(char *, strcat, char *Dst, const char *Src) {
- const auto DstLenBeforeCat = internal_strlen(Dst);
- char *Res = REAL(strcat)(Dst, Src);
- nsanCopyZeroTerminated(Dst + DstLenBeforeCat, Src, internal_strlen(Src));
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wcscat, wchar_t *Dst, const wchar_t *Src) {
- const auto DstLenBeforeCat = wcslen(Dst);
- wchar_t *Res = REAL(wcscat)(Dst, Src);
- nsanWCopyZeroTerminated(Dst + DstLenBeforeCat, Src, wcslen(Src));
- return Res;
-}
-
-INTERCEPTOR(char *, strncat, char *Dst, const char *Src, uptr Size) {
- const auto DstLen = internal_strlen(Dst);
- char *Res = REAL(strncat)(Dst, Src, Size);
- nsanCopyZeroTerminated(Dst + DstLen, Src, min(Size, internal_strlen(Src)));
- return Res;
-}
-
-INTERCEPTOR(char *, stpcpy, char *Dst, const char *Src) {
- char *Res = REAL(stpcpy)(Dst, Src);
- nsanCopyZeroTerminated(Dst, Src, internal_strlen(Src));
- return Res;
-}
-
-INTERCEPTOR(wchar_t *, wcpcpy, wchar_t *Dst, const wchar_t *Src) {
- wchar_t *Res = REAL(wcpcpy)(Dst, Src);
- nsanWCopyZeroTerminated(Dst, Src, wcslen(Src));
- return Res;
-}
-
-INTERCEPTOR(uptr, strxfrm, char *Dst, const char *Src, uptr Size) {
- // This is overly conservative, but this function should very rarely be used.
- __nsan_set_value_unknown(reinterpret_cast<u8 *>(Dst), internal_strlen(Dst));
- const uptr Res = REAL(strxfrm)(Dst, Src, Size);
- return Res;
-}
-
-namespace __nsan {
-void initializeInterceptors() {
- static bool Initialized = false;
- CHECK(!Initialized);
-
- // Instruct libc malloc to consume less memory.
-#if SANITIZER_LINUX
- mallopt(1, 0); // M_MXFAST
- mallopt(-3, 32 * 1024); // M_MMAP_THRESHOLD
-#endif
-
- INTERCEPT_FUNCTION(malloc);
- INTERCEPT_FUNCTION(calloc);
- INTERCEPT_FUNCTION(free);
- INTERCEPT_FUNCTION(realloc);
- INTERCEPT_FUNCTION(valloc);
- INTERCEPT_FUNCTION(memalign);
- INTERCEPT_FUNCTION(__libc_memalign);
- INTERCEPT_FUNCTION(pvalloc);
- INTERCEPT_FUNCTION(aligned_alloc);
- INTERCEPT_FUNCTION(posix_memalign);
-
- INTERCEPT_FUNCTION(memset);
- INTERCEPT_FUNCTION(wmemset);
- INTERCEPT_FUNCTION(memmove);
- INTERCEPT_FUNCTION(wmemmove);
- INTERCEPT_FUNCTION(memcpy);
- INTERCEPT_FUNCTION(wmemcpy);
-
- INTERCEPT_FUNCTION(strdup);
- INTERCEPT_FUNCTION(wcsdup);
- INTERCEPT_FUNCTION(strndup);
- INTERCEPT_FUNCTION(stpcpy);
- INTERCEPT_FUNCTION(wcpcpy);
- INTERCEPT_FUNCTION(strcpy);
- INTERCEPT_FUNCTION(wcscpy);
- INTERCEPT_FUNCTION(strncpy);
- INTERCEPT_FUNCTION(strcat);
- INTERCEPT_FUNCTION(wcscat);
- INTERCEPT_FUNCTION(strncat);
- INTERCEPT_FUNCTION(strxfrm);
-
- INTERCEPT_FUNCTION(strfry);
- INTERCEPT_FUNCTION(strsep);
- INTERCEPT_FUNCTION(strtok);
-
- Initialized = 1;
-}
-} // end namespace __nsan
diff --git a/compiler-rt/lib/nsan/nsan_interceptors.cpp b/compiler-rt/lib/nsan/nsan_interceptors.cpp
new file mode 100644
index 0000000000000..68127f169ee46
--- /dev/null
+++ b/compiler-rt/lib/nsan/nsan_interceptors.cpp
@@ -0,0 +1,356 @@
+//===-- nsan_interceptors.cc ----------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Interceptors for standard library functions.
+//
+// A note about `printf`: Make sure none of the interceptor code calls any
+// part of the nsan framework that can call `printf`, since this could create
+// a loop (`printf` itself uses the libc). printf-free functions are documented
+// as such in nsan.h.
+//
+//===----------------------------------------------------------------------===//
+
+#include "interception/interception.h"
+#include "nsan/nsan.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+#include <wchar.h>
+
+#if SANITIZER_LINUX
+extern "C" int mallopt(int param, int value);
+#endif
+
+using namespace __sanitizer;
+using __nsan::nsan_init_is_running;
+using __nsan::nsan_initialized;
+
+constexpr uptr kEarlyAllocBufSize = 16384;
+static uptr allocated_bytes;
+static char early_alloc_buf[kEarlyAllocBufSize];
+
+static bool isInEarlyAllocBuf(const void *ptr) {
+ return ((uptr)ptr >= (uptr)early_alloc_buf &&
+ ((uptr)ptr - (uptr)early_alloc_buf) < sizeof(early_alloc_buf));
+}
+
+template <typename T> T min(T a, T b) { return a < b ? a : b; }
+
+// Handle allocation requests early (before all interceptors are setup). dlsym,
+// for example, calls calloc.
+static void *HandleEarlyAlloc(uptr size) {
+ void *Mem = (void *)&early_alloc_buf[allocated_bytes];
+ allocated_bytes += size;
+ CHECK_LT(allocated_bytes, kEarlyAllocBufSize);
+ return Mem;
+}
+
+INTERCEPTOR(void *, memset, void *dst, int v, uptr size) {
+ // NOTE: This guard is needed because nsan's initialization code might call
+ // memset.
+ if (!nsan_initialized && REAL(memset) == nullptr)
+ return internal_memset(dst, v, size);
+
+ void *res = REAL(memset)(dst, v, size);
+ __nsan_set_value_unknown(static_cast<u8 *>(dst), size);
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wmemset, wchar_t *dst, wchar_t v, uptr size) {
+ wchar_t *res = REAL(wmemset)(dst, v, size);
+ __nsan_set_value_unknown((u8 *)dst, sizeof(wchar_t) * size);
+ return res;
+}
+
+INTERCEPTOR(void *, memmove, void *dst, const void *src, uptr size) {
+ // NOTE: This guard is needed because nsan's initialization code might call
+ // memmove.
+ if (!nsan_initialized && REAL(memmove) == nullptr)
+ return internal_memmove(dst, src, size);
+
+ void *res = REAL(memmove)(dst, src, size);
+ __nsan_copy_values(static_cast<u8 *>(dst), static_cast<const u8 *>(src),
+ size);
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wmemmove, wchar_t *dst, const wchar_t *src, uptr size) {
+ wchar_t *res = REAL(wmemmove)(dst, src, size);
+ __nsan_copy_values((u8 *)dst, (const u8 *)src, sizeof(wchar_t) * size);
+ return res;
+}
+
+INTERCEPTOR(void *, memcpy, void *dst, const void *src, uptr size) {
+ // NOTE: This guard is needed because nsan's initialization code might call
+ // memcpy.
+ if (!nsan_initialized && REAL(memcpy) == nullptr) {
+ // memmove is used here because on some platforms this will also
+ // intercept the memmove implementation.
+ return internal_memmove(dst, src, size);
+ }
+
+ void *res = REAL(memcpy)(dst, src, size);
+ __nsan_copy_values(static_cast<u8 *>(dst), static_cast<const u8 *>(src),
+ size);
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wmemcpy, wchar_t *dst, const wchar_t *src, uptr size) {
+ wchar_t *res = REAL(wmemcpy)(dst, src, size);
+ __nsan_copy_values((u8 *)dst, (const u8 *)src, sizeof(wchar_t) * size);
+ return res;
+}
+
+INTERCEPTOR(void *, malloc, uptr size) {
+ // NOTE: This guard is needed because nsan's initialization code might call
+ // malloc.
+ if (nsan_init_is_running && REAL(malloc) == nullptr)
+ return HandleEarlyAlloc(size);
+
+ void *res = REAL(malloc)(size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(void *, realloc, void *ptr, uptr size) {
+ void *res = REAL(realloc)(ptr, size);
+ // FIXME: We might want to copy the types from the original allocation
+ // (although that would require that we know its size).
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(void *, calloc, uptr Nmemb, uptr size) {
+ // NOTE: This guard is needed because nsan's initialization code might call
+ // calloc.
+ if (nsan_init_is_running && REAL(calloc) == nullptr) {
+ // Note: EarlyAllocBuf is initialized with zeros.
+ return HandleEarlyAlloc(Nmemb * size);
+ }
+
+ void *res = REAL(calloc)(Nmemb, size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), Nmemb * size);
+ return res;
+}
+
+INTERCEPTOR(void, free, void *P) {
+ // There are only a few early allocation requests, so we simply skip the free.
+ if (isInEarlyAllocBuf(P))
+ return;
+ REAL(free)(P);
+}
+
+INTERCEPTOR(void *, valloc, uptr size) {
+ void *const res = REAL(valloc)(size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(void *, memalign, uptr align, uptr size) {
+ void *const res = REAL(memalign)(align, size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(void *, __libc_memalign, uptr align, uptr size) {
+ void *const res = REAL(__libc_memalign)(align, size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(void *, pvalloc, uptr size) {
+ void *const res = REAL(pvalloc)(size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(void *, aligned_alloc, uptr align, uptr size) {
+ void *const res = REAL(aligned_alloc)(align, size);
+ if (res)
+ __nsan_set_value_unknown(static_cast<u8 *>(res), size);
+ return res;
+}
+
+INTERCEPTOR(int, posix_memalign, void **memptr, uptr align, uptr size) {
+ int res = REAL(posix_memalign)(memptr, align, size);
+ if (res == 0 && *memptr)
+ __nsan_set_value_unknown(static_cast<u8 *>(*memptr), size);
+ return res;
+}
+
+INTERCEPTOR(char *, strfry, char *s) {
+ const auto Len = internal_strlen(s);
+ char *res = REAL(strfry)(s);
+ if (res)
+ __nsan_set_value_unknown(reinterpret_cast<u8 *>(s), Len);
+ return res;
+}
+
+INTERCEPTOR(char *, strsep, char **Stringp, const char *delim) {
+ char *OrigStringp = REAL(strsep)(Stringp, delim);
+ if (Stringp != nullptr) {
+ // The previous character has been overwritten with a '\0' char.
+ __nsan_set_value_unknown(reinterpret_cast<u8 *>(*Stringp) - 1, 1);
+ }
+ return OrigStringp;
+}
+
+INTERCEPTOR(char *, strtok, char *str, const char *delim) {
+ // This is overly conservative, but the probability that modern code is using
+ // strtok on double data is essentially zero anyway.
+ if (str)
+ __nsan_set_value_unknown(reinterpret_cast<u8 *>(str), internal_strlen(str));
+ return REAL(strtok)(str, delim);
+}
+
+static void nsanCopyZeroTerminated(char *dst, const char *src, uptr n) {
+ __nsan_copy_values(reinterpret_cast<u8 *>(dst),
+ reinterpret_cast<const u8 *>(src), n); // Data.
+ __nsan_set_value_unknown(reinterpret_cast<u8 *>(dst) + n, 1); // Terminator.
+}
+
+static void nsanWCopyZeroTerminated(wchar_t *dst, const wchar_t *src, uptr n) {
+ __nsan_copy_values((u8 *)dst, (const u8 *)(src), sizeof(wchar_t) * n);
+ __nsan_set_value_unknown((u8 *)(dst + n), sizeof(wchar_t));
+}
+
+INTERCEPTOR(char *, strdup, const char *S) {
+ char *res = REAL(strdup)(S);
+ if (res) {
+ nsanCopyZeroTerminated(res, S, internal_strlen(S));
+ }
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wcsdup, const wchar_t *S) {
+ wchar_t *res = REAL(wcsdup)(S);
+ if (res) {
+ nsanWCopyZeroTerminated(res, S, wcslen(S));
+ }
+ return res;
+}
+
+INTERCEPTOR(char *, strndup, const char *S, uptr size) {
+ char *res = REAL(strndup)(S, size);
+ if (res) {
+ nsanCopyZeroTerminated(res, S, min(internal_strlen(S), size));
+ }
+ return res;
+}
+
+INTERCEPTOR(char *, strcpy, char *dst, const char *src) {
+ char *res = REAL(strcpy)(dst, src);
+ nsanCopyZeroTerminated(dst, src, internal_strlen(src));
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wcscpy, wchar_t *dst, const wchar_t *src) {
+ wchar_t *res = REAL(wcscpy)(dst, src);
+ nsanWCopyZeroTerminated(dst, src, wcslen(src));
+ return res;
+}
+
+INTERCEPTOR(char *, strncpy, char *dst, const char *src, uptr size) {
+ char *res = REAL(strncpy)(dst, src, size);
+ nsanCopyZeroTerminated(dst, src, min(size, internal_strlen(src)));
+ return res;
+}
+
+INTERCEPTOR(char *, strcat, char *dst, const char *src) {
+ const auto DstLenBeforeCat = internal_strlen(dst);
+ char *res = REAL(strcat)(dst, src);
+ nsanCopyZeroTerminated(dst + DstLenBeforeCat, src, internal_strlen(src));
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wcscat, wchar_t *dst, const wchar_t *src) {
+ const auto DstLenBeforeCat = wcslen(dst);
+ wchar_t *res = REAL(wcscat)(dst, src);
+ nsanWCopyZeroTerminated(dst + DstLenBeforeCat, src, wcslen(src));
+ return res;
+}
+
+INTERCEPTOR(char *, strncat, char *dst, const char *src, uptr size) {
+ const auto DstLen = internal_strlen(dst);
+ char *res = REAL(strncat)(dst, src, size);
+ nsanCopyZeroTerminated(dst + DstLen, src, min(size, internal_strlen(src)));
+ return res;
+}
+
+INTERCEPTOR(char *, stpcpy, char *dst, const char *src) {
+ char *res = REAL(stpcpy)(dst, src);
+ nsanCopyZeroTerminated(dst, src, internal_strlen(src));
+ return res;
+}
+
+INTERCEPTOR(wchar_t *, wcpcpy, wchar_t *dst, const wchar_t *src) {
+ wchar_t *res = REAL(wcpcpy)(dst, src);
+ nsanWCopyZeroTerminated(dst, src, wcslen(src));
+ return res;
+}
+
+INTERCEPTOR(uptr, strxfrm, char *dst, const char *src, uptr size) {
+ // This is overly conservative, but this function should very rarely be used.
+ __nsan_set_value_unknown(reinterpret_cast<u8 *>(dst), internal_strlen(dst));
+ const uptr res = REAL(strxfrm)(dst, src, size);
+ return res;
+}
+
+void __nsan::InitializeInterceptors() {
+ static bool initialized = false;
+ CHECK(!initialized);
+
+ // Instruct libc malloc to consume less memory.
+#if SANITIZER_LINUX
+ mallopt(1, 0); // M_MXFAST
+ mallopt(-3, 32 * 1024); // M_MMAP_THRESHOLD
+#endif
+
+ INTERCEPT_FUNCTION(malloc);
+ INTERCEPT_FUNCTION(calloc);
+ INTERCEPT_FUNCTION(free);
+ INTERCEPT_FUNCTION(realloc);
+ INTERCEPT_FUNCTION(valloc);
+ INTERCEPT_FUNCTION(memalign);
+ INTERCEPT_FUNCTION(__libc_memalign);
+ INTERCEPT_FUNCTION(pvalloc);
+ INTERCEPT_FUNCTION(aligned_alloc);
+ INTERCEPT_FUNCTION(posix_memalign);
+
+ INTERCEPT_FUNCTION(memset);
+ INTERCEPT_FUNCTION(wmemset);
+ INTERCEPT_FUNCTION(memmove);
+ INTERCEPT_FUNCTION(wmemmove);
+ INTERCEPT_FUNCTION(memcpy);
+ INTERCEPT_FUNCTION(wmemcpy);
+
+ INTERCEPT_FUNCTION(strdup);
+ INTERCEPT_FUNCTION(wcsdup);
+ INTERCEPT_FUNCTION(strndup);
+ INTERCEPT_FUNCTION(stpcpy);
+ INTERCEPT_FUNCTION(wcpcpy);
+ INTERCEPT_FUNCTION(strcpy);
+ INTERCEPT_FUNCTION(wcscpy);
+ INTERCEPT_FUNCTION(strncpy);
+ INTERCEPT_FUNCTION(strcat);
+ INTERCEPT_FUNCTION(wcscat);
+ INTERCEPT_FUNCTION(strncat);
+ INTERCEPT_FUNCTION(strxfrm);
+
+ INTERCEPT_FUNCTION(strfry);
+ INTERCEPT_FUNCTION(strsep);
+ INTERCEPT_FUNCTION(strtok);
+
+ initialized = 1;
+}
diff --git a/compiler-rt/lib/nsan/nsan_stats.cc b/compiler-rt/lib/nsan/nsan_stats.cc
deleted file mode 100644
index 4e7a0c5810192..0000000000000
--- a/compiler-rt/lib/nsan/nsan_stats.cc
+++ /dev/null
@@ -1,158 +0,0 @@
-//===-- nsan_stats.cc -----------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of NumericalStabilitySanitizer.
-//
-// NumericalStabilitySanitizer statistics.
-//===----------------------------------------------------------------------===//
-
-#include "nsan/nsan_stats.h"
-
-#include "sanitizer_common/sanitizer_common.h"
-#include "sanitizer_common/sanitizer_placement_new.h"
-#include "sanitizer_common/sanitizer_stackdepot.h"
-#include "sanitizer_common/sanitizer_stacktrace.h"
-#include "sanitizer_common/sanitizer_symbolizer.h"
-
-#include <assert.h>
-#include <stdio.h>
-
-namespace __nsan {
-
-using namespace __sanitizer;
-
-Stats::Stats() {
- CheckAndWarnings.Initialize(0);
- TrackedLoads.Initialize(0);
-}
-
-Stats::~Stats() { Printf("deleting nsan stats\n"); }
-
-static uptr key(CheckTypeT CheckType, u32 StackId) {
- return static_cast<uptr>(CheckType) +
- StackId * static_cast<uptr>(CheckTypeT::kMaxCheckType);
-}
-
-template <typename MapT, typename VectorT, typename Fn>
-void UpdateEntry(CheckTypeT CheckTy, uptr PC, uptr BP, MapT *Map,
- VectorT *Vector, Mutex *Mutex, Fn F) {
- BufferedStackTrace Stack;
- Stack.Unwind(PC, BP, nullptr, false);
- u32 StackId = StackDepotPut(Stack);
- typename MapT::Handle Handle(Map, key(CheckTy, StackId));
- Lock L(Mutex);
- if (Handle.created()) {
- typename VectorT::value_type Entry;
- Entry.StackId = StackId;
- Entry.CheckTy = CheckTy;
- F(Entry);
- Vector->push_back(Entry);
- } else {
- auto &Entry = (*Vector)[*Handle];
- F(Entry);
- }
-}
-
-void Stats::addCheck(CheckTypeT CheckTy, uptr PC, uptr BP, double RelErr) {
- UpdateEntry(CheckTy, PC, BP, &CheckAndWarningsMap, &CheckAndWarnings,
- &CheckAndWarningsMutex, [RelErr](CheckAndWarningsValue &Entry) {
- ++Entry.NumChecks;
- if (RelErr > Entry.MaxRelativeError) {
- Entry.MaxRelativeError = RelErr;
- }
- });
-}
-
-void Stats::addWarning(CheckTypeT CheckTy, uptr PC, uptr BP, double RelErr) {
- UpdateEntry(CheckTy, PC, BP, &CheckAndWarningsMap, &CheckAndWarnings,
- &CheckAndWarningsMutex, [RelErr](CheckAndWarningsValue &Entry) {
- ++Entry.NumWarnings;
- if (RelErr > Entry.MaxRelativeError) {
- Entry.MaxRelativeError = RelErr;
- }
- });
-}
-
-void Stats::addInvalidLoadTrackingEvent(uptr PC, uptr BP) {
- UpdateEntry(CheckTypeT::kLoad, PC, BP, &LoadTrackingMap, &TrackedLoads,
- &TrackedLoadsMutex,
- [](LoadTrackingValue &Entry) { ++Entry.NumInvalid; });
-}
-
-void Stats::addUnknownLoadTrackingEvent(uptr PC, uptr BP) {
- UpdateEntry(CheckTypeT::kLoad, PC, BP, &LoadTrackingMap, &TrackedLoads,
- &TrackedLoadsMutex,
- [](LoadTrackingValue &Entry) { ++Entry.NumUnknown; });
-}
-
-static const char *CheckTypeDisplay(CheckTypeT CheckType) {
- switch (CheckType) {
- case CheckTypeT::kUnknown:
- return "unknown";
- case CheckTypeT::kRet:
- return "return";
- case CheckTypeT::kArg:
- return "argument";
- case CheckTypeT::kLoad:
- return "load";
- case CheckTypeT::kStore:
- return "store";
- case CheckTypeT::kInsert:
- return "vector insert";
- case CheckTypeT::kUser:
- return "user-initiated";
- case CheckTypeT::kFcmp:
- return "fcmp";
- case CheckTypeT::kMaxCheckType:
- return "[max]";
- }
- assert(false && "unknown CheckType case");
- return "";
-}
-
-void Stats::print() const {
- {
- Lock L(&CheckAndWarningsMutex);
- for (const auto &Entry : CheckAndWarnings) {
- Printf("warned %llu times out of %llu %s checks ", Entry.NumWarnings,
- Entry.NumChecks, CheckTypeDisplay(Entry.CheckTy));
- if (Entry.NumWarnings > 0) {
- char RelErrBuf[64];
- snprintf(RelErrBuf, sizeof(RelErrBuf) - 1, "%f",
- Entry.MaxRelativeError * 100.0);
- Printf("(max relative error: %s%%) ", RelErrBuf);
- }
- Printf("at:\n");
- StackDepotGet(Entry.StackId).Print();
- }
- }
-
- {
- Lock L(&TrackedLoadsMutex);
- u64 TotalInvalidLoadTracking = 0;
- u64 TotalUnknownLoadTracking = 0;
- for (const auto &Entry : TrackedLoads) {
- TotalInvalidLoadTracking += Entry.NumInvalid;
- TotalUnknownLoadTracking += Entry.NumUnknown;
- Printf("invalid/unknown type for %llu/%llu loads at:\n", Entry.NumInvalid,
- Entry.NumUnknown);
- StackDepotGet(Entry.StackId).Print();
- }
- Printf(
- "There were %llu/%llu floating-point loads where the shadow type was "
- "invalid/unknown.\n",
- TotalInvalidLoadTracking, TotalUnknownLoadTracking);
- }
-}
-
-ALIGNED(64) static char StatsPlaceholder[sizeof(Stats)];
-Stats *nsan_stats = nullptr;
-
-void initializeStats() { nsan_stats = new (StatsPlaceholder) Stats(); }
-
-} // namespace __nsan
diff --git a/compiler-rt/lib/nsan/nsan_stats.cpp b/compiler-rt/lib/nsan/nsan_stats.cpp
new file mode 100644
index 0000000000000..d188df1b1f70b
--- /dev/null
+++ b/compiler-rt/lib/nsan/nsan_stats.cpp
@@ -0,0 +1,157 @@
+//===-- nsan_stats.cc -----------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of NumericalStabilitySanitizer.
+//
+// NumericalStabilitySanitizer statistics.
+//===----------------------------------------------------------------------===//
+
+#include "nsan/nsan_stats.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+using namespace __sanitizer;
+using namespace __nsan;
+
+Stats::Stats() {
+ check_and_warnings.Initialize(0);
+ TrackedLoads.Initialize(0);
+}
+
+Stats::~Stats() { Printf("deleting nsan stats\n"); }
+
+static uptr Key(CheckTypeT CheckType, u32 StackId) {
+ return static_cast<uptr>(CheckType) +
+ StackId * static_cast<uptr>(CheckTypeT::kMaxCheckType);
+}
+
+template <typename MapT, typename VectorT, typename Fn>
+static void UpdateEntry(CheckTypeT check_ty, uptr pc, uptr bp, MapT *map,
+ VectorT *vector, Mutex *mutex, Fn F) {
+ BufferedStackTrace Stack;
+ Stack.Unwind(pc, bp, nullptr, false);
+ u32 stack_id = StackDepotPut(Stack);
+ typename MapT::Handle Handle(map, Key(check_ty, stack_id));
+ Lock L(mutex);
+ if (Handle.created()) {
+ typename VectorT::value_type entry;
+ entry.stack_id = stack_id;
+ entry.check_ty = check_ty;
+ F(entry);
+ vector->push_back(entry);
+ } else {
+ auto &entry = (*vector)[*Handle];
+ F(entry);
+ }
+}
+
+void Stats::AddCheck(CheckTypeT check_ty, uptr pc, uptr bp, double rel_err) {
+ UpdateEntry(check_ty, pc, bp, &CheckAndWarningsMap, &check_and_warnings,
+ &check_and_warning_mutex,
+ [rel_err](CheckAndWarningsValue &entry) {
+ ++entry.num_checks;
+ if (rel_err > entry.max_relative_err) {
+ entry.max_relative_err = rel_err;
+ }
+ });
+}
+
+void Stats::AddWarning(CheckTypeT check_ty, uptr pc, uptr bp, double rel_err) {
+ UpdateEntry(check_ty, pc, bp, &CheckAndWarningsMap, &check_and_warnings,
+ &check_and_warning_mutex,
+ [rel_err](CheckAndWarningsValue &entry) {
+ ++entry.num_warnings;
+ if (rel_err > entry.max_relative_err) {
+ entry.max_relative_err = rel_err;
+ }
+ });
+}
+
+void Stats::AddInvalidLoadTrackingEvent(uptr pc, uptr bp) {
+ UpdateEntry(CheckTypeT::kLoad, pc, bp, &LoadTrackingMap, &TrackedLoads,
+ &TrackedLoadsMutex,
+ [](LoadTrackingValue &entry) { ++entry.num_invalid; });
+}
+
+void Stats::AddUnknownLoadTrackingEvent(uptr pc, uptr bp) {
+ UpdateEntry(CheckTypeT::kLoad, pc, bp, &LoadTrackingMap, &TrackedLoads,
+ &TrackedLoadsMutex,
+ [](LoadTrackingValue &entry) { ++entry.num_unknown; });
+}
+
+static const char *CheckTypeDisplay(CheckTypeT CheckType) {
+ switch (CheckType) {
+ case CheckTypeT::kUnknown:
+ return "unknown";
+ case CheckTypeT::kRet:
+ return "return";
+ case CheckTypeT::kArg:
+ return "argument";
+ case CheckTypeT::kLoad:
+ return "load";
+ case CheckTypeT::kStore:
+ return "store";
+ case CheckTypeT::kInsert:
+ return "vector insert";
+ case CheckTypeT::kUser:
+ return "user-initiated";
+ case CheckTypeT::kFcmp:
+ return "fcmp";
+ case CheckTypeT::kMaxCheckType:
+ return "[max]";
+ }
+ assert(false && "unknown CheckType case");
+ return "";
+}
+
+void Stats::Print() const {
+ {
+ Lock L(&check_and_warning_mutex);
+ for (const auto &entry : check_and_warnings) {
+ Printf("warned %llu times out of %llu %s checks ", entry.num_warnings,
+ entry.num_checks, CheckTypeDisplay(entry.check_ty));
+ if (entry.num_warnings > 0) {
+ char RelErrBuf[64];
+ snprintf(RelErrBuf, sizeof(RelErrBuf) - 1, "%f",
+ entry.max_relative_err * 100.0);
+ Printf("(max relative error: %s%%) ", RelErrBuf);
+ }
+ Printf("at:\n");
+ StackDepotGet(entry.stack_id).Print();
+ }
+ }
+
+ {
+ Lock L(&TrackedLoadsMutex);
+ u64 TotalInvalidLoadTracking = 0;
+ u64 TotalUnknownLoadTracking = 0;
+ for (const auto &entry : TrackedLoads) {
+ TotalInvalidLoadTracking += entry.num_invalid;
+ TotalUnknownLoadTracking += entry.num_unknown;
+ Printf("invalid/unknown type for %llu/%llu loads at:\n",
+ entry.num_invalid, entry.num_unknown);
+ StackDepotGet(entry.stack_id).Print();
+ }
+ Printf(
+ "There were %llu/%llu floating-point loads where the shadow type was "
+ "invalid/unknown.\n",
+ TotalInvalidLoadTracking, TotalUnknownLoadTracking);
+ }
+}
+
+alignas(64) static char stats_placeholder[sizeof(Stats)];
+Stats *__nsan::nsan_stats = nullptr;
+
+void __nsan::InitializeStats() { nsan_stats = new (stats_placeholder) Stats(); }
diff --git a/compiler-rt/lib/nsan/nsan_stats.h b/compiler-rt/lib/nsan/nsan_stats.h
index 7e8c7bb7bf12d..d1c7e0115e7ae 100644
--- a/compiler-rt/lib/nsan/nsan_stats.h
+++ b/compiler-rt/lib/nsan/nsan_stats.h
@@ -40,52 +40,53 @@ class Stats {
~Stats();
// Signal that we checked the instruction at the given address.
- void addCheck(CheckTypeT CheckType, __sanitizer::uptr PC,
- __sanitizer::uptr BP, double RelErr);
+ void AddCheck(CheckTypeT check_ty, __sanitizer::uptr pc, __sanitizer::uptr bp,
+ double rel_err);
// Signal that we warned for the instruction at the given address.
- void addWarning(CheckTypeT CheckType, __sanitizer::uptr PC,
- __sanitizer::uptr BP, double RelErr);
+ void AddWarning(CheckTypeT check_ty, __sanitizer::uptr pc,
+ __sanitizer::uptr bp, double rel_err);
// Signal that we detected a floating-point load where the shadow type was
// invalid.
- void addInvalidLoadTrackingEvent(__sanitizer::uptr PC, __sanitizer::uptr BP);
+ void AddInvalidLoadTrackingEvent(__sanitizer::uptr pc, __sanitizer::uptr bp);
// Signal that we detected a floating-point load where the shadow type was
// unknown but the value was nonzero.
- void addUnknownLoadTrackingEvent(__sanitizer::uptr PC, __sanitizer::uptr BP);
+ void AddUnknownLoadTrackingEvent(__sanitizer::uptr pc, __sanitizer::uptr bp);
- void print() const;
+ void Print() const;
private:
using IndexMap = __sanitizer::AddrHashMap<__sanitizer::uptr, 11>;
struct CheckAndWarningsValue {
- CheckTypeT CheckTy;
- __sanitizer::u32 StackId = 0;
- __sanitizer::u64 NumChecks = 0;
- __sanitizer::u64 NumWarnings = 0;
+ CheckTypeT check_ty;
+ __sanitizer::u32 stack_id = 0;
+ __sanitizer::u64 num_checks = 0;
+ __sanitizer::u64 num_warnings = 0;
// This is a bitcasted double. Doubles have the nice idea to be ordered as
// ints.
- double MaxRelativeError = 0;
+ double max_relative_err = 0;
};
- // Maps key(CheckType, StackId) to indices in CheckAndWarnings.
+ // Map Key(check_ty, StackId) to indices in CheckAndWarnings.
IndexMap CheckAndWarningsMap;
- __sanitizer::InternalMmapVectorNoCtor<CheckAndWarningsValue> CheckAndWarnings;
- mutable __sanitizer::Mutex CheckAndWarningsMutex;
+ __sanitizer::InternalMmapVectorNoCtor<CheckAndWarningsValue>
+ check_and_warnings;
+ mutable __sanitizer::Mutex check_and_warning_mutex;
struct LoadTrackingValue {
- CheckTypeT CheckTy;
- __sanitizer::u32 StackId = 0;
- __sanitizer::u64 NumInvalid = 0;
- __sanitizer::u64 NumUnknown = 0;
+ CheckTypeT check_ty;
+ __sanitizer::u32 stack_id = 0;
+ __sanitizer::u64 num_invalid = 0;
+ __sanitizer::u64 num_unknown = 0;
};
- // Maps key(CheckTypeT::kLoad, StackId) to indices in TrackedLoads.
+ // Map Key(CheckTypeT::kLoad, StackId) to indices in TrackedLoads.
IndexMap LoadTrackingMap;
__sanitizer::InternalMmapVectorNoCtor<LoadTrackingValue> TrackedLoads;
mutable __sanitizer::Mutex TrackedLoadsMutex;
};
extern Stats *nsan_stats;
-void initializeStats();
+void InitializeStats();
} // namespace __nsan
diff --git a/compiler-rt/lib/nsan/nsan_suppressions.cc b/compiler-rt/lib/nsan/nsan_suppressions.cc
deleted file mode 100644
index 9529a8e1be7d8..0000000000000
--- a/compiler-rt/lib/nsan/nsan_suppressions.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-//===-- nsan_suppressions.cc ----------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "nsan_suppressions.h"
-
-#include "sanitizer_common/sanitizer_placement_new.h"
-#include "sanitizer_common/sanitizer_stacktrace.h"
-#include "sanitizer_common/sanitizer_symbolizer.h"
-
-#include "nsan_flags.h"
-
-// Can be overriden in frontend.
-SANITIZER_WEAK_DEFAULT_IMPL
-const char *__nsan_default_suppressions() { return 0; }
-
-namespace __nsan {
-
-const char *const kSuppressionFcmp = "fcmp";
-const char *const kSuppressionConsistency = "consistency";
-
-using namespace __sanitizer;
-
-ALIGNED(64) static char SuppressionPlaceholder[sizeof(SuppressionContext)];
-static SuppressionContext *SuppressionCtx = nullptr;
-
-// The order should match the enum CheckKind.
-static const char *kSuppressionTypes[] = {kSuppressionFcmp,
- kSuppressionConsistency};
-
-void InitializeSuppressions() {
- CHECK_EQ(nullptr, SuppressionCtx);
- SuppressionCtx = new (SuppressionPlaceholder)
- SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
- SuppressionCtx->ParseFromFile(flags().suppressions);
- SuppressionCtx->Parse(__nsan_default_suppressions());
-}
-
-static Suppression *GetSuppressionForAddr(uptr Addr, const char *SupprType) {
- Suppression *S = nullptr;
-
- // Suppress by module name.
- SuppressionContext *Suppressions = SuppressionCtx;
- if (const char *ModuleName =
- Symbolizer::GetOrInit()->GetModuleNameForPc(Addr)) {
- if (Suppressions->Match(ModuleName, SupprType, &S))
- return S;
- }
-
- // Suppress by file or function name.
- SymbolizedStack *Frames = Symbolizer::GetOrInit()->SymbolizePC(Addr);
- for (SymbolizedStack *Cur = Frames; Cur; Cur = Cur->next) {
- if (Suppressions->Match(Cur->info.function, SupprType, &S) ||
- Suppressions->Match(Cur->info.file, SupprType, &S)) {
- break;
- }
- }
- Frames->ClearAll();
- return S;
-}
-
-Suppression *GetSuppressionForStack(const StackTrace *Stack, CheckKind K) {
- for (uptr I = 0, E = Stack->size; I < E; I++) {
- Suppression *S = GetSuppressionForAddr(
- StackTrace::GetPreviousInstructionPc(Stack->trace[I]),
- kSuppressionTypes[static_cast<int>(K)]);
- if (S)
- return S;
- }
- return nullptr;
-}
-
-} // end namespace __nsan
diff --git a/compiler-rt/lib/nsan/nsan_suppressions.cpp b/compiler-rt/lib/nsan/nsan_suppressions.cpp
new file mode 100644
index 0000000000000..c4d438e090e05
--- /dev/null
+++ b/compiler-rt/lib/nsan/nsan_suppressions.cpp
@@ -0,0 +1,73 @@
+//===-- nsan_suppressions.cc ----------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "nsan_suppressions.h"
+#include "nsan_flags.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+using namespace __sanitizer;
+using namespace __nsan;
+
+SANITIZER_INTERFACE_WEAK_DEF(const char *, __nsan_default_suppressions, void) {
+ return 0;
+}
+
+const char kSuppressionFcmp[] = "fcmp";
+const char kSuppressionConsistency[] = "consistency";
+
+alignas(64) static char suppression_placeholder[sizeof(SuppressionContext)];
+static SuppressionContext *suppression_ctx;
+
+// The order should match the enum CheckKind.
+static const char *kSuppressionTypes[] = {kSuppressionFcmp,
+ kSuppressionConsistency};
+
+void __nsan::InitializeSuppressions() {
+ CHECK_EQ(nullptr, suppression_ctx);
+ suppression_ctx = new (suppression_placeholder)
+ SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
+ suppression_ctx->ParseFromFile(flags().suppressions);
+ suppression_ctx->Parse(__nsan_default_suppressions());
+}
+
+static Suppression *GetSuppressionForAddr(uptr addr, const char *suppr_type) {
+ Suppression *s = nullptr;
+
+ // Suppress by module name.
+ SuppressionContext *suppressions = suppression_ctx;
+ if (const char *moduleName =
+ Symbolizer::GetOrInit()->GetModuleNameForPc(addr)) {
+ if (suppressions->Match(moduleName, suppr_type, &s))
+ return s;
+ }
+
+ // Suppress by file or function name.
+ SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(addr);
+ for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+ if (suppressions->Match(cur->info.function, suppr_type, &s) ||
+ suppressions->Match(cur->info.file, suppr_type, &s)) {
+ break;
+ }
+ }
+ frames->ClearAll();
+ return s;
+}
+
+Suppression *__nsan::GetSuppressionForStack(const StackTrace *stack,
+ CheckKind k) {
+ for (uptr i = 0, e = stack->size; i < e; i++) {
+ Suppression *s = GetSuppressionForAddr(
+ StackTrace::GetPreviousInstructionPc(stack->trace[i]),
+ kSuppressionTypes[static_cast<int>(k)]);
+ if (s)
+ return s;
+ }
+ return nullptr;
+}
diff --git a/compiler-rt/lib/nsan/tests/NSanUnitTest.cpp b/compiler-rt/lib/nsan/tests/NSanUnitTest.cpp
index 3c6b505aaf7a1..d121292c36682 100644
--- a/compiler-rt/lib/nsan/tests/NSanUnitTest.cpp
+++ b/compiler-rt/lib/nsan/tests/NSanUnitTest.cpp
@@ -14,41 +14,41 @@ namespace __nsan {
template <typename FT, auto next> void TestFT() {
// Basic local tests anchored at 0.0.
- ASSERT_EQ(getULPDiff<FT>(0.0, 0.0), 0);
- ASSERT_EQ(getULPDiff<FT>(-0.0, 0.0), 0);
- ASSERT_EQ(getULPDiff<FT>(next(-0.0, -1.0), 0.0), 1);
- ASSERT_EQ(getULPDiff<FT>(next(0.0, 1.0), -0.0), 1);
- ASSERT_EQ(getULPDiff<FT>(next(-0.0, -1.0), next(0.0, 1.0)), 2);
+ ASSERT_EQ(GetULPDiff<FT>(0.0, 0.0), 0);
+ ASSERT_EQ(GetULPDiff<FT>(-0.0, 0.0), 0);
+ ASSERT_EQ(GetULPDiff<FT>(next(-0.0, -1.0), 0.0), 1);
+ ASSERT_EQ(GetULPDiff<FT>(next(0.0, 1.0), -0.0), 1);
+ ASSERT_EQ(GetULPDiff<FT>(next(-0.0, -1.0), next(0.0, 1.0)), 2);
// Basic local tests anchored at 2.0.
- ASSERT_EQ(getULPDiff<FT>(next(2.0, 1.0), 2.0), 1);
- ASSERT_EQ(getULPDiff<FT>(next(2.0, 3.0), 2.0), 1);
- ASSERT_EQ(getULPDiff<FT>(next(2.0, 1.0), next(2.0, 3.0)), 2);
+ ASSERT_EQ(GetULPDiff<FT>(next(2.0, 1.0), 2.0), 1);
+ ASSERT_EQ(GetULPDiff<FT>(next(2.0, 3.0), 2.0), 1);
+ ASSERT_EQ(GetULPDiff<FT>(next(2.0, 1.0), next(2.0, 3.0)), 2);
- ASSERT_NE(getULPDiff<FT>(-0.01, 0.01), kMaxULPDiff);
+ ASSERT_NE(GetULPDiff<FT>(-0.01, 0.01), kMaxULPDiff);
// Basic local tests anchored at a random number.
const FT X = 4863.5123;
const FT To = 2 * X;
FT Y = X;
- ASSERT_EQ(getULPDiff<FT>(X, Y), 0);
- ASSERT_EQ(getULPDiff<FT>(-X, -Y), 0);
+ ASSERT_EQ(GetULPDiff<FT>(X, Y), 0);
+ ASSERT_EQ(GetULPDiff<FT>(-X, -Y), 0);
Y = next(Y, To);
- ASSERT_EQ(getULPDiff<FT>(X, Y), 1);
- ASSERT_EQ(getULPDiff<FT>(-X, -Y), 1);
+ ASSERT_EQ(GetULPDiff<FT>(X, Y), 1);
+ ASSERT_EQ(GetULPDiff<FT>(-X, -Y), 1);
Y = next(Y, To);
- ASSERT_EQ(getULPDiff<FT>(X, Y), 2);
- ASSERT_EQ(getULPDiff<FT>(-X, -Y), 2);
+ ASSERT_EQ(GetULPDiff<FT>(X, Y), 2);
+ ASSERT_EQ(GetULPDiff<FT>(-X, -Y), 2);
Y = next(Y, To);
- ASSERT_EQ(getULPDiff<FT>(X, Y), 3);
- ASSERT_EQ(getULPDiff<FT>(-X, -Y), 3);
+ ASSERT_EQ(GetULPDiff<FT>(X, Y), 3);
+ ASSERT_EQ(GetULPDiff<FT>(-X, -Y), 3);
// Values with larger
diff erences.
static constexpr const __sanitizer::u64 MantissaSize =
__sanitizer::u64{1} << FTInfo<FT>::kMantissaBits;
- ASSERT_EQ(getULPDiff<FT>(1.0, next(2.0, 1.0)), MantissaSize - 1);
- ASSERT_EQ(getULPDiff<FT>(1.0, 2.0), MantissaSize);
- ASSERT_EQ(getULPDiff<FT>(1.0, next(2.0, 3.0)), MantissaSize + 1);
- ASSERT_EQ(getULPDiff<FT>(1.0, 3.0), (3 * MantissaSize) / 2);
+ ASSERT_EQ(GetULPDiff<FT>(1.0, next(2.0, 1.0)), MantissaSize - 1);
+ ASSERT_EQ(GetULPDiff<FT>(1.0, 2.0), MantissaSize);
+ ASSERT_EQ(GetULPDiff<FT>(1.0, next(2.0, 3.0)), MantissaSize + 1);
+ ASSERT_EQ(GetULPDiff<FT>(1.0, 3.0), (3 * MantissaSize) / 2);
}
TEST(NSanTest, Float) { TestFT<float, nextafterf>(); }
@@ -59,9 +59,9 @@ TEST(NSanTest, Double) {
TEST(NSanTest, Float128) {
// Very basic tests. FIXME: improve when we have nextafter<__float128>.
- ASSERT_EQ(getULPDiff<__float128>(0.0, 0.0), 0);
- ASSERT_EQ(getULPDiff<__float128>(-0.0, 0.0), 0);
- ASSERT_NE(getULPDiff<__float128>(-0.01, 0.01), kMaxULPDiff);
+ ASSERT_EQ(GetULPDiff<__float128>(0.0, 0.0), 0);
+ ASSERT_EQ(GetULPDiff<__float128>(-0.0, 0.0), 0);
+ ASSERT_NE(GetULPDiff<__float128>(-0.01, 0.01), kMaxULPDiff);
}
} // end namespace __nsan
More information about the llvm-commits
mailing list