hwasan: lay groundwork for importing subset of sanitizer_common interceptors [NFC]

[thurston]

Summary

This patch does the bare minimum to import sanitizer_common_interceptors, but
without actually enabling any interceptors or meaningfully defining the
COMMON_INTERCEPT macros.

This will allow selectively enabling sanitizer_common interceptors (if the
appropriate macros are defined), as suggested by Vitaly in D149701.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_platform_interceptors.h

1

#include guards?

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

39 ↗

(On Diff #522741)

why we need to change this, I would expect it's in the search path ?

[thurston]

Add #include guards

Revert unnnecessary path specification

[thurston]

compiler-rt/lib/hwasan/hwasan_platform_interceptors.h

1

Done

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

39 ↗

(On Diff #522741)

You're correct, it's not necessary.

Somehow I had encountered a build error earlier on that needed this, but it seems fine now.

[pcc]

I think this broke the sanitizer-aarch64-linux-bootstrap-hwasan buildbot (caused "stage2/hwasan check" to start failing).

First test failure: https://lab.llvm.org/buildbot/#/builders/236/builds/4069

[thurston]

In D150708#4350613, @pcc wrote:

I think this broke the sanitizer-aarch64-linux-bootstrap-hwasan buildbot (caused "stage2/hwasan check" to start failing).

First test failure: https://lab.llvm.org/buildbot/#/builders/236/builds/4069

Thanks Peter for the heads up! I've reverted it in https://reviews.llvm.org/rG70e0c8ffcb71486b17bdee305ba49e80b03d00f5

[thurston]

The stage2/hwasan check failure has been fixed in https://reviews.llvm.org/D150909 - it was
due to a missing SANITIZER_INTERCEPTOR_ guard for wcslen in sanitizer_common; as a result, the wcslen interceptor had been erroneously included in hwasan.

This patch has been updated to:

• clear the newly added SANITIZER_INTERCEPTOR_WCSLEN macro
• subsume the minor fixes for unused variables and functions

compiler-rt/lib/hwasan/hwasan_interceptors.cpp

 // Interceptors for standard library functions.
 //
 // FIXME: move as many interceptors as possible into
 // sanitizer_common/sanitizer_common_interceptors.h
 //===----------------------------------------------------------------------===//
 
 #include "hwasan.h"
 #include "hwasan_checks.h"
+#include "hwasan_platform_interceptors.h"
 #include "hwasan_thread.h"
 #include "hwasan_thread_list.h"
 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 
 #if !SANITIZER_FUCHSIA
 

 #    define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
       do {                                        \
         (void)(p);                                \
         (void)(s);                                \
       } while (false)
 #    include "sanitizer_common/sanitizer_common_syscalls.inc"
 #    include "sanitizer_common/sanitizer_syscalls_netbsd.inc"
 
+#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
+  do {                                                \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
+  do {                                                \
+    (void)(ctx);                                      \
+    (void)(ptr);                                      \
+    (void)(size);                                     \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...) \
+  do {                                           \
+    (void)(ctx);                                 \
+    (void)(func);                                \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
+  do {                                            \
+    (void)(ctx);                                  \
+    (void)(path);                                 \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
+  do {                                         \
+    (void)(ctx);                               \
+    (void)(fd);                                \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
+  do {                                         \
+    (void)(ctx);                               \
+    (void)(fd);                                \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
+  do {                                                      \
+    (void)(ctx);                                            \
+    (void)(fd);                                             \
+    (void)(newfd);                                          \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) \
+  do {                                                \
+    (void)(ctx);                                      \
+    (void)(name);                                     \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
+  do {                                                         \
+    (void)(ctx);                                               \
+    (void)(thread);                                            \
+    (void)(name);                                              \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_BLOCK_REAL(name) \
+  do {                                      \
+    (void)(name);                           \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, to, from, size) \
+  do {                                                       \
+    (void)(ctx);                                             \
+    (void)(to);                                              \
+    (void)(from);                                            \
+    (void)(size);                                            \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, to, from, size) \
+  do {                                                      \
+    (void)(ctx);                                            \
+    (void)(to);                                             \
+    (void)(from);                                           \
+    (void)(size);                                           \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, c, size) \
+  do {                                                      \
+    (void)(ctx);                                            \
+    (void)(block);                                          \
+    (void)(c);                                              \
+    (void)(size);                                           \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_STRERROR() \
+  do {                                \
+  } while (false)
+
+#define COMMON_INTERCEPT_FUNCTION(name) \
+  do {                                  \
+    (void)(name);                       \
+  } while (false)
+
+#include "sanitizer_common/sanitizer_common_interceptors.inc"
+
 struct ThreadStartArg {
   __sanitizer_sigset_t starting_sigset_;
 };
 
 static void *HwasanThreadStartFunc(void *arg) {
   __hwasan_thread_enter();
   ThreadStartArg A = *reinterpret_cast<ThreadStartArg *>(arg);
   SetSigProcMask(&A.starting_sigset_, nullptr);

 }  // namespace __hwasan
 
 namespace __hwasan {
 
 void InitializeInterceptors() {
   static int inited = 0;
   CHECK_EQ(inited, 0);
 
+  (void)(InitializeCommonInterceptors);
+  (void)(read_iovec);
+  (void)(write_iovec);
+
 #  if HWASAN_WITH_INTERCEPTORS
 #    if defined(__linux__)
   INTERCEPT_FUNCTION(__libc_longjmp);
   INTERCEPT_FUNCTION(longjmp);
   INTERCEPT_FUNCTION(siglongjmp);
   INTERCEPT_FUNCTION(vfork);
 #    endif  // __linux__
   INTERCEPT_FUNCTION(pthread_create);

compiler-rt/lib/hwasan/hwasan_platform_interceptors.h

 #ifndef HWASAN_PLATFORM_INTERCEPTORS_H
 #define HWASAN_PLATFORM_INTERCEPTORS_H
 
 #include "sanitizer_common/sanitizer_platform_interceptors.h"
 
 // cat sanitizer_platform_interceptors.h  | grep '^#define SANITIZER_INTERCEPT' | cut -d ' ' -f 1,2 | sed -r 's/^#define/#undef/'
 #undef SANITIZER_INTERCEPT_STRLEN
 #undef SANITIZER_INTERCEPT_STRNLEN
 #undef SANITIZER_INTERCEPT_STRCMP

 #undef SANITIZER_INTERCEPT_MEMALIGN
 #undef SANITIZER_INTERCEPT___LIBC_MEMALIGN
 #undef SANITIZER_INTERCEPT_PVALLOC
 #undef SANITIZER_INTERCEPT_CFREE
 #undef SANITIZER_INTERCEPT_REALLOCARRAY
 #undef SANITIZER_INTERCEPT_ALIGNED_ALLOC
 #undef SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE
 #undef SANITIZER_INTERCEPT_MCHECK_MPROBE
+#undef SANITIZER_INTERCEPT_WCSLEN
 #undef SANITIZER_INTERCEPT_WCSCAT
 #undef SANITIZER_INTERCEPT_WCSDUP
 #undef SANITIZER_INTERCEPT_SIGNAL_AND_SIGACTION
 #undef SANITIZER_INTERCEPT_BSD_SIGNAL
 #undef SANITIZER_INTERCEPT_ACCT
 #undef SANITIZER_INTERCEPT_USER_FROM_UID
 #undef SANITIZER_INTERCEPT_UID_FROM_USER
 #undef SANITIZER_INTERCEPT_GROUP_FROM_GID

 #define SANITIZER_INTERCEPT_MEMALIGN 0
 #define SANITIZER_INTERCEPT___LIBC_MEMALIGN 0
 #define SANITIZER_INTERCEPT_PVALLOC 0
 #define SANITIZER_INTERCEPT_CFREE 0
 #define SANITIZER_INTERCEPT_REALLOCARRAY 0
 #define SANITIZER_INTERCEPT_ALIGNED_ALLOC 0
 #define SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE 0
 #define SANITIZER_INTERCEPT_MCHECK_MPROBE 0
+#define SANITIZER_INTERCEPT_WCSLEN 0
 #define SANITIZER_INTERCEPT_WCSCAT 0
 #define SANITIZER_INTERCEPT_WCSDUP 0
 #define SANITIZER_INTERCEPT_SIGNAL_AND_SIGACTION 0
 #define SANITIZER_INTERCEPT_BSD_SIGNAL 0
 #define SANITIZER_INTERCEPT_ACCT 0
 #define SANITIZER_INTERCEPT_USER_FROM_UID 0
 #define SANITIZER_INTERCEPT_UID_FROM_USER 0
 #define SANITIZER_INTERCEPT_GROUP_FROM_GID 0