v8::internal::ExternalReferenceTable Class Reference

#include <serialize.h>

Collaboration diagram for v8::internal::ExternalReferenceTable:

Classes
struct	ExternalReferenceEntry

Public Member Functions
	~ExternalReferenceTable ()
int	size () const
Address	address (int i)
uint32_t	code (int i)
const char *	name (int i)
int	max_id (int code)

Static Public Member Functions
static ExternalReferenceTable *	instance (Isolate *isolate)

Private Member Functions
	ExternalReferenceTable (Isolate *isolate)
void	PopulateTable (Isolate *isolate)
void	AddFromId (TypeCode type, uint16_t id, const char *name, Isolate *isolate)
void	Add (Address address, TypeCode type, uint16_t id, const char *name)
void	Add (Address address, const char *name)

Private Attributes
List< ExternalReferenceEntry >	refs_
uint16_t	max_id_ [kTypeCodeCount]

Detailed Description

Definition at line 45 of file serialize.h.

Constructor & Destructor Documentation

~ExternalReferenceTable()

v8::internal::ExternalReferenceTable::~ExternalReferenceTable ( )

inline

Definition at line 49 of file serialize.h.

{ }

ExternalReferenceTable()

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

inlineexplicitprivate

Definition at line 62 of file serialize.h.

                                                    : refs_(64) {
    PopulateTable(isolate);
  }

References PopulateTable().

Referenced by instance().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

Add() [1/2]

void v8::internal::ExternalReferenceTable::Add ( Address  address, const char *  name  )

inlineprivate

Definition at line 83 of file serialize.h.

                                              {
    Add(address, UNCLASSIFIED, ++max_id_[UNCLASSIFIED], name);
  }

References Add(), address(), max_id_, name(), and v8::internal::UNCLASSIFIED.

Here is the call graph for this function:

Add() [2/2]

void v8::internal::ExternalReferenceTable::Add ( Address  address, TypeCode  type, uint16_t  id, const char *  name  )

private

Definition at line 94 of file serialize.cc.

                                                   {
  DCHECK_NE(NULL, address);
  ExternalReferenceEntry entry;
  entry.address = address;
  entry.code = EncodeExternal(type, id);
  entry.name = name;
  DCHECK_NE(0, entry.code);
  // Assert that the code is added in ascending order to rule out duplicates.
  DCHECK((size() == 0) || (code(size() - 1) < entry.code));
  refs_.Add(entry);
  if (id > max_id_[type]) max_id_[type] = id;
}

References address(), v8::internal::ExternalReferenceTable::ExternalReferenceEntry::address, code(), v8::internal::ExternalReferenceTable::ExternalReferenceEntry::code, DCHECK, DCHECK_NE, v8::internal::EncodeExternal(), max_id_, name(), v8::internal::ExternalReferenceTable::ExternalReferenceEntry::name, NULL, refs_, and size().

Referenced by Add(), AddFromId(), and PopulateTable().

Here is the call graph for this function:

Here is the caller graph for this function:

AddFromId()

void v8::internal::ExternalReferenceTable::AddFromId ( TypeCode  type, uint16_t  id, const char *  name, Isolate *  isolate  )

private

Definition at line 59 of file serialize.cc.

                                                         {
  Address address;
  switch (type) {
    case C_BUILTIN: {
      ExternalReference ref(static_cast<Builtins::CFunctionId>(id), isolate);
      address = ref.address();
      break;
    }
    case BUILTIN: {
      ExternalReference ref(static_cast<Builtins::Name>(id), isolate);
      address = ref.address();
      break;
    }
    case RUNTIME_FUNCTION: {
      ExternalReference ref(static_cast<Runtime::FunctionId>(id), isolate);
      address = ref.address();
      break;
    }
    case IC_UTILITY: {
      ExternalReference ref(IC_Utility(static_cast<IC::UtilityId>(id)),
                            isolate);
      address = ref.address();
      break;
    }
    default:
      UNREACHABLE();
      return;
  }
  Add(address, type, id, name);
}

References Add(), address(), v8::internal::BUILTIN, v8::internal::C_BUILTIN, v8::internal::IC_UTILITY, name(), v8::internal::RUNTIME_FUNCTION, and UNREACHABLE.

Referenced by PopulateTable().

Here is the call graph for this function:

Here is the caller graph for this function:

address()

Address v8::internal::ExternalReferenceTable::address ( int  i )

inline

Definition at line 53 of file serialize.h.

{ return refs_[i].address; }

References refs_.

Referenced by Add(), AddFromId(), v8::internal::ExternalReferenceDecoder::ExternalReferenceDecoder(), v8::internal::ExternalReferenceEncoder::ExternalReferenceEncoder(), and PopulateTable().

Here is the caller graph for this function:

code()

uint32_t v8::internal::ExternalReferenceTable::code ( int  i )

inline

Definition at line 55 of file serialize.h.

{ return refs_[i].code; }

References refs_.

Referenced by Add(), v8::internal::ExternalReferenceEncoder::Encode(), v8::internal::ExternalReferenceDecoder::ExternalReferenceDecoder(), and max_id().

Here is the caller graph for this function:

instance()

ExternalReferenceTable * v8::internal::ExternalReferenceTable::instance ( Isolate *  isolate )

static

Definition at line 48 of file serialize.cc.

                                                                         {
  ExternalReferenceTable* external_reference_table =
      isolate->external_reference_table();
  if (external_reference_table == NULL) {
    external_reference_table = new ExternalReferenceTable(isolate);
    isolate->set_external_reference_table(external_reference_table);
  }
  return external_reference_table;
}

References ExternalReferenceTable(), and NULL.

Referenced by v8::internal::ExternalReferenceEncoder::Encode(), v8::internal::ExternalReferenceDecoder::ExternalReferenceDecoder(), v8::internal::ExternalReferenceEncoder::ExternalReferenceEncoder(), and v8::internal::ExternalReferenceEncoder::NameOfAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

max_id()

int v8::internal::ExternalReferenceTable::max_id ( int  code )

inline

Definition at line 59 of file serialize.h.

{ return max_id_[code]; }

References code(), and max_id_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

name()

const char* v8::internal::ExternalReferenceTable::name ( int  i )

inline

Definition at line 57 of file serialize.h.

{ return refs_[i].name; }

References refs_.

Referenced by Add(), AddFromId(), v8::internal::ExternalReferenceEncoder::NameOfAddress(), and PopulateTable().

Here is the caller graph for this function:

PopulateTable()

void v8::internal::ExternalReferenceTable::PopulateTable ( Isolate *  isolate )

private

Definition at line 111 of file serialize.cc.

                                                           {
  for (int type_code = 0; type_code < kTypeCodeCount; type_code++) {
    max_id_[type_code] = 0;
  }
 
  // Miscellaneous
  Add(ExternalReference::roots_array_start(isolate).address(),
      "Heap::roots_array_start()");
  Add(ExternalReference::address_of_stack_limit(isolate).address(),
      "StackGuard::address_of_jslimit()");
  Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
      "StackGuard::address_of_real_jslimit()");
  Add(ExternalReference::new_space_start(isolate).address(),
      "Heap::NewSpaceStart()");
  Add(ExternalReference::new_space_mask(isolate).address(),
      "Heap::NewSpaceMask()");
  Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
      "Heap::NewSpaceAllocationLimitAddress()");
  Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
      "Heap::NewSpaceAllocationTopAddress()");
  Add(ExternalReference::debug_break(isolate).address(), "Debug::Break()");
  Add(ExternalReference::debug_step_in_fp_address(isolate).address(),
      "Debug::step_in_fp_addr()");
  Add(ExternalReference::mod_two_doubles_operation(isolate).address(),
      "mod_two_doubles");
  // Keyed lookup cache.
  Add(ExternalReference::keyed_lookup_cache_keys(isolate).address(),
      "KeyedLookupCache::keys()");
  Add(ExternalReference::keyed_lookup_cache_field_offsets(isolate).address(),
      "KeyedLookupCache::field_offsets()");
  Add(ExternalReference::handle_scope_next_address(isolate).address(),
      "HandleScope::next");
  Add(ExternalReference::handle_scope_limit_address(isolate).address(),
      "HandleScope::limit");
  Add(ExternalReference::handle_scope_level_address(isolate).address(),
      "HandleScope::level");
  Add(ExternalReference::new_deoptimizer_function(isolate).address(),
      "Deoptimizer::New()");
  Add(ExternalReference::compute_output_frames_function(isolate).address(),
      "Deoptimizer::ComputeOutputFrames()");
  Add(ExternalReference::address_of_min_int().address(),
      "LDoubleConstant::min_int");
  Add(ExternalReference::address_of_one_half().address(),
      "LDoubleConstant::one_half");
  Add(ExternalReference::isolate_address(isolate).address(), "isolate");
  Add(ExternalReference::address_of_negative_infinity().address(),
      "LDoubleConstant::negative_infinity");
  Add(ExternalReference::power_double_double_function(isolate).address(),
      "power_double_double_function");
  Add(ExternalReference::power_double_int_function(isolate).address(),
      "power_double_int_function");
  Add(ExternalReference::math_log_double_function(isolate).address(),
      "std::log");
  Add(ExternalReference::store_buffer_top(isolate).address(),
      "store_buffer_top");
  Add(ExternalReference::address_of_canonical_non_hole_nan().address(),
      "canonical_nan");
  Add(ExternalReference::address_of_the_hole_nan().address(), "the_hole_nan");
  Add(ExternalReference::get_date_field_function(isolate).address(),
      "JSDate::GetField");
  Add(ExternalReference::date_cache_stamp(isolate).address(),
      "date_cache_stamp");
  Add(ExternalReference::address_of_pending_message_obj(isolate).address(),
      "address_of_pending_message_obj");
  Add(ExternalReference::address_of_has_pending_message(isolate).address(),
      "address_of_has_pending_message");
  Add(ExternalReference::address_of_pending_message_script(isolate).address(),
      "pending_message_script");
  Add(ExternalReference::get_make_code_young_function(isolate).address(),
      "Code::MakeCodeYoung");
  Add(ExternalReference::cpu_features().address(), "cpu_features");
  Add(ExternalReference(Runtime::kAllocateInNewSpace, isolate).address(),
      "Runtime::AllocateInNewSpace");
  Add(ExternalReference(Runtime::kAllocateInTargetSpace, isolate).address(),
      "Runtime::AllocateInTargetSpace");
  Add(ExternalReference::old_pointer_space_allocation_top_address(isolate)
          .address(),
      "Heap::OldPointerSpaceAllocationTopAddress");
  Add(ExternalReference::old_pointer_space_allocation_limit_address(isolate)
          .address(),
      "Heap::OldPointerSpaceAllocationLimitAddress");
  Add(ExternalReference::old_data_space_allocation_top_address(isolate)
          .address(),
      "Heap::OldDataSpaceAllocationTopAddress");
  Add(ExternalReference::old_data_space_allocation_limit_address(isolate)
          .address(),
      "Heap::OldDataSpaceAllocationLimitAddress");
  Add(ExternalReference::allocation_sites_list_address(isolate).address(),
      "Heap::allocation_sites_list_address()");
  Add(ExternalReference::address_of_uint32_bias().address(), "uint32_bias");
  Add(ExternalReference::get_mark_code_as_executed_function(isolate).address(),
      "Code::MarkCodeAsExecuted");
  Add(ExternalReference::is_profiling_address(isolate).address(),
      "CpuProfiler::is_profiling");
  Add(ExternalReference::scheduled_exception_address(isolate).address(),
      "Isolate::scheduled_exception");
  Add(ExternalReference::invoke_function_callback(isolate).address(),
      "InvokeFunctionCallback");
  Add(ExternalReference::invoke_accessor_getter_callback(isolate).address(),
      "InvokeAccessorGetterCallback");
  Add(ExternalReference::flush_icache_function(isolate).address(),
      "CpuFeatures::FlushICache");
  Add(ExternalReference::log_enter_external_function(isolate).address(),
      "Logger::EnterExternal");
  Add(ExternalReference::log_leave_external_function(isolate).address(),
      "Logger::LeaveExternal");
  Add(ExternalReference::address_of_minus_one_half().address(),
      "double_constants.minus_one_half");
  Add(ExternalReference::stress_deopt_count(isolate).address(),
      "Isolate::stress_deopt_count_address()");
  Add(ExternalReference::incremental_marking_record_write_function(isolate)
          .address(),
      "IncrementalMarking::RecordWriteFromCode");
 
  // Debug addresses
  Add(ExternalReference::debug_after_break_target_address(isolate).address(),
      "Debug::after_break_target_address()");
  Add(ExternalReference::debug_restarter_frame_function_pointer_address(isolate)
          .address(),
      "Debug::restarter_frame_function_pointer_address()");
  Add(ExternalReference::debug_is_active_address(isolate).address(),
      "Debug::is_active_address()");
 
#ifndef V8_INTERPRETED_REGEXP
  Add(ExternalReference::re_case_insensitive_compare_uc16(isolate).address(),
      "NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16()");
  Add(ExternalReference::re_check_stack_guard_state(isolate).address(),
      "RegExpMacroAssembler*::CheckStackGuardState()");
  Add(ExternalReference::re_grow_stack(isolate).address(),
      "NativeRegExpMacroAssembler::GrowStack()");
  Add(ExternalReference::re_word_character_map().address(),
      "NativeRegExpMacroAssembler::word_character_map");
  Add(ExternalReference::address_of_regexp_stack_limit(isolate).address(),
      "RegExpStack::limit_address()");
  Add(ExternalReference::address_of_regexp_stack_memory_address(isolate)
          .address(),
      "RegExpStack::memory_address()");
  Add(ExternalReference::address_of_regexp_stack_memory_size(isolate).address(),
      "RegExpStack::memory_size()");
  Add(ExternalReference::address_of_static_offsets_vector(isolate).address(),
      "OffsetsVector::static_offsets_vector");
#endif  // V8_INTERPRETED_REGEXP
 
  // The following populates all of the different type of external references
  // into the ExternalReferenceTable.
  //
  // NOTE: This function was originally 100k of code.  It has since been
  // rewritten to be mostly table driven, as the callback macro style tends to
  // very easily cause code bloat.  Please be careful in the future when adding
  // new references.
 
  struct RefTableEntry {
    TypeCode type;
    uint16_t id;
    const char* name;
  };
 
  static const RefTableEntry ref_table[] = {
  // Builtins
#define DEF_ENTRY_C(name, ignored) \
  { C_BUILTIN, \
    Builtins::c_##name, \
    "Builtins::" #name },
 
  BUILTIN_LIST_C(DEF_ENTRY_C)
#undef DEF_ENTRY_C
 
#define DEF_ENTRY_C(name, ignored) \
  { BUILTIN, \
    Builtins::k##name, \
    "Builtins::" #name },
#define DEF_ENTRY_A(name, kind, state, extra) DEF_ENTRY_C(name, ignored)
 
  BUILTIN_LIST_C(DEF_ENTRY_C)
  BUILTIN_LIST_A(DEF_ENTRY_A)
  BUILTIN_LIST_DEBUG_A(DEF_ENTRY_A)
#undef DEF_ENTRY_C
#undef DEF_ENTRY_A
 
  // Runtime functions
#define RUNTIME_ENTRY(name, nargs, ressize) \
  { RUNTIME_FUNCTION, \
    Runtime::k##name, \
    "Runtime::" #name },
 
  RUNTIME_FUNCTION_LIST(RUNTIME_ENTRY)
  INLINE_OPTIMIZED_FUNCTION_LIST(RUNTIME_ENTRY)
#undef RUNTIME_ENTRY
 
#define INLINE_OPTIMIZED_ENTRY(name, nargs, ressize) \
  { RUNTIME_FUNCTION, \
    Runtime::kInlineOptimized##name, \
    "Runtime::" #name },
 
  INLINE_OPTIMIZED_FUNCTION_LIST(INLINE_OPTIMIZED_ENTRY)
#undef INLINE_OPTIMIZED_ENTRY
 
  // IC utilities
#define IC_ENTRY(name) \
  { IC_UTILITY, \
    IC::k##name, \
    "IC::" #name },
 
  IC_UTIL_LIST(IC_ENTRY)
#undef IC_ENTRY
  };  // end of ref_table[].
 
  for (size_t i = 0; i < arraysize(ref_table); ++i) {
    AddFromId(ref_table[i].type,
              ref_table[i].id,
              ref_table[i].name,
              isolate);
  }
 
  // Stat counters
  struct StatsRefTableEntry {
    StatsCounter* (Counters::*counter)();
    uint16_t id;
    const char* name;
  };
 
  const StatsRefTableEntry stats_ref_table[] = {
#define COUNTER_ENTRY(name, caption) \
  { &Counters::name,    \
    Counters::k_##name, \
    "Counters::" #name },
 
  STATS_COUNTER_LIST_1(COUNTER_ENTRY)
  STATS_COUNTER_LIST_2(COUNTER_ENTRY)
#undef COUNTER_ENTRY
  };  // end of stats_ref_table[].
 
  Counters* counters = isolate->counters();
  for (size_t i = 0; i < arraysize(stats_ref_table); ++i) {
    Add(reinterpret_cast<Address>(GetInternalPointer(
            (counters->*(stats_ref_table[i].counter))())),
        STATS_COUNTER,
        stats_ref_table[i].id,
        stats_ref_table[i].name);
  }
 
  // Top addresses
 
  const char* AddressNames[] = {
#define BUILD_NAME_LITERAL(CamelName, hacker_name)      \
    "Isolate::" #hacker_name "_address",
    FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL)
    NULL
#undef BUILD_NAME_LITERAL
  };
 
  for (uint16_t i = 0; i < Isolate::kIsolateAddressCount; ++i) {
    Add(isolate->get_address_from_id((Isolate::AddressId)i),
        TOP_ADDRESS, i, AddressNames[i]);
  }
 
  // Accessors
#define ACCESSOR_INFO_DECLARATION(name) \
  Add(FUNCTION_ADDR(&Accessors::name##Getter), \
      ACCESSOR, \
      Accessors::k##name##Getter, \
      "Accessors::" #name "Getter"); \
  Add(FUNCTION_ADDR(&Accessors::name##Setter), \
      ACCESSOR, \
      Accessors::k##name##Setter, \
      "Accessors::" #name "Setter");
  ACCESSOR_INFO_LIST(ACCESSOR_INFO_DECLARATION)
#undef ACCESSOR_INFO_DECLARATION
 
  StubCache* stub_cache = isolate->stub_cache();
 
  // Stub cache tables
  Add(stub_cache->key_reference(StubCache::kPrimary).address(),
      STUB_CACHE_TABLE, 1, "StubCache::primary_->key");
  Add(stub_cache->value_reference(StubCache::kPrimary).address(),
      STUB_CACHE_TABLE, 2, "StubCache::primary_->value");
  Add(stub_cache->map_reference(StubCache::kPrimary).address(),
      STUB_CACHE_TABLE, 3, "StubCache::primary_->map");
  Add(stub_cache->key_reference(StubCache::kSecondary).address(),
      STUB_CACHE_TABLE, 4, "StubCache::secondary_->key");
  Add(stub_cache->value_reference(StubCache::kSecondary).address(),
      STUB_CACHE_TABLE, 5, "StubCache::secondary_->value");
  Add(stub_cache->map_reference(StubCache::kSecondary).address(),
      STUB_CACHE_TABLE, 6, "StubCache::secondary_->map");
 
  // Runtime entries
  Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
      RUNTIME_ENTRY, 1, "HandleScope::DeleteExtensions");
  Add(ExternalReference::incremental_marking_record_write_function(isolate)
          .address(),
      RUNTIME_ENTRY, 2, "IncrementalMarking::RecordWrite");
  Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
      RUNTIME_ENTRY, 3, "StoreBuffer::StoreBufferOverflow");
 
  // Add a small set of deopt entry addresses to encoder without generating the
  // deopt table code, which isn't possible at deserialization time.
  HandleScope scope(isolate);
  for (int entry = 0; entry < kDeoptTableSerializeEntryCount; ++entry) {
    Address address = Deoptimizer::GetDeoptimizationEntry(
        isolate,
        entry,
        Deoptimizer::LAZY,
        Deoptimizer::CALCULATE_ENTRY_ADDRESS);
    Add(address, LAZY_DEOPTIMIZATION, entry, "lazy_deopt");
  }
}

References ACCESSOR_INFO_DECLARATION, ACCESSOR_INFO_LIST, Add(), AddFromId(), address(), arraysize, BUILD_NAME_LITERAL, BUILTIN_LIST_A, BUILTIN_LIST_C, BUILTIN_LIST_DEBUG_A, v8::internal::Deoptimizer::CALCULATE_ENTRY_ADDRESS, COUNTER_ENTRY, v8::internal::Isolate::counters(), DEF_ENTRY_A, DEF_ENTRY_C, FOR_EACH_ISOLATE_ADDRESS_NAME, v8::internal::Isolate::get_address_from_id(), v8::internal::Deoptimizer::GetDeoptimizationEntry(), v8::internal::GetInternalPointer(), IC_ENTRY, IC_UTIL_LIST, INLINE_OPTIMIZED_ENTRY, INLINE_OPTIMIZED_FUNCTION_LIST, v8::internal::kDeoptTableSerializeEntryCount, v8::internal::Isolate::kIsolateAddressCount, v8::internal::StubCache::kPrimary, v8::internal::StubCache::kSecondary, v8::internal::kTypeCodeCount, v8::internal::Deoptimizer::LAZY, v8::internal::LAZY_DEOPTIMIZATION, max_id_, name(), NULL, v8::internal::RUNTIME_ENTRY, RUNTIME_FUNCTION_LIST, v8::internal::STATS_COUNTER, STATS_COUNTER_LIST_1, STATS_COUNTER_LIST_2, v8::internal::Isolate::stub_cache(), v8::internal::STUB_CACHE_TABLE, and v8::internal::TOP_ADDRESS.

Referenced by ExternalReferenceTable().

Here is the call graph for this function:

Here is the caller graph for this function:

size()

int v8::internal::ExternalReferenceTable::size ( ) const

inline

Definition at line 51 of file serialize.h.

{ return refs_.length(); }

References refs_.

Referenced by Add(), v8::internal::ExternalReferenceDecoder::ExternalReferenceDecoder(), and v8::internal::ExternalReferenceEncoder::ExternalReferenceEncoder().

Here is the caller graph for this function:

Member Data Documentation

max_id_

uint16_t v8::internal::ExternalReferenceTable::max_id_[kTypeCodeCount]

private

Definition at line 88 of file serialize.h.

Referenced by Add(), max_id(), and PopulateTable().

refs_

List<ExternalReferenceEntry> v8::internal::ExternalReferenceTable::refs_

private

Definition at line 87 of file serialize.h.

Referenced by Add(), address(), code(), name(), and size().

---

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

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