[Sanitizers] Use SANITIZER_* macros in lib/interception

[ro]

Summary

Unlike the rest of the sanitizer code, lib/interception uses native macros like linux
to check for specific targets instead of the common ones like SANITIZER_LINUX.

When working on the Solaris port of the sanitizers, the current style was found to not
only be inconsistent, but clumsy to use because the canonical way to check for Solaris
is to check for sun && svr4 which is a mouthful.

Therefore, this patch switches to use SANITIZER_* macros instead.

Tested on x86_64-pc-linux-gnu.

[krytarowski]

lib/interception/interception.h

267

SANITIZER_NETBSD

lib/interception/interception_mac.cc

17

Does it make sense?

[ro]

lib/interception/interception_mac.cc

17

How do you mean? One could do away with the effectively empty
file completely.

[ro]

Fixed capitalization.

lib/interception/interception_mac.cc

17

Sorry but I still don't know what you mean here.

[krytarowski]

lib/interception/interception_mac.cc

17

I would just drop this:

#if SANITIZER_MAC
#endif

[ro]

Remove unused guard.

[ro]

lib/interception/interception_mac.cc

17

Fine with me. However, there's the risk of breaking non-OS X
builds if there's code added to the file and the guard forgotten...

But let's cross that bridge when/if we get there.

[vitalybuka]

lib/interception/interception_mac.cc

17

I'd probably keep this for consistency with other platform specific files.

[ro]

Effectively restored to previous revision.

[ro]

Thanks for the approval. Could you (or someone else) please commit this for me?

lib/interception/interception.h

 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Machinery for providing replacements/wrappers for system functions.
 //===----------------------------------------------------------------------===//
 
 #ifndef INTERCEPTION_H
 #define INTERCEPTION_H
 
-#if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__APPLE__) && \
-    !defined(__NetBSD__) && !defined(_WIN32) && !defined(__Fuchsia__)
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+#if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_MAC && \
+    !SANITIZER_NETBSD && !SANITIZER_WINDOWS && !SANITIZER_FUCHSIA
 # error "Interception doesn't work on this operating system."
 #endif
 
-#include "sanitizer_common/sanitizer_internal_defs.h"
-
 // These typedefs should be used only in the interceptor definitions to replace
 // the standard system types (e.g. SSIZE_T instead of ssize_t)
 typedef __sanitizer::uptr    SIZE_T;
 typedef __sanitizer::sptr    SSIZE_T;
 typedef __sanitizer::sptr    PTRDIFF_T;
 typedef __sanitizer::s64     INTMAX_T;
 typedef __sanitizer::OFF_T   OFF_T;
 typedef __sanitizer::OFF64_T OFF64_T;

 // Instead we create a dylib containing a __DATA,__interpose section that
 // associates library functions with their wrappers. When this dylib is
 // preloaded before an executable using DYLD_INSERT_LIBRARIES, it routes all
 // the calls to interposed functions done through stubs to the wrapper
 // functions.
 // As it's decided at compile time which functions are to be intercepted on Mac,
 // INTERCEPT_FUNCTION() is effectively a no-op on this system.
 
-#if defined(__APPLE__)
+#if SANITIZER_MAC
 #include <sys/cdefs.h>  // For __DARWIN_ALIAS_C().
 
 // Just a pair of pointers.
 struct interpose_substitution {
   const __sanitizer::uptr replacement;
   const __sanitizer::uptr original;
 };
 
__attribute__((section("__DATA, __interpose"))) = { \
       reinterpret_cast<const uptr>(func_name) } \
 }
 
 # define WRAP(x) wrap_##x
 # define WRAPPER_NAME(x) "wrap_"#x
 # define INTERCEPTOR_ATTRIBUTE
 # define DECLARE_WRAPPER(ret_type, func, ...)
 
-#elif defined(_WIN32)
+#elif SANITIZER_WINDOWS
 # define WRAP(x) __asan_wrap_##x
 # define WRAPPER_NAME(x) "__asan_wrap_"#x
 # define INTERCEPTOR_ATTRIBUTE __declspec(dllexport)
 # define DECLARE_WRAPPER(ret_type, func, ...) \
     extern "C" ret_type func(__VA_ARGS__);
 # define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \
     extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__);
-#elif defined(__FreeBSD__) || defined(__NetBSD__)
+#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
 # define WRAP(x) __interceptor_ ## x
 # define WRAPPER_NAME(x) "__interceptor_" #x
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
 // FreeBSD's dynamic linker (incompliantly) gives non-weak symbols higher
 // priority than weak ones so weak aliases won't work for indirect calls
 // in position-independent (-fPIC / -fPIE) mode.
 # define DECLARE_WRAPPER(ret_type, func, ...) \
      extern "C" ret_type func(__VA_ARGS__) \
      __attribute__((alias("__interceptor_" #func), visibility("default")));
-#elif !defined(__Fuchsia__)
+#elif !SANITIZER_FUCHSIA
 # define WRAP(x) __interceptor_ ## x
 # define WRAPPER_NAME(x) "__interceptor_" #x
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
 # define DECLARE_WRAPPER(ret_type, func, ...) \
     extern "C" ret_type func(__VA_ARGS__) \
     __attribute__((weak, alias("__interceptor_" #func), visibility("default")));
 #endif
 
-#if defined(__Fuchsia__)
+#if SANITIZER_FUCHSIA
 // There is no general interception at all on Fuchsia.
 // Sanitizer runtimes just define functions directly to preempt them,
 // and have bespoke ways to access the underlying libc functions.
 # include <zircon/sanitizer.h>
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
 # define REAL(x) __unsanitized_##x
 # define DECLARE_REAL(ret_type, func, ...)
-#elif !defined(__APPLE__)
+#elif !SANITIZER_MAC
 # define PTR_TO_REAL(x) real_##x
 # define REAL(x) __interception::PTR_TO_REAL(x)
 # define FUNC_TYPE(x) x##_f
 
 # define DECLARE_REAL(ret_type, func, ...) \
     typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \
     namespace __interception { \
       extern FUNC_TYPE(func) PTR_TO_REAL(func); \
     }
 # define ASSIGN_REAL(dst, src) REAL(dst) = REAL(src)
-#else  // __APPLE__
+#else  // SANITIZER_MAC
 # define REAL(x) x
 # define DECLARE_REAL(ret_type, func, ...) \
     extern "C" ret_type func(__VA_ARGS__);
 # define ASSIGN_REAL(x, y)
-#endif  // __APPLE__
+#endif  // SANITIZER_MAC
 
-#if !defined(__Fuchsia__)
+#if !SANITIZER_FUCHSIA
 #define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...) \
   DECLARE_REAL(ret_type, func, __VA_ARGS__) \
   extern "C" ret_type WRAP(func)(__VA_ARGS__);
 #else
 #define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...)
 #endif
 
 // Generally, you don't need to use DEFINE_REAL by itself, as INTERCEPTOR
 // macros does its job. In exceptional cases you may need to call REAL(foo)
 // without defining INTERCEPTOR(..., foo, ...). For example, if you override
 // foo with an interceptor for other function.
-#if !defined(__APPLE__) && !defined(__Fuchsia__)
+#if !SANITIZER_MAC && !SANITIZER_FUCHSIA
 # define DEFINE_REAL(ret_type, func, ...) \
     typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \
     namespace __interception { \
       FUNC_TYPE(func) PTR_TO_REAL(func); \
     }
 #else
 # define DEFINE_REAL(ret_type, func, ...)
 #endif
 
-#if defined(__Fuchsia__)
+#if SANITIZER_FUCHSIA
 
 // We need to define the __interceptor_func name just to get
 // sanitizer_common/scripts/gen_dynamic_list.py to export func.
 // But we don't need to export __interceptor_func to get that.
 #define INTERCEPTOR(ret_type, func, ...)                                \
   extern "C"[[ gnu::alias(#func), gnu::visibility("hidden") ]] ret_type \
       __interceptor_##func(__VA_ARGS__);                                \
   extern "C" INTERCEPTOR_ATTRIBUTE ret_type func(__VA_ARGS__)
 
-#elif !defined(__APPLE__)
+#elif !SANITIZER_MAC
 
 #define INTERCEPTOR(ret_type, func, ...) \
   DEFINE_REAL(ret_type, func, __VA_ARGS__) \
   DECLARE_WRAPPER(ret_type, func, __VA_ARGS__) \
   extern "C" \
   INTERCEPTOR_ATTRIBUTE \
   ret_type WRAP(func)(__VA_ARGS__)
 
 // We don't need INTERCEPTOR_WITH_SUFFIX on non-Darwin for now.
 #define INTERCEPTOR_WITH_SUFFIX(ret_type, func, ...) \
   INTERCEPTOR(ret_type, func, __VA_ARGS__)
 
-#else  // __APPLE__
+#else  // SANITIZER_MAC
 
 #define INTERCEPTOR_ZZZ(suffix, ret_type, func, ...) \
   extern "C" ret_type func(__VA_ARGS__) suffix; \
   extern "C" ret_type WRAP(func)(__VA_ARGS__); \
   INTERPOSER(func); \
   extern "C" INTERCEPTOR_ATTRIBUTE ret_type WRAP(func)(__VA_ARGS__)
 
 #define INTERCEPTOR(ret_type, func, ...) \
   INTERCEPTOR_ZZZ(/*no symbol variants*/, ret_type, func, __VA_ARGS__)
 
 #define INTERCEPTOR_WITH_SUFFIX(ret_type, func, ...) \
   INTERCEPTOR_ZZZ(__DARWIN_ALIAS_C(func), ret_type, func, __VA_ARGS__)
 
 // Override |overridee| with |overrider|.
 #define OVERRIDE_FUNCTION(overridee, overrider) \
   INTERPOSER_2(overridee, WRAP(overrider))
 #endif
 
-#if defined(_WIN32)
+#if SANITIZER_WINDOWS
 # define INTERCEPTOR_WINAPI(ret_type, func, ...) \
     typedef ret_type (__stdcall *FUNC_TYPE(func))(__VA_ARGS__); \
     namespace __interception { \
       FUNC_TYPE(func) PTR_TO_REAL(func); \
     } \
     extern "C" \
     INTERCEPTOR_ATTRIBUTE \
     ret_type __stdcall WRAP(func)(__VA_ARGS__)

 typedef unsigned long long uptr;  // NOLINT
 #else
 typedef unsigned long uptr;  // NOLINT
 #endif  // _WIN64
 }  // namespace __interception
 
 #define INCLUDED_FROM_INTERCEPTION_LIB
 
-#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 # include "interception_linux.h"
 # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
 # define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver)
-#elif defined(__APPLE__)
+#elif SANITIZER_MAC
 # include "interception_mac.h"
 # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_MAC(func)
 # define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_MAC(func, symver)
-#elif defined(_WIN32)
+#elif SANITIZER_WINDOWS
 # include "interception_win.h"
 # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_WIN(func)
 # define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_WIN(func, symver)
 #endif
 
 #undef INCLUDED_FROM_INTERCEPTION_LIB
 
 #endif  // INTERCEPTION_H

lib/interception/interception_linux.h

 //===-- interception_linux.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Linux-specific interception methods.
 //===----------------------------------------------------------------------===//
 
-#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
 # error "interception_linux.h should be included from interception library only"
 #endif
 
 #ifndef INTERCEPTION_LINUX_H
 #define INTERCEPTION_LINUX_H
 
 namespace __interception {
 // returns true if a function with the given name was found.
 bool GetRealFunctionAddress(const char *func_name, uptr *func_addr,
     uptr real, uptr wrapper);
 void *GetFuncAddrVer(const char *func_name, const char *ver);
 }  // namespace __interception
 
 #define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)                          \
   ::__interception::GetRealFunctionAddress(                                \
       #func, (::__interception::uptr *)&__interception::PTR_TO_REAL(func), \
       (::__interception::uptr) & (func),                                   \
       (::__interception::uptr) & WRAP(func))
 
-#if !defined(__ANDROID__)  // android does not have dlvsym
+#if !SANITIZER_ANDROID  // android does not have dlvsym
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
   (::__interception::real_##func = (func##_f)(                \
        unsigned long)::__interception::GetFuncAddrVer(#func, symver))
 #else
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
   INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
-#endif  // !defined(__ANDROID__)
+#endif  // !SANITIZER_ANDROID
 
 #endif  // INTERCEPTION_LINUX_H
-#endif  // __linux__ || __FreeBSD__ || __NetBSD__
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD

lib/interception/interception_linux.cc

 //===-- interception_linux.cc -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Linux-specific interception methods.
 //===----------------------------------------------------------------------===//
 
-#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
 #include "interception.h"
 
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
+
 #include <dlfcn.h>   // for dlsym() and dlvsym()
 
-#ifdef __NetBSD__
+#if SANITIZER_NETBSD
 #include "sanitizer_common/sanitizer_libc.h"
 #endif
 
 namespace __interception {
 bool GetRealFunctionAddress(const char *func_name, uptr *func_addr,
     uptr real, uptr wrapper) {
-#ifdef __NetBSD__
+#if SANITIZER_NETBSD
   // XXX: Find a better way to handle renames
   if (internal_strcmp(func_name, "sigaction") == 0) func_name = "__sigaction14";
 #endif
   *func_addr = (uptr)dlsym(RTLD_NEXT, func_name);
   if (!*func_addr) {
     // If the lookup using RTLD_NEXT failed, the sanitizer runtime library is
     // later in the library search order than the DSO that we are trying to
     // intercept, which means that we cannot intercept this function. We still
     // want the address of the real definition, though, so look it up using
     // RTLD_DEFAULT.
     *func_addr = (uptr)dlsym(RTLD_DEFAULT, func_name);
   }
   return real == wrapper;
 }
 
-#if !defined(__ANDROID__)  // android does not have dlvsym
+#if !SANITIZER_ANDROID  // android does not have dlvsym
 void *GetFuncAddrVer(const char *func_name, const char *ver) {
   return dlvsym(RTLD_NEXT, func_name, ver);
 }
-#endif  // !defined(__ANDROID__)
+#endif  // !SANITIZER_ANDROID
 
 }  // namespace __interception
 
-#endif  // __linux__ || __FreeBSD__ || __NetBSD__
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD

lib/interception/interception_mac.h

 //===-- interception_mac.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Mac-specific interception methods.
 //===----------------------------------------------------------------------===//
 
-#ifdef __APPLE__
+#if SANITIZER_MAC
 
 #if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
 # error "interception_mac.h should be included from interception.h only"
 #endif
 
 #ifndef INTERCEPTION_MAC_H
 #define INTERCEPTION_MAC_H
 
 #define INTERCEPT_FUNCTION_MAC(func)
 #define INTERCEPT_FUNCTION_VER_MAC(func, symver)
 
 #endif  // INTERCEPTION_MAC_H
-#endif  // __APPLE__
+#endif  // SANITIZER_MAC

lib/interception/interception_mac.cc

 //===-- interception_mac.cc -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Mac-specific interception methods.
 //===----------------------------------------------------------------------===//
 
-#ifdef __APPLE__
-
 #include "interception.h"
 
+#if SANITIZER_MAC
 
-#endif  // __APPLE__
+#endif  // SANITIZER_MAC

lib/interception/interception_type_test.cc

 //===-- interception_type_test.cc -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Compile-time tests of the internal type definitions.
 //===----------------------------------------------------------------------===//
 
-#if defined(__linux__) || defined(__APPLE__)
-
 #include "interception.h"
+
+#if SANITIZER_LINUX || SANITIZER_MAC
+
 #include <sys/types.h>
 #include <stddef.h>
 #include <stdint.h>
 
 COMPILER_CHECK(sizeof(::SIZE_T) == sizeof(size_t));
 COMPILER_CHECK(sizeof(::SSIZE_T) == sizeof(ssize_t));
 COMPILER_CHECK(sizeof(::PTRDIFF_T) == sizeof(ptrdiff_t));
 COMPILER_CHECK(sizeof(::INTMAX_T) == sizeof(intmax_t));
 
-#ifndef __APPLE__
+#if !SANITIZER_MAC
 COMPILER_CHECK(sizeof(::OFF64_T) == sizeof(off64_t));
 #endif
 
 // The following are the cases when pread (and friends) is used instead of
 // pread64. In those cases we need OFF_T to match off_t. We don't care about the
 // rest (they depend on _FILE_OFFSET_BITS setting when building an application).
-# if defined(__ANDROID__) || !defined _FILE_OFFSET_BITS || \
+# if SANITIZER_ANDROID || !defined _FILE_OFFSET_BITS || \
   _FILE_OFFSET_BITS != 64
 COMPILER_CHECK(sizeof(::OFF_T) == sizeof(off_t));
 # endif
 
 #endif

lib/interception/interception_win.h

 //===-- interception_linux.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Windows-specific interception methods.
 //===----------------------------------------------------------------------===//
 
-#ifdef _WIN32
+#if SANITIZER_WINDOWS
 
 #if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
 # error "interception_win.h should be included from interception library only"
 #endif
 
 #ifndef INTERCEPTION_WIN_H
 #define INTERCEPTION_WIN_H
 

 #define INTERCEPT_FUNCTION_VER_WIN(func, symver) INTERCEPT_FUNCTION_WIN(func)
 
 #define INTERCEPT_FUNCTION_DLLIMPORT(user_dll, provider_dll, func)       \
   ::__interception::OverrideImportedFunction(                            \
       user_dll, provider_dll, #func, (::__interception::uptr)WRAP(func), \
       (::__interception::uptr *)&REAL(func))
 
 #endif  // INTERCEPTION_WIN_H
-#endif  // _WIN32
+#endif  // SANITIZER_WINDOWS

lib/interception/interception_win.cc

 //                                   [trampoline]
 //                                      addr1:  .bytes <hook>
 //                                       real:  <instr>
 //                                              <instr>
 //                                              jmp QWORD [addr2]
 //                                      addr2:  .bytes <body>
 //===----------------------------------------------------------------------===//
 
-#ifdef _WIN32
-
 #include "interception.h"
+
+#if SANITIZER_WINDOWS
 #include "sanitizer_common/sanitizer_platform.h"
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
 namespace __interception {
 
 static const int kAddressLength = FIRST_32_SECOND_64(4, 8);
 static const int kJumpInstructionLength = 5;
bool OverrideImportedFunction(const char *module_to_patch,
   iat->u1.AddressOfData = new_function;
   if (!VirtualProtect(&iat->u1.AddressOfData, 4, old_prot, &unused_prot))
     return false;  // Not clear if this failure bothers us.
   return true;
 }
 
 }  // namespace __interception
 
-#endif  // _WIN32
+#endif  // SANITIZER_MAC