dag.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 <llvm/ADT/DenseSet.h>
#include <llvm/Support/raw_ostream.h>
 
class Block;
class Func;
 
 
 
struct DAGBlock {
  const unsigned Index;
 
  llvm::DenseSet<Block *> Blocks;
  llvm::SmallVector<DAGBlock *, 4> Succs;
  llvm::SmallVector<DAGBlock *, 4> Preds;
  int64_t Length;
  bool IsLoop;
  bool Lands;
  bool Returns;
  bool IsReturn;
  bool Raises;
  bool IsRaise;
  bool Traps;
  bool IsTrap;
 
  bool Exits() const
  {
    return Returns || Raises || Traps;
  }
 
  bool IsExit() const
  {
    return IsReturn || IsRaise || IsTrap;
  }
 
  DAGBlock(unsigned index) : Index(index) {}
};
 
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, DAGBlock &node);
 
 
 
class DAGFunc {
public:
  using NodeList = std::vector<std::unique_ptr<DAGBlock>>;
 
  template <typename T>
  struct iterator : llvm::iterator_adaptor_base
      < iterator<T>
      , T
      , std::random_access_iterator_tag
      , DAGBlock *
      >
  {
    iterator<T>(T it)
      : llvm::iterator_adaptor_base
          < iterator<T>
          , T
          , std::random_access_iterator_tag
          , DAGBlock *
          >(it)
    {
    }
 
    DAGBlock *operator*() const { return this->I->get(); }
    DAGBlock *operator->() const { return operator*(); }
  };
 
  using node_iterator = iterator<NodeList::iterator>;
  using reverse_node_iterator = iterator<NodeList::reverse_iterator>;
 
public:
  DAGFunc(Func &func);
 
  DAGBlock *operator[] (Block *block) { return blocks_[block]; }
  DAGBlock *operator[] (unsigned idx) { return &*nodes_[idx]; }
 
  Func &GetFunc() { return func_; }
 
  // Iterator over nodes.
  size_t size() const { return nodes_.size(); }
  node_iterator begin() { return node_iterator(nodes_.begin()); }
  node_iterator end() { return node_iterator(nodes_.end()); }
  reverse_node_iterator rbegin() { return reverse_node_iterator(nodes_.rbegin()); }
  reverse_node_iterator rend() { return reverse_node_iterator(nodes_.rend()); }
 
private:
  Func &func_;
  NodeList nodes_;
  std::unordered_map<Block *, DAGBlock *> blocks_;
};