object.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/ilist.h>
 
#include "core/atom.h"
#include "core/symbol_table.h"
 
class Object;
class Prog;
class Atom;
 
 
 
template <> struct llvm::ilist_traits<Object> {
private:
  using instr_iterator = simple_ilist<Object>::iterator;
 
public:
  void deleteNode(Object *inst);
  void addNodeToList(Object *inst);
  void removeNodeFromList(Object *inst);
  void transferNodesFromList(
      ilist_traits &from,
      instr_iterator first,
      instr_iterator last
  );
 
  Data *getParent();
};
 
 
 
class Object final : public llvm::ilist_node_with_parent<Object, Prog> {
private:
  using AtomListType = SymbolTableList<Atom>;
 
  using iterator = AtomListType::iterator;
  using const_iterator = AtomListType::const_iterator;
  using reverse_iterator = AtomListType::reverse_iterator;
  using const_reverse_iterator = AtomListType::const_reverse_iterator;
 
public:
  // Initialises the data segment.
  Object() : parent_(nullptr), isThreadLocal_(false) {}
 
  ~Object();
 
  void removeFromParent();
  void eraseFromParent();
 
  Data *getParent() const { return parent_; }
 
  void remove(iterator it) { atoms_.remove(it); }
  void erase(iterator it) { atoms_.erase(it); }
  void AddAtom(Atom *atom, Atom *before = nullptr);
 
  // Iterators over atoms.
  bool empty() const { return atoms_.empty(); }
  size_t size() const { return atoms_.size(); }
  iterator begin() { return atoms_.begin(); }
  iterator end() { return atoms_.end(); }
  const_iterator begin() const { return atoms_.begin(); }
  const_iterator end() const { return atoms_.end(); }
  reverse_iterator rbegin() { return atoms_.rbegin(); }
  reverse_iterator rend() { return atoms_.rend(); }
  const_reverse_iterator rbegin() const { return atoms_.rbegin(); }
  const_reverse_iterator rend() const { return atoms_.rend(); }
 
  void dump(llvm::raw_ostream &os = llvm::errs()) const;
 
  Value *Load(uint64_t offset, Type type);
  bool Store(uint64_t offset, Ref<Value> value, Type type);
 
  void SetThreadLocal(bool flag = true) { isThreadLocal_ = flag; }
  bool IsThreadLocal() const { return isThreadLocal_; }
 
private:
  friend struct llvm::ilist_traits<Object>;
  friend class SymbolTableListTraits<Atom>;
  static AtomListType Object::*getSublistAccess(Atom *) {
    return &Object::atoms_;
  }
 
  void setParent(Data *parent) { parent_ = parent; }
 
private:
  Data *parent_;
  AtomListType atoms_;
  bool isThreadLocal_;
};
 
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Object &obj)
{
  obj.dump(os);
  return os;
}