// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef BASE_COMPILER_SPECIFIC_H_ #define BASE_COMPILER_SPECIFIC_H_ #include "build/build_config.h" #if defined(COMPILER_MSVC) // For _Printf_format_string_. #include <sal.h> // Macros for suppressing and disabling warnings on MSVC. // // Warning numbers are enumerated at: // http://msdn.microsoft.com/en-us/library/8x5x43k7(VS.80).aspx // // The warning pragma: // http://msdn.microsoft.com/en-us/library/2c8f766e(VS.80).aspx // // Using __pragma instead of #pragma inside macros: // http://msdn.microsoft.com/en-us/library/d9x1s805.aspx // MSVC_SUPPRESS_WARNING disables warning |n| for the remainder of the line and // for the next line of the source file. #define MSVC_SUPPRESS_WARNING(n) __pragma(warning(suppress : n)) // MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled. // The warning remains disabled until popped by MSVC_POP_WARNING. #define MSVC_PUSH_DISABLE_WARNING(n) \ __pragma(warning(push)) __pragma(warning(disable : n)) // MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level. The level // remains in effect until popped by MSVC_POP_WARNING(). Use 0 to disable all // warnings. #define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n)) // Pop effects of innermost MSVC_PUSH_* macro. #define MSVC_POP_WARNING() __pragma(warning(pop)) #define MSVC_DISABLE_OPTIMIZE() __pragma(optimize("", off)) #define MSVC_ENABLE_OPTIMIZE() __pragma(optimize("", on)) #else // Not MSVC #define _Printf_format_string_ #define MSVC_SUPPRESS_WARNING(n) #define MSVC_PUSH_DISABLE_WARNING(n) #define MSVC_PUSH_WARNING_LEVEL(n) #define MSVC_POP_WARNING() #define MSVC_DISABLE_OPTIMIZE() #define MSVC_ENABLE_OPTIMIZE() #endif // COMPILER_MSVC // Annotate a variable indicating it's ok if the variable is not used. // (Typically used to silence a compiler warning when the assignment // is important for some other reason.) // Use like: // int x = ...; // ALLOW_UNUSED_LOCAL(x); #define ALLOW_UNUSED_LOCAL(x) (void)x // Annotate a typedef or function indicating it's ok if it's not used. // Use like: // typedef Foo Bar ALLOW_UNUSED_TYPE; #if defined(COMPILER_GCC) || defined(__clang__) #define ALLOW_UNUSED_TYPE __attribute__((unused)) #else #define ALLOW_UNUSED_TYPE #endif // Annotate a function indicating it should not be inlined. // Use like: // NOINLINE void DoStuff() { ... } #if defined(COMPILER_GCC) #define NOINLINE __attribute__((noinline)) #elif defined(COMPILER_MSVC) #define NOINLINE __declspec(noinline) #else #define NOINLINE #endif #if COMPILER_GCC && defined(NDEBUG) #define ALWAYS_INLINE inline __attribute__((__always_inline__)) #elif COMPILER_MSVC && defined(NDEBUG) #define ALWAYS_INLINE __forceinline #else #define ALWAYS_INLINE inline #endif // Specify memory alignment for structs, classes, etc. // Use like: // class ALIGNAS(16) MyClass { ... } // ALIGNAS(16) int array[4]; // // In most places you can use the C++11 keyword "alignas", which is preferred. // // But compilers have trouble mixing __attribute__((...)) syntax with // alignas(...) syntax. // // Doesn't work in clang or gcc: // struct alignas(16) __attribute__((packed)) S { char c; }; // Works in clang but not gcc: // struct __attribute__((packed)) alignas(16) S2 { char c; }; // Works in clang and gcc: // struct alignas(16) S3 { char c; } __attribute__((packed)); // // There are also some attributes that must be specified *before* a class // definition: visibility (used for exporting functions/classes) is one of // these attributes. This means that it is not possible to use alignas() with a // class that is marked as exported. #if defined(COMPILER_MSVC) #define ALIGNAS(byte_alignment) __declspec(align(byte_alignment)) #elif defined(COMPILER_GCC) #define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment))) #endif // Annotate a function indicating the caller must examine the return value. // Use like: // int foo() WARN_UNUSED_RESULT; // To explicitly ignore a result, see |ignore_result()| in base/macros.h. #undef WARN_UNUSED_RESULT #if defined(COMPILER_GCC) || defined(__clang__) #define WARN_UNUSED_RESULT __attribute__((warn_unused_result)) #else #define WARN_UNUSED_RESULT #endif // Tell the compiler a function is using a printf-style format string. // |format_param| is the one-based index of the format string parameter; // |dots_param| is the one-based index of the "..." parameter. // For v*printf functions (which take a va_list), pass 0 for dots_param. // (This is undocumented but matches what the system C headers do.) #if defined(COMPILER_GCC) || defined(__clang__) #define PRINTF_FORMAT(format_param, dots_param) \ __attribute__((format(printf, format_param, dots_param))) #else #define PRINTF_FORMAT(format_param, dots_param) #endif // WPRINTF_FORMAT is the same, but for wide format strings. // This doesn't appear to yet be implemented in any compiler. // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38308 . #define WPRINTF_FORMAT(format_param, dots_param) // If available, it would look like: // __attribute__((format(wprintf, format_param, dots_param))) // Sanitizers annotations. #if defined(__has_attribute) #if __has_attribute(no_sanitize) #define NO_SANITIZE(what) __attribute__((no_sanitize(what))) #endif #endif #if !defined(NO_SANITIZE) #define NO_SANITIZE(what) #endif // MemorySanitizer annotations. #if defined(MEMORY_SANITIZER) && !defined(OS_NACL) #include <sanitizer/msan_interface.h> // Mark a memory region fully initialized. // Use this to annotate code that deliberately reads uninitialized data, for // example a GC scavenging root set pointers from the stack. #define MSAN_UNPOISON(p, size) __msan_unpoison(p, size) // Check a memory region for initializedness, as if it was being used here. // If any bits are uninitialized, crash with an MSan report. // Use this to sanitize data which MSan won't be able to track, e.g. before // passing data to another process via shared memory. #define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) \ __msan_check_mem_is_initialized(p, size) #else // MEMORY_SANITIZER #define MSAN_UNPOISON(p, size) #define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) #endif // MEMORY_SANITIZER // DISABLE_CFI_PERF -- Disable Control Flow Integrity for perf reasons. #if !defined(DISABLE_CFI_PERF) #if defined(__clang__) && defined(OFFICIAL_BUILD) #define DISABLE_CFI_PERF __attribute__((no_sanitize("cfi"))) #else #define DISABLE_CFI_PERF #endif #endif // Macro useful for writing cross-platform function pointers. #if !defined(CDECL) #if defined(OS_WIN) #define CDECL __cdecl #else // defined(OS_WIN) #define CDECL #endif // defined(OS_WIN) #endif // !defined(CDECL) // Macro for hinting that an expression is likely to be false. #if !defined(UNLIKELY) #if defined(COMPILER_GCC) || defined(__clang__) #define UNLIKELY(x) __builtin_expect(!!(x), 0) #else #define UNLIKELY(x) (x) #endif // defined(COMPILER_GCC) #endif // !defined(UNLIKELY) #if !defined(LIKELY) #if defined(COMPILER_GCC) || defined(__clang__) #define LIKELY(x) __builtin_expect(!!(x), 1) #else #define LIKELY(x) (x) #endif // defined(COMPILER_GCC) #endif // !defined(LIKELY) // Compiler feature-detection. // clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension #if defined(__has_feature) #define HAS_FEATURE(FEATURE) __has_feature(FEATURE) #else #define HAS_FEATURE(FEATURE) 0 #endif // Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional. #if defined(__clang__) #define FALLTHROUGH [[clang::fallthrough]] #else #define FALLTHROUGH #endif #endif // BASE_COMPILER_SPECIFIC_H_