dart::DeoptInfoBuilder Class Reference

#include <deopt_instructions.h>

Inheritance diagram for dart::DeoptInfoBuilder:

Classes
class	TrieNode

Public Member Functions
	DeoptInfoBuilder (Zone *zone, const intptr_t num_args, compiler::Assembler *assembler)
void	AddReturnAddress (const Function &function, intptr_t deopt_id, intptr_t dest_index)
void	AddCopy (Value *value, const Location &source_loc, intptr_t dest_index)
void	AddPcMarker (const Function &function, intptr_t dest_index)
void	AddPp (const Function &function, intptr_t dest_index)
void	AddCallerFp (intptr_t dest_index)
void	AddCallerPp (intptr_t dest_index)
void	AddCallerPc (intptr_t dest_index)
void	AddMaterialization (MaterializeObjectInstr *mat)
intptr_t	EmitMaterializationArguments (intptr_t dest_index)
TypedDataPtr	CreateDeoptInfo (const Array &deopt_table)
void	MarkFrameStart ()
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Friends
class	CompilerDeoptInfo

Detailed Description

Definition at line 472 of file deopt_instructions.h.

Constructor & Destructor Documentation

DeoptInfoBuilder()

dart::DeoptInfoBuilder::DeoptInfoBuilder	(	Zone *	zone,
		const intptr_t	num_args,
		compiler::Assembler *	assembler
	)

Definition at line 1024 of file deopt_instructions.cc.

    : zone_(zone),
      instructions_(),
      num_args_(num_args),
      assembler_(assembler),
      trie_root_(new(zone) TrieNode()),
      current_info_number_(0),
      frame_start_(-1),
      materializations_() {}

Member Function Documentation

AddCallerFp()

void dart::DeoptInfoBuilder::AddCallerFp

(

intptr_t

dest_index

)

Definition at line 1172 of file deopt_instructions.cc.

                                                      {
  ASSERT(dest_index == FrameSize());
  instructions_.Add(new (zone()) DeoptCallerFpInstr());
}

AddCallerPc()

void dart::DeoptInfoBuilder::AddCallerPc

(

intptr_t

dest_index

)

Definition at line 1182 of file deopt_instructions.cc.

                                                      {
  ASSERT(dest_index == FrameSize());
  instructions_.Add(new (zone()) DeoptCallerPcInstr());
}

AddCallerPp()

void dart::DeoptInfoBuilder::AddCallerPp

(

intptr_t

dest_index

)

Definition at line 1177 of file deopt_instructions.cc.

                                                      {
  ASSERT(dest_index == FrameSize());
  instructions_.Add(new (zone()) DeoptCallerPpInstr());
}

AddCopy()

void dart::DeoptInfoBuilder::AddCopy	(	Value *	value,
		const Location &	source_loc,
		intptr_t	dest_index
	)

Definition at line 1094 of file deopt_instructions.cc.

                                                          {
  DeoptInstr* deopt_instr = nullptr;
  if (source_loc.IsConstant()) {
    intptr_t object_table_index = FindOrAddObjectInTable(source_loc.constant());
    deopt_instr = new (zone()) DeoptConstantInstr(object_table_index);
  } else if (source_loc.IsInvalid() &&
             value->definition()->IsMaterializeObject()) {
    const intptr_t index =
        FindMaterialization(value->definition()->AsMaterializeObject());
    ASSERT(index >= 0);
    deopt_instr = new (zone()) DeoptMaterializedObjectRefInstr(index);
  } else {
    ASSERT(!source_loc.IsInvalid());
    Representation rep = value->definition()->representation();
    switch (rep) {
      case kTagged:
        deopt_instr =
            new (zone()) DeoptWordInstr(ToCpuRegisterSource(source_loc));
        break;
#if defined(TARGET_ARCH_IS_64_BIT)
      case kUntagged:
#endif
      case kUnboxedInt64: {
        if (source_loc.IsPairLocation()) {
          PairLocation* pair = source_loc.AsPairLocation();
          deopt_instr =
              new (zone()) DeoptMintPairInstr(ToCpuRegisterSource(pair->At(0)),
                                              ToCpuRegisterSource(pair->At(1)));
        } else {
          ASSERT(!source_loc.IsPairLocation());
          deopt_instr =
              new (zone()) DeoptMintInstr(ToCpuRegisterSource(source_loc));
        }
        break;
      }
#if defined(TARGET_ARCH_IS_32_BIT)
      case kUntagged:
#endif
      case kUnboxedInt32:
        deopt_instr =
            new (zone()) DeoptInt32Instr(ToCpuRegisterSource(source_loc));
        break;
      case kUnboxedUint32:
        deopt_instr =
            new (zone()) DeoptUint32Instr(ToCpuRegisterSource(source_loc));
        break;
      case kUnboxedFloat:
        deopt_instr = new (zone()) DeoptFloatInstr(
            ToFpuRegisterSource(source_loc, Location::kDoubleStackSlot));
        break;
      case kUnboxedDouble:
        deopt_instr = new (zone()) DeoptDoubleInstr(
            ToFpuRegisterSource(source_loc, Location::kDoubleStackSlot));
        break;
      case kUnboxedFloat32x4:
        deopt_instr = new (zone()) DeoptFloat32x4Instr(
            ToFpuRegisterSource(source_loc, Location::kQuadStackSlot));
        break;
      case kUnboxedFloat64x2:
        deopt_instr = new (zone()) DeoptFloat64x2Instr(
            ToFpuRegisterSource(source_loc, Location::kQuadStackSlot));
        break;
      case kUnboxedInt32x4:
        deopt_instr = new (zone()) DeoptInt32x4Instr(
            ToFpuRegisterSource(source_loc, Location::kQuadStackSlot));
        break;
      default:
        UNREACHABLE();
        break;
    }
  }
  ASSERT(dest_index == FrameSize());
  ASSERT(deopt_instr != nullptr);
  instructions_.Add(deopt_instr);
}

AddMaterialization()

void dart::DeoptInfoBuilder::AddMaterialization

(

MaterializeObjectInstr *

mat

)

Definition at line 1193 of file deopt_instructions.cc.

                                                                     {
  const intptr_t index = FindMaterialization(mat);
  if (index >= 0) {
    return;  // Already added.
  }
  materializations_.Add(mat);
 
  // Count initialized fields and emit kMaterializeObject instruction.
  // There is no need to write nulls into fields because object is null
  // initialized by default.
  intptr_t non_null_fields = 0;
  for (intptr_t i = 0; i < mat->InputCount(); i++) {
    if (!mat->InputAt(i)->BindsToConstantNull()) {
      non_null_fields++;
    }
  }
 
  instructions_.Add(new (zone()) DeoptMaterializeObjectInstr(non_null_fields));
 
  for (intptr_t i = 0; i < mat->InputCount(); i++) {
    MaterializeObjectInstr* nested_mat =
        mat->InputAt(i)->definition()->AsMaterializeObject();
    if (nested_mat != nullptr) {
      AddMaterialization(nested_mat);
    }
  }
}

AddPcMarker()

void dart::DeoptInfoBuilder::AddPcMarker	(	const Function &	function,
		intptr_t	dest_index
	)

Definition at line 1081 of file deopt_instructions.cc.

                                                        {
  intptr_t object_table_index = FindOrAddObjectInTable(function);
  ASSERT(dest_index == FrameSize());
  instructions_.Add(new (zone()) DeoptPcMarkerInstr(object_table_index));
}

AddPp()

void dart::DeoptInfoBuilder::AddPp	(	const Function &	function,
		intptr_t	dest_index
	)

Definition at line 1088 of file deopt_instructions.cc.

                                                                          {
  intptr_t object_table_index = FindOrAddObjectInTable(function);
  ASSERT(dest_index == FrameSize());
  instructions_.Add(new (zone()) DeoptPpInstr(object_table_index));
}

AddReturnAddress()

void dart::DeoptInfoBuilder::AddReturnAddress	(	const Function &	function,
		intptr_t	deopt_id,
		intptr_t	dest_index
	)

Definition at line 1072 of file deopt_instructions.cc.

                                                             {
  const intptr_t object_table_index = FindOrAddObjectInTable(function);
  ASSERT(dest_index == FrameSize());
  instructions_.Add(new (zone())
                        DeoptRetAddressInstr(object_table_index, deopt_id));
}

CreateDeoptInfo()

TypedDataPtr dart::DeoptInfoBuilder::CreateDeoptInfo

(

const Array &

deopt_table

)

Definition at line 1251 of file deopt_instructions.cc.

                                                                       {
  intptr_t length = instructions_.length();
 
  // Count the number of instructions that are a shared suffix of some deopt
  // info already written.
  TrieNode* suffix = trie_root_;
  intptr_t suffix_length = 0;
  if (FLAG_compress_deopt_info) {
    for (intptr_t i = length - 1; i >= 0; --i) {
      TrieNode* node = suffix->FindChild(*instructions_[i]);
      if (node == nullptr) break;
      suffix = node;
      ++suffix_length;
    }
  }
 
  // Allocate space for the translation.  If the shared suffix is longer
  // than one instruction, we replace it with a single suffix instruction.
  const bool use_suffix = suffix_length > 1;
  if (use_suffix) {
    length -= (suffix_length - 1);
  }
 
  typedef ZoneWriteStream::Raw<sizeof(intptr_t), intptr_t> Writer;
  ZoneWriteStream stream(zone(), 2 * length * kWordSize);
 
  Writer::Write(&stream, FrameSize());
 
  if (use_suffix) {
    Writer::Write(&stream, suffix_length);
    Writer::Write(&stream, suffix->info_number());
  } else {
    Writer::Write(&stream, 0);
  }
 
  // Write the unshared instructions and build their sub-tree.
  TrieNode* node = use_suffix ? suffix : trie_root_;
  const intptr_t write_count = use_suffix ? length - 1 : length;
  for (intptr_t i = write_count - 1; i >= 0; --i) {
    DeoptInstr* instr = instructions_[i];
    Writer::Write(&stream, instr->kind());
    Writer::Write(&stream, instr->source_index());
 
    TrieNode* child = new (zone()) TrieNode(instr, current_info_number_);
    node->AddChild(child);
    node = child;
  }
 
  const TypedData& deopt_info = TypedData::Handle(
      zone(), TypedData::New(kTypedDataUint8ArrayCid, stream.bytes_written(),
                             Heap::kOld));
  {
    NoSafepointScope no_safepoint;
    memmove(deopt_info.DataAddr(0), stream.buffer(), stream.bytes_written());
  }
 
  ASSERT(
      DeoptInfo::VerifyDecompression(instructions_, deopt_table, deopt_info));
  instructions_.Clear();
  materializations_.Clear();
  frame_start_ = -1;
 
  ++current_info_number_;
  return deopt_info.ptr();
}

EmitMaterializationArguments()

intptr_t dart::DeoptInfoBuilder::EmitMaterializationArguments

(

intptr_t

dest_index

)

Definition at line 1221 of file deopt_instructions.cc.

                                                                           {
  ASSERT(dest_index == kDartFrameFixedSize);
  for (intptr_t i = 0; i < materializations_.length(); i++) {
    MaterializeObjectInstr* mat = materializations_[i];
    // Class of the instance to allocate.
    AddConstant(mat->cls(), dest_index++);
    AddConstant(Smi::ZoneHandle(Smi::New(mat->length_or_shape())),
                dest_index++);
    for (intptr_t i = 0; i < mat->InputCount(); i++) {
      if (!mat->InputAt(i)->BindsToConstantNull()) {
        // Emit offset-value pair.
        AddConstant(Smi::ZoneHandle(Smi::New(mat->FieldOffsetAt(i))),
                    dest_index++);
        AddCopy(mat->InputAt(i), mat->LocationAt(i), dest_index++);
      }
    }
  }
  return dest_index;
}

MarkFrameStart()

void dart::DeoptInfoBuilder::MarkFrameStart ( )

inline

Definition at line 509 of file deopt_instructions.h.

                        {
    ASSERT(frame_start_ == -1);
    frame_start_ = instructions_.length();
  }

Friends And Related Function Documentation

CompilerDeoptInfo

friend class CompilerDeoptInfo

friend

Definition at line 515 of file deopt_instructions.h.

---

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

• third_party/dart-lang/sdk/runtime/vm/deopt_instructions.h
• third_party/dart-lang/sdk/runtime/vm/deopt_instructions.cc