[nsan] Fix style issue #96142
Merged
[nsan] Fix style issue #96142
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Created using spr 1.3.5-bogner
Created using spr 1.3.5-bogner [skip ci]
|
@llvm/pr-subscribers-compiler-rt-sanitizer Author: Fangrui Song (MaskRay) ChangesThe initial check-in of compiler-rt/lib/nsan #94322 has a lot of style Patch is 54.71 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/96142.diff 8 Files Affected:
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 78%
rename from compiler-rt/lib/nsan/nsan.cc
rename to compiler-rt/lib/nsan/nsan.cpp
index d0d29ddfba0e3..ece1130f73d14 100644
--- a/compiler-rt/lib/nsan/nsan.cc
+++ b/compiler-rt/lib/nsan/nsan.cpp
@@ -82,22 +82,22 @@ 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> __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) {
+__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;
}
@@ -120,30 +120,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 +151,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;
@@ -192,7 +192,7 @@ extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __nsan_print_accumulated_stats() {
nsan_stats->print();
}
-static void nsanAtexit() {
+static void NsanAtexit() {
Printf("Numerical Sanitizer exit stats:\n");
__nsan_print_accumulated_stats();
nsan_stats = nullptr;
@@ -204,13 +204,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,36 +228,36 @@ __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);
}
@@ -269,7 +269,7 @@ static const u8 *getShadowPtrForLoad(const u8 *LoadAddr, uptr N) {
return nullptr;
}
}
- return getShadowAddrFor(LoadAddr);
+ return getShadowAddrFor(load_addr);
}
extern "C" SANITIZER_INTERFACE_ATTRIBUTE const u8 *
@@ -308,14 +308,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 +325,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 +342,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 +358,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 +422,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,13 +468,13 @@ 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);
+ const double ShadowUlpDiff = getULPDiff(check_value, check_shadow);
if (ShadowUlpDiff != kMaxULPDiff) {
// This is the ULP diff in the internal domain. The user actually cares
// about that in the original domain.
@@ -529,18 +523,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, UlpErrBuf);
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) {
@@ -614,9 +608,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.
@@ -657,14 +651,14 @@ 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),
// Native, hex.
FTInfo<FT>::kCppTypeName, ValuePrinter::hex(Lhs).Buffer, PredicateName,
- ValuePrinter::hex(Rhs).Buffer, getTruthValueName(Result),
+ ValuePrinter::hex(Rhs).Buffer, getTruthValueName(result),
// Shadow...
[truncated]
|
|
thanks! |
alexander-shaposhnikov
approved these changes
Jun 20, 2024
MaskRay
changed the base branch from
users/MaskRay/spr/main.nsan-fix-style-issue
to
main
AlexisPerry
pushed a commit
to llvm-project-tlp/llvm-project
that referenced
this pull request
Jul 9, 2024
The initial check-in of compiler-rt/lib/nsan llvm#94322 has a lot of style issues. Fix them before the history becomes more useful. Pull Request: llvm#96142
nikic
added a commit
that referenced
this pull request
Jul 17, 2024
Use `alignas(16) SANITIZER_INTERFACE_ATTRIBUTE` instead of `SANITIZER_INTERFACE_ATTRIBUTE alignas(16)`, as the former is not supported prior to clang 16. See https://clang.godbolt.org/z/Wj1193xWK. This was broken by #96142 as part of other style changes.
sgundapa
pushed a commit
to sgundapa/upstream_effort
that referenced
this pull request
Jul 23, 2024
Use `alignas(16) SANITIZER_INTERFACE_ATTRIBUTE` instead of `SANITIZER_INTERFACE_ATTRIBUTE alignas(16)`, as the former is not supported prior to clang 16. See https://clang.godbolt.org/z/Wj1193xWK. This was broken by llvm#96142 as part of other style changes.
yuxuanchen1997
pushed a commit
that referenced
this pull request
Jul 25, 2024
Summary: Use `alignas(16) SANITIZER_INTERFACE_ATTRIBUTE` instead of `SANITIZER_INTERFACE_ATTRIBUTE alignas(16)`, as the former is not supported prior to clang 16. See https://clang.godbolt.org/z/Wj1193xWK. This was broken by #96142 as part of other style changes. Test Plan: Reviewers: Subscribers: Tasks: Tags: Differential Revision: https://phabricator.intern.facebook.com/D60250864
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
The initial check-in of compiler-rt/lib/nsan #94322 has a lot of style
issues. Fix them before the history becomes more useful.