SYS_Compiler.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        SYS_Compiler.h (SYS Library, C++)
 *
 * COMMENTS:    
 */

#ifndef __SYS_COMPILER_H_INCLUDED__
#define __SYS_COMPILER_H_INCLUDED__

#if defined(__GNUC__)
    #define SYS_IS_GCC_GE(MAJOR, MINOR) \
        (__GNUC__ > MAJOR || (__GNUC__ == MAJOR && __GNUC_MINOR__ >= MINOR))
    #define SYS_IS_GCC_EQ(MAJOR, MINOR) \
        (__GNUC__ == MAJOR && __GNUC_MINOR__ == MINOR)
#else
    #define SYS_IS_GCC_GE(MAJOR, MINOR) 0
    #define SYS_IS_GCC_EQ(MAJOR, MINOR) 0
#endif

#if defined(__clang__)
    #define SYS_IS_CLANG_GE(MAJOR, MINOR) \
        (__clang_major__ > MAJOR || (__clang_major__ == MAJOR && __clang_minor__ >= MINOR))
#else
    #define SYS_IS_CLANG_GE(MAJOR, MINOR) 0
#endif

#if (__cplusplus >= 201402) || (defined(_MSC_VER) && _MSVC_LANG >= 201402)
    #define SYS_HAS_CXX14    1
#else
    #define SYS_HAS_CXX14    0
#endif

// Token concatenation
#define SYS_CONCAT(a, b) SYS_CONCAT_(a, b)
#define SYS_CONCAT_(a, b) a ## b

#define SYS_TO_STRING_(a) # a
#define SYS_TO_STRING(a) SYS_TO_STRING_(a)

// Handy macro to add warnings (for fix-me's etc.)
#if defined(_MSC_VER)
#define SYS_MESSAGE(desc) __pragma(message(__FILE__ "(" SYS_TO_STRING(__LINE__) ") : Warning: " #desc))
#else
#define SYS_MESSAGE(__msg__) _Pragma(SYS_TO_STRING(message __msg__))
#endif

// Define the [[fallthrough]] and [[maybe_unused]] attributes.
#if defined(__has_cpp_attribute)
    #if __has_cpp_attribute(fallthrough) == 201603
        #define SYS_FALLTHROUGH [[fallthrough]]
    #endif
    #if __has_cpp_attribute(maybe_unused) == 201603
        #define SYS_MAYBE_UNUSED [[maybe_unused]]
    #endif
#endif
#if !defined(SYS_FALLTHROUGH)
    #define SYS_FALLTHROUGH
#endif
#if !defined(SYS_MAYBE_UNUSED)
    #define SYS_MAYBE_UNUSED
#endif

// gcc 7 & 8 produce warnings about ignored attributes when using maybe_unused
// on a member variable.
#if SYS_IS_GCC_GE(7, 0)
    #define SYS_MAYBE_UNUSED_MEMBER
#else
    #define SYS_MAYBE_UNUSED_MEMBER SYS_MAYBE_UNUSED
#endif

#if defined(__has_cpp_attribute)
    #if __has_cpp_attribute(nodiscard) >= 201603L
        #define SYS_NO_DISCARD_RESULT   [[nodiscard]]
    #endif
#elif __cplusplus >= 201703L // We live in the future and using c++17 or later!
    #define SYS_NO_DISCARD_RESULT       [[nodiscard]]
#endif
#if !defined(SYS_NO_DISCARD_RESULT)
    #if defined(__GNUC__)
        #define SYS_NO_DISCARD_RESULT   __attribute__((warn_unused_result))
    #else
        #define SYS_NO_DISCARD_RESULT
    #endif
#endif

// Use to mark declared variables as unused. This is typically for 
// static function variables which are declared just to run initialization
// code, or if the variable is used only in debug builds.
#if defined(__GNUC__) || defined(__clang__)
#   define SYS_UNUSED_VAR_ATTRIB    __attribute__((unused))
#else
#   define SYS_UNUSED_VAR_ATTRIB
#endif

// Use to mark a function as not returning.  This is typically just used for
// exit().
#define SYS_FUNC_NORETURN    [[noreturn]]

// Apple dropped the ball on implementing C++11 thread_local in clang on OSX.
// Cited reason was that they thought they could do better than previous
// implementation, but then never did.
// See: https://devforums.apple.com/message/1079348#1079348
#if !(defined(__APPLE__) && defined(__clang__))
    #define SYS_THREAD_LOCAL thread_local
#else
    #define SYS_THREAD_LOCAL __thread
#endif

// Instruct the compiler to assume that the expression given will be true and
// use that information to guide optimizations.
#if defined(_MSC_VER)
    #define SYS_ASSUME(EXPR) __assume(EXPR)
#elif defined(__clang__)
    #if __has_builtin(__builtin_assume)
        #define SYS_ASSUME(EXPR) __builtin_assume(EXPR)
    #else
        #define SYS_ASSUME(EXPR) if (!(EXPR)) __builtin_unreachable() 
    #endif
#else
    #define SYS_ASSUME(EXPR) if (!(EXPR)) __builtin_unreachable() 
#endif

// Defines to disable compiler sanitizer checks
#if defined(__has_feature)
    #if __has_feature(thread_sanitizer)
        #define SYS_NO_SANITIZE_THREAD  __attribute__((no_sanitize_thread))
    #endif
    #if __has_feature(memory_sanitizer)
        #define SYS_NO_SANITIZE_MEMORY  __attribute__((no_sanitize_memory))
    #endif
    #if __has_feature(address_sanitizer)
        #define SYS_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
    #endif
#endif
#if !defined(SYS_NO_SANITIZE_THREAD)
    #define SYS_NO_SANITIZE_THREAD
#endif
#if !defined(SYS_NO_SANITIZE_MEMORY)
    #define SYS_NO_SANITIZE_MEMORY
#endif
#if !defined(SYS_NO_SANITIZE_ADDRESS)
    #define SYS_NO_SANITIZE_ADDRESS
#endif

// Defines whether or not ASAN is enabled
#if defined(__SANITIZE_ADDRESS__)
    #define SYS_ASAN_ENABLED 1
#elif defined(__has_feature)
    #if __has_feature(address_sanitizer)
        #define SYS_ASAN_ENABLED 1
    #else
        #define SYS_ASAN_ENABLED 0
    #endif
#else
    #define SYS_ASAN_ENABLED 0
#endif

#endif // __SYS_COMPILER_H_INCLUDED__