Source/JavaScriptCore/heap/HandleHeap.h

   1 /*
   2  * Copyright (C) 2011 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. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef HandleHeap_h
  27 #define HandleHeap_h
  28
  29 #include "BlockStack.h"
  30 #include "Handle.h"
  31 #include "SentinelLinkedList.h"
  32 #include "SinglyLinkedList.h"
  33
  34 namespace JSC {
  35
  36 class HandleHeap;
  37 class HeapRootMarker;
  38 class JSGlobalData;
  39 class JSValue;
  40 class MarkStack;
  41 class TypeCounter;
  42
  43 class WeakHandleOwner {
  44 public:
  45     virtual ~WeakHandleOwner();
  46     virtual bool isReachableFromOpaqueRoots(Handle<Unknown>, void* context, MarkStack&);
  47     virtual void finalize(Handle<Unknown>, void* context);
  48 };
  49
  50 class HandleHeap {
  51 public:
  52     static HandleHeap* heapFor(HandleSlot);
  53
  54     HandleHeap(JSGlobalData*);
  55
  56     JSGlobalData* globalData();
  57
  58     HandleSlot allocate();
  59     void deallocate(HandleSlot);
  60
  61     void makeWeak(HandleSlot, WeakHandleOwner* = 0, void* context = 0);
  62     HandleSlot copyWeak(HandleSlot);
  63
  64     void markStrongHandles(HeapRootMarker&);
  65     void markWeakHandles(HeapRootMarker&);
  66     void finalizeWeakHandles();
  67
  68     void writeBarrier(HandleSlot, const JSValue&);
  69
  70 #if !ASSERT_DISABLED
  71     bool hasWeakOwner(HandleSlot, WeakHandleOwner*);
  72 #endif
  73
  74     unsigned protectedGlobalObjectCount();
  75     void protectedObjectTypeCounts(TypeCounter&);
  76
  77 private:
  78     class Node {
  79     public:
  80         Node(WTF::SentinelTag);
  81         Node(HandleHeap*);
  82
  83         HandleSlot slot();
  84         HandleHeap* handleHeap();
  85
  86         void makeWeak(WeakHandleOwner*, void* context);
  87         bool isWeak();
  88
  89         WeakHandleOwner* weakOwner();
  90         void* weakOwnerContext();
  91
  92         void setPrev(Node*);
  93         Node* prev();
  94
  95         void setNext(Node*);
  96         Node* next();
  97
  98     private:
  99         WeakHandleOwner* emptyWeakOwner();
 100
 101         JSValue m_value;
 102         HandleHeap* m_handleHeap;
 103         WeakHandleOwner* m_weakOwner;
 104         void* m_weakOwnerContext;
 105         Node* m_prev;
 106         Node* m_next;
 107     };
 108
 109     static HandleSlot toHandle(Node*);
 110     static Node* toNode(HandleSlot);
 111
 112     void grow();
 113
 114 #if !ASSERT_DISABLED
 115     bool isValidWeakNode(Node*);
 116 #endif
 117
 118     JSGlobalData* m_globalData;
 119     BlockStack<Node> m_blockStack;
 120
 121     SentinelLinkedList<Node> m_strongList;
 122     SentinelLinkedList<Node> m_weakList;
 123     SentinelLinkedList<Node> m_immediateList;
 124     SinglyLinkedList<Node> m_freeList;
 125     Node* m_nextToFinalize;
 126 };
 127
 128 inline HandleHeap* HandleHeap::heapFor(HandleSlot handle)
 129 {
 130     return toNode(handle)->handleHeap();
 131 }
 132
 133 inline JSGlobalData* HandleHeap::globalData()
 134 {
 135     return m_globalData;
 136 }
 137
 138 inline HandleSlot HandleHeap::toHandle(Node* node)
 139 {
 140     return reinterpret_cast<HandleSlot>(node);
 141 }
 142
 143 inline HandleHeap::Node* HandleHeap::toNode(HandleSlot handle)
 144 {
 145     return reinterpret_cast<Node*>(handle);
 146 }
 147
 148 inline HandleSlot HandleHeap::allocate()
 149 {
 150     if (m_freeList.isEmpty())
 151         grow();
 152
 153     Node* node = m_freeList.pop();
 154     new (node) Node(this);
 155     m_immediateList.push(node);
 156     return toHandle(node);
 157 }
 158
 159 inline void HandleHeap::deallocate(HandleSlot handle)
 160 {
 161     Node* node = toNode(handle);
 162     if (node == m_nextToFinalize) {
 163         m_nextToFinalize = node->next();
 164         ASSERT(m_nextToFinalize->next());
 165     }
 166
 167     SentinelLinkedList<Node>::remove(node);
 168     m_freeList.push(node);
 169 }
 170
 171 inline HandleSlot HandleHeap::copyWeak(HandleSlot other)
 172 {
 173     Node* node = toNode(allocate());
 174     node->makeWeak(toNode(other)->weakOwner(), toNode(other)->weakOwnerContext());
 175     writeBarrier(node->slot(), *other);
 176     *node->slot() = *other;
 177     return toHandle(node);
 178 }
 179
 180 inline void HandleHeap::makeWeak(HandleSlot handle, WeakHandleOwner* weakOwner, void* context)
 181 {
 182     Node* node = toNode(handle);
 183     node->makeWeak(weakOwner, context);
 184
 185     SentinelLinkedList<Node>::remove(node);
 186     if (!*handle || !handle->isCell()) {
 187         m_immediateList.push(node);
 188         return;
 189     }
 190
 191     m_weakList.push(node);
 192 }
 193
 194 #if !ASSERT_DISABLED
 195 inline bool HandleHeap::hasWeakOwner(HandleSlot handle, WeakHandleOwner* weakOwner)
 196 {
 197     return toNode(handle)->weakOwner() == weakOwner;
 198 }
 199 #endif
 200
 201 inline HandleHeap::Node::Node(HandleHeap* handleHeap)
 202     : m_handleHeap(handleHeap)
 203     , m_weakOwner(0)
 204     , m_weakOwnerContext(0)
 205 {
 206 }
 207
 208 inline HandleHeap::Node::Node(WTF::SentinelTag)
 209     : m_handleHeap(0)
 210     , m_weakOwner(0)
 211     , m_weakOwnerContext(0)
 212 {
 213 }
 214
 215 inline HandleSlot HandleHeap::Node::slot()
 216 {
 217     return &m_value;
 218 }
 219
 220 inline HandleHeap* HandleHeap::Node::handleHeap()
 221 {
 222     return m_handleHeap;
 223 }
 224
 225 inline void HandleHeap::Node::makeWeak(WeakHandleOwner* weakOwner, void* context)
 226 {
 227     m_weakOwner = weakOwner ? weakOwner : emptyWeakOwner();
 228     m_weakOwnerContext = context;
 229 }
 230
 231 inline bool HandleHeap::Node::isWeak()
 232 {
 233     return m_weakOwner; // True for emptyWeakOwner().
 234 }
 235
 236 inline WeakHandleOwner* HandleHeap::Node::weakOwner()
 237 {
 238     return m_weakOwner == emptyWeakOwner() ? 0 : m_weakOwner; // 0 for emptyWeakOwner().
 239 }
 240
 241 inline void* HandleHeap::Node::weakOwnerContext()
 242 {
 243     ASSERT(weakOwner());
 244     return m_weakOwnerContext;
 245 }
 246
 247 inline void HandleHeap::Node::setPrev(Node* prev)
 248 {
 249     m_prev = prev;
 250 }
 251
 252 inline HandleHeap::Node* HandleHeap::Node::prev()
 253 {
 254     return m_prev;
 255 }
 256
 257 inline void HandleHeap::Node::setNext(Node* next)
 258 {
 259     m_next = next;
 260 }
 261
 262 inline HandleHeap::Node* HandleHeap::Node::next()
 263 {
 264     return m_next;
 265 }
 266
 267 // Sentinel to indicate that a node is weak, but its owner has no meaningful
 268 // callbacks. This allows us to optimize by skipping such nodes.
 269 inline WeakHandleOwner* HandleHeap::Node::emptyWeakOwner()
 270 {
 271     return reinterpret_cast<WeakHandleOwner*>(-1);
 272 }
 273
 274 }
 275
 276 #endif