utils::PassManager Class Reference

Public Member Functions
	PassManager (CLI::App &app)
bool	Run ()
	Runs all the passes in the pass manager. More...
void	Reset ()
	Resets the pass manager and frees all resources.
Pass const *	LastRun () const
void	SetHeapReuse (bool reuse)
	Sets whether the pass manager should reuse heaps.
	PassManager (PassManager const &)=delete
	PassManager (PassManager &&)=delete
PassManager &	operator= (PassManager const &)=delete
PassManager &	operator= (PassManager &&)=delete
template<typename T , typename... Args>
requires PassType< T > T &	AddPass (Args &&... args)
	Adds a pass to the pass manager. More...
diagnostics::DiagnosticEngine &	Diag ()
	Gets a reference to the diagnostic engine.
PassOptions &	PO ()
	Gets the pass options.
template<typename T >
requires PassType< T > T &	FindPass ()
	Outside method to get a pass by type.
template<typename T >
requires PassType< T > void	PreserveAnalysis ()
	Declare an analysis to be preserved forever.

Friends
class	Pass
class	HeapRef

Detailed Description

Definition at line 196 of file PassManager.h.

Member Function Documentation

AddPass()

template<typename T , typename... Args>

requires PassType<T> T& utils::PassManager::AddPass ( Args &&...  args )

inline

Adds a pass to the pass manager.

Template Parameters

T	The type of the passr

Parameters

...args

The remaining arguments to pass to the pass constructor. The pass manager will be passed to the pass as the first argument.

Definition at line 244 of file PassManager.h.

                              {
      passes_.emplace_back(new T(*this, std::forward<Args>(args)...));
      T& result = *cast<T*>(passes_.back().get());
      // If the pass has a name, register it as constructible from the command
      // line options
      if(!result.Name().empty()) result.RegisterCLI();
      return result;
   }

LastRun()

Pass const* utils::PassManager::LastRun ( ) const

inline

Returns

The last pass that was run by the pass manager

Definition at line 221 of file PassManager.h.

{ return lastRun_; }

Run()

bool utils::PassManager::Run

(

)

Runs all the passes in the pass manager.

Returns

True if all passes ran successfully

Definition at line 123 of file PassManager.cc.

                      {
   std::vector<Pass*> S;
   std::vector<Pass*> L;
   // 1a Propagate the enabled state
   for(auto& pass : passes_) {
      pass->state = Pass::PropagateEnabled;
      pass->computeDependencies();
   }
   // 1b Acquire resources for the passes
   for(auto& pass : passes_) {
      // If the pass is disabled, then we skip it
      if(PO().IsPassDisabled(pass.get())) continue;
      pass->state = Pass::AcquireResources;
      pass->Init();
   }
   // 1c Propagate the heap refcounts
   for(auto& pass : passes_) {
      if(PO().IsPassDisabled(pass.get())) continue;
      pass->computeDependencies();
   }
   if(Diag().Verbose(2)) {
      for(auto& heap : heaps_) {
         Diag().ReportDebug(2) << "[=>] Heap Owner: \"" << heap.owner->Desc()
                               << "\" RefCount: " << heap.refCount;
      }
   }
   // 2. Build the dependency graph of passes
   size_t NumEnabledPasses = 0;
   for(auto& pass : passes_) {
      if(PO().IsPassDisabled(pass.get())) continue;
      NumEnabledPasses++;
      passDeps_[pass.get()] = 0;
      pass->state = Pass::RegisterDependencies;
      pass->computeDependencies();
      // Mark the pass in the graph
      if(passDeps_[pass.get()] == 0) S.push_back(pass.get());
   }
   // 3. Run topological sort on the dependency graph
   while(!S.empty()) {
      auto* n = *S.begin();
      S.erase(S.begin());
      L.push_back(n);
      for(auto* m : depgraph_[n]) {
         if(--passDeps_[m] == 0) S.push_back(m);
      }
      depgraph_[n].clear();
   }
   // 4. Check for cycles
   if(L.size() != NumEnabledPasses)
      throw utils::FatalError("Cyclic pass dependency detected");
   // 5. Run the passes in topological order
   for(auto& pass : L) {
      assert(pass->state != Pass::Valid && "Pass already run");
      pass->state = Pass::Running;
      if(Diag().Verbose()) {
         Diag().ReportDebug() << "[=>] Running " << pass->Desc() << " Pass";
      }
      pass->Run();
      lastRun_ = pass;
      if(Diag().hasErrors()) {
         pass->state = Pass::Invalid;
         return false;
      } else if(Diag().hasWarnings()) {
         pass->state = Pass::Invalid;
         return false;
      }
      // If the pass is running, we can free the heaps by calling
      // computeDependencies again
      pass->state = Pass::Cleanup;
      pass->computeDependencies();
      // Update the pass state
      pass->state = Pass::Valid;
   }
   return true;
}

---

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

• include/utils/PassManager.h
• lib/utils/PassManager.cc