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/handles.h"
6
7#include "src/address-map.h"
8#include "src/api.h"
9#include "src/base/logging.h"
10#include "src/identity-map.h"
11#include "src/maybe-handles.h"
12#include "src/objects-inl.h"
13#include "src/roots-inl.h"
14
15#ifdef DEBUG
16// For GetIsolateFromWritableHeapObject.
17#include "src/heap/heap-write-barrier-inl.h"
18#endif
19
20namespace v8 {
21namespace internal {
22
23// Handles should be trivially copyable so that they can be efficiently passed
24// by value. If they are not trivially copyable, they cannot be passed in
25// registers.
26ASSERT_TRIVIALLY_COPYABLE(HandleBase);
27ASSERT_TRIVIALLY_COPYABLE(Handle<Object>);
28ASSERT_TRIVIALLY_COPYABLE(MaybeHandle<Object>);
29
30#ifdef DEBUG
31bool HandleBase::IsDereferenceAllowed(DereferenceCheckMode mode) const {
32 DCHECK_NOT_NULL(location_);
33 Object object(*location_);
34 if (object->IsSmi()) return true;
35 HeapObject heap_object = HeapObject::cast(object);
36 Isolate* isolate;
37 if (!GetIsolateFromWritableObject(heap_object, &isolate)) return true;
38 RootIndex root_index;
39 if (isolate->roots_table().IsRootHandleLocation(location_, &root_index) &&
40 RootsTable::IsImmortalImmovable(root_index)) {
41 return true;
42 }
43 if (!AllowHandleDereference::IsAllowed()) return false;
44 if (mode == INCLUDE_DEFERRED_CHECK &&
45 !AllowDeferredHandleDereference::IsAllowed()) {
46 // Accessing cells, maps and internalized strings is safe.
47 if (heap_object->IsCell()) return true;
48 if (heap_object->IsMap()) return true;
49 if (heap_object->IsInternalizedString()) return true;
50 return !isolate->IsDeferredHandle(location_);
51 }
52 return true;
53}
54#endif
55
56
57int HandleScope::NumberOfHandles(Isolate* isolate) {
58 HandleScopeImplementer* impl = isolate->handle_scope_implementer();
59 int n = static_cast<int>(impl->blocks()->size());
60 if (n == 0) return 0;
61 return ((n - 1) * kHandleBlockSize) +
62 static_cast<int>(
63 (isolate->handle_scope_data()->next - impl->blocks()->back()));
64}
65
66Address* HandleScope::Extend(Isolate* isolate) {
67 HandleScopeData* current = isolate->handle_scope_data();
68
69 Address* result = current->next;
70
71 DCHECK(result == current->limit);
72 // Make sure there's at least one scope on the stack and that the
73 // top of the scope stack isn't a barrier.
74 if (!Utils::ApiCheck(current->level != current->sealed_level,
75 "v8::HandleScope::CreateHandle()",
76 "Cannot create a handle without a HandleScope")) {
77 return nullptr;
78 }
79 HandleScopeImplementer* impl = isolate->handle_scope_implementer();
80 // If there's more room in the last block, we use that. This is used
81 // for fast creation of scopes after scope barriers.
82 if (!impl->blocks()->empty()) {
83 Address* limit = &impl->blocks()->back()[kHandleBlockSize];
84 if (current->limit != limit) {
85 current->limit = limit;
86 DCHECK_LT(limit - current->next, kHandleBlockSize);
87 }
88 }
89
90 // If we still haven't found a slot for the handle, we extend the
91 // current handle scope by allocating a new handle block.
92 if (result == current->limit) {
93 // If there's a spare block, use it for growing the current scope.
94 result = impl->GetSpareOrNewBlock();
95 // Add the extension to the global list of blocks, but count the
96 // extension as part of the current scope.
97 impl->blocks()->push_back(result);
98 current->limit = &result[kHandleBlockSize];
99 }
100
101 return result;
102}
103
104
105void HandleScope::DeleteExtensions(Isolate* isolate) {
106 HandleScopeData* current = isolate->handle_scope_data();
107 isolate->handle_scope_implementer()->DeleteExtensions(current->limit);
108}
109
110
111#ifdef ENABLE_HANDLE_ZAPPING
112void HandleScope::ZapRange(Address* start, Address* end) {
113 DCHECK_LE(end - start, kHandleBlockSize);
114 for (Address* p = start; p != end; p++) {
115 *p = static_cast<Address>(kHandleZapValue);
116 }
117}
118#endif
119
120
121Address HandleScope::current_level_address(Isolate* isolate) {
122 return reinterpret_cast<Address>(&isolate->handle_scope_data()->level);
123}
124
125
126Address HandleScope::current_next_address(Isolate* isolate) {
127 return reinterpret_cast<Address>(&isolate->handle_scope_data()->next);
128}
129
130
131Address HandleScope::current_limit_address(Isolate* isolate) {
132 return reinterpret_cast<Address>(&isolate->handle_scope_data()->limit);
133}
134
135CanonicalHandleScope::CanonicalHandleScope(Isolate* isolate)
136 : isolate_(isolate), zone_(isolate->allocator(), ZONE_NAME) {
137 HandleScopeData* handle_scope_data = isolate_->handle_scope_data();
138 prev_canonical_scope_ = handle_scope_data->canonical_scope;
139 handle_scope_data->canonical_scope = this;
140 root_index_map_ = new RootIndexMap(isolate);
141 identity_map_ = new IdentityMap<Address*, ZoneAllocationPolicy>(
142 isolate->heap(), ZoneAllocationPolicy(&zone_));
143 canonical_level_ = handle_scope_data->level;
144}
145
146
147CanonicalHandleScope::~CanonicalHandleScope() {
148 delete root_index_map_;
149 delete identity_map_;
150 isolate_->handle_scope_data()->canonical_scope = prev_canonical_scope_;
151}
152
153Address* CanonicalHandleScope::Lookup(Address object) {
154 DCHECK_LE(canonical_level_, isolate_->handle_scope_data()->level);
155 if (isolate_->handle_scope_data()->level != canonical_level_) {
156 // We are in an inner handle scope. Do not canonicalize since we will leave
157 // this handle scope while still being in the canonical scope.
158 return HandleScope::CreateHandle(isolate_, object);
159 }
160 if (Internals::HasHeapObjectTag(object)) {
161 RootIndex root_index;
162 if (root_index_map_->Lookup(object, &root_index)) {
163 return isolate_->root_handle(root_index).location();
164 }
165 }
166 Address** entry = identity_map_->Get(Object(object));
167 if (*entry == nullptr) {
168 // Allocate new handle location.
169 *entry = HandleScope::CreateHandle(isolate_, object);
170 }
171 return *entry;
172}
173
174
175DeferredHandleScope::DeferredHandleScope(Isolate* isolate)
176 : impl_(isolate->handle_scope_implementer()) {
177 impl_->BeginDeferredScope();
178 HandleScopeData* data = impl_->isolate()->handle_scope_data();
179 Address* new_next = impl_->GetSpareOrNewBlock();
180 Address* new_limit = &new_next[kHandleBlockSize];
181 // Check that at least one HandleScope with at least one Handle in it exists,
182 // see the class description.
183 DCHECK(!impl_->blocks()->empty());
184 // Check that we are not in a SealedHandleScope.
185 DCHECK(data->limit == &impl_->blocks()->back()[kHandleBlockSize]);
186 impl_->blocks()->push_back(new_next);
187
188#ifdef DEBUG
189 prev_level_ = data->level;
190#endif
191 data->level++;
192 prev_limit_ = data->limit;
193 prev_next_ = data->next;
194 data->next = new_next;
195 data->limit = new_limit;
196}
197
198
199DeferredHandleScope::~DeferredHandleScope() {
200 impl_->isolate()->handle_scope_data()->level--;
201 DCHECK(handles_detached_);
202 DCHECK(impl_->isolate()->handle_scope_data()->level == prev_level_);
203}
204
205
206DeferredHandles* DeferredHandleScope::Detach() {
207 DeferredHandles* deferred = impl_->Detach(prev_limit_);
208 HandleScopeData* data = impl_->isolate()->handle_scope_data();
209 data->next = prev_next_;
210 data->limit = prev_limit_;
211#ifdef DEBUG
212 handles_detached_ = true;
213#endif
214 return deferred;
215}
216
217} // namespace internal
218} // namespace v8
219