[sanitizer] Remove cpplint annotations

[vitalybuka]

Summary

cpplint was removed by D107197

[morehouse]

LGTM

compiler-rt/include/sanitizer/dfsan_interface.h

 /// Returns the value of -dfsan-track-origins.
 /// * 0: do not track origins.
 /// * 1: track origins at memory store operations.
 /// * 2: track origins at memory load and store operations.
 int dfsan_get_track_origins(void);
 #ifdef __cplusplus
 }  // extern "C"
 
-template <typename T>
-void dfsan_set_label(dfsan_label label, T &data) { // NOLINT
+template <typename T> void dfsan_set_label(dfsan_label label, T &data) {
   dfsan_set_label(label, (void *)&data, sizeof(T));
 }
 
 #endif
 
 #endif  // DFSAN_INTERFACE_H

compiler-rt/lib/dfsan/dfsan.h

 void dfsan_set_label_origin(dfsan_label label, dfsan_origin origin, void *addr,
                             uptr size);
 
 // Copy or move the origins of the len bytes from src to dst.
 void dfsan_mem_origin_transfer(const void *dst, const void *src, uptr len);
 }  // extern "C"
 
 template <typename T>
-void dfsan_set_label(dfsan_label label, T &data) {  // NOLINT
+void dfsan_set_label(dfsan_label label, T &data) {
   dfsan_set_label(label, (void *)&data, sizeof(T));
 }
 
 namespace __dfsan {
 
 extern bool dfsan_inited;
 extern bool dfsan_init_is_running;
 

compiler-rt/lib/dfsan/dfsan_custom.cpp

void *__dfso_memset(void *s, int c, size_t n, dfsan_label s_label,
   return s;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strcat(char *dest, const char *src,
                                                   dfsan_label dest_label,
                                                   dfsan_label src_label,
                                                   dfsan_label *ret_label) {
   size_t dest_len = strlen(dest);
-  char *ret = strcat(dest, src);  // NOLINT
+  char *ret = strcat(dest, src);
   dfsan_label *sdest = shadow_for(dest + dest_len);
   const dfsan_label *ssrc = shadow_for(src);
   internal_memcpy((void *)sdest, (const void *)ssrc,
                   strlen(src) * sizeof(dfsan_label));
   *ret_label = dest_label;
   return ret;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE char *__dfso_strcat(
     char *dest, const char *src, dfsan_label dest_label, dfsan_label src_label,
     dfsan_label *ret_label, dfsan_origin dest_origin, dfsan_origin src_origin,
     dfsan_origin *ret_origin) {
   size_t dest_len = strlen(dest);
-  char *ret = strcat(dest, src);  // NOLINT
+  char *ret = strcat(dest, src);
   dfsan_label *sdest = shadow_for(dest + dest_len);
   const dfsan_label *ssrc = shadow_for(src);
   size_t src_len = strlen(src);
   dfsan_mem_origin_transfer(dest + dest_len, src, src_len);
   internal_memcpy((void *)sdest, (const void *)ssrc,
                   src_len * sizeof(dfsan_label));
   *ret_label = dest_label;
   *ret_origin = dest_origin;
int __dfso_getrusage(int who, struct rusage *usage, dfsan_label who_label,
                      dfsan_origin who_origin, dfsan_origin usage_origin,
                      dfsan_label *ret_origin) {
   return __dfsw_getrusage(who, usage, who_label, usage_label, ret_label);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 char *__dfsw_strcpy(char *dest, const char *src, dfsan_label dst_label,
                     dfsan_label src_label, dfsan_label *ret_label) {
-  char *ret = strcpy(dest, src);  // NOLINT
+  char *ret = strcpy(dest, src);
   if (ret) {
     internal_memcpy(shadow_for(dest), shadow_for(src),
                     sizeof(dfsan_label) * (strlen(src) + 1));
   }
   *ret_label = dst_label;
   return ret;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 char *__dfso_strcpy(char *dest, const char *src, dfsan_label dst_label,
                     dfsan_label src_label, dfsan_label *ret_label,
                     dfsan_origin dst_origin, dfsan_origin src_origin,
                     dfsan_origin *ret_origin) {
-  char *ret = strcpy(dest, src);  // NOLINT
+  char *ret = strcpy(dest, src);
   if (ret) {
     size_t str_len = strlen(src) + 1;
     dfsan_mem_origin_transfer(dest, src, str_len);
     internal_memcpy(shadow_for(dest), shadow_for(src),
                     sizeof(dfsan_label) * str_len);
   }
   *ret_label = dst_label;
   *ret_origin = dst_origin;

compiler-rt/lib/dfsan/dfsan_interceptors.cpp

if (!__dfsan::dfsan_inited) {           \
       __dfsan::dfsan_init();                \
     }                                       \
   } while (0)
 
 #define COMMON_INTERCEPTOR_ENTER(func, ...) \
   if (__dfsan::dfsan_init_is_running)       \
     return REAL(func)(__VA_ARGS__);         \
   ENSURE_DFSAN_INITED();                    \
-  dfsan_set_label(0, __errno_location(), sizeof(int)); /* NOLINT */
+  dfsan_set_label(0, __errno_location(), sizeof(int));
 
 INTERCEPTOR(void *, mmap, void *addr, SIZE_T length, int prot, int flags,
             int fd, OFF_T offset) {
   if (common_flags()->detect_write_exec)
     ReportMmapWriteExec(prot);
   if (!__dfsan::dfsan_inited)
     return (void *)internal_mmap(addr, length, prot, flags, fd, offset);
   COMMON_INTERCEPTOR_ENTER(mmap, addr, length, prot, flags, fd, offset);

compiler-rt/lib/msan/msan_interceptors.cpp

 #define COMMON_INTERCEPTOR_UNPOISON_PARAM(count)  \
   UnpoisonParam(count)
 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
   __msan_unpoison(ptr, size)
 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
   CHECK_UNPOISONED_CTX(ctx, ptr, size)
 #define COMMON_INTERCEPTOR_INITIALIZE_RANGE(ptr, size) \
   __msan_unpoison(ptr, size)
-#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)                  \
-  if (msan_init_is_running) return REAL(func)(__VA_ARGS__);       \
-  ENSURE_MSAN_INITED();                                           \
-  MSanInterceptorContext msan_ctx = {IsInInterceptorScope()};     \
-  ctx = (void *)&msan_ctx;                                        \
-  (void)ctx;                                                      \
-  InterceptorScope interceptor_scope;                             \
-  __msan_unpoison(__errno_location(), sizeof(int)); /* NOLINT */
+#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)              \
+  if (msan_init_is_running)                                   \
+    return REAL(func)(__VA_ARGS__);                           \
+  ENSURE_MSAN_INITED();                                       \
+  MSanInterceptorContext msan_ctx = {IsInInterceptorScope()}; \
+  ctx = (void *)&msan_ctx;                                    \
+  (void)ctx;                                                  \
+  InterceptorScope interceptor_scope;                         \
+  __msan_unpoison(__errno_location(), sizeof(int));
 #define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
   do {                                            \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
   do {                                         \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
   do {                                         \

compiler-rt/lib/msan/tests/msan_test.cpp

TEST(MemorySanitizerOrigins, InitializedStoreDoesNotChangeOrigin) {
   EXPECT_ORIGIN(origin, __msan_get_origin(&s.a));
   EXPECT_ORIGIN(origin, __msan_get_origin(&s.b));
 }
 }  // namespace
 
 template<class T, class BinaryOp>
 ALWAYS_INLINE
 void BinaryOpOriginTest(BinaryOp op) {
-  U4 ox = rand();  //NOLINT
-  U4 oy = rand();  //NOLINT
+  U4 ox = rand();
+  U4 oy = rand();
   T *x = GetPoisonedO<T>(0, ox, 0);
   T *y = GetPoisonedO<T>(1, oy, 0);
   T *z = GetPoisonedO<T>(2, 0, 0);
 
   *z = op(*x, *y);
   U4 origin = __msan_get_origin(z);
   EXPECT_POISONED_O(*z, origin);
   EXPECT_EQ(true, __msan_origin_is_descendant_or_same(origin, ox) ||

compiler-rt/lib/sanitizer_common/sanitizer_asm.h

 # define ASM_SYMBOL(symbol) _##symbol
 # define ASM_SYMBOL_INTERCEPTOR(symbol) _wrap_##symbol
 # define ASM_WRAPPER_NAME(symbol) __interceptor_##symbol
 #endif
 
 #if defined(__ELF__) && (defined(__GNU__) || defined(__FreeBSD__) || \
                          defined(__Fuchsia__) || defined(__linux__))
 // clang-format off
-#define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits  // NOLINT
+#define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits
 // clang-format on
 #else
 #define NO_EXEC_STACK_DIRECTIVE
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_common.h

(*((u8 *)&v + 0)), (*((u8 *)&v + 1)), (*((u8 *)&v + 2)), (*((u8 *)&v + 3)), \
       (*((u8 *)&v + 4)), (*((u8 *)&v + 5)), (*((u8 *)&v + 6)),                \
       (*((u8 *)&v + 7)), (*((u8 *)&v + 8)), (*((u8 *)&v + 9)),                \
       (*((u8 *)&v + 10)), (*((u8 *)&v + 11)), (*((u8 *)&v + 12)),             \
       (*((u8 *)&v + 13)), (*((u8 *)&v + 14)), (*((u8 *)&v + 15))
 
 }  // namespace __sanitizer
 
 inline void *operator new(__sanitizer::operator_new_size_type size,
-                          __sanitizer::LowLevelAllocator &alloc) {  // NOLINT
+                          __sanitizer::LowLevelAllocator &alloc) {
   return alloc.Allocate(size);
 }
 
 #endif  // SANITIZER_COMMON_H

compiler-rt/lib/sanitizer_common/sanitizer_interceptors_ioctl_netbsd.inc

#endif
   _(SNDCTL_DSP_SILENCE, NONE, 0);
   /* Entries from file: dev/filemon/filemon.h (compat <= 9.99.26) */
   _(FILEMON_SET_FD, READWRITE, sizeof(int));
   _(FILEMON_SET_PID, READWRITE, sizeof(int));
   /* Entries from file: dev/usb/urio.h (compat <= 9.99.43) */
   _(URIO_SEND_COMMAND, READWRITE, struct_urio_command_sz);
   _(URIO_RECV_COMMAND, READWRITE, struct_urio_command_sz);
 #undef _
-} // NOLINT
+}
 
 static bool ioctl_initialized = false;
 
 struct ioctl_desc_compare {
   bool operator()(const ioctl_desc &left, const ioctl_desc &right) const {
     return left.req < right.req;
   }
 };

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_SCANDIR \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SCANDIR64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
 #define SANITIZER_INTERCEPT_GETGROUPS SI_POSIX
 #define SANITIZER_INTERCEPT_POLL SI_POSIX
 #define SANITIZER_INTERCEPT_PPOLL SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_WORDEXP                                          \
   (SI_FREEBSD || SI_NETBSD || (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID || \
-   SI_SOLARIS)  // NOLINT
+   SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SIGWAIT SI_POSIX
 #define SANITIZER_INTERCEPT_SIGWAITINFO SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_SIGTIMEDWAIT SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_SIGSETOPS \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SIGSET_LOGICOPS SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SIGPENDING SI_POSIX
 #define SANITIZER_INTERCEPT_SIGPROCMASK SI_POSIX

 #define SANITIZER_INTERCEPT_STATVFS64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_INITGROUPS SI_POSIX
 #define SANITIZER_INTERCEPT_ETHER_NTOA_ATON SI_POSIX
 #define SANITIZER_INTERCEPT_ETHER_HOST \
   (SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_ETHER_R (SI_FREEBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_SHMCTL                                       \
   (((SI_FREEBSD || SI_LINUX_NOT_ANDROID) && SANITIZER_WORDSIZE == 64) || \
-   SI_NETBSD || SI_SOLARIS)  // NOLINT
+   SI_NETBSD || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_RANDOM_R SI_GLIBC
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_GLIBC
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET_SCHED SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED \
   (SI_POSIX && !SI_NETBSD)

compiler-rt/lib/sanitizer_common/tests/sanitizer_printf_test.cpp

TEST(Printf, Basic) {
   std::string expectedString = "a-1b-2c4294967292e5fahbq0x";
   expectedString += std::string(SANITIZER_POINTER_FORMAT_LENGTH - 3, '0');
   expectedString += "123e_string_r";
   EXPECT_STREQ(expectedString.c_str(), buf);
 }
 
 TEST(Printf, OverflowStr) {
   char buf[] = "123456789";
-  uptr len = internal_snprintf(buf, 4, "%s", "abcdef");  // NOLINT
+  uptr len = internal_snprintf(buf, 4, "%s", "abcdef");
   EXPECT_EQ(len, (uptr)6);
   EXPECT_STREQ("abc", buf);
   EXPECT_EQ(buf[3], 0);
   EXPECT_EQ(buf[4], '5');
   EXPECT_EQ(buf[5], '6');
   EXPECT_EQ(buf[6], '7');
   EXPECT_EQ(buf[7], '8');
   EXPECT_EQ(buf[8], '9');
   EXPECT_EQ(buf[9], 0);
 }
 
 TEST(Printf, OverflowInt) {
   char buf[] = "123456789";
-  internal_snprintf(buf, 4, "%d", -123456789);  // NOLINT
+  internal_snprintf(buf, 4, "%d", -123456789);
   EXPECT_STREQ("-12", buf);
   EXPECT_EQ(buf[3], 0);
   EXPECT_EQ(buf[4], '5');
   EXPECT_EQ(buf[5], '6');
   EXPECT_EQ(buf[6], '7');
   EXPECT_EQ(buf[7], '8');
   EXPECT_EQ(buf[8], '9');
   EXPECT_EQ(buf[9], 0);
 }
 
 TEST(Printf, OverflowUint) {
   char buf[] = "123456789";
   uptr val;
   if (sizeof(val) == 4) {
     val = (uptr)0x12345678;
   } else {
     val = (uptr)0x123456789ULL;
   }
-  internal_snprintf(buf, 4, "a%zx", val);  // NOLINT
+  internal_snprintf(buf, 4, "a%zx", val);
   EXPECT_STREQ("a12", buf);
   EXPECT_EQ(buf[3], 0);
   EXPECT_EQ(buf[4], '5');
   EXPECT_EQ(buf[5], '6');
   EXPECT_EQ(buf[6], '7');
   EXPECT_EQ(buf[7], '8');
   EXPECT_EQ(buf[8], '9');
   EXPECT_EQ(buf[9], 0);
 }
 
 TEST(Printf, OverflowPtr) {
   char buf[] = "123456789";
   void *p;
   if (sizeof(p) == 4) {
     p = (void*)0x1234567;
   } else {
     p = (void*)0x123456789ULL;
   }
-  internal_snprintf(buf, 4, "%p", p);  // NOLINT
+  internal_snprintf(buf, 4, "%p", p);
   EXPECT_STREQ("0x0", buf);
   EXPECT_EQ(buf[3], 0);
   EXPECT_EQ(buf[4], '5');
   EXPECT_EQ(buf[5], '6');
   EXPECT_EQ(buf[6], '7');
   EXPECT_EQ(buf[7], '8');
   EXPECT_EQ(buf[8], '9');
   EXPECT_EQ(buf[9], 0);
TEST(Printf, Precision) {
   len = internal_snprintf(buf, sizeof(buf), "%.*s", 6, "12345");
   EXPECT_EQ(5U, len);
   EXPECT_STREQ("12345", buf);
   len = internal_snprintf(buf, sizeof(buf), "%-6s", "12345");
   EXPECT_EQ(6U, len);
   EXPECT_STREQ("12345 ", buf);
   // Check that width does not overflow the smaller buffer, although
   // 10 chars is requested, it stops at the buffer size, 8.
-  len = internal_snprintf(buf, 8, "%-10s", "12345");  // NOLINT
+  len = internal_snprintf(buf, 8, "%-10s", "12345");
   EXPECT_EQ(10U, len);  // The required size reported.
   EXPECT_STREQ("12345  ", buf);
 }
 
 #ifdef __x86_64__
 TEST(Printf, M128) {
   __m128i v = _mm_set_epi32(0x12345678, 0x0a0a0a0a, 0xb0b0b0b0, 0xaabbccdd);
   char buf[128];

compiler-rt/lib/tsan/rtl/tsan_interface.h

 void __tsan_external_write(void *addr, void *caller_pc, void *tag);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_read_range(void *addr, unsigned long size);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_write_range(void *addr, unsigned long size);
 
 SANITIZER_INTERFACE_ATTRIBUTE
-void __tsan_read_range_pc(void *addr, unsigned long size, void *pc);  // NOLINT
+void __tsan_read_range_pc(void *addr, unsigned long size, void *pc);
 SANITIZER_INTERFACE_ATTRIBUTE
-void __tsan_write_range_pc(void *addr, unsigned long size, void *pc);  // NOLINT
+void __tsan_write_range_pc(void *addr, unsigned long size, void *pc);
 
 // User may provide function that would be called right when TSan detects
 // an error. The argument 'report' is an opaque pointer that can be used to
 // gather additional information using other TSan report API functions.
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_on_report(void *report);
 
 // If TSan is currently reporting a detected issue on the current thread,

compiler-rt/test/asan/TestCases/vla_condition_overflow.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 //
 // REQUIRES: stable-runtime
 
 #include <assert.h>
 #include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   if (index > len) {
-    char str[len]; //NOLINT
+    char str[len];
     assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
     str[index] = '1'; // BOOM
 // CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
   }
 }
 
 int main(int argc, char **argv) {
   foo(33, 10);
   return 0;
 }

compiler-rt/test/lsan/TestCases/use_globals_unused.cpp

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #ifdef TEST_LIB
 
 void set(char *a) {
-  strcpy(a, "hello"); // NOLINT
+  strcpy(a, "hello");
 }
 
 #else
 
 static void *g;
 
 void set(char *a);
 void foo(void *a) {

compiler-rt/utils/generate_netbsd_ioctls.awk

for (i = 0; i < ioctl_table_max; i++) {
     pcmd("  _(" ioctl_name[i] ", " ioctl_mode[i] "," type ");")
 
     if (ioctl_name[i] == "NVMM_IOC_CTL") {
       pcmd("#endif")
     }
   }
 
   pcmd("#undef _")
-  pcmd("}   // NOLINT")
+  pcmd("}")
   pcmd("")
   pcmd("static bool ioctl_initialized = false;")
   pcmd("")
   pcmd("struct ioctl_desc_compare {")
   pcmd("  bool operator()(const ioctl_desc& left, const ioctl_desc& right) const {")
   pcmd("    return left.req < right.req;")
   pcmd("  }")
   pcmd("};")