OLD | NEW |
1 // Copyright 2006-2008 the V8 project authors. All rights reserved. | 1 // Copyright 2006-2008 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 11 matching lines...) Expand all Loading... |
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
27 // | 27 // |
28 | 28 |
29 #ifndef V8_HANDLES_INL_H_ | 29 #ifndef V8_HANDLES_INL_H_ |
30 #define V8_HANDLES_INL_H_ | 30 #define V8_HANDLES_INL_H_ |
31 | 31 |
| 32 #include "api.h" |
32 #include "apiutils.h" | 33 #include "apiutils.h" |
33 #include "handles.h" | 34 #include "handles.h" |
34 #include "api.h" | 35 #include "isolate.h" |
35 | 36 |
36 namespace v8 { | 37 namespace v8 { |
37 namespace internal { | 38 namespace internal { |
38 | 39 |
| 40 inline Isolate* GetIsolateForHandle(Object* obj) { |
| 41 return Isolate::Current(); |
| 42 } |
| 43 |
| 44 inline Isolate* GetIsolateForHandle(HeapObject* obj) { |
| 45 return obj->GetIsolate(); |
| 46 } |
| 47 |
39 template<typename T> | 48 template<typename T> |
40 Handle<T>::Handle(T* obj) { | 49 Handle<T>::Handle(T* obj) { |
41 ASSERT(!obj->IsFailure()); | 50 ASSERT(!obj->IsFailure()); |
42 location_ = HandleScope::CreateHandle(obj); | 51 location_ = HandleScope::CreateHandle(obj, GetIsolateForHandle(obj)); |
| 52 } |
| 53 |
| 54 |
| 55 template<typename T> |
| 56 Handle<T>::Handle(T* obj, Isolate* isolate) { |
| 57 ASSERT(!obj->IsFailure()); |
| 58 location_ = HandleScope::CreateHandle(obj, isolate); |
43 } | 59 } |
44 | 60 |
45 | 61 |
46 template <typename T> | 62 template <typename T> |
47 inline T* Handle<T>::operator*() const { | 63 inline T* Handle<T>::operator*() const { |
48 ASSERT(location_ != NULL); | 64 ASSERT(location_ != NULL); |
49 ASSERT(reinterpret_cast<Address>(*location_) != kHandleZapValue); | 65 ASSERT(reinterpret_cast<Address>(*location_) != kHandleZapValue); |
50 return *BitCast<T**>(location_); | 66 return *BitCast<T**>(location_); |
51 } | 67 } |
52 | 68 |
53 | 69 |
| 70 HandleScope::HandleScope() { |
| 71 Isolate* isolate = Isolate::Current(); |
| 72 v8::ImplementationUtilities::HandleScopeData* current = |
| 73 isolate->handle_scope_data(); |
| 74 isolate_ = isolate; |
| 75 prev_next_ = current->next; |
| 76 prev_limit_ = current->limit; |
| 77 current->level++; |
| 78 } |
| 79 |
| 80 |
| 81 HandleScope::HandleScope(Isolate* isolate) { |
| 82 ASSERT(isolate == Isolate::Current()); |
| 83 v8::ImplementationUtilities::HandleScopeData* current = |
| 84 isolate->handle_scope_data(); |
| 85 isolate_ = isolate; |
| 86 prev_next_ = current->next; |
| 87 prev_limit_ = current->limit; |
| 88 current->level++; |
| 89 } |
| 90 |
| 91 |
| 92 HandleScope::~HandleScope() { |
| 93 CloseScope(); |
| 94 } |
| 95 |
| 96 void HandleScope::CloseScope() { |
| 97 ASSERT(isolate_ == Isolate::Current()); |
| 98 v8::ImplementationUtilities::HandleScopeData* current = |
| 99 isolate_->handle_scope_data(); |
| 100 current->next = prev_next_; |
| 101 current->level--; |
| 102 if (current->limit != prev_limit_) { |
| 103 current->limit = prev_limit_; |
| 104 DeleteExtensions(isolate_); |
| 105 } |
| 106 #ifdef DEBUG |
| 107 ZapRange(prev_next_, prev_limit_); |
| 108 #endif |
| 109 } |
| 110 |
| 111 |
| 112 template <typename T> |
| 113 Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) { |
| 114 T* value = *handle_value; |
| 115 // Throw away all handles in the current scope. |
| 116 CloseScope(); |
| 117 v8::ImplementationUtilities::HandleScopeData* current = |
| 118 isolate_->handle_scope_data(); |
| 119 // Allocate one handle in the parent scope. |
| 120 ASSERT(current->level > 0); |
| 121 Handle<T> result(CreateHandle<T>(value, isolate_)); |
| 122 // Reinitialize the current scope (so that it's ready |
| 123 // to be used or closed again). |
| 124 prev_next_ = current->next; |
| 125 prev_limit_ = current->limit; |
| 126 current->level++; |
| 127 return result; |
| 128 } |
| 129 |
| 130 |
| 131 template <typename T> |
| 132 T** HandleScope::CreateHandle(T* value, Isolate* isolate) { |
| 133 ASSERT(isolate == Isolate::Current()); |
| 134 v8::ImplementationUtilities::HandleScopeData* current = |
| 135 isolate->handle_scope_data(); |
| 136 |
| 137 internal::Object** cur = current->next; |
| 138 if (cur == current->limit) cur = Extend(); |
| 139 // Update the current next field, set the value in the created |
| 140 // handle, and return the result. |
| 141 ASSERT(cur < current->limit); |
| 142 current->next = cur + 1; |
| 143 |
| 144 T** result = reinterpret_cast<T**>(cur); |
| 145 *result = value; |
| 146 return result; |
| 147 } |
| 148 |
| 149 |
54 #ifdef DEBUG | 150 #ifdef DEBUG |
55 inline NoHandleAllocation::NoHandleAllocation() { | 151 inline NoHandleAllocation::NoHandleAllocation() { |
56 v8::ImplementationUtilities::HandleScopeData* current = | 152 v8::ImplementationUtilities::HandleScopeData* current = |
57 v8::ImplementationUtilities::CurrentHandleScope(); | 153 Isolate::Current()->handle_scope_data(); |
| 154 |
58 // Shrink the current handle scope to make it impossible to do | 155 // Shrink the current handle scope to make it impossible to do |
59 // handle allocations without an explicit handle scope. | 156 // handle allocations without an explicit handle scope. |
60 current->limit = current->next; | 157 current->limit = current->next; |
61 | 158 |
62 level_ = current->level; | 159 level_ = current->level; |
63 current->level = 0; | 160 current->level = 0; |
64 } | 161 } |
65 | 162 |
66 | 163 |
67 inline NoHandleAllocation::~NoHandleAllocation() { | 164 inline NoHandleAllocation::~NoHandleAllocation() { |
68 // Restore state in current handle scope to re-enable handle | 165 // Restore state in current handle scope to re-enable handle |
69 // allocations. | 166 // allocations. |
70 v8::ImplementationUtilities::HandleScopeData* current = | 167 v8::ImplementationUtilities::HandleScopeData* data = |
71 v8::ImplementationUtilities::CurrentHandleScope(); | 168 Isolate::Current()->handle_scope_data(); |
72 ASSERT_EQ(0, current->level); | 169 ASSERT_EQ(0, data->level); |
73 current->level = level_; | 170 data->level = level_; |
74 } | 171 } |
75 #endif | 172 #endif |
76 | 173 |
77 | 174 |
78 } } // namespace v8::internal | 175 } } // namespace v8::internal |
79 | 176 |
80 #endif // V8_HANDLES_INL_H_ | 177 #endif // V8_HANDLES_INL_H_ |
OLD | NEW |