Generate a compile error if release is built without compiler optimizations
[WebKit-https.git] / Source / WTF / wtf / Compiler.h
index d800e74..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_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
+
+/* 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
+
+/* 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() - primary detection of the compiler being used to build the project, in alphabetical order ==== */
 
 /* COMPILER(CLANG) - Clang  */
+
 #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)
 
-/* Specific compiler features */
-#define WTF_COMPILER_SUPPORTS_CXX_VARIADIC_TEMPLATES __has_feature(cxx_variadic_templates)
-#define WTF_COMPILER_SUPPORTS_CXX_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
-#define WTF_COMPILER_SUPPORTS_CXX_DELETED_FUNCTIONS __has_feature(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_feature(c_static_assert)
-#define WTF_COMPILER_SUPPORTS_CXX_STATIC_ASSERT __has_feature(cxx_static_assert)
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL __has_feature(cxx_override_control)
-#define WTF_COMPILER_SUPPORTS_CXX_STRONG_ENUMS __has_feature(cxx_strong_enums)
-#define WTF_COMPILER_SUPPORTS_CXX_REFERENCE_QUALIFIED_FUNCTIONS __has_feature(cxx_reference_qualified_functions)
-#define WTF_COMPILER_SUPPORTS_CXX_AUTO_TYPE __has_feature(cxx_auto_type)
-#define WTF_COMPILER_SUPPORTS_CXX_GENERALIZED_INITIALIZERS __has_feature(cxx_generalized_initializers)
-
+#ifdef __cplusplus
+#if __cplusplus <= 201103L
+#define WTF_CPP_STD_VER 11
+#elif __cplusplus <= 201402L
+#define WTF_CPP_STD_VER 14
 #endif
-
-/* COMPILER(MSVC) - Microsoft Visual C++ */
-#if defined(_MSC_VER)
-#if _MSC_VER < 1800
-#error "Please use a newer version of Visual Studio. WebKit requires VS2013 or newer to compile."
 #endif
-#define WTF_COMPILER_MSVC 1
 
-/* Specific compiler features */
-#define WTF_COMPILER_SUPPORTS_CXX_NULLPTR 1
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL 1
-#define WTF_COMPILER_SUPPORTS_CXX_RVALUE_REFERENCES 1
-#define WTF_COMPILER_SUPPORTS_CXX_STATIC_ASSERT 1
-#define WTF_COMPILER_SUPPORTS_CXX_AUTO_TYPE 1
-#define WTF_COMPILER_SUPPORTS_CXX_STRONG_ENUMS 1
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL 1
-#define WTF_COMPILER_SUPPORTS_CXX_DELETED_FUNCTIONS 1
-#define WTF_COMPILER_SUPPORTS_CXX_EXPLICIT_CONVERSIONS 1
-#define WTF_COMPILER_SUPPORTS_CXX_GENERALIZED_INITIALIZERS 1
-#define WTF_COMPILER_SUPPORTS_CXX_VARIADIC_TEMPLATES 1
+#endif // defined(__clang__)
 
-#endif /* defined(_MSC_VER) */
-
-/* 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))
+/* 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 */
-#if defined(__GNUC__)
+/* 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, 7, 0)
-#error "Please use a newer version of GCC. WebKit requires GCC 4.7.0 or newer to compile."
-#endif
-#if GCC_VERSION_AT_LEAST(4, 8, 0)
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#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 */
-#define WTF_COMPILER_SUPPORTS_CXX_RVALUE_REFERENCES 1
-#define WTF_COMPILER_SUPPORTS_CXX_STATIC_ASSERT 1
-#define WTF_COMPILER_SUPPORTS_CXX_VARIADIC_TEMPLATES 1
-#define WTF_COMPILER_SUPPORTS_CXX_AUTO_TYPE 1
-#define WTF_COMPILER_SUPPORTS_CXX_DELETED_FUNCTIONS 1
-#define WTF_COMPILER_SUPPORTS_CXX_EXPLICIT_CONVERSIONS 1
-#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
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
-#define WTF_COMPILER_SUPPORTS_CXX_OVERRIDE_CONTROL 1
-#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(SUNCC) */
-#if defined(__SUNPRO_CC) || defined(__SUNPRO_C)
-#define WTF_COMPILER_SUNCC 1
+#if COMPILER(MINGW) && defined(__MINGW64_VERSION_MAJOR) /* best way to check for mingw-w64 vs mingw.org */
+#define WTF_COMPILER_MINGW64 1
 #endif
 
-/* ABI */
-#if defined(__ARM_EABI__) || defined(__EABI__)
-#define WTF_COMPILER_SUPPORTS_EABI 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
 
-/* ==== Compiler features ==== */
+#endif
 
-/* Required C++11 features. We can remove these once they've been required for some time */
+#if !COMPILER(CLANG) && !COMPILER(MSVC)
+#define WTF_COMPILER_QUIRK_CONSIDERS_UNREACHABLE_CODE 1
+#endif
 
-#ifdef __cplusplus
-#if !COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
-#error "Please use a compiler that supports C++11 rvalue references."
+/* ==== 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
-#if !COMPILER_SUPPORTS(CXX_STATIC_ASSERT)
-#error "Please use a compiler that supports C++11 static_assert."
+
+/* Non-static data member initializer (NSDMI) for aggregates */
+
+#if defined(__cpp_aggregate_nsdmi) && __cpp_aggregate_nsdmi >= 201304
+#define WTF_COMPILER_SUPPORTS_NSDMI_FOR_AGGREGATES 1
 #endif
-#if !COMPILER_SUPPORTS(CXX_AUTO_TYPE)
-#error "Please use a compiler that supports C++11 auto."
+
+/* RELAXED_CONSTEXPR */
+
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+#define WTF_COMPILER_SUPPORTS_RELAXED_CONSTEXPR 1
 #endif
-#if !COMPILER_SUPPORTS(CXX_VARIADIC_TEMPLATES)
-#error "Please use a compiler that supports C++11 variadic templates."
+
+#if !defined(RELAXED_CONSTEXPR)
+#if COMPILER_SUPPORTS(RELAXED_CONSTEXPR)
+#define RELAXED_CONSTEXPR constexpr
+#else
+#define RELAXED_CONSTEXPR
 #endif
 #endif
 
-/* PURE_FUNCTION */
+#define ASAN_ENABLED COMPILER_HAS_CLANG_FEATURE(address_sanitizer)
 
-#if COMPILER(GCC)
-#define PURE_FUNCTION __attribute__ ((__pure__))
+#if ASAN_ENABLED
+#define SUPPRESS_ASAN __attribute__((no_sanitize_address))
 #else
-#define PURE_FUNCTION
+#define SUPPRESS_ASAN
 #endif
 
+/* ==== Compiler-independent macros for various compiler features, in alphabetical order ==== */
+
 /* ALWAYS_INLINE */
 
-#ifndef ALWAYS_INLINE
-#if COMPILER(GCC) && defined(NDEBUG) && !COMPILER(MINGW)
+#if !defined(ALWAYS_INLINE) && COMPILER(GCC_OR_CLANG) && defined(NDEBUG) && !COMPILER(MINGW)
 #define ALWAYS_INLINE inline __attribute__((__always_inline__))
-#elif COMPILER(MSVC) && defined(NDEBUG)
-#define ALWAYS_INLINE __forceinline
-#else
-#define ALWAYS_INLINE inline
 #endif
+
+#if !defined(ALWAYS_INLINE) && COMPILER(MSVC) && defined(NDEBUG)
+#define ALWAYS_INLINE __forceinline
 #endif
 
+#if !defined(ALWAYS_INLINE)
+#define ALWAYS_INLINE inline
+#endif
 
-/* NEVER_INLINE */
+/* WTF_EXTERN_C_{BEGIN, END} */
 
-#ifndef NEVER_INLINE
-#if COMPILER(GCC)
-#define NEVER_INLINE __attribute__((__noinline__))
-#elif COMPILER(MSVC) || COMPILER(RVCT)
-#define NEVER_INLINE __declspec(noinline)
+#ifdef __cplusplus
+#define WTF_EXTERN_C_BEGIN extern "C" {
+#define WTF_EXTERN_C_END }
 #else
-#define NEVER_INLINE
-#endif
+#define WTF_EXTERN_C_BEGIN
+#define WTF_EXTERN_C_END
 #endif
 
+/* FALLTHROUGH */
 
-/* UNLIKELY */
+#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)
 
-#ifndef UNLIKELY
 #if COMPILER(GCC)
-#define UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define UNLIKELY(x) (x)
+#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)
+#if !defined(LIKELY) && COMPILER(GCC_OR_CLANG)
 #define LIKELY(x) __builtin_expect(!!(x), 1)
-#else
+#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)
+#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
+#endif
+
+#if !defined(NO_RETURN_WITH_VALUE)
 #define NO_RETURN_WITH_VALUE
 #endif
+
+/* OBJC_CLASS */
+
+#if !defined(OBJC_CLASS) && defined(__OBJC__)
+#define OBJC_CLASS @class
 #endif
 
+#if !defined(OBJC_CLASS)
+#define OBJC_CLASS class
+#endif
 
-/* WARN_UNUSED_RETURN */
+/* PURE_FUNCTION */
 
-#if COMPILER(GCC)
-#define WARN_UNUSED_RETURN __attribute__ ((warn_unused_result))
-#else
-#define WARN_UNUSED_RETURN
+#if !defined(PURE_FUNCTION) && COMPILER(GCC_OR_CLANG)
+#define PURE_FUNCTION __attribute__((__pure__))
 #endif
 
+#if !defined(PURE_FUNCTION)
+#define PURE_FUNCTION
+#endif
+
+/* UNUSED_FUNCTION */
+
+#if !defined(UNUSED_FUNCTION) && COMPILER(GCC_OR_CLANG)
+#define UNUSED_FUNCTION __attribute__((unused))
+#endif
+
+#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(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 */