1 /*
2 * Copyright (C) 2008 Apple Inc. All Rights Reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #ifndef WTF_StdLibExtras_h
27 #define WTF_StdLibExtras_h
28
29 #include "wtf/Assertions.h"
30 #include "wtf/CPU.h"
31 #include "wtf/CheckedArithmetic.h"
32
33 // Use this to declare and define a static local variable (static T;) so that
34 // it is leaked so that its destructors are not called at exit.
35 #ifndef DEFINE_STATIC_LOCAL
36 #define DEFINE_STATIC_LOCAL(type, name, arguments) \
37 static type& name = *new type arguments
38 #endif
39
40 // Use this to declare and define a static local pointer to a ref-counted object so that
41 // it is leaked so that the object's destructors are not called at exit.
42 // This macro should be used with ref-counted objects rather than DEFINE_STATIC_LOCAL macro,
43 // as this macro does not lead to an extra memory allocation.
44 #ifndef DEFINE_STATIC_REF
45 #define DEFINE_STATIC_REF(type, name, arguments) \
46 static type* name = PassRefPtr<type>(arguments).leakRef();
47 #endif
48
49 // Use this macro to declare and define a debug-only global variable that may have a
50 // non-trivial constructor and destructor. When building with clang, this will suppress
51 // warnings about global constructors and exit-time destructors.
52 #ifndef NDEBUG
53 #if COMPILER(CLANG)
54 #define DEFINE_DEBUG_ONLY_GLOBAL(type, name, arguments) \
55 _Pragma("clang diagnostic push") \
56 _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
57 _Pragma("clang diagnostic ignored \"-Wexit-time-destructors\"") \
58 static type name arguments; \
59 _Pragma("clang diagnostic pop")
60 #else
61 #define DEFINE_DEBUG_ONLY_GLOBAL(type, name, arguments) \
62 static type name arguments;
63 #endif // COMPILER(CLANG)
64 #else
65 #define DEFINE_DEBUG_ONLY_GLOBAL(type, name, arguments)
66 #endif // NDEBUG
67
68 /*
69 * The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where
70 * sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM with GCC:
71 * increases required alignment of target type.
72 *
73 * An implicit or an extra static_cast<void*> bypasses the warning.
74 * For more info see the following bugzilla entries:
75 * - https://bugs.webkit.org/show_bug.cgi?id=38045
76 * - http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43976
77 */
78 #if CPU(ARM) && COMPILER(GCC)
79 template<typename Type>
isPointerTypeAlignmentOkay(Type * ptr)80 bool isPointerTypeAlignmentOkay(Type* ptr)
81 {
82 return !(reinterpret_cast<intptr_t>(ptr) % __alignof__(Type));
83 }
84
85 template<typename TypePtr>
reinterpret_cast_ptr(void * ptr)86 TypePtr reinterpret_cast_ptr(void* ptr)
87 {
88 ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
89 return reinterpret_cast<TypePtr>(ptr);
90 }
91
92 template<typename TypePtr>
reinterpret_cast_ptr(const void * ptr)93 TypePtr reinterpret_cast_ptr(const void* ptr)
94 {
95 ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
96 return reinterpret_cast<TypePtr>(ptr);
97 }
98 #else
99 template<typename Type>
isPointerTypeAlignmentOkay(Type *)100 bool isPointerTypeAlignmentOkay(Type*)
101 {
102 return true;
103 }
104 #define reinterpret_cast_ptr reinterpret_cast
105 #endif
106
107 namespace WTF {
108
109 /*
110 * C++'s idea of a reinterpret_cast lacks sufficient cojones.
111 */
112 template<typename TO, typename FROM>
bitwise_cast(FROM from)113 inline TO bitwise_cast(FROM from)
114 {
115 COMPILE_ASSERT(sizeof(TO) == sizeof(FROM), WTF_bitwise_cast_sizeof_casted_types_is_equal);
116 union {
117 FROM from;
118 TO to;
119 } u;
120 u.from = from;
121 return u.to;
122 }
123
124 template<typename To, typename From>
safeCast(From value)125 inline To safeCast(From value)
126 {
127 ASSERT(isInBounds<To>(value));
128 return static_cast<To>(value);
129 }
130
131 // Macro that returns a compile time constant with the length of an array, but gives an error if passed a non-array.
132 template<typename T, size_t Size> char (&ArrayLengthHelperFunction(T (&)[Size]))[Size];
133 // GCC needs some help to deduce a 0 length array.
134 #if COMPILER(GCC)
135 template<typename T> char (&ArrayLengthHelperFunction(T (&)[0]))[0];
136 #endif
137 #define WTF_ARRAY_LENGTH(array) sizeof(::WTF::ArrayLengthHelperFunction(array))
138
139 } // namespace WTF
140
141 // This version of placement new omits a 0 check.
142 enum NotNullTag { NotNull };
new(size_t,NotNullTag,void * location)143 inline void* operator new(size_t, NotNullTag, void* location)
144 {
145 ASSERT(location);
146 return location;
147 }
148
149 using WTF::bitwise_cast;
150 using WTF::safeCast;
151
152 #endif // WTF_StdLibExtras_h
153