pass_manager.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <llvm/ADT/ArrayRef.h>
 
#include <type_traits>
#include <unordered_map>
#include <vector>
#include <string>
#include <memory>
#include <set>
 
#include "core/pass.h"
#include "core/analysis.h"
 
class Pass;
class Target;
 
 
 
enum class OptLevel {
  O0,
  O1,
  O2,
  O3,
  O4,
  Os,
};
 
struct PassConfig {
  OptLevel Opt = OptLevel::O0;
  bool Static = false;
  bool Shared = false;
  std::string Entry;
 
  PassConfig() {}
 
  PassConfig(
      OptLevel opt,
      bool isStatic,
      bool isShared,
      std::string entry)
    : Opt(opt)
    , Static(isStatic)
    , Shared(isShared)
    , Entry(entry)
  {
  }
};
 
 
class PassManager final {
public:
  PassManager(
      const PassConfig &config,
      const Target *target,
      const std::string &saveBefore,
      bool verbose,
      bool time,
      bool verify
  );
 
  template<typename T, typename... Args>
  void Add(const Args &... args)
  {
    if constexpr (std::is_base_of<Analysis, T>::value) {
      groups_.emplace_back(std::make_unique<T>(this), &AnalysisID<T>::ID, T::kPassID);
    } else {
      groups_.emplace_back(std::make_unique<T>(this, args...), nullptr, T::kPassID);
    }
  }
 
  template<typename... Ts>
  void Group()
  {
    std::vector<PassInfo> ps;
    ((ps.emplace_back(std::make_unique<Ts>(this), nullptr, Ts::kPassID)), ...);
    groups_.emplace_back(std::move(ps));
  }
 
  void Add(Pass *pass);
  void Run(Prog &prog);
 
  template<typename T> T* getAnalysis()
  {
    if (auto it = analyses_.find(&AnalysisID<T>::ID); it != analyses_.end()) {
      return static_cast<T *>(it->second);
    } else {
      return nullptr;
    }
  }
 
  const PassConfig &GetConfig() const { return config_; }
  const Target *GetTarget() const { return target_; }
 
private:
  struct PassInfo {
    std::unique_ptr<Pass> P;
    const char *ID;
    const char *Name;
 
    PassInfo(std::unique_ptr<Pass> &&pass, const char *id, const char *name)
      : P(std::move(pass))
      , ID(id)
      , Name(name)
    {
    }
  };
 
  bool Run(PassInfo &pass, Prog &prog);
 
  struct GroupInfo {
    std::vector<PassInfo> Passes;
    bool Repeat;
 
    GroupInfo(std::unique_ptr<Pass> &&pass, const char * id, const char *name)
      : Repeat(false)
    {
      Passes.emplace_back(std::move(pass), id, name);
    }
 
    GroupInfo(std::vector<PassInfo> &&passes)
      : Passes(std::move(passes))
      , Repeat(true)
    {
    }
  };
 
  PassConfig config_;
  const Target *target_;
  std::string saveBefore_;
  bool verbose_;
  bool time_;
  bool verify_;
  std::vector<GroupInfo> groups_;
  std::unordered_map<const char *, Pass *> analyses_;
  std::unordered_map<const char *, std::vector<double>> times_;
  std::set<std::string> disabled_;
};
 
 
 
// -----------------------------------------------------------------------------
template<typename T> T* Pass::getAnalysis()
{
  return passManager_->getAnalysis<T>();
}