clang_c_adjust_irep2.h

Go to the documentation of this file.

#pragma once
 
#include <util/symtab/context.h>
#include <util/symtab/namespace.h>
#include <irep2/irep2.h>
#include <cstddef>
#include <vector>

template <class Pass>
struct adjust_arm
{
  const char *name;
  void (*run)(Pass &, expr2tc &);
  bool (*when)(const expr2tc &);
};

template <class Pass, std::size_t N>
void run_adjust_arms(
  Pass &self,
  const adjust_arm<Pass> (&arms)[N],
  expr2tc &expr)
{
  for (const adjust_arm<Pass> &a : arms)
    if (!a.when || a.when(expr))
      a.run(self, expr);
}
 
class clang_c_adjust_irep2
{
public:
  explicit clang_c_adjust_irep2(
    contextt &_context,
    bool sole_adjuster = false,
    bool writeback_all = false)
    : context(_context),
      sole_adjuster(sole_adjuster),
      writeback_all(writeback_all)
  {
  }
 
  virtual ~clang_c_adjust_irep2() = default;

  bool adjust();
 
  void adjust_expr(expr2tc &expr);

  struct arm_info
  {
    const char *name;
    bool (*when)(const expr2tc &);
  };

  static std::vector<arm_info> arm_order();
 
  // Everything below is reachable by a sibling frontend's pass, which orders
  // these arms alongside its own in its own table
  // (docs/roadmap/scope-clang-cpp-irep2.md §3.1). Not public: nothing outside
  // an adjust pass has any business calling a single arm.
protected:
  virtual void adjust_reference(expr2tc &)
  {
  }

  void adjust_increment_reference(expr2tc &expr);

  void adjust_index(expr2tc &expr);

  void adjust_member(expr2tc &expr);

  void declare_implicit_callee(const expr2tc &expr);

  void adjust_boolean_operands(expr2tc &expr);

  void adjust_call_callee(expr2tc &expr);

  void adjust_call_signature(expr2tc &expr);

  virtual void align_call_return_type(expr2tc &, const symbolt &)
  {
  }

  void adjust_complex_arith(expr2tc &expr);

  void adjust_complex_unary(expr2tc &expr);

  void adjust_if_expr(expr2tc &expr);

  void adjust_special_functions(expr2tc &expr);

  void adjust_derived_to_base(expr2tc &expr);

  void adjust_base_to_derived(expr2tc &expr);

  void adjust_address_of(expr2tc &expr);

  void adjust_ptr_mem(expr2tc &expr);

  void declare_polymorphic_builtin(expr2tc &expr);
 
  void adjust_expression_statement(expr2tc &expr);
  void promote_unary_bool_operand(expr2tc &expr);
  void adjust_struct(expr2tc &expr);
  void adjust_array_subtype(expr2tc &expr);
  void adjust_decl_init(expr2tc &expr);
  void adjust_dereference(expr2tc &expr);
  void lower_complex_compound_assignment(expr2tc &expr);
  void adjust_vector_float_arith(expr2tc &expr);
  void hoist_for_init(expr2tc &expr);

  void pad_type_symbol(symbolt &symbol);
  void adjust_binary_arith_operands(expr2tc &expr);
  void adjust_shift_operands(expr2tc &expr);

  /// IREP2 form of clang_c_adjust::adjust_side_effect_assignment's plain
  /// "assign" case: the node takes the target's type, and the source converts
  /// to it.
  void adjust_plain_assignment(expr2tc &expr);

  void adjust_compound_assignment(expr2tc &expr);
  void adjust_statement_condition(expr2tc &expr);
  bool adjust_float_builtin(
    expr2tc &expr,
    const irep_idt &name,
    const std::vector<expr2tc> &args);

  void adjust_relational(expr2tc &expr);

  void adjust_call_arguments(expr2tc &expr);

  void adjust_function_designators(expr2tc &expr);

  virtual void gen_symbol_code(symbolt &)
  {
  }

  virtual void adjust_symbol_type(symbolt &)
  {
  }

  virtual void adjust_before_operands(expr2tc &)
  {
  }

  virtual void adjust_sole_arms(expr2tc &expr);

  void adjust_comma_type(expr2tc &expr);
 
  using arm = adjust_arm<clang_c_adjust_irep2>;

  static const arm arms[];
 
  contextt &context;
  const bool sole_adjuster;
  const bool writeback_all;
  locationt enclosing_location;
  namespacet ns{context};
};

void adjust_comma_at_dispatch(exprt &expr, const namespacet &ns);