Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Side by Side Diff: tools/clang/blink_gc_plugin/tests/heap/stubs.h

Issue 1385193002: Bisect clang Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: 246985 Created 5 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef HEAP_STUBS_H_
6 #define HEAP_STUBS_H_
7
8 #include "stddef.h"
9
10 #define WTF_MAKE_FAST_ALLOCATED \
11 public: \
12 void* operator new(size_t, void* p); \
13 void* operator new[](size_t, void* p); \
14 void* operator new(size_t size); \
15 private: \
16 typedef int __thisIsHereToForceASemicolonAfterThisMacro
17
18 namespace WTF {
19
20 template<typename T> class RefCounted { };
21
22 template<typename T> class RawPtr {
23 public:
24 operator T*() const { return 0; }
25 T* operator->() { return 0; }
26 };
27
28 template<typename T> class RefPtr {
29 public:
30 ~RefPtr() { }
31 operator T*() const { return 0; }
32 T* operator->() { return 0; }
33 };
34
35 template<typename T> class OwnPtr {
36 public:
37 ~OwnPtr() { }
38 operator T*() const { return 0; }
39 T* operator->() { return 0; }
40 };
41
42 class DefaultAllocator {
43 public:
44 static const bool isGarbageCollected = false;
45 };
46
47 template<typename T>
48 struct VectorTraits {
49 static const bool needsDestruction = true;
50 };
51
52 template<size_t inlineCapacity, bool isGarbageCollected, bool tNeedsDestruction>
53 class VectorDestructorBase {
54 public:
55 ~VectorDestructorBase() {}
56 };
57
58 template<size_t inlineCapacity>
59 class VectorDestructorBase<inlineCapacity, true, false> {};
60
61 template<>
62 class VectorDestructorBase<0, true, true> {};
63
64 template<
65 typename T,
66 size_t inlineCapacity = 0,
67 typename Allocator = DefaultAllocator>
68 class Vector : public VectorDestructorBase<inlineCapacity,
69 Allocator::isGarbageCollected,
70 VectorTraits<T>::needsDestruction> {
71 public:
72 size_t size();
73 T& operator[](size_t);
74 };
75
76 template<
77 typename T,
78 size_t inlineCapacity = 0,
79 typename Allocator = DefaultAllocator>
80 class Deque {};
81
82 template<
83 typename ValueArg,
84 typename HashArg = void,
85 typename TraitsArg = void,
86 typename Allocator = DefaultAllocator>
87 class HashSet {};
88
89 template<
90 typename ValueArg,
91 typename HashArg = void,
92 typename TraitsArg = void,
93 typename Allocator = DefaultAllocator>
94 class ListHashSet {};
95
96 template<
97 typename ValueArg,
98 typename HashArg = void,
99 typename TraitsArg = void,
100 typename Allocator = DefaultAllocator>
101 class LinkedHashSet {};
102
103 template<
104 typename ValueArg,
105 typename HashArg = void,
106 typename TraitsArg = void,
107 typename Allocator = DefaultAllocator>
108 class HashCountedSet {};
109
110 template<
111 typename KeyArg,
112 typename MappedArg,
113 typename HashArg = void,
114 typename KeyTraitsArg = void,
115 typename MappedTraitsArg = void,
116 typename Allocator = DefaultAllocator>
117 class HashMap {};
118
119 }
120
121 namespace blink {
122
123 using namespace WTF;
124
125 #define DISALLOW_ALLOCATION() \
126 private: \
127 void* operator new(size_t) = delete; \
128 void* operator new(size_t, void*) = delete;
129
130 #define STACK_ALLOCATED() \
131 private: \
132 __attribute__((annotate("blink_stack_allocated"))) \
133 void* operator new(size_t) = delete; \
134 void* operator new(size_t, void*) = delete;
135
136 #define ALLOW_ONLY_INLINE_ALLOCATION() \
137 public: \
138 void* operator new(size_t, void*); \
139 private: \
140 void* operator new(size_t) = delete;
141
142 #define GC_PLUGIN_IGNORE(bug) \
143 __attribute__((annotate("blink_gc_plugin_ignore")))
144
145 #define USING_GARBAGE_COLLECTED_MIXIN(type) \
146 public: \
147 virtual void adjustAndMark(Visitor*) const override { } \
148 virtual bool isHeapObjectAlive(Visitor*) const override { return 0; }
149
150 #define EAGERLY_FINALIZED() typedef int IsEagerlyFinalizedMarker
151
152 template<typename T> class GarbageCollected { };
153
154 template<typename T>
155 class GarbageCollectedFinalized : public GarbageCollected<T> { };
156
157 template<typename T> class Member {
158 public:
159 operator T*() const { return 0; }
160 T* operator->() { return 0; }
161 bool operator!() const { return false; }
162 };
163
164 template<typename T> class WeakMember {
165 public:
166 operator T*() const { return 0; }
167 T* operator->() { return 0; }
168 bool operator!() const { return false; }
169 };
170
171 template<typename T> class Persistent {
172 public:
173 operator T*() const { return 0; }
174 T* operator->() { return 0; }
175 bool operator!() const { return false; }
176 };
177
178 class HeapAllocator {
179 public:
180 static const bool isGarbageCollected = true;
181 };
182
183 template<typename T, size_t inlineCapacity = 0>
184 class HeapVector : public Vector<T, inlineCapacity, HeapAllocator> { };
185
186 template<typename T, size_t inlineCapacity = 0>
187 class HeapDeque : public Vector<T, inlineCapacity, HeapAllocator> { };
188
189 template<typename T>
190 class HeapHashSet : public HashSet<T, void, void, HeapAllocator> { };
191
192 template<typename T>
193 class HeapListHashSet : public ListHashSet<T, void, void, HeapAllocator> { };
194
195 template<typename T>
196 class HeapLinkedHashSet : public LinkedHashSet<T, void, void, HeapAllocator> {
197 };
198
199 template<typename T>
200 class HeapHashCountedSet : public HashCountedSet<T, void, void, HeapAllocator> {
201 };
202
203 template<typename K, typename V>
204 class HeapHashMap : public HashMap<K, V, void, void, void, HeapAllocator> { };
205
206 template<typename T>
207 class PersistentHeapVector : public Vector<T, 0, HeapAllocator> { };
208
209 template <typename Derived>
210 class VisitorHelper {
211 public:
212 template<typename T>
213 void trace(const T&);
214 };
215
216 class Visitor : public VisitorHelper<Visitor> {
217 public:
218 template<typename T, void (T::*method)(Visitor*)>
219 void registerWeakMembers(const T* obj);
220 };
221
222 class InlinedGlobalMarkingVisitor
223 : public VisitorHelper<InlinedGlobalMarkingVisitor> {
224 public:
225 InlinedGlobalMarkingVisitor* operator->() { return this; }
226
227 template<typename T, void (T::*method)(Visitor*)>
228 void registerWeakMembers(const T* obj);
229 };
230
231 class GarbageCollectedMixin {
232 public:
233 virtual void adjustAndMark(Visitor*) const = 0;
234 virtual bool isHeapObjectAlive(Visitor*) const = 0;
235 virtual void trace(Visitor*) { }
236 };
237
238 template<typename T>
239 struct TraceIfNeeded {
240 static void trace(Visitor*, T*);
241 };
242
243 // blink::ScriptWrappable receives special treatment
244 // so as to allow it to be used together with GarbageCollected<T>,
245 // even when its user-declared destructor is provided.
246 // As it is with Oilpan disabled.
247 class ScriptWrappable {
248 public:
249 ~ScriptWrappable() { /* user-declared, thus, non-trivial */ }
250 };
251
252 }
253
254 namespace WTF {
255
256 template<typename T>
257 struct VectorTraits<blink::Member<T> > {
258 static const bool needsDestruction = false;
259 };
260
261 }
262
263 #endif
OLDNEW
« no previous file with comments | « tools/clang/blink_gc_plugin/tests/garbage_collected_mixin.txt ('k') | tools/clang/blink_gc_plugin/tests/ignore_class.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698