| // 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 <stddef.h> |
| #include <stdint.h> |
| |
| #include <cstring> |
| |
| #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 aligned, non-zero value 16. |
| #define OFFSET_OF(type, field) \ |
| (reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(16)->field)) - 16) |
| |
| |
| #if V8_OS_NACL |
| |
| // 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 |
| |
| // 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 |
| |
| |
| // The COMPILE_ASSERT macro can be used to verify that a compile time |
| // expression is true. For example, you could use it to verify the |
| // size of a static array: |
| // |
| // COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES, |
| // content_type_names_incorrect_size); |
| // |
| // or to make sure a struct is smaller than a certain size: |
| // |
| // COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large); |
| // |
| // The second argument to the macro is the name of the variable. If |
| // the expression is false, most compilers will issue a warning/error |
| // containing the name of the variable. |
| #if V8_HAS_CXX11_STATIC_ASSERT |
| |
| // Under C++11, just use static_assert. |
| #define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg) |
| |
| #else |
| |
| template <bool> |
| struct CompileAssert {}; |
| |
| #define COMPILE_ASSERT(expr, msg) \ |
| typedef CompileAssert<static_cast<bool>(expr)> \ |
| msg[static_cast<bool>(expr) ? 1 : -1] ALLOW_UNUSED_TYPE |
| |
| // Implementation details of COMPILE_ASSERT: |
| // |
| // - COMPILE_ASSERT works by defining an array type that has -1 |
| // elements (and thus is invalid) when the expression is false. |
| // |
| // - The simpler definition |
| // |
| // #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1] |
| // |
| // does not work, as gcc supports variable-length arrays whose sizes |
| // are determined at run-time (this is gcc's extension and not part |
| // of the C++ standard). As a result, gcc fails to reject the |
| // following code with the simple definition: |
| // |
| // int foo; |
| // COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is |
| // // not a compile-time constant. |
| // |
| // - By using the type CompileAssert<static_cast<bool>(expr)>, we ensure that |
| // expr is a compile-time constant. (Template arguments must be |
| // determined at compile-time.) |
| // |
| // - The array size is (static_cast<bool>(expr) ? 1 : -1), instead of simply |
| // |
| // ((expr) ? 1 : -1). |
| // |
| // This is to avoid running into a bug in MS VC 7.1, which |
| // causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. |
| |
| #endif |
| |
| |
| // bit_cast<Dest,Source> is a template function that implements the |
| // equivalent of "*reinterpret_cast<Dest*>(&source)". We need this in |
| // very low-level functions like the protobuf library and fast math |
| // support. |
| // |
| // float f = 3.14159265358979; |
| // int i = bit_cast<int32>(f); |
| // // i = 0x40490fdb |
| // |
| // The classical address-casting method is: |
| // |
| // // WRONG |
| // float f = 3.14159265358979; // WRONG |
| // int i = * reinterpret_cast<int*>(&f); // WRONG |
| // |
| // The address-casting method actually produces undefined behavior |
| // according to ISO C++ specification section 3.10 -15 -. Roughly, this |
| // section says: if an object in memory has one type, and a program |
| // accesses it with a different type, then the result is undefined |
| // behavior for most values of "different type". |
| // |
| // This is true for any cast syntax, either *(int*)&f or |
| // *reinterpret_cast<int*>(&f). And it is particularly true for |
| // conversions between integral lvalues and floating-point lvalues. |
| // |
| // The purpose of 3.10 -15- is to allow optimizing compilers to assume |
| // that expressions with different types refer to different memory. gcc |
| // 4.0.1 has an optimizer that takes advantage of this. So a |
| // non-conforming program quietly produces wildly incorrect output. |
| // |
| // The problem is not the use of reinterpret_cast. The problem is type |
| // punning: holding an object in memory of one type and reading its bits |
| // back using a different type. |
| // |
| // The C++ standard is more subtle and complex than this, but that |
| // is the basic idea. |
| // |
| // Anyways ... |
| // |
| // bit_cast<> calls memcpy() which is blessed by the standard, |
| // especially by the example in section 3.9 . Also, of course, |
| // bit_cast<> wraps up the nasty logic in one place. |
| // |
| // Fortunately memcpy() is very fast. In optimized mode, with a |
| // constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline |
| // code with the minimal amount of data movement. On a 32-bit system, |
| // memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8) |
| // compiles to two loads and two stores. |
| // |
| // I tested this code with gcc 2.95.3, gcc 4.0.1, icc 8.1, and msvc 7.1. |
| // |
| // WARNING: if Dest or Source is a non-POD type, the result of the memcpy |
| // is likely to surprise you. |
| template <class Dest, class Source> |
| V8_INLINE Dest bit_cast(Source const& source) { |
| COMPILE_ASSERT(sizeof(Dest) == sizeof(Source), VerifySizesAreEqual); |
| |
| Dest dest; |
| memcpy(&dest, &source, sizeof(dest)); |
| return dest; |
| } |
| |
| |
| // 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_TYPE |
| |
| #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); |
| } |
| |
| |
| namespace v8 { |
| namespace base { |
| |
| // TODO(yangguo): This is a poor man's replacement for std::is_fundamental, |
| // which requires C++11. Switch to std::is_fundamental once possible. |
| template <typename T> |
| inline bool is_fundamental() { |
| return false; |
| } |
| |
| template <> |
| inline bool is_fundamental<uint8_t>() { |
| return true; |
| } |
| } |
| } // namespace v8::base |
| |
| #endif // V8_BASE_MACROS_H_ |