| // 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" |
| |
| |
| // 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) |
| |
| |
| // The expression ARRAY_SIZE(a) is a compile-time constant of type |
| // size_t which represents the number of elements of the given |
| // array. You should only use ARRAY_SIZE on statically allocated |
| // arrays. |
| #define ARRAY_SIZE(a) \ |
| ((sizeof(a) / sizeof(*(a))) / \ |
| static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) |
| |
| |
| // 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 V8_WARN_UNUSED_RESULT. |
| #define MUST_USE_RESULT V8_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__) V8_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)) |
| |
| // 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)) |
| |
| #endif // V8_BASE_MACROS_H_ |