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 6#ifndef V8_HANDLES_INL_H_ 7#define V8_HANDLES_INL_H_ 8 9#include "src/api.h" 10#include "src/handles.h" 11#include "src/heap/heap.h" 12#include "src/isolate.h" 13 14namespace v8 { 15namespace internal { 16 17template<typename T> 18Handle<T>::Handle(T* obj) { 19 location_ = HandleScope::CreateHandle(obj->GetIsolate(), obj); 20} 21 22 23template<typename T> 24Handle<T>::Handle(T* obj, Isolate* isolate) { 25 location_ = HandleScope::CreateHandle(isolate, obj); 26} 27 28 29template <typename T> 30inline bool Handle<T>::is_identical_to(const Handle<T> o) const { 31 // Dereferencing deferred handles to check object equality is safe. 32 SLOW_DCHECK( 33 (location_ == NULL || IsDereferenceAllowed(NO_DEFERRED_CHECK)) && 34 (o.location_ == NULL || o.IsDereferenceAllowed(NO_DEFERRED_CHECK))); 35 if (location_ == o.location_) return true; 36 if (location_ == NULL || o.location_ == NULL) return false; 37 return *location_ == *o.location_; 38} 39 40 41template <typename T> 42inline T* Handle<T>::operator*() const { 43 SLOW_DCHECK(IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK)); 44 return *bit_cast<T**>(location_); 45} 46 47template <typename T> 48inline T** Handle<T>::location() const { 49 SLOW_DCHECK(location_ == NULL || 50 IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK)); 51 return location_; 52} 53 54#ifdef DEBUG 55template <typename T> 56bool Handle<T>::IsDereferenceAllowed(DereferenceCheckMode mode) const { 57 DCHECK(location_ != NULL); 58 Object* object = *bit_cast<T**>(location_); 59 if (object->IsSmi()) return true; 60 HeapObject* heap_object = HeapObject::cast(object); 61 Heap* heap = heap_object->GetHeap(); 62 Object** handle = reinterpret_cast<Object**>(location_); 63 Object** roots_array_start = heap->roots_array_start(); 64 if (roots_array_start <= handle && 65 handle < roots_array_start + Heap::kStrongRootListLength && 66 heap->RootCanBeTreatedAsConstant( 67 static_cast<Heap::RootListIndex>(handle - roots_array_start))) { 68 return true; 69 } 70 if (!AllowHandleDereference::IsAllowed()) return false; 71 if (mode == INCLUDE_DEFERRED_CHECK && 72 !AllowDeferredHandleDereference::IsAllowed()) { 73 // Accessing cells, maps and internalized strings is safe. 74 if (heap_object->IsCell()) return true; 75 if (heap_object->IsMap()) return true; 76 if (heap_object->IsInternalizedString()) return true; 77 return !heap->isolate()->IsDeferredHandle(handle); 78 } 79 return true; 80} 81#endif 82 83 84 85HandleScope::HandleScope(Isolate* isolate) { 86 HandleScopeData* current = isolate->handle_scope_data(); 87 isolate_ = isolate; 88 prev_next_ = current->next; 89 prev_limit_ = current->limit; 90 current->level++; 91} 92 93 94HandleScope::~HandleScope() { 95 CloseScope(isolate_, prev_next_, prev_limit_); 96} 97 98 99void HandleScope::CloseScope(Isolate* isolate, 100 Object** prev_next, 101 Object** prev_limit) { 102 HandleScopeData* current = isolate->handle_scope_data(); 103 104 std::swap(current->next, prev_next); 105 current->level--; 106 if (current->limit != prev_limit) { 107 current->limit = prev_limit; 108 DeleteExtensions(isolate); 109#ifdef ENABLE_HANDLE_ZAPPING 110 ZapRange(current->next, prev_limit); 111 } else { 112 ZapRange(current->next, prev_next); 113#endif 114 } 115} 116 117 118template <typename T> 119Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) { 120 HandleScopeData* current = isolate_->handle_scope_data(); 121 122 T* value = *handle_value; 123 // Throw away all handles in the current scope. 124 CloseScope(isolate_, prev_next_, prev_limit_); 125 // Allocate one handle in the parent scope. 126 DCHECK(current->level > 0); 127 Handle<T> result(CreateHandle<T>(isolate_, value)); 128 // Reinitialize the current scope (so that it's ready 129 // to be used or closed again). 130 prev_next_ = current->next; 131 prev_limit_ = current->limit; 132 current->level++; 133 return result; 134} 135 136 137template <typename T> 138T** HandleScope::CreateHandle(Isolate* isolate, T* value) { 139 DCHECK(AllowHandleAllocation::IsAllowed()); 140 HandleScopeData* current = isolate->handle_scope_data(); 141 142 internal::Object** cur = current->next; 143 if (cur == current->limit) cur = Extend(isolate); 144 // Update the current next field, set the value in the created 145 // handle, and return the result. 146 DCHECK(cur < current->limit); 147 current->next = cur + 1; 148 149 T** result = reinterpret_cast<T**>(cur); 150 *result = value; 151 return result; 152} 153 154 155#ifdef DEBUG 156inline SealHandleScope::SealHandleScope(Isolate* isolate) : isolate_(isolate) { 157 // Make sure the current thread is allowed to create handles to begin with. 158 CHECK(AllowHandleAllocation::IsAllowed()); 159 HandleScopeData* current = isolate_->handle_scope_data(); 160 // Shrink the current handle scope to make it impossible to do 161 // handle allocations without an explicit handle scope. 162 limit_ = current->limit; 163 current->limit = current->next; 164 level_ = current->level; 165 current->level = 0; 166} 167 168 169inline SealHandleScope::~SealHandleScope() { 170 // Restore state in current handle scope to re-enable handle 171 // allocations. 172 HandleScopeData* current = isolate_->handle_scope_data(); 173 DCHECK_EQ(0, current->level); 174 current->level = level_; 175 DCHECK_EQ(current->next, current->limit); 176 current->limit = limit_; 177} 178 179#endif 180 181} } // namespace v8::internal 182 183#endif // V8_HANDLES_INL_H_ 184