register_analysis.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 <queue>
#include <unordered_set>
#include <unordered_map>
#include <llvm/Support/raw_ostream.h>
 
#include "core/inst_visitor.h"
#include "core/target.h"
#include "core/analysis/dominator.h"
#include "passes/tags/tagged_type.h"
 
 
 
namespace tags {
class Init;
class Step;
 
struct DominatorCache {
  DominatorTree DT;
  DominanceFrontier DF;
  PostDominatorTree PDT;
  PostDominanceFrontier PDF;
 
  DominatorCache(Func &func);
};
 
class RegisterAnalysis {
public:
  RegisterAnalysis(Prog &prog, const Target *target, bool banPolymorphism)
    : prog_(prog)
    , target_(target)
    , banPolymorphism_(banPolymorphism)
  {
    Solve();
  }
 
  void Solve();
 
  void dump(llvm::raw_ostream &os = llvm::errs());
 
  TaggedType Find(ConstRef<Inst> ref)
  {
    auto it = types_.find(ref);
    return it == types_.end() ? TaggedType::Unknown() : it->second;
  }
 
  void Replace(Ref<Inst> oldInst, Ref<Inst> newInst, const TaggedType &type);
  void Replace(Inst *oldInst, Inst *newInst);
  void Erase(Ref<Inst> oldInst);
 
private:
  friend class Init;
  friend class Step;
  friend class Refinement;
  friend class ConstraintSolver;
 
  bool Mark(Ref<Inst> inst, const TaggedType &type);
  bool Mark(Inst &inst, const TaggedType &type)
  {
    return Mark(inst.GetSubValue(0), type);
  }
 
  bool Define(Ref<Inst> inst, const TaggedType &type);
  bool Refine(Ref<Inst> inst, const TaggedType &type);
  bool Refine(Inst &inst, const TaggedType &type)
  {
    return Refine(inst.GetSubValue(0), type);
  }
  bool IsDefined(Ref<Inst> inst)
  {
    return defs_.count(inst) != 0;
  }
 
  void ForwardQueue(Ref<Inst> inst);
  void BackwardQueue(Ref<Inst > inst);
 
  static bool IsPolymorphic(const Inst &inst);
 
private:
  DominatorCache &GetDoms(Func &func)
  {
    auto it = doms_.emplace(&func, nullptr);
    if (it.second) {
      it.first->second.reset(new DominatorCache(func));
    }
    return *it.first->second;
  }
  DominatorCache &RebuildDoms(Func &func)
  {
    auto it = doms_.emplace(&func, nullptr);
    it.first->second.reset(new DominatorCache(func));
    return *it.first->second;
  }
 
private:
  Prog &prog_;
  const Target *target_;
  bool banPolymorphism_;
  std::queue<Inst *> forwardQueue_;
  std::queue<PhiInst *> forwardPhiQueue_;
  std::unordered_set<Inst *> inForwardQueue_;
  std::queue<Func *> backwardQueue_;
  std::unordered_set<Func *> inBackwardQueue_;
  std::queue<Inst *> refineQueue_;
  std::unordered_set<Inst *> inRefineQueue_;
  std::unordered_map<ConstRef<Inst>, TaggedType> types_;
  std::unordered_map
    < std::pair<const Func *, unsigned>
    , std::vector<ArgInst *>
    > args_;
  std::unordered_map<const Func *, std::vector<TaggedType>> rets_;
  std::unordered_map<Func *, std::unique_ptr<DominatorCache>> doms_;
  std::unordered_set<Ref<Inst>> defs_;
};
 
} // end namespace