refinement.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 <set>
#include <unordered_set>
 
#include "core/inst_visitor.h"
#include "core/target.h"
#include "passes/tags/tagged_type.h"
 
 
 
namespace tags {
 
class RegisterAnalysis;
struct DominatorCache;
 
class Refinement : public InstVisitor<void> {
public:
  Refinement(
      RegisterAnalysis &analysis,
      const Target *target,
      bool banPolymorphism,
      Func &func
  );
 
  void Run();
 
private:
  void PullFrontier();
 
  void Refine(Block *parent, Ref<Inst> ref, const TaggedType &type);
  void Refine(Block *start, Block *end, Ref<Inst> ref, const TaggedType &type);
  void Refine(Ref<Inst> ref, const TaggedType &type);
  void RefineJoin(Ref<Inst> ref, const TaggedType &ty, Use &use, Type type);
  Ref<Inst> Cast(Ref<Inst> ref, const TaggedType &ty);
  bool IsNonPolymorphic(Ref<Inst> ref, const TaggedType &ty);
  void Specialise(
      Ref<Inst> ref,
      const Block *from,
      const std::vector<std::pair<TaggedType, Block *>> &branches
  );
 
private:
  void RefineUpdate(Ref<Inst> inst, const TaggedType &type);
  void DefineUpdate(Ref<Inst> inst, const TaggedType &type);
  void Queue(Ref<Inst> inst);
 
private:
  void RefineAddr(Inst &inst, Ref<Inst> addr);
  void RefineInt(Inst &inst, Ref<Inst> addr);
  void RefineFunc(Inst &inst, Ref<Inst> addr);
 
private:
  void VisitMemoryLoadInst(MemoryLoadInst &i) override;
  void VisitMemoryStoreInst(MemoryStoreInst &i) override;
  void VisitSelectInst(SelectInst &i) override;
  void VisitSubInst(SubInst &i) override;
  void VisitAddInst(AddInst &i) override;
  void VisitAndInst(AndInst &i) override;
  void VisitOrInst(OrInst &i) override;
  void VisitXorInst(XorInst &i) override;
  void VisitCmpInst(CmpInst &i) override;
  void VisitMovInst(MovInst &i) override;
  void VisitPhiInst(PhiInst &phi) override;
  void VisitArgInst(ArgInst &arg) override;
  void VisitCallSite(CallSite &site) override;
  void VisitJumpCondInst(JumpCondInst &site) override;
  void VisitInst(Inst &i) override {}
 
private:
  void RefineEquality(
      Ref<Inst> lhs,
      Ref<Inst> rhs,
      Block *b,
      Block *bt,
      Block *bf
  );
  void RefineInequality(
      Ref<Inst> lhs,
      Ref<Inst> rhs,
      Block *b,
      Block *bt,
      Block *bf
  );
  void RefineAndOne(Ref<Inst> arg, Block *b, Block *bt, Block *bf);
 
private:
  std::pair<std::set<Block *>, std::set<Block *>>
  Liveness(
      Ref<Inst> ref,
      const llvm::SmallPtrSetImpl<const Block *> &defs
  );
  void DefineSplits(
      DominatorCache &doms,
      Ref<Inst> ref,
      const std::unordered_map<const Block *, TaggedType> &splits
  );
 
private:
  RegisterAnalysis &analysis_;
  const Target *target_;
  bool banPolymorphism_;
  Func &func_;
  std::queue<Inst *> queue_;
  std::unordered_set<Inst *> inQueue_;
};
 
} // end namespace