object_graph.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 <llvm/ADT/GraphTraits.h>
#include <llvm/ADT/PointerUnion.h>
 
#include "core/data.h"
#include "core/object.h"
#include "core/atom.h"
 
 
 
class ObjectGraph final {
public:
  class Node {
  public:
    class iterator {
    public:
      iterator(const Node *node, Item *start);
      iterator(const Node *node, Object *func);
      iterator() : it_(static_cast<Item *>(nullptr)) {}
 
      bool operator!=(const iterator &that) const { return !(*this == that); }
      bool operator==(const iterator &that) const;
 
      iterator &operator++();
 
      iterator operator++(int)
      {
        iterator it(*this);
        ++*this;
        return it;
      }
 
      Node *operator*() const;
 
    private:
      const Node *node_;
      llvm::PointerUnion<Item *, Object *> it_;
    };
 
  public:
 
    Node(const ObjectGraph *graph, Prog *prog);
    Node(const ObjectGraph *graph, Object *object);
 
    iterator begin() const;
    iterator end() const { return iterator(); }
 
    Object *GetObject() const;
 
  private:
    friend class iterator;
    const ObjectGraph *graph_;
    llvm::PointerUnion<Object *, Prog *> node_;
  };
 
public:
  ObjectGraph(Prog &p);
 
  ~ObjectGraph();
 
  const Node *Entry() const { return &entry_; }
 
  Node *operator[](Object *o) const;
 
private:
  friend class Node::iterator;
  Node entry_;
  mutable std::unordered_map<Object *, std::unique_ptr<Node>> nodes_;
};
 
namespace llvm {
 
template <>
struct GraphTraits<ObjectGraph::Node *> {
  using NodeRef = const ObjectGraph::Node *;
  using ChildIteratorType = ObjectGraph::Node::iterator;
 
  static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
  static ChildIteratorType child_end(NodeRef N) { return N->end(); }
};
 
template <>
struct GraphTraits<ObjectGraph *> : public GraphTraits<ObjectGraph::Node *> {
  static NodeRef getEntryNode(const ObjectGraph *g)
  {
    return g->Entry();
  }
};
 
} // end namespace llvm