#include <flow_graph.h>

Inheritance diagram for dart::FlowGraph:

Classes
struct	LogicalAnd

Public Types
enum class	CompilationMode { kUnoptimized , kOptimized , kIntrinsic }

enum class	ToCheck { kNoCheck , kCheckNull , kCheckCid }

enum	UseKind { kEffect , kValue }

Public Member Functions
	FlowGraph (const ParsedFunction &parsed_function, GraphEntryInstr *graph_entry, intptr_t max_block_id, PrologueInfo prologue_info, CompilationMode compilation_mode)

const ParsedFunction &	parsed_function () const

const Function &	function () const

void	Print (const char *phase="unknown")

intptr_t	num_direct_parameters () const

intptr_t	variable_count () const

intptr_t	osr_variable_count () const

intptr_t	num_stack_locals () const

bool	IsIrregexpFunction () const

LocalVariable *	SuspendStateVar () const

intptr_t	SuspendStateEnvIndex () const

LocalVariable *	CurrentContextVar () const

intptr_t	CurrentContextEnvIndex () const

intptr_t	RawTypeArgumentEnvIndex () const

intptr_t	ArgumentDescriptorEnvIndex () const

intptr_t	EnvIndex (const LocalVariable *variable) const

bool	IsImmortalVariable (intptr_t env_index) const

const GrowableArray< BlockEntryInstr * > &	preorder () const

const GrowableArray< BlockEntryInstr * > &	postorder () const

const GrowableArray< BlockEntryInstr * > &	reverse_postorder () const

const GrowableArray< BlockEntryInstr * > &	optimized_block_order () const

GrowableArray< BlockEntryInstr * > *	CodegenBlockOrder ()

const GrowableArray< BlockEntryInstr * > *	CodegenBlockOrder () const

BlockIterator	reverse_postorder_iterator () const

BlockIterator	postorder_iterator () const

void	EnsureSSATempIndex (Definition defn, Definition replacement)

void	ReplaceCurrentInstruction (ForwardInstructionIterator iterator, Instruction current, Instruction *replacement)

Instruction *	CreateCheckClass (Definition *to_check, const Cids &cids, intptr_t deopt_id, const InstructionSource &source)

Definition *	CreateCheckBound (Definition length, Definition index, intptr_t deopt_id)

void	AddExactnessGuard (InstanceCallInstr *call, intptr_t receiver_cid)

intptr_t	current_ssa_temp_index () const

void	set_current_ssa_temp_index (intptr_t index)

intptr_t	max_vreg () const

ToCheck	CheckForInstanceCall (InstanceCallInstr *call, UntaggedFunction::Kind kind) const

Thread *	thread () const

Zone *	zone () const

IsolateGroup *	isolate_group () const

intptr_t	max_block_id () const

void	set_max_block_id (intptr_t id)

intptr_t	allocate_block_id ()

GraphEntryInstr *	graph_entry () const

ConstantInstr *	constant_null () const

ConstantInstr *	constant_dead () const

void	AllocateSSAIndex (Definition *def)

intptr_t	InstructionCount () const

ConstantInstr *	GetExistingConstant (const Object &object, Representation representation=kTagged) const

ConstantInstr *	GetConstant (const Object &object, Representation representation=kTagged)

void	AddToGraphInitialDefinitions (Definition *defn)

void	AddToInitialDefinitions (BlockEntryWithInitialDefs entry, Definition defn)

Definition *	TryCreateConstantReplacementFor (Definition *op, const Object &value)

void	InsertBefore (Instruction next, Instruction instr, Environment *env, UseKind use_kind)

void	InsertSpeculativeBefore (Instruction next, Instruction instr, Environment *env, UseKind use_kind)

void	InsertAfter (Instruction prev, Instruction instr, Environment *env, UseKind use_kind)

void	InsertSpeculativeAfter (Instruction prev, Instruction instr, Environment *env, UseKind use_kind)

Instruction *	AppendTo (Instruction prev, Instruction instr, Environment *env, UseKind use_kind)

Instruction *	AppendSpeculativeTo (Instruction prev, Instruction instr, Environment *env, UseKind use_kind)

void	ComputeSSA (ZoneGrowableArray< Definition * > *inlining_parameters)

bool	VerifyRedefinitions ()

void	DiscoverBlocks ()

void	MergeBlocks ()

RedefinitionInstr *	EnsureRedefinition (Instruction prev, Definition original, CompileType compile_type)

void	RemoveRedefinitions (bool keep_checks=false)

void	InsertMoveArguments ()

void	CopyDeoptTarget (Instruction to, Instruction from)

bool	is_licm_allowed () const

void	disallow_licm ()

bool	unmatched_representations_allowed () const

void	disallow_unmatched_representations ()

bool	is_huge_method () const

void	mark_huge_method ()

PrologueInfo	prologue_info () const

const LoopHierarchy &	GetLoopHierarchy ()

const LoopHierarchy &	loop_hierarchy () const

void	ResetLoopHierarchy ()

ZoneGrowableArray< BitVector * > *	loop_invariant_loads () const

void	set_loop_invariant_loads (ZoneGrowableArray< BitVector * > *loop_invariant_loads)

bool	IsCompiledForOsr () const

BitVector *	captured_parameters () const

intptr_t	inlining_id () const

void	set_inlining_id (intptr_t value)

bool	Canonicalize ()

void	PopulateWithICData (const Function &function)

void	SelectRepresentations ()

void	EliminateEnvironments ()

void	ExtractNonInternalTypedDataPayloads ()

bool	IsReceiver (Definition *def) const

void	TryOptimizePatterns ()

void	RenameUsesDominatedByRedefinitions ()

bool	should_print () const

const uint8_t *	compiler_pass_filters () const

bool	should_reorder_blocks () const

bool	should_remove_all_bounds_checks () const

JoinEntryInstr *	NewDiamond (Instruction instruction, Instruction inherit, ComparisonInstr compare, TargetEntryInstr block_true, TargetEntryInstr *block_false)

JoinEntryInstr *	NewDiamond (Instruction instruction, Instruction inherit, const LogicalAnd &condition, TargetEntryInstr block_true, TargetEntryInstr block_false)

PhiInstr *	AddPhi (JoinEntryInstr join, Definition d1, Definition *d2)

void	ComputeDominators (GrowableArray< BitVector * > *dominance_frontier)

void	CreateCommonConstants ()

const Array &	coverage_array () const

void	set_coverage_array (const Array &array)

void	CompactSSA (ZoneGrowableArray< Definition * > *detached_defs=nullptr)

intptr_t	max_argument_slot_count () const

void	set_max_argument_slot_count (intptr_t count)

const std::pair< Location, Representation > &	GetDirectParameterInfoAt (intptr_t i)

bool	ExtractExternalUntaggedPayload (Instruction instr, Value array, classid_t cid)

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

void *	operator new (size_t size)

void *	operator new (size_t size, Zone *zone)

void	operator delete (void *pointer)

Static Public Member Functions
static Representation	ParameterRepresentationAt (const Function &function, intptr_t index)

static Representation	ReturnRepresentationOf (const Function &function)

static bool	IsConstantRepresentable (const Object &value, Representation target_rep, bool tagged_value_must_be_smi)

static void	RenameDominatedUses (Definition def, Instruction dom, Definition *other)

static intptr_t	ComputeLocationsOfFixedParameters (Zone zone, const Function &function, bool should_assign_stack_locations=false, compiler::ParameterInfoArray parameter_info=nullptr)

static intptr_t	ComputeArgumentsSizeInWords (const Function &function, intptr_t arguments_count)

static constexpr CompilationMode	CompilationModeFrom (bool is_optimizing)

Friends
class	FlowGraphCompiler

class	FlowGraphChecker

class	IfConverter

class	BranchSimplifier

class	ConstantPropagator

class	DeadCodeElimination

class	compiler::GraphIntrinsifier

Detailed Description

Definition at line 114 of file flow_graph.h.

Member Enumeration Documentation

◆ CompilationMode

enum class dart::FlowGraph::CompilationMode

strong

Enumerator
kUnoptimized
kOptimized
kIntrinsic

Definition at line 116 of file flow_graph.h.

                             {
    kUnoptimized,
    kOptimized,
    kIntrinsic,
  };

◆ ToCheck

enum class dart::FlowGraph::ToCheck

strong

Enumerator
kNoCheck
kCheckNull
kCheckCid

Definition at line 252 of file flow_graph.h.

252{ kNoCheck, kCheckNull, kCheckCid };

◆ UseKind

enum dart::FlowGraph::UseKind

Enumerator
kEffect
kValue

Definition at line 310 of file flow_graph.h.

310{ kEffect, kValue };

dart::FlowGraph::kValue

@ kValue

Definition: flow_graph.h:310

dart::FlowGraph::kEffect

@ kEffect

Definition: flow_graph.h:310

Constructor & Destructor Documentation

◆ FlowGraph()

dart::FlowGraph::FlowGraph	(	const ParsedFunction &	parsed_function,
		GraphEntryInstr *	graph_entry,
		intptr_t	max_block_id,
		PrologueInfo	prologue_info,
		CompilationMode	compilation_mode
	)

Definition at line 46 of file flow_graph.cc.

    : thread_(Thread::Current()),
      parent_(),
      current_ssa_temp_index_(0),
      max_block_id_(max_block_id),
      parsed_function_(parsed_function),
      num_direct_parameters_(parsed_function.function().MakesCopyOfParameters()
                                 ? 0
                                 : parsed_function.function().NumParameters()),
      direct_parameter_locations_(
          parsed_function.function().num_fixed_parameters()),
      graph_entry_(graph_entry),
      preorder_(),
      postorder_(),
      reverse_postorder_(),
      optimized_block_order_(),
      constant_null_(nullptr),
      constant_dead_(nullptr),
      licm_allowed_(true),
      should_reorder_blocks_(
          ShouldReorderBlocks(parsed_function.function(), compilation_mode)),
      prologue_info_(prologue_info),
      loop_hierarchy_(nullptr),
      loop_invariant_loads_(nullptr),
      captured_parameters_(new(zone()) BitVector(zone(), variable_count())),
      inlining_id_(-1),
      should_print_(false),
      should_remove_all_bounds_checks_(
          CompilerState::Current().is_aot() &&
          IsMarkedWithNoBoundsChecks(parsed_function.function())) {
  should_print_ = FlowGraphPrinter::ShouldPrint(parsed_function.function(),
                                                &compiler_pass_filters_);
  ComputeLocationsOfFixedParameters(
      zone(), function(),
      /*should_assign_stack_locations=*/
      !parsed_function.function().MakesCopyOfParameters(),
      &direct_parameter_locations_);
  DiscoverBlocks();
}

Member Function Documentation

◆ AddExactnessGuard()

void dart::FlowGraph::AddExactnessGuard	(	InstanceCallInstr *	call,
		intptr_t	receiver_cid
	)

Definition at line 627 of file flow_graph.cc.

                                                         {
  const Class& cls =
      Class::Handle(zone(), isolate_group()->class_table()->At(receiver_cid));
 
  Definition* load_type_args = new (zone()) LoadFieldInstr(
      call->Receiver()->CopyWithType(),
      Slot::GetTypeArgumentsSlotFor(thread(), cls), call->source());
  InsertBefore(call, load_type_args, call->env(), FlowGraph::kValue);
 
  const AbstractType& type =
      AbstractType::Handle(zone(), call->ic_data()->receivers_static_type());
  ASSERT(!type.IsNull());
  const TypeArguments& args = TypeArguments::Handle(
      zone(), Type::Cast(type).GetInstanceTypeArguments(thread()));
  Instruction* guard = new (zone()) CheckConditionInstr(
      new StrictCompareInstr(call->source(), Token::kEQ_STRICT,
                             new (zone()) Value(load_type_args),
                             new (zone()) Value(GetConstant(args)),
                             /*needs_number_check=*/false, call->deopt_id()),
      call->deopt_id());
  InsertBefore(call, guard, call->env(), FlowGraph::kEffect);
}

◆ AddPhi()

PhiInstr * dart::FlowGraph::AddPhi	(	JoinEntryInstr *	join,
		Definition *	d1,
		Definition *	d2
	)

Definition at line 2927 of file flow_graph.cc.

                                            {
  PhiInstr* phi = new (zone()) PhiInstr(join, 2);
  Value* v1 = new (zone()) Value(d1);
  Value* v2 = new (zone()) Value(d2);
 
  AllocateSSAIndex(phi);
 
  phi->mark_alive();
  phi->SetInputAt(0, v1);
  phi->SetInputAt(1, v2);
  d1->AddInputUse(v1);
  d2->AddInputUse(v2);
  join->InsertPhi(phi);
 
  return phi;
}

◆ AddToGraphInitialDefinitions()

void dart::FlowGraph::AddToGraphInitialDefinitions ( Definition * defn )

Definition at line 258 of file flow_graph.cc.

                                                             {
  defn->set_previous(graph_entry_);
  graph_entry_->initial_definitions()->Add(defn);
}

◆ AddToInitialDefinitions()

void dart::FlowGraph::AddToInitialDefinitions	(	BlockEntryWithInitialDefs *	entry,
		Definition *	defn
	)

Definition at line 263 of file flow_graph.cc.

                                                          {
  ASSERT(defn->previous() == nullptr);
  defn->set_previous(entry);
  if (auto par = defn->AsParameter()) {
    par->set_block(entry);  // set cached block
  }
  entry->initial_definitions()->Add(defn);
}

◆ allocate_block_id()

intptr_t dart::FlowGraph::allocate_block_id ( )

inline

Definition at line 266 of file flow_graph.h.

266{ return ++max_block_id_; }

◆ AllocateSSAIndex()

void dart::FlowGraph::AllocateSSAIndex ( Definition * def )

inline

Definition at line 274 of file flow_graph.h.

                                         {
    def->set_ssa_temp_index(current_ssa_temp_index_);
    current_ssa_temp_index_++;
  }

◆ AppendSpeculativeTo()

Instruction * dart::FlowGraph::AppendSpeculativeTo	(	Instruction *	prev,
		Instruction *	instr,
		Environment *	env,
		UseKind	use_kind
	)

Definition at line 312 of file flow_graph.cc.

                                                              {
  auto result = AppendTo(prev, instr, env, use_kind);
  if (instr->env() != nullptr) {
    instr->env()->MarkAsLazyDeoptToBeforeDeoptId();
  }
  return result;
}

◆ AppendTo()

Instruction * dart::FlowGraph::AppendTo	(	Instruction *	prev,
		Instruction *	instr,
		Environment *	env,
		UseKind	use_kind
	)

Definition at line 298 of file flow_graph.cc.

                                                   {
  if (use_kind == kValue) {
    ASSERT(instr->IsDefinition());
    AllocateSSAIndex(instr->AsDefinition());
  }
  ASSERT(instr->env() == nullptr);
  if (env != nullptr) {
    env->DeepCopyTo(zone(), instr);
  }
  return prev->AppendInstruction(instr);
}

◆ ArgumentDescriptorEnvIndex()

intptr_t dart::FlowGraph::ArgumentDescriptorEnvIndex ( ) const

inline

Definition at line 185 of file flow_graph.h.

                                              {
    return EnvIndex(parsed_function().arg_desc_var());
  }

◆ Canonicalize()

bool dart::FlowGraph::Canonicalize ( )

Definition at line 2466 of file flow_graph.cc.

                             {
  bool changed = false;
 
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    BlockEntryInstr* const block = block_it.Current();
    if (auto join = block->AsJoinEntry()) {
      for (PhiIterator it(join); !it.Done(); it.Advance()) {
        PhiInstr* current = it.Current();
        if (current->HasUnmatchedInputRepresentations() &&
            (current->SpeculativeModeOfInputs() == Instruction::kGuardInputs)) {
          // Can't canonicalize this instruction until all conversions for its
          // speculative inputs are inserted.
          continue;
        }
 
        Definition* replacement = current->Canonicalize(this);
        ASSERT(replacement != nullptr);
        RELEASE_ASSERT(unmatched_representations_allowed() ||
                       !replacement->HasUnmatchedInputRepresentations());
        if (replacement != current) {
          current->ReplaceUsesWith(replacement);
          it.RemoveCurrentFromGraph();
          changed = true;
        }
      }
    }
    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
      Instruction* current = it.Current();
      if (current->HasUnmatchedInputRepresentations() &&
          (current->SpeculativeModeOfInputs() == Instruction::kGuardInputs)) {
        // Can't canonicalize this instruction until all conversions for its
        // speculative inputs are inserted.
        continue;
      }
 
      Instruction* replacement = current->Canonicalize(this);
 
      if (replacement != current) {
        // For non-definitions Canonicalize should return either nullptr or
        // this.
        if (replacement != nullptr) {
          ASSERT(current->IsDefinition());
          if (!unmatched_representations_allowed()) {
            RELEASE_ASSERT(!replacement->HasUnmatchedInputRepresentations());
            if ((replacement->representation() != current->representation()) &&
                current->AsDefinition()->HasUses()) {
              // Can't canonicalize this instruction as unmatched
              // representations are not allowed at this point, but
              // replacement has a different representation.
              continue;
            }
          }
        }
        ReplaceCurrentInstruction(&it, current, replacement);
        changed = true;
      }
    }
  }
  return changed;
}

◆ captured_parameters()

BitVector * dart::FlowGraph::captured_parameters ( ) const

inline

Definition at line 462 of file flow_graph.h.

462{ return captured_parameters_; }

◆ CheckForInstanceCall()

FlowGraph::ToCheck dart::FlowGraph::CheckForInstanceCall	(	InstanceCallInstr *	call,
		UntaggedFunction::Kind	kind
	)		const

Definition at line 493 of file flow_graph.cc.

                                     {
  if (!FLAG_use_cha_deopt && !isolate_group()->all_classes_finalized()) {
    // Even if class or function are private, lazy class finalization
    // may later add overriding methods.
    return ToCheck::kCheckCid;
  }
 
  // Best effort to get the receiver class.
  Value* receiver = call->Receiver();
  Class& receiver_class = Class::Handle(zone());
  bool receiver_maybe_null = false;
  if (function().IsDynamicFunction() && IsReceiver(receiver->definition())) {
    // Call receiver is callee receiver: calling "this.g()" in f().
    receiver_class = function().Owner();
  } else {
    // Get the receiver's compile type. Note that
    // we allow nullable types, which may result in just generating
    // a null check rather than the more elaborate class check
    CompileType* type = receiver->Type();
    const intptr_t receiver_cid = type->ToNullableCid();
    if (receiver_cid != kDynamicCid) {
      receiver_class = isolate_group()->class_table()->At(receiver_cid);
      receiver_maybe_null = type->is_nullable();
    } else {
      const AbstractType* atype = type->ToAbstractType();
      if (atype->IsInstantiated() && atype->HasTypeClass() &&
          !atype->IsDynamicType()) {
        if (type->is_nullable()) {
          receiver_maybe_null = true;
        }
        receiver_class = atype->type_class();
        if (receiver_class.is_implemented()) {
          receiver_class = Class::null();
        }
      }
    }
  }
 
  // Useful receiver class information?
  if (receiver_class.IsNull() ||
      receiver_class.has_dynamically_extendable_subtypes()) {
    return ToCheck::kCheckCid;
  } else if (call->HasICData()) {
    // If the static class type does not match information found in ICData
    // (which may be "guessed"), then bail, since subsequent code generation
    // (AOT and JIT) for inlining uses the latter.
    // TODO(ajcbik): improve this by using the static class.
    const intptr_t cid = receiver_class.id();
    const ICData* data = call->ic_data();
    bool match = false;
    Class& cls = Class::Handle(zone());
    Function& fun = Function::Handle(zone());
    for (intptr_t i = 0, len = data->NumberOfChecks(); i < len; i++) {
      if (!data->IsUsedAt(i)) {
        continue;  // do not consider
      }
      fun = data->GetTargetAt(i);
      cls = fun.Owner();
      if (data->GetReceiverClassIdAt(i) == cid || cls.id() == cid) {
        match = true;
        break;
      }
    }
    if (!match) {
      return ToCheck::kCheckCid;
    }
  }
 
  const String& method_name =
      (kind == UntaggedFunction::kMethodExtractor)
          ? String::Handle(zone(), Field::NameFromGetter(call->function_name()))
          : call->function_name();
 
  // If the receiver can have the null value, exclude any method
  // that is actually valid on a null receiver.
  if (receiver_maybe_null) {
    const Class& null_class =
        Class::Handle(zone(), isolate_group()->object_store()->null_class());
    Function& target = Function::Handle(zone());
    if (null_class.EnsureIsFinalized(thread()) == Error::null()) {
      target = Resolver::ResolveDynamicAnyArgs(zone(), null_class, method_name,
                                               /*allow_add=*/true);
    }
    if (!target.IsNull()) {
      return ToCheck::kCheckCid;
    }
  }
 
  // Use CHA to determine if the method is not overridden by any subclass
  // of the receiver class. Any methods that are valid when the receiver
  // has a null value are excluded above (to avoid throwing an exception
  // on something valid, like null.hashCode).
  intptr_t subclass_count = 0;
  CHA& cha = thread()->compiler_state().cha();
  if (!cha.HasOverride(receiver_class, method_name, &subclass_count)) {
    if (FLAG_trace_cha) {
      THR_Print(
          "  **(CHA) Instance call needs no class check since there "
          "are no overrides of method '%s' on '%s'\n",
          method_name.ToCString(), receiver_class.ToCString());
    }
    if (FLAG_use_cha_deopt) {
      cha.AddToGuardedClassesForSubclassCount(receiver_class, subclass_count);
    }
    return receiver_maybe_null ? ToCheck::kCheckNull : ToCheck::kNoCheck;
  }
  return ToCheck::kCheckCid;
}

◆ CodegenBlockOrder() [1/2]

GrowableArray< BlockEntryInstr * > * dart::FlowGraph::CodegenBlockOrder ( )

Definition at line 170 of file flow_graph.cc.

                                                              {
  return should_reorder_blocks() ? &optimized_block_order_
                                 : &reverse_postorder_;
}

◆ CodegenBlockOrder() [2/2]

const GrowableArray< BlockEntryInstr * > * dart::FlowGraph::CodegenBlockOrder ( ) const

Definition at line 175 of file flow_graph.cc.

                                                                          {
  return should_reorder_blocks() ? &optimized_block_order_
                                 : &reverse_postorder_;
}

◆ CompactSSA()

void dart::FlowGraph::CompactSSA ( ZoneGrowableArray< Definition * > * detached_defs = nullptr )

Definition at line 3123 of file flow_graph.cc.

                                                                        {
  if (detached_defs == nullptr) {
    detached_defs = new (Z) ZoneGrowableArray<Definition*>(Z, 0);
  }
  SSACompactor compactor(max_block_id() + 1, current_ssa_temp_index(),
                         detached_defs);
  compactor.RenumberGraph(this);
}

◆ CompilationModeFrom()

static constexpr CompilationMode dart::FlowGraph::CompilationModeFrom ( bool is_optimizing )

inlinestaticconstexpr

Definition at line 585 of file flow_graph.h.

                                                                           {
    return is_optimizing ? CompilationMode::kOptimized
                         : CompilationMode::kUnoptimized;
  }

◆ compiler_pass_filters()

const uint8_t * dart::FlowGraph::compiler_pass_filters ( ) const

inline

Definition at line 504 of file flow_graph.h.

                                               {
    return compiler_pass_filters_;
  }

◆ ComputeArgumentsSizeInWords()

intptr_t dart::FlowGraph::ComputeArgumentsSizeInWords	(	const Function &	function,
		intptr_t	arguments_count
	)

static

Definition at line 96 of file flow_graph.cc.

                                                                         {
  ASSERT(function.num_fixed_parameters() <= argument_count);
  ASSERT(argument_count <= function.NumParameters());
 
  const intptr_t fixed_parameters_size_in_bytes =
      ComputeLocationsOfFixedParameters(Thread::Current()->zone(), function);
 
  // Currently we box all optional parameters.
  return fixed_parameters_size_in_bytes +
         (argument_count - function.num_fixed_parameters());
}

◆ ComputeDominators()

void dart::FlowGraph::ComputeDominators ( GrowableArray< BitVector * > * dominance_frontier )

Definition at line 975 of file flow_graph.cc.

                                                   {
  // Use the SEMI-NCA algorithm to compute dominators.  This is a two-pass
  // version of the Lengauer-Tarjan algorithm (LT is normally three passes)
  // that eliminates a pass by using nearest-common ancestor (NCA) to
  // compute immediate dominators from semidominators.  It also removes a
  // level of indirection in the link-eval forest data structure.
  //
  // The algorithm is described in Georgiadis, Tarjan, and Werneck's
  // "Finding Dominators in Practice".
  // https://renatowerneck.files.wordpress.com/2016/06/gtw06-dominators.pdf
 
  // All arrays are maps between preorder basic-block numbers.
  intptr_t size = parent_.length();
  GrowableArray<intptr_t> idom(size);   // Immediate dominator.
  GrowableArray<intptr_t> semi(size);   // Semidominator.
  GrowableArray<intptr_t> label(size);  // Label for link-eval forest.
 
  // 1. First pass: compute semidominators as in Lengauer-Tarjan.
  // Semidominators are computed from a depth-first spanning tree and are an
  // approximation of immediate dominators.
 
  // Use a link-eval data structure with path compression.  Implement path
  // compression in place by mutating the parent array.  Each block has a
  // label, which is the minimum block number on the compressed path.
 
  // Initialize idom, semi, and label used by SEMI-NCA.  Initialize the
  // dominance frontier output array.
  for (intptr_t i = 0; i < size; ++i) {
    idom.Add(parent_[i]);
    semi.Add(i);
    label.Add(i);
    dominance_frontier->Add(new (zone()) BitVector(zone(), size));
  }
 
  // Loop over the blocks in reverse preorder (not including the graph
  // entry).  Clear the dominated blocks in the graph entry in case
  // ComputeDominators is used to recompute them.
  preorder_[0]->ClearDominatedBlocks();
  for (intptr_t block_index = size - 1; block_index >= 1; --block_index) {
    // Loop over the predecessors.
    BlockEntryInstr* block = preorder_[block_index];
    // Clear the immediately dominated blocks in case ComputeDominators is
    // used to recompute them.
    block->ClearDominatedBlocks();
    for (intptr_t i = 0, count = block->PredecessorCount(); i < count; ++i) {
      BlockEntryInstr* pred = block->PredecessorAt(i);
      ASSERT(pred != nullptr);
 
      // Look for the semidominator by ascending the semidominator path
      // starting from pred.
      intptr_t pred_index = pred->preorder_number();
      intptr_t best = pred_index;
      if (pred_index > block_index) {
        CompressPath(block_index, pred_index, &parent_, &label);
        best = label[pred_index];
      }
 
      // Update the semidominator if we've found a better one.
      semi[block_index] = Utils::Minimum(semi[block_index], semi[best]);
    }
 
    // Now use label for the semidominator.
    label[block_index] = semi[block_index];
  }
 
  // 2. Compute the immediate dominators as the nearest common ancestor of
  // spanning tree parent and semidominator, for all blocks except the entry.
  for (intptr_t block_index = 1; block_index < size; ++block_index) {
    intptr_t dom_index = idom[block_index];
    while (dom_index > semi[block_index]) {
      dom_index = idom[dom_index];
    }
    idom[block_index] = dom_index;
    preorder_[dom_index]->AddDominatedBlock(preorder_[block_index]);
  }
 
  // 3. Now compute the dominance frontier for all blocks.  This is
  // algorithm in "A Simple, Fast Dominance Algorithm" (Figure 5), which is
  // attributed to a paper by Ferrante et al.  There is no bookkeeping
  // required to avoid adding a block twice to the same block's dominance
  // frontier because we use a set to represent the dominance frontier.
  for (intptr_t block_index = 0; block_index < size; ++block_index) {
    BlockEntryInstr* block = preorder_[block_index];
    intptr_t count = block->PredecessorCount();
    if (count <= 1) continue;
    for (intptr_t i = 0; i < count; ++i) {
      BlockEntryInstr* runner = block->PredecessorAt(i);
      while (runner != block->dominator()) {
        (*dominance_frontier)[runner->preorder_number()]->Add(block_index);
        runner = runner->dominator();
      }
    }
  }
}

◆ ComputeLocationsOfFixedParameters()

intptr_t dart::FlowGraph::ComputeLocationsOfFixedParameters	(	Zone *	zone,
		const Function &	function,
		bool	should_assign_stack_locations = `false`,
		compiler::ParameterInfoArray *	parameter_info = `nullptr`
	)

static

Definition at line 1204 of file flow_graph.cc.

                                                  {
  return compiler::ComputeCallingConvention(
      zone, function, function.num_fixed_parameters(),
      [&](intptr_t i) {
        const intptr_t index = (function.IsFactory() ? (i - 1) : i);
        return index >= 0 ? ParameterRepresentationAt(function, index)
                          : kTagged;
      },
      should_assign_stack_locations, parameter_info);
}

◆ ComputeSSA()

void dart::FlowGraph::ComputeSSA ( ZoneGrowableArray< Definition * > * inlining_parameters )

Definition at line 926 of file flow_graph.cc.

                                                         {
  GrowableArray<BitVector*> dominance_frontier;
  GrowableArray<intptr_t> idom;
 
#ifdef DEBUG
  if (inlining_parameters != nullptr) {
    for (intptr_t i = 0, n = inlining_parameters->length(); i < n; ++i) {
      Definition* defn = (*inlining_parameters)[i];
      if (defn->IsConstant()) {
        ASSERT(defn->previous() == graph_entry_);
        ASSERT(defn->HasSSATemp());
        ASSERT(defn->ssa_temp_index() < current_ssa_temp_index());
      } else {
        ASSERT(defn->previous() == nullptr);
        ASSERT(!defn->HasSSATemp());
      }
    }
  } else {
    ASSERT(current_ssa_temp_index() == 0);
  }
#endif
 
  ComputeDominators(&dominance_frontier);
 
  VariableLivenessAnalysis variable_liveness(this);
  variable_liveness.Analyze();
 
  GrowableArray<PhiInstr*> live_phis;
 
  InsertPhis(preorder_, variable_liveness.ComputeAssignedVars(),
             dominance_frontier, &live_phis);
 
  // Rename uses to reference inserted phis where appropriate.
  // Collect phis that reach a non-environment use.
  Rename(&live_phis, &variable_liveness, inlining_parameters);
 
  // Propagate alive mark transitively from alive phis and then remove
  // non-live ones.
  RemoveDeadPhis(&live_phis);
}

◆ constant_dead()

ConstantInstr * dart::FlowGraph::constant_dead ( ) const

inline

Definition at line 272 of file flow_graph.h.

272{ return constant_dead_; }

◆ constant_null()

ConstantInstr * dart::FlowGraph::constant_null ( ) const

inline

Definition at line 270 of file flow_graph.h.

270{ return constant_null_; }

◆ CopyDeoptTarget()

void dart::FlowGraph::CopyDeoptTarget	(	Instruction *	to,
		Instruction *	from
	)

inline

Definition at line 395 of file flow_graph.h.

                                                           {
    if (is_licm_allowed()) {
      to->InheritDeoptTarget(zone(), from);
    }
  }

◆ coverage_array()

const Array & dart::FlowGraph::coverage_array ( ) const

inline

Definition at line 550 of file flow_graph.h.

550{ return *coverage_array_; }

◆ CreateCheckBound()

Definition * dart::FlowGraph::CreateCheckBound	(	Definition *	length,
		Definition *	index,
		intptr_t	deopt_id
	)

Definition at line 616 of file flow_graph.cc.

                                                           {
  Value* val1 = new (zone()) Value(length);
  Value* val2 = new (zone()) Value(index);
  if (CompilerState::Current().is_aot()) {
    return new (zone()) GenericCheckBoundInstr(val1, val2, deopt_id);
  }
  return new (zone()) CheckArrayBoundInstr(val1, val2, deopt_id);
}

◆ CreateCheckClass()

Instruction * dart::FlowGraph::CreateCheckClass	(	Definition *	to_check,
		const Cids &	cids,
		intptr_t	deopt_id,
		const InstructionSource &	source
	)

Definition at line 604 of file flow_graph.cc.

                                                                          {
  if (cids.IsMonomorphic() && cids.MonomorphicReceiverCid() == kSmiCid) {
    return new (zone())
        CheckSmiInstr(new (zone()) Value(to_check), deopt_id, source);
  }
  return new (zone())
      CheckClassInstr(new (zone()) Value(to_check), deopt_id, cids, source);
}

◆ CreateCommonConstants()

void dart::FlowGraph::CreateCommonConstants ( )

Definition at line 1143 of file flow_graph.cc.

                                      {
  constant_null_ = GetConstant(Object::ZoneHandle());
  constant_dead_ = GetConstant(Object::optimized_out());
}

◆ current_ssa_temp_index()

intptr_t dart::FlowGraph::current_ssa_temp_index ( ) const

inline

Definition at line 243 of file flow_graph.h.

243{ return current_ssa_temp_index_; }

◆ CurrentContextEnvIndex()

intptr_t dart::FlowGraph::CurrentContextEnvIndex ( ) const

inline

Definition at line 177 of file flow_graph.h.

                                          {
    return EnvIndex(parsed_function().current_context_var());
  }

◆ CurrentContextVar()

LocalVariable * dart::FlowGraph::CurrentContextVar ( ) const

inline

Definition at line 173 of file flow_graph.h.

                                           {
    return parsed_function().current_context_var();
  }

◆ disallow_licm()

void dart::FlowGraph::disallow_licm ( )

inline

Definition at line 408 of file flow_graph.h.

408{ licm_allowed_ = false; }

◆ disallow_unmatched_representations()

void dart::FlowGraph::disallow_unmatched_representations ( )

inline

Definition at line 417 of file flow_graph.h.

                                            {
    unmatched_representations_allowed_ = false;
  }

◆ DiscoverBlocks()

void dart::FlowGraph::DiscoverBlocks ( )

Definition at line 346 of file flow_graph.cc.

                               {
  COMPILER_TIMINGS_TIMER_SCOPE(thread(), DiscoverBlocks);
 
  StackZone zone(thread());
 
  // Initialize state.
  preorder_.Clear();
  postorder_.Clear();
  reverse_postorder_.Clear();
  parent_.Clear();
 
  GrowableArray<BlockTraversalState> block_stack;
  graph_entry_->DiscoverBlock(nullptr, &preorder_, &parent_);
  block_stack.Add(BlockTraversalState(graph_entry_));
  while (!block_stack.is_empty()) {
    BlockTraversalState& state = block_stack.Last();
    BlockEntryInstr* block = state.block();
    if (state.HasNextSuccessor()) {
      // Process successors one-by-one.
      BlockEntryInstr* succ = state.NextSuccessor();
      if (succ->DiscoverBlock(block, &preorder_, &parent_)) {
        block_stack.Add(BlockTraversalState(succ));
      }
    } else {
      // All successors have been processed, pop the current block entry node
      // and add it to the postorder list.
      block_stack.RemoveLast();
      block->set_postorder_number(postorder_.length());
      postorder_.Add(block);
    }
  }
 
  ASSERT(postorder_.length() == preorder_.length());
 
  // Create an array of blocks in reverse postorder.
  intptr_t block_count = postorder_.length();
  for (intptr_t i = 0; i < block_count; ++i) {
    reverse_postorder_.Add(postorder_[block_count - i - 1]);
  }
 
  ResetLoopHierarchy();
}

◆ EliminateEnvironments()

void dart::FlowGraph::EliminateEnvironments ( )

Definition at line 2351 of file flow_graph.cc.

                                      {
  // After this pass we can no longer perform LICM and hoist instructions
  // that can deoptimize.
 
  disallow_licm();
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    BlockEntryInstr* block = block_it.Current();
    if (!block->IsCatchBlockEntry()) {
      block->RemoveEnvironment();
    }
    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
      Instruction* current = it.Current();
      // This check is inconsistent with the flow graph checker. The flow graph
      // checker does not allow for not having an env if the block is not
      // inside a try-catch.
      // See FlowGraphChecker::VisitInstruction.
      if (!current->ComputeCanDeoptimize() &&
          !current->ComputeCanDeoptimizeAfterCall() &&
          (!current->MayThrow() || !current->GetBlock()->InsideTryBlock())) {
        // Instructions that can throw need an environment for optimized
        // try-catch.
        // TODO(srdjan): --source-lines needs deopt environments to get at
        // the code for this instruction, however, leaving the environment
        // changes code.
        current->RemoveEnvironment();
      }
    }
  }
}

◆ EnsureRedefinition()

RedefinitionInstr * dart::FlowGraph::EnsureRedefinition	(	Instruction *	prev,
		Definition *	original,
		CompileType	compile_type
	)

Definition at line 1777 of file flow_graph.cc.

                                                                           {
  RedefinitionInstr* first = prev->next()->AsRedefinition();
  if (first != nullptr && (first->constrained_type() != nullptr)) {
    if ((first->value()->definition() == original) &&
        first->constrained_type()->IsEqualTo(&compile_type)) {
      // Already redefined. Do nothing.
      return nullptr;
    }
  }
  RedefinitionInstr* redef = new RedefinitionInstr(new Value(original));
 
  // Don't set the constrained type when the type is None(), which denotes an
  // unreachable value (e.g. using value null after some form of null check).
  if (!compile_type.IsNone()) {
    redef->set_constrained_type(new CompileType(compile_type));
  }
 
  InsertAfter(prev, redef, nullptr, FlowGraph::kValue);
  RenameDominatedUses(original, redef, redef);
 
  if (redef->input_use_list() == nullptr) {
    // There are no dominated uses, so the newly added Redefinition is useless.
    // Remove Redefinition to avoid interfering with
    // BranchSimplifier::Simplify which needs empty blocks.
    redef->RemoveFromGraph();
    return nullptr;
  }
 
  return redef;
}

◆ EnsureSSATempIndex()

void dart::FlowGraph::EnsureSSATempIndex	(	Definition *	defn,
		Definition *	replacement
	)

Definition at line 90 of file flow_graph.cc.

                                                                            {
  if ((replacement->ssa_temp_index() == -1) && (defn->ssa_temp_index() != -1)) {
    AllocateSSAIndex(replacement);
  }
}

◆ EnvIndex()

intptr_t dart::FlowGraph::EnvIndex ( const LocalVariable * variable ) const

inline

Definition at line 189 of file flow_graph.h.

                                                         {
    ASSERT(!variable->is_captured());
    return num_direct_parameters_ - variable->index().value();
  }

◆ ExtractExternalUntaggedPayload()

bool dart::FlowGraph::ExtractExternalUntaggedPayload	(	Instruction *	instr,
		Value *	array,
		classid_t	cid
	)

Definition at line 2393 of file flow_graph.cc.

                                                              {
  ASSERT(array->instruction() == instr);
  // Nothing to do if already untagged.
  if (array->definition()->representation() != kTagged) return false;
  // If we've determined at compile time that this is an object that has an
  // external payload, use the cid of the compile type instead.
  if (IsExternalPayloadClassId(array->Type()->ToCid())) {
    cid = array->Type()->ToCid();
  } else if (!IsExternalPayloadClassId(cid)) {
    // Can't extract the payload address if it points to GC-managed memory.
    return false;
  }
 
  const Slot* slot = nullptr;
  if (cid == kPointerCid || IsExternalTypedDataClassId(cid)) {
    slot = &Slot::PointerBase_data();
  } else {
    UNREACHABLE();
  }
 
  ExtractUntaggedPayload(instr, array, *slot,
                         InnerPointerAccess::kCannotBeInnerPointer);
  return true;
}

◆ ExtractNonInternalTypedDataPayloads()

void dart::FlowGraph::ExtractNonInternalTypedDataPayloads ( )

Definition at line 2444 of file flow_graph.cc.

                                                    {
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    BlockEntryInstr* block = block_it.Current();
    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
      Instruction* current = it.Current();
      if (auto* const load_indexed = current->AsLoadIndexed()) {
        ExtractNonInternalTypedDataPayload(load_indexed, load_indexed->array(),
                                           load_indexed->class_id());
      } else if (auto* const store_indexed = current->AsStoreIndexed()) {
        ExtractNonInternalTypedDataPayload(
            store_indexed, store_indexed->array(), store_indexed->class_id());
      } else if (auto* const memory_copy = current->AsMemoryCopy()) {
        ExtractNonInternalTypedDataPayload(memory_copy, memory_copy->src(),
                                           memory_copy->src_cid());
        ExtractNonInternalTypedDataPayload(memory_copy, memory_copy->dest(),
                                           memory_copy->dest_cid());
      }
    }
  }
}

◆ function()

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

inline

Definition at line 130 of file flow_graph.h.

130{ return parsed_function_.function(); }

◆ GetConstant()

ConstantInstr * dart::FlowGraph::GetConstant	(	const Object &	object,
		Representation	representation = `kTagged`
	)

Definition at line 187 of file flow_graph.cc.

                                                                     {
  ConstantInstr* constant = GetExistingConstant(object, representation);
  if (constant == nullptr) {
    // Otherwise, allocate and add it to the pool.
    const Object& zone_object = Object::ZoneHandle(zone(), object.ptr());
    if (representation == kTagged) {
      constant = new (zone()) ConstantInstr(zone_object);
    } else {
      constant = new (zone()) UnboxedConstantInstr(zone_object, representation);
    }
    AllocateSSAIndex(constant);
    AddToGraphInitialDefinitions(constant);
    constant_instr_pool_.Insert(constant);
  }
  return constant;
}

◆ GetDirectParameterInfoAt()

const std::pair< Location, Representation > & dart::FlowGraph::GetDirectParameterInfoAt ( intptr_t i )

inline

Definition at line 571 of file flow_graph.h.

                  {
    return direct_parameter_locations_[i];
  }

◆ GetExistingConstant()

ConstantInstr * dart::FlowGraph::GetExistingConstant	(	const Object &	object,
		Representation	representation = `kTagged`
	)		const

Definition at line 180 of file flow_graph.cc.

                                         {
  return constant_instr_pool_.LookupValue(
      ConstantAndRepresentation{object, representation});
}

◆ GetLoopHierarchy()

const LoopHierarchy & dart::FlowGraph::GetLoopHierarchy ( )

inline

Definition at line 430 of file flow_graph.h.

                                          {
    if (loop_hierarchy_ == nullptr) {
      loop_hierarchy_ = ComputeLoops();
    }
    return loop_hierarchy();
  }

◆ graph_entry()

GraphEntryInstr * dart::FlowGraph::graph_entry ( ) const

inline

Definition at line 268 of file flow_graph.h.

268{ return graph_entry_; }

◆ inlining_id()

intptr_t dart::FlowGraph::inlining_id ( ) const

inline

Definition at line 464 of file flow_graph.h.

464{ return inlining_id_; }

◆ InsertAfter()

void dart::FlowGraph::InsertAfter	(	Instruction *	prev,
		Instruction *	instr,
		Environment *	env,
		UseKind	use_kind
	)

Definition at line 273 of file flow_graph.cc.

                                              {
  if (use_kind == kValue) {
    ASSERT(instr->IsDefinition());
    AllocateSSAIndex(instr->AsDefinition());
  }
  instr->InsertAfter(prev);
  ASSERT(instr->env() == nullptr);
  if (env != nullptr) {
    env->DeepCopyTo(zone(), instr);
  }
}

◆ InsertBefore()

void dart::FlowGraph::InsertBefore	(	Instruction *	next,
		Instruction *	instr,
		Environment *	env,
		UseKind	use_kind
	)

inline

Definition at line 312 of file flow_graph.h.

                                      {
    InsertAfter(next->previous(), instr, env, use_kind);
  }

◆ InsertMoveArguments()

void dart::FlowGraph::InsertMoveArguments ( )

Definition at line 2946 of file flow_graph.cc.

                                    {
  compiler::ParameterInfoArray argument_locations;
 
  intptr_t max_argument_slot_count = 0;
  auto& target = Function::Handle();
 
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    thread()->CheckForSafepoint();
    for (ForwardInstructionIterator instr_it(block_it.Current());
         !instr_it.Done(); instr_it.Advance()) {
      Instruction* instruction = instr_it.Current();
      const intptr_t arg_count = instruction->ArgumentCount();
      if (arg_count == 0) {
        continue;
      }
 
      target = Function::null();
      if (auto static_call = instruction->AsStaticCall()) {
        target = static_call->function().ptr();
      } else if (auto instance_call = instruction->AsInstanceCallBase()) {
        target = instance_call->interface_target().ptr();
      } else if (auto dispatch_call = instruction->AsDispatchTableCall()) {
        target = dispatch_call->interface_target().ptr();
      } else if (auto cachable_call = instruction->AsCachableIdempotentCall()) {
        target = cachable_call->function().ptr();
      }
 
      MoveArgumentsArray* arguments =
          new (Z) MoveArgumentsArray(zone(), arg_count);
      arguments->EnsureLength(arg_count, nullptr);
 
      const intptr_t stack_arguments_size_in_words =
          compiler::ComputeCallingConvention(
              zone(), target, arg_count,
              [&](intptr_t i) {
                return instruction->RequiredInputRepresentation(i);
              },
              /*should_assign_stack_locations=*/true, &argument_locations);
 
      for (intptr_t i = 0; i < arg_count; ++i) {
        const auto& [location, rep] = argument_locations[i];
        Value* arg = instruction->ArgumentValueAt(i);
        (*arguments)[i] = new (Z) MoveArgumentInstr(
            arg->CopyWithType(Z), rep, location.ToCallerSpRelative());
      }
      max_argument_slot_count = Utils::Maximum(max_argument_slot_count,
                                               stack_arguments_size_in_words);
 
      for (auto move_arg : *arguments) {
        // Insert all MoveArgument instructions immediately before call.
        // MoveArgumentInstr::EmitNativeCode may generate more efficient
        // code for subsequent MoveArgument instructions (ARM, ARM64).
        if (!move_arg->is_register_move()) {
          InsertBefore(instruction, move_arg, /*env=*/nullptr, kEffect);
        }
      }
      instruction->ReplaceInputsWithMoveArguments(arguments);
      if (instruction->env() != nullptr) {
        instruction->RepairArgumentUsesInEnvironment();
      }
    }
  }
  set_max_argument_slot_count(max_argument_slot_count);
}

◆ InsertSpeculativeAfter()

void dart::FlowGraph::InsertSpeculativeAfter	(	Instruction *	prev,
		Instruction *	instr,
		Environment *	env,
		UseKind	use_kind
	)

Definition at line 288 of file flow_graph.cc.

                                                         {
  InsertAfter(prev, instr, env, use_kind);
  if (instr->env() != nullptr) {
    instr->env()->MarkAsLazyDeoptToBeforeDeoptId();
  }
}

◆ InsertSpeculativeBefore()

void dart::FlowGraph::InsertSpeculativeBefore	(	Instruction *	next,
		Instruction *	instr,
		Environment *	env,
		UseKind	use_kind
	)

inline

Definition at line 318 of file flow_graph.h.

                                                 {
    InsertSpeculativeAfter(next->previous(), instr, env, use_kind);
  }

◆ InstructionCount()

intptr_t dart::FlowGraph::InstructionCount ( ) const

Definition at line 1896 of file flow_graph.cc.

                                           {
  intptr_t size = 0;
  // Iterate each block, skipping the graph entry.
  for (intptr_t i = 1; i < preorder_.length(); ++i) {
    BlockEntryInstr* block = preorder_[i];
 
    // Skip any blocks from the prologue to make them not count towards the
    // inlining instruction budget.
    const intptr_t block_id = block->block_id();
    if (prologue_info_.Contains(block_id)) {
      continue;
    }
 
    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
      ++size;
    }
  }
  return size;
}

◆ is_huge_method()

bool dart::FlowGraph::is_huge_method ( ) const

inline

Definition at line 423 of file flow_graph.h.

423{ return huge_method_; }

◆ is_licm_allowed()

bool dart::FlowGraph::is_licm_allowed ( ) const

inline

Definition at line 404 of file flow_graph.h.

404{ return licm_allowed_; }

◆ IsCompiledForOsr()

bool dart::FlowGraph::IsCompiledForOsr ( ) const

inline

Definition at line 460 of file flow_graph.h.

460{ return graph_entry()->IsCompiledForOsr(); }

dart::GraphEntryInstr::IsCompiledForOsr

bool IsCompiledForOsr() const

Definition: il.cc:1257

◆ IsConstantRepresentable()

bool dart::FlowGraph::IsConstantRepresentable	(	const Object &	value,
		Representation	target_rep,
		bool	tagged_value_must_be_smi
	)

static

Definition at line 205 of file flow_graph.cc.

                                                                       {
  switch (target_rep) {
    case kTagged:
      return !tagged_value_must_be_smi || value.IsSmi();
 
    case kUnboxedInt32:
      if (value.IsInteger()) {
        return Utils::IsInt(32, Integer::Cast(value).AsInt64Value());
      }
      return false;
 
    case kUnboxedUint32:
      if (value.IsInteger()) {
        return Utils::IsUint(32, Integer::Cast(value).AsInt64Value());
      }
      return false;
 
    case kUnboxedInt64:
      return value.IsInteger();
 
    case kUnboxedFloat:
    case kUnboxedDouble:
      return value.IsInteger() || value.IsDouble();
 
    default:
      return false;
  }
}

◆ IsImmortalVariable()

bool dart::FlowGraph::IsImmortalVariable ( intptr_t env_index ) const

inline

Definition at line 196 of file flow_graph.h.

                                                    {
    return (env_index == CurrentContextEnvIndex()) ||
           (SuspendStateVar() != nullptr &&
            env_index == SuspendStateEnvIndex());
  }

◆ IsIrregexpFunction()

bool dart::FlowGraph::IsIrregexpFunction ( ) const

inline

Definition at line 165 of file flow_graph.h.

165{ return function().IsIrregexpFunction(); }

dart::Function::IsIrregexpFunction

bool IsIrregexpFunction() const

Definition: object.h:3898

◆ isolate_group()

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

inline

Definition at line 262 of file flow_graph.h.

262{ return thread()->isolate_group(); }

dart::Thread::isolate_group

IsolateGroup * isolate_group() const

Definition: thread.h:541

◆ IsReceiver()

bool dart::FlowGraph::IsReceiver ( Definition * def ) const

Definition at line 478 of file flow_graph.cc.

                                                {
  def = def->OriginalDefinition();  // Could be redefined.
  if (def->IsParameter()) return (def->AsParameter()->env_index() == 0);
  if (!def->IsPhi() || graph_entry()->HasSingleEntryPoint()) {
    return false;
  }
  PhiInstr* phi = def->AsPhi();
  if (phi->is_receiver() != PhiInstr::kUnknownReceiver) {
    return (phi->is_receiver() == PhiInstr::kReceiver);
  }
  // Not known if this phi is the receiver yet. Compute it now.
  ComputeIsReceiver(phi);
  return (phi->is_receiver() == PhiInstr::kReceiver);
}

◆ loop_hierarchy()

const LoopHierarchy & dart::FlowGraph::loop_hierarchy ( ) const

inline

Definition at line 437 of file flow_graph.h.

437{ return *loop_hierarchy_; }

◆ loop_invariant_loads()

ZoneGrowableArray< BitVector * > * dart::FlowGraph::loop_invariant_loads ( ) const

inline

Definition at line 452 of file flow_graph.h.

                                                              {
    return loop_invariant_loads_;
  }

◆ mark_huge_method()

void dart::FlowGraph::mark_huge_method ( )

inline

Definition at line 425 of file flow_graph.h.

425{ huge_method_ = true; }

◆ max_argument_slot_count()

intptr_t dart::FlowGraph::max_argument_slot_count ( ) const

inline

Definition at line 562 of file flow_graph.h.

                                           {
    RELEASE_ASSERT(max_argument_slot_count_ >= 0);
    return max_argument_slot_count_;
  }

◆ max_block_id()

intptr_t dart::FlowGraph::max_block_id ( ) const

inline

Definition at line 264 of file flow_graph.h.

264{ return max_block_id_; }

◆ max_vreg()

intptr_t dart::FlowGraph::max_vreg ( ) const

inline

Definition at line 248 of file flow_graph.h.

                            {
    return current_ssa_temp_index() * kMaxLocationCount;
  }

◆ MergeBlocks()

void dart::FlowGraph::MergeBlocks ( )

Definition at line 389 of file flow_graph.cc.

                            {
  bool changed = false;
  BitVector* merged = new (zone()) BitVector(zone(), postorder().length());
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    BlockEntryInstr* block = block_it.Current();
    if (block->IsGraphEntry()) continue;
    if (merged->Contains(block->postorder_number())) continue;
 
    Instruction* last = block->last_instruction();
    BlockEntryInstr* last_merged_block = nullptr;
    while (auto goto_instr = last->AsGoto()) {
      JoinEntryInstr* successor = goto_instr->successor();
      if (successor->PredecessorCount() > 1) break;
      if (block->try_index() != successor->try_index()) break;
 
      // Replace all phis with their arguments prior to removing successor.
      for (PhiIterator it(successor); !it.Done(); it.Advance()) {
        PhiInstr* phi = it.Current();
        Value* input = phi->InputAt(0);
        phi->ReplaceUsesWith(input->definition());
        input->RemoveFromUseList();
      }
 
      // Remove environment uses and unlink goto and block entry.
      successor->UnuseAllInputs();
      last->previous()->LinkTo(successor->next());
      last->UnuseAllInputs();
 
      last = successor->last_instruction();
      merged->Add(successor->postorder_number());
      last_merged_block = successor;
      changed = true;
      if (FLAG_trace_optimization && should_print()) {
        THR_Print("Merged blocks B%" Pd " and B%" Pd "\n", block->block_id(),
                  successor->block_id());
      }
    }
    // The new block inherits the block id of the last successor to maintain
    // the order of phi inputs at its successors consistent with block ids.
    if (last_merged_block != nullptr) {
      block->set_block_id(last_merged_block->block_id());
    }
  }
  // Recompute block order after changes were made.
  if (changed) DiscoverBlocks();
}

◆ NewDiamond() [1/2]

JoinEntryInstr * dart::FlowGraph::NewDiamond	(	Instruction *	instruction,
		Instruction *	inherit,
		ComparisonInstr *	compare,
		TargetEntryInstr **	block_true,
		TargetEntryInstr **	block_false
	)

Definition at line 2858 of file flow_graph.cc.

                                                                  {
  BlockEntryInstr* entry = instruction->GetBlock();
 
  TargetEntryInstr* bt = NewTarget(this, inherit);
  TargetEntryInstr* bf = NewTarget(this, inherit);
  JoinEntryInstr* join = NewJoin(this, inherit);
  GotoInstr* gotot = NewGoto(this, join, inherit);
  GotoInstr* gotof = NewGoto(this, join, inherit);
  BranchInstr* bra = NewBranch(this, compare, inherit);
 
  instruction->AppendInstruction(bra);
  entry->set_last_instruction(bra);
 
  *bra->true_successor_address() = bt;
  *bra->false_successor_address() = bf;
 
  bt->AppendInstruction(gotot);
  bt->set_last_instruction(gotot);
 
  bf->AppendInstruction(gotof);
  bf->set_last_instruction(gotof);
 
  // Update dominance relation incrementally.
  for (intptr_t i = 0, n = entry->dominated_blocks().length(); i < n; ++i) {
    join->AddDominatedBlock(entry->dominated_blocks()[i]);
  }
  entry->ClearDominatedBlocks();
  entry->AddDominatedBlock(bt);
  entry->AddDominatedBlock(bf);
  entry->AddDominatedBlock(join);
 
  // TODO(ajcbik): update pred/succ/ordering incrementally too.
 
  // Return new blocks.
  *b_true = bt;
  *b_false = bf;
  return join;
}

◆ NewDiamond() [2/2]

JoinEntryInstr * dart::FlowGraph::NewDiamond	(	Instruction *	instruction,
		Instruction *	inherit,
		const LogicalAnd &	condition,
		TargetEntryInstr **	block_true,
		TargetEntryInstr **	block_false
	)

Definition at line 2901 of file flow_graph.cc.

                                                                  {
  // First diamond for first comparison.
  TargetEntryInstr* bt = nullptr;
  TargetEntryInstr* bf = nullptr;
  JoinEntryInstr* mid_point =
      NewDiamond(instruction, inherit, condition.oper1, &bt, &bf);
 
  // Short-circuit second comparison and connect through phi.
  condition.oper2->InsertAfter(bt);
  AllocateSSAIndex(condition.oper2);
  condition.oper2->InheritDeoptTarget(zone(), inherit);  // must inherit
  PhiInstr* phi =
      AddPhi(mid_point, condition.oper2, GetConstant(Bool::False()));
  StrictCompareInstr* circuit = new (zone()) StrictCompareInstr(
      inherit->source(), Token::kEQ_STRICT, new (zone()) Value(phi),
      new (zone()) Value(GetConstant(Bool::True())), false,
      DeoptId::kNone);  // don't inherit
 
  // Return new blocks through the second diamond.
  return NewDiamond(mid_point, inherit, circuit, b_true, b_false);
}

◆ num_direct_parameters()

intptr_t dart::FlowGraph::num_direct_parameters ( ) const

inline

Definition at line 137 of file flow_graph.h.

137{ return num_direct_parameters_; }

◆ num_stack_locals()

intptr_t dart::FlowGraph::num_stack_locals ( ) const

inline

Definition at line 161 of file flow_graph.h.

                                    {
    return parsed_function_.num_stack_locals();
  }

◆ optimized_block_order()

const GrowableArray< BlockEntryInstr * > & dart::FlowGraph::optimized_block_order ( ) const

inline

Definition at line 210 of file flow_graph.h.

                                                                       {
    return optimized_block_order_;
  }

◆ osr_variable_count()

intptr_t dart::FlowGraph::osr_variable_count ( ) const

inline

Definition at line 149 of file flow_graph.h.

                                      {
    ASSERT(IsCompiledForOsr());
    return variable_count() + graph_entry()->osr_entry()->stack_depth();
  }

◆ ParameterRepresentationAt()

Representation dart::FlowGraph::ParameterRepresentationAt	(	const Function &	function,
		intptr_t	index
	)

static

Definition at line 109 of file flow_graph.cc.

                                                                    {
  if (function.IsNull()) {
    return kTagged;
  }
  ASSERT(index < function.NumParameters());
  if (function.is_unboxed_integer_parameter_at(index)) {
    return kUnboxedInt64;
  } else if (function.is_unboxed_double_parameter_at(index)) {
    return kUnboxedDouble;
  } else {
    ASSERT(!function.is_unboxed_parameter_at(index));
    return kTagged;
  }
}

◆ parsed_function()

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

inline

Definition at line 129 of file flow_graph.h.

129{ return parsed_function_; }

◆ PopulateWithICData()

void dart::FlowGraph::PopulateWithICData ( const Function & function )

Definition at line 2528 of file flow_graph.cc.

                                                           {
  Zone* zone = Thread::Current()->zone();
 
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    ForwardInstructionIterator it(block_it.Current());
    for (; !it.Done(); it.Advance()) {
      Instruction* instr = it.Current();
      if (instr->IsInstanceCall()) {
        InstanceCallInstr* call = instr->AsInstanceCall();
        if (!call->HasICData()) {
          const Array& arguments_descriptor =
              Array::Handle(zone, call->GetArgumentsDescriptor());
          const ICData& ic_data = ICData::ZoneHandle(
              zone,
              ICData::New(function, call->function_name(), arguments_descriptor,
                          call->deopt_id(), call->checked_argument_count(),
                          ICData::kInstance));
          call->set_ic_data(&ic_data);
        }
      } else if (instr->IsStaticCall()) {
        StaticCallInstr* call = instr->AsStaticCall();
        if (!call->HasICData()) {
          const Array& arguments_descriptor =
              Array::Handle(zone, call->GetArgumentsDescriptor());
          const Function& target = call->function();
          int num_args_checked =
              MethodRecognizer::NumArgsCheckedForStaticCall(target);
          const ICData& ic_data = ICData::ZoneHandle(
              zone, ICData::NewForStaticCall(
                        function, target, arguments_descriptor,
                        call->deopt_id(), num_args_checked, ICData::kStatic));
          call->set_ic_data(&ic_data);
        }
      }
    }
  }
}

◆ postorder()

const GrowableArray< BlockEntryInstr * > & dart::FlowGraph::postorder ( ) const

inline

Definition at line 204 of file flow_graph.h.

                                                           {
    return postorder_;
  }

◆ postorder_iterator()

BlockIterator dart::FlowGraph::postorder_iterator ( ) const

inline

Definition at line 222 of file flow_graph.h.

                                           {
    return BlockIterator(postorder());
  }

◆ preorder()

const GrowableArray< BlockEntryInstr * > & dart::FlowGraph::preorder ( ) const

inline

Definition at line 203 of file flow_graph.h.

203{ return preorder_; }

◆ Print()

void dart::FlowGraph::Print ( const char * phase = "unknown" )

Definition at line 3012 of file flow_graph.cc.

                                       {
  FlowGraphPrinter::PrintGraph(phase, this);
}

◆ prologue_info()

PrologueInfo dart::FlowGraph::prologue_info ( ) const

inline

Definition at line 427 of file flow_graph.h.

427{ return prologue_info_; }

◆ RawTypeArgumentEnvIndex()

intptr_t dart::FlowGraph::RawTypeArgumentEnvIndex ( ) const

inline

Definition at line 181 of file flow_graph.h.

                                           {
    return EnvIndex(parsed_function().RawTypeArgumentsVariable());
  }

◆ RemoveRedefinitions()

void dart::FlowGraph::RemoveRedefinitions ( bool keep_checks = false )

Definition at line 1810 of file flow_graph.cc.

                                                    {
  // Remove redefinition and check instructions that were inserted
  // to make a control dependence explicit with a data dependence,
  // for example, to inhibit hoisting.
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    thread()->CheckForSafepoint();
    for (ForwardInstructionIterator instr_it(block_it.Current());
         !instr_it.Done(); instr_it.Advance()) {
      Instruction* instruction = instr_it.Current();
      if (auto redef = instruction->AsRedefinition()) {
        redef->ReplaceUsesWith(redef->value()->definition());
        instr_it.RemoveCurrentFromGraph();
      } else if (keep_checks) {
        continue;
      } else if (auto def = instruction->AsDefinition()) {
        Value* value = def->RedefinedValue();
        if (value != nullptr) {
          def->ReplaceUsesWith(value->definition());
          def->ClearSSATempIndex();
        }
      }
    }
  }
}

◆ RenameDominatedUses()

void dart::FlowGraph::RenameDominatedUses	(	Definition *	def,
		Instruction *	dom,
		Definition *	other
	)

static

Definition at line 2642 of file flow_graph.cc.

                                                       {
  for (Value::Iterator it(def->input_use_list()); !it.Done(); it.Advance()) {
    Value* use = it.Current();
    if (IsDominatedUse(dom, use)) {
      use->BindTo(other);
    }
  }
}

◆ RenameUsesDominatedByRedefinitions()

void dart::FlowGraph::RenameUsesDominatedByRedefinitions ( )

Definition at line 2653 of file flow_graph.cc.

                                                   {
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    for (ForwardInstructionIterator instr_it(block_it.Current());
         !instr_it.Done(); instr_it.Advance()) {
      Definition* definition = instr_it.Current()->AsDefinition();
      // CheckArrayBound instructions have their own mechanism for ensuring
      // proper dependencies, so we don't rewrite those here.
      if (definition != nullptr && !definition->IsCheckArrayBound()) {
        Value* redefined = definition->RedefinedValue();
        if (redefined != nullptr) {
          if (!definition->HasSSATemp()) {
            AllocateSSAIndex(definition);
          }
          Definition* original = redefined->definition();
          RenameDominatedUses(original, definition, definition);
        }
      }
    }
  }
}

◆ ReplaceCurrentInstruction()

void dart::FlowGraph::ReplaceCurrentInstruction	(	ForwardInstructionIterator *	iterator,
		Instruction *	current,
		Instruction *	replacement
	)

Definition at line 141 of file flow_graph.cc.

                                                                    {
  Definition* current_defn = current->AsDefinition();
  if ((replacement != nullptr) && (current_defn != nullptr)) {
    Definition* replacement_defn = replacement->AsDefinition();
    ASSERT(replacement_defn != nullptr);
    current_defn->ReplaceUsesWith(replacement_defn);
    EnsureSSATempIndex(current_defn, replacement_defn);
 
    if (FLAG_trace_optimization && should_print()) {
      THR_Print("Replacing v%" Pd " with v%" Pd "\n",
                current_defn->ssa_temp_index(),
                replacement_defn->ssa_temp_index());
    }
  } else if (FLAG_trace_optimization && should_print()) {
    if (current_defn == nullptr) {
      THR_Print("Removing %s\n", current->DebugName());
    } else {
      ASSERT(!current_defn->HasUses());
      THR_Print("Removing v%" Pd ".\n", current_defn->ssa_temp_index());
    }
  }
  if (current->ArgumentCount() != 0) {
    ASSERT(!current->HasMoveArguments());
  }
  iterator->RemoveCurrentFromGraph();
}

◆ ResetLoopHierarchy()

void dart::FlowGraph::ResetLoopHierarchy ( )

inline

Definition at line 444 of file flow_graph.h.

                            {
    loop_hierarchy_ = nullptr;
    loop_invariant_loads_ = nullptr;
  }

◆ ReturnRepresentationOf()

Representation dart::FlowGraph::ReturnRepresentationOf ( const Function & function )

static

Definition at line 125 of file flow_graph.cc.

                                                                         {
  if (function.IsNull()) {
    return kTagged;
  }
  if (function.has_unboxed_integer_return()) {
    return kUnboxedInt64;
  } else if (function.has_unboxed_double_return()) {
    return kUnboxedDouble;
  } else if (function.has_unboxed_record_return()) {
    return kPairOfTagged;
  } else {
    ASSERT(!function.has_unboxed_return());
    return kTagged;
  }
}

◆ reverse_postorder()

const GrowableArray< BlockEntryInstr * > & dart::FlowGraph::reverse_postorder ( ) const

inline

Definition at line 207 of file flow_graph.h.

                                                                   {
    return reverse_postorder_;
  }

◆ reverse_postorder_iterator()

BlockIterator dart::FlowGraph::reverse_postorder_iterator ( ) const

inline

Definition at line 219 of file flow_graph.h.

                                                   {
    return BlockIterator(reverse_postorder());
  }

◆ SelectRepresentations()

void dart::FlowGraph::SelectRepresentations ( )

Definition at line 2298 of file flow_graph.cc.

                                      {
  // First we decide for each phi if it is beneficial to unbox it. If so, we
  // change it's `phi->representation()`
  PhiUnboxingHeuristic phi_unboxing_heuristic(this);
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    JoinEntryInstr* join_entry = block_it.Current()->AsJoinEntry();
    if (join_entry != nullptr) {
      for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
        PhiInstr* phi = it.Current();
        phi_unboxing_heuristic.Process(phi);
      }
    }
  }
 
  // Process all initial definitions and insert conversions when needed (depends
  // on phi unboxing decision above).
  for (intptr_t i = 0; i < graph_entry()->initial_definitions()->length();
       i++) {
    InsertConversionsFor((*graph_entry()->initial_definitions())[i]);
  }
  for (intptr_t i = 0; i < graph_entry()->SuccessorCount(); ++i) {
    auto successor = graph_entry()->SuccessorAt(i);
    if (auto entry = successor->AsBlockEntryWithInitialDefs()) {
      auto& initial_definitions = *entry->initial_definitions();
      for (intptr_t j = 0; j < initial_definitions.length(); j++) {
        InsertConversionsFor(initial_definitions[j]);
      }
    }
  }
 
  // Process all normal definitions and insert conversions when needed (depends
  // on phi unboxing decision above).
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    BlockEntryInstr* entry = block_it.Current();
    if (JoinEntryInstr* join_entry = entry->AsJoinEntry()) {
      for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
        PhiInstr* phi = it.Current();
        ASSERT(phi != nullptr);
        ASSERT(phi->is_alive());
        InsertConversionsFor(phi);
      }
    }
    for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
      Definition* def = it.Current()->AsDefinition();
      if (def != nullptr) {
        InsertConversionsFor(def);
      }
    }
  }
}

◆ set_coverage_array()

void dart::FlowGraph::set_coverage_array ( const Array & array )

inline

Definition at line 551 of file flow_graph.h.

551{ coverage_array_ = &array; }

◆ set_current_ssa_temp_index()

void dart::FlowGraph::set_current_ssa_temp_index ( intptr_t index )

inline

Definition at line 244 of file flow_graph.h.

                                                  {
    current_ssa_temp_index_ = index;
  }

◆ set_inlining_id()

void dart::FlowGraph::set_inlining_id ( intptr_t value )

inline

Definition at line 465 of file flow_graph.h.

465{ inlining_id_ = value; }

◆ set_loop_invariant_loads()

void dart::FlowGraph::set_loop_invariant_loads ( ZoneGrowableArray< BitVector * > * loop_invariant_loads )

inline

Definition at line 455 of file flow_graph.h.

                                                           {
    loop_invariant_loads_ = loop_invariant_loads;
  }

◆ set_max_argument_slot_count()

void dart::FlowGraph::set_max_argument_slot_count ( intptr_t count )

inline

Definition at line 566 of file flow_graph.h.

                                                   {
    RELEASE_ASSERT(max_argument_slot_count_ == -1);
    max_argument_slot_count_ = count;
  }

◆ set_max_block_id()

void dart::FlowGraph::set_max_block_id ( intptr_t id )

inline

Definition at line 265 of file flow_graph.h.

265{ max_block_id_ = id; }

id

const uintptr_t id

Definition: texture_unittests.cc:27

◆ should_print()

bool dart::FlowGraph::should_print ( ) const

inline

Definition at line 503 of file flow_graph.h.

503{ return should_print_; }

◆ should_remove_all_bounds_checks()

bool dart::FlowGraph::should_remove_all_bounds_checks ( ) const

inline

Definition at line 510 of file flow_graph.h.

                                               {
    return should_remove_all_bounds_checks_;
  }

◆ should_reorder_blocks()

bool dart::FlowGraph::should_reorder_blocks ( ) const

inline

Definition at line 508 of file flow_graph.h.

508{ return should_reorder_blocks_; }

◆ SuspendStateEnvIndex()

intptr_t dart::FlowGraph::SuspendStateEnvIndex ( ) const

inline

Definition at line 171 of file flow_graph.h.

171{ return EnvIndex(SuspendStateVar()); }

◆ SuspendStateVar()

LocalVariable * dart::FlowGraph::SuspendStateVar ( ) const

inline

Definition at line 167 of file flow_graph.h.

                                         {
    return parsed_function().suspend_state_var();
  }

◆ thread()

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

inline

Definition at line 260 of file flow_graph.h.

260{ return thread_; }

◆ TryCreateConstantReplacementFor()

Definition * dart::FlowGraph::TryCreateConstantReplacementFor	(	Definition *	op,
		const Object &	value
	)

Definition at line 236 of file flow_graph.cc.

                                                                            {
  // Check that representation of the constant matches expected representation.
  const auto representation = op->representation();
  if (!IsConstantRepresentable(
          value, representation,
          /*tagged_value_must_be_smi=*/op->Type()->IsNullableSmi())) {
    return op;
  }
 
  if (((representation == kUnboxedFloat) ||
       (representation == kUnboxedDouble)) &&
      value.IsInteger()) {
    // Convert the boxed constant from int to float/double.
    return GetConstant(Double::Handle(Double::NewCanonical(
                           Integer::Cast(value).AsDoubleValue())),
                       representation);
  }
 
  return GetConstant(value, representation);
}

◆ TryOptimizePatterns()

void dart::FlowGraph::TryOptimizePatterns ( )

Definition at line 2570 of file flow_graph.cc.

                                    {
  if (!FLAG_truncating_left_shift) return;
  GrowableArray<BinarySmiOpInstr*> div_mod_merge;
  GrowableArray<InvokeMathCFunctionInstr*> sin_cos_merge;
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    // Merging only per basic-block.
    div_mod_merge.Clear();
    sin_cos_merge.Clear();
    ForwardInstructionIterator it(block_it.Current());
    for (; !it.Done(); it.Advance()) {
      if (it.Current()->IsBinarySmiOp()) {
        BinarySmiOpInstr* binop = it.Current()->AsBinarySmiOp();
        if (binop->op_kind() == Token::kBIT_AND) {
          OptimizeLeftShiftBitAndSmiOp(&it, binop, binop->left()->definition(),
                                       binop->right()->definition());
        } else if ((binop->op_kind() == Token::kTRUNCDIV) ||
                   (binop->op_kind() == Token::kMOD)) {
          if (binop->HasUses()) {
            div_mod_merge.Add(binop);
          }
        }
      } else if (it.Current()->IsBinaryInt64Op()) {
        BinaryInt64OpInstr* mintop = it.Current()->AsBinaryInt64Op();
        if (mintop->op_kind() == Token::kBIT_AND) {
          OptimizeLeftShiftBitAndSmiOp(&it, mintop,
                                       mintop->left()->definition(),
                                       mintop->right()->definition());
        }
      } else if (it.Current()->IsInvokeMathCFunction()) {
        InvokeMathCFunctionInstr* math_unary =
            it.Current()->AsInvokeMathCFunction();
        if ((math_unary->recognized_kind() == MethodRecognizer::kMathSin) ||
            (math_unary->recognized_kind() == MethodRecognizer::kMathCos)) {
          if (math_unary->HasUses()) {
            sin_cos_merge.Add(math_unary);
          }
        }
      }
    }
    TryMergeTruncDivMod(&div_mod_merge);
  }
}

◆ unmatched_representations_allowed()

bool dart::FlowGraph::unmatched_representations_allowed ( ) const

inline

Definition at line 411 of file flow_graph.h.

                                                 {
    return unmatched_representations_allowed_;
  }

◆ variable_count()

intptr_t dart::FlowGraph::variable_count ( ) const

inline

Definition at line 143 of file flow_graph.h.

                                  {
    return num_direct_parameters_ + parsed_function_.num_stack_locals();
  }

◆ VerifyRedefinitions()

bool dart::FlowGraph::VerifyRedefinitions ( )

Definition at line 652 of file flow_graph.cc.

                                    {
  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
       block_it.Advance()) {
    for (ForwardInstructionIterator instr_it(block_it.Current());
         !instr_it.Done(); instr_it.Advance()) {
      RedefinitionInstr* redefinition = instr_it.Current()->AsRedefinition();
      if (redefinition != nullptr) {
        Definition* original = redefinition->value()->definition();
        for (Value::Iterator it(original->input_use_list()); !it.Done();
             it.Advance()) {
          Value* original_use = it.Current();
          if (original_use->instruction() == redefinition) {
            continue;
          }
          if (original_use->instruction()->IsDominatedBy(redefinition)) {
            FlowGraphPrinter::PrintGraph("VerifyRedefinitions", this);
            THR_Print("%s\n", redefinition->ToCString());
            THR_Print("use=%s\n", original_use->instruction()->ToCString());
            return false;
          }
        }
      }
    }
  }
  return true;
}

◆ zone()

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

inline

Definition at line 261 of file flow_graph.h.

261{ return thread()->zone(); }

Friends And Related Function Documentation

◆ BranchSimplifier

friend class BranchSimplifier

friend

Definition at line 606 of file flow_graph.h.

◆ compiler::GraphIntrinsifier

friend class compiler::GraphIntrinsifier

friend

Definition at line 609 of file flow_graph.h.

◆ ConstantPropagator

friend class ConstantPropagator

friend

Definition at line 607 of file flow_graph.h.

◆ DeadCodeElimination

friend class DeadCodeElimination

friend

Definition at line 608 of file flow_graph.h.

◆ FlowGraphChecker

friend class FlowGraphChecker

friend

Definition at line 604 of file flow_graph.h.

◆ FlowGraphCompiler

friend class FlowGraphCompiler

friend

Definition at line 603 of file flow_graph.h.

◆ IfConverter

friend class IfConverter

friend

Definition at line 605 of file flow_graph.h.

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Enumeration Documentation

◆ CompilationMode

◆ ToCheck

◆ UseKind

Constructor & Destructor Documentation

◆ FlowGraph()

Member Function Documentation

◆ AddExactnessGuard()

◆ AddPhi()

◆ AddToGraphInitialDefinitions()

◆ AddToInitialDefinitions()

◆ allocate_block_id()

◆ AllocateSSAIndex()

◆ AppendSpeculativeTo()

◆ AppendTo()

◆ ArgumentDescriptorEnvIndex()

◆ Canonicalize()

◆ captured_parameters()

◆ CheckForInstanceCall()

◆ CodegenBlockOrder() [1/2]

◆ CodegenBlockOrder() [2/2]

◆ CompactSSA()

◆ CompilationModeFrom()

◆ compiler_pass_filters()

◆ ComputeArgumentsSizeInWords()

◆ ComputeDominators()

◆ ComputeLocationsOfFixedParameters()

◆ ComputeSSA()

◆ constant_dead()

◆ constant_null()

◆ CopyDeoptTarget()

◆ coverage_array()

◆ CreateCheckBound()

◆ CreateCheckClass()

◆ CreateCommonConstants()

◆ current_ssa_temp_index()

◆ CurrentContextEnvIndex()

◆ CurrentContextVar()

◆ disallow_licm()

◆ disallow_unmatched_representations()

◆ DiscoverBlocks()

◆ EliminateEnvironments()

◆ EnsureRedefinition()

◆ EnsureSSATempIndex()

◆ EnvIndex()

◆ ExtractExternalUntaggedPayload()

◆ ExtractNonInternalTypedDataPayloads()

◆ function()

◆ GetConstant()

◆ GetDirectParameterInfoAt()

◆ GetExistingConstant()

◆ GetLoopHierarchy()

◆ graph_entry()

◆ inlining_id()

◆ InsertAfter()

◆ InsertBefore()

◆ InsertMoveArguments()

◆ InsertSpeculativeAfter()

◆ InsertSpeculativeBefore()

◆ InstructionCount()

◆ is_huge_method()

◆ is_licm_allowed()

◆ IsCompiledForOsr()

◆ IsConstantRepresentable()

◆ IsImmortalVariable()

◆ IsIrregexpFunction()

◆ isolate_group()

◆ IsReceiver()

◆ loop_hierarchy()

◆ loop_invariant_loads()

◆ mark_huge_method()

◆ max_argument_slot_count()

◆ max_block_id()

◆ max_vreg()