dart::CompilerPass Class Reference

#include <compiler_pass.h>

Public Types
enum	Id
enum	Flag {   kDisabled = 1 << 0 , kTraceBefore = 1 << 1 , kTraceAfter = 1 << 2 , kSticky = 1 << 3 ,   kTraceBeforeOrAfter = kTraceBefore | kTraceAfter }
enum	PipelineMode { kJIT , kAOT }

Public Member Functions
	CompilerPass (Id id, const char *name)
virtual	~CompilerPass ()
void	Run (CompilerPassState *state) const
uint8_t	flags () const
const char *	name () const
Id	id () const

Static Public Member Functions
static CompilerPass *	Get (Id id)
static void	ParseFiltersFromFlag (const char *filter)
static uint8_t *	ParseFiltersFromPragma (const char *filter)
static void	ParseFilters (const char *filter, uint8_t *flags)
static void	ParseOneFilter (const char *start, const char *end, uint8_t *flags)
static void	GenerateCode (CompilerPassState *state)
static void	RunGraphIntrinsicPipeline (CompilerPassState *state)
static void	RunInliningPipeline (PipelineMode mode, CompilerPassState *state)
static DART_WARN_UNUSED_RESULT FlowGraph *	RunPipeline (PipelineMode mode, CompilerPassState *state, bool compute_ssa=true)
static DART_WARN_UNUSED_RESULT FlowGraph *	RunPipelineWithPasses (CompilerPassState *state, std::initializer_list< CompilerPass::Id > passes)

Static Public Attributes
static constexpr intptr_t	kNumPasses = 0 COMPILER_PASS_LIST(ADD_ONE)

Protected Member Functions
virtual bool	DoBody (CompilerPassState *state) const =0

Detailed Description

Definition at line 106 of file compiler_pass.h.

Member Enumeration Documentation

Flag

enum dart::CompilerPass::Flag

Enumerator
kDisabled
kTraceBefore
kTraceAfter
kSticky
kTraceBeforeOrAfter

Definition at line 131 of file compiler_pass.h.

            {
    kDisabled = 1 << 0,
    kTraceBefore = 1 << 1,
    kTraceAfter = 1 << 2,
    kSticky = 1 << 3,
    kTraceBeforeOrAfter = kTraceBefore | kTraceAfter,
  };

Id

enum dart::CompilerPass::Id

Definition at line 108 of file compiler_pass.h.

          {
#define DEF(name) k##name,
    COMPILER_PASS_LIST(DEF)
#undef DEF
  };

PipelineMode

enum dart::CompilerPass::PipelineMode

Enumerator
kJIT
kAOT

Definition at line 154 of file compiler_pass.h.

{ kJIT, kAOT };

Constructor & Destructor Documentation

CompilerPass()

dart::CompilerPass::CompilerPass ( Id  id, const char *  name  )

inline

Definition at line 118 of file compiler_pass.h.

                                        : id_(id), name_(name) {
    ASSERT(passes_[id] == nullptr);
    passes_[id] = this;
 
    // By default print the final flow-graph after the register allocation.
    if (id == kAllocateRegisters) {
      flags_[id] = kTraceAfter;
    } else {
      flags_[id] = 0;
    }
  }

~CompilerPass()

virtual dart::CompilerPass::~CompilerPass ( )

inlinevirtual

Definition at line 129 of file compiler_pass.h.

{}

Member Function Documentation

DoBody()

virtual bool dart::CompilerPass::DoBody ( CompilerPassState *  state ) const

protectedpure virtual

flags()

uint8_t dart::CompilerPass::flags ( ) const

inline

Definition at line 141 of file compiler_pass.h.

{ return flags_[id()]; }

GenerateCode()

static void dart::CompilerPass::GenerateCode ( CompilerPassState *  state )

inlinestatic

Definition at line 156 of file compiler_pass.h.

                                                     {
    CompilerPass::Get(CompilerPass::kGenerateCode)->Run(state);
  }

Get()

static CompilerPass * dart::CompilerPass::Get ( Id  id )

inlinestatic

Definition at line 145 of file compiler_pass.h.

{ return passes_[id]; }

id()

Id dart::CompilerPass::id ( ) const

inline

Definition at line 143 of file compiler_pass.h.

{ return id_; }

name()

const char * dart::CompilerPass::name ( ) const

inline

Definition at line 142 of file compiler_pass.h.

{ return name_; }

ParseFilters()

void dart::CompilerPass::ParseFilters ( const char *  filter, uint8_t *  flags  )

static

Definition at line 127 of file compiler_pass.cc.

                                                                       {
  if (filter == nullptr || *filter == 0) {
    return;
  }
 
  if (strcmp(filter, "help") == 0) {
    OS::PrintErr("%s", kCompilerPassesUsage);
    for (intptr_t i = 0; i < kNumPasses; i++) {
      if (passes_[i] != nullptr) {
        OS::PrintErr("  %s\n", passes_[i]->name());
      }
    }
    return;
  }
 
  // Clear all flags.
  memset(pass_flags, 0, CompilerPass::kNumPasses);
 
  for (const char *start = filter, *end = filter; *end != 0;
       start = (end + 1)) {
    // Search forward until the separator ',' or the end of filter is reached.
    end = start;
    while (*end != ',' && *end != '\0') {
      end++;
    }
    if (start == end) {
      OS::PrintErr("Ignoring empty compiler pass flag\n");
      continue;
    }
 
    ParseOneFilter(start, end, pass_flags);
  }
}

ParseFiltersFromFlag()

void dart::CompilerPass::ParseFiltersFromFlag ( const char *  filter )

static

Definition at line 116 of file compiler_pass.cc.

                                                          {
  ParseFilters(filter, flags_);
}

ParseFiltersFromPragma()

uint8_t * dart::CompilerPass::ParseFiltersFromPragma ( const char *  filter )

static

Definition at line 120 of file compiler_pass.cc.

                                                                {
  auto flags =
      ThreadState::Current()->zone()->Alloc<uint8_t>(CompilerPass::kNumPasses);
  ParseFilters(filter, flags);
  return flags;
}

ParseOneFilter()

void dart::CompilerPass::ParseOneFilter ( const char *  start, const char *  end, uint8_t *  flags  )

static

Definition at line 161 of file compiler_pass.cc.

                                                       {
  uint8_t flags = 0;
  if (*start == '-') {
    flags = kDisabled;
  } else if (*start == ']') {
    flags = kTraceAfter;
  } else if (*start == '[') {
    flags = kTraceBefore;
  } else if (*start == '*') {
    flags = kTraceBeforeOrAfter;
  }
  if (flags == 0) {
    flags |= kTraceAfter;
  } else {
    start++;  // Skip the modifier
  }
 
  size_t suffix = 0;
  if (end[-1] == '+') {
    if (start == (end - 1)) {
      OS::PrintErr("Sticky modifier '+' should follow pass name\n");
      return;
    }
    flags |= kSticky;
    suffix = 1;
  }
 
  size_t length = (end - start) - suffix;
  if (length != 0) {
    char* pass_name = Utils::StrNDup(start, length);
    CompilerPass* pass = FindPassByName(pass_name);
    if (pass != nullptr) {
      pass_flags[pass->id()] |= flags;
    } else {
      OS::PrintErr("Unknown compiler pass: %s\n", pass_name);
    }
    free(pass_name);
  } else if (flags == kTraceBeforeOrAfter) {
    for (intptr_t i = 0; i < kNumPasses; i++) {
      pass_flags[i] = kTraceAfter;
    }
  }
}

Run()

void dart::CompilerPass::Run

(

CompilerPassState *

state

)

const

Definition at line 207 of file compiler_pass.cc.

                                                     {
  if ((flags() & kDisabled) != 0) {
    return;
  }
 
  if ((flags() & kSticky) != 0) {
    state->sticky_flags |= flags();
  }
 
  const intptr_t kMaxRounds = 2;
  Thread* thread = state->thread;
  bool repeat = true;
  for (intptr_t round = 1; round <= kMaxRounds && repeat; round++) {
    if (round > 1) {
      Get(kCanonicalize)->Run(state);
    }
 
    CompilerState::Current().set_current_pass(this, state);
    PrintGraph(state, kTraceBefore, round);
    {
      TIMELINE_DURATION(thread, CompilerVerbose, name());
      {
        COMPILER_TIMINGS_PASS_TIMER_SCOPE(thread, id());
        repeat = DoBody(state);
      }
      thread->CheckForSafepoint();
    }
    PrintGraph(state, kTraceAfter, round);
#if defined(DEBUG)
    if (CompilerState::Current().is_optimizing()) {
      FlowGraphChecker(state->flow_graph(), state->inline_id_to_function)
          .Check(name());
    }
#endif
    CompilerState::Current().set_current_pass(nullptr, nullptr);
  }
}

RunGraphIntrinsicPipeline()

void dart::CompilerPass::RunGraphIntrinsicPipeline ( CompilerPassState *  state )

static

Definition at line 279 of file compiler_pass.cc.

                                                                          {
  INVOKE_PASS(AllocateRegistersForGraphIntrinsic);
}

RunInliningPipeline()

void dart::CompilerPass::RunInliningPipeline ( PipelineMode  mode, CompilerPassState *  state  )

static

Definition at line 283 of file compiler_pass.cc.

                                                                      {
  INVOKE_PASS(ApplyClassIds);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(ApplyICData);
  INVOKE_PASS(Canonicalize);
  // Run constant propagation to make sure we specialize for
  // (optional) constant arguments passed into the inlined method.
  INVOKE_PASS(ConstantPropagation);
  // Constant propagation removes unreachable basic blocks and
  // may open more opportunities for call specialization.
  // Call specialization during inlining may cause more call
  // sites to be discovered and more functions inlined.
  INVOKE_PASS_AOT(ApplyClassIds);
  // Optimize (a << b) & c patterns, merge instructions. Must occur
  // before 'SelectRepresentations' which inserts conversion nodes.
  INVOKE_PASS(TryOptimizePatterns);
}

RunPipeline()

FlowGraph * dart::CompilerPass::RunPipeline ( PipelineMode  mode, CompilerPassState *  state, bool  compute_ssa = true  )

static

Definition at line 302 of file compiler_pass.cc.

                                                       {
  if (compute_ssa) {
    INVOKE_PASS(ComputeSSA);
  }
  INVOKE_PASS_AOT(ApplyClassIds);
  INVOKE_PASS_AOT(TypePropagation);
  INVOKE_PASS(ApplyICData);
  INVOKE_PASS(TryOptimizePatterns);
  INVOKE_PASS(SetOuterInliningId);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(ApplyClassIds);
  INVOKE_PASS(Inlining);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(ApplyClassIds);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(ApplyICData);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS(BranchSimplify);
  INVOKE_PASS(IfConvert);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS(ConstantPropagation);
  INVOKE_PASS(OptimisticallySpecializeSmiPhis);
  INVOKE_PASS(TypePropagation);
  // The extra call specialization pass in AOT is able to specialize more
  // calls after ConstantPropagation, which removes unreachable code, and
  // TypePropagation, which can infer more accurate types after removing
  // unreachable code.
  INVOKE_PASS_AOT(ApplyICData);
  INVOKE_PASS_AOT(OptimizeTypedDataAccesses);
  INVOKE_PASS(SelectRepresentations);
  INVOKE_PASS(CSE);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS(LICM);
  INVOKE_PASS(TryOptimizePatterns);
  INVOKE_PASS(DSE);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(RangeAnalysis);
  INVOKE_PASS(OptimizeBranches);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(TryCatchOptimization);
  INVOKE_PASS(EliminateEnvironments);
  INVOKE_PASS(EliminateDeadPhis);
  // Currently DCE assumes that EliminateEnvironments has already been run,
  // so it should not be lifted earlier than that pass.
  INVOKE_PASS(DCE);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS_AOT(DelayAllocations);
  // Repeat branches optimization after DCE, as it could make more
  // empty blocks.
  INVOKE_PASS(OptimizeBranches);
  INVOKE_PASS(AllocationSinking_Sink);
  INVOKE_PASS(EliminateDeadPhis);
  INVOKE_PASS(DCE);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS(TypePropagation);
  INVOKE_PASS(SelectRepresentations_Final);
  INVOKE_PASS(UseTableDispatch);
  INVOKE_PASS(EliminateStackOverflowChecks);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS(AllocationSinking_DetachMaterializations);
  INVOKE_PASS(EliminateWriteBarriers);
  // This must be done after all other possible intra-block code motion.
  INVOKE_PASS(LoweringAfterCodeMotionDisabled);
  INVOKE_PASS(FinalizeGraph);
  INVOKE_PASS(Canonicalize);
  INVOKE_PASS(ReorderBlocks);
  INVOKE_PASS(AllocateRegisters);
  INVOKE_PASS(TestILSerialization);  // Must be last.
  return pass_state->flow_graph();
}

RunPipelineWithPasses()

FlowGraph * dart::CompilerPass::RunPipelineWithPasses ( CompilerPassState *  state, std::initializer_list< CompilerPass::Id >  passes  )

static

Definition at line 375 of file compiler_pass.cc.

                                                {
  for (auto pass_id : passes) {
    passes_[pass_id]->Run(state);
  }
  return state->flow_graph();
}

Member Data Documentation

kNumPasses

constexpr intptr_t dart::CompilerPass::kNumPasses = 0 COMPILER_PASS_LIST(ADD_ONE)

staticconstexpr

Definition at line 115 of file compiler_pass.h.

---

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

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