diff options
Diffstat (limited to 'chromium/v8/src/handles-inl.h')
-rw-r--r-- | chromium/v8/src/handles-inl.h | 75 |
1 files changed, 21 insertions, 54 deletions
diff --git a/chromium/v8/src/handles-inl.h b/chromium/v8/src/handles-inl.h index ec69c3fdbe6..833f9dd3a5a 100644 --- a/chromium/v8/src/handles-inl.h +++ b/chromium/v8/src/handles-inl.h @@ -1,79 +1,51 @@ // Copyright 2006-2008 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. // #ifndef V8_HANDLES_INL_H_ #define V8_HANDLES_INL_H_ -#include "api.h" -#include "apiutils.h" -#include "handles.h" -#include "heap.h" -#include "isolate.h" +#include "src/api.h" +#include "src/handles.h" +#include "src/heap.h" +#include "src/isolate.h" namespace v8 { namespace internal { template<typename T> Handle<T>::Handle(T* obj) { - ASSERT(!obj->IsFailure()); location_ = HandleScope::CreateHandle(obj->GetIsolate(), obj); } template<typename T> Handle<T>::Handle(T* obj, Isolate* isolate) { - ASSERT(!obj->IsFailure()); location_ = HandleScope::CreateHandle(isolate, obj); } template <typename T> -inline bool Handle<T>::is_identical_to(const Handle<T> other) const { - ASSERT(location_ == NULL || !(*location_)->IsFailure()); - if (location_ == other.location_) return true; - if (location_ == NULL || other.location_ == NULL) return false; +inline bool Handle<T>::is_identical_to(const Handle<T> o) const { // Dereferencing deferred handles to check object equality is safe. - SLOW_ASSERT(IsDereferenceAllowed(NO_DEFERRED_CHECK) && - other.IsDereferenceAllowed(NO_DEFERRED_CHECK)); - return *location_ == *other.location_; + SLOW_ASSERT( + (location_ == NULL || IsDereferenceAllowed(NO_DEFERRED_CHECK)) && + (o.location_ == NULL || o.IsDereferenceAllowed(NO_DEFERRED_CHECK))); + if (location_ == o.location_) return true; + if (location_ == NULL || o.location_ == NULL) return false; + return *location_ == *o.location_; } template <typename T> inline T* Handle<T>::operator*() const { - ASSERT(location_ != NULL && !(*location_)->IsFailure()); SLOW_ASSERT(IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK)); return *BitCast<T**>(location_); } template <typename T> inline T** Handle<T>::location() const { - ASSERT(location_ == NULL || !(*location_)->IsFailure()); SLOW_ASSERT(location_ == NULL || IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK)); return location_; @@ -98,7 +70,8 @@ bool Handle<T>::IsDereferenceAllowed(DereferenceCheckMode mode) const { if (!AllowHandleDereference::IsAllowed()) return false; if (mode == INCLUDE_DEFERRED_CHECK && !AllowDeferredHandleDereference::IsAllowed()) { - // Accessing maps and internalized strings is safe. + // Accessing cells, maps and internalized strings is safe. + if (heap_object->IsCell()) return true; if (heap_object->IsMap()) return true; if (heap_object->IsInternalizedString()) return true; return !heap->isolate()->IsDeferredHandle(handle); @@ -110,8 +83,7 @@ bool Handle<T>::IsDereferenceAllowed(DereferenceCheckMode mode) const { HandleScope::HandleScope(Isolate* isolate) { - v8::ImplementationUtilities::HandleScopeData* current = - isolate->handle_scope_data(); + HandleScopeData* current = isolate->handle_scope_data(); isolate_ = isolate; prev_next_ = current->next; prev_limit_ = current->limit; @@ -127,8 +99,7 @@ HandleScope::~HandleScope() { void HandleScope::CloseScope(Isolate* isolate, Object** prev_next, Object** prev_limit) { - v8::ImplementationUtilities::HandleScopeData* current = - isolate->handle_scope_data(); + HandleScopeData* current = isolate->handle_scope_data(); std::swap(current->next, prev_next); current->level--; @@ -146,8 +117,7 @@ void HandleScope::CloseScope(Isolate* isolate, template <typename T> Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) { - v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); + HandleScopeData* current = isolate_->handle_scope_data(); T* value = *handle_value; // Throw away all handles in the current scope. @@ -167,8 +137,7 @@ Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) { template <typename T> T** HandleScope::CreateHandle(Isolate* isolate, T* value) { ASSERT(AllowHandleAllocation::IsAllowed()); - v8::ImplementationUtilities::HandleScopeData* current = - isolate->handle_scope_data(); + HandleScopeData* current = isolate->handle_scope_data(); internal::Object** cur = current->next; if (cur == current->limit) cur = Extend(isolate); @@ -187,8 +156,7 @@ T** HandleScope::CreateHandle(Isolate* isolate, T* value) { inline SealHandleScope::SealHandleScope(Isolate* isolate) : isolate_(isolate) { // Make sure the current thread is allowed to create handles to begin with. CHECK(AllowHandleAllocation::IsAllowed()); - v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); + HandleScopeData* current = isolate_->handle_scope_data(); // Shrink the current handle scope to make it impossible to do // handle allocations without an explicit handle scope. limit_ = current->limit; @@ -201,8 +169,7 @@ inline SealHandleScope::SealHandleScope(Isolate* isolate) : isolate_(isolate) { inline SealHandleScope::~SealHandleScope() { // Restore state in current handle scope to re-enable handle // allocations. - v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); + HandleScopeData* current = isolate_->handle_scope_data(); ASSERT_EQ(0, current->level); current->level = level_; ASSERT_EQ(current->next, current->limit); |