1  /* Header file for gimple statement walk support.
       2     Copyright (C) 2013-2023 Free Software Foundation, Inc.
       3  
       4  This file is part of GCC.
       5  
       6  GCC is free software; you can redistribute it and/or modify it under
       7  the terms of the GNU General Public License as published by the Free
       8  Software Foundation; either version 3, or (at your option) any later
       9  version.
      10  
      11  GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12  WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14   for more details.
      15  
      16  You should have received a copy of the GNU General Public License
      17  along with GCC; see the file COPYING3.  If not see
      18  <http://www.gnu.org/licenses/>.  */
      19  
      20  #ifndef GCC_GIMPLE_WALK_H
      21  #define GCC_GIMPLE_WALK_H
      22  
      23  /* Convenience routines to walk all statements of a gimple function.
      24     Note that this is useful exclusively before the code is converted
      25     into SSA form.  Once the program is in SSA form, the standard
      26     operand interface should be used to analyze/modify statements.  */
      27  struct walk_stmt_info
      28  {
      29    /* Points to the current statement being walked.  */
      30    gimple_stmt_iterator gsi;
      31    gimple *stmt;
      32  
      33    /* Additional data that the callback functions may want to carry
      34       through the recursion.  */
      35    void *info;
      36  
      37    /* Pointer map used to mark visited tree nodes when calling
      38       walk_tree on each operand.  If set to NULL, duplicate tree nodes
      39       will be visited more than once.  */
      40    hash_set<tree> *pset;
      41  
      42    /* Operand returned by the callbacks.  This is set when calling
      43       walk_gimple_seq.  If the walk_stmt_fn or walk_tree_fn callback
      44       returns non-NULL, this field will contain the tree returned by
      45       the last callback.  */
      46    tree callback_result;
      47  
      48    /* Indicates whether the operand being examined may be replaced
      49       with something that matches is_gimple_val (if true) or something
      50       slightly more complicated (if false).  "Something" technically
      51       means the common subset of is_gimple_lvalue and is_gimple_rhs,
      52       but we never try to form anything more complicated than that, so
      53       we don't bother checking.
      54  
      55       Also note that CALLBACK should update this flag while walking the
      56       sub-expressions of a statement.  For instance, when walking the
      57       statement 'foo (&var)', the flag VAL_ONLY will initially be set
      58       to true, however, when walking &var, the operand of that
      59       ADDR_EXPR does not need to be a GIMPLE value.  */
      60    BOOL_BITFIELD val_only : 1;
      61  
      62    /* True if we are currently walking the LHS of an assignment.  */
      63    BOOL_BITFIELD is_lhs : 1;
      64  
      65    /* Optional.  Set to true by the callback functions if they made any
      66       changes.  */
      67    BOOL_BITFIELD changed : 1;
      68  
      69    /* True if we're interested in location information.  */
      70    BOOL_BITFIELD want_locations : 1;
      71  
      72    /* True if we've removed the statement that was processed.  */
      73    BOOL_BITFIELD removed_stmt : 1;
      74  };
      75  
      76  /* Callback for walk_gimple_stmt.  Called for every statement found
      77     during traversal.  The first argument points to the statement to
      78     walk.  The second argument is a flag that the callback sets to
      79     'true' if it the callback handled all the operands and
      80     sub-statements of the statement (the default value of this flag is
      81     'false').  The third argument is an anonymous pointer to data
      82     to be used by the callback.  */
      83  typedef tree (*walk_stmt_fn) (gimple_stmt_iterator *, bool *,
      84  			      struct walk_stmt_info *);
      85  
      86  extern gimple *walk_gimple_seq_mod (gimple_seq *, walk_stmt_fn, walk_tree_fn,
      87  				   struct walk_stmt_info *);
      88  extern gimple *walk_gimple_seq (gimple_seq, walk_stmt_fn, walk_tree_fn,
      89  			       struct walk_stmt_info *);
      90  extern tree walk_gimple_op (gimple *, walk_tree_fn, struct walk_stmt_info *);
      91  extern tree walk_gimple_stmt (gimple_stmt_iterator *, walk_stmt_fn,
      92  			      walk_tree_fn, struct walk_stmt_info *);
      93  typedef bool (*walk_stmt_load_store_addr_fn) (gimple *, tree, tree, void *);
      94  extern bool walk_stmt_load_store_addr_ops (gimple *, void *,
      95  					   walk_stmt_load_store_addr_fn,
      96  					   walk_stmt_load_store_addr_fn,
      97  					   walk_stmt_load_store_addr_fn);
      98  extern bool walk_stmt_load_store_ops (gimple *, void *,
      99  				      walk_stmt_load_store_addr_fn,
     100  				      walk_stmt_load_store_addr_fn);
     101  #endif /* GCC_GIMPLE_WALK_H */