compiler_pass.h File Reference

#include <initializer_list>
#include "vm/growable_array.h"
#include "vm/timer.h"
#include "vm/token_position.h"
#include "vm/zone.h"

Go to the source code of this file.

Classes
struct	dart::CompilerPassState
class	dart::CompilerPass

Namespaces
namespace	dart

Macros
#define	COMPILER_PASS_LIST(V)
#define	DEF(name)   k##name,
#define	ADD_ONE(name)   +1

Macro Definition Documentation

ADD_ONE

#define ADD_ONE

(

name

)

+1

Definition at line 115 of file compiler_pass.h.

COMPILER_PASS_LIST

#define COMPILER_PASS_LIST

(

V

)

Definition at line 21 of file compiler_pass.h.

                         {
  CompilerPassState(Thread* thread,
                    FlowGraph* flow_graph,
                    SpeculativeInliningPolicy* speculative_policy,
                    Precompiler* precompiler = nullptr);
 
  FlowGraph* flow_graph() const { return flow_graph_; }
 
  void set_flow_graph(FlowGraph* flow_graph);
 
  Thread* const thread;
  Precompiler* const precompiler;
  int inlining_depth;
  AllocationSinking* sinking;
 
  // Maps inline_id_to_function[inline_id] -> function. Top scope
  // function has inline_id 0. The map is populated by the inliner.
  GrowableArray<const Function*> inline_id_to_function;
  // Token position where inlining occurred.
  GrowableArray<TokenPosition> inline_id_to_token_pos;
  // For a given inlining-id(index) specifies the caller's inlining-id.
  GrowableArray<intptr_t> caller_inline_id;
 
  CallSpecializer* call_specializer;
 
  SpeculativeInliningPolicy* speculative_policy;
 
  intptr_t sticky_flags;
 
  FlowGraphCompiler* graph_compiler = nullptr;
 
 private:
  FlowGraph* flow_graph_;
};
 
class CompilerPass {
 public:
  enum Id {
#define DEF(name) k##name,
    COMPILER_PASS_LIST(DEF)
#undef DEF
  };
 
#define ADD_ONE(name) +1
  static constexpr intptr_t kNumPasses = 0 COMPILER_PASS_LIST(ADD_ONE);
#undef ADD_ONE
 
  CompilerPass(Id id, const char* name) : 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;
    }
  }
  virtual ~CompilerPass() {}
 
  enum Flag {
    kDisabled = 1 << 0,
    kTraceBefore = 1 << 1,
    kTraceAfter = 1 << 2,
    kSticky = 1 << 3,
    kTraceBeforeOrAfter = kTraceBefore | kTraceAfter,
  };
 
  void Run(CompilerPassState* state) const;
 
  uint8_t flags() const { return flags_[id()]; }
  const char* name() const { return name_; }
  Id id() const { return id_; }
 
  static CompilerPass* Get(Id id) { return passes_[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);
 
  enum PipelineMode { kJIT, kAOT };
 
  static void GenerateCode(CompilerPassState* state) {
    CompilerPass::Get(CompilerPass::kGenerateCode)->Run(state);
  }
 
  static void RunGraphIntrinsicPipeline(CompilerPassState* state);
 
  static void RunInliningPipeline(PipelineMode mode, CompilerPassState* state);
 
  // RunPipeline(WithPasses) may have the side effect of changing the FlowGraph
  // stored in the CompilerPassState. However, existing callers may depend on
  // the old invariant that the FlowGraph stored in the CompilerPassState was
  // always updated, never entirely replaced.
  //
  // To make sure callers are updated properly, these methods also return
  // the final FlowGraph and we add a check that callers use this result.
  DART_WARN_UNUSED_RESULT
  static FlowGraph* RunPipeline(PipelineMode mode, CompilerPassState* state);
  DART_WARN_UNUSED_RESULT
  static FlowGraph* RunPipelineWithPasses(
      CompilerPassState* state,
      std::initializer_list<CompilerPass::Id> passes);
 
 protected:
  // This function executes the pass. If it returns true then
  // we will run Canonicalize on the graph and execute the pass
  // again.
  virtual bool DoBody(CompilerPassState* state) const = 0;
 
 private:
  static CompilerPass* FindPassByName(const char* name) {
    for (intptr_t i = 0; i < kNumPasses; i++) {
      if ((passes_[i] != nullptr) && (strcmp(passes_[i]->name_, name) == 0)) {
        return passes_[i];
      }
    }
    return nullptr;
  }
 
  void PrintGraph(CompilerPassState* state, Flag mask, intptr_t round) const;
 
  static CompilerPass* passes_[];
  static uint8_t flags_[];
 
  Id id_;
  const char* name_;
};
 
}  // namespace dart
 
#endif  // RUNTIME_VM_COMPILER_COMPILER_PASS_H_

DEF

#define DEF

(

name

)

k##name,

Definition at line 110 of file compiler_pass.h.