irep2.h

Go to the documentation of this file.

#ifndef IREP2_H_
#define IREP2_H_

 
#include <big-int/bigint.hh>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <stdexcept>
#include <thread>
#include <type_traits>
#include <utility>
#include <util/base/compiler_defs.h>
#include <util/irep/irep_idt.h>
#include <util/irep/irep.h>
 
// The list of irep2 expression kinds lives in expr_kinds.inc; the
// list of type kinds lives in type_kinds.inc. Every consumer (the
// enum entries, the per-kind forward declarations, the is/to/try_to
// predicate generators, the pretty name tables) #include the matching
// .inc with a redefining IREP2_EXPR / IREP2_TYPE macro.
 
namespace esbmct
{
template <typename Signature>
class function_ref;
 
template <typename R, typename... Args>
class function_ref<R(Args...)>
{
public:
  template <
    typename F,
    typename = std::enable_if_t<
      !std::is_same_v<std::decay_t<F>, function_ref> &&
      std::is_invocable_r_v<R, F &, Args...>>>
  function_ref(F &&fn) noexcept
    : invoke_(&function_ref::call<std::remove_reference_t<F>>),
      ctx_(const_cast<void *>(static_cast<const void *>(std::addressof(fn))))
  {
  }
 
  R operator()(Args... args) const
  {
    if constexpr (std::is_void_v<R>)
      invoke_(ctx_, std::forward<Args>(args)...);
    else
      return invoke_(ctx_, std::forward<Args>(args)...);
  }
 
private:
  template <typename F>
  static R call(void *p, Args... args)
  {
    if constexpr (std::is_void_v<R>)
      (*static_cast<F *>(p))(std::forward<Args>(args)...);
    else
      return (*static_cast<F *>(p))(std::forward<Args>(args)...);
  }
 
  R (*invoke_)(void *, Args...);
  void *ctx_;
};

template <class T>
inline void hash_combine(std::size_t &seed, const T &v)
{
  seed ^= std::hash<T>{}(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
} // namespace esbmct
 
class type2t;
class expr2t;

template <class T>
class irep_container
{
private:
  // Private tag gate for the raw-pointer adopt constructor. Only
  // `make_irep` and other befriended factories can construct one,
  // which means user code cannot do `expr2tc(new foo2t(...))` — the
  // canonical idiom is the per-kind `foo2tc(...)` factory (itself a
  // thin wrapper over make_irep). The tag carries no state.
  struct make_tag
  {
    explicit make_tag() = default;
  };
 
  // Adopt a freshly-allocated node. The pointee's refcount must be 0
  // (i.e. just-new'd); we bump it to 1.
  irep_container(T *raw, make_tag) noexcept : ptr_(raw)
  {
    if (ptr_)
      ptr_->refcount.fetch_add(1, std::memory_order_relaxed);
  }
 
  template <class U, class... Args>
  friend irep_container<typename U::base_type> make_irep(Args &&...args);
 
public:
  // Default: empty container, nullptr inside. `noexcept`/`constexpr` to
  // preserve the storage-class properties of the previous design.
  constexpr irep_container() noexcept : ptr_(nullptr)
  {
  }
 
  irep_container(const irep_container &ref) noexcept : ptr_(ref.ptr_)
  {
    if (ptr_)
      ptr_->refcount.fetch_add(1, std::memory_order_relaxed);
  }
 
  irep_container(irep_container &&ref) noexcept : ptr_(ref.ptr_)
  {
    ref.ptr_ = nullptr;
  }
 
  ~irep_container()
  {
    release();
  }
 
  irep_container &operator=(const irep_container &ref) noexcept
  {
    if (this != &ref)
    {
      // Snapshot ref.ptr_ before calling release().  ref may alias a
      // member of an object that release() destroys (e.g.
      // `x = to_array_type(x).subtype` where x holds the only reference
      // to the array): after release() runs, that storage is gone and
      // any further access to ref is use-after-free.  Reading the
      // pointer up-front and then working off the local copy keeps us
      // correct regardless of whether the compiler caches or reloads
      // ref.ptr_ (gcc on Linux happens to cache it, AppleClang on macOS
      // reloads and crashes).
      T *new_ptr = ref.ptr_;
      if (new_ptr)
        new_ptr->refcount.fetch_add(1, std::memory_order_relaxed);
      release();
      ptr_ = new_ptr;
    }
    return *this;
  }
 
  irep_container &operator=(irep_container &&ref) noexcept
  {
    if (this != &ref)
    {
      // Same use-after-free concern as the copy-assign path: snapshot
      // and null out ref before release(), so even if release() ends
      // up destroying the storage backing ref we never re-read it.
      T *new_ptr = ref.ptr_;
      ref.ptr_ = nullptr;
      release();
      ptr_ = new_ptr;
    }
    return *this;
  }
 
  // Const accessors: hand out the pointee without detaching, since
  // they're const operations. Prefer these whenever you only need to
  // read the node — they are O(1) atomic-free pointer loads.
  [[nodiscard]] const T &operator*() const noexcept
  {
    return *ptr_;
  }
 
  [[nodiscard]] const T *operator->() const noexcept
  {
    return ptr_;
  }
 
  [[nodiscard]] const T *get() const noexcept
  {
    return ptr_;
  }
 
  // Non-const accessors detach: if the pointee is shared (refcount > 1)
  // we clone into a fresh refcount-1 object and rebind, then invalidate
  // the CRC cache on the (now uniquely-owned) copy. **WARNING:** even
  // when no actual mutation follows, calling these allocates+copies on
  // every shared node touch — favour the const overloads above when a
  // read is enough.
  T *get()
  {
    detach();
    // Single-writer contract: relaxed is enough to invalidate the
    // cache; the next crc() recomputation will publish via release.
    ptr_->crc_val.store(0, std::memory_order_relaxed);
#ifndef NDEBUG
    // Stamp the current thread as the writer of this (now uniquely
    // owned) node; if another thread is already inside a mutable
    // access on the same node, mark_writer asserts.
    ptr_->mark_writer();
#endif
    return ptr_;
  }
 
  T &operator*()
  {
    return *get();
  }
 
  T *operator->()
  {
    return get();
  }
 
  explicit operator bool() const noexcept
  {
    return ptr_ != nullptr;
  }
 
  void reset() noexcept
  {
    release();
    ptr_ = nullptr;
  }
 
  void detach()
  {
    if (!ptr_)
      return;
    // Acquire so we observe whatever state the owner of the prior
    // (about-to-be-replaced) reference flushed before storing here.
    // Almost always 1 — only shared subtrees go down the clone path.
    if (ptr_->refcount.load(std::memory_order_acquire) == 1)
      return;
    // Shared: clone into a fresh refcount-0 node and adopt it.
    *this = ptr_->clone();
  }
 
  friend void swap(irep_container &a, irep_container &b) noexcept
  {
    T *tmp = a.ptr_;
    a.ptr_ = b.ptr_;
    b.ptr_ = tmp;
  }
 
  void swap(irep_container &b) noexcept
  {
    using std::swap;
    swap(*this, b);
  }
 
  irep_container simplify() const
  {
    const T *foo = get();
    return foo->simplify();
  }
 
  size_t crc() const
  {
    const T *foo = get();
    // Acquire ordering on the load so a non-zero cached value also
    // synchronises with the writer that produced it (crc()'s release
    // store), and we observe whatever node state went into computing it.
    if (
      size_t cached = foo->crc_val.load(std::memory_order_acquire); cached != 0)
      return cached;
    return foo->crc();
  }
 
  /* Provide comparison operators here as inline friends so they don't pollute
   * the outer namespace; this reduces clutter when there are error messages
   * about these infix operators. It also means that no user-defined
   * conversions are considered unless at least one operand has the type of
   * this class or is derived from it. This is usually wanted since supplying
   * those conversions means someone else has to care about comparing whatever
   * values they potentially convert...
   *
   * This implementation assumes that the type T is totally ordered.
   *
   * TODO: when switching to >= C++20, replace these with only operator== and
   * operator<=>
   */
 
  friend bool operator==(const irep_container &a, const irep_container &b)
  {
    if (same(a, b))
      return true;
 
    if (!a || !b)
      return false;
 
    return *a == *b; // different pointees could still compare equal
  }
 
  friend bool operator!=(const irep_container &a, const irep_container &b)
  {
    return !(a == b);
  }
 
  friend bool operator<(const irep_container &a, const irep_container &b)
  {
    if (!b)
      return false; // If b is nil, nothing can be lower
    if (!a)
      return true; // nil is lower than non-nil
 
    if (same(a, b))
      return false;
 
    return *a < *b;
  }
 
  friend bool operator<=(const irep_container &a, const irep_container &b)
  {
    return !(a > b);
  }
 
  friend bool operator>=(const irep_container &a, const irep_container &b)
  {
    return !(a < b);
  }
 
  friend bool operator>(const irep_container &a, const irep_container &b)
  {
    return b < a;
  }
 
private:
  static bool same(const irep_container &a, const irep_container &b) noexcept
  {
    // Direct pointer equality is fine here because both pointers were
    // obtained from `new` (or are nullptr), so they are valid objects
    // of the same type and the comparison is well-defined.
    return a.ptr_ == b.ptr_;
  }
 
  // Drop our reference. Release ordering pairs with the acquire in
  // detach()/destruction on whichever container observes refcount==1
  // and is about to mutate or delete the pointee; this makes any
  // prior writes through *this happen-before that observer's access.
  void release() noexcept
  {
    if (!ptr_)
      return;
    unsigned int prev = ptr_->refcount.fetch_sub(1, std::memory_order_release);
    if (prev == 1)
    {
      // Acquire fence prevents the delete (and any side-effects of
      // the destructor) from being reordered before the final
      // fetch_sub, ensuring we see the prior owner's writes.
      std::atomic_thread_fence(std::memory_order_acquire);
      delete ptr_;
    }
#ifndef NDEBUG
    else if (prev == 2)
    {
      // We were one of exactly two owners and just dropped out; the
      // remaining sole owner is free to mutate. Clear the writer
      // stamp so they get a clean slate (the next non-const get()
      // will re-stamp).
      ptr_->clear_writer();
    }
#endif
  }
 
  T *ptr_;
};
 
typedef irep_container<type2t> type2tc;
typedef irep_container<expr2t> expr2tc;

template <class T, class... Args>
inline irep_container<typename T::base_type> make_irep(Args &&...args)
{
  using container_t = irep_container<typename T::base_type>;
  return container_t(
    new T(std::forward<Args>(args)...), typename container_t::make_tag{});
}
 
typedef std::pair<std::string, std::string> member_entryt;
typedef std::list<member_entryt> list_of_memberst;

class irep2t
{
public:
  irep2t() noexcept
    : refcount(0)
#ifndef NDEBUG
      ,
      writer_thread(0)
#endif
  {
  }
  // Copy constructor must NOT propagate the refcount: a fresh copy is
  // a brand new object that no container has yet adopted. The single
  // copy site that matters is clone(), which always wraps the result
  // in an irep_container immediately afterwards.
  irep2t(const irep2t &) noexcept
    : refcount(0)
#ifndef NDEBUG
      ,
      writer_thread(0)
#endif
  {
  }
  // Refcount is per-object identity; assignment is meaningless on the
  // base. Subclasses' copy-assignment operators do not call into here.
  irep2t &operator=(const irep2t &) = delete;
  virtual ~irep2t() = default;
 
  mutable std::atomic<unsigned int> refcount;
 
#ifndef NDEBUG
  // Debug-only writer-thread stamp. The threading contract says irep2
  // nodes are single-writer; on the first mutable access through an
  // irep_container, the container stamps this slot with a hash of the
  // current thread id (0 means "no writer"). Subsequent mutable
  // accesses compare — a mismatch means two threads are trying to
  // mutate the same uniquely-owned node, which is the contract
  // violation we want to catch. The stamp clears when the refcount
  // drops back to 1 in release(), so a single-owner-handoff across
  // threads (publish, then a new owner mutates) works correctly.
  // Compiled out entirely under NDEBUG. uintptr_t is used (rather
  // than std::thread::id directly) so the atomic is guaranteed
  // lock-free on every platform we target.
  mutable std::atomic<std::uintptr_t> writer_thread;
 
  static std::uintptr_t current_thread_tag() noexcept
  {
    auto h = std::hash<std::thread::id>{}(std::this_thread::get_id());
    // 0 is the "no writer" sentinel; if the hash collides with 0
    // (vanishingly unlikely but possible), bump it.
    return h == 0 ? 1 : static_cast<std::uintptr_t>(h);
  }
 
  void mark_writer() const noexcept
  {
    std::uintptr_t me = current_thread_tag();
    std::uintptr_t prev = writer_thread.load(std::memory_order_acquire);
    if (prev == me)
      return; // already mine, common fast path
    if (prev == 0)
    {
      // Race-free attempt to claim the slot. If we lose the CAS to a
      // concurrent writer we fall through to the mismatch assert
      // below, which is the contract violation.
      if (
        writer_thread.compare_exchange_strong(
          prev, me, std::memory_order_release, std::memory_order_acquire))
        return;
    }
    assert(
      prev == me &&
      "irep2 single-writer contract violated: a second thread tried to "
      "mutate a node already being mutated by another thread");
  }
 
  void clear_writer() const noexcept
  {
    writer_thread.store(0, std::memory_order_release);
  }
#endif
};

class type2t : public irep2t
{
public:
  enum type_ids
  {
#define IREP2_TYPE(kind, pretty) kind##_id,
#include <irep2/type_kinds.inc>
#undef IREP2_TYPE
    end_type_id
  };

  class symbolic_type_excp
  {
  public:
    const char *what() const noexcept
    {
      return "symbolic type encountered";
    }
  };
 
  // Non-owning callable references. The historic typedefs were
  // std::function<void(...)>, which allocated for any non-trivially-
  // copyable lambda capture and indirected through the std::function
  // type-erasure. function_ref is two pointers wide and inlines into
  // the caller's stack frame.
  typedef esbmct::function_ref<void(const type2tc &)> const_subtype_delegate;
  typedef esbmct::function_ref<void(type2tc &)> subtype_delegate;
 
protected:
  type2t(type_ids id);

  type2t(const type2t &ref);
 
  void foreach_subtype_impl_const(const_subtype_delegate &t) const;
  void foreach_subtype_impl(subtype_delegate &t);
 
public:
  // Provide base / container types for some templates stuck on top:
  typedef type2tc container_type;
  typedef type2t base_type;
 
  virtual ~type2t() = default;

  unsigned int get_width() const;
 
  bool operator==(const type2t &ref) const;
  bool operator!=(const type2t &ref) const;
  bool operator<(const type2t &ref) const;

  std::string pretty(unsigned int indent = 0) const;

  DUMP_METHOD void dump() const;

  size_t crc() const;

  bool cmp(const type2t &ref) const;

  int lt(const type2t &ref) const;

  list_of_memberst tostring(unsigned int indent) const;

  type2tc clone() const;
 
  // Please see the equivalent methods in expr2t for documentation
  template <typename T>
  void foreach_subtype(T &&t) const
  {
    const_subtype_delegate wrapped(t);
    foreach_subtype_impl_const(wrapped);
  }
 
  template <typename T>
  void Foreach_subtype(T &&t)
  {
    subtype_delegate wrapped(t);
    foreach_subtype_impl(wrapped);
  }

  const type_ids type_id;
 
  // CRC cache: 0 means "not yet computed". Atomic so concurrent readers
  // see either the prior value or the fresh one — never a torn read.
  // Writers respect the single-writer contract documented at the top of
  // this header; the cache is therefore safe to set without a lock as
  // long as readers and the (single) writer share happens-before via the
  // atomic.
  mutable std::atomic<size_t> crc_val;
};

std::string get_type_id(const type2t &type);

static inline std::string get_type_id(const type2tc &type)
{
  return get_type_id(*type);
}

class expr2t : public irep2t
{
public:
  enum expr_ids
  {
// The single source of truth for the kind list lives in
// expr_kinds.inc; see that file's header for the IREP2_EXPR(kind,
// pretty_name) contract.
#define IREP2_EXPR(kind, pretty) kind##_id,
#include <irep2/expr_kinds.inc>
#undef IREP2_EXPR
    end_expr_id
  };
 
  // Non-owning callable references; see commentary on type2t's variants.
  typedef esbmct::function_ref<void(const expr2tc &)> const_op_delegate;
  typedef esbmct::function_ref<void(expr2tc &)> op_delegate;
 
protected:
  expr2t(const type2tc &type, expr_ids id);
  expr2t(const expr2t &ref);
 
  void foreach_operand_impl_const(const_op_delegate &expr) const;
  void foreach_operand_impl(op_delegate &expr);
 
public:
  // Provide base / container types for some templates stuck on top:
  typedef expr2tc container_type;
  typedef expr2t base_type;
 
  virtual ~expr2t() = default;
 
  expr2tc clone() const;

  expr2tc with_type(const type2tc &new_type) const;
 
  bool operator==(const expr2t &ref) const;
  bool operator<(const expr2t &ref) const;
  bool operator!=(const expr2t &ref) const;

  std::string pretty(unsigned int indent = 0) const;

  DUMP_METHOD void dump() const;

  size_t crc() const;

  bool cmp(const expr2t &ref) const;

  int lt(const expr2t &ref) const;

  list_of_memberst tostring(unsigned int indent) const;

  const expr2tc *get_sub_expr(size_t idx) const;

  size_t get_num_sub_exprs() const;

  expr2tc simplify() const;

  expr2tc simplify(bool suppress_reassoc) const;

  [[nodiscard]] virtual expr2tc do_simplify() const;

  template <typename T>
  void foreach_operand(T &&t) const
  {
    const_op_delegate wrapped(t);
    foreach_operand_impl_const(wrapped);
  }
 
  template <typename T>
  void Foreach_operand(T &&t)
  {
    op_delegate wrapped(t);
    foreach_operand_impl(wrapped);
  }

  const expr_ids expr_id;

  const type2tc type;
 
  // CRC cache; see commentary on type2t::crc_val.
  mutable std::atomic<size_t> crc_val;
};
 
inline bool is_nil_expr(const expr2tc &exp)
{
  return exp.get() == nullptr;
}

template <class T>
inline bool same_pointer(const irep_container<T> &a, const irep_container<T> &b)
{
  return a.get() == b.get();
}
 
inline bool is_nil_type(const type2tc &t)
{
  return t.get() == nullptr;
}
 
// For boost multi-index hashing,
inline std::size_t hash_value(const expr2tc &expr)
{
  return expr.crc();
}

std::string get_expr_id(const expr2t &expr);

static inline std::string get_expr_id(const expr2tc &expr)
{
  return get_expr_id(*expr);
}

namespace esbmct
{
const unsigned int num_type_fields = 6;
 
// ---------------------------------------------------------------------------
// Per-kind invariants for the flat irep2 layout.
//
// Each concrete kind exposes:
//   * A `static constexpr auto fields` tuple of member pointers covering its
//     user-visible storage. Pointers may refer to members of the kind itself
//     OR of its base (e.g. `&expr2t::type` for kinds whose type slot is part
//     of the trait set).
//   * A `static std::string field_names[num_type_fields]` array of labels for
//     the pretty-printer.
//
// `assert_kind_invariants<K>()` packages the two compile-time checks we want
// every concrete kind to satisfy:
//
//   1. `fields_cover_class<K>()` — the member pointers in K::fields that
//      refer to K (i.e. not to a base) collectively cover the derived-class
//      storage span, modulo trailing padding (< alignof(K)). If someone
//      adds a raw `BigInt extra;` to a kind and forgets to extend `fields`,
//      this fires.
//
//   2. The number of derived-class entries in K::fields is at most
//      num_type_fields, so the field_names[] array indexing in
//      generic_tostring is in-bounds.
//
// Instantiated for every kind from the switch dispatchers (each `case`
// references `K::fields`, which transitively forces the static_asserts in
// the helpers below). Adding a new kind without listing its fields gets a
// compile error from this site rather than a silent bug at cmp/crc/hash time.
// ---------------------------------------------------------------------------
 
template <class P>
struct member_traits;
template <class C, class M>
struct member_traits<M C::*>
{
  using class_t = C;
  using member_t = M;
};
template <class C, class M>
struct member_traits<const M C::*>
{
  using class_t = C;
  using member_t = M;
};
 
// Sizeof the i-th K::fields entry, but only if it refers to K itself
// (member pointers into the base class point at base storage, so they
// shouldn't be counted against the derived-class storage span).
template <class K, std::size_t I>
constexpr std::size_t nth_field_size_in_derived()
{
  using P = std::remove_cvref_t<decltype(std::get<I>(K::fields))>;
  using class_t = typename member_traits<P>::class_t;
  if constexpr (std::is_same_v<class_t, K>)
    return sizeof(typename member_traits<P>::member_t);
  else
    return 0;
}
 
template <class K, std::size_t... Is>
constexpr std::size_t sum_derived_field_sizes(std::index_sequence<Is...>)
{
  return (nth_field_size_in_derived<K, Is>() + ... + std::size_t{0});
}
 
template <class K, std::size_t... Is>
constexpr std::size_t count_derived_field_entries(std::index_sequence<Is...>)
{
  return (
    (std::is_same_v<
       typename member_traits<
         std::remove_cvref_t<decltype(std::get<Is>(K::fields))>>::class_t,
       K>
       ? std::size_t{1}
       : std::size_t{0}) +
    ... + std::size_t{0});
}
 
// A kind may *intentionally* hold a member that is excluded from
// cmp/crc/hash/tostring — i.e. deliberately not listed in `fields`. Such a
// kind declares `static constexpr std::size_t excluded_field_bytes = ...;`
// giving the byte size of those excluded members, so `fields_cover_class`
// stops counting them as "missed". The excluded members are the non-reflected
// source `locationt`s carried by many code/if kinds (esbmc/esbmc#4715) — the
// V.4 structured-CF kinds carry a `location`, code_block2t also carries an
// `end_location`, and if2t (an expression) carries the ternary position — plus
// the per-loop `pragma_unroll_count` on the loop kinds. Source locations must
// travel with the statement for goto_convert, but must not enter value
// identity (matching how a goto instructiont stores its locationt separately
// from its IREP2 code). Kinds without such members get 0.
template <class K, class = void>
struct kind_excluded_field_bytes
{
  static constexpr std::size_t value = 0;
};
template <class K>
struct kind_excluded_field_bytes<
  K,
  std::void_t<decltype(K::excluded_field_bytes)>>
{
  static constexpr std::size_t value = K::excluded_field_bytes;
};
 
// `fields_cover_class<K>()` — the sum of derived-class field sizes in
// K::fields must equal `sizeof(K) - sizeof(base)` (minus any declared
// `excluded_field_bytes`), modulo at most `alignof(K) - 1` bytes of trailing
// padding. Catches missed-member-in-tuple at compile time for any kind where
// the missed member is at least one byte larger than the existing trailing
// padding (which covers every realistic case — irep2 nodes use pointer-sized
// fields almost exclusively).
template <class K>
constexpr bool fields_cover_class()
{
  using fields_t = std::remove_cv_t<decltype(K::fields)>;
  constexpr std::size_t derived_storage = sizeof(K) -
                                          sizeof(typename K::base_type) -
                                          kind_excluded_field_bytes<K>::value;
  constexpr std::size_t covered = sum_derived_field_sizes<K>(
    std::make_index_sequence<std::tuple_size_v<fields_t>>{});
  return derived_storage - covered < alignof(K);
}
 
// `derived_field_count<K>()` — number of K::fields entries that live in K
// itself (not in K::base_type). Compared against num_type_fields to ensure
// the field_names[] indexing in generic_tostring stays in-bounds.
template <class K>
constexpr std::size_t derived_field_count()
{
  using fields_t = std::remove_cv_t<decltype(K::fields)>;
  return count_derived_field_entries<K>(
    std::make_index_sequence<std::tuple_size_v<fields_t>>{});
}
 
template <class K>
constexpr bool assert_kind_invariants()
{
  static_assert(
    fields_cover_class<K>(),
    "irep2 kind invariant: fields tuple does not cover the derived class "
    "storage. Either add the missing member pointer to the kind's "
    "`fields = std::make_tuple(...)`, or — if the member is intentionally "
    "excluded from cmp/crc/hash — list every non-excluded member explicitly "
    "and document the omission.");
  static_assert(
    derived_field_count<K>() <= num_type_fields,
    "irep2 kind invariant: this kind has more derived-class field entries "
    "than esbmct::num_type_fields. Either bump num_type_fields and the "
    "corresponding field_names[] arrays, or replace the fixed-size array "
    "with one sized by std::tuple_size_v<decltype(fields)>.");
  return true;
}
 
} // namespace esbmct
 
inline std::ostream &operator<<(std::ostream &out, const expr2tc &a)
{
  out << a->pretty(0);
  return out;
}
 
struct irep2_hash
{
  size_t operator()(const expr2tc &ref) const
  {
    return ref.crc();
  }
};
 
struct type2_hash
{
  size_t operator()(const type2tc &ref) const
  {
    return ref->crc();
  }
};
 
// Exception thrown by irep2_checked_type_cast / irep2_checked_expr_cast when
// the runtime id does not match the requested derived type. A bad to_*2t /
// to_*_type was always a logic bug — surfacing it as an exception keeps the
// failure deterministic in every build mode (rather than the undefined
// behaviour the previous NDEBUG dynamic_cast→static_cast redefine produced)
// while staying recoverable for callers that want to handle it.
class irep2_cast_error : public std::logic_error
{
public:
  using std::logic_error::logic_error;
};
 
// Diagnose a bad to_* downcast and throw irep2_cast_error. Out-of-line and
// [[noreturn]] so the happy path stays a single compare+branch and the
// compiler does not pessimise the inlined helpers.
[[noreturn]] void
irep2_bad_type_cast(unsigned actual, unsigned expected, const char *target);
[[noreturn]] void
irep2_bad_expr_cast(unsigned actual, unsigned expected, const char *target);
[[noreturn]] void irep2_bad_family_cast(unsigned actual, const char *accessor);
 
// Checked downcast for type2t / expr2t hierarchies. The is_*_type / is_*2t
// predicates already do a single enum compare; these helpers do the same
// check before a static_cast, so a bad to_*2t throws irep2_cast_error in
// every build mode rather than invoking undefined behaviour under NDEBUG.
template <typename Derived>
inline Derived &irep2_checked_type_cast(
  type2t &t,
  type2t::type_ids expected,
  const char *target_name)
{
  if (t.type_id != expected)
    irep2_bad_type_cast(t.type_id, expected, target_name);
  return static_cast<Derived &>(t);
}
 
template <typename Derived>
inline const Derived &irep2_checked_type_cast(
  const type2t &t,
  type2t::type_ids expected,
  const char *target_name)
{
  if (t.type_id != expected)
    irep2_bad_type_cast(t.type_id, expected, target_name);
  return static_cast<const Derived &>(t);
}
 
template <typename Derived>
inline Derived &irep2_checked_expr_cast(
  expr2t &e,
  expr2t::expr_ids expected,
  const char *target_name)
{
  if (e.expr_id != expected)
    irep2_bad_expr_cast(e.expr_id, expected, target_name);
  return static_cast<Derived &>(e);
}
 
template <typename Derived>
inline const Derived &irep2_checked_expr_cast(
  const expr2t &e,
  expr2t::expr_ids expected,
  const char *target_name)
{
  if (e.expr_id != expected)
    irep2_bad_expr_cast(e.expr_id, expected, target_name);
  return static_cast<const Derived &>(e);
}
 
#endif /* IREP2_H_ */