gcc/tree-ssa-operands.h

   1 /* SSA operand management for trees.
   2    Copyright (C) 2003, 2005 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 2, 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 COPYING.  If not, write to the Free
  18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 #ifndef GCC_TREE_SSA_OPERANDS_H
  22 #define GCC_TREE_SSA_OPERANDS_H
  23
  24 /* Interface to SSA operands.  */
  25
  26
  27 /* This represents a pointer to a DEF operand.  */
  28 typedef struct def_operand_ptr GTY(())
  29 {
  30   tree * GTY((skip(""))) def;
  31 } def_operand_p;
  32
  33 /* This represents a pointer to a USE operand.  */
  34 typedef ssa_imm_use_t *use_operand_p;
  35
  36 #define NULL_USE_OPERAND_P              NULL
  37 extern def_operand_p NULL_DEF_OPERAND_P;
  38
  39 /* This represents the DEF operands of a stmt.  */
  40 typedef struct def_optype_d GTY(())
  41 {
  42   unsigned num_defs;
  43   struct def_operand_ptr GTY((length("%h.num_defs"))) defs[1];
  44 } def_optype_t;
  45
  46 typedef def_optype_t *def_optype;
  47
  48 /* Operand type which uses a pointer to a tree ihn an immediate use.  */
  49 typedef ssa_imm_use_t use_operand_type_t;
  50
  51 /* This represents the USE operands of a stmt.  */
  52 typedef struct use_optype_d GTY(())
  53 {
  54   unsigned num_uses;
  55   struct ssa_imm_use_d GTY((length("%h.num_uses"))) uses[1];
  56 } use_optype_t;
  57
  58 typedef use_optype_t *use_optype;
  59
  60 /* Operand type which stores a def a use, and an immediate use.  */
  61 typedef struct v_def_use_operand_type GTY(())
  62 {
  63   tree def;
  64   tree use;
  65   ssa_imm_use_t imm_use;
  66 } v_def_use_operand_type_t;
  67
  68 /* This represents the MAY_DEFS for a stmt.  */
  69 typedef struct v_may_def_optype_d GTY(())
  70 {
  71   unsigned num_v_may_defs;
  72   struct v_def_use_operand_type GTY((length ("%h.num_v_may_defs")))
  73                                                               v_may_defs[1];
  74 } v_may_def_optype_t;
  75
  76 typedef v_may_def_optype_t *v_may_def_optype;
  77
  78 /* Operand type which stores a tree and an immeidate_use.  */
  79 typedef struct vuse_operand_type GTY(())
  80 {
  81   tree use;
  82   ssa_imm_use_t imm_use;
  83 } vuse_operand_type_t;
  84
  85 /* This represents the VUSEs for a stmt.  */
  86 typedef struct vuse_optype_d GTY(())
  87 {
  88   unsigned num_vuses;
  89   struct vuse_operand_type GTY((length ("%h.num_vuses"))) vuses[1];
  90 } vuse_optype_t;
  91
  92 typedef vuse_optype_t *vuse_optype;
  93
  94 /* This represents the V_MUST_DEFS for a stmt.  */
  95 typedef struct v_must_def_optype_d GTY(())
  96 {
  97   unsigned num_v_must_defs;
  98   v_def_use_operand_type_t GTY((length("%h.num_v_must_defs"))) v_must_defs[1];
  99 } v_must_def_optype_t;
 100
 101 typedef v_must_def_optype_t *v_must_def_optype;
 102
 103 /* This represents the operand cache for a stmt.  */
 104 typedef struct stmt_operands_d GTY(())
 105 {
 106   /* Statement operands.  */
 107   struct def_optype_d * GTY (()) def_ops;
 108   struct use_optype_d * GTY (()) use_ops;
 109
 110   /* Virtual operands (V_MAY_DEF, VUSE, and V_MUST_DEF).  */
 111   struct v_may_def_optype_d * GTY (()) v_may_def_ops;
 112   struct vuse_optype_d * GTY (()) vuse_ops;
 113   struct v_must_def_optype_d * GTY (()) v_must_def_ops;
 114 } stmt_operands_t;
 115
 116 typedef stmt_operands_t *stmt_operands_p;
 117
 118 #define USE_FROM_PTR(OP)        get_use_from_ptr (OP)
 119 #define DEF_FROM_PTR(OP)        get_def_from_ptr (OP)
 120 #define SET_USE(OP, V)          set_ssa_use_from_ptr (OP, V)
 121 #define SET_DEF(OP, V)          ((*((OP).def)) = (V))
 122
 123 #define USE_STMT(OP)            (OP)->stmt
 124
 125 #define USE_OPS(ANN)            get_use_ops (ANN)
 126 #define STMT_USE_OPS(STMT)      get_use_ops (stmt_ann (STMT))
 127 #define NUM_USES(OPS)           ((OPS) ? (OPS)->num_uses : 0)
 128 #define USE_OP_PTR(OPS, I)      get_use_op_ptr ((OPS), (I))
 129 #define USE_OP(OPS, I)          (USE_FROM_PTR (USE_OP_PTR ((OPS), (I))))
 130 #define SET_USE_OP(OPS, I, V)   (SET_USE (USE_OP_PTR ((OPS), (I)), (V)))
 131
 132
 133
 134 #define DEF_OPS(ANN)            get_def_ops (ANN)
 135 #define STMT_DEF_OPS(STMT)      get_def_ops (stmt_ann (STMT))
 136 #define NUM_DEFS(OPS)           ((OPS) ? (OPS)->num_defs : 0)
 137 #define DEF_OP_PTR(OPS, I)      get_def_op_ptr ((OPS), (I))
 138 #define DEF_OP(OPS, I)          (DEF_FROM_PTR (DEF_OP_PTR ((OPS), (I))))
 139 #define SET_DEF_OP(OPS, I, V)   (SET_DEF (DEF_OP_PTR ((OPS), (I)), (V)))
 140
 141
 142
 143 #define V_MAY_DEF_OPS(ANN)              get_v_may_def_ops (ANN)
 144 #define STMT_V_MAY_DEF_OPS(STMT)        get_v_may_def_ops (stmt_ann(STMT))
 145 #define NUM_V_MAY_DEFS(OPS)             ((OPS) ? (OPS)->num_v_may_defs : 0)
 146 #define V_MAY_DEF_RESULT_PTR(OPS, I)    get_v_may_def_result_ptr ((OPS), (I))
 147 #define V_MAY_DEF_RESULT(OPS, I)                                        \
 148                             (DEF_FROM_PTR (V_MAY_DEF_RESULT_PTR ((OPS), (I))))
 149 #define SET_V_MAY_DEF_RESULT(OPS, I, V)                                 \
 150                             (SET_DEF (V_MAY_DEF_RESULT_PTR ((OPS), (I)), (V)))
 151 #define V_MAY_DEF_OP_PTR(OPS, I)        get_v_may_def_op_ptr ((OPS), (I))
 152 #define V_MAY_DEF_OP(OPS, I)                                            \
 153                             (USE_FROM_PTR (V_MAY_DEF_OP_PTR ((OPS), (I))))
 154 #define SET_V_MAY_DEF_OP(OPS, I, V)                                     \
 155                             (SET_USE (V_MAY_DEF_OP_PTR ((OPS), (I)), (V)))
 156
 157
 158 #define VUSE_OPS(ANN)           get_vuse_ops (ANN)
 159 #define STMT_VUSE_OPS(STMT)     get_vuse_ops (stmt_ann(STMT))
 160 #define NUM_VUSES(OPS)          ((OPS) ? (OPS)->num_vuses : 0)
 161 #define VUSE_OP_PTR(OPS, I)     get_vuse_op_ptr ((OPS), (I))
 162 #define VUSE_OP(OPS, I)         (USE_FROM_PTR (VUSE_OP_PTR ((OPS), (I))))
 163 #define SET_VUSE_OP(OPS, I, V)  (SET_USE (VUSE_OP_PTR ((OPS), (I)), (V)))
 164
 165
 166 #define V_MUST_DEF_OPS(ANN)             get_v_must_def_ops (ANN)
 167 #define STMT_V_MUST_DEF_OPS(STMT)       get_v_must_def_ops (stmt_ann (STMT))
 168 #define NUM_V_MUST_DEFS(OPS)            ((OPS) ? (OPS)->num_v_must_defs : 0)
 169 #define V_MUST_DEF_RESULT_PTR(OPS, I)   get_v_must_def_result_ptr ((OPS), (I))
 170 #define V_MUST_DEF_RESULT(OPS, I) \
 171                                 (DEF_FROM_PTR (V_MUST_DEF_RESULT_PTR ((OPS), (I))))
 172 #define SET_V_MUST_DEF_RESULT(OPS, I, V) \
 173                                 (SET_DEF (V_MUST_DEF_RESULT_PTR ((OPS), (I)), (V)))
 174 #define V_MUST_DEF_KILL_PTR(OPS, I)  get_v_must_def_kill_ptr ((OPS), (I))
 175 #define V_MUST_DEF_KILL(OPS, I) (USE_FROM_PTR (V_MUST_DEF_KILL_PTR ((OPS), (I))))
 176 #define SET_V_MUST_DEF_KILL(OPS, I, V) (SET_USE (V_MUST_DEF_KILL_PTR ((OPS), (I)), (V)))
 177
 178 #define PHI_RESULT_PTR(PHI)     get_phi_result_ptr (PHI)
 179 #define PHI_RESULT(PHI)         DEF_FROM_PTR (PHI_RESULT_PTR (PHI))
 180 #define SET_PHI_RESULT(PHI, V)  SET_DEF (PHI_RESULT_PTR (PHI), (V))
 181
 182 #define PHI_ARG_DEF_PTR(PHI, I) get_phi_arg_def_ptr ((PHI), (I))
 183 #define PHI_ARG_DEF(PHI, I)     USE_FROM_PTR (PHI_ARG_DEF_PTR ((PHI), (I)))
 184 #define SET_PHI_ARG_DEF(PHI, I, V)                                      \
 185                                 SET_USE (PHI_ARG_DEF_PTR ((PHI), (I)), (V))
 186 #define PHI_ARG_DEF_FROM_EDGE(PHI, E)                                   \
 187                                 PHI_ARG_DEF ((PHI), (E)->dest_idx)
 188 #define PHI_ARG_DEF_PTR_FROM_EDGE(PHI, E)                               \
 189                                 PHI_ARG_DEF_PTR ((PHI), (E)->dest_idx)
 190 #define PHI_ARG_INDEX_FROM_USE(USE)   phi_arg_index_from_use (USE)
 191
 192
 193 extern void init_ssa_operands (void);
 194 extern void fini_ssa_operands (void);
 195 extern void update_stmt_operands (tree);
 196 extern bool verify_imm_links (FILE *f, tree var);
 197
 198 extern void copy_virtual_operands (tree, tree);
 199 extern void create_ssa_artficial_load_stmt (stmt_operands_p, tree);
 200
 201 extern void dump_immediate_uses (FILE *file);
 202 extern void dump_immediate_uses_for (FILE *file, tree var);
 203 extern void debug_immediate_uses (void);
 204 extern void debug_immediate_uses_for (tree var);
 205
 206 extern bool ssa_call_clobbered_cache_valid;
 207 extern bool ssa_ro_call_cache_valid;
 208
 209 /* This structure is used in the operand iterator loops.  It contains the
 210    items required to determine which operand is retrieved next.  During
 211    optimization, this structure is scalarized, and any unused fields are
 212    optimized away, resulting in little overhead.  */
 213
 214 typedef struct ssa_operand_iterator_d
 215 {
 216   int num_use;
 217   int num_def;
 218   int num_vuse;
 219   int num_v_mayu;
 220   int num_v_mayd;
 221   int num_v_mustu;
 222   int num_v_mustd;
 223   int use_i;
 224   int def_i;
 225   int vuse_i;
 226   int v_mayu_i;
 227   int v_mayd_i;
 228   int v_mustu_i;
 229   int v_mustd_i;
 230   stmt_operands_p ops;
 231   bool done;
 232 } ssa_op_iter;
 233
 234 /* These flags are used to determine which operands are returned during
 235    execution of the loop.  */
 236 #define SSA_OP_USE              0x01    /* Real USE operands.  */
 237 #define SSA_OP_DEF              0x02    /* Real DEF operands.  */
 238 #define SSA_OP_VUSE             0x04    /* VUSE operands.  */
 239 #define SSA_OP_VMAYUSE          0x08    /* USE portion of V_MAY_DEFS.  */
 240 #define SSA_OP_VMAYDEF          0x10    /* DEF portion of V_MAY_DEFS.  */
 241 #define SSA_OP_VMUSTDEF         0x20    /* V_MUST_DEF definitions.  */
 242 #define SSA_OP_VMUSTDEFKILL     0x40    /* V_MUST_DEF kills.  */
 243
 244 /* These are commonly grouped operand flags.  */
 245 #define SSA_OP_VIRTUAL_USES     (SSA_OP_VUSE | SSA_OP_VMAYUSE)
 246 #define SSA_OP_VIRTUAL_DEFS     (SSA_OP_VMAYDEF | SSA_OP_VMUSTDEF)
 247 #define SSA_OP_VIRTUAL_KILLS    (SSA_OP_VMUSTDEFKILL)
 248 #define SSA_OP_ALL_VIRTUALS     (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS | SSA_OP_VIRTUAL_DEFS)
 249 #define SSA_OP_ALL_USES         (SSA_OP_VIRTUAL_USES | SSA_OP_USE)
 250 #define SSA_OP_ALL_DEFS         (SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF)
 251 #define SSA_OP_ALL_KILLS        (SSA_OP_VIRTUAL_KILLS)
 252 #define SSA_OP_ALL_OPERANDS     (SSA_OP_ALL_USES | SSA_OP_ALL_DEFS | SSA_OP_ALL_KILLS)
 253
 254 /* This macro executes a loop over the operands of STMT specified in FLAG,
 255    returning each operand as a 'tree' in the variable TREEVAR.  ITER is an
 256    ssa_op_iter structure used to control the loop.  */
 257 #define FOR_EACH_SSA_TREE_OPERAND(TREEVAR, STMT, ITER, FLAGS)   \
 258   for (TREEVAR = op_iter_init_tree (&(ITER), STMT, FLAGS);      \
 259        !op_iter_done (&(ITER));                                 \
 260        TREEVAR = op_iter_next_tree (&(ITER)))
 261
 262 /* This macro executes a loop over the operands of STMT specified in FLAG,
 263    returning each operand as a 'use_operand_p' in the variable USEVAR.
 264    ITER is an ssa_op_iter structure used to control the loop.  */
 265 #define FOR_EACH_SSA_USE_OPERAND(USEVAR, STMT, ITER, FLAGS)     \
 266   for (USEVAR = op_iter_init_use (&(ITER), STMT, FLAGS);        \
 267        !op_iter_done (&(ITER));                                 \
 268        USEVAR = op_iter_next_use (&(ITER)))
 269
 270 /* This macro executes a loop over the operands of STMT specified in FLAG,
 271    returning each operand as a 'def_operand_p' in the variable DEFVAR.
 272    ITER is an ssa_op_iter structure used to control the loop.  */
 273 #define FOR_EACH_SSA_DEF_OPERAND(DEFVAR, STMT, ITER, FLAGS)     \
 274   for (DEFVAR = op_iter_init_def (&(ITER), STMT, FLAGS);        \
 275        !op_iter_done (&(ITER));                                 \
 276        DEFVAR = op_iter_next_def (&(ITER)))
 277
 278 /* This macro executes a loop over the V_MAY_DEF operands of STMT.  The def
 279    and use for each V_MAY_DEF is returned in DEFVAR and USEVAR.
 280    ITER is an ssa_op_iter structure used to control the loop.  */
 281 #define FOR_EACH_SSA_MAYDEF_OPERAND(DEFVAR, USEVAR, STMT, ITER) \
 282   for (op_iter_init_maydef (&(ITER), STMT, &(USEVAR), &(DEFVAR));       \
 283        !op_iter_done (&(ITER));                                 \
 284        op_iter_next_maydef (&(USEVAR), &(DEFVAR), &(ITER)))
 285
 286 /* This macro executes a loop over the V_MUST_DEF operands of STMT.  The def
 287    and kill for each V_MUST_DEF is returned in DEFVAR and KILLVAR.
 288    ITER is an ssa_op_iter structure used to control the loop.  */
 289 #define FOR_EACH_SSA_MUSTDEF_OPERAND(DEFVAR, KILLVAR, STMT, ITER)       \
 290   for (op_iter_init_mustdef (&(ITER), STMT, &(KILLVAR), &(DEFVAR));     \
 291        !op_iter_done (&(ITER));                                 \
 292        op_iter_next_mustdef (&(KILLVAR), &(DEFVAR), &(ITER)))
 293
 294 /* This macro executes a loop over the V_{MUST,MAY}_DEF of STMT.  The def
 295    and kill for each V_{MUST,MAY}_DEF is returned in DEFVAR and KILLVAR.
 296    ITER is an ssa_op_iter structure used to control the loop.  */
 297 #define FOR_EACH_SSA_MUST_AND_MAY_DEF_OPERAND(DEFVAR, KILLVAR, STMT, ITER)\
 298   for (op_iter_init_must_and_may_def (&(ITER), STMT, &(KILLVAR), &(DEFVAR));\
 299        !op_iter_done (&(ITER));                                 \
 300        op_iter_next_must_and_may_def (&(KILLVAR), &(DEFVAR), &(ITER)))
 301 #endif  /* GCC_TREE_SSA_OPERANDS_H  */