hwasan: Reland "hwasan: lay groundwork for importing subset of sanitizer_common interceptors [NFC]" with fixes

[thurston]

Summary

https://reviews.llvm.org/D150708 had been reverted because of a stage2/hwasan check failure
(https://lab.llvm.org/buildbot/#/builders/236/builds/4069). That 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 sanitizer_common issue was fixed in https://reviews.llvm.org/D150909

Compared to https://reviews.llvm.org/D150708, this patch clears the newly added SANITIZER_INTERCEPTOR_WCSLEN.

This patch also subsumes two minor fixes that had been applied on top of D150708 (unused variables and functions).

Original commit message:
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]

for reland we usually reopen original review and upload new version there

[thurston]

Will reopen original review

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

 #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