value.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 <iterator>
 
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/iterator.h>
#include <llvm/ADT/iterator_range.h>
 
#include "core/use.h"
 
template<typename T> class Ref;
 
 
 
class Value {
public:
  template<typename T>
  using forward_it = std::iterator<std::forward_iterator_tag, T>;
 
  template <typename UseT>
  class use_iterator_impl : public forward_it<UseT *> {
  public:
    use_iterator_impl() : u_(nullptr) {}
 
    bool operator==(const use_iterator_impl &that) const { return u_ == that.u_; }
    bool operator!=(const use_iterator_impl &that) const { return !(*this == that); }
 
    use_iterator_impl &operator++() {
      assert(u_ && "Cannot increment end iterator!");
      u_ = u_->getNext();
      return *this;
    }
 
    use_iterator_impl operator++(int) {
      auto tmp = *this;
      ++*this;
      return tmp;
    }
 
    UseT &operator*() const {
      assert(u_ && "Cannot dereference end iterator!");
      return *u_;
    }
 
    UseT *operator->() const { return &operator*(); }
 
    operator use_iterator_impl<const UseT>() const {
      return use_iterator_impl<const UseT>(u_);
    }
 
  private:
    explicit use_iterator_impl(UseT *u) : u_(u) {}
 
  private:
    friend class Value;
    UseT *u_;
  };
 
  template <typename UserTy>
  class user_iterator_impl : public forward_it<UserTy *> {
  public:
    user_iterator_impl() = default;
 
    bool operator==(const user_iterator_impl &that) const
    {
      return UI == that.UI;
    }
 
    bool operator!=(const user_iterator_impl &that) const
    {
      return !(*this == that);
    }
 
    bool atEnd() const { return *this == user_iterator_impl(); }
 
    // Pre-increment
    user_iterator_impl &operator++()
    {
      ++UI;
      return *this;
    }
 
    // Post-increment
    user_iterator_impl operator++(int)
    {
      auto tmp = *this;
      ++*this;
      return tmp;
    }
 
    // Retrieve a pointer to the current User.
    UserTy *operator*() const {
      return UI->getUser();
    }
 
    UserTy *operator->() const { return operator*(); }
 
    operator user_iterator_impl<const UserTy>() const {
      return user_iterator_impl<const UserTy>(*UI);
    }
 
    Use &getUse() const { return *UI; }
 
  private:
    explicit user_iterator_impl(Use *U) : UI(U) {}
 
  private:
    use_iterator_impl<Use> UI;
    friend class Value;
  };
 
  using use_iterator = use_iterator_impl<Use>;
  using const_use_iterator = use_iterator_impl<const Use>;
  using user_iterator = user_iterator_impl<User>;
  using const_user_iterator = user_iterator_impl<const User>;
 
public:
  enum class Kind {
    INST,
    GLOBAL,
    EXPR,
    CONST,
  };
 
  Value(Kind kind) : kind_(kind), users_(nullptr) { }
  Value(const Value &) = delete;
  Value(Value &&) = delete;
 
  virtual ~Value();
 
  Kind GetKind() const { return kind_; }
  bool Is(Kind kind) const { return GetKind() == kind; }
  bool IsConstant() const;
 
  virtual void replaceAllUsesWith(Value *v);
  virtual void replaceAllUsesWith(Ref<Value> v);
 
  // Iterator over use sites.
  size_t use_size() const { return std::distance(use_begin(), use_end()); }
  bool use_empty() const { return users_ == nullptr; }
  use_iterator use_begin() { return use_iterator(users_); }
  const_use_iterator use_begin() const { return const_use_iterator(users_); }
  use_iterator use_end() { return use_iterator(); }
  const_use_iterator use_end() const { return const_use_iterator(); }
  llvm::iterator_range<use_iterator> uses();
  llvm::iterator_range<const_use_iterator> uses() const;
 
  // Iterator over users.
  bool user_empty() const { return users_ == nullptr; }
  user_iterator user_begin() { return user_iterator(users_); }
  const_user_iterator user_begin() const { return const_user_iterator(users_); }
  user_iterator user_end() { return user_iterator(); }
  const_user_iterator user_end() const { return const_user_iterator(); }
  llvm::iterator_range<user_iterator> users();
  llvm::iterator_range<const_user_iterator> users() const;
 
  void operator = (const Value &) = delete;
  void operator = (Value &&) = delete;
 
private:
  friend class Use;
  Kind kind_;
  Use *users_;
};