inst.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 <vector>
#include <optional>
 
#include <llvm/ADT/ilist_node.h>
#include <llvm/ADT/ilist.h>
 
#include "core/annot.h"
#include "core/constant.h"
#include "core/cond.h"
#include "core/expr.h"
#include "core/type.h"
#include "core/register.h"
#include "core/value.h"
#include "core/calling_conv.h"
 
class Block;
class Func;
class Inst;
class Context;
class Symbol;
 
 
 
template <> struct llvm::ilist_traits<Inst> {
private:
  using instr_iterator = simple_ilist<Inst>::iterator;
 
public:
  void deleteNode(Inst *inst);
  void addNodeToList(Inst *inst);
  void removeNodeFromList(Inst *inst);
  void transferNodesFromList(
      ilist_traits &from,
      instr_iterator first,
      instr_iterator last
  );
 
  Block *getParent();
};
 
class Inst
  : public llvm::ilist_node_with_parent<Inst, Block>
  , public User
{
public:
  static constexpr Value::Kind kValueKind = Value::Kind::INST;
 
public:
  enum class Kind : uint8_t {
    #define GET_INST(kind, type, name, sort) kind,
    #include "instructions.def"
  };
 
  virtual ~Inst();
 
  unsigned GetOrder() const { return order_; }
 
  void removeFromParent();
  void eraseFromParent();
 
  Kind GetKind() const { return kind_; }
  bool Is(Kind kind) const { return GetKind() == kind; }
  Block *getParent() const { return parent_; }
  virtual unsigned GetNumRets() const { return 0; }
  virtual Type GetType(unsigned i) const { llvm_unreachable("missing type"); }
 
  bool IsVoid() const { return GetNumRets() == 0; }
 
  virtual bool IsReturn() const { return false; }
  virtual bool IsConstant() const { return false; }
  virtual bool IsTerminator() const { return false; }
  virtual bool HasSideEffects() const { return false; }
 
  template<typename T>
  bool HasAnnot() const { return annot_.Has<T>(); }
 
  template<typename T>
  bool ClearAnnot() { return annot_.Clear<T>(); }
 
  template<typename T>
  const T *GetAnnot() const { return annot_.Get<T>(); }
 
  template<typename T, typename... Args>
  bool SetAnnot(Args&&... args)
  {
    return annot_.Set<T, Args...>(std::forward<Args>(args)...);
  }
 
  bool AddAnnot(const Annot &annot) { return annot_.Add(annot); }
  const AnnotSet &GetAnnots() const { return annot_; }
  size_t annot_size() const { return annot_.size(); }
  bool annot_empty() const { return annot_.empty(); }
  llvm::iterator_range<AnnotSet::const_iterator> annots() const
  {
    return llvm::make_range(annot_.begin(), annot_.end());
  }
 
  Ref<Inst> GetSubValue(unsigned i) { return Ref(this, i); }
  ConstRef<Inst> GetSubValue(unsigned i) const { return ConstRef(this, i); }
 
  void replaceAllUsesWith(Value *v) override;
  void replaceAllUsesWith(llvm::ArrayRef<Ref<Inst>> v);
 
  template <typename T>
  typename std::enable_if<std::is_base_of<Inst, T>::value>::type
  replaceAllUsesWith(llvm::ArrayRef<Ref<T>> insts)
  {
    std::vector<Ref<Inst>> values;
    for (Ref<T> inst : insts) {
      values.push_back(inst);
    }
    return replaceAllUsesWith(values);
  }
 
  void dump(llvm::raw_ostream &os = llvm::errs()) const;
 
protected:
  Inst(Kind kind, unsigned numOps, AnnotSet &&annot);
  Inst(Kind kind, unsigned numOps, const AnnotSet &annot);
 
private:
  friend struct llvm::ilist_traits<Inst>;
  void setParent(Block *parent) { parent_ = parent; }
 
private:
  const Kind kind_;
  AnnotSet annot_;
 
protected:
  Block *parent_;
  unsigned order_;
};
 
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, Inst::Kind kind);
 
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Inst &inst)
{
  inst.dump(os);
  return os;
}
 
#define GET_BASE_INTF
#include "instructions.def"