irep2_type.h

Go to the documentation of this file.

#ifndef IREP2_TYPE_H_
#define IREP2_TYPE_H_
 
#include <optional>
#include <irep2/irep2.h>
 
// Forward-declare a concrete <kind>_type2t class for every entry in
// type_kinds.inc. The same manifest drives the type_ids enum in
// irep2.h and the is_/to_/try_to_ predicate generators below.
#define IREP2_TYPE(kind, pretty) class kind##_type2t;
#include <irep2/type_kinds.inc>
#undef IREP2_TYPE
 
// Then give them a typedef name
 
#define irep_typedefs(basename)                                                \
  template <typename... Args>                                                  \
  inline type2tc basename##_type2tc(Args &&...args)                            \
  {                                                                            \
    return make_irep<basename##_type2t>(std::forward<Args>(args)...);          \
  }
 
irep_typedefs(bool);
irep_typedefs(empty);
irep_typedefs(symbol);
irep_typedefs(struct);
irep_typedefs(union);
irep_typedefs(unsignedbv);
irep_typedefs(signedbv);
irep_typedefs(code);
irep_typedefs(array);
irep_typedefs(pointer);
irep_typedefs(fixedbv);
irep_typedefs(floatbv);
irep_typedefs(complex);
irep_typedefs(cpp_name);
irep_typedefs(vector);
#undef irep_typedefs

class bool_type2t : public type2t
{
public:
  bool_type2t() : type2t(bool_id)
  {
  }
  bool_type2t(const bool_type2t &ref) = default;
  unsigned int get_width() const;
 
  static constexpr auto fields = std::make_tuple();
  static std::string field_names[esbmct::num_type_fields];
};

class empty_type2t : public type2t
{
public:
  empty_type2t() : type2t(empty_id)
  {
  }
  empty_type2t(const empty_type2t &ref) = default;
  unsigned int get_width() const;
 
  static constexpr auto fields = std::make_tuple();
  static std::string field_names[esbmct::num_type_fields];
};

class symbol_type2t : public type2t
{
public:
  symbol_type2t(const irep_idt &sym_name)
    : type2t(symbol_id), symbol_name(sym_name)
  {
  }
  symbol_type2t(const symbol_type2t &ref) = default;
  unsigned int get_width() const;
 
  irep_idt symbol_name;
 
  static constexpr auto fields = std::make_tuple(&symbol_type2t::symbol_name);
  static std::string field_names[esbmct::num_type_fields];
};

class struct_type2t : public type2t
{
public:
  struct_type2t(
    const std::vector<type2tc> &_members,
    const std::vector<irep_idt> &memb_names,
    const std::vector<irep_idt> &memb_pretty_names,
    const irep_idt &_name,
    bool _packed = false,
    const std::vector<irep_idt> &memb_base_names = {},
    const BigInt &_alignment = 0,
    const irep_idt &_python_aggregate = irep_idt(),
    bool _has_bases = false,
    const std::vector<irep_idt> &_bases = {})
    : type2t(struct_id),
      members(_members),
      member_names(memb_names),
      member_pretty_names(memb_pretty_names),
      member_base_names(memb_base_names),
      name(_name),
      packed(_packed),
      has_bases(_has_bases),
      alignment(_alignment),
      python_aggregate(_python_aggregate),
      bases(_bases)
  {
    assert(
      memb_base_names.empty() || memb_base_names.size() == _members.size());
  }
  struct_type2t(const struct_type2t &ref) = default;
  unsigned int get_width() const;
 
  std::vector<type2tc> members;
  std::vector<irep_idt> member_names;
  std::vector<irep_idt> member_pretty_names;
  std::vector<irep_idt> member_base_names;
  irep_idt name;
  bool packed;
  bool has_bases;

  BigInt alignment;

  irep_idt python_aggregate;

  std::vector<irep_idt> bases;
 
  static constexpr auto fields = std::make_tuple(
    &struct_type2t::members,
    &struct_type2t::member_names,
    &struct_type2t::member_pretty_names,
    &struct_type2t::name,
    &struct_type2t::packed);
  static constexpr std::size_t excluded_field_bytes =
    2 * sizeof(std::vector<irep_idt>) + sizeof(BigInt) + sizeof(irep_idt) +
    sizeof(bool);
  static std::string field_names[esbmct::num_type_fields];
};

class union_type2t : public type2t
{
public:
  union_type2t(
    const std::vector<type2tc> &_members,
    const std::vector<irep_idt> &memb_names,
    const std::vector<irep_idt> &memb_pretty_names,
    const irep_idt &_name,
    bool _packed = false)
    : type2t(union_id),
      members(_members),
      member_names(memb_names),
      member_pretty_names(memb_pretty_names),
      name(_name),
      packed(_packed)
  {
  }
  union_type2t(const union_type2t &ref) = default;
  unsigned int get_width() const;
 
  std::vector<type2tc> members;
  std::vector<irep_idt> member_names;
  std::vector<irep_idt> member_pretty_names;
  irep_idt name;
  bool packed;
 
  static constexpr auto fields = std::make_tuple(
    &union_type2t::members,
    &union_type2t::member_names,
    &union_type2t::member_pretty_names,
    &union_type2t::name,
    &union_type2t::packed);
  static std::string field_names[esbmct::num_type_fields];
};

class unsignedbv_type2t : public type2t
{
public:
  unsignedbv_type2t(
    unsigned int w,
    bool qualified = false,
    const irep_idt &cpp = irep_idt())
    : type2t(unsignedbv_id),
      width(w),
      cpp_type(cpp),
      constant_qualified(qualified)
  {
    // assert(w != 0 && "Must have nonzero width for integer type");
    // XXX -- zero sized bitfields are permissible. Oh my.
  }
  unsignedbv_type2t(const unsignedbv_type2t &ref) = default;
  unsigned int get_width() const;
 
  unsigned int width;
  irep_idt cpp_type;
  bool constant_qualified;
 
  static constexpr auto fields = std::make_tuple(&unsignedbv_type2t::width);
  static constexpr std::size_t excluded_field_bytes =
    sizeof(irep_idt) + sizeof(bool);
  static_assert(
    sizeof(unsigned int) + sizeof(irep_idt) + sizeof(bool) <=
      2 * sizeof(void *),
    "unsignedbv_type2t's reflected + excluded fields no longer fit the pinned "
    "layout; re-check fields_cover_class's margin before adding a field");
  static std::string field_names[esbmct::num_type_fields];
};

class signedbv_type2t : public type2t
{
public:
  signedbv_type2t(
    signed int w,
    bool qualified = false,
    const irep_idt &cpp = irep_idt())
    : type2t(signedbv_id),
      width(w),
      cpp_type(cpp),
      constant_qualified(qualified)
  {
  }
  signedbv_type2t(const signedbv_type2t &ref) = default;
  unsigned int get_width() const;
 
  unsigned int width;
  irep_idt cpp_type;
  bool constant_qualified;
 
  static constexpr auto fields = std::make_tuple(&signedbv_type2t::width);
  static constexpr std::size_t excluded_field_bytes =
    sizeof(irep_idt) + sizeof(bool);
  static_assert(
    sizeof(unsigned int) + sizeof(irep_idt) + sizeof(bool) <=
      2 * sizeof(void *),
    "signedbv_type2t's reflected + excluded fields no longer fit the pinned "
    "layout; re-check fields_cover_class's margin before adding a field");
  static std::string field_names[esbmct::num_type_fields];
};

class code_type2t : public type2t
{
public:
  code_type2t(
    const std::vector<type2tc> &args,
    const type2tc &ret,
    const std::vector<irep_idt> &names,
    bool e,
    const std::vector<irep_idt> &base_names = {},
    const std::vector<expr2tc> &defaults = {},
    const irep_idt &exc_kind = irep_idt(),
    const std::vector<irep_idt> &exc_types = {},
    const irep_idt &ret_marker = irep_idt(),
    bool implicit_union_copy_move = false,
    const std::vector<type2tc> &exc_decl = {})
    : type2t(code_id),
      arguments(args),
      ret_type(ret),
      argument_names(names),
      argument_base_names(base_names),
      argument_defaults(defaults),
      exception_types(exc_types),
      exception_decl(exc_decl),
      exception_kind(exc_kind),
      return_marker(ret_marker),
      ellipsis(e),
      implicit_union_copy_move(implicit_union_copy_move)
  {
    assert(args.size() == names.size());
    assert(base_names.empty() || base_names.size() == args.size());
    assert(defaults.empty() || defaults.size() == args.size());
  }
  code_type2t(const code_type2t &ref) = default;
  unsigned int get_width() const;
 
  std::vector<type2tc> arguments;
  type2tc ret_type;
  std::vector<irep_idt> argument_names;
  /// reflected: C11 6.7.6.3p15 makes a parameter's spelling no part of the
  /// function type, so two signatures differing only here are the same type and
  /// must hash and compare equal. Kept because a consumer reads it back --
  /// clang_cpp_convert_vft.cpp's thunk argument loop does
  /// (docs/roadmap/frontends-to-irep2.md §44).
  std::vector<irep_idt> argument_base_names;

  /// The arguments' `#default_value`s, null where an argument has none, and
  /// empty when none has one. Unreflected: a default is no part of the
  /// function's type. Carried because Python call lowering fills a missing
  /// argument from it (converter_funcall.cpp, function_call/expr.cpp).
  std::vector<expr2tc> argument_defaults;
  /// `exception_spec_types` record it (util/lang/exception_specification.h);
  /// empty when there is none. Unreflected, like the fields above: two
  /// signatures differing only here still compare equal. Carried because
  /// goto_convert_functions decodes it from the function symbol's type.
  std::vector<irep_idt> exception_types;
  /// finalize_exception_specification resolves them to `exception_types`.
  std::vector<type2tc> exception_decl;
  irep_idt exception_kind;
  /// "destructor"), which ret_type models as empty; and whether it is an
  /// implicit copy/move constructor of a union. Unreflected, like the fields
  /// above. Carried because vptr initialisation and the union copy/move
  /// synthesis read them (docs/roadmap/frontends-to-irep2.md §50.2,
  /// scope-clang-cpp-irep2.md §12).
  irep_idt return_marker;
  bool ellipsis;
  bool implicit_union_copy_move;
 
  static constexpr auto fields = std::make_tuple(
    &code_type2t::arguments,
    &code_type2t::ret_type,
    &code_type2t::argument_names,
    &code_type2t::ellipsis);
  static constexpr std::size_t excluded_field_bytes =
    2 * sizeof(std::vector<irep_idt>) + sizeof(std::vector<expr2tc>) +
    sizeof(std::vector<type2tc>) + 2 * sizeof(irep_idt) + sizeof(bool);
  static std::string field_names[esbmct::num_type_fields];
};

class array_type2t : public type2t
{
public:
  array_type2t(const type2tc &_subtype, const expr2tc &size, bool inf)
    : type2t(array_id),
      subtype(_subtype),
      array_size(size),
      size_is_infinite(inf)
  {
    // Constant-fold the size expression so identical array types compare
    // equal regardless of how their size was constructed. Skip the work
    // when the size is already a constant_int (the common case from the
    // frontend) — simplify() would just return nil for it but the walk
    // still costs a few cycles. Long-term fix is to normalise sizes at
    // the frontend / migration boundary instead.
    if (!is_nil_expr(size))
    {
      assert(
        size->type->type_id == signedbv_id ||
        size->type->type_id == unsignedbv_id);
      if (size->expr_id != expr2t::constant_int_id)
      {
        expr2tc sz = size->simplify();
        if (!is_nil_expr(sz))
          array_size = sz;
      }
    }
  }
  array_type2t(const array_type2t &ref) = default;
 
  virtual ~array_type2t() = default;
 
  unsigned int get_width() const;

  class array_size_excp : public std::exception
  {
  public:
    const char *what() const noexcept override
    {
      return "array size is not statically known";
    }
  };

  class inf_sized_array_excp : public array_size_excp
  {
  public:
    const char *what() const noexcept override
    {
      return "infinite sized array encountered";
    }
  };

  class dyn_sized_array_excp : public array_size_excp
  {
  public:
    dyn_sized_array_excp(const expr2tc &_size) : size(_size)
    {
    }
 
    const char *what() const noexcept override
    {
      return "Sizeof nondeterministically sized array encountered";
    }
 
    expr2tc size;
  };
 
  type2tc subtype;
  expr2tc array_size;
  bool size_is_infinite;
 
  static constexpr auto fields = std::make_tuple(
    &array_type2t::subtype,
    &array_type2t::array_size,
    &array_type2t::size_is_infinite);
  static std::string field_names[esbmct::num_type_fields];
};

class vector_type2t : public type2t
{
public:
  vector_type2t(const type2tc &_subtype, const expr2tc &size)
    : type2t(vector_id),
      subtype(_subtype),
      array_size(size),
      size_is_infinite(false)
  {
    // Mirror array_type2t: skip simplify() when the size is already a
    // literal. See note in array_type2t for the normalisation rationale.
    if (!is_nil_expr(size) && size->expr_id != expr2t::constant_int_id)
    {
      expr2tc sz = size->simplify();
      if (!is_nil_expr(sz))
        array_size = sz;
    }
  }
  vector_type2t(const vector_type2t &ref) = default;
  unsigned int get_width() const;
 
  type2tc subtype;
  expr2tc array_size;
  bool size_is_infinite;
 
  static constexpr auto fields = std::make_tuple(
    &vector_type2t::subtype,
    &vector_type2t::array_size,
    &vector_type2t::size_is_infinite);
  static std::string field_names[esbmct::num_type_fields];
};

enum class pointer_ref_kindt
{
  NONE,
  LVALUE,
  RVALUE
};

class pointer_type2t : public type2t
{
public:
  pointer_type2t(
    const type2tc &st,
    const bool &p = false,
    pointer_ref_kindt rk = pointer_ref_kindt::NONE)
    : type2t(pointer_id), subtype(st), carry_provenance(p), ref_kind(rk)
  {
  }
  pointer_type2t(const pointer_type2t &ref) = default;
  unsigned int get_width() const;
 
  type2tc subtype;
  bool carry_provenance;
  pointer_ref_kindt ref_kind;
 
  static constexpr auto fields = std::make_tuple(
    &pointer_type2t::subtype,
    &pointer_type2t::carry_provenance,
    &pointer_type2t::ref_kind);
  static std::string field_names[esbmct::num_type_fields];
};

class fixedbv_type2t : public type2t
{
public:
  fixedbv_type2t(unsigned int w, unsigned int ib)
    : type2t(fixedbv_id), width(w), integer_bits(ib)
  {
  }
  fixedbv_type2t(const fixedbv_type2t &ref) = default;
  unsigned int get_width() const;
 
  unsigned int width;
  unsigned int integer_bits;
 
  static constexpr auto fields =
    std::make_tuple(&fixedbv_type2t::width, &fixedbv_type2t::integer_bits);
  static std::string field_names[esbmct::num_type_fields];
};

class floatbv_type2t : public type2t
{
public:
  floatbv_type2t(
    unsigned int f,
    unsigned int e,
    const irep_idt &cpp = irep_idt())
    : type2t(floatbv_id), fraction(f), exponent(e), cpp_type(cpp)
  {
  }
  floatbv_type2t(const floatbv_type2t &ref) = default;
  unsigned int get_width() const;
 
  unsigned int fraction;
  unsigned int exponent;
  irep_idt cpp_type;
 
  static constexpr auto fields =
    std::make_tuple(&floatbv_type2t::fraction, &floatbv_type2t::exponent);
  static constexpr std::size_t excluded_field_bytes = sizeof(irep_idt);
  static std::string field_names[esbmct::num_type_fields];
};

class complex_type2t : public type2t
{
public:
  complex_type2t(const type2tc &st) : type2t(complex_id), subtype(st)
  {
  }
  complex_type2t(const complex_type2t &ref) = default;
  unsigned int get_width() const;
 
  type2tc subtype;
 
  static constexpr auto fields = std::make_tuple(&complex_type2t::subtype);
  static std::string field_names[esbmct::num_type_fields];
};

class cpp_name_type2t : public type2t
{
public:
  cpp_name_type2t(const irep_idt &n, const std::vector<type2tc> &ta)
    : type2t(cpp_name_id), name(n), template_args(ta)
  {
  }
  cpp_name_type2t(const cpp_name_type2t &ref) = default;
 
  unsigned int get_width() const;
 
  irep_idt name;
  std::vector<type2tc> template_args;
 
  static constexpr auto fields =
    std::make_tuple(&cpp_name_type2t::name, &cpp_name_type2t::template_args);
  static std::string field_names[esbmct::num_type_fields];
};
 
// Generate "is_<name>_type" predicates and "to_<name>_type" downcasts. The
// downcasts route through irep2_checked_type_cast so a bad to_*_type throws
// irep2_cast_error in every build mode rather than invoking undefined
// behaviour under NDEBUG (the previous design redefined dynamic_cast as
// static_cast in release).
#define type_macros(name)                                                      \
  inline bool is_##name##_type(const expr2tc &e)                               \
  {                                                                            \
    return e->type->type_id == type2t::name##_id;                              \
  }                                                                            \
  inline bool is_##name##_type(const type2tc &t)                               \
  {                                                                            \
    return t->type_id == type2t::name##_id;                                    \
  }                                                                            \
  inline const name##_type2t &to_##name##_type(const type2tc &t)               \
  {                                                                            \
    return irep2_checked_type_cast<const name##_type2t>(                       \
      *t.get(), type2t::name##_id, #name);                                     \
  }                                                                            \
  inline name##_type2t &to_##name##_type(type2tc &t)                           \
  {                                                                            \
    return irep2_checked_type_cast<name##_type2t>(                             \
      *t.get(), type2t::name##_id, #name);                                     \
  }                                                                            \
  inline const name##_type2t *try_to_##name##_type(const type2tc &t)           \
  {                                                                            \
    return is_##name##_type(t) ? &to_##name##_type(t) : nullptr;               \
  }
 
// Instantiate the is_/to_/try_to_ predicate triple for every kind in
// type_kinds.inc. Same manifest as the enum and forward declarations.
#define IREP2_TYPE(kind, pretty) type_macros(kind);
#include <irep2/type_kinds.inc>
#undef IREP2_TYPE
#undef type_macros
 
// struct_type2t and union_type2t each own a 5-field block
// (members / member_names / member_pretty_names / name / packed);
// complex_type2t stores only its element type but the SMT tuple
// lowering treats it as a (real, imag) 2-tuple of that type. The
// helpers below give callers a uniform "tuple view" of all three
// without forcing them to dispatch by hand: for struct/union they
// copy the kind's stored vectors, for complex they synthesise the
// 2-element view from the subtype. Return-by-value lets the helper
// be uniform; callers bind to `const auto &x = ...` and rely on
// temporary lifetime extension.
//
// Small per-call copies in exchange for a single point of truth per
// field. Direct mutation goes via the mutating overload below (or via
// the concrete kind, e.g. `to_struct_type(t).members`).
std::vector<type2tc> struct_union_members(const type2tc &t);
std::vector<irep_idt> struct_union_member_names(const type2tc &t);
irep_idt struct_union_name(const type2tc &t);
bool struct_union_packed(const type2tc &t);

std::vector<type2tc> &struct_union_members(type2tc &t);

std::optional<unsigned int>
struct_union_get_component_number(const type2tc &t, const irep_idt &comp);
 
#endif /* IREP2_TYPE_H_ */