v8::internal::CodeFlusher Class Reference

#include <mark-compact.h>

Collaboration diagram for v8::internal::CodeFlusher:

Public Member Functions
	CodeFlusher (Isolate *isolate)
void	AddCandidate (SharedFunctionInfo *shared_info)
void	AddCandidate (JSFunction *function)
void	AddOptimizedCodeMap (SharedFunctionInfo *code_map_holder)
void	EvictOptimizedCodeMap (SharedFunctionInfo *code_map_holder)
void	EvictCandidate (SharedFunctionInfo *shared_info)
void	EvictCandidate (JSFunction *function)
void	ProcessCandidates ()
void	EvictAllCandidates ()
void	IteratePointersToFromSpace (ObjectVisitor *v)

Private Member Functions
void	ProcessOptimizedCodeMaps ()
void	ProcessJSFunctionCandidates ()
void	ProcessSharedFunctionInfoCandidates ()
void	EvictOptimizedCodeMaps ()
void	EvictJSFunctionCandidates ()
void	EvictSharedFunctionInfoCandidates ()
	DISALLOW_COPY_AND_ASSIGN (CodeFlusher)

Static Private Member Functions
static JSFunction **	GetNextCandidateSlot (JSFunction *candidate)
static JSFunction *	GetNextCandidate (JSFunction *candidate)
static void	SetNextCandidate (JSFunction *candidate, JSFunction *next_candidate)
static void	ClearNextCandidate (JSFunction *candidate, Object *undefined)
static SharedFunctionInfo *	GetNextCandidate (SharedFunctionInfo *candidate)
static void	SetNextCandidate (SharedFunctionInfo *candidate, SharedFunctionInfo *next_candidate)
static void	ClearNextCandidate (SharedFunctionInfo *candidate)
static SharedFunctionInfo *	GetNextCodeMap (SharedFunctionInfo *holder)
static void	SetNextCodeMap (SharedFunctionInfo *holder, SharedFunctionInfo *next_holder)
static void	ClearNextCodeMap (SharedFunctionInfo *holder)

Private Attributes
Isolate *	isolate_
JSFunction *	jsfunction_candidates_head_
SharedFunctionInfo *	shared_function_info_candidates_head_
SharedFunctionInfo *	optimized_code_map_holder_head_

Detailed Description

Definition at line 376 of file mark-compact.h.

Constructor & Destructor Documentation

CodeFlusher()

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

inlineexplicit

Definition at line 378 of file mark-compact.h.

      : isolate_(isolate),
        jsfunction_candidates_head_(NULL),
        shared_function_info_candidates_head_(NULL),
        optimized_code_map_holder_head_(NULL) {}

Member Function Documentation

AddCandidate() [1/2]

void v8::internal::CodeFlusher::AddCandidate ( JSFunction *  function )

inline

Definition at line 391 of file mark-compact.h.

                                          {
    DCHECK(function->code() == function->shared()->code());
    if (GetNextCandidate(function)->IsUndefined()) {
      SetNextCandidate(function, jsfunction_candidates_head_);
      jsfunction_candidates_head_ = function;
    }
  }

References DCHECK, GetNextCandidate(), jsfunction_candidates_head_, and SetNextCandidate().

Here is the call graph for this function:

AddCandidate() [2/2]

void v8::internal::CodeFlusher::AddCandidate ( SharedFunctionInfo *  shared_info )

inline

Definition at line 384 of file mark-compact.h.

                                                     {
    if (GetNextCandidate(shared_info) == NULL) {
      SetNextCandidate(shared_info, shared_function_info_candidates_head_);
      shared_function_info_candidates_head_ = shared_info;
    }
  }

References GetNextCandidate(), NULL, SetNextCandidate(), and shared_function_info_candidates_head_.

Here is the call graph for this function:

AddOptimizedCodeMap()

void v8::internal::CodeFlusher::AddOptimizedCodeMap ( SharedFunctionInfo *  code_map_holder )

inline

Definition at line 399 of file mark-compact.h.

                                                                {
    if (GetNextCodeMap(code_map_holder)->IsUndefined()) {
      SetNextCodeMap(code_map_holder, optimized_code_map_holder_head_);
      optimized_code_map_holder_head_ = code_map_holder;
    }
  }

References GetNextCodeMap(), optimized_code_map_holder_head_, and SetNextCodeMap().

Here is the call graph for this function:

ClearNextCandidate() [1/2]

static void v8::internal::CodeFlusher::ClearNextCandidate ( JSFunction *  candidate, Object *  undefined  )

inlinestaticprivate

Definition at line 447 of file mark-compact.h.

                                                                           {
    DCHECK(undefined->IsUndefined());
    candidate->set_next_function_link(undefined, SKIP_WRITE_BARRIER);
  }

References DCHECK, and v8::internal::SKIP_WRITE_BARRIER.

Referenced by EvictCandidate(), ProcessJSFunctionCandidates(), and ProcessSharedFunctionInfoCandidates().

Here is the caller graph for this function:

ClearNextCandidate() [2/2]

static void v8::internal::CodeFlusher::ClearNextCandidate ( SharedFunctionInfo *  candidate )

inlinestaticprivate

Definition at line 462 of file mark-compact.h.

                                                                {
    candidate->code()->set_gc_metadata(NULL, SKIP_WRITE_BARRIER);
  }

References NULL, and v8::internal::SKIP_WRITE_BARRIER.

ClearNextCodeMap()

static void v8::internal::CodeFlusher::ClearNextCodeMap ( SharedFunctionInfo *  holder )

inlinestaticprivate

Definition at line 478 of file mark-compact.h.

                                                           {
    FixedArray* code_map = FixedArray::cast(holder->optimized_code_map());
    code_map->set_undefined(SharedFunctionInfo::kNextMapIndex);
  }

References v8::internal::SharedFunctionInfo::kNextMapIndex, and v8::internal::FixedArray::set_undefined().

Referenced by EvictOptimizedCodeMap(), and ProcessOptimizedCodeMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::CodeFlusher::DISALLOW_COPY_AND_ASSIGN ( CodeFlusher  )

private

EvictAllCandidates()

void v8::internal::CodeFlusher::EvictAllCandidates ( )

inline

Definition at line 416 of file mark-compact.h.

                            {
    EvictOptimizedCodeMaps();
    EvictJSFunctionCandidates();
    EvictSharedFunctionInfoCandidates();
  }

References EvictJSFunctionCandidates(), EvictOptimizedCodeMaps(), and EvictSharedFunctionInfoCandidates().

Referenced by v8::internal::MarkCompactCollector::EnableCodeFlushing().

Here is the call graph for this function:

Here is the caller graph for this function:

EvictCandidate() [1/2]

void v8::internal::CodeFlusher::EvictCandidate

(

JSFunction *

function

)

Definition at line 1184 of file mark-compact.cc.

                                                     {
  DCHECK(!function->next_function_link()->IsUndefined());
  Object* undefined = isolate_->heap()->undefined_value();
 
  // Make sure previous flushing decisions are revisited.
  isolate_->heap()->incremental_marking()->RecordWrites(function);
  isolate_->heap()->incremental_marking()->RecordWrites(function->shared());
 
  if (FLAG_trace_code_flushing) {
    PrintF("[code-flushing abandons closure: ");
    function->shared()->ShortPrint();
    PrintF("]\n");
  }
 
  JSFunction* candidate = jsfunction_candidates_head_;
  JSFunction* next_candidate;
  if (candidate == function) {
    next_candidate = GetNextCandidate(function);
    jsfunction_candidates_head_ = next_candidate;
    ClearNextCandidate(function, undefined);
  } else {
    while (candidate != NULL) {
      next_candidate = GetNextCandidate(candidate);
 
      if (next_candidate == function) {
        next_candidate = GetNextCandidate(function);
        SetNextCandidate(candidate, next_candidate);
        ClearNextCandidate(function, undefined);
        break;
      }
 
      candidate = next_candidate;
    }
  }
}

References ClearNextCandidate(), DCHECK, GetNextCandidate(), v8::internal::Isolate::heap(), v8::internal::Heap::incremental_marking(), isolate_, jsfunction_candidates_head_, NULL, v8::internal::PrintF(), v8::internal::IncrementalMarking::RecordWrites(), and SetNextCandidate().

Here is the call graph for this function:

EvictCandidate() [2/2]

void v8::internal::CodeFlusher::EvictCandidate

(

SharedFunctionInfo *

shared_info

)

Definition at line 1151 of file mark-compact.cc.

                                                                {
  // Make sure previous flushing decisions are revisited.
  isolate_->heap()->incremental_marking()->RecordWrites(shared_info);
 
  if (FLAG_trace_code_flushing) {
    PrintF("[code-flushing abandons function-info: ");
    shared_info->ShortPrint();
    PrintF("]\n");
  }
 
  SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
  SharedFunctionInfo* next_candidate;
  if (candidate == shared_info) {
    next_candidate = GetNextCandidate(shared_info);
    shared_function_info_candidates_head_ = next_candidate;
    ClearNextCandidate(shared_info);
  } else {
    while (candidate != NULL) {
      next_candidate = GetNextCandidate(candidate);
 
      if (next_candidate == shared_info) {
        next_candidate = GetNextCandidate(shared_info);
        SetNextCandidate(candidate, next_candidate);
        ClearNextCandidate(shared_info);
        break;
      }
 
      candidate = next_candidate;
    }
  }
}

References ClearNextCandidate(), GetNextCandidate(), v8::internal::Isolate::heap(), v8::internal::Heap::incremental_marking(), isolate_, NULL, v8::internal::PrintF(), v8::internal::IncrementalMarking::RecordWrites(), SetNextCandidate(), shared_function_info_candidates_head_, and v8::internal::Object::ShortPrint().

Referenced by v8::internal::Context::AddOptimizedFunction(), EvictJSFunctionCandidates(), EvictSharedFunctionInfoCandidates(), and v8::internal::SharedFunctionInfo::ReplaceCode().

Here is the call graph for this function:

Here is the caller graph for this function:

EvictJSFunctionCandidates()

void v8::internal::CodeFlusher::EvictJSFunctionCandidates ( )

private

Definition at line 1258 of file mark-compact.cc.

                                            {
  JSFunction* candidate = jsfunction_candidates_head_;
  JSFunction* next_candidate;
  while (candidate != NULL) {
    next_candidate = GetNextCandidate(candidate);
    EvictCandidate(candidate);
    candidate = next_candidate;
  }
  DCHECK(jsfunction_candidates_head_ == NULL);
}

References DCHECK, EvictCandidate(), GetNextCandidate(), jsfunction_candidates_head_, and NULL.

Referenced by EvictAllCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

EvictOptimizedCodeMap()

void v8::internal::CodeFlusher::EvictOptimizedCodeMap

(

SharedFunctionInfo *

code_map_holder

)

Definition at line 1221 of file mark-compact.cc.

                                                                           {
  DCHECK(!FixedArray::cast(code_map_holder->optimized_code_map())
              ->get(SharedFunctionInfo::kNextMapIndex)
              ->IsUndefined());
 
  // Make sure previous flushing decisions are revisited.
  isolate_->heap()->incremental_marking()->RecordWrites(code_map_holder);
 
  if (FLAG_trace_code_flushing) {
    PrintF("[code-flushing abandons code-map: ");
    code_map_holder->ShortPrint();
    PrintF("]\n");
  }
 
  SharedFunctionInfo* holder = optimized_code_map_holder_head_;
  SharedFunctionInfo* next_holder;
  if (holder == code_map_holder) {
    next_holder = GetNextCodeMap(code_map_holder);
    optimized_code_map_holder_head_ = next_holder;
    ClearNextCodeMap(code_map_holder);
  } else {
    while (holder != NULL) {
      next_holder = GetNextCodeMap(holder);
 
      if (next_holder == code_map_holder) {
        next_holder = GetNextCodeMap(code_map_holder);
        SetNextCodeMap(holder, next_holder);
        ClearNextCodeMap(code_map_holder);
        break;
      }
 
      holder = next_holder;
    }
  }
}

References ClearNextCodeMap(), DCHECK, GetNextCodeMap(), v8::internal::Isolate::heap(), v8::internal::Heap::incremental_marking(), isolate_, v8::internal::SharedFunctionInfo::kNextMapIndex, NULL, optimized_code_map_holder_head_, v8::internal::PrintF(), v8::internal::IncrementalMarking::RecordWrites(), SetNextCodeMap(), and v8::internal::Object::ShortPrint().

Referenced by v8::internal::SharedFunctionInfo::ClearOptimizedCodeMap(), and EvictOptimizedCodeMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

EvictOptimizedCodeMaps()

void v8::internal::CodeFlusher::EvictOptimizedCodeMaps ( )

private

Definition at line 1282 of file mark-compact.cc.

                                         {
  SharedFunctionInfo* holder = optimized_code_map_holder_head_;
  SharedFunctionInfo* next_holder;
  while (holder != NULL) {
    next_holder = GetNextCodeMap(holder);
    EvictOptimizedCodeMap(holder);
    holder = next_holder;
  }
  DCHECK(optimized_code_map_holder_head_ == NULL);
}

References DCHECK, EvictOptimizedCodeMap(), GetNextCodeMap(), NULL, and optimized_code_map_holder_head_.

Referenced by EvictAllCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

EvictSharedFunctionInfoCandidates()

void v8::internal::CodeFlusher::EvictSharedFunctionInfoCandidates ( )

private

Definition at line 1270 of file mark-compact.cc.

                                                    {
  SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
  SharedFunctionInfo* next_candidate;
  while (candidate != NULL) {
    next_candidate = GetNextCandidate(candidate);
    EvictCandidate(candidate);
    candidate = next_candidate;
  }
  DCHECK(shared_function_info_candidates_head_ == NULL);
}

References DCHECK, EvictCandidate(), GetNextCandidate(), NULL, and shared_function_info_candidates_head_.

Referenced by EvictAllCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNextCandidate() [1/2]

static JSFunction* v8::internal::CodeFlusher::GetNextCandidate ( JSFunction *  candidate )

inlinestaticprivate

Definition at line 437 of file mark-compact.h.

                                                             {
    Object* next_candidate = candidate->next_function_link();
    return reinterpret_cast<JSFunction*>(next_candidate);
  }

Referenced by AddCandidate(), EvictCandidate(), EvictJSFunctionCandidates(), EvictSharedFunctionInfoCandidates(), IteratePointersToFromSpace(), ProcessJSFunctionCandidates(), and ProcessSharedFunctionInfoCandidates().

Here is the caller graph for this function:

GetNextCandidate() [2/2]

static SharedFunctionInfo* v8::internal::CodeFlusher::GetNextCandidate ( SharedFunctionInfo *  candidate )

inlinestaticprivate

Definition at line 452 of file mark-compact.h.

                                                                             {
    Object* next_candidate = candidate->code()->gc_metadata();
    return reinterpret_cast<SharedFunctionInfo*>(next_candidate);
  }

GetNextCandidateSlot()

static JSFunction** v8::internal::CodeFlusher::GetNextCandidateSlot ( JSFunction *  candidate )

inlinestaticprivate

Definition at line 432 of file mark-compact.h.

                                                                  {
    return reinterpret_cast<JSFunction**>(
        HeapObject::RawField(candidate, JSFunction::kNextFunctionLinkOffset));
  }

References v8::internal::JSFunction::kNextFunctionLinkOffset, and v8::internal::HeapObject::RawField().

Referenced by IteratePointersToFromSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNextCodeMap()

static SharedFunctionInfo* v8::internal::CodeFlusher::GetNextCodeMap ( SharedFunctionInfo *  holder )

inlinestaticprivate

Definition at line 466 of file mark-compact.h.

                                                                        {
    FixedArray* code_map = FixedArray::cast(holder->optimized_code_map());
    Object* next_map = code_map->get(SharedFunctionInfo::kNextMapIndex);
    return reinterpret_cast<SharedFunctionInfo*>(next_map);
  }

References v8::internal::FixedArray::get(), and v8::internal::SharedFunctionInfo::kNextMapIndex.

Referenced by AddOptimizedCodeMap(), EvictOptimizedCodeMap(), EvictOptimizedCodeMaps(), and ProcessOptimizedCodeMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

IteratePointersToFromSpace()

void v8::internal::CodeFlusher::IteratePointersToFromSpace

(

ObjectVisitor *

v

)

Definition at line 1294 of file mark-compact.cc.

                                                             {
  Heap* heap = isolate_->heap();
 
  JSFunction** slot = &jsfunction_candidates_head_;
  JSFunction* candidate = jsfunction_candidates_head_;
  while (candidate != NULL) {
    if (heap->InFromSpace(candidate)) {
      v->VisitPointer(reinterpret_cast<Object**>(slot));
    }
    candidate = GetNextCandidate(*slot);
    slot = GetNextCandidateSlot(*slot);
  }
}

References GetNextCandidate(), GetNextCandidateSlot(), v8::internal::Isolate::heap(), v8::internal::Heap::InFromSpace(), isolate_, jsfunction_candidates_head_, and NULL.

Referenced by v8::internal::Heap::Scavenge().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessCandidates()

void v8::internal::CodeFlusher::ProcessCandidates ( )

inline

Definition at line 410 of file mark-compact.h.

                           {
    ProcessOptimizedCodeMaps();
    ProcessSharedFunctionInfoCandidates();
    ProcessJSFunctionCandidates();
  }

References ProcessJSFunctionCandidates(), ProcessOptimizedCodeMaps(), and ProcessSharedFunctionInfoCandidates().

Referenced by v8::internal::MarkCompactCollector::AfterMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessJSFunctionCandidates()

void v8::internal::CodeFlusher::ProcessJSFunctionCandidates ( )

private

Definition at line 1026 of file mark-compact.cc.

                                              {
  Code* lazy_compile = isolate_->builtins()->builtin(Builtins::kCompileLazy);
  Object* undefined = isolate_->heap()->undefined_value();
 
  JSFunction* candidate = jsfunction_candidates_head_;
  JSFunction* next_candidate;
  while (candidate != NULL) {
    next_candidate = GetNextCandidate(candidate);
    ClearNextCandidate(candidate, undefined);
 
    SharedFunctionInfo* shared = candidate->shared();
 
    Code* code = shared->code();
    MarkBit code_mark = Marking::MarkBitFrom(code);
    if (!code_mark.Get()) {
      if (FLAG_trace_code_flushing && shared->is_compiled()) {
        PrintF("[code-flushing clears: ");
        shared->ShortPrint();
        PrintF(" - age: %d]\n", code->GetAge());
      }
      shared->set_code(lazy_compile);
      candidate->set_code(lazy_compile);
    } else {
      candidate->set_code(code);
    }
 
    // We are in the middle of a GC cycle so the write barrier in the code
    // setter did not record the slot update and we have to do that manually.
    Address slot = candidate->address() + JSFunction::kCodeEntryOffset;
    Code* target = Code::cast(Code::GetObjectFromEntryAddress(slot));
    isolate_->heap()->mark_compact_collector()->RecordCodeEntrySlot(slot,
                                                                    target);
 
    Object** shared_code_slot =
        HeapObject::RawField(shared, SharedFunctionInfo::kCodeOffset);
    isolate_->heap()->mark_compact_collector()->RecordSlot(
        shared_code_slot, shared_code_slot, *shared_code_slot);
 
    candidate = next_candidate;
  }
 
  jsfunction_candidates_head_ = NULL;
}

References v8::internal::HeapObject::address(), v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), ClearNextCandidate(), v8::internal::MarkBit::Get(), v8::internal::Code::GetAge(), GetNextCandidate(), v8::internal::Code::GetObjectFromEntryAddress(), v8::internal::Isolate::heap(), v8::internal::SharedFunctionInfo::is_compiled(), isolate_, jsfunction_candidates_head_, v8::internal::JSFunction::kCodeEntryOffset, v8::internal::SharedFunctionInfo::kCodeOffset, v8::internal::Heap::mark_compact_collector(), NULL, v8::internal::PrintF(), v8::internal::HeapObject::RawField(), v8::internal::MarkCompactCollector::RecordCodeEntrySlot(), v8::internal::JSFunction::set_code(), and v8::internal::Object::ShortPrint().

Referenced by ProcessCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessOptimizedCodeMaps()

void v8::internal::CodeFlusher::ProcessOptimizedCodeMaps ( )

private

Definition at line 1103 of file mark-compact.cc.

                                           {
  STATIC_ASSERT(SharedFunctionInfo::kEntryLength == 4);
 
  SharedFunctionInfo* holder = optimized_code_map_holder_head_;
  SharedFunctionInfo* next_holder;
 
  while (holder != NULL) {
    next_holder = GetNextCodeMap(holder);
    ClearNextCodeMap(holder);
 
    FixedArray* code_map = FixedArray::cast(holder->optimized_code_map());
    int new_length = SharedFunctionInfo::kEntriesStart;
    int old_length = code_map->length();
    for (int i = SharedFunctionInfo::kEntriesStart; i < old_length;
         i += SharedFunctionInfo::kEntryLength) {
      Code* code =
          Code::cast(code_map->get(i + SharedFunctionInfo::kCachedCodeOffset));
      if (!Marking::MarkBitFrom(code).Get()) continue;
 
      // Move every slot in the entry.
      for (int j = 0; j < SharedFunctionInfo::kEntryLength; j++) {
        int dst_index = new_length++;
        Object** slot = code_map->RawFieldOfElementAt(dst_index);
        Object* object = code_map->get(i + j);
        code_map->set(dst_index, object);
        if (j == SharedFunctionInfo::kOsrAstIdOffset) {
          DCHECK(object->IsSmi());
        } else {
          DCHECK(
              Marking::IsBlack(Marking::MarkBitFrom(HeapObject::cast(*slot))));
          isolate_->heap()->mark_compact_collector()->RecordSlot(slot, slot,
                                                                 *slot);
        }
      }
    }
 
    // Trim the optimized code map if entries have been removed.
    if (new_length < old_length) {
      holder->TrimOptimizedCodeMap(old_length - new_length);
    }
 
    holder = next_holder;
  }
 
  optimized_code_map_holder_head_ = NULL;
}

References ClearNextCodeMap(), DCHECK, v8::internal::FixedArray::get(), GetNextCodeMap(), v8::internal::Isolate::heap(), isolate_, v8::internal::SharedFunctionInfo::kCachedCodeOffset, v8::internal::SharedFunctionInfo::kEntriesStart, v8::internal::SharedFunctionInfo::kEntryLength, v8::internal::SharedFunctionInfo::kOsrAstIdOffset, v8::internal::FixedArrayBase::length(), v8::internal::Heap::mark_compact_collector(), NULL, optimized_code_map_holder_head_, v8::internal::FixedArray::RawFieldOfElementAt(), v8::internal::FixedArray::set(), v8::internal::STATIC_ASSERT(), and v8::internal::SharedFunctionInfo::TrimOptimizedCodeMap().

Referenced by ProcessCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessSharedFunctionInfoCandidates()

void v8::internal::CodeFlusher::ProcessSharedFunctionInfoCandidates ( )

private

Definition at line 1071 of file mark-compact.cc.

                                                      {
  Code* lazy_compile = isolate_->builtins()->builtin(Builtins::kCompileLazy);
 
  SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
  SharedFunctionInfo* next_candidate;
  while (candidate != NULL) {
    next_candidate = GetNextCandidate(candidate);
    ClearNextCandidate(candidate);
 
    Code* code = candidate->code();
    MarkBit code_mark = Marking::MarkBitFrom(code);
    if (!code_mark.Get()) {
      if (FLAG_trace_code_flushing && candidate->is_compiled()) {
        PrintF("[code-flushing clears: ");
        candidate->ShortPrint();
        PrintF(" - age: %d]\n", code->GetAge());
      }
      candidate->set_code(lazy_compile);
    }
 
    Object** code_slot =
        HeapObject::RawField(candidate, SharedFunctionInfo::kCodeOffset);
    isolate_->heap()->mark_compact_collector()->RecordSlot(code_slot, code_slot,
                                                           *code_slot);
 
    candidate = next_candidate;
  }
 
  shared_function_info_candidates_head_ = NULL;
}

References v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), ClearNextCandidate(), v8::internal::MarkBit::Get(), v8::internal::Code::GetAge(), GetNextCandidate(), v8::internal::Isolate::heap(), v8::internal::SharedFunctionInfo::is_compiled(), isolate_, v8::internal::SharedFunctionInfo::kCodeOffset, v8::internal::Heap::mark_compact_collector(), NULL, v8::internal::PrintF(), v8::internal::HeapObject::RawField(), shared_function_info_candidates_head_, and v8::internal::Object::ShortPrint().

Referenced by ProcessCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

SetNextCandidate() [1/2]

static void v8::internal::CodeFlusher::SetNextCandidate ( JSFunction *  candidate, JSFunction *  next_candidate  )

inlinestaticprivate

Definition at line 442 of file mark-compact.h.

                                                           {
    candidate->set_next_function_link(next_candidate);
  }

Referenced by AddCandidate(), and EvictCandidate().

Here is the caller graph for this function:

SetNextCandidate() [2/2]

static void v8::internal::CodeFlusher::SetNextCandidate ( SharedFunctionInfo *  candidate, SharedFunctionInfo *  next_candidate  )

inlinestaticprivate

Definition at line 457 of file mark-compact.h.

                                                                   {
    candidate->code()->set_gc_metadata(next_candidate);
  }

SetNextCodeMap()

static void v8::internal::CodeFlusher::SetNextCodeMap ( SharedFunctionInfo *  holder, SharedFunctionInfo *  next_holder  )

inlinestaticprivate

Definition at line 472 of file mark-compact.h.

                                                              {
    FixedArray* code_map = FixedArray::cast(holder->optimized_code_map());
    code_map->set(SharedFunctionInfo::kNextMapIndex, next_holder);
  }

References v8::internal::SharedFunctionInfo::kNextMapIndex, and v8::internal::FixedArray::set().

Referenced by AddOptimizedCodeMap(), and EvictOptimizedCodeMap().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

isolate_

Isolate* v8::internal::CodeFlusher::isolate_

private

Definition at line 483 of file mark-compact.h.

Referenced by EvictCandidate(), EvictOptimizedCodeMap(), IteratePointersToFromSpace(), ProcessJSFunctionCandidates(), ProcessOptimizedCodeMaps(), and ProcessSharedFunctionInfoCandidates().

jsfunction_candidates_head_

JSFunction* v8::internal::CodeFlusher::jsfunction_candidates_head_

private

Definition at line 484 of file mark-compact.h.

Referenced by AddCandidate(), EvictCandidate(), EvictJSFunctionCandidates(), IteratePointersToFromSpace(), and ProcessJSFunctionCandidates().

optimized_code_map_holder_head_

SharedFunctionInfo* v8::internal::CodeFlusher::optimized_code_map_holder_head_

private

Definition at line 486 of file mark-compact.h.

Referenced by AddOptimizedCodeMap(), EvictOptimizedCodeMap(), EvictOptimizedCodeMaps(), and ProcessOptimizedCodeMaps().

shared_function_info_candidates_head_

SharedFunctionInfo* v8::internal::CodeFlusher::shared_function_info_candidates_head_

private

Definition at line 485 of file mark-compact.h.

Referenced by AddCandidate(), EvictCandidate(), EvictSharedFunctionInfoCandidates(), and ProcessSharedFunctionInfoCandidates().

---

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

• /mnt/V8SourceCode/src/heap/mark-compact.h
• /mnt/V8SourceCode/src/heap/mark-compact.cc