tools/clang/blink_gc_plugin/tests/heap/stubs.h

   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 template<typename T> class GarbageCollected { };
 151
 152 template<typename T>
 153 class GarbageCollectedFinalized : public GarbageCollected<T> { };
 154
 155 template<typename T> class Member {
 156 public:
 157     operator T*() const { return 0; }
 158     T* operator->() { return 0; }
 159     bool operator!() const { return false; }
 160 };
 161
 162 template<typename T> class WeakMember {
 163 public:
 164     operator T*() const { return 0; }
 165     T* operator->() { return 0; }
 166     bool operator!() const { return false; }
 167 };
 168
 169 template<typename T> class Persistent {
 170 public:
 171     operator T*() const { return 0; }
 172     T* operator->() { return 0; }
 173     bool operator!() const { return false; }
 174 };
 175
 176 class HeapAllocator {
 177 public:
 178     static const bool isGarbageCollected = true;
 179 };
 180
 181 template<typename T, size_t inlineCapacity = 0>
 182 class HeapVector : public Vector<T, inlineCapacity, HeapAllocator> { };
 183
 184 template<typename T, size_t inlineCapacity = 0>
 185 class HeapDeque : public Vector<T, inlineCapacity, HeapAllocator> { };
 186
 187 template<typename T>
 188 class HeapHashSet : public HashSet<T, void, void, HeapAllocator> { };
 189
 190 template<typename T>
 191 class HeapListHashSet : public ListHashSet<T, void, void, HeapAllocator> { };
 192
 193 template<typename T>
 194 class HeapLinkedHashSet : public LinkedHashSet<T, void, void, HeapAllocator> {
 195 };
 196
 197 template<typename T>
 198 class HeapHashCountedSet : public HashCountedSet<T, void, void, HeapAllocator> {
 199 };
 200
 201 template<typename K, typename V>
 202 class HeapHashMap : public HashMap<K, V, void, void, void, HeapAllocator> { };
 203
 204 template<typename T>
 205 class PersistentHeapVector : public Vector<T, 0, HeapAllocator> { };
 206
 207 template <typename Derived>
 208 class VisitorHelper {
 209 public:
 210     template<typename T>
 211     void trace(const T&);
 212 };
 213
 214 class Visitor : public VisitorHelper<Visitor> {
 215 public:
 216     template<typename T, void (T::*method)(Visitor*)>
 217     void registerWeakMembers(const T* obj);
 218 };
 219
 220 class InlinedGlobalMarkingVisitor
 221     : public VisitorHelper<InlinedGlobalMarkingVisitor> {
 222 public:
 223     InlinedGlobalMarkingVisitor* operator->() { return this; }
 224
 225     template<typename T, void (T::*method)(Visitor*)>
 226     void registerWeakMembers(const T* obj);
 227 };
 228
 229 class GarbageCollectedMixin {
 230 public:
 231     virtual void adjustAndMark(Visitor*) const = 0;
 232     virtual bool isHeapObjectAlive(Visitor*) const = 0;
 233     virtual void trace(Visitor*) { }
 234 };
 235
 236 template<typename T>
 237 struct TraceIfNeeded {
 238     static void trace(Visitor*, T*);
 239 };
 240
 241 // blink::ScriptWrappable receives special treatment
 242 // so as to allow it to be used together with GarbageCollected<T>,
 243 // even when its user-declared destructor is provided.
 244 // As it is with Oilpan disabled.
 245 class ScriptWrappable {
 246 public:
 247     ~ScriptWrappable() { /* user-declared, thus, non-trivial */ }
 248 };
 249
 250 }
 251
 252 namespace WTF {
 253
 254 template<typename T>
 255 struct VectorTraits<blink::Member<T> > {
 256     static const bool needsDestruction = false;
 257 };
 258
 259 }
 260
 261 #endif