ops.h

Go to the documentation of this file.

/* Operations within the code being analyzed.
   Copyright (C) 2019-2026 Free Software Foundation, Inc.
   Contributed by David Malcolm <dmalcolm@redhat.com>.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
 
#ifndef GCC_ANALYZER_OPS_H
#define GCC_ANALYZER_OPS_H
 
#include "except.h"
#include "gimple-walk.h"
 
namespace ana {
 
class operation;
  class control_flow_op;
  class call_and_return_op;
  class phis_for_edge_op;
 
class callsite_expr;
 
struct operation_context
{
  operation_context (exploded_graph &eg,
                     exploded_node &src_enode,
                     const superedge &sedge)
  : m_eg (eg),
    m_src_enode (src_enode),
    m_sedge (sedge)
  {
  }
 
  void DEBUG_FUNCTION dump () const;
 
  logger *get_logger () const;
 
  const extrinsic_state &get_ext_state () const;
 
  const program_point &
  get_initial_point () const;
 
  const program_state &
  get_initial_state () const;
 
  const supergraph &
  get_supergraph () const;
 
  program_point
  get_next_intraprocedural_point () const;
 
  void
  add_outcome (const program_point &dst_point,
               program_state dst_state,
               bool could_do_work,
               uncertainty_t *uncertainty,
               std::unique_ptr<custom_edge_info> info = nullptr);
 
  exploded_graph &m_eg;
  exploded_node &m_src_enode;
  const superedge &m_sedge;
};
 
struct rewind_context
{
  rewind_context (logger *logger,
                  diagnostic_state input_state)
  : m_logger (logger),
    m_input (input_state),
    m_output (input_state)
  {
  }
 
  void
  on_data_origin (tree dst);
 
  void
  on_data_flow (tree src, tree dst);
 
  virtual const region_model &
  get_src_region_model () const = 0;
 
  virtual const region_model &
  get_dst_region_model () const = 0;
 
  virtual bool
  could_be_affected_by_write_p (tree lhs) = 0;
 
  virtual void
  add_state_transition (std::unique_ptr<state_transition>) = 0;
 
  logger *m_logger;
  diagnostic_state m_input;
  diagnostic_state m_output;
};
 
/* Abstract base class for an operation along a superedge.  */
 
class operation
{
 public:
  // Discriminator for concrete subclasses
  enum kind
  {
    asm_stmt,
    assignment,
    predict_stmt,
    return_stmt,
    resx,
    cond_edge,
    goto_edge,
    switch_edge,
    eh_dispatch_try_edge,
    eh_dispatch_allowed_edge,
    phis,
    call_and_return
  };
 
  virtual ~operation () {}
 
  void
  dump () const;
 
  virtual std::unique_ptr<operation>
  clone () const = 0;
 
  virtual void
  print_as_edge_label (pretty_printer *pp, bool user_facing) const = 0;
 
  virtual bool
  defines_ssa_name_p (const_tree ssa_name) const = 0;
 
  virtual void
  walk_load_store_addr_ops (void *,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn) const = 0;
 
  virtual const gimple *
  maybe_get_stmt () const
  {
    return nullptr;
  }
 
  virtual void
  execute (operation_context &op_ctxt) const = 0;
 
  virtual bool
  execute_for_feasibility (const exploded_edge &,
                           feasibility_state &,
                           region_model_context *,
                           std::unique_ptr<rejected_constraint> */*out_rc*/) const
  {
    // no-op
    return true;
  }
 
  /* Is this op suitable for bulk-merging?
     It must have a single outcome, at the intraprocedural
     next point, with some state.  */
  virtual bool
  supports_bulk_merge_p () const = 0;
  virtual void
  update_state_for_bulk_merger (const program_state &,
                                program_state &) const
  {
    /* Must be implemented for any subclasses that return true
       for supports_bulk_merge_p.  */
    gcc_unreachable ();
  }
  virtual void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const = 0;
 
  virtual const control_flow_op *
  dyn_cast_control_flow_op () const { return nullptr; }
 
  virtual const call_and_return_op *
  dyn_cast_call_and_return_op () const { return nullptr; }
 
  virtual const phis_for_edge_op *
  dyn_cast_phis_for_edge_op () const { return nullptr; }
 
  enum kind get_kind () const { return m_kind; }
 
  virtual bool
  try_to_rewind_data_flow (rewind_context &) const
  {
    return false;
  }
 
protected:
  operation (enum kind kind_)
  : m_kind (kind_)
  {
  }
 
  static void
  handle_on_stmt_for_state_machines (operation_context &op_ctxt,
                                     program_state &dst_state,
                                     path_context *path_ctxt,
                                     bool &unknown_side_effects,
                                     const gimple &stmt);
 
private:
  enum kind m_kind;
};
 
/* Subclass for an operation representing a specific gimple stmt
   that isn't control flow.  */
 
class gimple_stmt_op : public operation
{
public:
  const gimple &get_stmt () const { return m_stmt; }
 
  void
  print_as_edge_label (pretty_printer *pp, bool user_facing) const override;
 
  bool
  defines_ssa_name_p (const_tree ssa_name) const final override;
 
  void
  walk_load_store_addr_ops (void *,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn) const final override;
 
  const gimple *
  maybe_get_stmt () const final override
  {
    return &m_stmt;
  }
 
  void
  execute (operation_context &op_ctxt) const override;
 
  void
  execute_on_state (operation_context &op_ctxt,
                    program_state dst_state) const;
 
  bool
  execute_for_feasibility (const exploded_edge &,
                           feasibility_state &,
                           region_model_context *,
                           std::unique_ptr<rejected_constraint> *out_rc) const override;
 
  virtual bool
  supports_bulk_merge_p () const override;
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const override;
 
protected:
  gimple_stmt_op (enum kind kind_, const gimple &stmt)
  : operation (kind_), m_stmt (stmt)
  {}
 
private:
  const gimple &m_stmt;
};
 
/* Various subclasses of gimple_stmt_op.  */
 
/* An operation subclass representing the effect of a GIMPLE_ASM stmt.  */
 
class gasm_op : public gimple_stmt_op
{
public:
  gasm_op (const gasm &asm_stmt)
  : gimple_stmt_op (kind::asm_stmt, asm_stmt)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<gasm_op> (get_gasm ());
  }
 
  const gasm &get_gasm () const
  {
    return *as_a <const gasm *> (&get_stmt ());
  }
};
 
/* An operation subclass representing the effect of a GIMPLE_ASSIGN stmt.  */
 
class gassign_op : public gimple_stmt_op
{
public:
  gassign_op (const gassign &assign_stmt)
  : gimple_stmt_op (kind::assignment, assign_stmt)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<gassign_op> (get_gassign ());
  }
 
  const gassign &get_gassign () const
  {
    return *as_a <const gassign *> (&get_stmt ());
  }
 
  bool
  try_to_rewind_data_flow (rewind_context &ctxt) const final override;
};
 
/* An operation subclass for a GIMPLE_PREDICT stmt.
   They have no effect on state, but can be useful for reconstructing
   where "return" statements were in the code the user originally wrote,
   to improve the reported locations in diagnostics.  */
 
class predict_op : public gimple_stmt_op
{
public:
  predict_op (const gimple &predict_stmt)
  : gimple_stmt_op (kind::predict_stmt, predict_stmt)
  {
    gcc_assert (predict_stmt.code == GIMPLE_PREDICT);
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<predict_op> (get_stmt ());
  }
 
  bool
  try_to_rewind_data_flow (rewind_context &) const final override
  {
    return true;
  }
};
 
/* An operation subclass representing both:
   (a) the effect of a GIMPLE_RETURN stmt: copying a value into the
   RESULT_DECL of the current frame, and
   (b) a hint when reporting diagnostics that this is the return
   path from the function (rather than say, throwing an exception).  */
 
class greturn_op : public gimple_stmt_op
{
public:
  greturn_op (const greturn &return_stmt)
  : gimple_stmt_op (kind::return_stmt, return_stmt)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<greturn_op> (get_greturn ());
  }
 
  void
  execute (operation_context &op_ctxt) const final override;
 
  bool
  execute_for_feasibility (const exploded_edge &,
                           feasibility_state &,
                           region_model_context *ctxt,
                           std::unique_ptr<rejected_constraint> *out_rc) const override;
 
  bool
  supports_bulk_merge_p () const final override
  {
    return false;
  }
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const final override;
 
  const greturn &get_greturn () const
  {
    return *as_a <const greturn *> (&get_stmt ());
  }
 
  tree get_retval () const
  {
    return gimple_return_retval (&get_greturn ());
  }
 
  bool
  try_to_rewind_data_flow (rewind_context &ctxt) const final override;
};
 
/* A concrete operation subclass representing the effect of a GIMPLE_CALL stmt.
 
   If the function is identified and has a known body, either simulate
   it interprocedurally by pushing a stack frame and transitioning to the
   callee, or simulate it intraprocedurally by replaying a summary of the
   effects of the call.
 
   If the function is identified but has an unknown body,
   simulate it intraprocedurally, either using a known_function
   subclass for precision, or following conservative rules that
   assume various side-effects.
 
   If the function is unidentified (for some kinds of dynamic calls),
   simulate it intraprocedurally, following conservative rules that
   assume various side-effects.
 
   In the various intraprocedural simulation cases, the exploded edge will
   correspond to the underlying superedge.
 
   In the interprocedural simulation case, the exploded edge will
   link two supernodes in different functions, and thus will require
   custom edge info.
 
   Various subclasses exist for handling awkward special cases,
   such as longjmp.  */
 
class call_and_return_op : public gimple_stmt_op
{
public:
  static std::unique_ptr<operation>
  make (const gcall &call_stmt);
 
  std::unique_ptr<operation>
  clone () const override
  {
    return std::make_unique<call_and_return_op> (get_gcall ());
  }
 
  const gcall &get_gcall () const
  {
    return *as_a <const gcall *> (&get_stmt ());
  }
 
  void
  execute (operation_context &op_ctxt) const override;
 
  bool
  supports_bulk_merge_p () const final override
  {
    return false;
  }
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const override;
 
  const call_and_return_op *
  dyn_cast_call_and_return_op () const final override { return this; }
 
  tree
  map_expr_from_caller_to_callee (tree callee_fndecl,
                                  tree caller_expr,
                                  callsite_expr *out) const;
  tree
  map_expr_from_callee_to_caller (tree callee_fndecl,
                                  tree callee_expr,
                                  callsite_expr *out) const;
 
  call_and_return_op (const gcall &call_stmt)
  : gimple_stmt_op (kind::call_and_return, call_stmt)
  {
  }
 
  const known_function *
  maybe_get_known_function (const call_details &cd) const;
 
  bool
  try_to_rewind_data_flow (rewind_context &ctxt) const final override;
 
private:
  cgraph_edge *
  get_any_cgraph_edge (operation_context &op_ctxt) const;
 
  void
  replay_call_summaries (operation_context &op_ctxt,
                         function &called_fn,
                         per_function_data &called_fn_data,
                         region_model_context *ctxt) const;
 
  void
  replay_call_summary (operation_context &op_ctxt,
                       function &called_fn,
                       call_summary &summary,
                       region_model_context *ctxt) const;
 
  tree
  get_arg_for_parm (tree callee_fndecl,
                    tree parm,
                    callsite_expr *out) const;
  tree
  get_parm_for_arg (tree callee_fndecl,
                    tree arg,
                    callsite_expr *out) const;
};
 
/* A call to one of the various __analyzer_dump* functions.
   These have no effect on state.  */
 
class dump_op : public call_and_return_op
{
public:
  enum dump_kind
  {
   state,
   sarif,
   dot,
   state_2
  };
 
  dump_op (const gcall &call_stmt, enum dump_kind dump_kind_)
  : call_and_return_op (call_stmt),
    m_dump_kind (dump_kind_)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<dump_op> (get_gcall (), m_dump_kind);
  }
 
  void
  execute (operation_context &op_ctxt) const final override;
 
private:
  enum dump_kind m_dump_kind;
};
 
class setjmp_op : public call_and_return_op
{
public:
  setjmp_op (const gcall &call_stmt)
  : call_and_return_op (call_stmt)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<setjmp_op> (get_gcall ());
  }
 
  void
  execute (operation_context &op_ctxt) const final override;
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const final override;
};
 
class longjmp_op : public call_and_return_op
{
public:
  longjmp_op (const gcall &call_stmt)
  : call_and_return_op (call_stmt)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<longjmp_op> (get_gcall ());
  }
 
  void
  execute (operation_context &op_ctxt) const final override;
};
 
class cxa_throw_op : public call_and_return_op
{
public:
  cxa_throw_op (const gcall &call_stmt, bool is_rethrow)
  : call_and_return_op (call_stmt),
    m_is_rethrow (is_rethrow)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<cxa_throw_op> (get_gcall (), m_is_rethrow);
  }
 
  void
  execute (operation_context &op_ctxt) const final override;
 
private:
  bool m_is_rethrow;
};
 
class resx_op : public gimple_stmt_op
{
public:
  resx_op (const gresx &resx_stmt)
  : gimple_stmt_op (kind::resx, resx_stmt)
  {
  }
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<resx_op> (get_gresx ());
  }
 
  const gresx &get_gresx () const
  {
    return *as_a <const gresx *> (&get_stmt ());
  }
 
  void
  execute (operation_context &op_ctxt) const final override;
 
  bool
  supports_bulk_merge_p () const final override
  {
    return false;
  }
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const final override;
};
 
/* An abstract subclass of operation representing the filtering effect on
   state of a gimple control-flow statement at the end of a BB, for
   a specific CFG out-edge from that BB.  */
 
class control_flow_op : public operation
{
public:
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const override;
 
  bool
  defines_ssa_name_p (const_tree) const final override
  {
    return false;
  }
 
  void
  walk_load_store_addr_ops (void *,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn) const final override;
 
  const gimple *
  maybe_get_stmt () const final override
  {
    return &m_ctrlflow_stmt;
  }
 
  virtual label_text
  maybe_describe_condition (bool can_colorize) const;
 
  void
  execute (operation_context &op_ctxt) const final override;
 
  bool
  supports_bulk_merge_p () const final override
  {
    return false;
  }
 
  bool
  execute_for_feasibility (const exploded_edge &,
                           feasibility_state &,
                           region_model_context *,
                           std::unique_ptr<rejected_constraint> *out_rc) const override;
 
  const control_flow_op *
  dyn_cast_control_flow_op () const final override { return this; }
 
  ::edge get_cfg_edge () const { return m_cfg_edge; }
  int get_flags () const { return m_cfg_edge->flags; }
  int back_edge_p () const { return get_flags () & EDGE_DFS_BACK; }
 
  const gimple &get_ctrlflow_stmt () const { return m_ctrlflow_stmt; }
 
  bool
  try_to_rewind_data_flow (rewind_context &) const final override
  {
    return true;
  }
 
protected:
  control_flow_op (enum kind kind_,
                   ::edge cfg_edge,
                   const gimple &ctrlflow_stmt)
  : operation (kind_),
    m_cfg_edge (cfg_edge),
    m_ctrlflow_stmt (ctrlflow_stmt)
  {}
 
private:
  virtual bool
  apply_constraints (const superedge *sedge,
                     region_model &model,
                     region_model_context *ctxt,
                     std::unique_ptr<rejected_constraint> *out) const = 0;
 
  ::edge m_cfg_edge;
  const gimple &m_ctrlflow_stmt;
};
 
/* Concrete operation subclass representing filtering/applying state
   transitions on a specific CFG edge after a GIMPLE_COND stmt, either the
   "if (cond) is true" or the "if (cond) is false" branch.  */
 
class gcond_edge_op : public control_flow_op
{
public:
  gcond_edge_op (::edge cfg_edge,
                 const gcond &cond_stmt);
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<gcond_edge_op> (get_cfg_edge (),
                                            get_gcond ());
  }
 
  void
  print_as_edge_label (pretty_printer *pp,
                       bool user_facing) const final override;
 
  label_text
  maybe_describe_condition (bool can_colorize) const final override;
 
  const gcond &get_gcond () const
  {
    return *as_a <const gcond *> (&get_ctrlflow_stmt ());
  }
 
private:
  static label_text
  maybe_describe_condition (bool can_colorize,
                            tree lhs,
                            enum tree_code op,
                            tree rhs);
  static bool should_print_expr_p (tree expr);
 
  bool
  apply_constraints (const superedge *sedge,
                     region_model &model,
                     region_model_context *ctxt,
                     std::unique_ptr<rejected_constraint> *out)
    const final override;
 
  bool m_true_value;
};
 
/* Concrete operation subclass representing filtering/applying state
   transitions on a specific CFG edge after a GIMPLE_GOTO stmt, thus
   handling computed gotos.  */
 
class ggoto_edge_op : public control_flow_op
{
public:
  ggoto_edge_op (::edge cfg_edge,
                 const ggoto &goto_stmt,
                 tree dst_label);
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<ggoto_edge_op> (get_cfg_edge (),
                                            get_ggoto (),
                                            m_dst_label);
  }
 
  void
  print_as_edge_label (pretty_printer *pp,
                       bool user_facing) const final override;
 
  label_text
  maybe_describe_condition (bool can_colorize) const final override;
 
  const ggoto &get_ggoto () const
  {
    return *as_a <const ggoto *> (&get_ctrlflow_stmt ());
  }
 
private:
  bool
  apply_constraints (const superedge *sedge,
                     region_model &model,
                     region_model_context *ctxt,
                     std::unique_ptr<rejected_constraint> *out)
    const final override;
 
  tree m_dst_label;
};
 
/* Concrete operation subclass representing filtering/applying state
   transitions on a specific CFG edge after a GIMPLE_SWITCH stmt, thus
   handling a cluster of cases/default value.  */
 
class switch_case_op : public control_flow_op
{
 public:
  switch_case_op (function &fun,
                  ::edge cfg_edge,
                  const gswitch &switch_stmt,
                  bounded_ranges_manager &mgr);
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<switch_case_op> (*this);
  }
 
  void
  print_as_edge_label (pretty_printer *pp,
                       bool user_facing) const final override;
 
  bool implicitly_created_default_p () const;
 
  const gswitch &get_gswitch () const
  {
    return *as_a <const gswitch *> (&get_ctrlflow_stmt ());
  }
 
 private:
  bool
  apply_constraints (const superedge *sedge,
                     region_model &model,
                     region_model_context *ctxt,
                     std::unique_ptr<rejected_constraint> *out)
    const final override;
 
  std::vector<tree> m_case_labels;
  const bounded_ranges *m_all_cases_ranges;
};
 
/* Abstract subclass for edges from eh_dispatch statements.  */
 
class eh_dispatch_edge_op : public control_flow_op
{
public:
  static std::unique_ptr<eh_dispatch_edge_op>
  make (supernode *src,
        supernode *dest,
        ::edge cfg_edge,
        const geh_dispatch &geh_dispatch_stmt);
 
  const geh_dispatch &
  get_geh_dispatch () const
  {
    return *as_a <const geh_dispatch *> (&get_ctrlflow_stmt ());
  }
 
  eh_region
  get_eh_region () const { return m_eh_region; }
 
protected:
  eh_dispatch_edge_op (supernode *src_snode,
                       enum kind kind_,
                       ::edge cfg_edge,
                       const geh_dispatch &geh_dispatch_stmt,
                       eh_region eh_reg);
 
  supernode *get_src_snode () const { return m_src_snode; }
 
private:
  bool
  apply_constraints (const superedge *sedge,
                     region_model &model,
                     region_model_context *ctxt,
                     std::unique_ptr<rejected_constraint> *out)
    const final override;
 
  virtual bool
  apply_eh_constraints (const superedge *sedge,
                        region_model &model,
                        region_model_context *ctxt,
                        tree exception_type,
                        std::unique_ptr<rejected_constraint> *out) const = 0;
 
  supernode *m_src_snode;
  eh_region m_eh_region;
};
 
/* Concrete operation for edges from an eh_dispatch statement
   for ERT_TRY regions.  */
 
class eh_dispatch_try_edge_op : public eh_dispatch_edge_op
{
public:
  eh_dispatch_try_edge_op (supernode *src_snode,
                           ::edge cfg_edge,
                           const geh_dispatch &geh_dispatch_stmt,
                           eh_region eh_reg,
                           eh_catch ehc);
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<eh_dispatch_try_edge_op> (*this);
  }
 
  void
  print_as_edge_label (pretty_printer *pp,
                       bool user_facing) const final override;
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const final override;
 
private:
  bool
  apply_eh_constraints (const superedge *sedge,
                        region_model &model,
                        region_model_context *ctxt,
                        tree exception_type,
                        std::unique_ptr<rejected_constraint> *out)
    const final override;
 
  eh_catch m_eh_catch;
};
 
/* Concrete operation for edges from an eh_dispatch statement
   for ERT_ALLOWED_EXCEPTIONS regions.  */
 
class eh_dispatch_allowed_edge_op : public eh_dispatch_edge_op
{
public:
  enum eh_kind
  {
    expected,
    unexpected
  };
 
  eh_dispatch_allowed_edge_op (supernode *src_snode,
                               supernode *dst_snode,
                               ::edge cfg_edge,
                               const geh_dispatch &geh_dispatch_stmt,
                               eh_region eh_reg);
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<eh_dispatch_allowed_edge_op> (*this);
  }
 
  void
  print_as_edge_label (pretty_printer *pp,
                       bool user_facing) const final override;
 
  enum eh_kind get_eh_kind () const { return m_kind; }
 
private:
  bool
  apply_eh_constraints (const superedge *sedge,
                        region_model &model,
                        region_model_context *ctxt,
                        tree exception_type,
                        std::unique_ptr<rejected_constraint> *out)
    const final override;
 
  enum eh_kind m_kind;
};
 
/* Concrete operation subclass representing the state transition
   for simultaneously handling all of the phi nodes at the entry to a BB,
   after following a specific CFG in-edge.
   Note that this covers multiple gimple stmts: all of the gphi stmts
   at a basic block entry (albeit for just one in-edge).
   This can be thought of as handling one column of the entries in the
   phi nodes of a BB (for a specific in-edge).
   We ignore MEM entries, and discard phi nodes purely affecting them.  */
 
class phis_for_edge_op : public operation
{
public:
  /* A "dst=src;" pair within a phi node.  */
  struct pair
  {
    tree m_dst;
    tree m_src;
  };
 
  static std::unique_ptr<operation>
  maybe_make (::edge cfg_in_edge);
 
  std::unique_ptr<operation>
  clone () const final override
  {
    return std::make_unique<phis_for_edge_op> (*this);
  }
 
  phis_for_edge_op (std::vector<pair> &&pairs);
 
  const phis_for_edge_op *
  dyn_cast_phis_for_edge_op () const final override { return this; }
 
  void
  print_as_edge_label (pretty_printer *pp,
                       bool user_facing) const final override;
 
  bool
  defines_ssa_name_p (const_tree ssa_name) const final override;
 
  void
  walk_load_store_addr_ops (void *,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn,
                            walk_stmt_load_store_addr_fn) const final override;
  void
  execute (operation_context &op_ctxt) const final override;
 
  bool
  execute_for_feasibility (const exploded_edge &,
                           feasibility_state &,
                           region_model_context *,
                           std::unique_ptr<rejected_constraint> *out_rc) const override;
 
  bool
  supports_bulk_merge_p () const final override
  {
    return true;
  }
  void
  update_state_for_bulk_merger (const program_state &src_state,
                                program_state &dst_state) const final override;
 
  void
  add_any_events_for_eedge (const exploded_edge &eedge,
                            checker_path &out_path) const final override;
 
  bool
  try_to_rewind_data_flow (rewind_context &ctxt) const final override;
 
  const std::vector<pair> &get_pairs () const { return m_pairs; }
 
private:
  static std::vector<pair>
  get_pairs_for_phi_along_in_edge (::edge cfg_in_edge);
 
  void
  update_state (const program_state &src_state,
                program_state &dst_state,
                region_model_context *ctxt) const;
 
  std::vector<pair> m_pairs;
};
 
} // namespace ana
 
#endif /* GCC_ANALYZER_OPS_H */