src/base/macros.h - v8/v8.git - Git at Google

 // Copyright 2014 the V8 project 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 V8_BASE_MACROS_H_
 #define V8_BASE_MACROS_H_

 #include "include/v8stdint.h"
 #include "src/base/build_config.h"
 #include "src/base/compiler-specific.h"
 #include "src/base/logging.h"


 // The expression OFFSET_OF(type, field) computes the byte-offset
 // of the specified field relative to the containing type. This
 // corresponds to 'offsetof' (in stddef.h), except that it doesn't
 // use 0 or NULL, which causes a problem with the compiler warnings
 // we have enabled (which is also why 'offsetof' doesn't seem to work).
 // Here we simply use the non-zero value 4, which seems to work.
 #define OFFSET_OF(type, field)                                          \
   (reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(4)->field)) - 4)


 // ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,
 // but can be used on anonymous types or types defined inside
 // functions.  It's less safe than arraysize as it accepts some
 // (although not all) pointers.  Therefore, you should use arraysize
 // whenever possible.
 //
 // The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type
 // size_t.
 //
 // ARRAYSIZE_UNSAFE catches a few type errors.  If you see a compiler error
 //
 //   "warning: division by zero in ..."
 //
 // when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer.
 // You should only use ARRAYSIZE_UNSAFE on statically allocated arrays.
 //
 // The following comments are on the implementation details, and can
 // be ignored by the users.
 //
 // ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in
 // the array) and sizeof(*(arr)) (the # of bytes in one array
 // element).  If the former is divisible by the latter, perhaps arr is
 // indeed an array, in which case the division result is the # of
 // elements in the array.  Otherwise, arr cannot possibly be an array,
 // and we generate a compiler error to prevent the code from
 // compiling.
 //
 // Since the size of bool is implementation-defined, we need to cast
 // !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
 // result has type size_t.
 //
 // This macro is not perfect as it wrongfully accepts certain
 // pointers, namely where the pointer size is divisible by the pointee
 // size.  Since all our code has to go through a 32-bit compiler,
 // where a pointer is 4 bytes, this means all pointers to a type whose
 // size is 3 or greater than 4 will be (righteously) rejected.
 #define ARRAYSIZE_UNSAFE(a)     \
   ((sizeof(a) / sizeof(*(a))) / \
    static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))  // NOLINT


 #if V8_OS_NACL

 // TODO(bmeurer): For some reason, the NaCl toolchain cannot handle the correct
 // definition of arraysize() below, so we have to use the unsafe version for
 // now.
 #define arraysize ARRAYSIZE_UNSAFE

 #else  // V8_OS_NACL

 // The arraysize(arr) macro returns the # of elements in an array arr.
 // The expression is a compile-time constant, and therefore can be
 // used in defining new arrays, for example.  If you use arraysize on
 // a pointer by mistake, you will get a compile-time error.
 //
 // One caveat is that arraysize() doesn't accept any array of an
 // anonymous type or a type defined inside a function.  In these rare
 // cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is
 // due to a limitation in C++'s template system.  The limitation might
 // eventually be removed, but it hasn't happened yet.
 #define arraysize(array) (sizeof(ArraySizeHelper(array)))


 // This template function declaration is used in defining arraysize.
 // Note that the function doesn't need an implementation, as we only
 // use its type.
 template <typename T, size_t N>
 char (&ArraySizeHelper(T (&array)[N]))[N];


 #if !V8_CC_MSVC
 // That gcc wants both of these prototypes seems mysterious. VC, for
 // its part, can't decide which to use (another mystery). Matching of
 // template overloads: the final frontier.
 template <typename T, size_t N>
 char (&ArraySizeHelper(const T (&array)[N]))[N];
 #endif

 #endif  // V8_OS_NACL


 // A macro to disallow the evil copy constructor and operator= functions
 // This should be used in the private: declarations for a class
 #define DISALLOW_COPY_AND_ASSIGN(TypeName)  \
   TypeName(const TypeName&) V8_DELETE;      \
   void operator=(const TypeName&) V8_DELETE


 // A macro to disallow all the implicit constructors, namely the
 // default constructor, copy constructor and operator= functions.
 //
 // This should be used in the private: declarations for a class
 // that wants to prevent anyone from instantiating it. This is
 // especially useful for classes containing only static methods.
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName)  \
   TypeName() V8_DELETE;                           \
   DISALLOW_COPY_AND_ASSIGN(TypeName)


 // Newly written code should use V8_INLINE and V8_NOINLINE directly.
 #define INLINE(declarator)    V8_INLINE declarator
 #define NO_INLINE(declarator) V8_NOINLINE declarator


 // Newly written code should use WARN_UNUSED_RESULT.
 #define MUST_USE_RESULT WARN_UNUSED_RESULT


 // Define V8_USE_ADDRESS_SANITIZER macros.
 #if defined(__has_feature)
 #if __has_feature(address_sanitizer)
 #define V8_USE_ADDRESS_SANITIZER 1
 #endif
 #endif

 // Define DISABLE_ASAN macros.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #define DISABLE_ASAN __attribute__((no_sanitize_address))
 #else
 #define DISABLE_ASAN
 #endif


 #if V8_CC_GNU
 #define V8_IMMEDIATE_CRASH() __builtin_trap()
 #else
 #define V8_IMMEDIATE_CRASH() ((void(*)())0)()
 #endif


 // Use C++11 static_assert if possible, which gives error
 // messages that are easier to understand on first sight.
 #if V8_HAS_CXX11_STATIC_ASSERT
 #define STATIC_ASSERT(test) static_assert(test, #test)
 #else
 // This is inspired by the static assertion facility in boost.  This
 // is pretty magical.  If it causes you trouble on a platform you may
 // find a fix in the boost code.
 template <bool> class StaticAssertion;
 template <> class StaticAssertion<true> { };
 // This macro joins two tokens.  If one of the tokens is a macro the
 // helper call causes it to be resolved before joining.
 #define SEMI_STATIC_JOIN(a, b) SEMI_STATIC_JOIN_HELPER(a, b)
 #define SEMI_STATIC_JOIN_HELPER(a, b) a##b
 // Causes an error during compilation of the condition is not
 // statically known to be true.  It is formulated as a typedef so that
 // it can be used wherever a typedef can be used.  Beware that this
 // actually causes each use to introduce a new defined type with a
 // name depending on the source line.
 template <int> class StaticAssertionHelper { };
 #define STATIC_ASSERT(test)                                                    \
   typedef                                                                     \
     StaticAssertionHelper<sizeof(StaticAssertion<static_cast<bool>((test))>)> \
     SEMI_STATIC_JOIN(__StaticAssertTypedef__, __LINE__) ALLOW_UNUSED

 #endif


 // The USE(x) template is used to silence C++ compiler warnings
 // issued for (yet) unused variables (typically parameters).
 template <typename T>
 inline void USE(T) { }


 #define IS_POWER_OF_TWO(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))


 // Define our own macros for writing 64-bit constants.  This is less fragile
 // than defining __STDC_CONSTANT_MACROS before including <stdint.h>, and it
 // works on compilers that don't have it (like MSVC).
 #if V8_CC_MSVC
 # define V8_UINT64_C(x)   (x ## UI64)
 # define V8_INT64_C(x)    (x ## I64)
 # if V8_HOST_ARCH_64_BIT
 #  define V8_INTPTR_C(x)  (x ## I64)
 #  define V8_PTR_PREFIX   "ll"
 # else
 #  define V8_INTPTR_C(x)  (x)
 #  define V8_PTR_PREFIX   ""
 # endif  // V8_HOST_ARCH_64_BIT
 #elif V8_CC_MINGW64
 # define V8_UINT64_C(x)   (x ## ULL)
 # define V8_INT64_C(x)    (x ## LL)
 # define V8_INTPTR_C(x)   (x ## LL)
 # define V8_PTR_PREFIX    "I64"
 #elif V8_HOST_ARCH_64_BIT
 # if V8_OS_MACOSX
 #  define V8_UINT64_C(x)   (x ## ULL)
 #  define V8_INT64_C(x)    (x ## LL)
 # else
 #  define V8_UINT64_C(x)   (x ## UL)
 #  define V8_INT64_C(x)    (x ## L)
 # endif
 # define V8_INTPTR_C(x)   (x ## L)
 # define V8_PTR_PREFIX    "l"
 #else
 # define V8_UINT64_C(x)   (x ## ULL)
 # define V8_INT64_C(x)    (x ## LL)
 # define V8_INTPTR_C(x)   (x)
 # define V8_PTR_PREFIX    ""
 #endif

 #define V8PRIxPTR V8_PTR_PREFIX "x"
 #define V8PRIdPTR V8_PTR_PREFIX "d"
 #define V8PRIuPTR V8_PTR_PREFIX "u"

 // Fix for Mac OS X defining uintptr_t as "unsigned long":
 #if V8_OS_MACOSX
 #undef V8PRIxPTR
 #define V8PRIxPTR "lx"
 #endif

 // The following macro works on both 32 and 64-bit platforms.
 // Usage: instead of writing 0x1234567890123456
 //      write V8_2PART_UINT64_C(0x12345678,90123456);
 #define V8_2PART_UINT64_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))


 // Compute the 0-relative offset of some absolute value x of type T.
 // This allows conversion of Addresses and integral types into
 // 0-relative int offsets.
 template <typename T>
 inline intptr_t OffsetFrom(T x) {
   return x - static_cast<T>(0);
 }


 // Compute the absolute value of type T for some 0-relative offset x.
 // This allows conversion of 0-relative int offsets into Addresses and
 // integral types.
 template <typename T>
 inline T AddressFrom(intptr_t x) {
   return static_cast<T>(static_cast<T>(0) + x);
 }


 // Return the largest multiple of m which is <= x.
 template <typename T>
 inline T RoundDown(T x, intptr_t m) {
   DCHECK(IS_POWER_OF_TWO(m));
   return AddressFrom<T>(OffsetFrom(x) & -m);
 }


 // Return the smallest multiple of m which is >= x.
 template <typename T>
 inline T RoundUp(T x, intptr_t m) {
   return RoundDown<T>(static_cast<T>(x + m - 1), m);
 }


 template <typename T, typename U>
 inline bool IsAligned(T value, U alignment) {
   return (value & (alignment - 1)) == 0;
 }


 // Returns current value of top of the stack. Works correctly with ASAN.
 DISABLE_ASAN
 inline uintptr_t GetCurrentStackPosition() {
   // Takes the address of the limit variable in order to find out where
   // the top of stack is right now.
   uintptr_t limit = reinterpret_cast<uintptr_t>(&limit);
   return limit;
 }

 #endif   // V8_BASE_MACROS_H_
	// Copyright 2014 the V8 project 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 V8_BASE_MACROS_H_
	#define V8_BASE_MACROS_H_

	#include "include/v8stdint.h"
	#include "src/base/build_config.h"
	#include "src/base/compiler-specific.h"
	#include "src/base/logging.h"


	// The expression OFFSET_OF(type, field) computes the byte-offset
	// of the specified field relative to the containing type. This
	// corresponds to 'offsetof' (in stddef.h), except that it doesn't
	// use 0 or NULL, which causes a problem with the compiler warnings
	// we have enabled (which is also why 'offsetof' doesn't seem to work).
	// Here we simply use the non-zero value 4, which seems to work.
	#define OFFSET_OF(type, field) \
	(reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(4)->field)) - 4)


	// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,
	// but can be used on anonymous types or types defined inside
	// functions. It's less safe than arraysize as it accepts some
	// (although not all) pointers. Therefore, you should use arraysize
	// whenever possible.
	//
	// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type
	// size_t.
	//
	// ARRAYSIZE_UNSAFE catches a few type errors. If you see a compiler error
	//
	// "warning: division by zero in ..."
	//
	// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer.
	// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays.
	//
	// The following comments are on the implementation details, and can
	// be ignored by the users.
	//
	// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in
	// the array) and sizeof(*(arr)) (the # of bytes in one array
	// element). If the former is divisible by the latter, perhaps arr is
	// indeed an array, in which case the division result is the # of
	// elements in the array. Otherwise, arr cannot possibly be an array,
	// and we generate a compiler error to prevent the code from
	// compiling.
	//
	// Since the size of bool is implementation-defined, we need to cast
	// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
	// result has type size_t.
	//
	// This macro is not perfect as it wrongfully accepts certain
	// pointers, namely where the pointer size is divisible by the pointee
	// size. Since all our code has to go through a 32-bit compiler,
	// where a pointer is 4 bytes, this means all pointers to a type whose
	// size is 3 or greater than 4 will be (righteously) rejected.
	#define ARRAYSIZE_UNSAFE(a) \
	((sizeof(a) / sizeof(*(a))) / \
	static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) // NOLINT


	#if V8_OS_NACL

	// TODO(bmeurer): For some reason, the NaCl toolchain cannot handle the correct
	// definition of arraysize() below, so we have to use the unsafe version for
	// now.
	#define arraysize ARRAYSIZE_UNSAFE

	#else // V8_OS_NACL

	// The arraysize(arr) macro returns the # of elements in an array arr.
	// The expression is a compile-time constant, and therefore can be
	// used in defining new arrays, for example. If you use arraysize on
	// a pointer by mistake, you will get a compile-time error.
	//
	// One caveat is that arraysize() doesn't accept any array of an
	// anonymous type or a type defined inside a function. In these rare
	// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is
	// due to a limitation in C++'s template system. The limitation might
	// eventually be removed, but it hasn't happened yet.
	#define arraysize(array) (sizeof(ArraySizeHelper(array)))


	// This template function declaration is used in defining arraysize.
	// Note that the function doesn't need an implementation, as we only
	// use its type.
	template <typename T, size_t N>
	char (&ArraySizeHelper(T (&array)[N]))[N];


	#if !V8_CC_MSVC
	// That gcc wants both of these prototypes seems mysterious. VC, for
	// its part, can't decide which to use (another mystery). Matching of
	// template overloads: the final frontier.
	template <typename T, size_t N>
	char (&ArraySizeHelper(const T (&array)[N]))[N];
	#endif

	#endif // V8_OS_NACL


	// A macro to disallow the evil copy constructor and operator= functions
	// This should be used in the private: declarations for a class
	#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
	TypeName(const TypeName&) V8_DELETE; \
	void operator=(const TypeName&) V8_DELETE


	// A macro to disallow all the implicit constructors, namely the
	// default constructor, copy constructor and operator= functions.
	//
	// This should be used in the private: declarations for a class
	// that wants to prevent anyone from instantiating it. This is
	// especially useful for classes containing only static methods.
	#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
	TypeName() V8_DELETE; \
	DISALLOW_COPY_AND_ASSIGN(TypeName)


	// Newly written code should use V8_INLINE and V8_NOINLINE directly.
	#define INLINE(declarator) V8_INLINE declarator
	#define NO_INLINE(declarator) V8_NOINLINE declarator


	// Newly written code should use WARN_UNUSED_RESULT.
	#define MUST_USE_RESULT WARN_UNUSED_RESULT


	// Define V8_USE_ADDRESS_SANITIZER macros.
	#if defined(__has_feature)
	#if __has_feature(address_sanitizer)
	#define V8_USE_ADDRESS_SANITIZER 1
	#endif
	#endif

	// Define DISABLE_ASAN macros.
	#ifdef V8_USE_ADDRESS_SANITIZER
	#define DISABLE_ASAN __attribute__((no_sanitize_address))
	#else
	#define DISABLE_ASAN
	#endif


	#if V8_CC_GNU
	#define V8_IMMEDIATE_CRASH() __builtin_trap()
	#else
	#define V8_IMMEDIATE_CRASH() ((void(*)())0)()
	#endif


	// Use C++11 static_assert if possible, which gives error
	// messages that are easier to understand on first sight.
	#if V8_HAS_CXX11_STATIC_ASSERT
	#define STATIC_ASSERT(test) static_assert(test, #test)
	#else
	// This is inspired by the static assertion facility in boost. This
	// is pretty magical. If it causes you trouble on a platform you may
	// find a fix in the boost code.
	template <bool> class StaticAssertion;
	template <> class StaticAssertion<true> { };
	// This macro joins two tokens. If one of the tokens is a macro the
	// helper call causes it to be resolved before joining.
	#define SEMI_STATIC_JOIN(a, b) SEMI_STATIC_JOIN_HELPER(a, b)
	#define SEMI_STATIC_JOIN_HELPER(a, b) a##b
	// Causes an error during compilation of the condition is not
	// statically known to be true. It is formulated as a typedef so that
	// it can be used wherever a typedef can be used. Beware that this
	// actually causes each use to introduce a new defined type with a
	// name depending on the source line.
	template <int> class StaticAssertionHelper { };
	#define STATIC_ASSERT(test) \
	typedef \
	StaticAssertionHelper<sizeof(StaticAssertion<static_cast<bool>((test))>)> \
	SEMI_STATIC_JOIN(__StaticAssertTypedef__, __LINE__) ALLOW_UNUSED

	#endif


	// The USE(x) template is used to silence C++ compiler warnings
	// issued for (yet) unused variables (typically parameters).
	template <typename T>
	inline void USE(T) { }


	#define IS_POWER_OF_TWO(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))


	// Define our own macros for writing 64-bit constants. This is less fragile
	// than defining __STDC_CONSTANT_MACROS before including <stdint.h>, and it
	// works on compilers that don't have it (like MSVC).
	#if V8_CC_MSVC
	# define V8_UINT64_C(x) (x ## UI64)
	# define V8_INT64_C(x) (x ## I64)
	# if V8_HOST_ARCH_64_BIT
	# define V8_INTPTR_C(x) (x ## I64)
	# define V8_PTR_PREFIX "ll"
	# else
	# define V8_INTPTR_C(x) (x)
	# define V8_PTR_PREFIX ""
	# endif // V8_HOST_ARCH_64_BIT
	#elif V8_CC_MINGW64
	# define V8_UINT64_C(x) (x ## ULL)
	# define V8_INT64_C(x) (x ## LL)
	# define V8_INTPTR_C(x) (x ## LL)
	# define V8_PTR_PREFIX "I64"
	#elif V8_HOST_ARCH_64_BIT
	# if V8_OS_MACOSX
	# define V8_UINT64_C(x) (x ## ULL)
	# define V8_INT64_C(x) (x ## LL)
	# else
	# define V8_UINT64_C(x) (x ## UL)
	# define V8_INT64_C(x) (x ## L)
	# endif
	# define V8_INTPTR_C(x) (x ## L)
	# define V8_PTR_PREFIX "l"
	#else
	# define V8_UINT64_C(x) (x ## ULL)
	# define V8_INT64_C(x) (x ## LL)
	# define V8_INTPTR_C(x) (x)
	# define V8_PTR_PREFIX ""
	#endif

	#define V8PRIxPTR V8_PTR_PREFIX "x"
	#define V8PRIdPTR V8_PTR_PREFIX "d"
	#define V8PRIuPTR V8_PTR_PREFIX "u"

	// Fix for Mac OS X defining uintptr_t as "unsigned long":
	#if V8_OS_MACOSX
	#undef V8PRIxPTR
	#define V8PRIxPTR "lx"
	#endif

	// The following macro works on both 32 and 64-bit platforms.
	// Usage: instead of writing 0x1234567890123456
	// write V8_2PART_UINT64_C(0x12345678,90123456);
	#define V8_2PART_UINT64_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))


	// Compute the 0-relative offset of some absolute value x of type T.
	// This allows conversion of Addresses and integral types into
	// 0-relative int offsets.
	template <typename T>
	inline intptr_t OffsetFrom(T x) {
	return x - static_cast<T>(0);
	}


	// Compute the absolute value of type T for some 0-relative offset x.
	// This allows conversion of 0-relative int offsets into Addresses and
	// integral types.
	template <typename T>
	inline T AddressFrom(intptr_t x) {
	return static_cast<T>(static_cast<T>(0) + x);
	}


	// Return the largest multiple of m which is <= x.
	template <typename T>
	inline T RoundDown(T x, intptr_t m) {
	DCHECK(IS_POWER_OF_TWO(m));
	return AddressFrom<T>(OffsetFrom(x) & -m);
	}


	// Return the smallest multiple of m which is >= x.
	template <typename T>
	inline T RoundUp(T x, intptr_t m) {
	return RoundDown<T>(static_cast<T>(x + m - 1), m);
	}


	template <typename T, typename U>
	inline bool IsAligned(T value, U alignment) {
	return (value & (alignment - 1)) == 0;
	}


	// Returns current value of top of the stack. Works correctly with ASAN.
	DISABLE_ASAN
	inline uintptr_t GetCurrentStackPosition() {
	// Takes the address of the limit variable in order to find out where
	// the top of stack is right now.
	uintptr_t limit = reinterpret_cast<uintptr_t>(&limit);
	return limit;
	}

	#endif // V8_BASE_MACROS_H_