il_serializer.cc File Reference

#include "vm/compiler/backend/il_serializer.h"
#include "vm/class_id.h"
#include "vm/closure_functions_cache.h"
#include "vm/compiler/backend/flow_graph.h"
#include "vm/compiler/backend/il.h"
#include "vm/compiler/backend/range_analysis.h"
#include "vm/compiler/frontend/flow_graph_builder.h"
#include "vm/object_store.h"
#include "vm/parser.h"

Go to the source code of this file.

Namespaces
namespace	dart

Macros
#define	Z   zone_
#define	INSTRUCTION_REFS_SERIALIZABLE_AS_BLOCK_ENTRY(V)
#define	SERIALIZABLE_AS_BLOCK_ENTRY(name, type)
#define	MATCH(member, name)
#define	MATCH(member, name)
#define	UNIMPLEMENTED_FUNCTION_KIND(kind)
#define	READ_INSTRUCTION(type, attrs)
#define	INSTRUCTIONS_SERIALIZABLE_AS_INSTRUCTION(V)
#define	SERIALIZABLE_AS_INSTRUCTION(name, type)
#define	HANDLES_SERIALIZABLE_AS_OBJECT(V)
#define	SERIALIZE_HANDLE_AS_OBJECT(handle, null_handle)

Macro Definition Documentation

HANDLES_SERIALIZABLE_AS_OBJECT

#define HANDLES_SERIALIZABLE_AS_OBJECT

(

V

)

Value:

  V(AbstractType, Object::null_abstract_type())                                \
  V(Array, Object::null_array())                                               \
  V(Field, Field::Handle(d->zone()))                                           \
  V(FunctionType, Object::null_function_type())                                \
  V(Instance, Object::null_instance())                                         \
  V(String, Object::null_string())                                             \
  V(TypeArguments, Object::null_type_arguments())                              \
  V(TypeParameters, TypeParameters::Handle(d->zone()))

Definition at line 2094 of file il_serializer.cc.

INSTRUCTION_REFS_SERIALIZABLE_AS_BLOCK_ENTRY

#define INSTRUCTION_REFS_SERIALIZABLE_AS_BLOCK_ENTRY

(

V

)

Value:

  V(CatchBlockEntry, CatchBlockEntryInstr)                                     \
  V(FunctionEntry, FunctionEntryInstr)                                         \
  V(IndirectEntry, IndirectEntryInstr)                                         \
  V(JoinEntry, JoinEntryInstr)                                                 \
  V(OsrEntry, OsrEntryInstr)                                                   \
  V(TargetEntry, TargetEntryInstr)

Definition at line 154 of file il_serializer.cc.

INSTRUCTIONS_SERIALIZABLE_AS_INSTRUCTION

#define INSTRUCTIONS_SERIALIZABLE_AS_INSTRUCTION

(

V

)

Value:

  V(Comparison, ComparisonInstr)                                               \
  V(Constant, ConstantInstr)                                                   \
  V(Definition, Definition)                                                    \
  V(ParallelMove, ParallelMoveInstr)                                           \
  V(Phi, PhiInstr)

Definition at line 1123 of file il_serializer.cc.

MATCH [1/2]

#define MATCH	(		member,
			name
	)

Value:

  if (object_store->member() == x.ptr()) {                                     \
    s->Write<intptr_t>(index);                                                 \
    return;                                                                    \
  }                                                                            \
  ++index;

MATCH [2/2]

#define MATCH	(		member,
			name
	)

Value:

  if (index == stub_id) {                                                      \
    return Code::ZoneHandle(d->zone(), object_store->member());                \
  }                                                                            \
  ++index;

READ_INSTRUCTION

#define READ_INSTRUCTION	(		type,
			attrs
	)

Value:

  case Instruction::k##type:                                                   \
    return new (d->zone()) type##Instr(d);

SERIALIZABLE_AS_BLOCK_ENTRY

#define SERIALIZABLE_AS_BLOCK_ENTRY	(		name,
			type
	)

Value:

  template <>                                                                  \
  void FlowGraphSerializer::WriteRefTrait<type*>::WriteRef(                    \
      FlowGraphSerializer* s, type* x) {                                       \
    s->WriteRef<BlockEntryInstr*>(x);                                          \
  }                                                                            \
  template <>                                                                  \
  type* FlowGraphDeserializer::ReadRefTrait<type*>::ReadRef(                   \
      FlowGraphDeserializer* d) {                                              \
    BlockEntryInstr* instr = d->ReadRef<BlockEntryInstr*>();                   \
    ASSERT((instr == nullptr) || instr->Is##name());                           \
    return static_cast<type*>(instr);                                          \
  }

Definition at line 162 of file il_serializer.cc.

SERIALIZABLE_AS_INSTRUCTION

#define SERIALIZABLE_AS_INSTRUCTION	(		name,
			type
	)

Value:

  template <>                                                                  \
  void FlowGraphSerializer::WriteTrait<type*>::Write(FlowGraphSerializer* s,   \
                                                     type* x) {                \
    s->Write<Instruction*>(x);                                                 \
  }                                                                            \
  template <>                                                                  \
  type* FlowGraphDeserializer::ReadTrait<type*>::Read(                         \
      FlowGraphDeserializer* d) {                                              \
    Instruction* instr = d->Read<Instruction*>();                              \
    ASSERT((instr == nullptr) || instr->Is##name());                           \
    return static_cast<type*>(instr);                                          \
  }

Definition at line 1130 of file il_serializer.cc.

SERIALIZE_HANDLE_AS_OBJECT

#define SERIALIZE_HANDLE_AS_OBJECT	(		handle,
			null_handle
	)

Value:

  template <>                                                                  \
  void FlowGraphSerializer::WriteTrait<const handle&>::Write(                  \
      FlowGraphSerializer* s, const handle& x) {                               \
    s->Write<const Object&>(x);                                                \
  }                                                                            \
  template <>                                                                  \
  const handle& FlowGraphDeserializer::ReadTrait<const handle&>::Read(         \
      FlowGraphDeserializer* d) {                                              \
    const Object& result = d->Read<const Object&>();                           \
    if (result.IsNull()) {                                                     \
      return null_handle;                                                      \
    }                                                                          \
    return handle::Cast(result);                                               \
  }

Definition at line 2104 of file il_serializer.cc.

UNIMPLEMENTED_FUNCTION_KIND

#define UNIMPLEMENTED_FUNCTION_KIND

(

kind

)

Value:

  case UntaggedFunction::k##kind:                                              \
    FATAL("Unimplemented WriteTrait<const Function&>::Write for " #kind);

Z

#define Z   zone_

Definition at line 19 of file il_serializer.cc.