#include <flow_graph_compiler.h>

Inheritance diagram for dart::FlowGraphCompiler:

Public Member Functions
	FlowGraphCompiler (compiler::Assembler assembler, FlowGraph flow_graph, const ParsedFunction &parsed_function, bool is_optimizing, SpeculativeInliningPolicy speculative_policy, const GrowableArray< const Function > &inline_id_to_function, const GrowableArray< TokenPosition > &inline_id_to_token_pos, const GrowableArray< intptr_t > &caller_inline_id, ZoneGrowableArray< const ICData * > deopt_id_to_ic_data, CodeStatistics stats=nullptr)

void	ArchSpecificInitialization ()

	~FlowGraphCompiler ()

compiler::Assembler *	assembler () const

const ParsedFunction &	parsed_function () const

const Function &	function () const

const GrowableArray< BlockEntryInstr * > &	block_order () const

const GrowableArray< const compiler::TableSelector * > &	dispatch_table_call_targets () const

bool	ForcedOptimization () const

const FlowGraph &	flow_graph () const

BlockEntryInstr *	current_block () const

void	set_current_block (BlockEntryInstr *value)

Instruction *	current_instruction () const

bool	CanOptimize () const

bool	CanOptimizeFunction () const

bool	CanOSRFunction () const

bool	is_optimizing () const

void	InsertBSSRelocation (BSS::Relocation reloc)

void	LoadBSSEntry (BSS::Relocation relocation, Register dst, Register tmp)

bool	skip_body_compilation () const

void	EnterIntrinsicMode ()

void	ExitIntrinsicMode ()

bool	intrinsic_mode () const

void	set_intrinsic_flow_graph (const FlowGraph &flow_graph)

void	set_intrinsic_slow_path_label (compiler::Label *label)

compiler::Label *	intrinsic_slow_path_label () const

bool	ForceSlowPathForStackOverflow () const

const GrowableArray< BlockInfo * > &	block_info () const

void	StatsBegin (Instruction *instr)

void	StatsEnd (Instruction *instr)

void	SpecialStatsBegin (intptr_t tag)

void	SpecialStatsEnd (intptr_t tag)

GrowableArray< const Field * > &	used_static_fields ()

void	InitCompiler ()

void	CompileGraph ()

void	EmitPrologue ()

void	VisitBlocks ()

void	EmitFunctionEntrySourcePositionDescriptorIfNeeded ()

void	Bailout (const char *reason)

bool	TryIntrinsify ()

void	EmitMove (Location dst, Location src, TemporaryRegisterAllocator *temp)

void	EmitNativeMove (const compiler::ffi::NativeLocation &dst, const compiler::ffi::NativeLocation &src, TemporaryRegisterAllocator *temp)

void	EmitMoveToNative (const compiler::ffi::NativeLocation &dst, Location src_loc, Representation src_type, TemporaryRegisterAllocator *temp)

void	EmitMoveFromNative (Location dst_loc, Representation dst_type, const compiler::ffi::NativeLocation &src, TemporaryRegisterAllocator *temp)

void	EmitMoveConst (const compiler::ffi::NativeLocation &dst, Location src, Representation src_type, TemporaryRegisterAllocator *temp)

bool	CheckAssertAssignableTypeTestingABILocations (const LocationSummary &locs)

void	GenerateAssertAssignable (CompileType receiver_type, const InstructionSource &source, intptr_t deopt_id, Environment env, const String &dst_name, LocationSummary *locs)

void	GenerateCallerChecksForAssertAssignable (CompileType receiver_type, const AbstractType &dst_type, compiler::Label done)

void	GenerateTTSCall (const InstructionSource &source, intptr_t deopt_id, Environment env, Register reg_with_type, const AbstractType &dst_type, const String &dst_name, LocationSummary locs)

void	GenerateStubCall (const InstructionSource &source, const Code &stub, UntaggedPcDescriptors::Kind kind, LocationSummary locs, intptr_t deopt_id, Environment env)

void	GenerateNonLazyDeoptableStubCall (const InstructionSource &source, const Code &stub, UntaggedPcDescriptors::Kind kind, LocationSummary *locs, ObjectPool::SnapshotBehavior snapshot_behavior=compiler::ObjectPoolBuilderEntry::kSnapshotable)

void	GeneratePatchableCall (const InstructionSource &source, const Code &stub, UntaggedPcDescriptors::Kind kind, LocationSummary *locs, ObjectPool::SnapshotBehavior snapshot_behavior=compiler::ObjectPoolBuilderEntry::kSnapshotable)

void	GenerateDartCall (intptr_t deopt_id, const InstructionSource &source, const Code &stub, UntaggedPcDescriptors::Kind kind, LocationSummary *locs, Code::EntryKind entry_kind=Code::EntryKind::kNormal)

void	GenerateStaticDartCall (intptr_t deopt_id, const InstructionSource &source, UntaggedPcDescriptors::Kind kind, LocationSummary *locs, const Function &target, Code::EntryKind entry_kind=Code::EntryKind::kNormal)

void	GenerateInstanceOf (const InstructionSource &source, intptr_t deopt_id, Environment env, const AbstractType &type, LocationSummary locs)

void	GenerateInstanceCall (intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs, const ICData &ic_data, Code::EntryKind entry_kind, bool receiver_can_be_smi)

void	GenerateStaticCall (intptr_t deopt_id, const InstructionSource &source, const Function &function, ArgumentsInfo args_info, LocationSummary *locs, const ICData &ic_data_in, ICData::RebindRule rebind_rule, Code::EntryKind entry_kind=Code::EntryKind::kNormal)

void	GenerateNumberTypeCheck (Register kClassIdReg, const AbstractType &type, compiler::Label is_instance_lbl, compiler::Label is_not_instance_lbl)

void	GenerateStringTypeCheck (Register kClassIdReg, compiler::Label is_instance_lbl, compiler::Label is_not_instance_lbl)

void	GenerateListTypeCheck (Register kClassIdReg, compiler::Label *is_instance_lbl)

bool	GenerateSubtypeRangeCheck (Register class_id_reg, const Class &type_class, compiler::Label *is_subtype_lbl)

void	EmitOptimizedInstanceCall (const Code &stub, const ICData &ic_data, intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs, Code::EntryKind entry_kind=Code::EntryKind::kNormal)

void	EmitInstanceCallJIT (const Code &stub, const ICData &ic_data, intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs, Code::EntryKind entry_kind)

void	EmitPolymorphicInstanceCall (const PolymorphicInstanceCallInstr call, const CallTargets &targets, ArgumentsInfo args_info, intptr_t deopt_id, const InstructionSource &source, LocationSummary locs, bool complete, intptr_t total_call_count, bool receiver_can_be_smi=true)

void	EmitMegamorphicInstanceCall (const ICData &icdata, intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs)

void	EmitMegamorphicInstanceCall (const String &function_name, const Array &arguments_descriptor, intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs)

void	EmitInstanceCallAOT (const ICData &ic_data, intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs, Code::EntryKind entry_kind=Code::EntryKind::kNormal, bool receiver_can_be_smi=true)

void	EmitTestAndCall (const CallTargets &targets, const String &function_name, ArgumentsInfo args_info, compiler::Label failed, compiler::Label match_found, intptr_t deopt_id, const InstructionSource &source_index, LocationSummary *locs, bool complete, intptr_t total_ic_calls, Code::EntryKind entry_kind=Code::EntryKind::kNormal)

void	EmitDispatchTableCall (int32_t selector_offset, const Array &arguments_descriptor)

Condition	EmitEqualityRegConstCompare (Register reg, const Object &obj, bool needs_number_check, const InstructionSource &source, intptr_t deopt_id)

Condition	EmitEqualityRegRegCompare (Register left, Register right, bool needs_number_check, const InstructionSource &source, intptr_t deopt_id)

Condition	EmitBoolTest (Register value, BranchLabels labels, bool invert)

bool	NeedsEdgeCounter (BlockEntryInstr *block)

void	EmitEdgeCounter (intptr_t edge_id)

void	RecordCatchEntryMoves (Environment *env)

void	EmitCallToStub (const Code &stub, ObjectPool::SnapshotBehavior snapshot_behavior=compiler::ObjectPoolBuilderEntry::kSnapshotable)

void	EmitJumpToStub (const Code &stub)

void	EmitTailCallToStub (const Code &stub)

void	EmitDropArguments (intptr_t count)

void	EmitCallsiteMetadata (const InstructionSource &source, intptr_t deopt_id, UntaggedPcDescriptors::Kind kind, LocationSummary locs, Environment env)

void	EmitYieldPositionMetadata (const InstructionSource &source, intptr_t yield_index)

void	EmitComment (Instruction *instr)

intptr_t	StackSize () const

intptr_t	ExtraStackSlotsOnOsrEntry () const

compiler::Label *	GetJumpLabel (BlockEntryInstr *block_entry) const

bool	WasCompacted (BlockEntryInstr *block_entry) const

compiler::Label *	NextNonEmptyLabel () const

bool	CanFallThroughTo (BlockEntryInstr *block_entry) const

BranchLabels	CreateBranchLabels (BranchInstr *branch) const

void	AddExceptionHandler (CatchBlockEntryInstr *entry)

void	SetNeedsStackTrace (intptr_t try_index)

void	AddCurrentDescriptor (UntaggedPcDescriptors::Kind kind, intptr_t deopt_id, const InstructionSource &source)

void	AddDescriptor (UntaggedPcDescriptors::Kind kind, intptr_t pc_offset, intptr_t deopt_id, const InstructionSource &source, intptr_t try_index, intptr_t yield_index=UntaggedPcDescriptors::kInvalidYieldIndex)

void	AddNullCheck (const InstructionSource &source, const String &name)

void	RecordSafepoint (LocationSummary *locs, intptr_t slow_path_argument_count=0)

compiler::Label *	AddDeoptStub (intptr_t deopt_id, ICData::DeoptReasonId reason, uint32_t flags=0)

CompilerDeoptInfo *	AddDeoptIndexAtCall (intptr_t deopt_id, Environment *env)

CompilerDeoptInfo *	AddSlowPathDeoptInfo (intptr_t deopt_id, Environment *env)

void	AddSlowPathCode (SlowPathCode *slow_path)

void	FinalizeExceptionHandlers (const Code &code)

void	FinalizePcDescriptors (const Code &code)

ArrayPtr	CreateDeoptInfo (compiler::Assembler *assembler)

void	FinalizeStackMaps (const Code &code)

void	FinalizeVarDescriptors (const Code &code)

void	FinalizeCatchEntryMovesMap (const Code &code)

void	FinalizeStaticCallTargetsTable (const Code &code)

void	FinalizeCodeSourceMap (const Code &code)

const Class &	double_class () const

const Class &	mint_class () const

const Class &	float32x4_class () const

const Class &	float64x2_class () const

const Class &	int32x4_class () const

const Class &	BoxClassFor (Representation rep)

void	SaveLiveRegisters (LocationSummary *locs)

void	RestoreLiveRegisters (LocationSummary *locs)

Environment *	SlowPathEnvironmentFor (Instruction *inst, intptr_t num_slow_path_args)

Environment *	SlowPathEnvironmentFor (Environment env, LocationSummary locs, intptr_t num_slow_path_args)

intptr_t	CurrentTryIndex () const

bool	may_reoptimize () const

const ICData *	GetOrAddInstanceCallICData (intptr_t deopt_id, const String &target_name, const Array &arguments_descriptor, intptr_t num_args_tested, const AbstractType &receiver_type, const Function &binary_smi_target)

const ICData *	GetOrAddStaticCallICData (intptr_t deopt_id, const Function &target, const Array &arguments_descriptor, intptr_t num_args_tested, ICData::RebindRule rebind_rule)

const ZoneGrowableArray< const ICData * > &	deopt_id_to_ic_data () const

Thread *	thread () const

IsolateGroup *	isolate_group () const

Zone *	zone () const

void	AddStubCallTarget (const Code &code)

void	AddDispatchTableCallTarget (const compiler::TableSelector *selector)

ArrayPtr	edge_counters_array () const

ArrayPtr	InliningIdToFunction () const

void	BeginCodeSourceRange (const InstructionSource &source)

void	EndCodeSourceRange (const InstructionSource &source)

bool	IsEmptyBlock (BlockEntryInstr *block) const

void	EmitOptimizedStaticCall (const Function &function, const Array &arguments_descriptor, intptr_t size_with_type_args, intptr_t deopt_id, const InstructionSource &source, LocationSummary *locs, Code::EntryKind entry_kind=Code::EntryKind::kNormal)

Public Member Functions inherited from dart::ValueObject
	ValueObject ()

	~ValueObject ()

Static Public Member Functions
static bool	SupportsUnboxedSimd128 ()

static bool	CanConvertInt64ToDouble ()

static void	GenerateIndirectTTSCall (compiler::Assembler *assembler, Register reg_with_type, intptr_t sub_type_cache_index)

static bool	GenerateCidRangesCheck (compiler::Assembler assembler, Register class_id_reg, const CidRangeVector &cid_ranges, compiler::Label inside_range_lbl, compiler::Label *outside_range_lbl=nullptr, bool fall_through_if_inside=false)

static const CallTargets *	ResolveCallTargetsForReceiverCid (intptr_t cid, const String &selector, const Array &args_desc_array)

static bool	LookupMethodFor (int class_id, const String &name, const ArgumentsDescriptor &args_desc, Function fn_return, bool class_is_abstract_return=nullptr)

static int	EmitTestAndCallCheckCid (compiler::Assembler assembler, compiler::Label label, Register class_id_reg, const CidRangeValue &range, int bias, bool jump_on_miss=true)

Static Public Attributes
static constexpr intptr_t	kMaxNumberOfCidRangesToTest = 4

Friends
class	BoxInt64Instr

class	CheckNullInstr

class	NullErrorSlowPath

class	CheckStackOverflowInstr

class	StoreIndexedInstr

class	StoreFieldInstr

class	CheckStackOverflowSlowPath

class	GraphIntrinsicCodeGenScope

Detailed Description

Definition at line 338 of file flow_graph_compiler.h.

Constructor & Destructor Documentation

◆ FlowGraphCompiler()

dart::FlowGraphCompiler::FlowGraphCompiler	(	compiler::Assembler *	assembler,
		FlowGraph *	flow_graph,
		const ParsedFunction &	parsed_function,
		bool	is_optimizing,
		SpeculativeInliningPolicy *	speculative_policy,
		const GrowableArray< const Function * > &	inline_id_to_function,
		const GrowableArray< TokenPosition > &	inline_id_to_token_pos,
		const GrowableArray< intptr_t > &	caller_inline_id,
		ZoneGrowableArray< const ICData * > *	deopt_id_to_ic_data,
		CodeStatistics *	stats = `nullptr`
	)

Definition at line 135 of file flow_graph_compiler.cc.

    : thread_(Thread::Current()),
      zone_(Thread::Current()->zone()),
      assembler_(assembler),
      parsed_function_(parsed_function),
      flow_graph_(*flow_graph),
      block_order_(*flow_graph->CodegenBlockOrder()),
      current_block_(nullptr),
      exception_handlers_list_(nullptr),
      pc_descriptors_list_(nullptr),
      compressed_stackmaps_builder_(nullptr),
      code_source_map_builder_(nullptr),
      catch_entry_moves_maps_builder_(nullptr),
      block_info_(block_order_.length()),
      deopt_infos_(),
      static_calls_target_table_(),
      indirect_gotos_(),
      is_optimizing_(is_optimizing),
      speculative_policy_(speculative_policy),
      may_reoptimize_(false),
      intrinsic_mode_(false),
      stats_(stats),
      double_class_(
          Class::ZoneHandle(isolate_group()->object_store()->double_class())),
      mint_class_(
          Class::ZoneHandle(isolate_group()->object_store()->mint_class())),
      float32x4_class_(Class::ZoneHandle(
          isolate_group()->object_store()->float32x4_class())),
      float64x2_class_(Class::ZoneHandle(
          isolate_group()->object_store()->float64x2_class())),
      int32x4_class_(
          Class::ZoneHandle(isolate_group()->object_store()->int32x4_class())),
      list_class_(Class::ZoneHandle(Library::Handle(Library::CoreLibrary())
                                        .LookupClass(Symbols::List()))),
      pending_deoptimization_env_(nullptr),
      deopt_id_to_ic_data_(deopt_id_to_ic_data),
      edge_counters_array_(Array::ZoneHandle()) {
  ASSERT(flow_graph->parsed_function().function().ptr() ==
         parsed_function.function().ptr());
  if (is_optimizing) {
    // No need to collect extra ICData objects created during compilation.
    deopt_id_to_ic_data_ = nullptr;
  } else {
    const intptr_t len = thread()->compiler_state().deopt_id();
    deopt_id_to_ic_data_->EnsureLength(len, nullptr);
  }
  ASSERT(assembler != nullptr);
  ASSERT(!list_class_.IsNull());
 
#if defined(PRODUCT)
  const bool stack_traces_only = true;
#else
  const bool stack_traces_only = false;
#endif
  // Make sure that the function is at the position for inline_id 0.
  ASSERT(inline_id_to_function.length() >= 1);
  ASSERT(inline_id_to_function[0]->ptr() ==
         flow_graph->parsed_function().function().ptr());
  code_source_map_builder_ = new (zone_)
      CodeSourceMapBuilder(zone_, stack_traces_only, caller_inline_id,
                           inline_id_to_token_pos, inline_id_to_function);
 
  ArchSpecificInitialization();
}

◆ ~FlowGraphCompiler()

dart::FlowGraphCompiler::~FlowGraphCompiler ( )

Member Function Documentation

◆ AddCurrentDescriptor()

void dart::FlowGraphCompiler::AddCurrentDescriptor	(	UntaggedPcDescriptors::Kind	kind,
		intptr_t	deopt_id,
		const InstructionSource &	source
	)

Definition at line 934 of file flow_graph_compiler.cc.

                                                                              {
  AddDescriptor(kind, assembler()->CodeSize(), deopt_id, source,
                CurrentTryIndex());
}

◆ AddDeoptIndexAtCall()

CompilerDeoptInfo * dart::FlowGraphCompiler::AddDeoptIndexAtCall	(	intptr_t	deopt_id,
		Environment *	env
	)

Definition at line 1015 of file flow_graph_compiler.cc.

                                                                            {
  ASSERT(is_optimizing());
  ASSERT(!intrinsic_mode());
  ASSERT(!FLAG_precompiled_mode);
  if (env != nullptr) {
    env = env->GetLazyDeoptEnv(zone());
  }
  CompilerDeoptInfo* info =
      new (zone()) CompilerDeoptInfo(deopt_id, ICData::kDeoptAtCall,
                                     0,  // No flags.
                                     env);
  info->set_pc_offset(assembler()->CodeSize());
  deopt_infos_.Add(info);
  return info;
}

◆ AddDeoptStub()

compiler::Label * dart::FlowGraphCompiler::AddDeoptStub	(	intptr_t	deopt_id,
		ICData::DeoptReasonId	reason,
		uint32_t	flags = `0`
	)

Definition at line 1248 of file flow_graph_compiler.cc.

                                                                 {
  if (intrinsic_mode()) {
    return intrinsic_slow_path_label_;
  }
 
  // No deoptimization allowed when 'FLAG_precompiled_mode' is set.
  if (FLAG_precompiled_mode) {
    if (FLAG_trace_compiler) {
      THR_Print(
          "Retrying compilation %s, suppressing inlining of deopt_id:%" Pd "\n",
          parsed_function_.function().ToFullyQualifiedCString(), deopt_id);
    }
    ASSERT(speculative_policy_->AllowsSpeculativeInlining());
    ASSERT(deopt_id != 0);  // longjmp must return non-zero value.
    Thread::Current()->long_jump_base()->Jump(
        deopt_id, Object::speculative_inlining_error());
  }
 
  ASSERT(is_optimizing_);
  ASSERT(pending_deoptimization_env_ != nullptr);
  if (pending_deoptimization_env_->IsHoisted()) {
    flags |= ICData::kHoisted;
  }
  CompilerDeoptInfoWithStub* stub = new (zone()) CompilerDeoptInfoWithStub(
      deopt_id, reason, flags, pending_deoptimization_env_);
  deopt_infos_.Add(stub);
  return stub->entry_label();
}

◆ AddDescriptor()

void dart::FlowGraphCompiler::AddDescriptor	(	UntaggedPcDescriptors::Kind	kind,
		intptr_t	pc_offset,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		intptr_t	try_index,
		intptr_t	yield_index = `UntaggedPcDescriptors::kInvalidYieldIndex`
	)

Definition at line 917 of file flow_graph_compiler.cc.

                                                            {
  code_source_map_builder_->NoteDescriptor(kind, pc_offset, source);
  // Don't emit deopt-descriptors in AOT mode.
  if (FLAG_precompiled_mode && (kind == UntaggedPcDescriptors::kDeopt)) return;
  // Use the token position of the original call in the root function if source
  // has an inlining id.
  const auto& root_pos = code_source_map_builder_->RootPosition(source);
  pc_descriptors_list_->AddDescriptor(kind, pc_offset, deopt_id, root_pos,
                                      try_index, yield_index);
}

◆ AddDispatchTableCallTarget()

void dart::FlowGraphCompiler::AddDispatchTableCallTarget ( const compiler::TableSelector * selector )

Definition at line 1010 of file flow_graph_compiler.cc.

                                           {
  dispatch_table_call_targets_.Add(selector);
}

◆ AddExceptionHandler()

void dart::FlowGraphCompiler::AddExceptionHandler ( CatchBlockEntryInstr * entry )

Definition at line 903 of file flow_graph_compiler.cc.

                                                                       {
  exception_handlers_list_->AddHandler(
      entry->catch_try_index(), entry->try_index(), assembler()->CodeSize(),
      entry->is_generated(), entry->catch_handler_types(),
      entry->needs_stacktrace());
  if (is_optimizing()) {
    RecordSafepoint(entry->locs());
  }
}

◆ AddNullCheck()

void dart::FlowGraphCompiler::AddNullCheck	(	const InstructionSource &	source,
		const String &	name
	)

Definition at line 941 of file flow_graph_compiler.cc.

                                                         {
#if defined(DART_PRECOMPILER)
  // If we are generating an AOT snapshot and have DWARF stack traces enabled,
  // the AOT runtime is unable to obtain the pool index at runtime. Therefore,
  // there is no reason to put the name into the pool in the first place.
  // TODO(dartbug.com/40605): Move this info to the pc descriptors.
  if (FLAG_precompiled_mode && FLAG_dwarf_stack_traces_mode) return;
#endif
  const intptr_t name_index =
      assembler()->object_pool_builder().FindObject(name);
  code_source_map_builder_->NoteNullCheck(assembler()->CodeSize(), source,
                                          name_index);
}

◆ AddSlowPathCode()

void dart::FlowGraphCompiler::AddSlowPathCode ( SlowPathCode * slow_path )

Definition at line 860 of file flow_graph_compiler.cc.

                                                          {
  slow_path_code_.Add(code);
}

◆ AddSlowPathDeoptInfo()

CompilerDeoptInfo * dart::FlowGraphCompiler::AddSlowPathDeoptInfo	(	intptr_t	deopt_id,
		Environment *	env
	)

Definition at line 1032 of file flow_graph_compiler.cc.

                                                                             {
  ASSERT(deopt_id != DeoptId::kNone);
  deopt_id = DeoptId::ToDeoptAfter(deopt_id);
  CompilerDeoptInfo* info =
      new (zone()) CompilerDeoptInfo(deopt_id, ICData::kDeoptUnknown, 0, env);
  info->set_pc_offset(assembler()->CodeSize());
  deopt_infos_.Add(info);
  return info;
}

◆ AddStubCallTarget()

void dart::FlowGraphCompiler::AddStubCallTarget ( const Code & code )

Definition at line 1003 of file flow_graph_compiler.cc.

                                                          {
  DEBUG_ASSERT(code.IsNotTemporaryScopedHandle());
  static_calls_target_table_.Add(new (zone()) StaticCallsStruct(
      Code::kCallViaCode, Code::kDefaultEntry, assembler()->CodeSize(), nullptr,
      &code, nullptr));
}

◆ ArchSpecificInitialization()

void dart::FlowGraphCompiler::ArchSpecificInitialization ( )

◆ assembler()

compiler::Assembler * dart::FlowGraphCompiler::assembler ( ) const

inline

Definition at line 399 of file flow_graph_compiler.h.

399{ return assembler_; }

◆ Bailout()

void dart::FlowGraphCompiler::Bailout ( const char * reason )

Definition at line 812 of file flow_graph_compiler.cc.

                                                  {
  parsed_function_.Bailout("FlowGraphCompiler", reason);
}

◆ BeginCodeSourceRange()

void dart::FlowGraphCompiler::BeginCodeSourceRange ( const InstructionSource & source )

Definition at line 1994 of file flow_graph_compiler.cc.

                                                                            {
  code_source_map_builder_->BeginCodeSourceRange(assembler()->CodeSize(),
                                                 source);
}

◆ block_info()

const GrowableArray< BlockInfo * > & dart::FlowGraphCompiler::block_info ( ) const

inline

Definition at line 460 of file flow_graph_compiler.h.

460{ return block_info_; }

◆ block_order()

const GrowableArray< BlockEntryInstr * > & dart::FlowGraphCompiler::block_order ( ) const

inline

Definition at line 402 of file flow_graph_compiler.h.

                                                             {
    return block_order_;
  }

◆ BoxClassFor()

const Class & dart::FlowGraphCompiler::BoxClassFor ( Representation rep )

Definition at line 1975 of file flow_graph_compiler.cc.

                                                              {
  switch (rep) {
    case kUnboxedFloat:
    case kUnboxedDouble:
      return double_class();
    case kUnboxedFloat32x4:
      return float32x4_class();
    case kUnboxedFloat64x2:
      return float64x2_class();
    case kUnboxedInt32x4:
      return int32x4_class();
    case kUnboxedInt64:
      return mint_class();
    default:
      UNREACHABLE();
      return Class::ZoneHandle();
  }
}

◆ CanConvertInt64ToDouble()

static bool dart::FlowGraphCompiler::CanConvertInt64ToDouble ( )

static

◆ CanFallThroughTo()

bool dart::FlowGraphCompiler::CanFallThroughTo ( BlockEntryInstr * block_entry ) const

Definition at line 848 of file flow_graph_compiler.cc.

                                                                           {
  return NextNonEmptyLabel() == GetJumpLabel(block_entry);
}

◆ CanOptimize()

bool dart::FlowGraphCompiler::CanOptimize ( ) const

Definition at line 256 of file flow_graph_compiler.cc.

                                          {
  return thread()->isolate_group()->optimization_counter_threshold() >= 0;
}

◆ CanOptimizeFunction()

bool dart::FlowGraphCompiler::CanOptimizeFunction ( ) const

Definition at line 260 of file flow_graph_compiler.cc.

                                                  {
  return CanOptimize() && !parsed_function().function().HasBreakpoint();
}

◆ CanOSRFunction()

bool dart::FlowGraphCompiler::CanOSRFunction ( ) const

Definition at line 264 of file flow_graph_compiler.cc.

                                             {
  return isolate_group()->use_osr() && CanOptimizeFunction() &&
         !is_optimizing();
}

◆ CheckAssertAssignableTypeTestingABILocations()

bool dart::FlowGraphCompiler::CheckAssertAssignableTypeTestingABILocations ( const LocationSummary & locs )

Definition at line 2325 of file flow_graph_compiler.cc.

                                 {
  ASSERT(locs.in(AssertAssignableInstr::kInstancePos).IsRegister() &&
         locs.in(AssertAssignableInstr::kInstancePos).reg() ==
             TypeTestABI::kInstanceReg);
  ASSERT((locs.in(AssertAssignableInstr::kDstTypePos).IsConstant() &&
          locs.in(AssertAssignableInstr::kDstTypePos)
              .constant()
              .IsAbstractType()) ||
         (locs.in(AssertAssignableInstr::kDstTypePos).IsRegister() &&
          locs.in(AssertAssignableInstr::kDstTypePos).reg() ==
              TypeTestABI::kDstTypeReg));
  ASSERT(locs.in(AssertAssignableInstr::kInstantiatorTAVPos).IsRegister() &&
         locs.in(AssertAssignableInstr::kInstantiatorTAVPos).reg() ==
             TypeTestABI::kInstantiatorTypeArgumentsReg);
  ASSERT(locs.in(AssertAssignableInstr::kFunctionTAVPos).IsRegister() &&
         locs.in(AssertAssignableInstr::kFunctionTAVPos).reg() ==
             TypeTestABI::kFunctionTypeArgumentsReg);
  ASSERT(locs.out(0).IsRegister() &&
         locs.out(0).reg() == TypeTestABI::kInstanceReg);
  return true;
}

◆ CompileGraph()

void dart::FlowGraphCompiler::CompileGraph ( )

Definition at line 628 of file flow_graph_compiler.cc.

                                     {
  InitCompiler();
 
#if !defined(TARGET_ARCH_IA32)
  // For JIT we have multiple entrypoints functionality which moved the frame
  // setup into the [TargetEntryInstr] (which will set the constant pool
  // allowed bit to true).  Despite this we still have to set the
  // constant pool allowed bit to true here as well, because we can generate
  // code for [CatchEntryInstr]s, which need the pool.
  assembler()->set_constant_pool_allowed(true);
#endif
 
  EmitFunctionEntrySourcePositionDescriptorIfNeeded();
  VisitBlocks();
 
#if defined(DEBUG)
  assembler()->Breakpoint();
#endif
 
  if (!skip_body_compilation()) {
#if !defined(TARGET_ARCH_IA32)
    ASSERT(assembler()->constant_pool_allowed());
#endif
    GenerateDeferredCode();
  }
 
  for (intptr_t i = 0; i < indirect_gotos_.length(); ++i) {
    indirect_gotos_[i]->ComputeOffsetTable(this);
  }
}

◆ CreateBranchLabels()

BranchLabels dart::FlowGraphCompiler::CreateBranchLabels ( BranchInstr * branch ) const

Definition at line 852 of file flow_graph_compiler.cc.

                                                                            {
  compiler::Label* true_label = GetJumpLabel(branch->true_successor());
  compiler::Label* false_label = GetJumpLabel(branch->false_successor());
  compiler::Label* fall_through = NextNonEmptyLabel();
  BranchLabels result = {true_label, false_label, fall_through};
  return result;
}

◆ CreateDeoptInfo()

ArrayPtr dart::FlowGraphCompiler::CreateDeoptInfo ( compiler::Assembler * assembler )

Definition at line 1294 of file flow_graph_compiler.cc.

                                                                        {
  // No deopt information if we precompile (no deoptimization allowed).
  if (FLAG_precompiled_mode) {
    return Array::empty_array().ptr();
  }
  // For functions with optional arguments, all incoming arguments are copied
  // to spill slots. The deoptimization environment does not track them.
  const Function& function = parsed_function().function();
  const intptr_t incoming_arg_count =
      function.MakesCopyOfParameters() ? 0 : function.num_fixed_parameters();
  DeoptInfoBuilder builder(zone(), incoming_arg_count, assembler);
 
  intptr_t deopt_info_table_size = DeoptTable::SizeFor(deopt_infos_.length());
  if (deopt_info_table_size == 0) {
    return Object::empty_array().ptr();
  } else {
    const Array& array =
        Array::Handle(Array::New(deopt_info_table_size, Heap::kOld));
    Smi& offset = Smi::Handle();
    TypedData& info = TypedData::Handle();
    Smi& reason_and_flags = Smi::Handle();
    for (intptr_t i = 0; i < deopt_infos_.length(); i++) {
      offset = Smi::New(deopt_infos_[i]->pc_offset());
      info = deopt_infos_[i]->CreateDeoptInfo(this, &builder, array);
      reason_and_flags = DeoptTable::EncodeReasonAndFlags(
          deopt_infos_[i]->reason(), deopt_infos_[i]->flags());
      DeoptTable::SetEntry(array, i, offset, info, reason_and_flags);
    }
    return array.ptr();
  }
}

◆ current_block()

BlockEntryInstr * dart::FlowGraphCompiler::current_block ( ) const

inline

Definition at line 419 of file flow_graph_compiler.h.

419{ return current_block_; }

◆ current_instruction()

Instruction * dart::FlowGraphCompiler::current_instruction ( ) const

inline

Definition at line 422 of file flow_graph_compiler.h.

422{ return current_instruction_; }

◆ CurrentTryIndex()

intptr_t dart::FlowGraphCompiler::CurrentTryIndex ( ) const

inline

Definition at line 877 of file flow_graph_compiler.h.

                                   {
    if (current_block_ == nullptr) {
      return kInvalidTryIndex;
    }
    return current_block_->try_index();
  }

◆ deopt_id_to_ic_data()

const ZoneGrowableArray< const ICData * > & dart::FlowGraphCompiler::deopt_id_to_ic_data ( ) const

inline

Definition at line 908 of file flow_graph_compiler.h.

                                                                      {
    return *deopt_id_to_ic_data_;
  }

◆ dispatch_table_call_targets()

const GrowableArray< const compiler::TableSelector * > & dart::FlowGraphCompiler::dispatch_table_call_targets ( ) const

inline

Definition at line 406 of file flow_graph_compiler.h.

                                      {
    return dispatch_table_call_targets_;
  }

◆ double_class()

const Class & dart::FlowGraphCompiler::double_class ( ) const

inline

Definition at line 844 of file flow_graph_compiler.h.

844{ return double_class_; }

◆ edge_counters_array()

ArrayPtr dart::FlowGraphCompiler::edge_counters_array ( ) const

inline

Definition at line 919 of file flow_graph_compiler.h.

919{ return edge_counters_array_.ptr(); }

◆ EmitBoolTest()

Condition dart::FlowGraphCompiler::EmitBoolTest	(	Register	value,
		BranchLabels	labels,
		bool	invert
	)

◆ EmitCallsiteMetadata()

void dart::FlowGraphCompiler::EmitCallsiteMetadata	(	const InstructionSource &	source,
		intptr_t	deopt_id,
		UntaggedPcDescriptors::Kind	kind,
		LocationSummary *	locs,
		Environment *	env
	)

Definition at line 469 of file flow_graph_compiler.cc.

                                                               {
  AddCurrentDescriptor(kind, deopt_id, source);
  RecordSafepoint(locs);
  RecordCatchEntryMoves(env);
  if ((deopt_id != DeoptId::kNone) && !FLAG_precompiled_mode) {
    // Marks either the continuation point in unoptimized code or the
    // deoptimization point in optimized code, after call.
    if (env != nullptr) {
      // Note that we may lazy-deopt to the same IR instruction in unoptimized
      // code or to another IR instruction (e.g. if LICM hoisted an instruction
      // it will lazy-deopt to a Goto).
      // If we happen to deopt to the beginning of an instruction in unoptimized
      // code, we'll use the before deopt-id, otherwise the after deopt-id.
      const intptr_t dest_deopt_id = env->LazyDeoptToBeforeDeoptId()
                                         ? deopt_id
                                         : DeoptId::ToDeoptAfter(deopt_id);
      AddDeoptIndexAtCall(dest_deopt_id, env);
    } else {
      const intptr_t deopt_id_after = DeoptId::ToDeoptAfter(deopt_id);
      // Add deoptimization continuation point after the call and before the
      // arguments are removed.
      AddCurrentDescriptor(UntaggedPcDescriptors::kDeopt, deopt_id_after,
                           source);
    }
  }
}

◆ EmitCallToStub()

void dart::FlowGraphCompiler::EmitCallToStub	(	const Code &	stub,
		ObjectPool::SnapshotBehavior	snapshot_behavior = `compiler::ObjectPoolBuilderEntry::kSnapshotable`
	)

◆ EmitComment()

void dart::FlowGraphCompiler::EmitComment ( Instruction * instr )

Definition at line 1621 of file flow_graph_compiler.cc.

                                                      {
#if defined(INCLUDE_IL_PRINTER)
  char buffer[256];
  BufferFormatter f(buffer, sizeof(buffer));
  instr->PrintTo(&f);
  assembler()->Comment("%s", buffer);
#endif  // defined(INCLUDE_IL_PRINTER)
}

◆ EmitDispatchTableCall()

void dart::FlowGraphCompiler::EmitDispatchTableCall	(	int32_t	selector_offset,
		const Array &	arguments_descriptor
	)

◆ EmitDropArguments()

void dart::FlowGraphCompiler::EmitDropArguments ( intptr_t count )

Definition at line 2106 of file flow_graph_compiler.cc.

                                                        {
  if (!is_optimizing()) {
    __ Drop(count);
  }
}

◆ EmitEdgeCounter()

void dart::FlowGraphCompiler::EmitEdgeCounter ( intptr_t edge_id )

◆ EmitEqualityRegConstCompare()

Condition dart::FlowGraphCompiler::EmitEqualityRegConstCompare	(	Register	reg,
		const Object &	obj,
		bool	needs_number_check,
		const InstructionSource &	source,
		intptr_t	deopt_id
	)

◆ EmitEqualityRegRegCompare()

Condition dart::FlowGraphCompiler::EmitEqualityRegRegCompare	(	Register	left,
		Register	right,
		bool	needs_number_check,
		const InstructionSource &	source,
		intptr_t	deopt_id
	)

◆ EmitFunctionEntrySourcePositionDescriptorIfNeeded()

void dart::FlowGraphCompiler::EmitFunctionEntrySourcePositionDescriptorIfNeeded ( )

Definition at line 612 of file flow_graph_compiler.cc.

                                                                          {
  // When unwinding async stacks we might produce frames which correspond
  // to future listeners which are going to be called when the future completes.
  // These listeners are not yet called and thus their frame pc_offset is set
  // to 0 - which does not actually correspond to any call- or yield- site
  // inside the code object. Nevertheless we would like to be able to
  // produce proper position information for it when symbolizing the stack.
  // To achieve that in AOT mode (where we don't actually have
  // |Function::token_pos| available) we instead emit an artificial descriptor
  // at the very beginning of the function.
  if (FLAG_precompiled_mode && flow_graph().function().IsClosureFunction()) {
    code_source_map_builder_->WriteFunctionEntrySourcePosition(
        InstructionSource(flow_graph().function().token_pos()));
  }
}

◆ EmitInstanceCallAOT()

void dart::FlowGraphCompiler::EmitInstanceCallAOT	(	const ICData &	ic_data,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`,
		bool	receiver_can_be_smi = `true`
	)

◆ EmitInstanceCallJIT()

void dart::FlowGraphCompiler::EmitInstanceCallJIT	(	const Code &	stub,
		const ICData &	ic_data,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs,
		Code::EntryKind	entry_kind
	)

◆ EmitJumpToStub()

void dart::FlowGraphCompiler::EmitJumpToStub ( const Code & stub )

◆ EmitMegamorphicInstanceCall() [1/2]

void dart::FlowGraphCompiler::EmitMegamorphicInstanceCall	(	const ICData &	icdata,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs
	)

inline

Definition at line 690 of file flow_graph_compiler.h.

                                                          {
    const String& name = String::Handle(icdata.target_name());
    const Array& arguments_descriptor =
        Array::Handle(icdata.arguments_descriptor());
    EmitMegamorphicInstanceCall(name, arguments_descriptor, deopt_id, source,
                                locs);
  }

◆ EmitMegamorphicInstanceCall() [2/2]

void dart::FlowGraphCompiler::EmitMegamorphicInstanceCall	(	const String &	function_name,
		const Array &	arguments_descriptor,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs
	)

◆ EmitMove()

void dart::FlowGraphCompiler::EmitMove	(	Location	dst,
		Location	src,
		TemporaryRegisterAllocator *	temp
	)

◆ EmitMoveConst()

void dart::FlowGraphCompiler::EmitMoveConst	(	const compiler::ffi::NativeLocation &	dst,
		Location	src,
		Representation	src_type,
		TemporaryRegisterAllocator *	temp
	)

Definition at line 3483 of file flow_graph_compiler.cc.

                                                                        {
  ASSERT(src.IsConstant() || src.IsPairLocation());
  const auto& dst_type = dst.payload_type();
  Register scratch = kNoRegister;
  if (dst.IsExpressibleAsLocation() &&
      dst_type.IsExpressibleAsRepresentation() &&
      dst_type.AsRepresentationOverApprox(zone_) == src_type) {
    // We can directly emit the const in the right place and representation.
    const Location dst_loc = dst.AsLocation();
    assembler()->Comment("dst.IsExpressibleAsLocation() %s",
                         dst_loc.ToCString());
    EmitMove(dst_loc, src, temp);
  } else {
    // We need an intermediate location.
    Location intermediate;
    if (dst_type.IsInt()) {
      if (TMP == kNoRegister) {
        scratch = temp->AllocateTemporary();
        Location::RegisterLocation(scratch);
      } else {
        intermediate = Location::RegisterLocation(TMP);
      }
    } else {
      ASSERT(dst_type.IsFloat());
      intermediate = Location::FpuRegisterLocation(FpuTMP);
    }
    assembler()->Comment("constant using intermediate: %s",
                         intermediate.ToCString());
 
    if (src.IsPairLocation()) {
      for (intptr_t i : {0, 1}) {
        const Representation src_type_split =
            compiler::ffi::NativeType::FromRepresentation(zone_, src_type)
                .Split(zone_, i)
                .AsRepresentation();
        const auto& intermediate_native =
            compiler::ffi::NativeLocation::FromLocation(zone_, intermediate,
                                                        src_type_split);
        EmitMove(intermediate, src.AsPairLocation()->At(i), temp);
        EmitNativeMove(dst.Split(zone_, 2, i), intermediate_native, temp);
      }
    } else {
      const auto& intermediate_native =
          compiler::ffi::NativeLocation::FromLocation(zone_, intermediate,
                                                      src_type);
      EmitMove(intermediate, src, temp);
      EmitNativeMove(dst, intermediate_native, temp);
    }
 
    if (scratch != kNoRegister) {
      temp->ReleaseTemporary();
    }
  }
  return;
}

◆ EmitMoveFromNative()

void dart::FlowGraphCompiler::EmitMoveFromNative	(	Location	dst_loc,
		Representation	dst_type,
		const compiler::ffi::NativeLocation &	src,
		TemporaryRegisterAllocator *	temp
	)

Definition at line 3456 of file flow_graph_compiler.cc.

                                      {
  if (dst_loc.IsPairLocation()) {
    for (intptr_t i : {0, 1}) {
      const auto& dest_split = compiler::ffi::NativeLocation::FromPairLocation(
          zone_, dst_loc, dst_type, i);
      EmitNativeMove(dest_split, src.Split(zone_, 2, i), temp);
    }
  } else {
    const auto& dst =
        compiler::ffi::NativeLocation::FromLocation(zone_, dst_loc, dst_type);
    // Deal with sign mismatch caused by lack of kUnboxedUint64 representation.
    if (dst_type == kUnboxedInt64 &&
        src.container_type().AsPrimitive().representation() ==
            compiler::ffi::kUint64) {
      EmitNativeMove(dst.WithOtherNativeType(zone_, src.container_type(),
                                             src.container_type()),
                     src, temp);
    } else {
      EmitNativeMove(dst, src, temp);
    }
  }
}

◆ EmitMoveToNative()

void dart::FlowGraphCompiler::EmitMoveToNative	(	const compiler::ffi::NativeLocation &	dst,
		Location	src_loc,
		Representation	src_type,
		TemporaryRegisterAllocator *	temp
	)

Definition at line 3428 of file flow_graph_compiler.cc.

                                      {
  if (src_loc.IsPairLocation()) {
    for (intptr_t i : {0, 1}) {
      const auto& src_split = compiler::ffi::NativeLocation::FromPairLocation(
          zone_, src_loc, src_type, i);
      EmitNativeMove(dst.Split(zone_, 2, i), src_split, temp);
    }
  } else {
    const auto& src =
        compiler::ffi::NativeLocation::FromLocation(zone_, src_loc, src_type);
    // Deal with sign mismatch caused by lack of kUnboxedUint64 representation.
    if (src_type == kUnboxedInt64 &&
        dst.container_type().AsPrimitive().representation() ==
            compiler::ffi::kUint64) {
      EmitNativeMove(dst,
                     src.WithOtherNativeType(zone_, dst.container_type(),
                                             dst.container_type()),
                     temp);
    } else {
      EmitNativeMove(dst, src, temp);
    }
  }
}

◆ EmitNativeMove()

void dart::FlowGraphCompiler::EmitNativeMove	(	const compiler::ffi::NativeLocation &	dst,
		const compiler::ffi::NativeLocation &	src,
		TemporaryRegisterAllocator *	temp
	)

Definition at line 3298 of file flow_graph_compiler.cc.

                                      {
  if (destination.IsBoth()) {
    // Copy to both.
    const auto& both = destination.AsBoth();
    EmitNativeMove(both.location(0), source, temp);
    EmitNativeMove(both.location(1), source, temp);
    return;
  }
  if (source.IsBoth()) {
    // Copy from one of both.
    const auto& both = source.AsBoth();
    EmitNativeMove(destination, both.location(0), temp);
    return;
  }
 
  const auto& src_payload_type = source.payload_type();
  const auto& dst_payload_type = destination.payload_type();
  const auto& src_container_type = source.container_type();
  const auto& dst_container_type = destination.container_type();
  const intptr_t src_payload_size = src_payload_type.SizeInBytes();
  const intptr_t dst_payload_size = dst_payload_type.SizeInBytes();
  const intptr_t src_container_size = src_container_type.SizeInBytes();
  const intptr_t dst_container_size = dst_container_type.SizeInBytes();
 
  // This function does not know how to do larger mem copy moves yet.
  ASSERT(src_payload_type.IsPrimitive());
  ASSERT(dst_payload_type.IsPrimitive());
 
  // This function does not deal with sign conversions yet.
  ASSERT(src_payload_type.IsSigned() == dst_payload_type.IsSigned());
 
  // If the location, payload, and container are equal, we're done.
  if (source.Equals(destination) && src_payload_type.Equals(dst_payload_type) &&
      src_container_type.Equals(dst_container_type)) {
#if defined(TARGET_ARCH_RISCV64)
    // Except we might still need to adjust for the difference between C's
    // representation of uint32 (sign-extended to 64 bits) and Dart's
    // (zero-extended).
    EmitNativeMoveArchitecture(destination, source);
#endif
    return;
  }
 
  // Solve discrepancies between container size and payload size.
  if (src_payload_type.IsInt() && dst_payload_type.IsInt() &&
      (src_payload_size != src_container_size ||
       dst_payload_size != dst_container_size)) {
    if (source.IsStack() && src_container_size > src_payload_size) {
      // Shrink loads since all loads are extending.
      return EmitNativeMove(
          destination,
          source.WithOtherNativeType(zone_, src_payload_type, src_payload_type),
          temp);
    }
    if (src_payload_size <= dst_payload_size &&
        src_container_size >= dst_container_size) {
      // The upper bits of the source are already properly sign or zero
      // extended, so just copy the required amount of bits.
      return EmitNativeMove(destination.WithOtherNativeType(
                                zone_, dst_container_type, dst_container_type),
                            source.WithOtherNativeType(
                                zone_, dst_container_type, dst_container_type),
                            temp);
    }
    if (src_payload_size >= dst_payload_size &&
        dst_container_size > dst_payload_size) {
      // The upper bits of the source are not properly sign or zero extended
      // to be copied to the target, so regard the source as smaller.
      return EmitNativeMove(
          destination.WithOtherNativeType(zone_, dst_container_type,
                                          dst_container_type),
          source.WithOtherNativeType(zone_, dst_payload_type, dst_payload_type),
          temp);
    }
    UNREACHABLE();
  }
  ASSERT(src_payload_size == src_container_size);
  ASSERT(dst_payload_size == dst_container_size);
 
  // Split moves that are larger than kWordSize, these require separate
  // instructions on all architectures.
  if (compiler::target::kWordSize == 4 && src_container_size == 8 &&
      dst_container_size == 8 && !source.IsFpuRegisters() &&
      !destination.IsFpuRegisters()) {
    // TODO(40209): If this is stack to stack, we could use FpuTMP.
    // Test the impact on code size and speed.
    EmitNativeMove(destination.Split(zone_, 2, 0), source.Split(zone_, 2, 0),
                   temp);
    EmitNativeMove(destination.Split(zone_, 2, 1), source.Split(zone_, 2, 1),
                   temp);
    return;
  }
 
  // Split moves from stack to stack, none of the architectures provides
  // memory to memory move instructions.
  if (source.IsStack() && destination.IsStack()) {
    Register scratch = temp->AllocateTemporary();
    ASSERT(scratch != kNoRegister);
#if defined(TARGET_ARCH_RISCV32) || defined(TARGET_ARCH_RISCV64)
    ASSERT(scratch != TMP);   // TMP is an argument register.
    ASSERT(scratch != TMP2);  // TMP2 is an argument register.
#endif
    const auto& intermediate =
        *new (zone_) compiler::ffi::NativeRegistersLocation(
            zone_, dst_payload_type, dst_container_type, scratch);
    EmitNativeMove(intermediate, source, temp);
    EmitNativeMove(destination, intermediate, temp);
    temp->ReleaseTemporary();
    return;
  }
 
  const bool sign_or_zero_extend = dst_container_size > src_container_size;
 
  // No architecture supports sign extending with memory as destination.
  if (sign_or_zero_extend && destination.IsStack()) {
    ASSERT(source.IsRegisters());
    const auto& intermediate =
        source.WithOtherNativeType(zone_, dst_payload_type, dst_container_type);
    EmitNativeMove(intermediate, source, temp);
    EmitNativeMove(destination, intermediate, temp);
    return;
  }
 
  // Do the simple architecture specific moves.
  EmitNativeMoveArchitecture(destination, source);
}

◆ EmitOptimizedInstanceCall()

void dart::FlowGraphCompiler::EmitOptimizedInstanceCall	(	const Code &	stub,
		const ICData &	ic_data,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`
	)

◆ EmitOptimizedStaticCall()

void dart::FlowGraphCompiler::EmitOptimizedStaticCall	(	const Function &	function,
		const Array &	arguments_descriptor,
		intptr_t	size_with_type_args,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`
	)

◆ EmitPolymorphicInstanceCall()

void dart::FlowGraphCompiler::EmitPolymorphicInstanceCall	(	const PolymorphicInstanceCallInstr *	call,
		const CallTargets &	targets,
		ArgumentsInfo	args_info,
		intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs,
		bool	complete,
		intptr_t	total_call_count,
		bool	receiver_can_be_smi = `true`
	)

Definition at line 2050 of file flow_graph_compiler.cc.

                              {
  ASSERT(call != nullptr);
  if (!FLAG_precompiled_mode) {
    if (FLAG_polymorphic_with_deopt) {
      compiler::Label* deopt =
          AddDeoptStub(deopt_id, ICData::kDeoptPolymorphicInstanceCallTestFail);
      compiler::Label ok;
      EmitTestAndCall(targets, call->function_name(), args_info,
                      deopt,  // No cid match.
                      &ok,    // Found cid.
                      deopt_id, source, locs, complete, total_ic_calls,
                      call->entry_kind());
      assembler()->Bind(&ok);
    } else {
      compiler::Label megamorphic, ok;
      EmitTestAndCall(targets, call->function_name(), args_info,
                      &megamorphic,  // No cid match.
                      &ok,           // Found cid.
                      deopt_id, source, locs, complete, total_ic_calls,
                      call->entry_kind());
      assembler()->Jump(&ok);
      assembler()->Bind(&megamorphic);
      // Instead of deoptimizing, do a megamorphic call when no matching
      // cid found.
      EmitMegamorphicInstanceCall(*call->ic_data(), deopt_id, source, locs);
      assembler()->Bind(&ok);
    }
  } else {
    if (complete) {
      compiler::Label ok;
      EmitTestAndCall(targets, call->function_name(), args_info,
                      nullptr,  // No cid match.
                      &ok,      // Found cid.
                      deopt_id, source, locs, true, total_ic_calls,
                      call->entry_kind());
      assembler()->Bind(&ok);
    } else {
      const ICData& unary_checks =
          ICData::ZoneHandle(zone(), call->ic_data()->AsUnaryClassChecks());
      EmitInstanceCallAOT(unary_checks, deopt_id, source, locs,
                          call->entry_kind(), receiver_can_be_smi);
    }
  }
}

◆ EmitPrologue()

void dart::FlowGraphCompiler::EmitPrologue ( )

◆ EmitTailCallToStub()

void dart::FlowGraphCompiler::EmitTailCallToStub ( const Code & stub )

◆ EmitTestAndCall()

void dart::FlowGraphCompiler::EmitTestAndCall	(	const CallTargets &	targets,
		const String &	function_name,
		ArgumentsInfo	args_info,
		compiler::Label *	failed,
		compiler::Label *	match_found,
		intptr_t	deopt_id,
		const InstructionSource &	source_index,
		LocationSummary *	locs,
		bool	complete,
		intptr_t	total_ic_calls,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`
	)

Definition at line 2123 of file flow_graph_compiler.cc.

                                                                  {
  ASSERT(is_optimizing());
  ASSERT(complete || (failed != nullptr));  // Complete calls can't fail.
 
  const Array& arguments_descriptor =
      Array::ZoneHandle(zone(), args_info.ToArgumentsDescriptor());
  EmitTestAndCallLoadReceiver(args_info.count_without_type_args,
                              arguments_descriptor);
 
  const int kNoCase = -1;
  int smi_case = kNoCase;
  int which_case_to_skip = kNoCase;
 
  const int length = targets.length();
  ASSERT(length > 0);
  int non_smi_length = length;
 
  // Find out if one of the classes in one of the cases is the Smi class. We
  // will be handling that specially.
  for (int i = 0; i < length; i++) {
    const intptr_t start = targets[i].cid_start;
    if (start > kSmiCid) continue;
    const intptr_t end = targets[i].cid_end;
    if (end >= kSmiCid) {
      smi_case = i;
      if (start == kSmiCid && end == kSmiCid) {
        // If this case has only the Smi class then we won't need to emit it at
        // all later.
        which_case_to_skip = i;
        non_smi_length--;
      }
      break;
    }
  }
 
  if (smi_case != kNoCase) {
    compiler::Label after_smi_test;
    // If the call is complete and there are no other possible receiver
    // classes - then receiver can only be a smi value and we don't need
    // to check if it is a smi.
    if (!(complete && non_smi_length == 0)) {
      EmitTestAndCallSmiBranch(non_smi_length == 0 ? failed : &after_smi_test,
                               /* jump_if_smi= */ false);
    }
 
    // Do not use the code from the function, but let the code be patched so
    // that we can record the outgoing edges to other code.
    const Function& function = *targets.TargetAt(smi_case)->target;
    GenerateStaticDartCall(deopt_id, source_index,
                           UntaggedPcDescriptors::kOther, locs, function,
                           entry_kind);
    EmitDropArguments(args_info.size_with_type_args);
    if (match_found != nullptr) {
      __ Jump(match_found);
    }
    __ Bind(&after_smi_test);
  } else {
    if (!complete) {
      // Smi is not a valid class.
      EmitTestAndCallSmiBranch(failed, /* jump_if_smi = */ true);
    }
  }
 
  if (non_smi_length == 0) {
    // If non_smi_length is 0 then only a Smi check was needed; the Smi check
    // above will fail if there was only one check and receiver is not Smi.
    return;
  }
 
  bool add_megamorphic_call = false;
  int bias = 0;
 
  // Value is not Smi.
  EmitTestAndCallLoadCid(EmitTestCidRegister());
 
  int last_check = which_case_to_skip == length - 1 ? length - 2 : length - 1;
 
  for (intptr_t i = 0; i < length; i++) {
    if (i == which_case_to_skip) continue;
    const bool is_last_check = (i == last_check);
    const int count = targets.TargetAt(i)->count;
    if (!is_last_check && !complete && count < (total_ic_calls >> 5)) {
      // This case is hit too rarely to be worth writing class-id checks inline
      // for.  Note that we can't do this for calls with only one target because
      // the type propagator may have made use of that and expects a deopt if
      // a new class is seen at this calls site.  See IsMonomorphic.
      add_megamorphic_call = true;
      break;
    }
    compiler::Label next_test;
    if (!complete || !is_last_check) {
      bias = EmitTestAndCallCheckCid(assembler(),
                                     is_last_check ? failed : &next_test,
                                     EmitTestCidRegister(), targets[i], bias,
                                     /*jump_on_miss =*/true);
    }
    // Do not use the code from the function, but let the code be patched so
    // that we can record the outgoing edges to other code.
    const Function& function = *targets.TargetAt(i)->target;
    GenerateStaticDartCall(deopt_id, source_index,
                           UntaggedPcDescriptors::kOther, locs, function,
                           entry_kind);
    EmitDropArguments(args_info.size_with_type_args);
    if (!is_last_check || add_megamorphic_call) {
      __ Jump(match_found);
    }
    __ Bind(&next_test);
  }
  if (add_megamorphic_call) {
    EmitMegamorphicInstanceCall(function_name, arguments_descriptor, deopt_id,
                                source_index, locs);
  }
}

◆ EmitTestAndCallCheckCid()

int dart::FlowGraphCompiler::EmitTestAndCallCheckCid	(	compiler::Assembler *	assembler,
		compiler::Label *	label,
		Register	class_id_reg,
		const CidRangeValue &	range,
		int	bias,
		bool	jump_on_miss = `true`
	)

static

Definition at line 2305 of file flow_graph_compiler.cc.

                                                                  {
  const intptr_t cid_start = range.cid_start;
  if (range.IsSingleCid()) {
    assembler->CompareImmediate(class_id_reg, cid_start - bias);
    assembler->BranchIf(jump_on_miss ? NOT_EQUAL : EQUAL, label);
  } else {
    assembler->AddImmediate(class_id_reg, bias - cid_start);
    bias = cid_start;
    assembler->CompareImmediate(class_id_reg, range.Extent());
    assembler->BranchIf(jump_on_miss ? UNSIGNED_GREATER : UNSIGNED_LESS_EQUAL,
                        label);
  }
  return bias;
}

◆ EmitYieldPositionMetadata()

void dart::FlowGraphCompiler::EmitYieldPositionMetadata	(	const InstructionSource &	source,
		intptr_t	yield_index
	)

Definition at line 500 of file flow_graph_compiler.cc.

                          {
  AddDescriptor(UntaggedPcDescriptors::kOther, assembler()->CodeSize(),
                DeoptId::kNone, source, CurrentTryIndex(), yield_index);
}

◆ EndCodeSourceRange()

void dart::FlowGraphCompiler::EndCodeSourceRange ( const InstructionSource & source )

Definition at line 1999 of file flow_graph_compiler.cc.

                                                                          {
  code_source_map_builder_->EndCodeSourceRange(assembler()->CodeSize(), source);
}

◆ EnterIntrinsicMode()

void dart::FlowGraphCompiler::EnterIntrinsicMode ( )

◆ ExitIntrinsicMode()

void dart::FlowGraphCompiler::ExitIntrinsicMode ( )

◆ ExtraStackSlotsOnOsrEntry()

intptr_t dart::FlowGraphCompiler::ExtraStackSlotsOnOsrEntry ( ) const

Definition at line 824 of file flow_graph_compiler.cc.

                                                            {
  ASSERT(flow_graph().IsCompiledForOsr());
  const intptr_t stack_depth =
      flow_graph().graph_entry()->osr_entry()->stack_depth();
  const intptr_t num_stack_locals = flow_graph().num_stack_locals();
  return StackSize() - stack_depth - num_stack_locals;
}

◆ FinalizeCatchEntryMovesMap()

void dart::FlowGraphCompiler::FinalizeCatchEntryMovesMap ( const Code & code )

Definition at line 1365 of file flow_graph_compiler.cc.

                                                                   {
#if defined(DART_PRECOMPILER)
  if (FLAG_precompiled_mode) {
    TypedData& maps = TypedData::Handle(
        catch_entry_moves_maps_builder_->FinalizeCatchEntryMovesMap());
    code.set_catch_entry_moves_maps(maps);
    return;
  }
#endif
  code.set_num_variables(flow_graph().variable_count());
}

◆ FinalizeCodeSourceMap()

void dart::FlowGraphCompiler::FinalizeCodeSourceMap ( const Code & code )

Definition at line 1412 of file flow_graph_compiler.cc.

                                                              {
  const Array& inlined_id_array =
      Array::Handle(zone(), code_source_map_builder_->InliningIdToFunction());
  code.set_inlined_id_to_function(inlined_id_array);
 
  const CodeSourceMap& map =
      CodeSourceMap::Handle(code_source_map_builder_->Finalize());
  code.set_code_source_map(map);
 
#if defined(DEBUG)
  // Force simulation through the last pc offset. This checks we can decode
  // the whole CodeSourceMap without hitting an unknown opcode, stack underflow,
  // etc.
  GrowableArray<const Function*> fs;
  GrowableArray<TokenPosition> tokens;
  code.GetInlinedFunctionsAtInstruction(code.Size() - 1, &fs, &tokens);
#endif
}

◆ FinalizeExceptionHandlers()

void dart::FlowGraphCompiler::FinalizeExceptionHandlers ( const Code & code )

Definition at line 1279 of file flow_graph_compiler.cc.

                                                                  {
  ASSERT(exception_handlers_list_ != nullptr);
  const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
      exception_handlers_list_->FinalizeExceptionHandlers(code.PayloadStart()));
  code.set_exception_handlers(handlers);
}

◆ FinalizePcDescriptors()

void dart::FlowGraphCompiler::FinalizePcDescriptors ( const Code & code )

Definition at line 1286 of file flow_graph_compiler.cc.

                                                              {
  ASSERT(pc_descriptors_list_ != nullptr);
  const PcDescriptors& descriptors = PcDescriptors::Handle(
      pc_descriptors_list_->FinalizePcDescriptors(code.PayloadStart()));
  if (!is_optimizing_) descriptors.Verify(parsed_function_.function());
  code.set_pc_descriptors(descriptors);
}

◆ FinalizeStackMaps()

void dart::FlowGraphCompiler::FinalizeStackMaps ( const Code & code )

Definition at line 1326 of file flow_graph_compiler.cc.

                                                          {
  ASSERT(compressed_stackmaps_builder_ != nullptr);
  // Finalize the compressed stack maps and add it to the code object.
  const auto& maps =
      CompressedStackMaps::Handle(compressed_stackmaps_builder_->Finalize());
  code.set_compressed_stackmaps(maps);
}

◆ FinalizeStaticCallTargetsTable()

void dart::FlowGraphCompiler::FinalizeStaticCallTargetsTable ( const Code & code )

Definition at line 1377 of file flow_graph_compiler.cc.

                                                                       {
  ASSERT(code.static_calls_target_table() == Array::null());
  const auto& calls = static_calls_target_table_;
  const intptr_t array_length = calls.length() * Code::kSCallTableEntryLength;
  const auto& targets =
      Array::Handle(zone(), Array::New(array_length, Heap::kOld));
 
  StaticCallsTable entries(targets);
  auto& kind_type_and_offset = Smi::Handle(zone());
  for (intptr_t i = 0; i < calls.length(); i++) {
    auto entry = calls[i];
    kind_type_and_offset =
        Smi::New(Code::KindField::encode(entry->call_kind) |
                 Code::EntryPointField::encode(entry->entry_point) |
                 Code::OffsetField::encode(entry->offset));
    auto view = entries[i];
    view.Set<Code::kSCallTableKindAndOffset>(kind_type_and_offset);
    const Object* target = nullptr;
    if (entry->function != nullptr) {
      target = entry->function;
      view.Set<Code::kSCallTableFunctionTarget>(*entry->function);
    }
    if (entry->code != nullptr) {
      ASSERT(target == nullptr);
      target = entry->code;
      view.Set<Code::kSCallTableCodeOrTypeTarget>(*entry->code);
    }
    if (entry->dst_type != nullptr) {
      ASSERT(target == nullptr);
      view.Set<Code::kSCallTableCodeOrTypeTarget>(*entry->dst_type);
    }
  }
  code.set_static_calls_target_table(targets);
}

◆ FinalizeVarDescriptors()

void dart::FlowGraphCompiler::FinalizeVarDescriptors ( const Code & code )

Definition at line 1334 of file flow_graph_compiler.cc.

                                                               {
#if defined(PRODUCT)
// No debugger: no var descriptors.
#else
  if (code.is_optimized()) {
    // Optimized code does not need variable descriptors. They are
    // only stored in the unoptimized version.
    code.set_var_descriptors(Object::empty_var_descriptors());
    return;
  }
  LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle();
  if (flow_graph().IsIrregexpFunction()) {
    // Eager local var descriptors computation for Irregexp function as it is
    // complicated to factor out.
    // TODO(srdjan): Consider canonicalizing and reusing the local var
    // descriptor for IrregexpFunction.
    ASSERT(parsed_function().scope() == nullptr);
    var_descs = LocalVarDescriptors::New(1);
    UntaggedLocalVarDescriptors::VarInfo info;
    info.set_kind(UntaggedLocalVarDescriptors::kSavedCurrentContext);
    info.scope_id = 0;
    info.begin_pos = TokenPosition::kMinSource;
    info.end_pos = TokenPosition::kMinSource;
    info.set_index(compiler::target::frame_layout.FrameSlotForVariable(
        parsed_function().current_context_var()));
    var_descs.SetVar(0, Symbols::CurrentContextVar(), &info);
  }
  code.set_var_descriptors(var_descs);
#endif
}

◆ float32x4_class()

const Class & dart::FlowGraphCompiler::float32x4_class ( ) const

inline

Definition at line 846 of file flow_graph_compiler.h.

846{ return float32x4_class_; }

◆ float64x2_class()

const Class & dart::FlowGraphCompiler::float64x2_class ( ) const

inline

Definition at line 847 of file flow_graph_compiler.h.

847{ return float64x2_class_; }

◆ flow_graph()

const FlowGraph & dart::FlowGraphCompiler::flow_graph ( ) const

inline

Definition at line 415 of file flow_graph_compiler.h.

                                      {
    return intrinsic_mode() ? *intrinsic_flow_graph_ : flow_graph_;
  }

◆ ForcedOptimization()

bool dart::FlowGraphCompiler::ForcedOptimization ( ) const

inline

Definition at line 413 of file flow_graph_compiler.h.

413{ return function().ForceOptimize(); }

dart::Function::ForceOptimize

bool ForceOptimize() const

Definition: object.cc:9017

◆ ForceSlowPathForStackOverflow()

bool dart::FlowGraphCompiler::ForceSlowPathForStackOverflow ( ) const

Definition at line 276 of file flow_graph_compiler.cc.

                                                            {
#if !defined(PRODUCT)
  if (FLAG_stacktrace_every > 0 || FLAG_deoptimize_every > 0 ||
      FLAG_gc_every > 0 ||
      (isolate_group()->reload_every_n_stack_overflow_checks() > 0)) {
    if (!IsolateGroup::IsSystemIsolateGroup(isolate_group())) {
      return true;
    }
  }
  if (FLAG_stacktrace_filter != nullptr &&
      strstr(parsed_function().function().ToFullyQualifiedCString(),
             FLAG_stacktrace_filter) != nullptr) {
    return true;
  }
  if (is_optimizing() && FLAG_deoptimize_filter != nullptr &&
      strstr(parsed_function().function().ToFullyQualifiedCString(),
             FLAG_deoptimize_filter) != nullptr) {
    return true;
  }
#endif  // !defined(PRODUCT)
  return false;
}

◆ function()

const Function & dart::FlowGraphCompiler::function ( ) const

inline

Definition at line 401 of file flow_graph_compiler.h.

401{ return parsed_function_.function(); }

◆ GenerateAssertAssignable()

void dart::FlowGraphCompiler::GenerateAssertAssignable	(	CompileType *	receiver_type,
		const InstructionSource &	source,
		intptr_t	deopt_id,
		Environment *	env,
		const String &	dst_name,
		LocationSummary *	locs
	)

Definition at line 2811 of file flow_graph_compiler.cc.

                           {
  ASSERT(!source.token_pos.IsClassifying());
  ASSERT(CheckAssertAssignableTypeTestingABILocations(*locs));
 
  // Non-null if we have a constant destination type.
  const auto& dst_type =
      locs->in(AssertAssignableInstr::kDstTypePos).IsConstant()
          ? AbstractType::Cast(
                locs->in(AssertAssignableInstr::kDstTypePos).constant())
          : Object::null_abstract_type();
 
  if (!dst_type.IsNull()) {
    ASSERT(dst_type.IsFinalized());
    if (dst_type.IsTopTypeForSubtyping()) return;  // No code needed.
  }
 
  compiler::Label done;
  Register type_reg = TypeTestABI::kDstTypeReg;
  // Generate caller-side checks to perform prior to calling the TTS.
  if (dst_type.IsNull()) {
    __ Comment("AssertAssignable for runtime type");
    // kDstTypeReg should already contain the destination type.
  } else {
    __ Comment("AssertAssignable for compile-time type");
    GenerateCallerChecksForAssertAssignable(receiver_type, dst_type, &done);
    if (dst_type.IsTypeParameter()) {
      // The resolved type parameter is in the scratch register.
      type_reg = TypeTestABI::kScratchReg;
    }
  }
 
  GenerateTTSCall(source, deopt_id, env, type_reg, dst_type, dst_name, locs);
  __ Bind(&done);
}

◆ GenerateCallerChecksForAssertAssignable()

void dart::FlowGraphCompiler::GenerateCallerChecksForAssertAssignable	(	CompileType *	receiver_type,
		const AbstractType &	dst_type,
		compiler::Label *	done
	)

Definition at line 2916 of file flow_graph_compiler.cc.

                         {
  // Top types should be handled by the caller and cannot reach here.
  ASSERT(!dst_type.IsTopTypeForSubtyping());
 
  // Set this to avoid marking the type testing stub for optimization.
  bool elide_info = false;
  // Call before any return points to set the destination type register and
  // mark the destination type TTS as needing optimization, unless it is
  // unlikely to be called.
  auto output_dst_type = [&]() -> void {
    // If we haven't handled the positive case of the type check on the call
    // site and we'll be using the TTS of the destination type, we want an
    // optimized type testing stub and thus record it in the [TypeUsageInfo].
    if (!elide_info) {
      if (auto const type_usage_info = thread()->type_usage_info()) {
        type_usage_info->UseTypeInAssertAssignable(dst_type);
      } else {
        ASSERT(!FLAG_precompiled_mode);
      }
    }
    __ LoadObject(TypeTestABI::kDstTypeReg, dst_type);
  };
 
  // We can handle certain types and checks very efficiently on the call site,
  // meaning those need not be checked within the stubs (which may involve
  // a runtime call).
 
  if (dst_type.IsObjectType()) {
    // Special case: non-nullable Object.
    ASSERT(dst_type.IsNonNullable());
    __ CompareObject(TypeTestABI::kInstanceReg, Object::null_object());
    __ BranchIf(NOT_EQUAL, done);
    // Fall back to type testing stub in caller to throw the exception.
    return output_dst_type();
  }
 
  // If the int type is assignable to [dst_type] we special case it on the
  // caller side!
  const Type& int_type = Type::Handle(zone(), Type::IntType());
  bool is_non_smi = false;
  if (int_type.IsSubtypeOf(dst_type, Heap::kOld)) {
    __ BranchIfSmi(TypeTestABI::kInstanceReg, done);
    is_non_smi = true;
  } else if (!receiver_type->CanBeSmi()) {
    is_non_smi = true;
  }
 
  if (dst_type.IsTypeParameter()) {
    // Special case: Instantiate the type parameter on the caller side, invoking
    // the TTS of the corresponding type parameter in the caller.
    const TypeParameter& type_param = TypeParameter::Cast(dst_type);
    if (!type_param.IsNonNullable()) {
      // If the type parameter is nullable when running in strong mode, we need
      // to handle null before calling the TTS because the type parameter may be
      // instantiated with a non-nullable type, where the TTS rejects null.
      __ CompareObject(TypeTestABI::kInstanceReg, Object::null_object());
      __ BranchIf(EQUAL, done);
    }
    const Register kTypeArgumentsReg =
        type_param.IsClassTypeParameter()
            ? TypeTestABI::kInstantiatorTypeArgumentsReg
            : TypeTestABI::kFunctionTypeArgumentsReg;
 
    // Check if type arguments are null, i.e. equivalent to vector of dynamic.
    // If so, then the value is guaranteed assignable as dynamic is a top type.
    __ CompareObject(kTypeArgumentsReg, Object::null_object());
    __ BranchIf(EQUAL, done);
    // Put the instantiated type parameter into the scratch register, so its
    // TTS can be called by the caller.
    __ LoadCompressedFieldFromOffset(
        TypeTestABI::kScratchReg, kTypeArgumentsReg,
        compiler::target::TypeArguments::type_at_offset(type_param.index()));
    return output_dst_type();
  }
 
  if (dst_type.IsFunctionType() || dst_type.IsRecordType()) {
    return output_dst_type();
  }
 
  if (auto const hi = thread()->hierarchy_info()) {
    const Class& type_class = Class::Handle(zone(), dst_type.type_class());
 
    if (hi->CanUseSubtypeRangeCheckFor(dst_type)) {
      const CidRangeVector& ranges = hi->SubtypeRangesForClass(
          type_class,
          /*include_abstract=*/false,
          /*exclude_null=*/!Instance::NullIsAssignableTo(dst_type));
      if (ranges.length() <= kMaxNumberOfCidRangesToTest) {
        if (is_non_smi) {
          __ LoadClassId(TypeTestABI::kScratchReg, TypeTestABI::kInstanceReg);
        } else {
          __ LoadClassIdMayBeSmi(TypeTestABI::kScratchReg,
                                 TypeTestABI::kInstanceReg);
        }
        GenerateCidRangesCheck(assembler(), TypeTestABI::kScratchReg, ranges,
                               done);
        elide_info = true;
      } else if (IsListClass(type_class)) {
        __ LoadClassIdMayBeSmi(TypeTestABI::kScratchReg,
                               TypeTestABI::kInstanceReg);
        GenerateListTypeCheck(TypeTestABI::kScratchReg, done);
      }
    }
  }
  output_dst_type();
}

◆ GenerateCidRangesCheck()

bool dart::FlowGraphCompiler::GenerateCidRangesCheck	(	compiler::Assembler *	assembler,
		Register	class_id_reg,
		const CidRangeVector &	cid_ranges,
		compiler::Label *	inside_range_lbl,
		compiler::Label *	outside_range_lbl = `nullptr`,
		bool	fall_through_if_inside = `false`
	)

static

Definition at line 2271 of file flow_graph_compiler.cc.

                                 {
  // If there are no valid class ranges, the check will fail.  If we are
  // supposed to fall-through in the positive case, we'll explicitly jump to
  // the [outside_range_lbl].
  if (cid_ranges.is_empty()) {
    if (fall_through_if_inside) {
      assembler->Jump(outside_range_lbl);
    }
    return false;
  }
 
  int bias = 0;
  for (intptr_t i = 0; i < cid_ranges.length(); ++i) {
    const CidRangeValue& range = cid_ranges[i];
    RELEASE_ASSERT(!range.IsIllegalRange());
    const bool last_round = i == (cid_ranges.length() - 1);
 
    compiler::Label* jump_label = last_round && fall_through_if_inside
                                      ? outside_range_lbl
                                      : inside_range_lbl;
    const bool jump_on_miss = last_round && fall_through_if_inside;
 
    bias = EmitTestAndCallCheckCid(assembler, jump_label, class_id_reg, range,
                                   bias, jump_on_miss);
  }
  return bias != 0;
}

◆ GenerateDartCall()

void dart::FlowGraphCompiler::GenerateDartCall	(	intptr_t	deopt_id,
		const InstructionSource &	source,
		const Code &	stub,
		UntaggedPcDescriptors::Kind	kind,
		LocationSummary *	locs,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`
	)

◆ GenerateIndirectTTSCall()

static void dart::FlowGraphCompiler::GenerateIndirectTTSCall	(	compiler::Assembler *	assembler,
		Register	reg_with_type,
		intptr_t	sub_type_cache_index
	)

static

◆ GenerateInstanceCall()

void dart::FlowGraphCompiler::GenerateInstanceCall	(	intptr_t	deopt_id,
		const InstructionSource &	source,
		LocationSummary *	locs,
		const ICData &	ic_data,
		Code::EntryKind	entry_kind,
		bool	receiver_can_be_smi
	)

Definition at line 1509 of file flow_graph_compiler.cc.

                                                                       {
  ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
  if (FLAG_precompiled_mode) {
    ic_data = ic_data.AsUnaryClassChecks();
    EmitInstanceCallAOT(ic_data, deopt_id, source, locs, entry_kind,
                        receiver_can_be_smi);
    return;
  }
  ASSERT(!ic_data.IsNull());
  if (is_optimizing() && (ic_data_in.NumberOfUsedChecks() == 0)) {
    // Emit IC call that will count and thus may need reoptimization at
    // function entry.
    ASSERT(may_reoptimize() || flow_graph().IsCompiledForOsr());
    EmitOptimizedInstanceCall(StubEntryFor(ic_data, /*optimized=*/true),
                              ic_data, deopt_id, source, locs, entry_kind);
    return;
  }
 
  if (is_optimizing()) {
    EmitMegamorphicInstanceCall(ic_data_in, deopt_id, source, locs);
    return;
  }
 
  EmitInstanceCallJIT(StubEntryFor(ic_data, /*optimized=*/false), ic_data,
                      deopt_id, source, locs, entry_kind);
}

◆ GenerateInstanceOf()

void dart::FlowGraphCompiler::GenerateInstanceOf	(	const InstructionSource &	source,
		intptr_t	deopt_id,
		Environment *	env,
		const AbstractType &	type,
		LocationSummary *	locs
	)

Definition at line 2721 of file flow_graph_compiler.cc.

                                                                  {
  ASSERT(type.IsFinalized());
  ASSERT(!type.IsTopTypeForInstanceOf());  // Already checked.
 
  compiler::Label is_instance, is_not_instance;
  // 'null' is an instance of Null, Object*, Never*, void, and dynamic.
  // In addition, 'null' is an instance of any nullable type.
  // It is also an instance of FutureOr<T> if it is an instance of T.
  const AbstractType& unwrapped_type =
      AbstractType::Handle(type.UnwrapFutureOr());
  if (!unwrapped_type.IsTypeParameter() || unwrapped_type.IsNullable()) {
    // Only nullable type parameter remains nullable after instantiation.
    // See NullIsInstanceOf().
    __ CompareObject(TypeTestABI::kInstanceReg, Object::null_object());
    __ BranchIf(EQUAL,
                unwrapped_type.IsNullable() ? &is_instance : &is_not_instance);
  }
 
  // Generate inline instanceof test.
  SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
  // kInstanceReg, kInstantiatorTypeArgumentsReg, and kFunctionTypeArgumentsReg
  // are preserved across the call.
  test_cache =
      GenerateInlineInstanceof(source, type, &is_instance, &is_not_instance);
 
  // test_cache is null if there is no fall-through.
  compiler::Label done;
  if (!test_cache.IsNull()) {
    // Generate Runtime call.
    __ LoadUniqueObject(TypeTestABI::kDstTypeReg, type);
    __ LoadUniqueObject(TypeTestABI::kSubtypeTestCacheReg, test_cache);
    GenerateStubCall(source, StubCode::InstanceOf(),
                     /*kind=*/UntaggedPcDescriptors::kOther, locs, deopt_id,
                     env);
    __ Jump(&done, compiler::Assembler::kNearJump);
  }
  __ Bind(&is_not_instance);
  __ LoadObject(TypeTestABI::kInstanceOfResultReg, Bool::Get(false));
  __ Jump(&done, compiler::Assembler::kNearJump);
 
  __ Bind(&is_instance);
  __ LoadObject(TypeTestABI::kInstanceOfResultReg, Bool::Get(true));
  __ Bind(&done);
}

◆ GenerateListTypeCheck()

void dart::FlowGraphCompiler::GenerateListTypeCheck	(	Register	kClassIdReg,
		compiler::Label *	is_instance_lbl
	)

Definition at line 1610 of file flow_graph_compiler.cc.

                                    {
  assembler()->Comment("ListTypeCheck");
  COMPILE_ASSERT((kImmutableArrayCid == kArrayCid + 1) &&
                 (kGrowableObjectArrayCid == kArrayCid + 2));
  CidRangeVector ranges;
  ranges.Add({kArrayCid, kGrowableObjectArrayCid});
  GenerateCidRangesCheck(assembler(), class_id_reg, ranges, is_instance_lbl);
}

◆ GenerateNonLazyDeoptableStubCall()

void dart::FlowGraphCompiler::GenerateNonLazyDeoptableStubCall	(	const InstructionSource &	source,
		const Code &	stub,
		UntaggedPcDescriptors::Kind	kind,
		LocationSummary *	locs,
		ObjectPool::SnapshotBehavior	snapshot_behavior = `compiler::ObjectPoolBuilderEntry::kSnapshotable`
	)

Definition at line 1476 of file flow_graph_compiler.cc.

                                                  {
  EmitCallToStub(stub, snapshot_behavior);
  EmitCallsiteMetadata(source, DeoptId::kNone, kind, locs, /*env=*/nullptr);
}

◆ GenerateNumberTypeCheck()

void dart::FlowGraphCompiler::GenerateNumberTypeCheck	(	Register	kClassIdReg,
		const AbstractType &	type,
		compiler::Label *	is_instance_lbl,
		compiler::Label *	is_not_instance_lbl
	)

Definition at line 1581 of file flow_graph_compiler.cc.

                                        {
  assembler()->Comment("NumberTypeCheck");
  GrowableArray<intptr_t> args;
  if (type.IsNumberType()) {
    args.Add(kDoubleCid);
    args.Add(kMintCid);
  } else if (type.IsIntType()) {
    args.Add(kMintCid);
  } else if (type.IsDoubleType()) {
    args.Add(kDoubleCid);
  }
  CheckClassIds(class_id_reg, args, is_instance_lbl, is_not_instance_lbl);
}

◆ GeneratePatchableCall()

void dart::FlowGraphCompiler::GeneratePatchableCall	(	const InstructionSource &	source,
		const Code &	stub,
		UntaggedPcDescriptors::Kind	kind,
		LocationSummary *	locs,
		ObjectPool::SnapshotBehavior	snapshot_behavior = `compiler::ObjectPoolBuilderEntry::kSnapshotable`
	)

◆ GenerateStaticCall()

void dart::FlowGraphCompiler::GenerateStaticCall	(	intptr_t	deopt_id,
		const InstructionSource &	source,
		const Function &	function,
		ArgumentsInfo	args_info,
		LocationSummary *	locs,
		const ICData &	ic_data_in,
		ICData::RebindRule	rebind_rule,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`
	)

Definition at line 1541 of file flow_graph_compiler.cc.

                                                                     {
  const ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
  const Array& arguments_descriptor = Array::ZoneHandle(
      zone(), ic_data.IsNull() ? args_info.ToArgumentsDescriptor()
                               : ic_data.arguments_descriptor());
  ASSERT(ArgumentsDescriptor(arguments_descriptor).TypeArgsLen() ==
         args_info.type_args_len);
  ASSERT(ArgumentsDescriptor(arguments_descriptor).Count() ==
         args_info.count_without_type_args);
  ASSERT(ArgumentsDescriptor(arguments_descriptor).Size() ==
         args_info.size_without_type_args);
  // Force-optimized functions lack the deopt info which allows patching of
  // optimized static calls.
  if (is_optimizing() && (!ForcedOptimization() || FLAG_precompiled_mode)) {
    EmitOptimizedStaticCall(function, arguments_descriptor,
                            args_info.size_with_type_args, deopt_id, source,
                            locs, entry_kind);
  } else {
    ICData& call_ic_data = ICData::ZoneHandle(zone(), ic_data.ptr());
    if (call_ic_data.IsNull()) {
      const intptr_t kNumArgsChecked = 0;
      call_ic_data =
          GetOrAddStaticCallICData(deopt_id, function, arguments_descriptor,
                                   kNumArgsChecked, rebind_rule)
              ->ptr();
      call_ic_data = call_ic_data.Original();
    }
    AddCurrentDescriptor(UntaggedPcDescriptors::kRewind, deopt_id, source);
    EmitUnoptimizedStaticCall(args_info.size_with_type_args, deopt_id, source,
                              locs, call_ic_data, entry_kind);
  }
}

◆ GenerateStaticDartCall()

void dart::FlowGraphCompiler::GenerateStaticDartCall	(	intptr_t	deopt_id,
		const InstructionSource &	source,
		UntaggedPcDescriptors::Kind	kind,
		LocationSummary *	locs,
		const Function &	target,
		Code::EntryKind	entry_kind = `Code::EntryKind::kNormal`
	)

◆ GenerateStringTypeCheck()

void dart::FlowGraphCompiler::GenerateStringTypeCheck	(	Register	kClassIdReg,
		compiler::Label *	is_instance_lbl,
		compiler::Label *	is_not_instance_lbl
	)

Definition at line 1599 of file flow_graph_compiler.cc.

                                        {
  assembler()->Comment("StringTypeCheck");
  GrowableArray<intptr_t> args;
  args.Add(kOneByteStringCid);
  args.Add(kTwoByteStringCid);
  CheckClassIds(class_id_reg, args, is_instance_lbl, is_not_instance_lbl);
}

◆ GenerateStubCall()

void dart::FlowGraphCompiler::GenerateStubCall	(	const InstructionSource &	source,
		const Code &	stub,
		UntaggedPcDescriptors::Kind	kind,
		LocationSummary *	locs,
		intptr_t	deopt_id,
		Environment *	env
	)

Definition at line 1464 of file flow_graph_compiler.cc.

                                                           {
  ASSERT(FLAG_precompiled_mode ||
         (deopt_id != DeoptId::kNone && (!is_optimizing() || env != nullptr)));
  EmitCallToStub(stub);
  EmitCallsiteMetadata(source, deopt_id, kind, locs, env);
}

◆ GenerateSubtypeRangeCheck()

bool dart::FlowGraphCompiler::GenerateSubtypeRangeCheck	(	Register	class_id_reg,
		const Class &	type_class,
		compiler::Label *	is_subtype_lbl
	)

Definition at line 2247 of file flow_graph_compiler.cc.

                                                                             {
  HierarchyInfo* hi = Thread::Current()->hierarchy_info();
  if (hi != nullptr) {
    const CidRangeVector& ranges =
        hi->SubtypeRangesForClass(type_class,
                                  /*include_abstract=*/false,
                                  /*exclude_null=*/false);
    if (ranges.length() <= kMaxNumberOfCidRangesToTest) {
      GenerateCidRangesCheck(assembler(), class_id_reg, ranges, is_subtype);
      return true;
    }
  }
 
  // We don't have cid-ranges for subclasses, so we'll just test against the
  // class directly if it's non-abstract.
  if (!type_class.is_abstract()) {
    __ CompareImmediate(class_id_reg, type_class.id());
    __ BranchIf(EQUAL, is_subtype);
  }
  return false;
}

◆ GenerateTTSCall()

void dart::FlowGraphCompiler::GenerateTTSCall	(	const InstructionSource &	source,
		intptr_t	deopt_id,
		Environment *	env,
		Register	reg_with_type,
		const AbstractType &	dst_type,
		const String &	dst_name,
		LocationSummary *	locs
	)

Definition at line 2855 of file flow_graph_compiler.cc.

                                                               {
  ASSERT(!dst_name.IsNull());
  // We use 2 consecutive entries in the pool for the subtype cache and the
  // destination name.  The second entry, namely [dst_name] seems to be unused,
  // but it will be used by the code throwing a TypeError if the type test fails
  // (see runtime/vm/runtime_entry.cc:TypeCheck).  It will use pattern matching
  // on the call site to find out at which pool index the destination name is
  // located.
  const intptr_t sub_type_cache_index = __ object_pool_builder().AddObject(
      Object::null_object(), compiler::ObjectPoolBuilderEntry::kPatchable);
  const intptr_t dst_name_index = __ object_pool_builder().AddObject(
      dst_name, compiler::ObjectPoolBuilderEntry::kPatchable);
  ASSERT((sub_type_cache_index + 1) == dst_name_index);
  ASSERT(__ constant_pool_allowed());
 
  __ Comment("TTSCall");
  // If the dst_type is known at compile time and instantiated, we know the
  // target TTS stub and so can use a PC-relative call when available.
  if (!dst_type.IsNull() && dst_type.IsInstantiated() &&
      CanPcRelativeCall(dst_type)) {
    __ LoadWordFromPoolIndex(TypeTestABI::kSubtypeTestCacheReg,
                             sub_type_cache_index);
    __ GenerateUnRelocatedPcRelativeCall();
    AddPcRelativeTTSCallTypeTarget(dst_type);
  } else {
    GenerateIndirectTTSCall(assembler(), reg_with_type, sub_type_cache_index);
  }
 
  EmitCallsiteMetadata(source, deopt_id, UntaggedPcDescriptors::kOther, locs,
                       env);
}

◆ GetJumpLabel()

compiler::Label * dart::FlowGraphCompiler::GetJumpLabel ( BlockEntryInstr * block_entry ) const

Definition at line 832 of file flow_graph_compiler.cc.

                                        {
  const intptr_t block_index = block_entry->postorder_number();
  return block_info_[block_index]->jump_label();
}

◆ GetOrAddInstanceCallICData()

const ICData * dart::FlowGraphCompiler::GetOrAddInstanceCallICData	(	intptr_t	deopt_id,
		const String &	target_name,
		const Array &	arguments_descriptor,
		intptr_t	num_args_tested,
		const AbstractType &	receiver_type,
		const Function &	binary_smi_target
	)

Definition at line 1867 of file flow_graph_compiler.cc.

                                       {
  if ((deopt_id_to_ic_data_ != nullptr) &&
      ((*deopt_id_to_ic_data_)[deopt_id] != nullptr)) {
    const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
    ASSERT(res->deopt_id() == deopt_id);
    ASSERT(res->target_name() == target_name.ptr());
    ASSERT(res->NumArgsTested() == num_args_tested);
    ASSERT(res->TypeArgsLen() ==
           ArgumentsDescriptor(arguments_descriptor).TypeArgsLen());
    ASSERT(!res->is_static_call());
    ASSERT(res->receivers_static_type() == receiver_type.ptr());
    return res;
  }
 
  auto& ic_data = ICData::ZoneHandle(zone());
  if (!binary_smi_target.IsNull()) {
    ASSERT(num_args_tested == 2);
    ASSERT(!binary_smi_target.IsNull());
    GrowableArray<intptr_t> cids(num_args_tested);
    cids.Add(kSmiCid);
    cids.Add(kSmiCid);
    ic_data = ICData::NewWithCheck(parsed_function().function(), target_name,
                                   arguments_descriptor, deopt_id,
                                   num_args_tested, ICData::kInstance, &cids,
                                   binary_smi_target, receiver_type);
  } else {
    ic_data = ICData::New(parsed_function().function(), target_name,
                          arguments_descriptor, deopt_id, num_args_tested,
                          ICData::kInstance, receiver_type);
  }
 
  if (deopt_id_to_ic_data_ != nullptr) {
    (*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
  }
  ASSERT(!ic_data.is_static_call());
  return &ic_data;
}

◆ GetOrAddStaticCallICData()

const ICData * dart::FlowGraphCompiler::GetOrAddStaticCallICData	(	intptr_t	deopt_id,
		const Function &	target,
		const Array &	arguments_descriptor,
		intptr_t	num_args_tested,
		ICData::RebindRule	rebind_rule
	)

Definition at line 1911 of file flow_graph_compiler.cc.

                                  {
  if ((deopt_id_to_ic_data_ != nullptr) &&
      ((*deopt_id_to_ic_data_)[deopt_id] != nullptr)) {
    const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
    ASSERT(res->deopt_id() == deopt_id);
    ASSERT(res->target_name() == target.name());
    ASSERT(res->NumArgsTested() == num_args_tested);
    ASSERT(res->TypeArgsLen() ==
           ArgumentsDescriptor(arguments_descriptor).TypeArgsLen());
    ASSERT(res->is_static_call());
    return res;
  }
 
  const auto& ic_data = ICData::ZoneHandle(
      zone(), ICData::NewForStaticCall(parsed_function().function(), target,
                                       arguments_descriptor, deopt_id,
                                       num_args_tested, rebind_rule));
  if (deopt_id_to_ic_data_ != nullptr) {
    (*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
  }
  return &ic_data;
}

◆ InitCompiler()

void dart::FlowGraphCompiler::InitCompiler ( )

Definition at line 210 of file flow_graph_compiler.cc.

                                     {
  compressed_stackmaps_builder_ =
      new (zone()) CompressedStackMapsBuilder(zone());
  pc_descriptors_list_ = new (zone()) DescriptorList(
      zone(), &code_source_map_builder_->inline_id_to_function());
  exception_handlers_list_ =
      new (zone()) ExceptionHandlerList(parsed_function().function());
#if defined(DART_PRECOMPILER)
  catch_entry_moves_maps_builder_ = new (zone()) CatchEntryMovesMapBuilder();
#endif
  block_info_.Clear();
  // Initialize block info and search optimized (non-OSR) code for calls
  // indicating a non-leaf routine and calls without IC data indicating
  // possible reoptimization.
 
  for (int i = 0; i < block_order_.length(); ++i) {
    block_info_.Add(new (zone()) BlockInfo());
    if (is_optimizing() && !flow_graph().IsCompiledForOsr()) {
      BlockEntryInstr* entry = block_order_[i];
      for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
        Instruction* current = it.Current();
        if (auto* branch = current->AsBranch()) {
          current = branch->comparison();
        }
        if (auto* instance_call = current->AsInstanceCall()) {
          const ICData* ic_data = instance_call->ic_data();
          if ((ic_data == nullptr) || (ic_data->NumberOfUsedChecks() == 0)) {
            may_reoptimize_ = true;
          }
        }
      }
    }
  }
 
  if (!is_optimizing() && FLAG_reorder_basic_blocks) {
    // Initialize edge counter array.
    const intptr_t num_counters = flow_graph_.preorder().length();
    const Array& edge_counters =
        Array::Handle(Array::New(num_counters, Heap::kOld));
    for (intptr_t i = 0; i < num_counters; ++i) {
      edge_counters.SetAt(i, Object::smi_zero());
    }
    edge_counters_array_ = edge_counters.ptr();
  }
}

◆ InliningIdToFunction()

ArrayPtr dart::FlowGraphCompiler::InliningIdToFunction ( ) const

◆ InsertBSSRelocation()

void dart::FlowGraphCompiler::InsertBSSRelocation ( BSS::Relocation reloc )

Definition at line 269 of file flow_graph_compiler.cc.

                                                               {
  const intptr_t offset = assembler()->InsertAlignedRelocation(reloc);
  AddDescriptor(UntaggedPcDescriptors::kBSSRelocation, /*pc_offset=*/offset,
                /*deopt_id=*/DeoptId::kNone, InstructionSource(),
                /*try_index=*/-1);
}

◆ int32x4_class()

const Class & dart::FlowGraphCompiler::int32x4_class ( ) const

inline

Definition at line 848 of file flow_graph_compiler.h.

848{ return int32x4_class_; }

◆ intrinsic_mode()

bool dart::FlowGraphCompiler::intrinsic_mode ( ) const

inline

Definition at line 443 of file flow_graph_compiler.h.

443{ return intrinsic_mode_; }

◆ intrinsic_slow_path_label()

compiler::Label * dart::FlowGraphCompiler::intrinsic_slow_path_label ( ) const

inline

Definition at line 453 of file flow_graph_compiler.h.

                                                   {
    ASSERT(intrinsic_slow_path_label_ != nullptr);
    return intrinsic_slow_path_label_;
  }

◆ is_optimizing()

bool dart::FlowGraphCompiler::is_optimizing ( ) const

inline

Definition at line 427 of file flow_graph_compiler.h.

427{ return is_optimizing_; }

◆ IsEmptyBlock()

bool dart::FlowGraphCompiler::IsEmptyBlock ( BlockEntryInstr * block ) const

Definition at line 299 of file flow_graph_compiler.cc.

                                                                 {
  // Entry-points cannot be merged because they must have assembly
  // prologue emitted which should not be included in any block they jump to.
  return !block->IsGraphEntry() && !block->IsFunctionEntry() &&
         !block->IsCatchBlockEntry() && !block->IsOsrEntry() &&
         !block->IsIndirectEntry() && !block->HasNonRedundantParallelMove() &&
         block->next()->IsGoto() &&
         !block->next()->AsGoto()->HasNonRedundantParallelMove();
}

◆ isolate_group()

IsolateGroup * dart::FlowGraphCompiler::isolate_group ( ) const

inline

Definition at line 913 of file flow_graph_compiler.h.

913{ return thread_->isolate_group(); }

◆ LoadBSSEntry()

void dart::FlowGraphCompiler::LoadBSSEntry	(	BSS::Relocation	relocation,
		Register	dst,
		Register	tmp
	)

◆ LookupMethodFor()

bool dart::FlowGraphCompiler::LookupMethodFor	(	int	class_id,
		const String &	name,
		const ArgumentsDescriptor &	args_desc,
		Function *	fn_return,
		bool *	class_is_abstract_return = `nullptr`
	)

static

Definition at line 2021 of file flow_graph_compiler.cc.

                                                                        {
  auto thread = Thread::Current();
  auto zone = thread->zone();
  auto class_table = thread->isolate_group()->class_table();
  if (class_id < 0) return false;
  if (class_id >= class_table->NumCids()) return false;
 
  ClassPtr raw_class = class_table->At(class_id);
  if (raw_class == nullptr) return false;
  Class& cls = Class::Handle(zone, raw_class);
  if (cls.IsNull()) return false;
  if (!cls.is_finalized()) return false;
  if (Array::Handle(cls.current_functions()).IsNull()) return false;
 
  if (class_is_abstract_return != nullptr) {
    *class_is_abstract_return = cls.is_abstract();
  }
  Function& target_function =
      Function::Handle(zone, Resolver::ResolveDynamicForReceiverClass(
                                 cls, name, args_desc, /*allow_add=*/false));
  if (target_function.IsNull()) return false;
  *fn_return = target_function.ptr();
  return true;
}

◆ may_reoptimize()

bool dart::FlowGraphCompiler::may_reoptimize ( ) const

inline

Definition at line 884 of file flow_graph_compiler.h.

884{ return may_reoptimize_; }

◆ mint_class()

const Class & dart::FlowGraphCompiler::mint_class ( ) const

inline

Definition at line 845 of file flow_graph_compiler.h.

845{ return mint_class_; }

◆ NeedsEdgeCounter()

bool dart::FlowGraphCompiler::NeedsEdgeCounter ( BlockEntryInstr * block )

Definition at line 1630 of file flow_graph_compiler.cc.

                                                               {
  // Only emit an edge counter if there is not goto at the end of the block,
  // except for the entry block.
  return FLAG_reorder_basic_blocks &&
         (!block->last_instruction()->IsGoto() || block->IsFunctionEntry());
}

◆ NextNonEmptyLabel()

compiler::Label * dart::FlowGraphCompiler::NextNonEmptyLabel ( ) const

Definition at line 843 of file flow_graph_compiler.cc.

                                                          {
  const intptr_t current_index = current_block()->postorder_number();
  return block_info_[current_index]->next_nonempty_label();
}

◆ parsed_function()

const ParsedFunction & dart::FlowGraphCompiler::parsed_function ( ) const

inline

Definition at line 400 of file flow_graph_compiler.h.

400{ return parsed_function_; }

◆ RecordCatchEntryMoves()

void dart::FlowGraphCompiler::RecordCatchEntryMoves ( Environment * env )

Definition at line 427 of file flow_graph_compiler.cc.

                                                              {
#if defined(DART_PRECOMPILER)
  const intptr_t try_index = CurrentTryIndex();
  if (is_optimizing() && env != nullptr && (try_index != kInvalidTryIndex)) {
    env = env->Outermost();
    CatchBlockEntryInstr* catch_block =
        flow_graph().graph_entry()->GetCatchEntry(try_index);
    const GrowableArray<Definition*>* idefs =
        catch_block->initial_definitions();
    catch_entry_moves_maps_builder_->NewMapping(assembler()->CodeSize());
 
    for (intptr_t i = 0; i < flow_graph().variable_count(); ++i) {
      // Don't sync captured parameters. They are not in the environment.
      if (flow_graph().captured_parameters()->Contains(i)) continue;
      auto param = (*idefs)[i]->AsParameter();
 
      // Don't sync values that have been replaced with constants.
      if (param == nullptr) continue;
      RELEASE_ASSERT(param->env_index() == i);
      Location dst = param->location();
 
      // Don't sync exception or stack trace variables.
      if (dst.IsRegister()) continue;
 
      Location src = env->LocationAt(i);
      // Can only occur if AllocationSinking is enabled - and it is disabled
      // in functions with try.
      ASSERT(!src.IsInvalid());
      const Representation src_type =
          env->ValueAt(i)->definition()->representation();
      const auto move = CatchEntryMoveFor(assembler(), src_type, src,
                                          LocationToStackIndex(dst));
      if (!move.IsRedundant()) {
        catch_entry_moves_maps_builder_->Append(move);
      }
    }
 
    catch_entry_moves_maps_builder_->EndMapping();
  }
#endif  // defined(DART_PRECOMPILER)
}

◆ RecordSafepoint()

void dart::FlowGraphCompiler::RecordSafepoint	(	LocationSummary *	locs,
		intptr_t	slow_path_argument_count = `0`
	)

Definition at line 1047 of file flow_graph_compiler.cc.

                                                                           {
  if (is_optimizing() || locs->live_registers()->HasUntaggedValues()) {
    const intptr_t spill_area_size =
        is_optimizing() ? flow_graph_.graph_entry()->spill_slot_count() : 0;
 
    RegisterSet* registers = locs->live_registers();
    ASSERT(registers != nullptr);
    const intptr_t kFpuRegisterSpillFactor =
        kFpuRegisterSize / compiler::target::kWordSize;
    const bool using_shared_stub = locs->call_on_shared_slow_path();
 
    BitmapBuilder bitmap(locs->stack_bitmap());
 
    // Expand the bitmap to cover the whole area reserved for spill slots.
    // (register allocator takes care of marking slots containing live tagged
    // values but it does not do the same for other slots so length might be
    // below spill_area_size at this point).
    RELEASE_ASSERT(bitmap.Length() <= spill_area_size);
    bitmap.SetLength(spill_area_size);
 
    auto instr = current_instruction();
    const intptr_t args_count = instr->ArgumentCount();
    RELEASE_ASSERT(args_count == 0 || is_optimizing());
 
    for (intptr_t i = 0; i < args_count; i++) {
      const auto move_arg =
          instr->ArgumentValueAt(i)->instruction()->AsMoveArgument();
      const auto rep = move_arg->representation();
      if (move_arg->is_register_move()) {
        continue;
      }
 
      ASSERT(rep == kTagged || rep == kUnboxedInt64 || rep == kUnboxedDouble);
      static_assert(compiler::target::kIntSpillFactor ==
                        compiler::target::kDoubleSpillFactor,
                    "int and double are of the same size");
      const bool is_tagged = move_arg->representation() == kTagged;
      const intptr_t num_bits =
          is_tagged ? 1 : compiler::target::kIntSpillFactor;
 
      // Note: bits are reversed so higher bit corresponds to lower word.
      const intptr_t last_arg_bit =
          (spill_area_size - 1) - move_arg->sp_relative_index();
      bitmap.SetRange(last_arg_bit - (num_bits - 1), last_arg_bit, is_tagged);
    }
    ASSERT(slow_path_argument_count == 0 || !using_shared_stub);
    RELEASE_ASSERT(bitmap.Length() == spill_area_size);
 
    // Trim the fully tagged suffix. Stack walking assumes that everything
    // not included into the stack map is tagged.
    intptr_t spill_area_bits = bitmap.Length();
    while (spill_area_bits > 0) {
      if (!bitmap.Get(spill_area_bits - 1)) {
        break;
      }
      spill_area_bits--;
    }
    bitmap.SetLength(spill_area_bits);
 
    // Mark the bits in the stack map in the same order we push registers in
    // slow path code (see FlowGraphCompiler::SaveLiveRegisters).
    //
    // Slow path code can have registers at the safepoint.
    if (!locs->always_calls() && !using_shared_stub) {
      RegisterSet* regs = locs->live_registers();
      if (regs->FpuRegisterCount() > 0) {
        // Denote FPU registers with 0 bits in the stackmap.  Based on the
        // assumption that there are normally few live FPU registers, this
        // encoding is simpler and roughly as compact as storing a separate
        // count of FPU registers.
        //
        // FPU registers have the highest register number at the highest
        // address (i.e., first in the stackmap).
        for (intptr_t i = kNumberOfFpuRegisters - 1; i >= 0; --i) {
          FpuRegister reg = static_cast<FpuRegister>(i);
          if (regs->ContainsFpuRegister(reg)) {
            for (intptr_t j = 0; j < kFpuRegisterSpillFactor; ++j) {
              bitmap.Set(bitmap.Length(), false);
            }
          }
        }
      }
 
      // General purpose registers have the highest register number at the
      // highest address (i.e., first in the stackmap).
      for (intptr_t i = kNumberOfCpuRegisters - 1; i >= 0; --i) {
        Register reg = static_cast<Register>(i);
        if (locs->live_registers()->ContainsRegister(reg)) {
          bitmap.Set(bitmap.Length(), locs->live_registers()->IsTagged(reg));
        }
      }
    }
 
    if (using_shared_stub) {
      // To simplify the code in the shared stub, we create an untagged hole
      // in the stack frame where the shared stub can leave the return address
      // before saving registers.
      bitmap.Set(bitmap.Length(), false);
      if (registers->FpuRegisterCount() > 0) {
        bitmap.SetRange(bitmap.Length(),
                        bitmap.Length() +
                            kNumberOfFpuRegisters * kFpuRegisterSpillFactor - 1,
                        false);
      }
      for (intptr_t i = kNumberOfCpuRegisters - 1; i >= 0; --i) {
        if ((kReservedCpuRegisters & (1 << i)) != 0) continue;
        const Register reg = static_cast<Register>(i);
        bitmap.Set(bitmap.Length(),
                   locs->live_registers()->ContainsRegister(reg) &&
                       locs->live_registers()->IsTagged(reg));
      }
    }
 
    // Arguments pushed after live registers in the slow path are tagged.
    for (intptr_t i = 0; i < slow_path_argument_count; ++i) {
      bitmap.Set(bitmap.Length(), true);
    }
 
    compressed_stackmaps_builder_->AddEntry(assembler()->CodeSize(), &bitmap,
                                            spill_area_bits);
  }
}

◆ ResolveCallTargetsForReceiverCid()

const CallTargets * dart::FlowGraphCompiler::ResolveCallTargetsForReceiverCid	(	intptr_t	cid,
		const String &	selector,
		const Array &	args_desc_array
	)

static

Definition at line 2003 of file flow_graph_compiler.cc.

                                  {
  Zone* zone = Thread::Current()->zone();
 
  ArgumentsDescriptor args_desc(args_desc_array);
 
  Function& fn = Function::ZoneHandle(zone);
  if (!LookupMethodFor(cid, selector, args_desc, &fn)) return nullptr;
 
  CallTargets* targets = new (zone) CallTargets(zone);
  targets->Add(new (zone) TargetInfo(cid, cid, &fn, /* count = */ 1,
                                     StaticTypeExactnessState::NotTracking()));
 
  return targets;
}

◆ RestoreLiveRegisters()

void dart::FlowGraphCompiler::RestoreLiveRegisters ( LocationSummary * locs )

◆ SaveLiveRegisters()

void dart::FlowGraphCompiler::SaveLiveRegisters ( LocationSummary * locs )

◆ set_current_block()

void dart::FlowGraphCompiler::set_current_block ( BlockEntryInstr * value )

inline

Definition at line 420 of file flow_graph_compiler.h.

420{ current_block_ = value; }

value

uint8_t value

Definition: fl_standard_message_codec.cc:36

◆ set_intrinsic_flow_graph()

void dart::FlowGraphCompiler::set_intrinsic_flow_graph ( const FlowGraph & flow_graph )

inline

Definition at line 445 of file flow_graph_compiler.h.

                                                             {
    intrinsic_flow_graph_ = &flow_graph;
  }

◆ set_intrinsic_slow_path_label()

void dart::FlowGraphCompiler::set_intrinsic_slow_path_label ( compiler::Label * label )

inline

Definition at line 449 of file flow_graph_compiler.h.

                                                           {
    ASSERT(intrinsic_slow_path_label_ == nullptr || label == nullptr);
    intrinsic_slow_path_label_ = label;
  }

◆ SetNeedsStackTrace()

void dart::FlowGraphCompiler::SetNeedsStackTrace ( intptr_t try_index )

Definition at line 913 of file flow_graph_compiler.cc.

                                                             {
  exception_handlers_list_->SetNeedsStackTrace(try_index);
}

◆ skip_body_compilation()

bool dart::FlowGraphCompiler::skip_body_compilation ( ) const

inline

Definition at line 437 of file flow_graph_compiler.h.

                                     {
    return fully_intrinsified_ && is_optimizing();
  }

◆ SlowPathEnvironmentFor() [1/2]

Environment * dart::FlowGraphCompiler::SlowPathEnvironmentFor	(	Environment *	env,
		LocationSummary *	locs,
		intptr_t	num_slow_path_args
	)

Definition at line 1177 of file flow_graph_compiler.cc.

                                 {
  const bool using_shared_stub = locs->call_on_shared_slow_path();
  const bool shared_stub_save_fpu_registers =
      using_shared_stub && locs->live_registers()->FpuRegisterCount() > 0;
  // TODO(sjindel): Modify logic below to account for slow-path args with shared
  // stubs.
  ASSERT(!using_shared_stub || num_slow_path_args == 0);
  if (env == nullptr) {
    // In AOT, environments can be removed by EliminateEnvironments pass
    // (if not in a try block).
    ASSERT(!is_optimizing() || FLAG_precompiled_mode);
    return nullptr;
  }
 
  Environment* slow_path_env =
      env->DeepCopy(zone(), env->Length() - env->LazyDeoptPruneCount());
  // 1. Iterate the registers in the order they will be spilled to compute
  //    the slots they will be spilled to.
  intptr_t next_slot = StackSize() + slow_path_env->CountArgsPushed();
  if (using_shared_stub) {
    // The PC from the call to the shared stub is pushed here.
    next_slot++;
  }
  RegisterSet* regs = locs->live_registers();
  intptr_t fpu_reg_slots[kNumberOfFpuRegisters];
  intptr_t cpu_reg_slots[kNumberOfCpuRegisters];
  const intptr_t kFpuRegisterSpillFactor =
      kFpuRegisterSize / compiler::target::kWordSize;
  // FPU registers are spilled first from highest to lowest register number.
  for (intptr_t i = kNumberOfFpuRegisters - 1; i >= 0; --i) {
    FpuRegister reg = static_cast<FpuRegister>(i);
    if (regs->ContainsFpuRegister(reg)) {
      // We use the lowest address (thus highest index) to identify a
      // multi-word spill slot.
      next_slot += kFpuRegisterSpillFactor;
      fpu_reg_slots[i] = (next_slot - 1);
    } else {
      if (using_shared_stub && shared_stub_save_fpu_registers) {
        next_slot += kFpuRegisterSpillFactor;
      }
      fpu_reg_slots[i] = -1;
    }
  }
  // General purpose registers are spilled from highest to lowest register
  // number.
  for (intptr_t i = kNumberOfCpuRegisters - 1; i >= 0; --i) {
    if ((kReservedCpuRegisters & (1 << i)) != 0) continue;
    Register reg = static_cast<Register>(i);
    if (regs->ContainsRegister(reg)) {
      cpu_reg_slots[i] = next_slot++;
    } else {
      if (using_shared_stub) next_slot++;
      cpu_reg_slots[i] = -1;
    }
  }
 
  // 2. Iterate the environment and replace register locations with the
  //    corresponding spill slot locations.
  for (Environment::DeepIterator it(slow_path_env); !it.Done(); it.Advance()) {
    Location loc = it.CurrentLocation();
    Value* value = it.CurrentValue();
    it.SetCurrentLocation(LocationRemapForSlowPath(
        loc, value->definition(), cpu_reg_slots, fpu_reg_slots));
  }
 
  return slow_path_env;
}

◆ SlowPathEnvironmentFor() [2/2]

Environment * dart::FlowGraphCompiler::SlowPathEnvironmentFor	(	Instruction *	inst,
		intptr_t	num_slow_path_args
	)

inline

Definition at line 860 of file flow_graph_compiler.h.

                                                                   {
    if (inst->env() == nullptr && is_optimizing()) {
      if (pending_deoptimization_env_ == nullptr) {
        return nullptr;
      }
      return SlowPathEnvironmentFor(pending_deoptimization_env_, inst->locs(),
                                    num_slow_path_args);
    }
    return SlowPathEnvironmentFor(inst->env(), inst->locs(),
                                  num_slow_path_args);
  }

◆ SpecialStatsBegin()

void dart::FlowGraphCompiler::SpecialStatsBegin ( intptr_t tag )

inline

Definition at line 470 of file flow_graph_compiler.h.

                                       {
    if (stats_ != nullptr) stats_->SpecialBegin(tag);
  }

◆ SpecialStatsEnd()

void dart::FlowGraphCompiler::SpecialStatsEnd ( intptr_t tag )

inline

Definition at line 474 of file flow_graph_compiler.h.

                                     {
    if (stats_ != nullptr) stats_->SpecialEnd(tag);
  }

◆ StackSize()

intptr_t dart::FlowGraphCompiler::StackSize ( ) const

Definition at line 816 of file flow_graph_compiler.cc.

                                            {
  if (is_optimizing_) {
    return flow_graph_.graph_entry()->spill_slot_count();
  } else {
    return parsed_function_.num_stack_locals();
  }
}

◆ StatsBegin()

void dart::FlowGraphCompiler::StatsBegin ( Instruction * instr )

inline

Definition at line 462 of file flow_graph_compiler.h.

                                      {
    if (stats_ != nullptr) stats_->Begin(instr);
  }

◆ StatsEnd()

void dart::FlowGraphCompiler::StatsEnd ( Instruction * instr )

inline

Definition at line 466 of file flow_graph_compiler.h.

                                    {
    if (stats_ != nullptr) stats_->End(instr);
  }

◆ SupportsUnboxedSimd128()

static bool dart::FlowGraphCompiler::SupportsUnboxedSimd128 ( )

static

◆ thread()

Thread * dart::FlowGraphCompiler::thread ( ) const

inline

Definition at line 912 of file flow_graph_compiler.h.

912{ return thread_; }

◆ TryIntrinsify()

bool dart::FlowGraphCompiler::TryIntrinsify ( )

Definition at line 1432 of file flow_graph_compiler.cc.

                                      {
  if (TryIntrinsifyHelper()) {
    fully_intrinsified_ = true;
    return true;
  }
  return false;
}

◆ used_static_fields()

GrowableArray< const Field * > & dart::FlowGraphCompiler::used_static_fields ( )

inline

Definition at line 478 of file flow_graph_compiler.h.

                                                    {
    return used_static_fields_;
  }

◆ VisitBlocks()

void dart::FlowGraphCompiler::VisitBlocks ( )

Definition at line 670 of file flow_graph_compiler.cc.

                                    {
  CompactBlocks();
  if (compiler::Assembler::EmittingComments()) {
    // The loop_info fields were cleared, recompute.
    flow_graph().ComputeLoops();
  }
 
  // In precompiled mode, we require the function entry to come first (after the
  // graph entry), since the polymorphic check is performed in the function
  // entry (see Instructions::EntryPoint).
  if (FLAG_precompiled_mode) {
    ASSERT(block_order()[1] == flow_graph().graph_entry()->normal_entry());
  }
 
#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
  const auto inner_lr_state = ComputeInnerLRState(flow_graph());
#endif  // defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
 
#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
  const bool should_align_loops =
      FLAG_align_all_loops || IsMarkedWithAlignLoops(function());
#endif  // defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
 
  for (intptr_t i = 0; i < block_order().length(); ++i) {
    // Compile the block entry.
    BlockEntryInstr* entry = block_order()[i];
    assembler()->Comment("B%" Pd "", entry->block_id());
    set_current_block(entry);
 
    if (WasCompacted(entry)) {
      continue;
    }
 
#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
    // At the start of every non-entry block we expect return address either
    // to be  spilled into the frame or to be in the LR register.
    if (entry->IsFunctionEntry() || entry->IsNativeEntry()) {
      assembler()->set_lr_state(compiler::LRState::OnEntry());
    } else {
      assembler()->set_lr_state(inner_lr_state);
    }
#endif  // defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
 
#if defined(DEBUG)
    if (!is_optimizing()) {
      FrameStateClear();
    }
#endif
 
    if (compiler::Assembler::EmittingComments()) {
      for (LoopInfo* l = entry->loop_info(); l != nullptr; l = l->outer()) {
        assembler()->Comment("  Loop %" Pd "", l->id());
      }
      if (entry->IsLoopHeader()) {
        assembler()->Comment("  Loop Header");
      }
    }
 
#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
    if (should_align_loops && entry->IsLoopHeader() &&
        kPreferredLoopAlignment > 1) {
      assembler()->mark_should_be_aligned();
      assembler()->Align(kPreferredLoopAlignment, 0);
    }
#else
    static_assert(kPreferredLoopAlignment == 1);
#endif  // defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
 
    BeginCodeSourceRange(entry->source());
    ASSERT(pending_deoptimization_env_ == nullptr);
    pending_deoptimization_env_ = entry->env();
    set_current_instruction(entry);
    StatsBegin(entry);
    entry->EmitNativeCode(this);
    StatsEnd(entry);
    set_current_instruction(nullptr);
    pending_deoptimization_env_ = nullptr;
    EndCodeSourceRange(entry->source());
 
    if (skip_body_compilation()) {
      ASSERT(entry == flow_graph().graph_entry()->normal_entry());
      break;
    }
 
    // Compile all successors until an exit, branch, or a block entry.
    for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
      Instruction* instr = it.Current();
      set_current_instruction(instr);
      StatsBegin(instr);
      // Unoptimized code always stores boxed values on the expression stack.
      // However, unboxed representation is allowed for instruction inputs and
      // outputs of certain types (e.g. for doubles).
      // Unboxed inputs/outputs are handled in the instruction prologue
      // and epilogue, but flagged as a mismatch on the IL level.
      RELEASE_ASSERT(!is_optimizing() ||
                     !instr->HasUnmatchedInputRepresentations());
 
      if (FLAG_code_comments || FLAG_disassemble ||
          FLAG_disassemble_optimized) {
        if (FLAG_source_lines) {
          EmitSourceLine(instr);
        }
        EmitComment(instr);
      }
 
      BeginCodeSourceRange(instr->source());
      EmitInstructionPrologue(instr);
      ASSERT(pending_deoptimization_env_ == nullptr);
      pending_deoptimization_env_ = instr->env();
      DEBUG_ONLY(current_instruction_ = instr);
      instr->EmitNativeCode(this);
      DEBUG_ONLY(current_instruction_ = nullptr);
      pending_deoptimization_env_ = nullptr;
      if (IsPeephole(instr)) {
        ASSERT(top_of_stack_ == nullptr);
        top_of_stack_ = instr->AsDefinition();
      } else {
        EmitInstructionEpilogue(instr);
      }
      EndCodeSourceRange(instr->source());
 
#if defined(DEBUG)
      if (!is_optimizing()) {
        FrameStateUpdateWith(instr);
      }
#endif
      StatsEnd(instr);
      set_current_instruction(nullptr);
 
      if (auto indirect_goto = instr->AsIndirectGoto()) {
        indirect_gotos_.Add(indirect_goto);
      }
    }
 
#if defined(DEBUG)
    ASSERT(is_optimizing() || FrameStateIsSafeToCall());
#endif
  }
 
  set_current_block(nullptr);
}

◆ WasCompacted()

bool dart::FlowGraphCompiler::WasCompacted ( BlockEntryInstr * block_entry ) const

Definition at line 838 of file flow_graph_compiler.cc.

                                                                       {
  const intptr_t block_index = block_entry->postorder_number();
  return block_info_[block_index]->WasCompacted();
}

◆ zone()

Zone * dart::FlowGraphCompiler::zone ( ) const

inline

Definition at line 914 of file flow_graph_compiler.h.

914{ return zone_; }

Friends And Related Function Documentation

◆ BoxInt64Instr

friend class BoxInt64Instr

friend

Definition at line 954 of file flow_graph_compiler.h.

◆ CheckNullInstr

friend class CheckNullInstr

friend

Definition at line 955 of file flow_graph_compiler.h.

◆ CheckStackOverflowInstr

friend class CheckStackOverflowInstr

friend

Definition at line 957 of file flow_graph_compiler.h.

◆ CheckStackOverflowSlowPath

friend class CheckStackOverflowSlowPath

friend

Definition at line 960 of file flow_graph_compiler.h.

◆ GraphIntrinsicCodeGenScope

friend class GraphIntrinsicCodeGenScope

friend

Definition at line 961 of file flow_graph_compiler.h.

◆ NullErrorSlowPath

friend class NullErrorSlowPath

friend

Definition at line 956 of file flow_graph_compiler.h.

◆ StoreFieldInstr

friend class StoreFieldInstr

friend

Definition at line 959 of file flow_graph_compiler.h.

◆ StoreIndexedInstr

friend class StoreIndexedInstr

friend

Definition at line 958 of file flow_graph_compiler.h.

Member Data Documentation

◆ kMaxNumberOfCidRangesToTest

constexpr intptr_t dart::FlowGraphCompiler::kMaxNumberOfCidRangesToTest = 4

staticconstexpr

Definition at line 650 of file flow_graph_compiler.h.

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

third_party/dart-lang/sdk/runtime/vm/compiler/backend/flow_graph_compiler.h
third_party/dart-lang/sdk/runtime/vm/compiler/backend/flow_graph_compiler.cc

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ FlowGraphCompiler()

◆ ~FlowGraphCompiler()

Member Function Documentation

◆ AddCurrentDescriptor()

◆ AddDeoptIndexAtCall()

◆ AddDeoptStub()

◆ AddDescriptor()

◆ AddDispatchTableCallTarget()

◆ AddExceptionHandler()

◆ AddNullCheck()

◆ AddSlowPathCode()

◆ AddSlowPathDeoptInfo()

◆ AddStubCallTarget()

◆ ArchSpecificInitialization()

◆ assembler()

◆ Bailout()

◆ BeginCodeSourceRange()

◆ block_info()

◆ block_order()

◆ BoxClassFor()

◆ CanConvertInt64ToDouble()

◆ CanFallThroughTo()

◆ CanOptimize()

◆ CanOptimizeFunction()

◆ CanOSRFunction()

◆ CheckAssertAssignableTypeTestingABILocations()

◆ CompileGraph()

◆ CreateBranchLabels()

◆ CreateDeoptInfo()

◆ current_block()

◆ current_instruction()

◆ CurrentTryIndex()

◆ deopt_id_to_ic_data()

◆ dispatch_table_call_targets()

◆ double_class()

◆ edge_counters_array()

◆ EmitBoolTest()

◆ EmitCallsiteMetadata()

◆ EmitCallToStub()

◆ EmitComment()

◆ EmitDispatchTableCall()

◆ EmitDropArguments()

◆ EmitEdgeCounter()

◆ EmitEqualityRegConstCompare()

◆ EmitEqualityRegRegCompare()

◆ EmitFunctionEntrySourcePositionDescriptorIfNeeded()

◆ EmitInstanceCallAOT()

◆ EmitInstanceCallJIT()

◆ EmitJumpToStub()

◆ EmitMegamorphicInstanceCall() [1/2]

◆ EmitMegamorphicInstanceCall() [2/2]

◆ EmitMove()

◆ EmitMoveConst()

◆ EmitMoveFromNative()

◆ EmitMoveToNative()

◆ EmitNativeMove()

◆ EmitOptimizedInstanceCall()

◆ EmitOptimizedStaticCall()

◆ EmitPolymorphicInstanceCall()

◆ EmitPrologue()

◆ EmitTailCallToStub()

◆ EmitTestAndCall()

◆ EmitTestAndCallCheckCid()

◆ EmitYieldPositionMetadata()

◆ EndCodeSourceRange()

◆ EnterIntrinsicMode()

◆ ExitIntrinsicMode()

◆ ExtraStackSlotsOnOsrEntry()

◆ FinalizeCatchEntryMovesMap()

◆ FinalizeCodeSourceMap()

◆ FinalizeExceptionHandlers()

◆ FinalizePcDescriptors()

◆ FinalizeStackMaps()

◆ FinalizeStaticCallTargetsTable()