base/compiler_specific.h - chromium/src - Git at Google

 // 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) && !defined(__clang__)
 #error "Only clang-cl is supported on Windows, see https://crbug.com/988071"
 #endif

 // 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 defined(COMPILER_GCC) && defined(NDEBUG)
 #define ALWAYS_INLINE inline __attribute__((__always_inline__))
 #elif defined(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.)
 // For member functions, the implicit this parameter counts as index 1.
 #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

 #if defined(COMPILER_GCC)
 #define PRETTY_FUNCTION __PRETTY_FUNCTION__
 #elif defined(COMPILER_MSVC)
 #define PRETTY_FUNCTION __FUNCSIG__
 #else
 // See https://en.cppreference.com/w/c/language/function_definition#func
 #define PRETTY_FUNCTION __func__
 #endif

 #if !defined(CPU_ARM_NEON)
 #if defined(__arm__)
 #if !defined(__ARMEB__) && !defined(__ARM_EABI__) && !defined(__EABI__) && \
     !defined(__VFP_FP__) && !defined(_WIN32_WCE) && !defined(ANDROID)
 #error Chromium does not support middle endian architecture
 #endif
 #if defined(__ARM_NEON__)
 #define CPU_ARM_NEON 1
 #endif
 #endif  // defined(__arm__)
 #endif  // !defined(CPU_ARM_NEON)

 #if !defined(HAVE_MIPS_MSA_INTRINSICS)
 #if defined(__mips_msa) && defined(__mips_isa_rev) && (__mips_isa_rev >= 5)
 #define HAVE_MIPS_MSA_INTRINSICS 1
 #endif
 #endif

 #if defined(__clang__) && __has_attribute(uninitialized)
 // Attribute "uninitialized" disables -ftrivial-auto-var-init=pattern for
 // the specified variable.
 // Library-wide alternative is
 // 'configs -= [ "//build/config/compiler:default_init_stack_vars" ]' in .gn
 // file.
 //
 // See "init_stack_vars" in build/config/compiler/BUILD.gn and
 // http://crbug.com/977230
 // "init_stack_vars" is enabled for non-official builds and we hope to enable it
 // in official build in 2020 as well. The flag writes fixed pattern into
 // uninitialized parts of all local variables. In rare cases such initialization
 // is undesirable and attribute can be used:
 //   1. Degraded performance
 // In most cases compiler is able to remove additional stores. E.g. if memory is
 // never accessed or properly initialized later. Preserved stores mostly will
 // not affect program performance. However if compiler failed on some
 // performance critical code we can get a visible regression in a benchmark.
 //   2. memset, memcpy calls
 // Compiler may replaces some memory writes with memset or memcpy calls. This is
 // not -ftrivial-auto-var-init specific, but it can happen more likely with the
 // flag. It can be a problem if code is not linked with C run-time library.
 //
 // Note: The flag is security risk mitigation feature. So in future the
 // attribute uses should be avoided when possible. However to enable this
 // mitigation on the most of the code we need to be less strict now and minimize
 // number of exceptions later. So if in doubt feel free to use attribute, but
 // please document the problem for someone who is going to cleanup it later.
 // E.g. platform, bot, benchmark or test name in patch description or next to
 // the attribute.
 #define STACK_UNINITIALIZED __attribute__((uninitialized))
 #else
 #define STACK_UNINITIALIZED
 #endif

 #endif  // BASE_COMPILER_SPECIFIC_H_
	// 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) && !defined(__clang__)
	#error "Only clang-cl is supported on Windows, see https://crbug.com/988071"
	#endif

	// 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 defined(COMPILER_GCC) && defined(NDEBUG)
	#define ALWAYS_INLINE inline __attribute__((__always_inline__))
	#elif defined(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.)
	// For member functions, the implicit this parameter counts as index 1.
	#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

	#if defined(COMPILER_GCC)
	#define PRETTY_FUNCTION __PRETTY_FUNCTION__
	#elif defined(COMPILER_MSVC)
	#define PRETTY_FUNCTION __FUNCSIG__
	#else
	// See https://en.cppreference.com/w/c/language/function_definition#func
	#define PRETTY_FUNCTION __func__
	#endif

	#if !defined(CPU_ARM_NEON)
	#if defined(__arm__)
	#if !defined(__ARMEB__) && !defined(__ARM_EABI__) && !defined(__EABI__) && \
	!defined(__VFP_FP__) && !defined(_WIN32_WCE) && !defined(ANDROID)
	#error Chromium does not support middle endian architecture
	#endif
	#if defined(__ARM_NEON__)
	#define CPU_ARM_NEON 1
	#endif
	#endif // defined(__arm__)
	#endif // !defined(CPU_ARM_NEON)

	#if !defined(HAVE_MIPS_MSA_INTRINSICS)
	#if defined(__mips_msa) && defined(__mips_isa_rev) && (__mips_isa_rev >= 5)
	#define HAVE_MIPS_MSA_INTRINSICS 1
	#endif
	#endif

	#if defined(__clang__) && __has_attribute(uninitialized)
	// Attribute "uninitialized" disables -ftrivial-auto-var-init=pattern for
	// the specified variable.
	// Library-wide alternative is
	// 'configs -= [ "//build/config/compiler:default_init_stack_vars" ]' in .gn
	// file.
	//
	// See "init_stack_vars" in build/config/compiler/BUILD.gn and
	// http://crbug.com/977230
	// "init_stack_vars" is enabled for non-official builds and we hope to enable it
	// in official build in 2020 as well. The flag writes fixed pattern into
	// uninitialized parts of all local variables. In rare cases such initialization
	// is undesirable and attribute can be used:
	// 1. Degraded performance
	// In most cases compiler is able to remove additional stores. E.g. if memory is
	// never accessed or properly initialized later. Preserved stores mostly will
	// not affect program performance. However if compiler failed on some
	// performance critical code we can get a visible regression in a benchmark.
	// 2. memset, memcpy calls
	// Compiler may replaces some memory writes with memset or memcpy calls. This is
	// not -ftrivial-auto-var-init specific, but it can happen more likely with the
	// flag. It can be a problem if code is not linked with C run-time library.
	//
	// Note: The flag is security risk mitigation feature. So in future the
	// attribute uses should be avoided when possible. However to enable this
	// mitigation on the most of the code we need to be less strict now and minimize
	// number of exceptions later. So if in doubt feel free to use attribute, but
	// please document the problem for someone who is going to cleanup it later.
	// E.g. platform, bot, benchmark or test name in patch description or next to
	// the attribute.
	#define STACK_UNINITIALIZED __attribute__((uninitialized))
	#else
	#define STACK_UNINITIALIZED
	#endif

	#endif // BASE_COMPILER_SPECIFIC_H_