serialize.cc File Reference

#include "src/v8.h"
#include "src/accessors.h"
#include "src/api.h"
#include "src/base/platform/platform.h"
#include "src/bootstrapper.h"
#include "src/code-stubs.h"
#include "src/deoptimizer.h"
#include "src/execution.h"
#include "src/global-handles.h"
#include "src/ic/ic.h"
#include "src/ic/stub-cache.h"
#include "src/natives.h"
#include "src/objects.h"
#include "src/runtime/runtime.h"
#include "src/serialize.h"
#include "src/snapshot.h"
#include "src/snapshot-source-sink.h"
#include "src/v8threads.h"
#include "src/version.h"

Include dependency graph for serialize.cc:

Go to the source code of this file.

Classes
class	v8::internal::CodeAddressMap
class	v8::internal::CodeAddressMap::NameMap
class	v8::internal::StringTableInsertionKey

Namespaces
	v8
	Debugger support for the V8 JavaScript engine.
	v8::internal

Macros
#define	DEF_ENTRY_C(name, ignored)
#define	DEF_ENTRY_C(name, ignored)
#define	DEF_ENTRY_A(name, kind, state, extra)   DEF_ENTRY_C(name, ignored)
#define	RUNTIME_ENTRY(name, nargs, ressize)
#define	INLINE_OPTIMIZED_ENTRY(name, nargs, ressize)
#define	IC_ENTRY(name)
#define	COUNTER_ENTRY(name, caption)
#define	BUILD_NAME_LITERAL(CamelName, hacker_name)    "Isolate::" #hacker_name "_address",
#define	ACCESSOR_INFO_DECLARATION(name)
#define	CASE_STATEMENT(where, how, within, space_number)
#define	CASE_BODY(where, how, within, space_number_if_any)
#define	ALL_SPACES(where, how, within)
#define	FOUR_CASES(byte_code)
#define	SIXTEEN_CASES(byte_code)
#define	COMMON_RAW_LENGTHS(f)
#define	RAW_CASE(index)
#define	RAW_CASE(index)
#define	IC_KIND_CASE(KIND)   case Code::KIND:

Functions
static uint32_t	v8::internal::EncodeExternal (TypeCode type, uint16_t id)
static int *	v8::internal::GetInternalPointer (StatsCounter *counter)
static Code *	v8::internal::CloneCodeObject (HeapObject *code)
static void	v8::internal::WipeOutRelocations (Code *code)

Macro Definition Documentation

ACCESSOR_INFO_DECLARATION

#define ACCESSOR_INFO_DECLARATION

(

name

)

Value:

  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");

ALL_SPACES

#define ALL_SPACES	(		where,
			how,
			within
	)

Value:

  CASE_STATEMENT(where, how, within, NEW_SPACE)           \
  CASE_BODY(where, how, within, NEW_SPACE)                \
  CASE_STATEMENT(where, how, within, OLD_DATA_SPACE)      \
  CASE_STATEMENT(where, how, within, OLD_POINTER_SPACE)   \
  CASE_STATEMENT(where, how, within, CODE_SPACE)          \
  CASE_STATEMENT(where, how, within, MAP_SPACE)           \
  CASE_STATEMENT(where, how, within, CELL_SPACE)          \
  CASE_STATEMENT(where, how, within, PROPERTY_CELL_SPACE) \
  CASE_STATEMENT(where, how, within, LO_SPACE)            \
  CASE_BODY(where, how, within, kAnyOldSpace)

BUILD_NAME_LITERAL

#define BUILD_NAME_LITERAL	(		CamelName,
			hacker_name
	)		"Isolate::" #hacker_name "_address",

CASE_BODY

#define CASE_BODY	(		where,
			how,
			within,
			space_number_if_any
	)

CASE_STATEMENT

#define CASE_STATEMENT	(		where,
			how,
			within,
			space_number
	)

Value:

  case where + how + within + space_number:              \
    STATIC_ASSERT((where & ~kPointedToMask) == 0);       \
    STATIC_ASSERT((how & ~kHowToCodeMask) == 0);         \
    STATIC_ASSERT((within & ~kWhereToPointMask) == 0);   \
    STATIC_ASSERT((space_number & ~kSpaceMask) == 0);

COMMON_RAW_LENGTHS

#define COMMON_RAW_LENGTHS

(

f

)

COUNTER_ENTRY

#define COUNTER_ENTRY	(		name,
			caption
	)

Value:

  { &Counters::name,    \
    Counters::k_##name, \
    "Counters::" #name },

DEF_ENTRY_A

#define DEF_ENTRY_A	(		name,
			kind,
			state,
			extra
	)		DEF_ENTRY_C(name, ignored)

DEF_ENTRY_C [1/2]

#define DEF_ENTRY_C	(		name,
			ignored
	)

Value:

  { C_BUILTIN, \
    Builtins::c_##name, \
    "Builtins::" #name },

DEF_ENTRY_C [2/2]

#define DEF_ENTRY_C	(		name,
			ignored
	)

Value:

  { BUILTIN, \
    Builtins::k##name, \
    "Builtins::" #name },

FOUR_CASES

#define FOUR_CASES

(

byte_code

)

Value:

  case byte_code:                         \
  case byte_code + 1:                     \
  case byte_code + 2:                     \
  case byte_code + 3:

IC_ENTRY

#define IC_ENTRY

(

name

)

Value:

  { IC_UTILITY, \
    IC::k##name, \
    "IC::" #name },

IC_KIND_CASE

#define IC_KIND_CASE

(

KIND

)

case Code::KIND:

INLINE_OPTIMIZED_ENTRY

#define INLINE_OPTIMIZED_ENTRY	(		name,
			nargs,
			ressize
	)

Value:

  { RUNTIME_FUNCTION, \
    Runtime::kInlineOptimized##name, \
    "Runtime::" #name },

RAW_CASE [1/2]

#define RAW_CASE

(

index

)

Value:

      case kRawData + index: {                                               \
        byte* raw_data_out = reinterpret_cast<byte*>(current);               \
        source_->CopyRaw(raw_data_out, index * kPointerSize);                \
        current =                                                            \
            reinterpret_cast<Object**>(raw_data_out + index * kPointerSize); \
        break;                                                               \
      }

RAW_CASE [2/2]

#define RAW_CASE

(

index

)

Value:

    if (!outputting_code && bytes_to_output == index * kPointerSize &&         \
        index * kPointerSize == to_skip) {                                     \
      sink_->PutSection(kRawData + index, "RawDataFixed");                     \
      to_skip = 0;  /* This insn already skips. */                             \
    } else  /* NOLINT */

RUNTIME_ENTRY

#define RUNTIME_ENTRY	(		name,
			nargs,
			ressize
	)

Value:

  { RUNTIME_FUNCTION, \
    Runtime::k##name, \
    "Runtime::" #name },

SIXTEEN_CASES

#define SIXTEEN_CASES

(

byte_code

)

Value:

  FOUR_CASES(byte_code)                   \
  FOUR_CASES(byte_code + 4)               \
  FOUR_CASES(byte_code + 8)               \
  FOUR_CASES(byte_code + 12)