clone.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 <unordered_map>
 
#include "core/cast.h"
#include "core/insts.h"
 
class Inst;
class Block;
class Global;
class Prog;
 
 
 
class CloneVisitor {
public:
  virtual ~CloneVisitor();
 
public:
  virtual Block *Map(Block *block) { return block; }
  virtual Func *Map(Func *func) { return func; }
  virtual Extern *Map(Extern *ext) { return ext; }
  virtual Atom *Map(Atom *atom) { return atom; }
  virtual Constant *Map(Constant *constant) { return constant; }
  virtual Global *Map(Global *global);
  virtual Expr *Map(Expr *expr);
  virtual AnnotSet Annot(const Inst *inst);
 
public:
  virtual Ref<Inst> Map(Ref<Inst> inst) { return inst; }
  virtual Type Map(Type ty, Inst *inst, unsigned idx) { return ty; }
 
public:
  virtual Inst *Clone(Inst *inst);
  void Fixup();
 
public:
  // Declaration of individual clone methods.
  #define GET_INST(kind, type, name, sort) \
    virtual Inst *Clone(type *i);
  #include "instructions.def"
 
protected:
  Ref<Value> Map(Ref<Value> value);
 
  template<typename It, typename T = typename It::value_type>
  std::vector<T> Map(llvm::iterator_range<It> range)
  {
    std::vector<T> args;
    for (T arg : range) {
      args.push_back(Map(arg));
    }
    return args;
  }
 
protected:
  llvm::SmallVector<std::pair<PhiInst *, PhiInst *>, 10> fixups_;
};
 
 
std::pair<std::unique_ptr<Prog>, Inst *> Clone(Prog &oldProg, Inst *inst);
 
 
template<typename T>
std::pair<std::unique_ptr<Prog>, T *> CloneT(Prog &oldProg, T *inst)
{
  auto &&[prog, newInst] = Clone(oldProg, inst);
  return { std::move(prog), static_cast<T *>(newInst) };
}
 
 
std::unique_ptr<Prog> Clone(Prog &oldProg);