prog.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 <string>
#include <memory>
#include <vector>
#include <unordered_map>
#include <map>
 
#include <llvm/ADT/ilist.h>
#include <llvm/ADT/ilist_node.h>
#include <llvm/ADT/iterator_range.h>
 
#include "core/constant.h"
#include "core/expr.h"
#include "core/extern.h"
#include "core/symbol_table.h"
#include "core/data.h"
#include "core/object.h"
#include "core/func.h"
#include "core/xtor.h"
 
class Extern;
 
 
 
class Prog final {
private:
  using FuncListType = SymbolTableList<Func>;
  using DataListType = llvm::ilist<Data>;
  using ExternListType = SymbolTableList<Extern>;
  using XtorListType = llvm::ilist<Xtor>;
 
  using GlobalMap = std::unordered_map<std::string_view, Global *>;
 
  class global_iterator
    : public llvm::iterator_adaptor_base
        < global_iterator
        , GlobalMap::iterator
        , std::random_access_iterator_tag
        , Global *
        >
  {
  public:
    explicit global_iterator(GlobalMap::iterator it)
      : iterator_adaptor_base(it)
    {
    }
 
    Global *operator*() const { return this->I->second; }
 
    Global *operator->() const { return this->I->second; }
  };
 
  class const_global_iterator
    : public llvm::iterator_adaptor_base
        < const_global_iterator
        , GlobalMap::const_iterator
        , std::random_access_iterator_tag
        , const Global *
        >
  {
  public:
    explicit const_global_iterator(GlobalMap::const_iterator it)
      : iterator_adaptor_base(it)
    {
    }
 
    const Global *operator*() const { return this->I->second; }
 
    const Global *operator->() const { return this->I->second; }
  };
 
public:
  using iterator = FuncListType::iterator;
  using const_iterator = FuncListType::const_iterator;
 
  using data_iterator = DataListType::iterator;
  using const_data_iterator = DataListType::const_iterator;
 
  using ext_iterator = ExternListType::iterator;
  using const_ext_iterator = ExternListType::const_iterator;
 
  using xtor_iterator = XtorListType::iterator;
  using const_xtor_iterator = XtorListType::const_iterator;
 
public:
  Prog(std::string_view path);
  ~Prog();
 
  Global *GetGlobalOrExtern(const std::string_view name);
  Extern *GetExtern(const std::string_view name);
  Data *GetOrCreateData(const std::string_view name);
  Data *GetData(const std::string_view name);
  Global *GetGlobal(const std::string_view name) const;
 
  const std::string &GetName() const { return name_; }
  llvm::StringRef getName() const { return { name_.data(), name_.size() }; }
 
  void remove(iterator it) { funcs_.remove(it); }
  void erase(iterator it) { funcs_.erase(it); }
  void remove(ext_iterator it) { externs_.remove(it); }
  void erase(ext_iterator it) { externs_.erase(it); }
  void remove(data_iterator it) { datas_.remove(it); }
  void erase(data_iterator it) { datas_.erase(it); }
  void remove(xtor_iterator it) { xtors_.remove(it); }
  void erase(xtor_iterator it) { xtors_.erase(it); }
 
  void AddFunc(Func *func, Func *before = nullptr);
  // Iterators over functions.
  size_t size() const { return funcs_.size(); }
  bool empty() const { return funcs_.empty(); }
  iterator begin() { return funcs_.begin(); }
  iterator end() { return funcs_.end(); }
  const_iterator begin() const { return funcs_.begin(); }
  const_iterator end() const { return funcs_.end(); }
  llvm::iterator_range<const_iterator> funcs() const;
  llvm::iterator_range<iterator> funcs();
 
  void AddExtern(Extern *ext, Extern *before = nullptr);
  // Iterator over external symbols.
  size_t ext_size() const { return externs_.size(); }
  ext_iterator ext_begin() { return externs_.begin(); }
  ext_iterator ext_end() { return externs_.end(); }
  const_ext_iterator ext_begin() const { return externs_.begin(); }
  const_ext_iterator ext_end() const { return externs_.end(); }
  llvm::iterator_range<const_ext_iterator> externs() const;
  llvm::iterator_range<ext_iterator> externs();
 
  void AddData(Data *data, Data *before = nullptr);
  // Iterator over data segments.
  size_t data_size() const { return datas_.size(); }
  bool data_empty() const { return datas_.empty(); }
  data_iterator data_begin() { return datas_.begin(); }
  data_iterator data_end() { return datas_.end(); }
  const_data_iterator data_begin() const { return datas_.begin(); }
  const_data_iterator data_end() const { return datas_.end(); }
  llvm::iterator_range<const_data_iterator> data() const;
  llvm::iterator_range<data_iterator> data();
 
  void AddXtor(Xtor *xtor, Xtor *before = nullptr);
  // Iterator over constructors/destructors.
  size_t xtor_size() const { return xtors_.size(); }
  bool xtor_empty() const { return xtors_.empty(); }
  xtor_iterator xtor_begin() { return xtors_.begin(); }
  xtor_iterator xtor_end() { return xtors_.end(); }
  const_xtor_iterator xtor_begin() const { return xtors_.begin(); }
  const_xtor_iterator xtor_end() const { return xtors_.end(); }
  llvm::iterator_range<const_xtor_iterator> xtor() const;
  llvm::iterator_range<xtor_iterator> xtor();
 
  global_iterator global_begin() { return global_iterator(globals_.begin()); }
  global_iterator global_end() { return global_iterator(globals_.end()); }
  const_global_iterator global_begin() const { return const_global_iterator(globals_.begin()); }
  const_global_iterator global_end() const { return const_global_iterator(globals_.end()); }
  llvm::iterator_range<global_iterator> globals();
  llvm::iterator_range<const_global_iterator> globals() const;
 
  void dump(llvm::raw_ostream &os = llvm::errs()) const;
 
private:
  friend class SymbolTableListTraits<Block>;
  friend class SymbolTableListTraits<Func>;
  friend class SymbolTableListTraits<Extern>;
  friend class SymbolTableListTraits<Atom>;
  friend struct llvm::ilist_traits<Data>;
  friend struct llvm::ilist_traits<Object>;
 
  void insertGlobal(Global *g);
  void removeGlobalName(std::string_view name);
 
  static FuncListType Prog::*getSublistAccess(Func *) { return &Prog::funcs_; }
  static ExternListType Prog::*getSublistAccess(Extern *) { return &Prog::externs_; }
  static DataListType Prog::*getSublistAccess(Data *) { return &Prog::datas_; }
  static XtorListType Prog::*getSublistAccess(Xtor *) { return &Prog::xtors_; }
 
private:
  std::string name_;
  std::unordered_map<std::string_view, Global *> globals_;
  FuncListType funcs_;
  DataListType datas_;
  ExternListType externs_;
  XtorListType xtors_;
};