v8::internal::HandleScope Class Reference

#include <handles.h>

Collaboration diagram for v8::internal::HandleScope:

Public Member Functions
	HandleScope (Isolate *isolate)
	~HandleScope ()
template<typename T >
Handle< T >	CloseAndEscape (Handle< T > handle_value)
Isolate *	isolate ()

Static Public Member Functions
static int	NumberOfHandles (Isolate *isolate)
template<typename T >
static T **	CreateHandle (Isolate *isolate, T *value)
static void	DeleteExtensions (Isolate *isolate)
static Address	current_next_address (Isolate *isolate)
static Address	current_limit_address (Isolate *isolate)
static Address	current_level_address (Isolate *isolate)

Private Member Functions
	HandleScope (const HandleScope &)
void	operator= (const HandleScope &)
void *	operator new (size_t size)
void	operator delete (void *size_t)

Static Private Member Functions
static void	CloseScope (Isolate *isolate, Object **prev_next, Object **prev_limit)
static internal::Object **	Extend (Isolate *isolate)

Private Attributes
Isolate *	isolate_
Object **	prev_next_
Object **	prev_limit_

Friends
class	v8::HandleScope
class	v8::internal::DeferredHandles
class	v8::internal::HandleScopeImplementer
class	v8::internal::Isolate

Detailed Description

Definition at line 181 of file handles.h.

Constructor & Destructor Documentation

HandleScope() [1/2]

v8::internal::HandleScope::HandleScope ( Isolate *  isolate )

inlineexplicit

Definition at line 85 of file handles-inl.h.

                                         {
  HandleScopeData* current = isolate->handle_scope_data();
  isolate_ = isolate;
  prev_next_ = current->next;
  prev_limit_ = current->limit;
  current->level++;
}

References v8::internal::Isolate::handle_scope_data(), isolate(), isolate_, v8::internal::HandleScopeData::level, v8::internal::HandleScopeData::limit, v8::internal::HandleScopeData::next, prev_limit_, and prev_next_.

Here is the call graph for this function:

~HandleScope()

v8::internal::HandleScope::~HandleScope ( )

inline

Definition at line 94 of file handles-inl.h.

                          {
  CloseScope(isolate_, prev_next_, prev_limit_);
}

References CloseScope(), isolate_, prev_limit_, and prev_next_.

Here is the call graph for this function:

HandleScope() [2/2]

v8::internal::HandleScope::HandleScope ( const HandleScope &  )

private

Member Function Documentation

CloseAndEscape()

template<typename T >

Handle< T > v8::internal::HandleScope::CloseAndEscape

(

Handle< T >

handle_value

)

Definition at line 119 of file handles-inl.h.

                                                            {
  HandleScopeData* current = isolate_->handle_scope_data();
 
  T* value = *handle_value;
  // Throw away all handles in the current scope.
  CloseScope(isolate_, prev_next_, prev_limit_);
  // Allocate one handle in the parent scope.
  DCHECK(current->level > 0);
  Handle<T> result(CreateHandle<T>(isolate_, value));
  // Reinitialize the current scope (so that it's ready
  // to be used or closed again).
  prev_next_ = current->next;
  prev_limit_ = current->limit;
  current->level++;
  return result;
}

References CloseScope(), DCHECK, v8::internal::Isolate::handle_scope_data(), isolate_, v8::internal::HandleScopeData::level, v8::internal::HandleScopeData::limit, v8::internal::HandleScopeData::next, prev_limit_, prev_next_, and T.

Referenced by v8::internal::TypeFeedbackOracle::BuildDictionary(), v8::Function::Call(), v8::Object::CallAsConstructor(), v8::Object::CallAsFunction(), v8::Object::GetOwnPropertyNames(), v8::Object::GetPropertyNames(), v8::internal::CompilationCacheEval::Lookup(), v8::internal::CompilationCacheRegExp::Lookup(), v8::Context::New(), v8::JSON::Parse(), v8::Script::Run(), v8::internal::ArrayConcatVisitor::SetDictionaryMode(), and v8::TryCatch::StackTrace().

Here is the call graph for this function:

Here is the caller graph for this function:

CloseScope()

void v8::internal::HandleScope::CloseScope ( Isolate *  isolate, Object **  prev_next, Object **  prev_limit  )

inlinestaticprivate

Definition at line 99 of file handles-inl.h.

                                                  {
  HandleScopeData* current = isolate->handle_scope_data();
 
  std::swap(current->next, prev_next);
  current->level--;
  if (current->limit != prev_limit) {
    current->limit = prev_limit;
    DeleteExtensions(isolate);
#ifdef ENABLE_HANDLE_ZAPPING
    ZapRange(current->next, prev_limit);
  } else {
    ZapRange(current->next, prev_next);
#endif
  }
}

References DeleteExtensions(), v8::internal::Isolate::handle_scope_data(), isolate(), v8::internal::HandleScopeData::level, v8::internal::HandleScopeData::limit, and v8::internal::HandleScopeData::next.

Referenced by CloseAndEscape(), v8::HandleScope::~HandleScope(), and ~HandleScope().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateHandle()

template<typename T >

T ** v8::internal::HandleScope::CreateHandle ( Isolate *  isolate, T *  value  )

inlinestatic

Definition at line 138 of file handles-inl.h.

                                                        {
  DCHECK(AllowHandleAllocation::IsAllowed());
  HandleScopeData* current = isolate->handle_scope_data();
 
  internal::Object** cur = current->next;
  if (cur == current->limit) cur = Extend(isolate);
  // Update the current next field, set the value in the created
  // handle, and return the result.
  DCHECK(cur < current->limit);
  current->next = cur + 1;
 
  T** result = reinterpret_cast<T**>(cur);
  *result = value;
  return result;
}

References DCHECK, Extend(), v8::internal::Isolate::handle_scope_data(), isolate(), v8::internal::HandleScopeData::limit, v8::internal::HandleScopeData::next, and T.

Referenced by v8::HandleScope::CreateHandle(), and v8::internal::Handle< T >::Handle().

Here is the call graph for this function:

Here is the caller graph for this function:

current_level_address()

Address v8::internal::HandleScope::current_level_address ( Isolate *  isolate )

static

Definition at line 77 of file handles.cc.

                                                           {
  return reinterpret_cast<Address>(&isolate->handle_scope_data()->level);
}

References v8::internal::Isolate::handle_scope_data(), isolate(), and v8::internal::HandleScopeData::level.

Here is the call graph for this function:

current_limit_address()

Address v8::internal::HandleScope::current_limit_address ( Isolate *  isolate )

static

Definition at line 87 of file handles.cc.

                                                           {
  return reinterpret_cast<Address>(&isolate->handle_scope_data()->limit);
}

References v8::internal::Isolate::handle_scope_data(), isolate(), and v8::internal::HandleScopeData::limit.

Here is the call graph for this function:

current_next_address()

Address v8::internal::HandleScope::current_next_address ( Isolate *  isolate )

static

Definition at line 82 of file handles.cc.

                                                          {
  return reinterpret_cast<Address>(&isolate->handle_scope_data()->next);
}

References v8::internal::Isolate::handle_scope_data(), isolate(), and v8::internal::HandleScopeData::next.

Here is the call graph for this function:

DeleteExtensions()

void v8::internal::HandleScope::DeleteExtensions ( Isolate *  isolate )

static

Definition at line 61 of file handles.cc.

                                                   {
  HandleScopeData* current = isolate->handle_scope_data();
  isolate->handle_scope_implementer()->DeleteExtensions(current->limit);
}

References v8::internal::HandleScopeImplementer::DeleteExtensions(), v8::internal::Isolate::handle_scope_data(), v8::internal::Isolate::handle_scope_implementer(), isolate(), and v8::internal::HandleScopeData::limit.

Referenced by CloseScope().

Here is the call graph for this function:

Here is the caller graph for this function:

Extend()

Object ** v8::internal::HandleScope::Extend ( Isolate *  isolate )

staticprivate

Definition at line 22 of file handles.cc.

                                             {
  HandleScopeData* current = isolate->handle_scope_data();
 
  Object** result = current->next;
 
  DCHECK(result == current->limit);
  // Make sure there's at least one scope on the stack and that the
  // top of the scope stack isn't a barrier.
  if (!Utils::ApiCheck(current->level != 0,
                       "v8::HandleScope::CreateHandle()",
                       "Cannot create a handle without a HandleScope")) {
    return NULL;
  }
  HandleScopeImplementer* impl = isolate->handle_scope_implementer();
  // If there's more room in the last block, we use that. This is used
  // for fast creation of scopes after scope barriers.
  if (!impl->blocks()->is_empty()) {
    Object** limit = &impl->blocks()->last()[kHandleBlockSize];
    if (current->limit != limit) {
      current->limit = limit;
      DCHECK(limit - current->next < kHandleBlockSize);
    }
  }
 
  // If we still haven't found a slot for the handle, we extend the
  // current handle scope by allocating a new handle block.
  if (result == current->limit) {
    // If there's a spare block, use it for growing the current scope.
    result = impl->GetSpareOrNewBlock();
    // Add the extension to the global list of blocks, but count the
    // extension as part of the current scope.
    impl->blocks()->Add(result);
    current->limit = &result[kHandleBlockSize];
  }
 
  return result;
}

References v8::Utils::ApiCheck(), v8::internal::HandleScopeImplementer::blocks(), DCHECK, v8::internal::HandleScopeImplementer::GetSpareOrNewBlock(), v8::internal::Isolate::handle_scope_data(), v8::internal::Isolate::handle_scope_implementer(), isolate(), v8::internal::kHandleBlockSize, v8::internal::HandleScopeData::level, v8::internal::HandleScopeData::limit, v8::internal::HandleScopeData::next, and NULL.

Referenced by CreateHandle().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate()

Isolate* v8::internal::HandleScope::isolate ( )

inline

Definition at line 208 of file handles.h.

{ return isolate_; }

References isolate_.

Referenced by CloseScope(), CreateHandle(), current_level_address(), current_limit_address(), current_next_address(), DeleteExtensions(), Extend(), HandleScope(), and NumberOfHandles().

Here is the caller graph for this function:

NumberOfHandles()

int v8::internal::HandleScope::NumberOfHandles ( Isolate *  isolate )

static

Definition at line 13 of file handles.cc.

                                                 {
  HandleScopeImplementer* impl = isolate->handle_scope_implementer();
  int n = impl->blocks()->length();
  if (n == 0) return 0;
  return ((n - 1) * kHandleBlockSize) + static_cast<int>(
      (isolate->handle_scope_data()->next - impl->blocks()->last()));
}

References v8::internal::HandleScopeImplementer::blocks(), v8::internal::Isolate::handle_scope_data(), v8::internal::Isolate::handle_scope_implementer(), isolate(), v8::internal::kHandleBlockSize, and v8::internal::HandleScopeData::next.

Referenced by v8::HandleScope::NumberOfHandles().

Here is the call graph for this function:

Here is the caller graph for this function:

operator delete()

void v8::internal::HandleScope::operator delete ( void *  size_t )

private

operator new()

void* v8::internal::HandleScope::operator new ( size_t  size )

private

operator=()

void v8::internal::HandleScope::operator= ( const HandleScope &  )

private

Friends And Related Function Documentation

v8::HandleScope

friend class v8::HandleScope

friend

Definition at line 234 of file handles.h.

v8::internal::DeferredHandles

friend class v8::internal::DeferredHandles

friend

Definition at line 235 of file handles.h.

v8::internal::HandleScopeImplementer

friend class v8::internal::HandleScopeImplementer

friend

Definition at line 236 of file handles.h.

v8::internal::Isolate

friend class v8::internal::Isolate

friend

Definition at line 237 of file handles.h.

Member Data Documentation

isolate_

Isolate* v8::internal::HandleScope::isolate_

private

Definition at line 217 of file handles.h.

Referenced by CloseAndEscape(), HandleScope(), isolate(), and ~HandleScope().

prev_limit_

Object** v8::internal::HandleScope::prev_limit_

private

Definition at line 219 of file handles.h.

Referenced by CloseAndEscape(), HandleScope(), and ~HandleScope().

prev_next_

Object** v8::internal::HandleScope::prev_next_

private

Definition at line 218 of file handles.h.

Referenced by CloseAndEscape(), HandleScope(), and ~HandleScope().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/handles.h
• /mnt/V8SourceCode/src/handles-inl.h
• /mnt/V8SourceCode/src/handles.cc