OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2008 Apple Inc. All Rights Reserved. | 2 * Copyright (C) 2008 Apple Inc. All Rights Reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * 1. Redistributions of source code must retain the above copyright | 7 * 1. Redistributions of source code must retain the above copyright |
8 * notice, this list of conditions and the following disclaimer. | 8 * notice, this list of conditions and the following disclaimer. |
9 * 2. Redistributions in binary form must reproduce the above copyright | 9 * 2. Redistributions in binary form must reproduce the above copyright |
10 * notice, this list of conditions and the following disclaimer in the | 10 * notice, this list of conditions and the following disclaimer in the |
(...skipping 12 matching lines...) Expand all Loading... |
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
24 */ | 24 */ |
25 | 25 |
26 #ifndef WTF_StdLibExtras_h | 26 #ifndef WTF_StdLibExtras_h |
27 #define WTF_StdLibExtras_h | 27 #define WTF_StdLibExtras_h |
28 | 28 |
29 #include "base/numerics/safe_conversions.h" | 29 #include "base/numerics/safe_conversions.h" |
30 #include "wtf/Assertions.h" | 30 #include "wtf/Assertions.h" |
31 #include "wtf/CPU.h" | 31 #include "wtf/CPU.h" |
32 #include "wtf/LeakAnnotations.h" | 32 #include "wtf/LeakAnnotations.h" |
33 #include "wtf/TypeTraits.h" | |
34 #include <cstddef> | 33 #include <cstddef> |
35 | 34 |
36 #if ENABLE(ASSERT) | 35 #if ENABLE(ASSERT) |
37 #include "wtf/Noncopyable.h" | 36 #include "wtf/Noncopyable.h" |
38 #include "wtf/Threading.h" | 37 #include "wtf/Threading.h" |
39 | 38 |
40 class WTF_EXPORT StaticLocalVerifier { | 39 class WTF_EXPORT StaticLocalVerifier { |
41 WTF_MAKE_NONCOPYABLE(StaticLocalVerifier); | 40 WTF_MAKE_NONCOPYABLE(StaticLocalVerifier); |
42 public: | 41 public: |
43 StaticLocalVerifier() | 42 StaticLocalVerifier() |
44 : m_safelyInitialized(WTF::isBeforeThreadCreated()) | 43 : m_safelyInitialized(WTF::isBeforeThreadCreated()) |
45 , m_thread(WTF::currentThread()) | 44 , m_thread(WTF::currentThread()) |
46 { | 45 { |
47 } | 46 } |
48 | 47 |
49 bool isNotRacy() | 48 bool isNotRacy() |
50 { | 49 { |
51 // Make sure that this 1) is safely initialized, 2) keeps being called | 50 // Make sure that this 1) is safely initialized, 2) keeps being called |
52 // on the same thread, or 3) is called within | 51 // on the same thread, or 3) is called within |
53 // AtomicallyInitializedStatic (i.e. with a lock held). | 52 // AtomicallyInitializedStatic (i.e. with a lock held). |
54 return m_safelyInitialized || m_thread == WTF::currentThread() || WTF::i
sAtomicallyInitializedStaticMutexLockHeld(); | 53 return m_safelyInitialized || m_thread == WTF::currentThread() || WTF::i
sAtomicallyInitializedStaticMutexLockHeld(); |
55 } | 54 } |
56 | 55 |
57 private: | 56 private: |
58 bool m_safelyInitialized; | 57 bool m_safelyInitialized; |
59 ThreadIdentifier m_thread; | 58 ThreadIdentifier m_thread; |
60 }; | 59 }; |
61 #endif | 60 #endif |
62 | 61 |
63 namespace blink { | 62 // A direct static local to a Blink garbage collected objects isn't allowed; |
64 template<typename T>class Persistent; | 63 // must be wrapped up with a persistent reference. |
65 }; | 64 #define STATIC_ASSERT_FOR_LOCAL_WITH_GARBAGE_COLLECTED_TYPE(Name, Type) \ |
| 65 using Name##NoConstType = std::remove_const<Type>::type; \ |
| 66 using Name##NoPointerType = std::remove_pointer<Name##NoConstType>::type; \ |
| 67 using Name##NoReferenceType = std::remove_reference<Name##NoPointerType>::ty
pe; \ |
| 68 static_assert(!WTF::IsGarbageCollectedType<Name##NoReferenceType>::value ||
WTF::IsPersistentReferenceType<Name##NoReferenceType>::value, "Garbage collected
static local needs to be wrapped up with a persistent reference") |
66 | 69 |
67 template<typename T, bool = WTF::IsGarbageCollectedType<T>::value && !WTF::IsPer
sistentReferenceType<T>::value> | 70 // Use DEFINE_STATIC_LOCAL() to declare and define a static local variable (stat
ic T;) |
68 class StaticLocalWrapper { | 71 // so that it is leaked and its destructors are not called at exit. |
69 public: | 72 // |
70 using WrapType = T; | 73 // To cooperate with leak detection, the objects held onto by these local static
s |
71 | 74 // will in some cases have to be finalized prior to leak checking. This only app
lies |
72 static T& unwrap(T* singleton) | 75 // to static references to Oilpan heap objects and what they transitively hold o
n to. |
73 { | 76 // LEAK_SANITIZER_REGISTER_STATIC_LOCAL() takes care of the details. |
74 return *singleton; | 77 // |
75 } | |
76 }; | |
77 | |
78 template<typename T> | |
79 class StaticLocalWrapper<T, true> { | |
80 public: | |
81 using WrapType = blink::Persistent<T>; | |
82 | |
83 static T& unwrap(blink::Persistent<T>* singleton) | |
84 { | |
85 ASSERT(singleton); | |
86 // If this assert triggers, you're supplying an empty ("()") 'Arguments'
argument | |
87 // to DEFINE_STATIC_LOCAL() - it must be the heap object you wish to cre
ate | |
88 // as a static singleton and wrapped up with a Persistent reference. | |
89 ASSERT(*singleton); | |
90 return **singleton; | |
91 } | |
92 }; | |
93 | |
94 #if ENABLE(ASSERT) | 78 #if ENABLE(ASSERT) |
95 #define DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name) \ | 79 #define DEFINE_STATIC_LOCAL(Type, Name, Arguments) \ |
| 80 STATIC_ASSERT_FOR_LOCAL_WITH_GARBAGE_COLLECTED_TYPE(Name, Type); \ |
96 static StaticLocalVerifier Name##StaticLocalVerifier; \ | 81 static StaticLocalVerifier Name##StaticLocalVerifier; \ |
97 ASSERT(Name##StaticLocalVerifier.isNotRacy()) | 82 ASSERT(Name##StaticLocalVerifier.isNotRacy()); \ |
| 83 static Type& Name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(Type, new Type Arg
uments) |
98 #else | 84 #else |
99 #define DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name) | 85 #define DEFINE_STATIC_LOCAL(Type, Name, Arguments) \ |
| 86 STATIC_ASSERT_FOR_LOCAL_WITH_GARBAGE_COLLECTED_TYPE(Name, Type); \ |
| 87 static Type& Name = *LEAK_SANITIZER_REGISTER_STATIC_LOCAL(Type, new Type Arg
uments) |
100 #endif | 88 #endif |
101 | 89 |
102 // Use DEFINE_STATIC_LOCAL() to declare and define a static local variable | |
103 // (static T;) so that it is leaked and its destructors are not called at exit. | |
104 // T may also be a Blink garbage collected object, in which case it is | |
105 // wrapped up by an off-heap Persistent<T> reference to the object, keeping | |
106 // it alive across GCs. | |
107 // | |
108 // To cooperate with leak detection(LSan) for Blink garbage collected objects, | |
109 // the objects owned by persistent local statics will in some cases have to be | |
110 // finalized prior to leak checking. This only applies to static references to | |
111 // Blink heap objects and what they transitively hold on to. Hence the | |
112 // LEAK_SANITIZER_REGISTER_STATIC_LOCAL() use, it taking care of the grungy | |
113 // details. | |
114 // | |
115 #define DEFINE_STATIC_LOCAL(Type, Name, Arguments) \ | |
116 DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name); \ | |
117 using WrappedTypeFor##Name = StaticLocalWrapper<Type>::WrapType; \ | |
118 static Type& Name = StaticLocalWrapper<Type>::unwrap(LEAK_SANITIZER_REGISTER
_STATIC_LOCAL(WrappedTypeFor##Name, new WrappedTypeFor##Name Arguments)) | |
119 | |
120 // Use this to declare and define a static local pointer to a ref-counted object
so that | 90 // Use this to declare and define a static local pointer to a ref-counted object
so that |
121 // it is leaked so that the object's destructors are not called at exit. | 91 // it is leaked so that the object's destructors are not called at exit. |
122 // This macro should be used with ref-counted objects rather than DEFINE_STATIC_
LOCAL macro, | 92 // This macro should be used with ref-counted objects rather than DEFINE_STATIC_
LOCAL macro, |
123 // as this macro does not lead to an extra memory allocation. | 93 // as this macro does not lead to an extra memory allocation. |
124 #define DEFINE_STATIC_REF(type, name, arguments) \ | 94 #define DEFINE_STATIC_REF(type, name, arguments) \ |
125 static type* name = PassRefPtr<type>(arguments).leakRef(); | 95 static type* name = PassRefPtr<type>(arguments).leakRef(); |
126 | 96 |
127 /* | 97 /* |
128 * The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where | 98 * The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where |
129 * sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM with GCC: | 99 * sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM with GCC: |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
231 inline void* operator new(size_t, NotNullTag, void* location) | 201 inline void* operator new(size_t, NotNullTag, void* location) |
232 { | 202 { |
233 ASSERT(location); | 203 ASSERT(location); |
234 return location; | 204 return location; |
235 } | 205 } |
236 | 206 |
237 using WTF::bitwise_cast; | 207 using WTF::bitwise_cast; |
238 using WTF::safeCast; | 208 using WTF::safeCast; |
239 | 209 |
240 #endif // WTF_StdLibExtras_h | 210 #endif // WTF_StdLibExtras_h |
OLD | NEW |