#include <prologue_builder.h>

Inheritance diagram for dart::kernel::PrologueBuilder:

Public Member Functions
	PrologueBuilder (const ParsedFunction *parsed_function, intptr_t last_used_id, bool compiling_for_osr, bool is_inlining)

BlockEntryInstr *	BuildPrologue (BlockEntryInstr entry, PrologueInfo prologue_info)

Fragment	BuildParameterHandling ()

intptr_t	last_used_block_id () const

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

const Array &	coverage_array () const

void	FinalizeCoverageArray ()

Fragment	LoadField (const Field &field, bool calls_initializer)

Fragment	LoadNativeField (const Slot &native_field, InnerPointerAccess loads_inner_pointer, bool calls_initializer=false)

Fragment	LoadNativeField (const Slot &native_field, bool calls_initializer=false)

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

Fragment	GenericCheckBound ()

Fragment	LoadUntagged (intptr_t offset)

Fragment	CalculateElementAddress (intptr_t index_scale)

Fragment	ConvertUntaggedToUnboxed ()

Fragment	ConvertUnboxedToUntagged ()

Fragment	FloatToDouble ()

Fragment	DoubleToFloat ()

void	SetTempIndex (Definition *definition)

Fragment	LoadLocal (LocalVariable *variable)

Fragment	StoreLocal (LocalVariable *variable)

Fragment	StoreLocal (TokenPosition position, LocalVariable *variable)

Fragment	StoreLocalRaw (TokenPosition position, LocalVariable *variable)

Fragment	LoadContextAt (int depth)

Fragment	GuardFieldLength (const Field &field, intptr_t deopt_id)

Fragment	GuardFieldClass (const Field &field, intptr_t deopt_id)

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

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

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

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

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

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

Fragment	LoadStaticField (const Field &field, bool calls_initializer)

Fragment	RedefinitionWithType (const AbstractType &type)

Fragment	ReachabilityFence ()

Fragment	StoreStaticField (TokenPosition position, const Field &field)

Fragment	StoreIndexed (classid_t class_id)

Fragment	StoreIndexedTypedData (classid_t class_id, intptr_t index_scale, bool index_unboxed, AlignmentType alignment=kAlignedAccess)

Fragment	Box (Representation from)

void	Push (Definition *definition)

Definition *	Peek (intptr_t depth=0)

Value *	Pop ()

Fragment	Drop ()

Fragment	DropTempsPreserveTop (intptr_t num_temps_to_drop)

Fragment	MakeTemp ()

LocalVariable *	MakeTemporary (const char *suffix=nullptr)

Fragment	DropTemporary (LocalVariable **temp)

InputsArray	GetArguments (int count)

TargetEntryInstr *	BuildTargetEntry ()

FunctionEntryInstr *	BuildFunctionEntry (GraphEntryInstr *graph_entry)

JoinEntryInstr *	BuildJoinEntry ()

JoinEntryInstr *	BuildJoinEntry (intptr_t try_index)

IndirectEntryInstr *	BuildIndirectEntry (intptr_t indirect_id, intptr_t try_index)

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

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

Fragment	Goto (JoinEntryInstr *destination)

Fragment	UnboxedIntConstant (int64_t value, Representation representation)

Fragment	IntConstant (int64_t value)

Fragment	Constant (const Object &value)

Fragment	NullConstant ()

Fragment	SmiRelationalOp (Token::Kind kind)

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

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

Fragment	LoadFpRelativeSlot (intptr_t offset, CompileType result_type, Representation representation=kTagged)

Fragment	StoreFpRelativeSlot (intptr_t offset)

Fragment	BranchIfTrue (TargetEntryInstr then_entry, TargetEntryInstr otherwise_entry, bool negate=false)

Fragment	BranchIfNull (TargetEntryInstr then_entry, TargetEntryInstr otherwise_entry, bool negate=false)

Fragment	BranchIfEqual (TargetEntryInstr then_entry, TargetEntryInstr otherwise_entry, bool negate=false)

Fragment	BranchIfStrictEqual (TargetEntryInstr then_entry, TargetEntryInstr otherwise_entry)

Fragment	Return (TokenPosition position)

Fragment	CheckStackOverflow (TokenPosition position, intptr_t stack_depth, intptr_t loop_depth)

Fragment	CheckStackOverflowInPrologue (TokenPosition position)

Fragment	MemoryCopy (classid_t src_cid, classid_t dest_cid, bool unboxed_inputs, bool can_overlap=true)

Fragment	TailCall (const Code &code)

Fragment	Utf8Scan ()

intptr_t	GetNextDeoptId ()

intptr_t	AllocateTryIndex ()

intptr_t	CurrentTryIndex () const

void	SetCurrentTryIndex (intptr_t try_index)

bool	IsCompiledForOsr ()

bool	IsInlining () const

void	InlineBailout (const char *reason)

Fragment	LoadArgDescriptor ()

Fragment	TestTypeArgsLen (Fragment eq_branch, Fragment neq_branch, intptr_t num_type_args)

Fragment	TestDelayedTypeArgs (LocalVariable *closure, Fragment present, Fragment absent)

Fragment	TestAnyTypeArgs (Fragment present, Fragment absent)

JoinEntryInstr *	BuildThrowNoSuchMethod ()

Fragment	ThrowException (TokenPosition position)

Fragment	AssertBool (TokenPosition position)

Fragment	BooleanNegate ()

Fragment	AllocateContext (const ZoneGrowableArray< const Slot * > &scope)

Fragment	AllocateClosure (TokenPosition position, bool has_instantiator_type_args, bool is_generic, bool is_tear_off)

Fragment	CreateArray ()

Fragment	AllocateRecord (TokenPosition position, RecordShape shape)

Fragment	AllocateSmallRecord (TokenPosition position, RecordShape shape)

Fragment	AllocateTypedData (TokenPosition position, classid_t class_id)

Fragment	InstantiateType (const AbstractType &type)

Fragment	InstantiateTypeArguments (const TypeArguments &type_arguments)

Fragment	InstantiateDynamicTypeArguments ()

Fragment	LoadClassId ()

bool	InliningUncheckedEntry () const

intptr_t	GetStackDepth () const

Fragment	AllocateObject (TokenPosition position, const Class &klass, intptr_t argument_count)

Fragment	DebugStepCheck (TokenPosition position)

Fragment	CheckNull (TokenPosition position, LocalVariable *receiver, const String &function_name)

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

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

Fragment	CheckNotDeeplyImmutable (CheckWritableInstr::Kind kind)

void	RecordUncheckedEntryPoint (GraphEntryInstr graph_entry, FunctionEntryInstr unchecked_entry)

Fragment	BuildEntryPointsIntrospection ()

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

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

bool	is_recording_context_levels () const

void	set_context_depth (intptr_t context_level)

void	reset_context_depth_for_deopt_id (intptr_t deopt_id)

Fragment	InitConstantParameters ()

Fragment	InvokeMathCFunction (MethodRecognizer::Kind recognized_kind, intptr_t num_inputs)

Fragment	DoubleToInteger (MethodRecognizer::Kind recognized_kind)

Fragment	UnaryDoubleOp (Token::Kind op)

Fragment	RecordCoverage (TokenPosition position)

Fragment	RecordBranchCoverage (TokenPosition position)

bool	has_saved_args_desc_array ()

const Array &	saved_args_desc_array ()

Static Public Member Functions
static bool	HasEmptyPrologue (const Function &function)

static bool	PrologueSkippableOnUncheckedEntry (const Function &function)

Static Public Member Functions inherited from dart::kernel::BaseFlowGraphBuilder
static const Field &	MayCloneField (Zone *zone, const Field &field)

Additional Inherited Members
Protected Member Functions inherited from dart::kernel::BaseFlowGraphBuilder
intptr_t	AllocateBlockId ()

Fragment	RecordCoverageImpl (TokenPosition position, bool is_branch_coverage)

intptr_t	GetCoverageIndexFor (intptr_t encoded_position)

Protected Attributes inherited from dart::kernel::BaseFlowGraphBuilder
const ParsedFunction *	parsed_function_

const Function &	function_

Thread *	thread_

Zone *	zone_

intptr_t	osr_id_

ZoneGrowableArray< intptr_t > *	context_level_array_

intptr_t	context_depth_

intptr_t	last_used_block_id_

intptr_t	current_try_index_

intptr_t	next_used_try_index_

Value *	stack_

InlineExitCollector *	exit_collector_

const bool	inlining_unchecked_entry_

const Array &	saved_args_desc_array_

GrowableArray< intptr_t >	coverage_array_positions_

Array &	coverage_array_

Detailed Description

Definition at line 39 of file prologue_builder.h.

Constructor & Destructor Documentation

◆ PrologueBuilder()

dart::kernel::PrologueBuilder::PrologueBuilder	(	const ParsedFunction *	parsed_function,
		intptr_t	last_used_id,
		bool	compiling_for_osr,
		bool	is_inlining
	)

inline

Definition at line 41 of file prologue_builder.h.

      : BaseFlowGraphBuilder(parsed_function, last_used_id),
        compiling_for_osr_(compiling_for_osr),
        is_inlining_(is_inlining) {}

Member Function Documentation

◆ BuildParameterHandling()

Fragment dart::kernel::PrologueBuilder::BuildParameterHandling ( )

Definition at line 96 of file prologue_builder.cc.

                                                 {
  Fragment copy_args_prologue;
  const int num_fixed_params = function_.num_fixed_parameters();
  const int num_opt_pos_params = function_.NumOptionalPositionalParameters();
  const int num_opt_named_params = function_.NumOptionalNamedParameters();
  const int num_params =
      num_fixed_params + num_opt_pos_params + num_opt_named_params;
  ASSERT(function_.NumParameters() == num_params);
 
  // This will contain information about registers assigned to fixed
  // parameters as well as their stack locations relative to callee FP
  // under the assumption that no other arguments were passed.
  compiler::ParameterInfoArray fixed_params(num_fixed_params);
  FlowGraph::ComputeLocationsOfFixedParameters(
      zone_, function_,
      /*should_assign_stack_locations=*/true, &fixed_params);
 
  // Check that min_num_pos_args <= num_pos_args <= max_num_pos_args,
  // where num_pos_args is the number of positional arguments passed in.
  const int min_num_pos_args = num_fixed_params;
 
  LocalVariable* count_var = nullptr;
  LocalVariable* optional_count_var = nullptr;
  if ((num_opt_pos_params > 0) || (num_opt_named_params > 0)) {
    copy_args_prologue += LoadArgDescriptor();
    copy_args_prologue +=
        LoadNativeField(Slot::ArgumentsDescriptor_positional_count());
 
    copy_args_prologue += LoadArgDescriptor();
    copy_args_prologue += LoadNativeField(Slot::ArgumentsDescriptor_count());
    count_var = MakeTemporary();
 
    copy_args_prologue += LoadLocal(count_var);
    copy_args_prologue += IntConstant(min_num_pos_args);
    copy_args_prologue += SmiBinaryOp(Token::kSUB, /* truncate= */ true);
    optional_count_var = MakeTemporary();
  }
 
  // Copy mandatory parameters down.
  intptr_t param = 0;
  for (; param < num_fixed_params; ++param) {
    const auto [location, representation] = fixed_params[param];
 
    const auto lo_location =
        location.IsPairLocation() ? location.AsPairLocation()->At(0) : location;
 
    if (lo_location.IsMachineRegister()) {
      continue;
    }
 
    if ((num_opt_pos_params > 0) || (num_opt_named_params > 0)) {
      copy_args_prologue += LoadLocal(optional_count_var);
    } else {
      copy_args_prologue += IntConstant(0);
    }
    const intptr_t stack_slot_offset = lo_location.ToStackSlotOffset();
    copy_args_prologue += LoadFpRelativeSlot(
        stack_slot_offset,
        ParameterType(ParameterVariable(param), representation),
        representation);
    copy_args_prologue +=
        StoreLocalRaw(TokenPosition::kNoSource, ParameterVariable(param));
    copy_args_prologue += Drop();
  }
 
  // Copy optional parameters down.
  if (num_opt_pos_params > 0) {
    JoinEntryInstr* next_missing = nullptr;
    for (intptr_t opt_param = 0; param < num_params; ++param, ++opt_param) {
      TargetEntryInstr *supplied, *missing;
      copy_args_prologue += IntConstant(opt_param + 1);
      copy_args_prologue += LoadLocal(optional_count_var);
      copy_args_prologue += SmiRelationalOp(Token::kLTE);
      copy_args_prologue += BranchIfTrue(&supplied, &missing);
 
      Fragment good(supplied);
      good += LoadLocal(optional_count_var);
      // Note: FP[param_end_from_fp + 1 + (optional_count_var - 1)] points to
      // the first optional parameter.
      good += LoadFpRelativeSlot(
          compiler::target::kWordSize *
              (compiler::target::frame_layout.param_end_from_fp - opt_param),
          ParameterType(ParameterVariable(param)));
      good += StoreLocalRaw(TokenPosition::kNoSource, ParameterVariable(param));
      good += Drop();
 
      Fragment not_good(missing);
      if (next_missing != nullptr) {
        not_good += Goto(next_missing);
        not_good.current = next_missing;
      }
      next_missing = BuildJoinEntry();
      not_good += Constant(DefaultParameterValueAt(opt_param));
      not_good +=
          StoreLocalRaw(TokenPosition::kNoSource, ParameterVariable(param));
      not_good += Drop();
      not_good += Goto(next_missing);
 
      copy_args_prologue.current = good.current;
    }
    copy_args_prologue += Goto(next_missing /* join good/not_good flows */);
    copy_args_prologue.current = next_missing;
 
  } else if (num_opt_named_params > 0) {
    const intptr_t first_name_offset =
        compiler::target::ArgumentsDescriptor::first_named_entry_offset() -
        compiler::target::Array::data_offset();
 
    // Start by alphabetically sorting the names of the optional parameters.
    int* opt_param_position = Z->Alloc<int>(num_opt_named_params);
    SortOptionalNamedParametersInto(opt_param_position, num_fixed_params,
                                    num_params);
 
    LocalVariable* optional_count_vars_processed =
        parsed_function_->expression_temp_var();
    ASSERT(optional_count_vars_processed != nullptr);
    copy_args_prologue += IntConstant(0);
    copy_args_prologue +=
        StoreLocalRaw(TokenPosition::kNoSource, optional_count_vars_processed);
    copy_args_prologue += Drop();
 
    for (intptr_t i = 0; param < num_params; ++param, ++i) {
      copy_args_prologue += IntConstant(
          compiler::target::ArgumentsDescriptor::named_entry_size() /
          compiler::target::kCompressedWordSize);
      copy_args_prologue += LoadLocal(optional_count_vars_processed);
      copy_args_prologue += SmiBinaryOp(Token::kMUL, /* truncate= */ true);
      LocalVariable* tuple_diff = MakeTemporary();
 
      // Let's load position from arg descriptor (to see which parameter is the
      // name) and move kEntrySize forward in ArgDescriptor names array.
      //
      // Later we'll either add this fragment directly to the copy_args_prologue
      // if no check is needed or add an appropriate check.
      Fragment good;
      {
        // fp[target::frame_layout.param_end_from_fp + (count_var - pos)]
        good += LoadLocal(count_var);
        {
          // pos = arg_desc[names_offset + arg_desc_name_index + positionOffset]
          good += LoadArgDescriptor();
          good += IntConstant(
              (first_name_offset +
               compiler::target::ArgumentsDescriptor::position_offset()) /
              compiler::target::kCompressedWordSize);
          good += LoadLocal(tuple_diff);
          good += SmiBinaryOp(Token::kADD, /* truncate= */ true);
          good += LoadIndexed(
              kArrayCid, /*index_scale*/ compiler::target::kCompressedWordSize);
        }
        good += SmiBinaryOp(Token::kSUB, /* truncate= */ true);
        good += LoadFpRelativeSlot(
            compiler::target::kWordSize *
                compiler::target::frame_layout.param_end_from_fp,
            ParameterType(ParameterVariable(opt_param_position[i])));
 
        // Copy down.
        good += StoreLocalRaw(TokenPosition::kNoSource,
                              ParameterVariable(opt_param_position[i]));
        good += Drop();
 
        // Increase processed optional variable count.
        good += LoadLocal(optional_count_vars_processed);
        good += IntConstant(1);
        good += SmiBinaryOp(Token::kADD, /* truncate= */ true);
        good += StoreLocalRaw(TokenPosition::kNoSource,
                              optional_count_vars_processed);
        good += Drop();
      }
 
      const bool required = function_.IsRequiredAt(opt_param_position[i]);
 
      if (required) {
        copy_args_prologue += good;
      } else {
        // name = arg_desc[names_offset + arg_desc_name_index + nameOffset]
        copy_args_prologue += LoadArgDescriptor();
        copy_args_prologue +=
            IntConstant((first_name_offset +
                         compiler::target::ArgumentsDescriptor::name_offset()) /
                        compiler::target::kCompressedWordSize);
        copy_args_prologue += LoadLocal(tuple_diff);
        copy_args_prologue += SmiBinaryOp(Token::kADD, /* truncate= */ true);
        copy_args_prologue += LoadIndexed(
            kArrayCid, /*index_scale*/ compiler::target::kCompressedWordSize);
 
        // first name in sorted list of all names
        const String& param_name = String::ZoneHandle(
            Z, function_.ParameterNameAt(opt_param_position[i]));
        ASSERT(param_name.IsSymbol());
        copy_args_prologue += Constant(param_name);
 
        // Compare the two names: Note that the ArgumentDescriptor array always
        // terminates with a "null" name (i.e. kNullCid), which will prevent us
        // from running out-of-bounds.
        TargetEntryInstr *supplied, *missing;
        copy_args_prologue += BranchIfStrictEqual(&supplied, &missing);
 
        // Join good/not_good.
        JoinEntryInstr* join = BuildJoinEntry();
 
        // Put good in the flowgraph as a separate basic block.
        good.Prepend(supplied);
        good += Goto(join);
 
        // We had no match, so load the default constant.
        Fragment not_good(missing);
        not_good += Constant(
            DefaultParameterValueAt(opt_param_position[i] - num_fixed_params));
 
        // Copy down with default value.
        not_good += StoreLocalRaw(TokenPosition::kNoSource,
                                  ParameterVariable(opt_param_position[i]));
        not_good += Drop();
        not_good += Goto(join);
 
        copy_args_prologue.current = join;
      }
 
      copy_args_prologue += Drop();  // tuple_diff
    }
  }
 
  if ((num_opt_pos_params > 0) || (num_opt_named_params > 0)) {
    copy_args_prologue += Drop();  // optional_count_var
    copy_args_prologue += Drop();  // count_var
    copy_args_prologue += Drop();  // positional_count_var
  }
 
  return copy_args_prologue;
}

◆ BuildPrologue()

BlockEntryInstr * dart::kernel::PrologueBuilder::BuildPrologue	(	BlockEntryInstr *	entry,
		PrologueInfo *	prologue_info
	)

Definition at line 47 of file prologue_builder.cc.

                                                                             {
  // We always have to build the graph, but we only link it sometimes.
  const bool link = !is_inlining_ && !compiling_for_osr_;
 
  const intptr_t previous_block_id = last_used_block_id_;
 
  const bool copy_parameters = function_.MakesCopyOfParameters();
  const bool expect_type_args = function_.IsGeneric();
 
  Fragment prologue = Fragment(entry);
 
  if (copy_parameters) {
    Fragment f = BuildParameterHandling();
    if (link) prologue += f;
  }
  if (function_.IsClosureFunction()) {
    Fragment f = BuildClosureContextHandling();
    if (!compiling_for_osr_) prologue += f;
  }
  if (expect_type_args) {
    Fragment f = BuildTypeArgumentsHandling();
    if (link) prologue += f;
 
    if (function_.IsClosureFunction()) {
      Fragment f = BuildClosureDelayedTypeArgumentsHandling();
      if (!compiling_for_osr_) prologue += f;
    }
  }
 
  const bool is_empty_prologue = prologue.entry == prologue.current;
  // Double-check we create empty prologues when HasEmptyPrologue returns true.
  ASSERT(!HasEmptyPrologue(function_) || is_empty_prologue);
 
  // Always do this to preserve deoptid numbering.
  JoinEntryInstr* normal_code = BuildJoinEntry();
  Fragment jump_to_normal_code = Goto(normal_code);
 
  if (is_empty_prologue) {
    *prologue_info = PrologueInfo(-1, -1);
    return entry;
  } else {
    prologue += jump_to_normal_code;
    *prologue_info =
        PrologueInfo(previous_block_id, normal_code->block_id() - 1);
    return normal_code;
  }
}

◆ HasEmptyPrologue()

bool dart::kernel::PrologueBuilder::HasEmptyPrologue ( const Function & function )

static

Definition at line 42 of file prologue_builder.cc.

                                                               {
  return !function.MakesCopyOfParameters() && !function.IsGeneric() &&
         !function.IsClosureFunction();
}

◆ last_used_block_id()

intptr_t dart::kernel::PrologueBuilder::last_used_block_id ( ) const

inline

Definition at line 57 of file prologue_builder.h.

57{ return last_used_block_id_; }

◆ PrologueSkippableOnUncheckedEntry()

bool dart::kernel::PrologueBuilder::PrologueSkippableOnUncheckedEntry ( const Function & function )

static

Definition at line 36 of file prologue_builder.cc.

                              {
  return !function.MakesCopyOfParameters() &&
         !function.IsNonImplicitClosureFunction() && !function.IsGeneric();
}

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

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

Public Member Functions

Static Public Member Functions

Additional Inherited Members