src/v8/src/handles.cc

   1 // Copyright 2012 the V8 project 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 #include "src/v8.h"
   6
   7 #include "src/handles.h"
   8
   9 namespace v8 {
  10 namespace internal {
  11
  12
  13 int HandleScope::NumberOfHandles(Isolate* isolate) {
  14   HandleScopeImplementer* impl = isolate->handle_scope_implementer();
  15   int n = impl->blocks()->length();
  16   if (n == 0) return 0;
  17   return ((n - 1) * kHandleBlockSize) + static_cast<int>(
  18       (isolate->handle_scope_data()->next - impl->blocks()->last()));
  19 }
  20
  21
  22 Object** HandleScope::Extend(Isolate* isolate) {
  23   HandleScopeData* current = isolate->handle_scope_data();
  24
  25   Object** result = current->next;
  26
  27   DCHECK(result == current->limit);
  28   // Make sure there's at least one scope on the stack and that the
  29   // top of the scope stack isn't a barrier.
  30   if (!Utils::ApiCheck(current->level != 0,
  31                        "v8::HandleScope::CreateHandle()",
  32                        "Cannot create a handle without a HandleScope")) {
  33     return NULL;
  34   }
  35   HandleScopeImplementer* impl = isolate->handle_scope_implementer();
  36   // If there's more room in the last block, we use that. This is used
  37   // for fast creation of scopes after scope barriers.
  38   if (!impl->blocks()->is_empty()) {
  39     Object** limit = &impl->blocks()->last()[kHandleBlockSize];
  40     if (current->limit != limit) {
  41       current->limit = limit;
  42       DCHECK(limit - current->next < kHandleBlockSize);
  43     }
  44   }
  45
  46   // If we still haven't found a slot for the handle, we extend the
  47   // current handle scope by allocating a new handle block.
  48   if (result == current->limit) {
  49     // If there's a spare block, use it for growing the current scope.
  50     result = impl->GetSpareOrNewBlock();
  51     // Add the extension to the global list of blocks, but count the
  52     // extension as part of the current scope.
  53     impl->blocks()->Add(result);
  54     current->limit = &result[kHandleBlockSize];
  55   }
  56
  57   return result;
  58 }
  59
  60
  61 void HandleScope::DeleteExtensions(Isolate* isolate) {
  62   HandleScopeData* current = isolate->handle_scope_data();
  63   isolate->handle_scope_implementer()->DeleteExtensions(current->limit);
  64 }
  65
  66
  67 #ifdef ENABLE_HANDLE_ZAPPING
  68 void HandleScope::ZapRange(Object** start, Object** end) {
  69   DCHECK(end - start <= kHandleBlockSize);
  70   for (Object** p = start; p != end; p++) {
  71     *reinterpret_cast<Address*>(p) = v8::internal::kHandleZapValue;
  72   }
  73 }
  74 #endif
  75
  76
  77 Address HandleScope::current_level_address(Isolate* isolate) {
  78   return reinterpret_cast<Address>(&isolate->handle_scope_data()->level);
  79 }
  80
  81
  82 Address HandleScope::current_next_address(Isolate* isolate) {
  83   return reinterpret_cast<Address>(&isolate->handle_scope_data()->next);
  84 }
  85
  86
  87 Address HandleScope::current_limit_address(Isolate* isolate) {
  88   return reinterpret_cast<Address>(&isolate->handle_scope_data()->limit);
  89 }
  90
  91
  92 DeferredHandleScope::DeferredHandleScope(Isolate* isolate)
  93     : impl_(isolate->handle_scope_implementer()) {
  94   impl_->BeginDeferredScope();
  95   HandleScopeData* data = impl_->isolate()->handle_scope_data();
  96   Object** new_next = impl_->GetSpareOrNewBlock();
  97   Object** new_limit = &new_next[kHandleBlockSize];
  98   DCHECK(data->limit == &impl_->blocks()->last()[kHandleBlockSize]);
  99   impl_->blocks()->Add(new_next);
 100
 101 #ifdef DEBUG
 102   prev_level_ = data->level;
 103 #endif
 104   data->level++;
 105   prev_limit_ = data->limit;
 106   prev_next_ = data->next;
 107   data->next = new_next;
 108   data->limit = new_limit;
 109 }
 110
 111
 112 DeferredHandleScope::~DeferredHandleScope() {
 113   impl_->isolate()->handle_scope_data()->level--;
 114   DCHECK(handles_detached_);
 115   DCHECK(impl_->isolate()->handle_scope_data()->level == prev_level_);
 116 }
 117
 118
 119 DeferredHandles* DeferredHandleScope::Detach() {
 120   DeferredHandles* deferred = impl_->Detach(prev_limit_);
 121   HandleScopeData* data = impl_->isolate()->handle_scope_data();
 122   data->next = prev_next_;
 123   data->limit = prev_limit_;
 124 #ifdef DEBUG
 125   handles_detached_ = true;
 126 #endif
 127   return deferred;
 128 }
 129
 130 } }  // namespace v8::internal