dart::kernel::BaseFlowGraphBuilder Class Reference

#include <base_flow_graph_builder.h>

Inheritance diagram for dart::kernel::BaseFlowGraphBuilder:

Public Member Functions
	BaseFlowGraphBuilder (const ParsedFunction *parsed_function, intptr_t last_used_block_id, intptr_t osr_id=DeoptId::kNone, ZoneGrowableArray< intptr_t > *context_level_array=nullptr, InlineExitCollector *exit_collector=nullptr, bool inlining_unchecked_entry=false)
const Array &	coverage_array () const
void	FinalizeCoverageArray ()
Fragment	LoadField (const Field &field, bool calls_initializer)
Fragment	LoadNativeField (const Slot &native_field, InnerPointerAccess loads_inner_pointer, bool calls_initializer=false)
Fragment	LoadNativeField (const Slot &native_field, bool calls_initializer=false)
Fragment	LoadIndexed (classid_t class_id, intptr_t index_scale=compiler::target::kWordSize, bool index_unboxed=false, AlignmentType alignment=kAlignedAccess)
Fragment	GenericCheckBound ()
Fragment	LoadUntagged (intptr_t offset)
Fragment	CalculateElementAddress (intptr_t index_scale)
Fragment	ConvertUntaggedToUnboxed ()
Fragment	ConvertUnboxedToUntagged ()
Fragment	FloatToDouble ()
Fragment	DoubleToFloat ()
void	SetTempIndex (Definition *definition)
Fragment	LoadLocal (LocalVariable *variable)
Fragment	StoreLocal (LocalVariable *variable)
Fragment	StoreLocal (TokenPosition position, LocalVariable *variable)
Fragment	StoreLocalRaw (TokenPosition position, LocalVariable *variable)
Fragment	LoadContextAt (int depth)
Fragment	GuardFieldLength (const Field &field, intptr_t deopt_id)
Fragment	GuardFieldClass (const Field &field, intptr_t deopt_id)
Fragment	StoreNativeField (TokenPosition position, const Slot &slot, InnerPointerAccess stores_inner_pointer, StoreFieldInstr::Kind kind=StoreFieldInstr::Kind::kOther, StoreBarrierType emit_store_barrier=kEmitStoreBarrier, compiler::Assembler::MemoryOrder memory_order=compiler::Assembler::kRelaxedNonAtomic)
Fragment	StoreNativeField (TokenPosition position, const Slot &slot, StoreFieldInstr::Kind kind=StoreFieldInstr::Kind::kOther, StoreBarrierType emit_store_barrier=kEmitStoreBarrier, compiler::Assembler::MemoryOrder memory_order=compiler::Assembler::kRelaxedNonAtomic)
Fragment	StoreNativeField (const Slot &slot, InnerPointerAccess stores_inner_pointer, StoreFieldInstr::Kind kind=StoreFieldInstr::Kind::kOther, StoreBarrierType emit_store_barrier=kEmitStoreBarrier, compiler::Assembler::MemoryOrder memory_order=compiler::Assembler::kRelaxedNonAtomic)
Fragment	StoreNativeField (const Slot &slot, StoreFieldInstr::Kind kind=StoreFieldInstr::Kind::kOther, StoreBarrierType emit_store_barrier=kEmitStoreBarrier, compiler::Assembler::MemoryOrder memory_order=compiler::Assembler::kRelaxedNonAtomic)
Fragment	StoreField (const Field &field, StoreFieldInstr::Kind kind=StoreFieldInstr::Kind::kOther, StoreBarrierType emit_store_barrier=kEmitStoreBarrier)
Fragment	StoreFieldGuarded (const Field &field, StoreFieldInstr::Kind kind=StoreFieldInstr::Kind::kOther)
Fragment	LoadStaticField (const Field &field, bool calls_initializer)
Fragment	RedefinitionWithType (const AbstractType &type)
Fragment	ReachabilityFence ()
Fragment	StoreStaticField (TokenPosition position, const Field &field)
Fragment	StoreIndexed (classid_t class_id)
Fragment	StoreIndexedTypedData (classid_t class_id, intptr_t index_scale, bool index_unboxed, AlignmentType alignment=kAlignedAccess)
Fragment	Box (Representation from)
void	Push (Definition *definition)
Definition *	Peek (intptr_t depth=0)
Value *	Pop ()
Fragment	Drop ()
Fragment	DropTempsPreserveTop (intptr_t num_temps_to_drop)
Fragment	MakeTemp ()
LocalVariable *	MakeTemporary (const char *suffix=nullptr)
Fragment	DropTemporary (LocalVariable **temp)
InputsArray	GetArguments (int count)
TargetEntryInstr *	BuildTargetEntry ()
FunctionEntryInstr *	BuildFunctionEntry (GraphEntryInstr *graph_entry)
JoinEntryInstr *	BuildJoinEntry ()
JoinEntryInstr *	BuildJoinEntry (intptr_t try_index)
IndirectEntryInstr *	BuildIndirectEntry (intptr_t indirect_id, intptr_t try_index)
Fragment	StrictCompare (TokenPosition position, Token::Kind kind, bool number_check=false)
Fragment	StrictCompare (Token::Kind kind, bool number_check=false)
Fragment	Goto (JoinEntryInstr *destination)
Fragment	UnboxedIntConstant (int64_t value, Representation representation)
Fragment	IntConstant (int64_t value)
Fragment	Constant (const Object &value)
Fragment	NullConstant ()
Fragment	SmiRelationalOp (Token::Kind kind)
Fragment	SmiBinaryOp (Token::Kind op, bool is_truncating=false)
Fragment	BinaryIntegerOp (Token::Kind op, Representation representation, bool is_truncating=false)
Fragment	LoadFpRelativeSlot (intptr_t offset, CompileType result_type, Representation representation=kTagged)
Fragment	StoreFpRelativeSlot (intptr_t offset)
Fragment	BranchIfTrue (TargetEntryInstr **then_entry, TargetEntryInstr **otherwise_entry, bool negate=false)
Fragment	BranchIfNull (TargetEntryInstr **then_entry, TargetEntryInstr **otherwise_entry, bool negate=false)
Fragment	BranchIfEqual (TargetEntryInstr **then_entry, TargetEntryInstr **otherwise_entry, bool negate=false)
Fragment	BranchIfStrictEqual (TargetEntryInstr **then_entry, TargetEntryInstr **otherwise_entry)
Fragment	Return (TokenPosition position)
Fragment	CheckStackOverflow (TokenPosition position, intptr_t stack_depth, intptr_t loop_depth)
Fragment	CheckStackOverflowInPrologue (TokenPosition position)
Fragment	MemoryCopy (classid_t src_cid, classid_t dest_cid, bool unboxed_inputs, bool can_overlap=true)
Fragment	TailCall (const Code &code)
Fragment	Utf8Scan ()
intptr_t	GetNextDeoptId ()
intptr_t	AllocateTryIndex ()
intptr_t	CurrentTryIndex () const
void	SetCurrentTryIndex (intptr_t try_index)
bool	IsCompiledForOsr ()
bool	IsInlining () const
void	InlineBailout (const char *reason)
Fragment	LoadArgDescriptor ()
Fragment	TestTypeArgsLen (Fragment eq_branch, Fragment neq_branch, intptr_t num_type_args)
Fragment	TestDelayedTypeArgs (LocalVariable *closure, Fragment present, Fragment absent)
Fragment	TestAnyTypeArgs (Fragment present, Fragment absent)
JoinEntryInstr *	BuildThrowNoSuchMethod ()
Fragment	ThrowException (TokenPosition position)
Fragment	AssertBool (TokenPosition position)
Fragment	BooleanNegate ()
Fragment	AllocateContext (const ZoneGrowableArray< const Slot * > &scope)
Fragment	AllocateClosure (TokenPosition position, bool has_instantiator_type_args, bool is_generic, bool is_tear_off)
Fragment	CreateArray ()
Fragment	AllocateRecord (TokenPosition position, RecordShape shape)
Fragment	AllocateSmallRecord (TokenPosition position, RecordShape shape)
Fragment	AllocateTypedData (TokenPosition position, classid_t class_id)
Fragment	InstantiateType (const AbstractType &type)
Fragment	InstantiateTypeArguments (const TypeArguments &type_arguments)
Fragment	InstantiateDynamicTypeArguments ()
Fragment	LoadClassId ()
bool	InliningUncheckedEntry () const
intptr_t	GetStackDepth () const
Fragment	AllocateObject (TokenPosition position, const Class &klass, intptr_t argument_count)
Fragment	DebugStepCheck (TokenPosition position)
Fragment	CheckNull (TokenPosition position, LocalVariable *receiver, const String &function_name)
Fragment	CheckNullOptimized (const String &name, CheckNullInstr::ExceptionType exception_type, TokenPosition position=TokenPosition::kNoSource)
Fragment	CheckNullOptimized (const String &function_name, TokenPosition position=TokenPosition::kNoSource)
Fragment	CheckNotDeeplyImmutable (CheckWritableInstr::Kind kind)
void	RecordUncheckedEntryPoint (GraphEntryInstr *graph_entry, FunctionEntryInstr *unchecked_entry)
Fragment	BuildEntryPointsIntrospection ()
Fragment	ClosureCall (const Function &target_function, TokenPosition position, intptr_t type_args_len, intptr_t argument_count, const Array &argument_names, const InferredTypeMetadata *result_type=nullptr)
Fragment	AssertAssignable (TokenPosition position, const String &dst_name, AssertAssignableInstr::Kind kind=AssertAssignableInstr::kUnknown)
bool	is_recording_context_levels () const
void	set_context_depth (intptr_t context_level)
void	reset_context_depth_for_deopt_id (intptr_t deopt_id)
Fragment	InitConstantParameters ()
Fragment	InvokeMathCFunction (MethodRecognizer::Kind recognized_kind, intptr_t num_inputs)
Fragment	DoubleToInteger (MethodRecognizer::Kind recognized_kind)
Fragment	UnaryDoubleOp (Token::Kind op)
Fragment	RecordCoverage (TokenPosition position)
Fragment	RecordBranchCoverage (TokenPosition position)
bool	has_saved_args_desc_array ()
const Array &	saved_args_desc_array ()

Static Public Member Functions
static const Field &	MayCloneField (Zone *zone, const Field &field)

Protected Member Functions
intptr_t	AllocateBlockId ()
Fragment	RecordCoverageImpl (TokenPosition position, bool is_branch_coverage)
intptr_t	GetCoverageIndexFor (intptr_t encoded_position)

Protected Attributes
const ParsedFunction *	parsed_function_
const Function &	function_
Thread *	thread_
Zone *	zone_
intptr_t	osr_id_
ZoneGrowableArray< intptr_t > *	context_level_array_
intptr_t	context_depth_
intptr_t	last_used_block_id_
intptr_t	current_try_index_
intptr_t	next_used_try_index_
Value *	stack_
InlineExitCollector *	exit_collector_
const bool	inlining_unchecked_entry_
const Array &	saved_args_desc_array_
GrowableArray< intptr_t >	coverage_array_positions_
Array &	coverage_array_

Friends
class	StreamingFlowGraphBuilder

Detailed Description

Definition at line 143 of file base_flow_graph_builder.h.

Constructor & Destructor Documentation

BaseFlowGraphBuilder()

dart::kernel::BaseFlowGraphBuilder::BaseFlowGraphBuilder ( const ParsedFunction *  parsed_function, intptr_t  last_used_block_id, intptr_t  osr_id = DeoptId::kNone, ZoneGrowableArray< intptr_t > *  context_level_array = nullptr, InlineExitCollector *  exit_collector = nullptr, bool  inlining_unchecked_entry = false  )

inline

Definition at line 145 of file base_flow_graph_builder.h.

      : parsed_function_(parsed_function),
        function_(parsed_function_->function()),
        thread_(Thread::Current()),
        zone_(thread_->zone()),
        osr_id_(osr_id),
        context_level_array_(context_level_array),
        context_depth_(0),
        last_used_block_id_(last_used_block_id),
        current_try_index_(kInvalidTryIndex),
        next_used_try_index_(0),
        stack_(nullptr),
        exit_collector_(exit_collector),
        inlining_unchecked_entry_(inlining_unchecked_entry),
        saved_args_desc_array_(
            has_saved_args_desc_array()
                ? Array::ZoneHandle(zone_, function_.saved_args_desc())
                : Object::null_array()),
        coverage_array_(
            Array::ZoneHandle(parsed_function->function().GetCoverageArray())) {
  }

Member Function Documentation

AllocateBlockId()

intptr_t dart::kernel::BaseFlowGraphBuilder::AllocateBlockId ( )

inlineprotected

Definition at line 515 of file base_flow_graph_builder.h.

{ return ++last_used_block_id_; }

AllocateClosure()

Fragment dart::kernel::BaseFlowGraphBuilder::AllocateClosure	(	TokenPosition	position,
		bool	has_instantiator_type_args,
		bool	is_generic,
		bool	is_tear_off
	)

Definition at line 926 of file base_flow_graph_builder.cc.

                                                                 {
  Value* instantiator_type_args =
      (has_instantiator_type_args ? Pop() : nullptr);
  auto const context = Pop();
  auto const function = Pop();
  auto* allocate = new (Z) AllocateClosureInstr(
      InstructionSource(position), function, context, instantiator_type_args,
      is_generic, is_tear_off, GetNextDeoptId());
  Push(allocate);
  return Fragment(allocate);
}

AllocateContext()

Fragment dart::kernel::BaseFlowGraphBuilder::AllocateContext

(

const ZoneGrowableArray< const Slot * > &

scope

)

Definition at line 918 of file base_flow_graph_builder.cc.

                                                         {
  AllocateContextInstr* allocate = new (Z) AllocateContextInstr(
      InstructionSource(), context_slots, GetNextDeoptId());
  Push(allocate);
  return Fragment(allocate);
}

AllocateObject()

Fragment dart::kernel::BaseFlowGraphBuilder::AllocateObject	(	TokenPosition	position,
		const Class &	klass,
		intptr_t	argument_count
	)

Definition at line 1028 of file base_flow_graph_builder.cc.

                                                                       {
  ASSERT((argument_count == 0) || (argument_count == 1));
  Value* type_arguments = (argument_count > 0) ? Pop() : nullptr;
  AllocateObjectInstr* allocate = new (Z) AllocateObjectInstr(
      InstructionSource(position), klass, GetNextDeoptId(), type_arguments);
  Push(allocate);
  return Fragment(allocate);
}

AllocateRecord()

Fragment dart::kernel::BaseFlowGraphBuilder::AllocateRecord	(	TokenPosition	position,
		RecordShape	shape
	)

Definition at line 951 of file base_flow_graph_builder.cc.

                                                                 {
  AllocateRecordInstr* allocate = new (Z)
      AllocateRecordInstr(InstructionSource(position), shape, GetNextDeoptId());
  Push(allocate);
  return Fragment(allocate);
}

AllocateSmallRecord()

Fragment dart::kernel::BaseFlowGraphBuilder::AllocateSmallRecord	(	TokenPosition	position,
		RecordShape	shape
	)

Definition at line 959 of file base_flow_graph_builder.cc.

                                                                      {
  const intptr_t num_fields = shape.num_fields();
  ASSERT(num_fields == 2 || num_fields == 3);
  Value* value2 = (num_fields > 2) ? Pop() : nullptr;
  Value* value1 = Pop();
  Value* value0 = Pop();
  AllocateSmallRecordInstr* allocate = new (Z)
      AllocateSmallRecordInstr(InstructionSource(position), shape, value0,
                               value1, value2, GetNextDeoptId());
  Push(allocate);
  return Fragment(allocate);
}

AllocateTryIndex()

intptr_t dart::kernel::BaseFlowGraphBuilder::AllocateTryIndex ( )

inline

Definition at line 358 of file base_flow_graph_builder.h.

{ return next_used_try_index_++; }

AllocateTypedData()

Fragment dart::kernel::BaseFlowGraphBuilder::AllocateTypedData	(	TokenPosition	position,
		classid_t	class_id
	)

Definition at line 973 of file base_flow_graph_builder.cc.

                                                                     {
  Value* num_elements = Pop();
  auto* instr = new (Z) AllocateTypedDataInstr(
      InstructionSource(position), class_id, num_elements, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

AssertAssignable()

Fragment dart::kernel::BaseFlowGraphBuilder::AssertAssignable	(	TokenPosition	position,
		const String &	dst_name,
		AssertAssignableInstr::Kind	kind = AssertAssignableInstr::kUnknown
	)

Definition at line 1204 of file base_flow_graph_builder.cc.

                                    {
  Value* function_type_args = Pop();
  Value* instantiator_type_args = Pop();
  Value* dst_type = Pop();
  Value* value = Pop();
 
  AssertAssignableInstr* instr = new (Z) AssertAssignableInstr(
      InstructionSource(position), value, dst_type, instantiator_type_args,
      function_type_args, dst_name, GetNextDeoptId(), kind);
  Push(instr);
 
  return Fragment(instr);
}

AssertBool()

Fragment dart::kernel::BaseFlowGraphBuilder::AssertBool

(

TokenPosition

position

)

Definition at line 904 of file base_flow_graph_builder.cc.

                                                                {
  Value* value = Pop();
  AssertBooleanInstr* instr = new (Z)
      AssertBooleanInstr(InstructionSource(position), value, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

BinaryIntegerOp()

Fragment dart::kernel::BaseFlowGraphBuilder::BinaryIntegerOp	(	Token::Kind	op,
		Representation	representation,
		bool	is_truncating = false
	)

Definition at line 844 of file base_flow_graph_builder.cc.

                                                                   {
  ASSERT(representation == kUnboxedInt32 || representation == kUnboxedUint32 ||
         representation == kUnboxedInt64 || representation == kTagged);
  Value* right = Pop();
  Value* left = Pop();
  BinaryIntegerOpInstr* instr = BinaryIntegerOpInstr::Make(
      representation, kind, left, right, GetNextDeoptId());
  ASSERT(instr != nullptr);
  if (is_truncating) {
    instr->mark_truncating();
  }
  Push(instr);
  return Fragment(instr);
}

BooleanNegate()

Fragment dart::kernel::BaseFlowGraphBuilder::BooleanNegate

(

)

Definition at line 912 of file base_flow_graph_builder.cc.

                                             {
  BooleanNegateInstr* negate = new (Z) BooleanNegateInstr(Pop());
  Push(negate);
  return Fragment(negate);
}

Box()

Fragment dart::kernel::BaseFlowGraphBuilder::Box

(

Representation

from

)

Definition at line 1039 of file base_flow_graph_builder.cc.

                                                      {
  Fragment instructions;
  if (from == kUnboxedFloat) {
    instructions += FloatToDouble();
    from = kUnboxedDouble;
  }
  BoxInstr* box = BoxInstr::Create(from, Pop());
  instructions <<= box;
  Push(box);
  return instructions;
}

BranchIfEqual()

Fragment dart::kernel::BaseFlowGraphBuilder::BranchIfEqual	(	TargetEntryInstr **	then_entry,
		TargetEntryInstr **	otherwise_entry,
		bool	negate = false
	)

Definition at line 181 of file base_flow_graph_builder.cc.

                                                          {
  Value* right_value = Pop();
  Value* left_value = Pop();
  StrictCompareInstr* compare = new (Z) StrictCompareInstr(
      InstructionSource(), negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
      left_value, right_value, false, GetNextDeoptId());
  BranchInstr* branch = new (Z) BranchInstr(compare, GetNextDeoptId());
  *then_entry = *branch->true_successor_address() = BuildTargetEntry();
  *otherwise_entry = *branch->false_successor_address() = BuildTargetEntry();
  return Fragment(branch).closed();
}

BranchIfNull()

Fragment dart::kernel::BaseFlowGraphBuilder::BranchIfNull	(	TargetEntryInstr **	then_entry,
		TargetEntryInstr **	otherwise_entry,
		bool	negate = false
	)

Definition at line 174 of file base_flow_graph_builder.cc.

                                                         {
  Fragment instructions = NullConstant();
  return instructions + BranchIfEqual(then_entry, otherwise_entry, negate);
}

BranchIfStrictEqual()

Fragment dart::kernel::BaseFlowGraphBuilder::BranchIfStrictEqual	(	TargetEntryInstr **	then_entry,
		TargetEntryInstr **	otherwise_entry
	)

Definition at line 195 of file base_flow_graph_builder.cc.

                                        {
  Value* rhs = Pop();
  Value* lhs = Pop();
  StrictCompareInstr* compare =
      new (Z) StrictCompareInstr(InstructionSource(), Token::kEQ_STRICT, lhs,
                                 rhs, false, GetNextDeoptId());
  BranchInstr* branch = new (Z) BranchInstr(compare, GetNextDeoptId());
  *then_entry = *branch->true_successor_address() = BuildTargetEntry();
  *otherwise_entry = *branch->false_successor_address() = BuildTargetEntry();
  return Fragment(branch).closed();
}

BranchIfTrue()

Fragment dart::kernel::BaseFlowGraphBuilder::BranchIfTrue	(	TargetEntryInstr **	then_entry,
		TargetEntryInstr **	otherwise_entry,
		bool	negate = false
	)

Definition at line 167 of file base_flow_graph_builder.cc.

                                                         {
  Fragment instructions = Constant(Bool::True());
  return instructions + BranchIfEqual(then_entry, otherwise_entry, negate);
}

BuildEntryPointsIntrospection()

Fragment dart::kernel::BaseFlowGraphBuilder::BuildEntryPointsIntrospection

(

)

Definition at line 1116 of file base_flow_graph_builder.cc.

                                                             {
  if (!FLAG_enable_testing_pragmas) return Drop();
 
  auto& function = Function::Handle(Z, parsed_function_->function().ptr());
 
  if (function.IsImplicitClosureFunction()) {
    const auto& parent = Function::Handle(Z, function.parent_function());
    const auto& func_name = String::Handle(Z, parent.name());
    const auto& owner = Class::Handle(Z, parent.Owner());
    if (owner.EnsureIsFinalized(thread_) == Error::null()) {
      function = Resolver::ResolveFunction(Z, owner, func_name);
    }
  }
 
  Object& options = Object::Handle(Z);
  if (!Library::FindPragma(thread_, /*only_core=*/false, function,
                           Symbols::vm_trace_entrypoints(), /*multiple=*/false,
                           &options) ||
      options.IsNull() || !options.IsClosure()) {
    return Drop();
  }
  auto& closure = Closure::ZoneHandle(Z, Closure::Cast(options).ptr());
  LocalVariable* entry_point_num = MakeTemporary("entry_point_num");
 
  auto& function_name = String::ZoneHandle(
      Z, String::New(function.ToLibNamePrefixedQualifiedCString(), Heap::kOld));
  if (parsed_function_->function().IsImplicitClosureFunction()) {
    function_name = String::Concat(
        function_name, String::Handle(Z, String::New("#tearoff", Heap::kNew)),
        Heap::kOld);
  }
  if (!function_name.IsCanonical()) {
    function_name = Symbols::New(thread_, function_name);
  }
 
  Fragment call_hook;
  call_hook += Constant(closure);
  call_hook += Constant(function_name);
  call_hook += LoadLocal(entry_point_num);
  if (FLAG_precompiled_mode) {
    call_hook += Constant(closure);
  } else {
    call_hook += Constant(Function::ZoneHandle(Z, closure.function()));
  }
  call_hook += ClosureCall(Function::null_function(), TokenPosition::kNoSource,
                           /*type_args_len=*/0, /*argument_count=*/3,
                           /*argument_names=*/Array::ZoneHandle(Z));
  call_hook += Drop();                           // result of closure call
  call_hook += DropTemporary(&entry_point_num);  // entrypoint number
  return call_hook;
}

BuildFunctionEntry()

FunctionEntryInstr * dart::kernel::BaseFlowGraphBuilder::BuildFunctionEntry

(

GraphEntryInstr *

graph_entry

)

Definition at line 798 of file base_flow_graph_builder.cc.

                                  {
  return new (Z) FunctionEntryInstr(graph_entry, AllocateBlockId(),
                                    CurrentTryIndex(), GetNextDeoptId());
}

BuildIndirectEntry()

IndirectEntryInstr * dart::kernel::BaseFlowGraphBuilder::BuildIndirectEntry	(	intptr_t	indirect_id,
		intptr_t	try_index
	)

Definition at line 814 of file base_flow_graph_builder.cc.

                        {
  return new (Z) IndirectEntryInstr(AllocateBlockId(), indirect_id, try_index,
                                    GetNextDeoptId());
}

BuildJoinEntry() [1/2]

JoinEntryInstr * dart::kernel::BaseFlowGraphBuilder::BuildJoinEntry

(

)

Definition at line 809 of file base_flow_graph_builder.cc.

                                                     {
  return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex(),
                                GetNextDeoptId(), GetStackDepth());
}

BuildJoinEntry() [2/2]

JoinEntryInstr * dart::kernel::BaseFlowGraphBuilder::BuildJoinEntry

(

intptr_t

try_index

)

Definition at line 804 of file base_flow_graph_builder.cc.

                                                                       {
  return new (Z) JoinEntryInstr(AllocateBlockId(), try_index, GetNextDeoptId(),
                                GetStackDepth());
}

BuildTargetEntry()

TargetEntryInstr * dart::kernel::BaseFlowGraphBuilder::BuildTargetEntry

(

)

Definition at line 793 of file base_flow_graph_builder.cc.

                                                         {
  return new (Z) TargetEntryInstr(AllocateBlockId(), CurrentTryIndex(),
                                  GetNextDeoptId(), GetStackDepth());
}

BuildThrowNoSuchMethod()

JoinEntryInstr * dart::kernel::BaseFlowGraphBuilder::BuildThrowNoSuchMethod

(

)

Definition at line 879 of file base_flow_graph_builder.cc.

                                                             {
  JoinEntryInstr* nsm = BuildJoinEntry();
 
  Fragment failing(nsm);
  const Code& nsm_handler = Code::ZoneHandle(
      Z, IG->object_store()->call_closure_no_such_method_stub());
  failing += LoadArgDescriptor();
  failing += TailCall(nsm_handler);
 
  return nsm;
}

CalculateElementAddress()

Fragment dart::kernel::BaseFlowGraphBuilder::CalculateElementAddress

(

intptr_t

index_scale

)

Definition at line 433 of file base_flow_graph_builder.cc.

                                                                           {
  Value* offset = Pop();
  Value* index = Pop();
  Value* base = Pop();
  auto adjust =
      new (Z) CalculateElementAddressInstr(base, index, index_scale, offset);
  Push(adjust);
  return Fragment(adjust);
}

CheckNotDeeplyImmutable()

Fragment dart::kernel::BaseFlowGraphBuilder::CheckNotDeeplyImmutable

(

CheckWritableInstr::Kind

kind

)

Definition at line 1089 of file base_flow_graph_builder.cc.

                                 {
  Value* value = Pop();
  auto* check_writable = new (Z)
      CheckWritableInstr(value, GetNextDeoptId(), InstructionSource(), kind);
  return Fragment(check_writable);
}

CheckNull()

Fragment dart::kernel::BaseFlowGraphBuilder::CheckNull	(	TokenPosition	position,
		LocalVariable *	receiver,
		const String &	function_name
	)

Definition at line 1061 of file base_flow_graph_builder.cc.

                                                                      {
  Fragment instructions = LoadLocal(receiver);
 
  CheckNullInstr* check_null = new (Z) CheckNullInstr(
      Pop(), function_name, GetNextDeoptId(), InstructionSource(position),
      function_name.IsNull() ? CheckNullInstr::kCastError
                             : CheckNullInstr::kNoSuchMethod);
 
  // Does not use the redefinition, no `Push(check_null)`.
  instructions <<= check_null;
 
  return instructions;
}

CheckNullOptimized() [1/2]

Fragment dart::kernel::BaseFlowGraphBuilder::CheckNullOptimized ( const String &  function_name, TokenPosition  position = TokenPosition::kNoSource  )

inline

Definition at line 433 of file base_flow_graph_builder.h.

                                                       {
    return CheckNullOptimized(function_name, CheckNullInstr::kNoSuchMethod,
                              position);
  }

CheckNullOptimized() [2/2]

Fragment dart::kernel::BaseFlowGraphBuilder::CheckNullOptimized	(	const String &	name,
		CheckNullInstr::ExceptionType	exception_type,
		TokenPosition	position = TokenPosition::kNoSource
	)

Definition at line 1077 of file base_flow_graph_builder.cc.

                            {
  Value* value = Pop();
  CheckNullInstr* check_null =
      new (Z) CheckNullInstr(value, function_name, GetNextDeoptId(),
                             InstructionSource(position), exception_type);
  Push(check_null);  // Use the redefinition.
  return Fragment(check_null);
}

CheckStackOverflow()

Fragment dart::kernel::BaseFlowGraphBuilder::CheckStackOverflow	(	TokenPosition	position,
		intptr_t	stack_depth,
		intptr_t	loop_depth
	)

Definition at line 226 of file base_flow_graph_builder.cc.

                                                                       {
  return Fragment(new (Z) CheckStackOverflowInstr(
      InstructionSource(position), stack_depth, loop_depth, GetNextDeoptId(),
      CheckStackOverflowInstr::kOsrAndPreemption));
}

CheckStackOverflowInPrologue()

Fragment dart::kernel::BaseFlowGraphBuilder::CheckStackOverflowInPrologue

(

TokenPosition

position

)

Definition at line 234 of file base_flow_graph_builder.cc.

                            {
  if (IsInlining()) {
    // If we are inlining don't actually attach the stack check.  We must still
    // create the stack check in order to allocate a deopt id.
    CheckStackOverflow(position, 0, 0);
    return Fragment();
  }
  return CheckStackOverflow(position, 0, 0);
}

ClosureCall()

Fragment dart::kernel::BaseFlowGraphBuilder::ClosureCall	(	const Function &	target_function,
		TokenPosition	position,
		intptr_t	type_args_len,
		intptr_t	argument_count,
		const Array &	argument_names,
		const InferredTypeMetadata *	result_type = nullptr
	)

Definition at line 1168 of file base_flow_graph_builder.cc.

                                             {
  Fragment instructions = RecordCoverage(position);
  const intptr_t total_count =
      (type_args_len > 0 ? 1 : 0) + argument_count +
      /*closure (bare instructions) or function (otherwise)*/ 1;
  InputsArray arguments = GetArguments(total_count);
  ClosureCallInstr* call = new (Z) ClosureCallInstr(
      target_function, std::move(arguments), type_args_len, argument_names,
      InstructionSource(position), GetNextDeoptId());
  Push(call);
  instructions <<= call;
  if (result_type != nullptr && result_type->IsConstant()) {
    instructions += Drop();
    instructions += Constant(result_type->constant_value);
  }
  return instructions;
}

Constant()

Fragment dart::kernel::BaseFlowGraphBuilder::Constant

(

const Object &

value

)

Definition at line 245 of file base_flow_graph_builder.cc.

                                                           {
  DEBUG_ASSERT(value.IsNotTemporaryScopedHandle());
  ConstantInstr* constant = new (Z) ConstantInstr(value);
  Push(constant);
  return Fragment(constant);
}

ConvertUnboxedToUntagged()

Fragment dart::kernel::BaseFlowGraphBuilder::ConvertUnboxedToUntagged

(

)

Definition at line 424 of file base_flow_graph_builder.cc.

                                                        {
  Value* value = Pop();
  auto converted = new (Z)
      IntConverterInstr(kUnboxedAddress, kUntagged, value, DeoptId::kNone);
  converted->mark_truncating();
  Push(converted);
  return Fragment(converted);
}

ConvertUntaggedToUnboxed()

Fragment dart::kernel::BaseFlowGraphBuilder::ConvertUntaggedToUnboxed

(

)

Definition at line 415 of file base_flow_graph_builder.cc.

                                                        {
  Value* value = Pop();
  auto converted = new (Z)
      IntConverterInstr(kUntagged, kUnboxedAddress, value, DeoptId::kNone);
  converted->mark_truncating();
  Push(converted);
  return Fragment(converted);
}

coverage_array()

const Array & dart::kernel::BaseFlowGraphBuilder::coverage_array ( ) const

inline

Definition at line 173 of file base_flow_graph_builder.h.

{ return coverage_array_; }

CreateArray()

Fragment dart::kernel::BaseFlowGraphBuilder::CreateArray

(

)

Definition at line 941 of file base_flow_graph_builder.cc.

                                           {
  Value* element_count = Pop();
  CreateArrayInstr* array =
      new (Z) CreateArrayInstr(InstructionSource(),
                               Pop(),  // Element type.
                               element_count, GetNextDeoptId());
  Push(array);
  return Fragment(array);
}

CurrentTryIndex()

intptr_t dart::kernel::BaseFlowGraphBuilder::CurrentTryIndex ( ) const

inline

Definition at line 359 of file base_flow_graph_builder.h.

{ return current_try_index_; }

DebugStepCheck()

Fragment dart::kernel::BaseFlowGraphBuilder::DebugStepCheck

(

TokenPosition

position

)

Definition at line 1051 of file base_flow_graph_builder.cc.

                                                                    {
#ifdef PRODUCT
  return Fragment();
#else
  return Fragment(new (Z) DebugStepCheckInstr(
      InstructionSource(position), UntaggedPcDescriptors::kRuntimeCall,
      GetNextDeoptId()));
#endif
}

DoubleToFloat()

Fragment dart::kernel::BaseFlowGraphBuilder::DoubleToFloat

(

)

Definition at line 450 of file base_flow_graph_builder.cc.

                                             {
  Value* value = Pop();
  DoubleToFloatInstr* instr = new DoubleToFloatInstr(
      value, DeoptId::kNone, Instruction::SpeculativeMode::kNotSpeculative);
  Push(instr);
  return Fragment(instr);
}

DoubleToInteger()

Fragment dart::kernel::BaseFlowGraphBuilder::DoubleToInteger

(

MethodRecognizer::Kind

recognized_kind

)

Definition at line 1247 of file base_flow_graph_builder.cc.

                                          {
  Value* value = Pop();
  auto* instr =
      new (Z) DoubleToIntegerInstr(value, recognized_kind, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

Drop()

Fragment dart::kernel::BaseFlowGraphBuilder::Drop

(

)

Definition at line 757 of file base_flow_graph_builder.cc.

                                    {
  ASSERT(stack_ != nullptr);
  Fragment instructions;
  Definition* definition = stack_->definition();
  // The SSA renaming implementation doesn't like [LoadLocal]s without a
  // tempindex.
  if (definition->HasSSATemp() || definition->IsLoadLocal()) {
    instructions <<= new (Z) DropTempsInstr(1, nullptr);
  } else {
    definition->ClearTempIndex();
  }
 
  Pop();
  return instructions;
}

DropTemporary()

Fragment dart::kernel::BaseFlowGraphBuilder::DropTemporary

(

LocalVariable **

temp

)

Definition at line 715 of file base_flow_graph_builder.cc.

                                                                 {
  ASSERT(temp != nullptr && *temp != nullptr && (*temp)->HasIndex());
  // Check that the temporary matches the current stack definition.
  ASSERT_EQUAL(
      stack_->definition()->temp_index(),
      -(*temp)->index().value() - parsed_function_->num_stack_locals());
  *temp = nullptr;  // Clear to avoid inadvertent usage after dropping.
  return Drop();
}

DropTempsPreserveTop()

Fragment dart::kernel::BaseFlowGraphBuilder::DropTempsPreserveTop

(

intptr_t

num_temps_to_drop

)

Definition at line 773 of file base_flow_graph_builder.cc.

                                {
  Value* top = Pop();
 
  for (intptr_t i = 0; i < num_temps_to_drop; ++i) {
    Pop();
  }
 
  DropTempsInstr* drop_temps = new (Z) DropTempsInstr(num_temps_to_drop, top);
  Push(drop_temps);
 
  return Fragment(drop_temps);
}

FinalizeCoverageArray()

void dart::kernel::BaseFlowGraphBuilder::FinalizeCoverageArray

(

)

Definition at line 1311 of file base_flow_graph_builder.cc.

                                                 {
  if (!coverage_array_.IsNull()) {
    return;
  }
 
  if (coverage_array_positions_.is_empty()) {
    coverage_array_ = Array::empty_array().ptr();
    return;
  }
 
  coverage_array_ =
      Array::New(coverage_array_positions_.length() * 2, Heap::kOld);
 
  Smi& value = Smi::Handle();
  for (intptr_t i = 0; i < coverage_array_positions_.length(); i++) {
    value = Smi::New(coverage_array_positions_[i]);
    coverage_array_.SetAt(2 * i, value);
    value = Smi::New(0);  // no coverage recorded.
    coverage_array_.SetAt(2 * i + 1, value);
  }
}

FloatToDouble()

Fragment dart::kernel::BaseFlowGraphBuilder::FloatToDouble

(

)

Definition at line 443 of file base_flow_graph_builder.cc.

                                             {
  Value* value = Pop();
  FloatToDoubleInstr* instr = new FloatToDoubleInstr(value, DeoptId::kNone);
  Push(instr);
  return Fragment(instr);
}

GenericCheckBound()

Fragment dart::kernel::BaseFlowGraphBuilder::GenericCheckBound

(

)

Definition at line 400 of file base_flow_graph_builder.cc.

                                                 {
  Value* index = Pop();
  Value* length = Pop();
  auto* instr = new (Z) GenericCheckBoundInstr(length, index, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

GetArguments()

InputsArray dart::kernel::BaseFlowGraphBuilder::GetArguments

(

int

count

)

Definition at line 821 of file base_flow_graph_builder.cc.

                                                        {
  InputsArray arguments(Z, count);
  arguments.SetLength(count);
  for (intptr_t i = count - 1; i >= 0; --i) {
    arguments[i] = Pop();
  }
  return arguments;
}

GetCoverageIndexFor()

intptr_t dart::kernel::BaseFlowGraphBuilder::GetCoverageIndexFor ( intptr_t  encoded_position )

protected

Definition at line 1286 of file base_flow_graph_builder.cc.

                                                                            {
  if (coverage_array_.IsNull()) {
    // We have not yet created coverage_array, this is the first time we are
    // building the graph for this function. Collect coverage positions.
    for (intptr_t i = 0; i < coverage_array_positions_.length(); i++) {
      if (coverage_array_positions_.At(i) == encoded_position) {
        return 2 * i + 1;
      }
    }
    const auto index = 2 * coverage_array_positions_.length() + 1;
    coverage_array_positions_.Add(encoded_position);
    return index;
  }
 
  for (intptr_t i = 0; i < coverage_array_.Length(); i += 2) {
    if (Smi::Value(static_cast<SmiPtr>(coverage_array_.At(i))) ==
        encoded_position) {
      return i + 1;
    }
  }
  // Reaching here indicates that the graph is constructed in an unstable way.
  UNREACHABLE();
  return 1;
}

GetNextDeoptId()

intptr_t dart::kernel::BaseFlowGraphBuilder::GetNextDeoptId ( )

inline

Definition at line 348 of file base_flow_graph_builder.h.

                            {
    intptr_t deopt_id = thread_->compiler_state().GetNextDeoptId();
    if (context_level_array_ != nullptr) {
      intptr_t level = context_depth_;
      context_level_array_->Add(deopt_id);
      context_level_array_->Add(level);
    }
    return deopt_id;
  }

GetStackDepth()

intptr_t dart::kernel::BaseFlowGraphBuilder::GetStackDepth ( ) const

inline

Definition at line 404 of file base_flow_graph_builder.h.

                                 {
    return stack_ == nullptr ? 0 : stack_->definition()->temp_index() + 1;
  }

Goto()

Fragment dart::kernel::BaseFlowGraphBuilder::Goto

(

JoinEntryInstr *

destination

)

Definition at line 252 of file base_flow_graph_builder.cc.

                                                               {
  return Fragment(new (Z) GotoInstr(destination, GetNextDeoptId())).closed();
}

GuardFieldClass()

Fragment dart::kernel::BaseFlowGraphBuilder::GuardFieldClass	(	const Field &	field,
		intptr_t	deopt_id
	)

Definition at line 502 of file base_flow_graph_builder.cc.

                                                                  {
  return Fragment(new (Z) GuardFieldClassInstr(Pop(), field, deopt_id));
}

GuardFieldLength()

Fragment dart::kernel::BaseFlowGraphBuilder::GuardFieldLength	(	const Field &	field,
		intptr_t	deopt_id
	)

Definition at line 497 of file base_flow_graph_builder.cc.

                                                                   {
  return Fragment(new (Z) GuardFieldLengthInstr(Pop(), field, deopt_id));
}

has_saved_args_desc_array()

bool dart::kernel::BaseFlowGraphBuilder::has_saved_args_desc_array ( )

inline

Definition at line 504 of file base_flow_graph_builder.h.

                                   {
    return function_.HasSavedArgumentsDescriptor();
  }

InitConstantParameters()

Fragment dart::kernel::BaseFlowGraphBuilder::InitConstantParameters

(

)

Definition at line 1221 of file base_flow_graph_builder.cc.

                                                      {
  Fragment instructions;
  const intptr_t parameter_count = parsed_function_->function().NumParameters();
  for (intptr_t i = 0; i < parameter_count; ++i) {
    LocalVariable* raw_parameter = parsed_function_->RawParameterVariable(i);
    const Object* param_value = raw_parameter->inferred_arg_value();
    if (param_value != nullptr) {
      instructions += Constant(*param_value);
      instructions += StoreLocalRaw(TokenPosition::kNoSource, raw_parameter);
      instructions += Drop();
    }
  }
  return instructions;
}

InlineBailout()

void dart::kernel::BaseFlowGraphBuilder::InlineBailout

(

const char *

reason

)

Definition at line 290 of file base_flow_graph_builder.cc.

                                                           {
  if (IsInlining()) {
    parsed_function_->function().set_is_inlinable(false);
    parsed_function_->Bailout("kernel::BaseFlowGraphBuilder", reason);
  }
}

InliningUncheckedEntry()

bool dart::kernel::BaseFlowGraphBuilder::InliningUncheckedEntry ( ) const

inline

Definition at line 401 of file base_flow_graph_builder.h.

{ return inlining_unchecked_entry_; }

InstantiateDynamicTypeArguments()

Fragment dart::kernel::BaseFlowGraphBuilder::InstantiateDynamicTypeArguments

(

)

Definition at line 1009 of file base_flow_graph_builder.cc.

                                                               {
  Value* type_arguments = Pop();
  Value* function_type_args = Pop();
  Value* instantiator_type_args = Pop();
  const Function& function = Object::null_function();
  const Class& instantiator_class = Class::ZoneHandle(Z);
  InstantiateTypeArgumentsInstr* instr = new (Z) InstantiateTypeArgumentsInstr(
      InstructionSource(), instantiator_type_args, function_type_args,
      type_arguments, instantiator_class, function, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

InstantiateType()

Fragment dart::kernel::BaseFlowGraphBuilder::InstantiateType

(

const AbstractType &

type

)

Definition at line 982 of file base_flow_graph_builder.cc.

                                                                       {
  Value* function_type_args = Pop();
  Value* instantiator_type_args = Pop();
  InstantiateTypeInstr* instr = new (Z)
      InstantiateTypeInstr(InstructionSource(), type, instantiator_type_args,
                           function_type_args, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

InstantiateTypeArguments()

Fragment dart::kernel::BaseFlowGraphBuilder::InstantiateTypeArguments

(

const TypeArguments &

type_arguments

)

Definition at line 992 of file base_flow_graph_builder.cc.

                                               {
  Fragment instructions;
  instructions += Constant(type_arguments_value);
 
  Value* type_arguments = Pop();
  Value* function_type_args = Pop();
  Value* instantiator_type_args = Pop();
  const Class& instantiator_class = Class::ZoneHandle(Z, function_.Owner());
  InstantiateTypeArgumentsInstr* instr = new (Z) InstantiateTypeArgumentsInstr(
      InstructionSource(), instantiator_type_args, function_type_args,
      type_arguments, instantiator_class, function_, GetNextDeoptId());
  Push(instr);
  instructions += Fragment(instr);
  return instructions;
}

IntConstant()

Fragment dart::kernel::BaseFlowGraphBuilder::IntConstant

(

int64_t

value

)

Definition at line 256 of file base_flow_graph_builder.cc.

                                                        {
  return Fragment(
      Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld))));
}

InvokeMathCFunction()

Fragment dart::kernel::BaseFlowGraphBuilder::InvokeMathCFunction	(	MethodRecognizer::Kind	recognized_kind,
		intptr_t	num_inputs
	)

Definition at line 1236 of file base_flow_graph_builder.cc.

                         {
  InputsArray args = GetArguments(num_inputs);
  auto* instr = new (Z) InvokeMathCFunctionInstr(
      std::move(args), GetNextDeoptId(), recognized_kind,
      InstructionSource(TokenPosition::kNoSource));
  Push(instr);
  return Fragment(instr);
}

is_recording_context_levels()

bool dart::kernel::BaseFlowGraphBuilder::is_recording_context_levels ( ) const

inline

Definition at line 472 of file base_flow_graph_builder.h.

                                           {
    return context_level_array_ != nullptr;
  }

IsCompiledForOsr()

bool dart::kernel::BaseFlowGraphBuilder::IsCompiledForOsr ( )

inline

Definition at line 364 of file base_flow_graph_builder.h.

{ return osr_id_ != DeoptId::kNone; }

IsInlining()

bool dart::kernel::BaseFlowGraphBuilder::IsInlining ( ) const

inline

Definition at line 366 of file base_flow_graph_builder.h.

{ return exit_collector_ != nullptr; }

LoadArgDescriptor()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadArgDescriptor

(

)

Definition at line 297 of file base_flow_graph_builder.cc.

                                                 {
  if (has_saved_args_desc_array()) {
    const ArgumentsDescriptor descriptor(saved_args_desc_array());
    // Double-check that compile-time Size() matches runtime size on target.
    ASSERT_EQUAL(descriptor.Size(), FlowGraph::ComputeArgumentsSizeInWords(
                                        function_, descriptor.Count()));
    return Constant(saved_args_desc_array());
  }
  ASSERT(parsed_function_->has_arg_desc_var());
  return LoadLocal(parsed_function_->arg_desc_var());
}

LoadClassId()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadClassId

(

)

Definition at line 1022 of file base_flow_graph_builder.cc.

                                           {
  LoadClassIdInstr* load = new (Z) LoadClassIdInstr(Pop());
  Push(load);
  return Fragment(load);
}

LoadContextAt()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadContextAt

(

int

depth

)

Definition at line 135 of file base_flow_graph_builder.cc.

                                                      {
  intptr_t delta = context_depth_ - depth;
  ASSERT(delta >= 0);
  Fragment instructions = LoadLocal(parsed_function_->current_context_var());
  while (delta-- > 0) {
    instructions += LoadNativeField(Slot::Context_parent());
  }
  return instructions;
}

LoadField()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadField	(	const Field &	field,
		bool	calls_initializer
	)

Definition at line 458 of file base_flow_graph_builder.cc.

                                                                 {
  return LoadNativeField(Slot::Get(MayCloneField(Z, field), parsed_function_),
                         calls_initializer);
}

LoadFpRelativeSlot()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadFpRelativeSlot	(	intptr_t	offset,
		CompileType	result_type,
		Representation	representation = kTagged
	)

Definition at line 861 of file base_flow_graph_builder.cc.

                                   {
  LoadIndexedUnsafeInstr* instr = new (Z)
      LoadIndexedUnsafeInstr(Pop(), offset, result_type, representation);
  Push(instr);
  return Fragment(instr);
}

LoadIndexed()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadIndexed	(	classid_t	class_id,
		intptr_t	index_scale = compiler::target::kWordSize,
		bool	index_unboxed = false,
		AlignmentType	alignment = kAlignedAccess
	)

Definition at line 383 of file base_flow_graph_builder.cc.

                                                                    {
  Value* index = Pop();
  // A C pointer if index_unboxed, otherwise a boxed Dart value.
  Value* array = Pop();
 
  // We use C behavior when dereferencing pointers, so we use aligned access in
  // all cases.
  LoadIndexedInstr* instr = new (Z)
      LoadIndexedInstr(array, index, index_unboxed, index_scale, class_id,
                       alignment, DeoptId::kNone, InstructionSource());
  Push(instr);
  return Fragment(instr);
}

LoadLocal()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadLocal

(

LocalVariable *

variable

)

Definition at line 486 of file base_flow_graph_builder.cc.

                                                                {
  ASSERT(!variable->is_captured());
  LoadLocalInstr* load = new (Z) LoadLocalInstr(*variable, InstructionSource());
  Push(load);
  return Fragment(load);
}

LoadNativeField() [1/2]

Fragment dart::kernel::BaseFlowGraphBuilder::LoadNativeField	(	const Slot &	native_field,
		bool	calls_initializer = false
	)

Definition at line 475 of file base_flow_graph_builder.cc.

                                                                       {
  const InnerPointerAccess loads_inner_pointer =
      native_field.representation() == kUntagged
          ? (native_field.may_contain_inner_pointer()
                 ? InnerPointerAccess::kMayBeInnerPointer
                 : InnerPointerAccess::kCannotBeInnerPointer)
          : InnerPointerAccess::kNotUntagged;
  return LoadNativeField(native_field, loads_inner_pointer, calls_initializer);
}

LoadNativeField() [2/2]

Fragment dart::kernel::BaseFlowGraphBuilder::LoadNativeField	(	const Slot &	native_field,
		InnerPointerAccess	loads_inner_pointer,
		bool	calls_initializer = false
	)

Definition at line 464 of file base_flow_graph_builder.cc.

                            {
  LoadFieldInstr* load = new (Z) LoadFieldInstr(
      Pop(), native_field, loads_inner_pointer, InstructionSource(),
      calls_initializer, calls_initializer ? GetNextDeoptId() : DeoptId::kNone);
  Push(load);
  return Fragment(load);
}

LoadStaticField()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadStaticField	(	const Field &	field,
		bool	calls_initializer
	)

Definition at line 585 of file base_flow_graph_builder.cc.

                                                                       {
  LoadStaticFieldInstr* load = new (Z) LoadStaticFieldInstr(
      field, InstructionSource(), calls_initializer,
      calls_initializer ? GetNextDeoptId() : DeoptId::kNone);
  Push(load);
  return Fragment(load);
}

LoadUntagged()

Fragment dart::kernel::BaseFlowGraphBuilder::LoadUntagged

(

intptr_t

offset

)

Definition at line 408 of file base_flow_graph_builder.cc.

                                                           {
  Value* object = Pop();
  auto load = new (Z) LoadUntaggedInstr(object, offset);
  Push(load);
  return Fragment(load);
}

MakeTemp()

Fragment dart::kernel::BaseFlowGraphBuilder::MakeTemp

(

)

Definition at line 787 of file base_flow_graph_builder.cc.

                                        {
  MakeTempInstr* make_temp = new (Z) MakeTempInstr(Z);
  Push(make_temp);
  return Fragment(make_temp);
}

MakeTemporary()

LocalVariable * dart::kernel::BaseFlowGraphBuilder::MakeTemporary

(

const char *

suffix = nullptr

)

Definition at line 685 of file base_flow_graph_builder.cc.

                                                                     {
  static constexpr intptr_t kTemporaryNameLength = 64;
  char name[kTemporaryNameLength];
  intptr_t index = stack_->definition()->temp_index();
  if (suffix != nullptr) {
    Utils::SNPrint(name, kTemporaryNameLength, ":t_%s", suffix);
  } else {
    Utils::SNPrint(name, kTemporaryNameLength, ":t%" Pd, index);
  }
  const String& symbol_name =
      String::ZoneHandle(Z, Symbols::New(thread_, name));
  LocalVariable* variable =
      new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                            symbol_name, Object::dynamic_type());
  // Set the index relative to the base of the expression stack including
  // outgoing arguments.
  variable->set_index(
      VariableIndex(-parsed_function_->num_stack_locals() - index));
 
  // The value on top of the stack has uses as if it were a local variable.
  // Mark all definitions on the stack as used so that their temp indices
  // will not be cleared (causing them to never be materialized in the
  // expression stack and skew stack depth).
  for (Value* item = stack_; item != nullptr; item = item->next_use()) {
    item->definition()->set_ssa_temp_index(0);
  }
 
  return variable;
}

MayCloneField()

const Field & dart::kernel::BaseFlowGraphBuilder::MayCloneField ( Zone *  zone, const Field &  field  )

static

Definition at line 507 of file base_flow_graph_builder.cc.

                                                                     {
  if (CompilerState::Current().should_clone_fields() && field.IsOriginal()) {
    return Field::ZoneHandle(zone, field.CloneFromOriginal());
  } else {
    DEBUG_ASSERT(field.IsNotTemporaryScopedHandle());
    return field;
  }
}

MemoryCopy()

Fragment dart::kernel::BaseFlowGraphBuilder::MemoryCopy	(	classid_t	src_cid,
		classid_t	dest_cid,
		bool	unboxed_inputs,
		bool	can_overlap = true
	)

Definition at line 270 of file base_flow_graph_builder.cc.

                                                            {
  Value* length = Pop();
  Value* dest_start = Pop();
  Value* src_start = Pop();
  Value* dest = Pop();
  Value* src = Pop();
  auto copy =
      new (Z) MemoryCopyInstr(src, src_cid, dest, dest_cid, src_start,
                              dest_start, length, unboxed_inputs, can_overlap);
  return Fragment(copy);
}

NullConstant()

Fragment dart::kernel::BaseFlowGraphBuilder::NullConstant

(

)

Definition at line 493 of file base_flow_graph_builder.cc.

                                            {
  return Constant(Instance::ZoneHandle(Z, Instance::null()));
}

Peek()

Definition * dart::kernel::BaseFlowGraphBuilder::Peek

(

intptr_t

depth = 0

)

Definition at line 735 of file base_flow_graph_builder.cc.

                                                     {
  Value* head = stack_;
  for (intptr_t i = 0; i < depth; ++i) {
    ASSERT(head != nullptr);
    head = head->next_use();
  }
  ASSERT(head != nullptr);
  return head->definition();
}

Pop()

Value * dart::kernel::BaseFlowGraphBuilder::Pop

(

)

Definition at line 745 of file base_flow_graph_builder.cc.

                                 {
  ASSERT(stack_ != nullptr);
  Value* value = stack_;
  stack_ = value->next_use();
  if (stack_ != nullptr) stack_->set_previous_use(nullptr);
 
  value->set_next_use(nullptr);
  value->set_previous_use(nullptr);
  value->definition()->ClearSSATempIndex();
  return value;
}

Push()

void dart::kernel::BaseFlowGraphBuilder::Push

(

Definition *

definition

)

Definition at line 730 of file base_flow_graph_builder.cc.

                                                      {
  SetTempIndex(definition);
  Value::AddToList(new (Z) Value(definition), &stack_);
}

ReachabilityFence()

Fragment dart::kernel::BaseFlowGraphBuilder::ReachabilityFence

(

)

Definition at line 603 of file base_flow_graph_builder.cc.

                                                 {
  Fragment instructions;
  instructions <<= new (Z) ReachabilityFenceInstr(Pop());
  return instructions;
}

RecordBranchCoverage()

Fragment dart::kernel::BaseFlowGraphBuilder::RecordBranchCoverage

(

TokenPosition

position

)

is_branch_coverage

Definition at line 1268 of file base_flow_graph_builder.cc.

                                                                          {
  return RecordCoverageImpl(position, true /** is_branch_coverage **/);
}

RecordCoverage()

Fragment dart::kernel::BaseFlowGraphBuilder::RecordCoverage

(

TokenPosition

position

)

is_branch_coverage

Definition at line 1264 of file base_flow_graph_builder.cc.

                                                                    {
  return RecordCoverageImpl(position, false /** is_branch_coverage **/);
}

RecordCoverageImpl()

Fragment dart::kernel::BaseFlowGraphBuilder::RecordCoverageImpl ( TokenPosition  position, bool  is_branch_coverage  )

protected

Definition at line 1272 of file base_flow_graph_builder.cc.

                                                                           {
  Fragment instructions;
  if (!SupportsCoverage()) return instructions;
  if (!position.IsReal()) return instructions;
  if (is_branch_coverage && !IG->branch_coverage()) return instructions;
 
  const intptr_t coverage_index =
      GetCoverageIndexFor(position.EncodeCoveragePosition(is_branch_coverage));
  instructions <<= new (Z) RecordCoverageInstr(coverage_array(), coverage_index,
                                               InstructionSource(position));
  return instructions;
}

RecordUncheckedEntryPoint()

void dart::kernel::BaseFlowGraphBuilder::RecordUncheckedEntryPoint	(	GraphEntryInstr *	graph_entry,
		FunctionEntryInstr *	unchecked_entry
	)

Definition at line 1097 of file base_flow_graph_builder.cc.

                                         {
  // Closures always check all arguments on their checked entry-point, most
  // call-sites are unchecked, and they're inlined less often, so it's very
  // beneficial to build multiple entry-points for them. Regular methods however
  // have fewer checks to begin with since they have dynamic invocation
  // forwarders, so in AOT we implement a more conservative time-space tradeoff
  // by only building the unchecked entry-point when inlining. We should
  // reconsider this heuristic if we identify non-inlined type-checks in
  // hotspots of new benchmarks.
  if (!IsInlining() && (parsed_function_->function().IsClosureFunction() ||
                        !CompilerState::Current().is_aot())) {
    graph_entry->set_unchecked_entry(unchecked_entry);
  } else if (InliningUncheckedEntry()) {
    graph_entry->set_normal_entry(unchecked_entry);
  }
}

RedefinitionWithType()

Fragment dart::kernel::BaseFlowGraphBuilder::RedefinitionWithType

(

const AbstractType &

type

)

Definition at line 594 of file base_flow_graph_builder.cc.

                                                                            {
  auto redefinition = new (Z) RedefinitionInstr(Pop());
  redefinition->set_constrained_type(
      new (Z) CompileType(CompileType::FromAbstractType(
          type, CompileType::kCanBeNull, CompileType::kCannotBeSentinel)));
  Push(redefinition);
  return Fragment(redefinition);
}

reset_context_depth_for_deopt_id()

void dart::kernel::BaseFlowGraphBuilder::reset_context_depth_for_deopt_id

(

intptr_t

deopt_id

)

Definition at line 1192 of file base_flow_graph_builder.cc.

                                                                             {
  if (is_recording_context_levels()) {
    for (intptr_t i = 0, n = context_level_array_->length(); i < n; i += 2) {
      if (context_level_array_->At(i) == deopt_id) {
        (*context_level_array_)[i + 1] = context_depth_;
        return;
      }
      ASSERT(context_level_array_->At(i) < deopt_id);
    }
  }
}

Return()

Fragment dart::kernel::BaseFlowGraphBuilder::Return

(

TokenPosition

position

)

Definition at line 209 of file base_flow_graph_builder.cc.

                                                            {
  Fragment instructions;
 
  Value* value = Pop();
  ASSERT(stack_ == nullptr);
  const Function& function = parsed_function_->function();
  const Representation representation =
      FlowGraph::ReturnRepresentationOf(function);
  DartReturnInstr* return_instr = new (Z) DartReturnInstr(
      InstructionSource(position), value, GetNextDeoptId(), representation);
  if (exit_collector_ != nullptr) exit_collector_->AddExit(return_instr);
 
  instructions <<= return_instr;
 
  return instructions.closed();
}

saved_args_desc_array()

const Array & dart::kernel::BaseFlowGraphBuilder::saved_args_desc_array ( )

inline

Definition at line 509 of file base_flow_graph_builder.h.

                                       {
    ASSERT(has_saved_args_desc_array());
    return saved_args_desc_array_;
  }

set_context_depth()

void dart::kernel::BaseFlowGraphBuilder::set_context_depth ( intptr_t  context_level )

inline

Definition at line 478 of file base_flow_graph_builder.h.

                                                 {
    context_depth_ = context_level;
  }

SetCurrentTryIndex()

void dart::kernel::BaseFlowGraphBuilder::SetCurrentTryIndex ( intptr_t  try_index )

inline

Definition at line 360 of file base_flow_graph_builder.h.

                                              {
    current_try_index_ = try_index;
  }

SetTempIndex()

void dart::kernel::BaseFlowGraphBuilder::SetTempIndex

(

Definition *

definition

)

Definition at line 725 of file base_flow_graph_builder.cc.

                                                              {
  definition->set_temp_index(
      stack_ == nullptr ? 0 : stack_->definition()->temp_index() + 1);
}

SmiBinaryOp()

Fragment dart::kernel::BaseFlowGraphBuilder::SmiBinaryOp	(	Token::Kind	op,
		bool	is_truncating = false
	)

Definition at line 839 of file base_flow_graph_builder.cc.

                                                               {
  return BinaryIntegerOp(kind, kTagged, is_truncating);
}

SmiRelationalOp()

Fragment dart::kernel::BaseFlowGraphBuilder::SmiRelationalOp

(

Token::Kind

kind

)

Definition at line 830 of file base_flow_graph_builder.cc.

                                                             {
  Value* right = Pop();
  Value* left = Pop();
  RelationalOpInstr* instr = new (Z) RelationalOpInstr(
      InstructionSource(), kind, left, right, kSmiCid, GetNextDeoptId());
  Push(instr);
  return Fragment(instr);
}

StoreField()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreField	(	const Field &	field,
		StoreFieldInstr::Kind	kind = StoreFieldInstr::Kind::kOther,
		StoreBarrierType	emit_store_barrier = kEmitStoreBarrier
	)

Definition at line 534 of file base_flow_graph_builder.cc.

                                         {
  return StoreNativeField(TokenPosition::kNoSource,
                          Slot::Get(MayCloneField(Z, field), parsed_function_),
                          kind, emit_store_barrier);
}

StoreFieldGuarded()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreFieldGuarded	(	const Field &	field,
		StoreFieldInstr::Kind	kind = StoreFieldInstr::Kind::kOther
	)

Definition at line 543 of file base_flow_graph_builder.cc.

                                {
  Fragment instructions;
  const Field& field_clone = MayCloneField(Z, field);
  if (IG->use_field_guards()) {
    LocalVariable* store_expression = MakeTemporary();
 
    // Note: unboxing decision can only change due to hot reload at which
    // point all code will be cleared, so there is no need to worry about
    // stability of deopt id numbering.
    if (!field_clone.is_unboxed()) {
      instructions += LoadLocal(store_expression);
      instructions += GuardFieldClass(field_clone, GetNextDeoptId());
    }
 
    // Field length guard can be omitted if it is not needed.
    // However, it is possible that we were tracking list length previously,
    // and generated length guards in the past. We need to generate same IL
    // to keep deopt ids stable, but we can discard generated IL fragment
    // if length guard is not needed.
    Fragment length_guard;
    length_guard += LoadLocal(store_expression);
    length_guard += GuardFieldLength(field_clone, GetNextDeoptId());
 
    if (field_clone.needs_length_check()) {
      instructions += length_guard;
    }
 
    // If we are tracking exactness of the static type of the field then
    // emit appropriate guard.
    if (field_clone.static_type_exactness_state().IsTracking()) {
      instructions += LoadLocal(store_expression);
      instructions <<=
          new (Z) GuardFieldTypeInstr(Pop(), field_clone, GetNextDeoptId());
    }
  }
  instructions +=
      StoreNativeField(Slot::Get(field_clone, parsed_function_), kind);
  return instructions;
}

StoreFpRelativeSlot()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreFpRelativeSlot

(

intptr_t

offset

)

Definition at line 871 of file base_flow_graph_builder.cc.

                                                                  {
  Value* value = Pop();
  Value* index = Pop();
  StoreIndexedUnsafeInstr* instr =
      new (Z) StoreIndexedUnsafeInstr(index, value, offset);
  return Fragment(instr);
}

StoreIndexed()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreIndexed

(

classid_t

class_id

)

Definition at line 630 of file base_flow_graph_builder.cc.

                                                              {
  // This fragment builder cannot be used for typed data accesses.
  ASSERT(!IsTypedDataBaseClassId(class_id));
  Value* value = Pop();
  Value* index = Pop();
  const StoreBarrierType emit_store_barrier =
      value->BindsToConstant() ? kNoStoreBarrier : kEmitStoreBarrier;
  StoreIndexedInstr* store = new (Z) StoreIndexedInstr(
      Pop(),  // Array.
      index, value, emit_store_barrier, /*index_unboxed=*/false,
      compiler::target::Instance::ElementSizeFor(class_id), class_id,
      kAlignedAccess, DeoptId::kNone, InstructionSource());
  return Fragment(store);
}

StoreIndexedTypedData()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreIndexedTypedData	(	classid_t	class_id,
		intptr_t	index_scale,
		bool	index_unboxed,
		AlignmentType	alignment = kAlignedAccess
	)

Definition at line 645 of file base_flow_graph_builder.cc.

                                                                              {
  ASSERT(IsTypedDataBaseClassId(class_id));
  Value* value = Pop();
  Value* index = Pop();
  Value* c_pointer = Pop();
  StoreIndexedInstr* instr = new (Z) StoreIndexedInstr(
      c_pointer, index, value, kNoStoreBarrier, index_unboxed, index_scale,
      class_id, alignment, DeoptId::kNone, InstructionSource(),
      Instruction::SpeculativeMode::kNotSpeculative);
  return Fragment(instr);
}

StoreLocal() [1/2]

Fragment dart::kernel::BaseFlowGraphBuilder::StoreLocal ( LocalVariable *  variable )

inline

Definition at line 200 of file base_flow_graph_builder.h.

                                               {
    return StoreLocal(TokenPosition::kNoSource, variable);
  }

StoreLocal() [2/2]

Fragment dart::kernel::BaseFlowGraphBuilder::StoreLocal	(	TokenPosition	position,
		LocalVariable *	variable
	)

Definition at line 660 of file base_flow_graph_builder.cc.

                                                                   {
  if (variable->is_captured()) {
    Fragment instructions;
    LocalVariable* value = MakeTemporary();
    instructions += LoadContextAt(variable->owner()->context_level());
    instructions += LoadLocal(value);
    instructions += StoreNativeField(
        position, Slot::GetContextVariableSlotFor(thread_, *variable));
    return instructions;
  }
  return StoreLocalRaw(position, variable);
}

StoreLocalRaw()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreLocalRaw	(	TokenPosition	position,
		LocalVariable *	variable
	)

Definition at line 674 of file base_flow_graph_builder.cc.

                                                                      {
  ASSERT(!variable->is_captured());
  Value* value = Pop();
  StoreLocalInstr* store =
      new (Z) StoreLocalInstr(*variable, value, InstructionSource(position));
  Fragment instructions(store);
  Push(store);
  return instructions;
}

StoreNativeField() [1/4]

Fragment dart::kernel::BaseFlowGraphBuilder::StoreNativeField ( const Slot &  slot, InnerPointerAccess  stores_inner_pointer, StoreFieldInstr::Kind  kind = StoreFieldInstr::Kind::kOther, StoreBarrierType  emit_store_barrier = kEmitStoreBarrier, compiler::Assembler::MemoryOrder  memory_order = compiler::Assembler::kRelaxedNonAtomic  )

inline

Definition at line 227 of file base_flow_graph_builder.h.

                                              {
    return StoreNativeField(TokenPosition::kNoSource, slot,
                            stores_inner_pointer, kind, emit_store_barrier,
                            memory_order);
  }

StoreNativeField() [2/4]

Fragment dart::kernel::BaseFlowGraphBuilder::StoreNativeField ( const Slot &  slot, StoreFieldInstr::Kind  kind = StoreFieldInstr::Kind::kOther, StoreBarrierType  emit_store_barrier = kEmitStoreBarrier, compiler::Assembler::MemoryOrder  memory_order = compiler::Assembler::kRelaxedNonAtomic  )

inline

Definition at line 238 of file base_flow_graph_builder.h.

                                              {
    return StoreNativeField(TokenPosition::kNoSource, slot,
                            InnerPointerAccess::kNotUntagged, kind,
                            emit_store_barrier, memory_order);
  }

StoreNativeField() [3/4]

Fragment dart::kernel::BaseFlowGraphBuilder::StoreNativeField	(	TokenPosition	position,
		const Slot &	slot,
		InnerPointerAccess	stores_inner_pointer,
		StoreFieldInstr::Kind	kind = StoreFieldInstr::Kind::kOther,
		StoreBarrierType	emit_store_barrier = kEmitStoreBarrier,
		compiler::Assembler::MemoryOrder	memory_order = compiler::Assembler::kRelaxedNonAtomic
	)

Definition at line 517 of file base_flow_graph_builder.cc.

                                                 {
  Value* value = Pop();
  if (value->BindsToConstant()) {
    emit_store_barrier = kNoStoreBarrier;
  }
  StoreFieldInstr* store = new (Z)
      StoreFieldInstr(slot, Pop(), value, emit_store_barrier,
                      stores_inner_pointer, InstructionSource(position), kind);
  return Fragment(store);
}

StoreNativeField() [4/4]

Fragment dart::kernel::BaseFlowGraphBuilder::StoreNativeField ( TokenPosition  position, const Slot &  slot, StoreFieldInstr::Kind  kind = StoreFieldInstr::Kind::kOther, StoreBarrierType  emit_store_barrier = kEmitStoreBarrier, compiler::Assembler::MemoryOrder  memory_order = compiler::Assembler::kRelaxedNonAtomic  )

inline

Definition at line 217 of file base_flow_graph_builder.h.

                                              {
    return StoreNativeField(position, slot, InnerPointerAccess::kNotUntagged,
                            kind, emit_store_barrier, memory_order);
  }

StoreStaticField()

Fragment dart::kernel::BaseFlowGraphBuilder::StoreStaticField	(	TokenPosition	position,
		const Field &	field
	)

Definition at line 624 of file base_flow_graph_builder.cc.

                                                                    {
  return Fragment(new (Z) StoreStaticFieldInstr(MayCloneField(Z, field), Pop(),
                                                InstructionSource(position)));
}

StrictCompare() [1/2]

Fragment dart::kernel::BaseFlowGraphBuilder::StrictCompare	(	Token::Kind	kind,
		bool	number_check = false
	)

Definition at line 157 of file base_flow_graph_builder.cc.

                                                                  {
  Value* right = Pop();
  Value* left = Pop();
  StrictCompareInstr* compare = new (Z) StrictCompareInstr(
      InstructionSource(), kind, left, right, number_check, GetNextDeoptId());
  Push(compare);
  return Fragment(compare);
}

StrictCompare() [2/2]

Fragment dart::kernel::BaseFlowGraphBuilder::StrictCompare	(	TokenPosition	position,
		Token::Kind	kind,
		bool	number_check = false
	)

Definition at line 145 of file base_flow_graph_builder.cc.

                                                                  {
  Value* right = Pop();
  Value* left = Pop();
  StrictCompareInstr* compare =
      new (Z) StrictCompareInstr(InstructionSource(position), kind, left, right,
                                 number_check, GetNextDeoptId());
  Push(compare);
  return Fragment(compare);
}

TailCall()

Fragment dart::kernel::BaseFlowGraphBuilder::TailCall

(

const Code &

code

)

Definition at line 285 of file base_flow_graph_builder.cc.

                                                        {
  Value* arg_desc = Pop();
  return Fragment(new (Z) TailCallInstr(code, arg_desc)).closed();
}

TestAnyTypeArgs()

Fragment dart::kernel::BaseFlowGraphBuilder::TestAnyTypeArgs	(	Fragment	present,
		Fragment	absent
	)

Definition at line 362 of file base_flow_graph_builder.cc.

                                                                {
  if (parsed_function_->function().IsClosureFunction()) {
    LocalVariable* closure = parsed_function_->ParameterVariable(0);
 
    JoinEntryInstr* complete = BuildJoinEntry();
    JoinEntryInstr* present_entry = BuildJoinEntry();
 
    Fragment test = TestTypeArgsLen(
        TestDelayedTypeArgs(closure, Goto(present_entry), absent),
        Goto(present_entry), 0);
    test += Goto(complete);
 
    Fragment(present_entry) + present + Goto(complete);
 
    return Fragment(test.entry, complete);
  } else {
    return TestTypeArgsLen(absent, present, 0);
  }
}

TestDelayedTypeArgs()

Fragment dart::kernel::BaseFlowGraphBuilder::TestDelayedTypeArgs	(	LocalVariable *	closure,
		Fragment	present,
		Fragment	absent
	)

Definition at line 339 of file base_flow_graph_builder.cc.

                                                                    {
  Fragment test;
 
  TargetEntryInstr* absent_entry;
  TargetEntryInstr* present_entry;
 
  test += LoadLocal(closure);
  test += LoadNativeField(Slot::Closure_delayed_type_arguments());
  test += Constant(Object::empty_type_arguments());
  test += BranchIfEqual(&absent_entry, &present_entry);
 
  present.Prepend(present_entry);
  absent.Prepend(absent_entry);
 
  JoinEntryInstr* join = BuildJoinEntry();
  absent += Goto(join);
  present += Goto(join);
 
  return Fragment(test.entry, join);
}

TestTypeArgsLen()

Fragment dart::kernel::BaseFlowGraphBuilder::TestTypeArgsLen	(	Fragment	eq_branch,
		Fragment	neq_branch,
		intptr_t	num_type_args
	)

Definition at line 309 of file base_flow_graph_builder.cc.

                                                                       {
  Fragment test;
 
  // Compile-time arguments descriptor case.
  if (has_saved_args_desc_array()) {
    const ArgumentsDescriptor descriptor(saved_args_desc_array_);
    return descriptor.TypeArgsLen() == num_type_args ? eq_branch : neq_branch;
  }
 
  // Runtime arguments descriptor case.
  TargetEntryInstr* eq_entry;
  TargetEntryInstr* neq_entry;
 
  test += LoadArgDescriptor();
  test += LoadNativeField(Slot::ArgumentsDescriptor_type_args_len());
  test += IntConstant(num_type_args);
  test += BranchIfEqual(&eq_entry, &neq_entry);
 
  eq_branch.Prepend(eq_entry);
  neq_branch.Prepend(neq_entry);
 
  JoinEntryInstr* join = BuildJoinEntry();
  eq_branch += Goto(join);
  neq_branch += Goto(join);
 
  return Fragment(test.entry, join);
}

ThrowException()

Fragment dart::kernel::BaseFlowGraphBuilder::ThrowException

(

TokenPosition

position

)

Definition at line 891 of file base_flow_graph_builder.cc.

                                                                    {
  Fragment instructions;
  Value* exception = Pop();
  instructions += Fragment(new (Z) ThrowInstr(InstructionSource(position),
                                              GetNextDeoptId(), exception))
                      .closed();
  // Use its side effect of leaving a constant on the stack (does not change
  // the graph).
  NullConstant();
 
  return instructions;
}

UnaryDoubleOp()

Fragment dart::kernel::BaseFlowGraphBuilder::UnaryDoubleOp

(

Token::Kind

op

)

Definition at line 1256 of file base_flow_graph_builder.cc.

                                                         {
  Value* value = Pop();
  auto* instr = new (Z) UnaryDoubleOpInstr(op, value, GetNextDeoptId(),
                                           Instruction::kNotSpeculative);
  Push(instr);
  return Fragment(instr);
}

UnboxedIntConstant()

Fragment dart::kernel::BaseFlowGraphBuilder::UnboxedIntConstant	(	int64_t	value,
		Representation	representation
	)

Definition at line 261 of file base_flow_graph_builder.cc.

                                   {
  const auto& obj = Integer::ZoneHandle(Z, Integer::NewCanonical(value));
  auto const constant = new (Z) UnboxedConstantInstr(obj, representation);
  Push(constant);
  return Fragment(constant);
}

Utf8Scan()

Fragment dart::kernel::BaseFlowGraphBuilder::Utf8Scan

(

)

Definition at line 609 of file base_flow_graph_builder.cc.

                                        {
  Value* table = Pop();
  Value* end = Pop();
  Value* start = Pop();
  Value* bytes = Pop();
  Value* decoder = Pop();
  const Field& scan_flags_field =
      compiler::LookupConvertUtf8DecoderScanFlagsField();
  auto scan = new (Z) Utf8ScanInstr(
      decoder, bytes, start, end, table,
      Slot::Get(MayCloneField(Z, scan_flags_field), parsed_function_));
  Push(scan);
  return Fragment(scan);
}

Friends And Related Symbol Documentation

StreamingFlowGraphBuilder

friend class StreamingFlowGraphBuilder

friend

Definition at line 541 of file base_flow_graph_builder.h.

Member Data Documentation

context_depth_

intptr_t dart::kernel::BaseFlowGraphBuilder::context_depth_

protected

Definition at line 526 of file base_flow_graph_builder.h.

context_level_array_

ZoneGrowableArray<intptr_t>* dart::kernel::BaseFlowGraphBuilder::context_level_array_

protected

Definition at line 525 of file base_flow_graph_builder.h.

coverage_array_

Array& dart::kernel::BaseFlowGraphBuilder::coverage_array_

protected

Definition at line 539 of file base_flow_graph_builder.h.

coverage_array_positions_

GrowableArray<intptr_t> dart::kernel::BaseFlowGraphBuilder::coverage_array_positions_

protected

Definition at line 538 of file base_flow_graph_builder.h.

current_try_index_

intptr_t dart::kernel::BaseFlowGraphBuilder::current_try_index_

protected

Definition at line 529 of file base_flow_graph_builder.h.

exit_collector_

InlineExitCollector* dart::kernel::BaseFlowGraphBuilder::exit_collector_

protected

Definition at line 533 of file base_flow_graph_builder.h.

function_

const Function& dart::kernel::BaseFlowGraphBuilder::function_

protected

Definition at line 520 of file base_flow_graph_builder.h.

inlining_unchecked_entry_

const bool dart::kernel::BaseFlowGraphBuilder::inlining_unchecked_entry_

protected

Definition at line 535 of file base_flow_graph_builder.h.

last_used_block_id_

intptr_t dart::kernel::BaseFlowGraphBuilder::last_used_block_id_

protected

Definition at line 527 of file base_flow_graph_builder.h.

next_used_try_index_

intptr_t dart::kernel::BaseFlowGraphBuilder::next_used_try_index_

protected

Definition at line 530 of file base_flow_graph_builder.h.

osr_id_

intptr_t dart::kernel::BaseFlowGraphBuilder::osr_id_

protected

Definition at line 523 of file base_flow_graph_builder.h.

parsed_function_

const ParsedFunction* dart::kernel::BaseFlowGraphBuilder::parsed_function_

protected

Definition at line 519 of file base_flow_graph_builder.h.

saved_args_desc_array_

const Array& dart::kernel::BaseFlowGraphBuilder::saved_args_desc_array_

protected

Definition at line 536 of file base_flow_graph_builder.h.

stack_

Value* dart::kernel::BaseFlowGraphBuilder::stack_

protected

Definition at line 532 of file base_flow_graph_builder.h.

thread_

Thread* dart::kernel::BaseFlowGraphBuilder::thread_

protected

Definition at line 521 of file base_flow_graph_builder.h.

zone_

Zone* dart::kernel::BaseFlowGraphBuilder::zone_

protected

Definition at line 522 of file base_flow_graph_builder.h.

---

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

• third_party/dart-lang/sdk/runtime/vm/compiler/frontend/base_flow_graph_builder.h
• third_party/dart-lang/sdk/runtime/vm/compiler/frontend/base_flow_graph_builder.cc