v8::internal::HandleScopeImplementer Class Reference

#include <api.h>

Collaboration diagram for v8::internal::HandleScopeImplementer:

Public Member Functions
	HandleScopeImplementer (Isolate *isolate)
	~HandleScopeImplementer ()
char *	RestoreThread (char *from)
char *	ArchiveThread (char *to)
void	FreeThreadResources ()
void	Iterate (v8::internal::ObjectVisitor *v)
internal::Object **	GetSpareOrNewBlock ()
void	DeleteExtensions (internal::Object **prev_limit)
void	IncrementCallDepth ()
void	DecrementCallDepth ()
bool	CallDepthIsZero ()
void	EnterContext (Handle< Context > context)
void	LeaveContext ()
bool	LastEnteredContextWas (Handle< Context > context)
Handle< Context >	LastEnteredContext ()
void	SaveContext (Context *context)
Context *	RestoreContext ()
bool	HasSavedContexts ()
List< internal::Object ** > *	blocks ()
Isolate *	isolate () const
void	ReturnBlock (Object **block)

Static Public Member Functions
static int	ArchiveSpacePerThread ()
static char *	Iterate (v8::internal::ObjectVisitor *v, char *data)

Private Member Functions
void	ResetAfterArchive ()
void	Free ()
void	BeginDeferredScope ()
DeferredHandles *	Detach (Object **prev_limit)
void	IterateThis (ObjectVisitor *v)
char *	RestoreThreadHelper (char *from)
char *	ArchiveThreadHelper (char *to)
	DISALLOW_COPY_AND_ASSIGN (HandleScopeImplementer)

Private Attributes
Isolate *	isolate_
List< internal::Object ** >	blocks_
List< Context * >	entered_contexts_
List< Context * >	saved_contexts_
Object **	spare_
int	call_depth_
Object **	last_handle_before_deferred_block_
HandleScopeData	handle_scope_data_

Friends
class	DeferredHandles
class	DeferredHandleScope

Detailed Description

Definition at line 492 of file api.h.

Constructor & Destructor Documentation

HandleScopeImplementer()

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

inlineexplicit

Definition at line 494 of file api.h.

      : isolate_(isolate),
        blocks_(0),
        entered_contexts_(0),
        saved_contexts_(0),
        spare_(NULL),
        call_depth_(0),
        last_handle_before_deferred_block_(NULL) { }

~HandleScopeImplementer()

v8::internal::HandleScopeImplementer::~HandleScopeImplementer ( )

inline

Definition at line 503 of file api.h.

                            {
    DeleteArray(spare_);
  }

References v8::internal::DeleteArray(), and spare_.

Here is the call graph for this function:

Member Function Documentation

ArchiveSpacePerThread()

int v8::internal::HandleScopeImplementer::ArchiveSpacePerThread ( )

static

Definition at line 7541 of file api.cc.

                                                  {
  return sizeof(HandleScopeImplementer);
}

Referenced by v8::internal::ArchiveSpacePerThread(), and v8::internal::ThreadManager::IterateArchivedThreads().

Here is the caller graph for this function:

ArchiveThread()

char * v8::internal::HandleScopeImplementer::ArchiveThread

(

char *

to

)

Definition at line 7529 of file api.cc.

                                                         {
  HandleScopeData* current = isolate_->handle_scope_data();
  handle_scope_data_ = *current;
  MemCopy(storage, this, sizeof(*this));
 
  ResetAfterArchive();
  current->Initialize();
 
  return storage + ArchiveSpacePerThread();
}

References v8::internal::ArchiveSpacePerThread(), v8::internal::HandleScopeData::Initialize(), and v8::internal::MemCopy().

Referenced by v8::internal::ThreadManager::EagerlyArchiveThread().

Here is the call graph for this function:

Here is the caller graph for this function:

ArchiveThreadHelper()

char* v8::internal::HandleScopeImplementer::ArchiveThreadHelper ( char *  to )

private

BeginDeferredScope()

void v8::internal::HandleScopeImplementer::BeginDeferredScope ( )

private

Definition at line 7633 of file api.cc.

                                                {
  DCHECK(last_handle_before_deferred_block_ == NULL);
  last_handle_before_deferred_block_ = isolate()->handle_scope_data()->next;
}

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

Referenced by v8::internal::DeferredHandleScope::DeferredHandleScope().

Here is the call graph for this function:

Here is the caller graph for this function:

blocks()

List<internal::Object**>* v8::internal::HandleScopeImplementer::blocks ( )

inline

Definition at line 537 of file api.h.

{ return &blocks_; }

References blocks_.

Referenced by v8::internal::DeferredHandleScope::DeferredHandleScope(), v8::internal::Deserializer::Deserialize(), v8::internal::HandleScope::Extend(), v8::internal::HandleScope::NumberOfHandles(), and v8::internal::StartupSerializer::SerializeStrongReferences().

Here is the caller graph for this function:

CallDepthIsZero()

bool v8::internal::HandleScopeImplementer::CallDepthIsZero ( )

inline

Definition at line 523 of file api.h.

{ return call_depth_ == 0; }

References call_depth_.

DecrementCallDepth()

void v8::internal::HandleScopeImplementer::DecrementCallDepth ( )

inline

Definition at line 522 of file api.h.

{call_depth_--;}

References call_depth_.

DeleteExtensions()

void v8::internal::HandleScopeImplementer::DeleteExtensions ( internal::Object **  prev_limit )

inline

Definition at line 645 of file api.h.

                                                                         {
  while (!blocks_.is_empty()) {
    internal::Object** block_start = blocks_.last();
    internal::Object** block_limit = block_start + kHandleBlockSize;
#ifdef DEBUG
    // SealHandleScope may make the prev_limit to point inside the block.
    if (block_start <= prev_limit && prev_limit <= block_limit) {
#ifdef ENABLE_HANDLE_ZAPPING
      internal::HandleScope::ZapRange(prev_limit, block_limit);
#endif
      break;
    }
#else
    if (prev_limit == block_limit) break;
#endif
 
    blocks_.RemoveLast();
#ifdef ENABLE_HANDLE_ZAPPING
    internal::HandleScope::ZapRange(block_start, block_limit);
#endif
    if (spare_ != NULL) {
      DeleteArray(spare_);
    }
    spare_ = block_start;
  }
  DCHECK((blocks_.is_empty() && prev_limit == NULL) ||
         (!blocks_.is_empty() && prev_limit != NULL));
}

References blocks_, DCHECK, v8::internal::DeleteArray(), v8::internal::kHandleBlockSize, NULL, and spare_.

Referenced by v8::internal::HandleScope::DeleteExtensions().

Here is the call graph for this function:

Here is the caller graph for this function:

Detach()

DeferredHandles * v8::internal::HandleScopeImplementer::Detach ( Object **  prev_limit )

private

Definition at line 7605 of file api.cc.

                                                                   {
  DeferredHandles* deferred =
      new DeferredHandles(isolate()->handle_scope_data()->next, isolate());
 
  while (!blocks_.is_empty()) {
    Object** block_start = blocks_.last();
    Object** block_limit = &block_start[kHandleBlockSize];
    // We should not need to check for SealHandleScope here. Assert this.
    DCHECK(prev_limit == block_limit ||
           !(block_start <= prev_limit && prev_limit <= block_limit));
    if (prev_limit == block_limit) break;
    deferred->blocks_.Add(blocks_.last());
    blocks_.RemoveLast();
  }
 
  // deferred->blocks_ now contains the blocks installed on the
  // HandleScope stack since BeginDeferredScope was called, but in
  // reverse order.
 
  DCHECK(prev_limit == NULL || !blocks_.is_empty());
 
  DCHECK(!blocks_.is_empty() && prev_limit != NULL);
  DCHECK(last_handle_before_deferred_block_ != NULL);
  last_handle_before_deferred_block_ = NULL;
  return deferred;
}

References v8::internal::DeferredHandles::blocks_, DCHECK, v8::internal::kHandleBlockSize, and NULL.

Referenced by v8::internal::DeferredHandleScope::Detach().

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::HandleScopeImplementer::DISALLOW_COPY_AND_ASSIGN ( HandleScopeImplementer  )

private

EnterContext()

void v8::internal::HandleScopeImplementer::EnterContext ( Handle< Context >  context )

inline

Definition at line 614 of file api.h.

                                                                 {
  entered_contexts_.Add(*context);
}

References entered_contexts_.

Referenced by v8::Context::Enter().

Here is the caller graph for this function:

Free()

void v8::internal::HandleScopeImplementer::Free ( )

inlineprivate

Definition at line 556 of file api.h.

              {
    DCHECK(blocks_.length() == 0);
    DCHECK(entered_contexts_.length() == 0);
    DCHECK(saved_contexts_.length() == 0);
    blocks_.Free();
    entered_contexts_.Free();
    saved_contexts_.Free();
    if (spare_ != NULL) {
      DeleteArray(spare_);
      spare_ = NULL;
    }
    DCHECK(call_depth_ == 0);
  }

References blocks_, call_depth_, DCHECK, v8::internal::DeleteArray(), entered_contexts_, NULL, saved_contexts_, and spare_.

Here is the call graph for this function:

FreeThreadResources()

void v8::internal::HandleScopeImplementer::FreeThreadResources

(

)

Definition at line 7524 of file api.cc.

                                                 {
  Free();
}

References v8::internal::Free().

Referenced by v8::internal::ThreadManager::FreeThreadResources().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSpareOrNewBlock()

internal::Object ** v8::internal::HandleScopeImplementer::GetSpareOrNewBlock ( )

inline

Definition at line 636 of file api.h.

                                                            {
  internal::Object** block = (spare_ != NULL) ?
      spare_ :
      NewArray<internal::Object*>(kHandleBlockSize);
  spare_ = NULL;
  return block;
}

References v8::internal::kHandleBlockSize, NULL, and spare_.

Referenced by v8::internal::DeferredHandleScope::DeferredHandleScope(), and v8::internal::HandleScope::Extend().

Here is the caller graph for this function:

HasSavedContexts()

bool v8::internal::HandleScopeImplementer::HasSavedContexts ( )

inline

Definition at line 609 of file api.h.

                                              {
  return !saved_contexts_.is_empty();
}

References saved_contexts_.

IncrementCallDepth()

void v8::internal::HandleScopeImplementer::IncrementCallDepth ( )

inline

Definition at line 521 of file api.h.

{call_depth_++;}

References call_depth_.

Referenced by v8::Isolate::SuppressMicrotaskExecutionScope::SuppressMicrotaskExecutionScope().

Here is the caller graph for this function:

isolate()

Isolate* v8::internal::HandleScopeImplementer::isolate ( ) const

inline

Definition at line 538 of file api.h.

{ return isolate_; }

References isolate_.

Referenced by v8::internal::DeferredHandleScope::DeferredHandleScope(), v8::internal::DeferredHandleScope::Detach(), and v8::internal::DeferredHandleScope::~DeferredHandleScope().

Here is the caller graph for this function:

Iterate() [1/2]

void v8::internal::HandleScopeImplementer::Iterate

(

v8::internal::ObjectVisitor *

v

)

Definition at line 7590 of file api.cc.

                                                     {
  HandleScopeData* current = isolate_->handle_scope_data();
  handle_scope_data_ = *current;
  IterateThis(v);
}

Referenced by v8::internal::ThreadManager::Iterate(), v8::internal::Heap::IterateStrongRoots(), and v8::internal::MarkCompactCollector::PrepareForCodeFlushing().

Here is the caller graph for this function:

Iterate() [2/2]

char * v8::internal::HandleScopeImplementer::Iterate ( v8::internal::ObjectVisitor *  v, char *  data  )

static

Definition at line 7597 of file api.cc.

                                                                     {
  HandleScopeImplementer* scope_implementer =
      reinterpret_cast<HandleScopeImplementer*>(storage);
  scope_implementer->IterateThis(v);
  return storage + ArchiveSpacePerThread();
}

References v8::internal::ArchiveSpacePerThread(), and IterateThis().

Here is the call graph for this function:

IterateThis()

void v8::internal::HandleScopeImplementer::IterateThis ( ObjectVisitor *  v )

private

Definition at line 7553 of file api.cc.

                                                         {
#ifdef DEBUG
  bool found_block_before_deferred = false;
#endif
  // Iterate over all handles in the blocks except for the last.
  for (int i = blocks()->length() - 2; i >= 0; --i) {
    Object** block = blocks()->at(i);
    if (last_handle_before_deferred_block_ != NULL &&
        (last_handle_before_deferred_block_ <= &block[kHandleBlockSize]) &&
        (last_handle_before_deferred_block_ >= block)) {
      v->VisitPointers(block, last_handle_before_deferred_block_);
      DCHECK(!found_block_before_deferred);
#ifdef DEBUG
      found_block_before_deferred = true;
#endif
    } else {
      v->VisitPointers(block, &block[kHandleBlockSize]);
    }
  }
 
  DCHECK(last_handle_before_deferred_block_ == NULL ||
         found_block_before_deferred);
 
  // Iterate over live handles in the last block (if any).
  if (!blocks()->is_empty()) {
    v->VisitPointers(blocks()->last(), handle_scope_data_.next);
  }
 
  List<Context*>* context_lists[2] = { &saved_contexts_, &entered_contexts_};
  for (unsigned i = 0; i < arraysize(context_lists); i++) {
    if (context_lists[i]->is_empty()) continue;
    Object** start = reinterpret_cast<Object**>(&context_lists[i]->first());
    v->VisitPointers(start, start + context_lists[i]->length());
  }
}

References arraysize, DCHECK, v8::internal::List< T, AllocationPolicy >::first(), v8::internal::kHandleBlockSize, and NULL.

Referenced by Iterate().

Here is the call graph for this function:

Here is the caller graph for this function:

LastEnteredContext()

Handle< Context > v8::internal::HandleScopeImplementer::LastEnteredContext ( )

inline

Definition at line 629 of file api.h.

                                                           {
  if (entered_contexts_.is_empty()) return Handle<Context>::null();
  return Handle<Context>(entered_contexts_.last());
}

References entered_contexts_, and v8::internal::Handle< T >::null().

Referenced by v8::Isolate::GetEnteredContext().

Here is the call graph for this function:

Here is the caller graph for this function:

LastEnteredContextWas()

bool v8::internal::HandleScopeImplementer::LastEnteredContextWas ( Handle< Context >  context )

inline

Definition at line 624 of file api.h.

                                                                          {
  return !entered_contexts_.is_empty() && entered_contexts_.last() == *context;
}

References entered_contexts_.

Referenced by v8::Context::Exit().

Here is the caller graph for this function:

LeaveContext()

void v8::internal::HandleScopeImplementer::LeaveContext ( )

inline

Definition at line 619 of file api.h.

                                          {
  entered_contexts_.RemoveLast();
}

References entered_contexts_.

Referenced by v8::Context::Exit().

Here is the caller graph for this function:

ResetAfterArchive()

void v8::internal::HandleScopeImplementer::ResetAfterArchive ( )

inlineprivate

Definition at line 547 of file api.h.

                           {
    blocks_.Initialize(0);
    entered_contexts_.Initialize(0);
    saved_contexts_.Initialize(0);
    spare_ = NULL;
    last_handle_before_deferred_block_ = NULL;
    call_depth_ = 0;
  }

References blocks_, call_depth_, entered_contexts_, last_handle_before_deferred_block_, NULL, saved_contexts_, and spare_.

RestoreContext()

Context * v8::internal::HandleScopeImplementer::RestoreContext ( )

inline

Definition at line 604 of file api.h.

                                                {
  return saved_contexts_.RemoveLast();
}

References saved_contexts_.

Referenced by v8::Context::Exit().

Here is the caller graph for this function:

RestoreThread()

char * v8::internal::HandleScopeImplementer::RestoreThread

(

char *

from

)

Definition at line 7546 of file api.cc.

                                                         {
  MemCopy(this, storage, sizeof(*this));
  *isolate_->handle_scope_data() = handle_scope_data_;
  return storage + ArchiveSpacePerThread();
}

References v8::internal::ArchiveSpacePerThread(), and v8::internal::MemCopy().

Referenced by v8::internal::ThreadManager::RestoreThread().

Here is the call graph for this function:

Here is the caller graph for this function:

RestoreThreadHelper()

char* v8::internal::HandleScopeImplementer::RestoreThreadHelper ( char *  from )

private

ReturnBlock()

void v8::internal::HandleScopeImplementer::ReturnBlock ( Object **  block )

inline

Definition at line 540 of file api.h.

                                   {
    DCHECK(block != NULL);
    if (spare_ != NULL) DeleteArray(spare_);
    spare_ = block;
  }

References DCHECK, v8::internal::DeleteArray(), NULL, and spare_.

Here is the call graph for this function:

SaveContext()

void v8::internal::HandleScopeImplementer::SaveContext ( Context *  context )

inline

Definition at line 599 of file api.h.

                                                         {
  saved_contexts_.Add(context);
}

References saved_contexts_.

Referenced by v8::Context::Enter().

Here is the caller graph for this function:

Friends And Related Function Documentation

DeferredHandles

friend class DeferredHandles

friend

Definition at line 589 of file api.h.

DeferredHandleScope

friend class DeferredHandleScope

friend

Definition at line 590 of file api.h.

Member Data Documentation

blocks_

List<internal::Object**> v8::internal::HandleScopeImplementer::blocks_

private

Definition at line 574 of file api.h.

Referenced by blocks(), DeleteExtensions(), Free(), and ResetAfterArchive().

call_depth_

int v8::internal::HandleScopeImplementer::call_depth_

private

Definition at line 580 of file api.h.

Referenced by CallDepthIsZero(), DecrementCallDepth(), Free(), IncrementCallDepth(), and ResetAfterArchive().

entered_contexts_

List<Context*> v8::internal::HandleScopeImplementer::entered_contexts_

private

Definition at line 576 of file api.h.

Referenced by EnterContext(), Free(), LastEnteredContext(), LastEnteredContextWas(), LeaveContext(), and ResetAfterArchive().

handle_scope_data_

HandleScopeData v8::internal::HandleScopeImplementer::handle_scope_data_

private

Definition at line 583 of file api.h.

isolate_

Isolate* v8::internal::HandleScopeImplementer::isolate_

private

Definition at line 573 of file api.h.

Referenced by isolate().

last_handle_before_deferred_block_

Object** v8::internal::HandleScopeImplementer::last_handle_before_deferred_block_

private

Definition at line 581 of file api.h.

Referenced by ResetAfterArchive().

saved_contexts_

List<Context*> v8::internal::HandleScopeImplementer::saved_contexts_

private

Definition at line 578 of file api.h.

Referenced by Free(), HasSavedContexts(), ResetAfterArchive(), RestoreContext(), and SaveContext().

spare_

Object** v8::internal::HandleScopeImplementer::spare_

private

Definition at line 579 of file api.h.

Referenced by DeleteExtensions(), Free(), GetSpareOrNewBlock(), ResetAfterArchive(), ReturnBlock(), and ~HandleScopeImplementer().

---

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

• /mnt/V8SourceCode/src/api.h
• /mnt/V8SourceCode/src/api.cc