[sanitizers] Do not define __has_feature in sanitizer/common_interface_defs.h

[jwakely]

Summary

Public headers intended for user code should not define __has_feature,
because this can break preprocessor checks done later in user code, e.g.
if they test #ifdef __has_feature to check for real support in the
compiler.

Replace the only use in the public header with a check for it being
supported before trying to use it. Define the fallback definition in the
internal headers, so that other internal sanitizer headers can continue
to use it as preferred.

This resolves a bug reported to GCC as https://gcc.gnu.org/PR109882

[jwakely]

Moved to https://github.com/llvm/llvm-project/pull/66628

compiler-rt/include/sanitizer/asan_interface.h

 /// \note This function is not thread-safe because no two threads can
 /// poison or unpoison memory in the same memory region simultaneously.
 ///
 /// \param addr Start of memory region.
 /// \param size Size of memory region.
 void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
 
 // Macros provided for convenience.
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+#ifdef __has_feature
+#if __has_feature(address_sanitizer)
+#define ASAN_DEFINE_REGION_MACROS
+#endif
+#elif defined(__SANITIZE_ADDRESS__)
+#define ASAN_DEFINE_REGION_MACROS
+#endif
+
+#ifdef ASAN_DEFINE_REGION_MACROS
 /// Marks a memory region as unaddressable.
 ///
 /// \note Macro provided for convenience; defined as a no-op if ASan is not
 /// enabled.
 ///
 /// \param addr Start of memory region.
 /// \param size Size of memory region.
 #define ASAN_POISON_MEMORY_REGION(addr, size) \

 #define ASAN_UNPOISON_MEMORY_REGION(addr, size) \
   __asan_unpoison_memory_region((addr), (size))
 #else
 #define ASAN_POISON_MEMORY_REGION(addr, size) \
   ((void)(addr), (void)(size))
 #define ASAN_UNPOISON_MEMORY_REGION(addr, size) \
   ((void)(addr), (void)(size))
 #endif
+#undef ASAN_DEFINE_REGION_MACROS
 
 /// Checks if an address is poisoned.
 ///
 /// Returns 1 if <c><i>addr</i></c> is poisoned (that is, 1-byte read/write
 /// access to this address would result in an error report from ASan).
 /// Otherwise returns 0.
 ///
 /// \param addr Address to check.

compiler-rt/include/sanitizer/common_interface_defs.h

 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_COMMON_INTERFACE_DEFS_H
 #define SANITIZER_COMMON_INTERFACE_DEFS_H
 
 #include <stddef.h>
 #include <stdint.h>
 
-// GCC does not understand __has_feature.
-#if !defined(__has_feature)
-#define __has_feature(x) 0
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 // Arguments for __sanitizer_sandbox_on_notify() below.
 typedef struct {
   // Enable sandbox support in sanitizer coverage.
   int coverage_sandboxed;
   // File descriptor to write coverage data to. If -1 is passed, a file will

compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h

 //===-- sanitizer_internal_defs.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer.
 // It contains macro used in run-time libraries code.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_DEFS_H
 #define SANITIZER_DEFS_H
 
 #include "sanitizer_platform.h"
 
+// GCC does not understand __has_feature.
+#if !defined(__has_feature)
+#define __has_feature(x) 0
+#endif
+
 #ifndef SANITIZER_DEBUG
 # define SANITIZER_DEBUG 0
 #endif
 
 #define SANITIZER_STRINGIFY_(S) #S
 #define SANITIZER_STRINGIFY(S) SANITIZER_STRINGIFY_(S)
 
 // Only use SANITIZER_*ATTRIBUTE* before the function return type!