1// Copyright 2006-2008 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#ifndef V8_HANDLES_INL_H_ 6#define V8_HANDLES_INL_H_ 7 8#include "src/api.h" 9#include "src/handles.h" 10#include "src/heap/heap.h" 11#include "src/isolate.h" 12 13namespace v8 { 14namespace internal { 15 16HandleBase::HandleBase(Object* object, Isolate* isolate) 17 : location_(HandleScope::GetHandle(isolate, object)) {} 18 19 20template <typename T> 21// Allocate a new handle for the object, do not canonicalize. 22Handle<T> Handle<T>::New(T* object, Isolate* isolate) { 23 return Handle( 24 reinterpret_cast<T**>(HandleScope::CreateHandle(isolate, object))); 25} 26 27 28HandleScope::HandleScope(Isolate* isolate) { 29 HandleScopeData* data = isolate->handle_scope_data(); 30 isolate_ = isolate; 31 prev_next_ = data->next; 32 prev_limit_ = data->limit; 33 data->level++; 34} 35 36 37template <typename T> 38inline std::ostream& operator<<(std::ostream& os, Handle<T> handle) { 39 return os << Brief(*handle); 40} 41 42 43HandleScope::~HandleScope() { 44#ifdef DEBUG 45 if (FLAG_check_handle_count) { 46 int before = NumberOfHandles(isolate_); 47 CloseScope(isolate_, prev_next_, prev_limit_); 48 int after = NumberOfHandles(isolate_); 49 DCHECK(after - before < kCheckHandleThreshold); 50 DCHECK(before < kCheckHandleThreshold); 51 } else { 52#endif // DEBUG 53 CloseScope(isolate_, prev_next_, prev_limit_); 54#ifdef DEBUG 55 } 56#endif // DEBUG 57} 58 59 60void HandleScope::CloseScope(Isolate* isolate, 61 Object** prev_next, 62 Object** prev_limit) { 63 HandleScopeData* current = isolate->handle_scope_data(); 64 65 std::swap(current->next, prev_next); 66 current->level--; 67 if (current->limit != prev_limit) { 68 current->limit = prev_limit; 69 DeleteExtensions(isolate); 70#ifdef ENABLE_HANDLE_ZAPPING 71 ZapRange(current->next, prev_limit); 72 } else { 73 ZapRange(current->next, prev_next); 74#endif 75 } 76} 77 78 79template <typename T> 80Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) { 81 HandleScopeData* current = isolate_->handle_scope_data(); 82 83 T* value = *handle_value; 84 // Throw away all handles in the current scope. 85 CloseScope(isolate_, prev_next_, prev_limit_); 86 // Allocate one handle in the parent scope. 87 DCHECK(current->level > current->sealed_level); 88 Handle<T> result(value, isolate_); 89 // Reinitialize the current scope (so that it's ready 90 // to be used or closed again). 91 prev_next_ = current->next; 92 prev_limit_ = current->limit; 93 current->level++; 94 return result; 95} 96 97Object** HandleScope::CreateHandle(Isolate* isolate, Object* value) { 98 DCHECK(AllowHandleAllocation::IsAllowed()); 99 HandleScopeData* data = isolate->handle_scope_data(); 100 101 Object** result = data->next; 102 if (result == data->limit) result = Extend(isolate); 103 // Update the current next field, set the value in the created 104 // handle, and return the result. 105 DCHECK(result < data->limit); 106 data->next = result + 1; 107 108 *result = value; 109 return result; 110} 111 112 113Object** HandleScope::GetHandle(Isolate* isolate, Object* value) { 114 DCHECK(AllowHandleAllocation::IsAllowed()); 115 HandleScopeData* data = isolate->handle_scope_data(); 116 CanonicalHandleScope* canonical = data->canonical_scope; 117 return canonical ? canonical->Lookup(value) : CreateHandle(isolate, value); 118} 119 120 121#ifdef DEBUG 122inline SealHandleScope::SealHandleScope(Isolate* isolate) : isolate_(isolate) { 123 // Make sure the current thread is allowed to create handles to begin with. 124 CHECK(AllowHandleAllocation::IsAllowed()); 125 HandleScopeData* current = isolate_->handle_scope_data(); 126 // Shrink the current handle scope to make it impossible to do 127 // handle allocations without an explicit handle scope. 128 prev_limit_ = current->limit; 129 current->limit = current->next; 130 prev_sealed_level_ = current->sealed_level; 131 current->sealed_level = current->level; 132} 133 134 135inline SealHandleScope::~SealHandleScope() { 136 // Restore state in current handle scope to re-enable handle 137 // allocations. 138 HandleScopeData* current = isolate_->handle_scope_data(); 139 DCHECK_EQ(current->next, current->limit); 140 current->limit = prev_limit_; 141 DCHECK_EQ(current->level, current->sealed_level); 142 current->sealed_level = prev_sealed_level_; 143} 144 145#endif 146 147} // namespace internal 148} // namespace v8 149 150#endif // V8_HANDLES_INL_H_ 151