Generate a compile error if release is built without compiler optimizations
[WebKit-https.git] / Source / WTF / wtf / Compiler.h
index d1a9ed7..6975234 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2012, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 /* COMPILER_QUIRK() - whether the compiler being used to build the project requires a given quirk. */
 #define COMPILER_QUIRK(WTF_COMPILER_QUIRK) (defined WTF_COMPILER_QUIRK_##WTF_COMPILER_QUIRK  && WTF_COMPILER_QUIRK_##WTF_COMPILER_QUIRK)
 
-/* ==== COMPILER() - the compiler being used to build the project ==== */
-
-/* COMPILER(CLANG) - Clang  */
-#if defined(__clang__)
-#define WTF_COMPILER_CLANG 1
-
-#ifndef __has_extension
-#define __has_extension __has_feature /* Compatibility with older versions of clang */
+/* COMPILER_HAS_CLANG_BUILTIN() - whether the compiler supports a particular clang builtin. */
+#ifdef __has_builtin
+#define COMPILER_HAS_CLANG_BUILTIN(x) __has_builtin(x)
+#else
+#define COMPILER_HAS_CLANG_BUILTIN(x) 0
 #endif
 
-#define CLANG_PRAGMA(PRAGMA) _Pragma(PRAGMA)
-
-/* Specific compiler features */
-#define WTF_COMPILER_SUPPORTS_CXX_VARIADIC_TEMPLATES __has_extension(cxx_variadic_templates)
-
-/* There is a bug in clang that comes with Xcode 4.2 where AtomicStrings can't be implicitly converted to Strings
-   in the presence of move constructors and/or move assignment operators. This bug has been fixed in Xcode 4.3 clang, so we
-   check for both cxx_rvalue_references as well as the unrelated cxx_nonstatic_member_init feature which we know was added in 4.3 */
-#define WTF_COMPILER_SUPPORTS_CXX_RVALUE_REFERENCES __has_extension(cxx_rvalue_references) && __has_extension(cxx_nonstatic_member_init)
-
-#define WTF_COMPILER_SUPPORTS_CXX_DELETED_FUNCTIONS __has_extension(cxx_deleted_functions)
-#define WTF_COMPILER_SUPPORTS_CXX_NULLPTR __has_feature(cxx_nullptr)
-#define WTF_COMPILER_SUPPORTS_CXX_EXPLICIT_CONVERSIONS __has_feature(cxx_explicit_conversions)
-#define WTF_COMPILER_SUPPORTS_BLOCKS __has_feature(blocks)
-#define WTF_COMPILER_SUPPORTS_C_STATIC_ASSERT __has_extension(c_static_assert)
-#define WTF_COMPILER_SUPPORTS_CXX_STATIC_ASSERT __has_extension(cxx_static_assert)
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL __has_extension(cxx_override_control)
-#define WTF_COMPILER_SUPPORTS_HAS_TRIVIAL_DESTRUCTOR __has_extension(has_trivial_destructor)
-#define WTF_COMPILER_SUPPORTS_CXX_STRONG_ENUMS __has_extension(cxx_strong_enums)
-#define WTF_COMPILER_SUPPORTS_CXX_REFERENCE_QUALIFIED_FUNCTIONS __has_extension(cxx_reference_qualified_functions)
+/* COMPILER_HAS_CLANG_FEATURE() - whether the compiler supports a particular language or library feature. */
+/* http://clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension */
+#ifdef __has_feature
+#define COMPILER_HAS_CLANG_FEATURE(x) __has_feature(x)
+#else
+#define COMPILER_HAS_CLANG_FEATURE(x) 0
 #endif
 
-#ifndef CLANG_PRAGMA
-#define CLANG_PRAGMA(PRAGMA)
+/* COMPILER_HAS_CLANG_DECLSPEC() - whether the compiler supports a Microsoft style __declspec attribute. */
+/* https://clang.llvm.org/docs/LanguageExtensions.html#has-declspec-attribute */
+#ifdef __has_declspec_attribute
+#define COMPILER_HAS_CLANG_DECLSPEC(x) __has_declspec_attribute(x)
+#else
+#define COMPILER_HAS_CLANG_DECLSPEC(x) 0
 #endif
 
-/* COMPILER(MSVC) - Microsoft Visual C++ */
-/* COMPILER(MSVC9_OR_LOWER) - Microsoft Visual C++ 2008 or lower*/
-#if defined(_MSC_VER)
-#define WTF_COMPILER_MSVC 1
-#if _MSC_VER < 1600
-#define WTF_COMPILER_MSVC9_OR_LOWER 1
-#endif
+/* ==== COMPILER() - primary detection of the compiler being used to build the project, in alphabetical order ==== */
 
-/* Specific compiler features */
-#if !COMPILER(CLANG) && _MSC_VER >= 1600
-#define WTF_COMPILER_SUPPORTS_CXX_NULLPTR 1
-#endif
+/* COMPILER(CLANG) - Clang  */
 
-#if !COMPILER(CLANG)
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL 1
-#define WTF_COMPILER_QUIRK_FINAL_IS_CALLED_SEALED 1
-#endif
+#if defined(__clang__)
+#define WTF_COMPILER_CLANG 1
+#define WTF_COMPILER_SUPPORTS_BLOCKS COMPILER_HAS_CLANG_FEATURE(blocks)
+#define WTF_COMPILER_SUPPORTS_C_STATIC_ASSERT COMPILER_HAS_CLANG_FEATURE(c_static_assert)
+#define WTF_COMPILER_SUPPORTS_CXX_REFERENCE_QUALIFIED_FUNCTIONS COMPILER_HAS_CLANG_FEATURE(cxx_reference_qualified_functions)
+#define WTF_COMPILER_SUPPORTS_CXX_EXCEPTIONS COMPILER_HAS_CLANG_FEATURE(cxx_exceptions)
+#define WTF_COMPILER_SUPPORTS_BUILTIN_IS_TRIVIALLY_COPYABLE COMPILER_HAS_CLANG_FEATURE(is_trivially_copyable)
 
+#ifdef __cplusplus
+#if __cplusplus <= 201103L
+#define WTF_CPP_STD_VER 11
+#elif __cplusplus <= 201402L
+#define WTF_CPP_STD_VER 14
 #endif
-
-/* COMPILER(RVCT) - ARM RealView Compilation Tools */
-#if defined(__CC_ARM) || defined(__ARMCC__)
-#define WTF_COMPILER_RVCT 1
-#define RVCT_VERSION_AT_LEAST(major, minor, patch, build) (__ARMCC_VERSION >= (major * 100000 + minor * 10000 + patch * 1000 + build))
-#else
-/* Define this for !RVCT compilers, just so we can write things like RVCT_VERSION_AT_LEAST(3, 0, 0, 0). */
-#define RVCT_VERSION_AT_LEAST(major, minor, patch, build) 0
 #endif
 
-/* COMPILER(GCCE) - GNU Compiler Collection for Embedded */
-#if defined(__GCCE__)
-#define WTF_COMPILER_GCCE 1
-#define GCCE_VERSION (__GCCE__ * 10000 + __GCCE_MINOR__ * 100 + __GCCE_PATCHLEVEL__)
-#define GCCE_VERSION_AT_LEAST(major, minor, patch) (GCCE_VERSION >= (major * 10000 + minor * 100 + patch))
+#endif // defined(__clang__)
+
+/* COMPILER(GCC_OR_CLANG) - GNU Compiler Collection or Clang */
+#if defined(__GNUC__)
+#define WTF_COMPILER_GCC_OR_CLANG 1
 #endif
 
 /* COMPILER(GCC) - GNU Compiler Collection */
-/* --gnu option of the RVCT compiler also defines __GNUC__ */
-#if defined(__GNUC__) && !COMPILER(RVCT)
+/* Note: This section must come after the Clang section since we check !COMPILER(CLANG) here. */
+#if COMPILER(GCC_OR_CLANG) && !COMPILER(CLANG)
 #define WTF_COMPILER_GCC 1
+#define WTF_COMPILER_SUPPORTS_CXX_REFERENCE_QUALIFIED_FUNCTIONS 1
+
 #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #define GCC_VERSION_AT_LEAST(major, minor, patch) (GCC_VERSION >= (major * 10000 + minor * 100 + patch))
-#else
-/* Define this for !GCC compilers, just so we can write things like GCC_VERSION_AT_LEAST(4, 1, 0). */
-#define GCC_VERSION_AT_LEAST(major, minor, patch) 0
-#endif
 
-/* Specific compiler features */
-#if COMPILER(GCC) && !COMPILER(CLANG)
-#if GCC_VERSION_AT_LEAST(4, 8, 0)
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#if !GCC_VERSION_AT_LEAST(5, 0, 0)
+#error "Please use a newer version of GCC. WebKit requires GCC 5.0.0 or newer to compile."
 #endif
+
 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-/* C11 support */
 #define WTF_COMPILER_SUPPORTS_C_STATIC_ASSERT 1
 #endif
-#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (defined(__cplusplus) && __cplusplus >= 201103L)
-/* C++11 support */
-#if GCC_VERSION_AT_LEAST(4, 3, 0)
-#define WTF_COMPILER_SUPPORTS_CXX_RVALUE_REFERENCES 1
-#define WTF_COMPILER_SUPPORTS_CXX_STATIC_ASSERT 1
-#define WTF_COMPILER_SUPPORTS_CXX_VARIADIC_TEMPLATES 1
-#endif
-#if GCC_VERSION_AT_LEAST(4, 4, 0)
-#define WTF_COMPILER_SUPPORTS_CXX_DELETED_FUNCTIONS 1
-#endif
-#if GCC_VERSION_AT_LEAST(4, 5, 0)
-#define WTF_COMPILER_SUPPORTS_CXX_EXPLICIT_CONVERSIONS 1
-#endif
-#if GCC_VERSION_AT_LEAST(4, 6, 0)
-#define WTF_COMPILER_SUPPORTS_CXX_NULLPTR 1
-/* Strong enums should work from gcc 4.4, but doesn't seem to support some operators */
-#define WTF_COMPILER_SUPPORTS_CXX_STRONG_ENUMS 1
-#endif
-#if GCC_VERSION_AT_LEAST(4, 7, 0)
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL 1
-#endif
-#endif /* defined(__GXX_EXPERIMENTAL_CXX0X__) || (defined(__cplusplus) && __cplusplus >= 201103L) */
+
 #endif /* COMPILER(GCC) */
 
+#if COMPILER(GCC_OR_CLANG) && defined(NDEBUG) && !defined(__OPTIMIZE__) && !defined(RELEASE_WITHOUT_OPTIMIZATIONS)
+#error "Building release without compiler optimizations: WebKit will be slow. Set -DRELEASE_WITHOUT_OPTIMIZATIONS if this is intended."
+#endif
+
 /* COMPILER(MINGW) - MinGW GCC */
-/* COMPILER(MINGW64) - mingw-w64 GCC - only used as additional check to exclude mingw.org specific functions */
+
 #if defined(__MINGW32__)
 #define WTF_COMPILER_MINGW 1
-#include <_mingw.h> /* private MinGW header */
-    #if defined(__MINGW64_VERSION_MAJOR) /* best way to check for mingw-w64 vs mingw.org */
-        #define WTF_COMPILER_MINGW64 1
-    #endif /* __MINGW64_VERSION_MAJOR */
-#endif /* __MINGW32__ */
+#include <_mingw.h>
+#endif
+
+/* COMPILER(MINGW64) - mingw-w64 GCC - used as additional check to exclude mingw.org specific functions */
+
+/* Note: This section must come after the MinGW section since we check COMPILER(MINGW) here. */
 
-/* COMPILER(INTEL) - Intel C++ Compiler */
-#if defined(__INTEL_COMPILER)
-#define WTF_COMPILER_INTEL 1
+#if COMPILER(MINGW) && defined(__MINGW64_VERSION_MAJOR) /* best way to check for mingw-w64 vs mingw.org */
+#define WTF_COMPILER_MINGW64 1
 #endif
 
-/* COMPILER(SUNCC) */
-#if defined(__SUNPRO_CC) || defined(__SUNPRO_C)
-#define WTF_COMPILER_SUNCC 1
+/* COMPILER(MSVC) - Microsoft Visual C++ */
+
+#if defined(_MSC_VER)
+
+#define WTF_COMPILER_MSVC 1
+#define WTF_COMPILER_SUPPORTS_CXX_REFERENCE_QUALIFIED_FUNCTIONS 1
+
+#if _MSC_VER < 1900
+#error "Please use a newer version of Visual Studio. WebKit requires VS2015 or newer to compile."
+#endif
+
+#endif
+
+#if !COMPILER(CLANG) && !COMPILER(MSVC)
+#define WTF_COMPILER_QUIRK_CONSIDERS_UNREACHABLE_CODE 1
 #endif
 
-/* ABI */
+/* ==== COMPILER_SUPPORTS - additional compiler feature detection, in alphabetical order ==== */
+
+/* COMPILER_SUPPORTS(EABI) */
+
 #if defined(__ARM_EABI__) || defined(__EABI__)
 #define WTF_COMPILER_SUPPORTS_EABI 1
 #endif
 
-/* ==== Compiler features ==== */
+/* Non-static data member initializer (NSDMI) for aggregates */
 
-/* ALWAYS_INLINE */
+#if defined(__cpp_aggregate_nsdmi) && __cpp_aggregate_nsdmi >= 201304
+#define WTF_COMPILER_SUPPORTS_NSDMI_FOR_AGGREGATES 1
+#endif
 
-#ifndef ALWAYS_INLINE
-#if COMPILER(GCC) && defined(NDEBUG) && !COMPILER(MINGW)
-#define ALWAYS_INLINE inline __attribute__((__always_inline__))
-#elif (COMPILER(MSVC) || COMPILER(RVCT)) && defined(NDEBUG)
-#define ALWAYS_INLINE __forceinline
+/* RELAXED_CONSTEXPR */
+
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+#define WTF_COMPILER_SUPPORTS_RELAXED_CONSTEXPR 1
+#endif
+
+#if !defined(RELAXED_CONSTEXPR)
+#if COMPILER_SUPPORTS(RELAXED_CONSTEXPR)
+#define RELAXED_CONSTEXPR constexpr
 #else
-#define ALWAYS_INLINE inline
+#define RELAXED_CONSTEXPR
 #endif
 #endif
 
+#define ASAN_ENABLED COMPILER_HAS_CLANG_FEATURE(address_sanitizer)
 
-/* NEVER_INLINE */
-
-#ifndef NEVER_INLINE
-#if COMPILER(GCC)
-#define NEVER_INLINE __attribute__((__noinline__))
-#elif COMPILER(RVCT)
-#define NEVER_INLINE __declspec(noinline)
+#if ASAN_ENABLED
+#define SUPPRESS_ASAN __attribute__((no_sanitize_address))
 #else
-#define NEVER_INLINE
+#define SUPPRESS_ASAN
+#endif
+
+/* ==== Compiler-independent macros for various compiler features, in alphabetical order ==== */
+
+/* ALWAYS_INLINE */
+
+#if !defined(ALWAYS_INLINE) && COMPILER(GCC_OR_CLANG) && defined(NDEBUG) && !COMPILER(MINGW)
+#define ALWAYS_INLINE inline __attribute__((__always_inline__))
 #endif
+
+#if !defined(ALWAYS_INLINE) && COMPILER(MSVC) && defined(NDEBUG)
+#define ALWAYS_INLINE __forceinline
 #endif
 
+#if !defined(ALWAYS_INLINE)
+#define ALWAYS_INLINE inline
+#endif
 
-/* UNLIKELY */
+/* WTF_EXTERN_C_{BEGIN, END} */
 
-#ifndef UNLIKELY
-#if COMPILER(GCC) || (COMPILER(RVCT) && defined(__GNUC__))
-#define UNLIKELY(x) __builtin_expect((x), 0)
+#ifdef __cplusplus
+#define WTF_EXTERN_C_BEGIN extern "C" {
+#define WTF_EXTERN_C_END }
 #else
-#define UNLIKELY(x) (x)
+#define WTF_EXTERN_C_BEGIN
+#define WTF_EXTERN_C_END
+#endif
+
+/* FALLTHROUGH */
+
+#if !defined(FALLTHROUGH) && defined(__cplusplus) && defined(__has_cpp_attribute)
+
+#if __has_cpp_attribute(fallthrough)
+#define FALLTHROUGH [[fallthrough]]
+#elif __has_cpp_attribute(clang::fallthrough)
+#define FALLTHROUGH [[clang::fallthrough]]
+#elif __has_cpp_attribute(gnu::fallthrough)
+#define FALLTHROUGH [[gnu::fallthrough]]
 #endif
+
+#elif !defined(FALLTHROUGH) && !defined(__cplusplus)
+
+#if COMPILER(GCC)
+#if GCC_VERSION_AT_LEAST(7, 0, 0)
+#define FALLTHROUGH __attribute__ ((fallthrough))
 #endif
+#endif
+
+#endif // !defined(FALLTHROUGH) && defined(__cplusplus) && defined(__has_cpp_attribute)
 
+#if !defined(FALLTHROUGH)
+#define FALLTHROUGH
+#endif
 
 /* LIKELY */
 
-#ifndef LIKELY
-#if COMPILER(GCC) || (COMPILER(RVCT) && defined(__GNUC__))
-#define LIKELY(x) __builtin_expect((x), 1)
-#else
+#if !defined(LIKELY) && COMPILER(GCC_OR_CLANG)
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#endif
+
+#if !defined(LIKELY)
 #define LIKELY(x) (x)
 #endif
+
+/* NEVER_INLINE */
+
+#if !defined(NEVER_INLINE) && COMPILER(GCC_OR_CLANG)
+#define NEVER_INLINE __attribute__((__noinline__))
 #endif
 
+#if !defined(NEVER_INLINE) && COMPILER(MSVC)
+#define NEVER_INLINE __declspec(noinline)
+#endif
 
-/* NO_RETURN */
+#if !defined(NEVER_INLINE)
+#define NEVER_INLINE
+#endif
 
+/* NO_RETURN */
 
-#ifndef NO_RETURN
-#if COMPILER(GCC)
+#if !defined(NO_RETURN) && COMPILER(GCC_OR_CLANG)
 #define NO_RETURN __attribute((__noreturn__))
-#elif COMPILER(MSVC) || COMPILER(RVCT)
+#endif
+
+#if !defined(NO_RETURN) && COMPILER(MSVC)
 #define NO_RETURN __declspec(noreturn)
-#else
+#endif
+
+#if !defined(NO_RETURN)
 #define NO_RETURN
 #endif
+
+/* NOT_TAIL_CALLED */
+
+#if !defined(NOT_TAIL_CALLED) && defined(__has_attribute)
+#if __has_attribute(not_tail_called)
+#define NOT_TAIL_CALLED __attribute__((not_tail_called))
+#endif
+#endif
+
+#if !defined(NOT_TAIL_CALLED)
+#define NOT_TAIL_CALLED
+#endif
+
+/* RETURNS_NONNULL */
+#if !defined(RETURNS_NONNULL) && COMPILER(GCC_OR_CLANG)
+#define RETURNS_NONNULL __attribute__((returns_nonnull))
 #endif
 
+#if !defined(RETURNS_NONNULL)
+#define RETURNS_NONNULL
+#endif
 
 /* NO_RETURN_WITH_VALUE */
 
-#ifndef NO_RETURN_WITH_VALUE
-#if !COMPILER(MSVC)
+#if !defined(NO_RETURN_WITH_VALUE) && !COMPILER(MSVC)
 #define NO_RETURN_WITH_VALUE NO_RETURN
-#else
-#define NO_RETURN_WITH_VALUE
 #endif
+
+#if !defined(NO_RETURN_WITH_VALUE)
+#define NO_RETURN_WITH_VALUE
 #endif
 
+/* OBJC_CLASS */
 
-/* WARN_UNUSED_RETURN */
+#if !defined(OBJC_CLASS) && defined(__OBJC__)
+#define OBJC_CLASS @class
+#endif
 
-#if COMPILER(GCC)
-#define WARN_UNUSED_RETURN __attribute__ ((warn_unused_result))
-#else
-#define WARN_UNUSED_RETURN
+#if !defined(OBJC_CLASS)
+#define OBJC_CLASS class
 #endif
 
-/* OVERRIDE and FINAL */
+/* PURE_FUNCTION */
 
-#if COMPILER_SUPPORTS(CXX_OVERRIDE_CONTROL)
-#define OVERRIDE override
+#if !defined(PURE_FUNCTION) && COMPILER(GCC_OR_CLANG)
+#define PURE_FUNCTION __attribute__((__pure__))
+#endif
 
-#if COMPILER_QUIRK(FINAL_IS_CALLED_SEALED)
-#define FINAL sealed
-#else
-#define FINAL final
+#if !defined(PURE_FUNCTION)
+#define PURE_FUNCTION
 #endif
 
-#else
-#define OVERRIDE
-#define FINAL
+/* UNUSED_FUNCTION */
+
+#if !defined(UNUSED_FUNCTION) && COMPILER(GCC_OR_CLANG)
+#define UNUSED_FUNCTION __attribute__((unused))
 #endif
 
-#if COMPILER_SUPPORTS(CXX_DELETED_FUNCTIONS)
-#define WTF_DELETED_FUNCTION = delete
-#else
-#define WTF_DELETED_FUNCTION
+#if !defined(UNUSED_FUNCTION)
+#define UNUSED_FUNCTION
 #endif
 
 /* REFERENCED_FROM_ASM */
 
-#ifndef REFERENCED_FROM_ASM
-#if COMPILER(GCC)
-#define REFERENCED_FROM_ASM __attribute__((used))
-#else
+#if !defined(REFERENCED_FROM_ASM) && COMPILER(GCC_OR_CLANG)
+#define REFERENCED_FROM_ASM __attribute__((__used__))
+#endif
+
+#if !defined(REFERENCED_FROM_ASM)
 #define REFERENCED_FROM_ASM
 #endif
+
+/* UNLIKELY */
+
+#if !defined(UNLIKELY) && COMPILER(GCC_OR_CLANG)
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
 #endif
 
-/* OBJC_CLASS */
+#if !defined(UNLIKELY)
+#define UNLIKELY(x) (x)
+#endif
 
-#ifndef OBJC_CLASS
-#ifdef __OBJC__
-#define OBJC_CLASS @class
-#else
-#define OBJC_CLASS class
+/* UNUSED_LABEL */
+
+/* Keep the compiler from complaining for a local label that is defined but not referenced. */
+/* Helpful when mixing hand-written and autogenerated code. */
+
+#if !defined(UNUSED_LABEL) && COMPILER(MSVC)
+#define UNUSED_LABEL(label) if (false) goto label
 #endif
+
+#if !defined(UNUSED_LABEL)
+#define UNUSED_LABEL(label) UNUSED_PARAM(&& label)
 #endif
 
 /* UNUSED_PARAM */
 
-#if COMPILER(INTEL) && !(defined(WIN32) || defined(_WIN32)) || COMPILER(RVCT)
-template<typename T>
-inline void unusedParam(T& x) { (void)x; }
-#define UNUSED_PARAM(variable) unusedParam(variable)
-#elif COMPILER(MSVC)
+#if !defined(UNUSED_PARAM) && COMPILER(MSVC)
 #define UNUSED_PARAM(variable) (void)&variable
-#else
+#endif
+
+#if !defined(UNUSED_PARAM)
 #define UNUSED_PARAM(variable) (void)variable
 #endif
 
-/* UNUSED_LABEL */
+/* WARN_UNUSED_RETURN */
 
-/* This is to keep the compiler from complaining when for local labels are
- declared but not referenced. For example, this can happen with code that
- works with auto-generated code.
- */
-#if COMPILER(MSVC)
-#define UNUSED_LABEL(label) if (false) goto label
-#else
-#define UNUSED_LABEL(label) UNUSED_PARAM(&& label)
+#if !defined(WARN_UNUSED_RETURN) && COMPILER(GCC_OR_CLANG)
+#define WARN_UNUSED_RETURN __attribute__((__warn_unused_result__))
 #endif
 
+#if !defined(WARN_UNUSED_RETURN)
+#define WARN_UNUSED_RETURN
+#endif
 
+#if !defined(__has_include) && COMPILER(MSVC)
+#define __has_include(path) 0
+#endif
 
 #endif /* WTF_Compiler_h */