Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-ssa-operands.h @ 63:b7f97abdc517 gcc-4.6-20100522
update gcc from gcc-4.5.0 to gcc-4.6
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 24 May 2010 12:47:05 +0900 |
| parents | 77e2b8dfacca |
| children | f6334be47118 |
| rev | line source |
|---|---|
| 0 | 1 /* SSA operand management for trees. |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2 Copyright (C) 2003, 2005, 2006, 2007, 2008, 2010 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3 Free Software Foundation, Inc. |
| 0 | 4 |
| 5 This file is part of GCC. | |
| 6 | |
| 7 GCC is free software; you can redistribute it and/or modify it under | |
| 8 the terms of the GNU General Public License as published by the Free | |
| 9 Software Foundation; either version 3, or (at your option) any later | |
| 10 version. | |
| 11 | |
| 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with GCC; see the file COPYING3. If not see | |
| 19 <http://www.gnu.org/licenses/>. */ | |
| 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 tree *def_operand_p; | |
| 29 | |
| 30 /* This represents a pointer to a USE operand. */ | |
| 31 typedef ssa_use_operand_t *use_operand_p; | |
| 32 | |
| 33 /* NULL operand types. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
34 #define NULL_USE_OPERAND_P ((use_operand_p)NULL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
35 #define NULL_DEF_OPERAND_P ((def_operand_p)NULL) |
| 0 | 36 |
| 37 /* This represents the DEF operands of a stmt. */ | |
| 38 struct def_optype_d | |
| 39 { | |
| 40 struct def_optype_d *next; | |
| 41 tree *def_ptr; | |
| 42 }; | |
| 43 typedef struct def_optype_d *def_optype_p; | |
| 44 | |
| 45 /* This represents the USE operands of a stmt. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
46 struct use_optype_d |
| 0 | 47 { |
| 48 struct use_optype_d *next; | |
| 49 struct ssa_use_operand_d use_ptr; | |
| 50 }; | |
| 51 typedef struct use_optype_d *use_optype_p; | |
| 52 | |
| 53 /* This structure represents a variable sized buffer which is allocated by the | |
| 54 operand memory manager. Operands are suballocated out of this block. The | |
| 55 MEM array varies in size. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
56 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
57 struct GTY((chain_next("%h.next"))) ssa_operand_memory_d { |
| 0 | 58 struct ssa_operand_memory_d *next; |
| 59 char mem[1]; | |
| 60 }; | |
| 61 | |
| 62 /* Per-function operand caches. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
63 struct GTY(()) ssa_operands { |
| 0 | 64 struct ssa_operand_memory_d *operand_memory; |
| 65 unsigned operand_memory_index; | |
| 66 /* Current size of the operand memory buffer. */ | |
| 67 unsigned int ssa_operand_mem_size; | |
| 68 | |
| 69 bool ops_active; | |
| 70 | |
| 71 struct def_optype_d * GTY ((skip (""))) free_defs; | |
| 72 struct use_optype_d * GTY ((skip (""))) free_uses; | |
| 73 }; | |
| 74 | |
| 75 #define USE_FROM_PTR(PTR) get_use_from_ptr (PTR) | |
| 76 #define DEF_FROM_PTR(PTR) get_def_from_ptr (PTR) | |
| 77 #define SET_USE(USE, V) set_ssa_use_from_ptr (USE, V) | |
| 78 #define SET_DEF(DEF, V) ((*(DEF)) = (V)) | |
| 79 | |
| 80 #define USE_STMT(USE) (USE)->loc.stmt | |
| 81 | |
| 82 #define USE_OP_PTR(OP) (&((OP)->use_ptr)) | |
| 83 #define USE_OP(OP) (USE_FROM_PTR (USE_OP_PTR (OP))) | |
| 84 | |
| 85 #define DEF_OP_PTR(OP) ((OP)->def_ptr) | |
| 86 #define DEF_OP(OP) (DEF_FROM_PTR (DEF_OP_PTR (OP))) | |
| 87 | |
| 88 #define PHI_RESULT_PTR(PHI) gimple_phi_result_ptr (PHI) | |
| 89 #define PHI_RESULT(PHI) DEF_FROM_PTR (PHI_RESULT_PTR (PHI)) | |
| 90 #define SET_PHI_RESULT(PHI, V) SET_DEF (PHI_RESULT_PTR (PHI), (V)) | |
| 91 | |
| 92 #define PHI_ARG_DEF_PTR(PHI, I) gimple_phi_arg_imm_use_ptr ((PHI), (I)) | |
| 93 #define PHI_ARG_DEF(PHI, I) USE_FROM_PTR (PHI_ARG_DEF_PTR ((PHI), (I))) | |
| 94 #define SET_PHI_ARG_DEF(PHI, I, V) \ | |
| 95 SET_USE (PHI_ARG_DEF_PTR ((PHI), (I)), (V)) | |
| 96 #define PHI_ARG_DEF_FROM_EDGE(PHI, E) \ | |
| 97 PHI_ARG_DEF ((PHI), (E)->dest_idx) | |
| 98 #define PHI_ARG_DEF_PTR_FROM_EDGE(PHI, E) \ | |
| 99 PHI_ARG_DEF_PTR ((PHI), (E)->dest_idx) | |
| 100 #define PHI_ARG_INDEX_FROM_USE(USE) phi_arg_index_from_use (USE) | |
| 101 | |
| 102 | |
| 103 extern void init_ssa_operands (void); | |
| 104 extern void fini_ssa_operands (void); | |
| 105 extern void update_stmt_operands (gimple); | |
| 106 extern void free_stmt_operands (gimple); | |
| 107 extern bool verify_imm_links (FILE *f, tree var); | |
| 108 | |
| 109 extern void dump_immediate_uses (FILE *file); | |
| 110 extern void dump_immediate_uses_for (FILE *file, tree var); | |
| 111 extern void debug_immediate_uses (void); | |
| 112 extern void debug_immediate_uses_for (tree var); | |
| 113 extern void dump_decl_set (FILE *, bitmap); | |
| 114 extern void debug_decl_set (bitmap); | |
| 115 | |
| 116 extern bool ssa_operands_active (void); | |
| 117 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
118 extern void unlink_stmt_vdef (gimple); |
| 0 | 119 |
| 120 enum ssa_op_iter_type { | |
| 121 ssa_op_iter_none = 0, | |
| 122 ssa_op_iter_tree, | |
| 123 ssa_op_iter_use, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
124 ssa_op_iter_def |
| 0 | 125 }; |
| 126 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
127 /* This structure is used in the operand iterator loops. It contains the |
| 0 | 128 items required to determine which operand is retrieved next. During |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
129 optimization, this structure is scalarized, and any unused fields are |
| 0 | 130 optimized away, resulting in little overhead. */ |
| 131 | |
| 132 typedef struct ssa_operand_iterator_d | |
| 133 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
134 bool done; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
135 enum ssa_op_iter_type iter_type; |
| 0 | 136 def_optype_p defs; |
| 137 use_optype_p uses; | |
| 138 int phi_i; | |
| 139 int num_phi; | |
| 140 gimple phi_stmt; | |
| 141 } ssa_op_iter; | |
| 142 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
143 /* These flags are used to determine which operands are returned during |
| 0 | 144 execution of the loop. */ |
| 145 #define SSA_OP_USE 0x01 /* Real USE operands. */ | |
| 146 #define SSA_OP_DEF 0x02 /* Real DEF operands. */ | |
| 147 #define SSA_OP_VUSE 0x04 /* VUSE operands. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
148 #define SSA_OP_VDEF 0x08 /* VDEF operands. */ |
| 0 | 149 |
| 150 /* These are commonly grouped operand flags. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
151 #define SSA_OP_VIRTUAL_USES (SSA_OP_VUSE) |
| 0 | 152 #define SSA_OP_VIRTUAL_DEFS (SSA_OP_VDEF) |
| 153 #define SSA_OP_ALL_VIRTUALS (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS) | |
| 154 #define SSA_OP_ALL_USES (SSA_OP_VIRTUAL_USES | SSA_OP_USE) | |
| 155 #define SSA_OP_ALL_DEFS (SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF) | |
| 156 #define SSA_OP_ALL_OPERANDS (SSA_OP_ALL_USES | SSA_OP_ALL_DEFS) | |
| 157 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
158 /* This macro executes a loop over the operands of STMT specified in FLAG, |
| 0 | 159 returning each operand as a 'tree' in the variable TREEVAR. ITER is an |
| 160 ssa_op_iter structure used to control the loop. */ | |
| 161 #define FOR_EACH_SSA_TREE_OPERAND(TREEVAR, STMT, ITER, FLAGS) \ | |
| 162 for (TREEVAR = op_iter_init_tree (&(ITER), STMT, FLAGS); \ | |
| 163 !op_iter_done (&(ITER)); \ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
164 (void) (TREEVAR = op_iter_next_tree (&(ITER)))) |
| 0 | 165 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
166 /* This macro executes a loop over the operands of STMT specified in FLAG, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
167 returning each operand as a 'use_operand_p' in the variable USEVAR. |
| 0 | 168 ITER is an ssa_op_iter structure used to control the loop. */ |
| 169 #define FOR_EACH_SSA_USE_OPERAND(USEVAR, STMT, ITER, FLAGS) \ | |
| 170 for (USEVAR = op_iter_init_use (&(ITER), STMT, FLAGS); \ | |
| 171 !op_iter_done (&(ITER)); \ | |
| 172 USEVAR = op_iter_next_use (&(ITER))) | |
| 173 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
174 /* This macro executes a loop over the operands of STMT specified in FLAG, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
175 returning each operand as a 'def_operand_p' in the variable DEFVAR. |
| 0 | 176 ITER is an ssa_op_iter structure used to control the loop. */ |
| 177 #define FOR_EACH_SSA_DEF_OPERAND(DEFVAR, STMT, ITER, FLAGS) \ | |
| 178 for (DEFVAR = op_iter_init_def (&(ITER), STMT, FLAGS); \ | |
| 179 !op_iter_done (&(ITER)); \ | |
| 180 DEFVAR = op_iter_next_def (&(ITER))) | |
| 181 | |
| 182 /* This macro will execute a loop over all the arguments of a PHI which | |
| 183 match FLAGS. A use_operand_p is always returned via USEVAR. FLAGS | |
| 184 can be either SSA_OP_USE or SSA_OP_VIRTUAL_USES or SSA_OP_ALL_USES. */ | |
| 185 #define FOR_EACH_PHI_ARG(USEVAR, STMT, ITER, FLAGS) \ | |
| 186 for ((USEVAR) = op_iter_init_phiuse (&(ITER), STMT, FLAGS); \ | |
| 187 !op_iter_done (&(ITER)); \ | |
| 188 (USEVAR) = op_iter_next_use (&(ITER))) | |
| 189 | |
| 190 | |
| 191 /* This macro will execute a loop over a stmt, regardless of whether it is | |
| 192 a real stmt or a PHI node, looking at the USE nodes matching FLAGS. */ | |
| 193 #define FOR_EACH_PHI_OR_STMT_USE(USEVAR, STMT, ITER, FLAGS) \ | |
| 194 for ((USEVAR) = (gimple_code (STMT) == GIMPLE_PHI \ | |
| 195 ? op_iter_init_phiuse (&(ITER), STMT, FLAGS) \ | |
| 196 : op_iter_init_use (&(ITER), STMT, FLAGS)); \ | |
| 197 !op_iter_done (&(ITER)); \ | |
| 198 (USEVAR) = op_iter_next_use (&(ITER))) | |
| 199 | |
| 200 /* This macro will execute a loop over a stmt, regardless of whether it is | |
| 201 a real stmt or a PHI node, looking at the DEF nodes matching FLAGS. */ | |
| 202 #define FOR_EACH_PHI_OR_STMT_DEF(DEFVAR, STMT, ITER, FLAGS) \ | |
| 203 for ((DEFVAR) = (gimple_code (STMT) == GIMPLE_PHI \ | |
| 204 ? op_iter_init_phidef (&(ITER), STMT, FLAGS) \ | |
| 205 : op_iter_init_def (&(ITER), STMT, FLAGS)); \ | |
| 206 !op_iter_done (&(ITER)); \ | |
| 207 (DEFVAR) = op_iter_next_def (&(ITER))) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
208 |
| 0 | 209 /* This macro returns an operand in STMT as a tree if it is the ONLY |
| 210 operand matching FLAGS. If there are 0 or more than 1 operand matching | |
| 211 FLAGS, then NULL_TREE is returned. */ | |
| 212 #define SINGLE_SSA_TREE_OPERAND(STMT, FLAGS) \ | |
| 213 single_ssa_tree_operand (STMT, FLAGS) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
214 |
| 0 | 215 /* This macro returns an operand in STMT as a use_operand_p if it is the ONLY |
| 216 operand matching FLAGS. If there are 0 or more than 1 operand matching | |
| 217 FLAGS, then NULL_USE_OPERAND_P is returned. */ | |
| 218 #define SINGLE_SSA_USE_OPERAND(STMT, FLAGS) \ | |
| 219 single_ssa_use_operand (STMT, FLAGS) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
220 |
| 0 | 221 /* This macro returns an operand in STMT as a def_operand_p if it is the ONLY |
| 222 operand matching FLAGS. If there are 0 or more than 1 operand matching | |
| 223 FLAGS, then NULL_DEF_OPERAND_P is returned. */ | |
| 224 #define SINGLE_SSA_DEF_OPERAND(STMT, FLAGS) \ | |
| 225 single_ssa_def_operand (STMT, FLAGS) | |
| 226 | |
| 227 /* This macro returns TRUE if there are no operands matching FLAGS in STMT. */ | |
| 228 #define ZERO_SSA_OPERANDS(STMT, FLAGS) zero_ssa_operands (STMT, FLAGS) | |
| 229 | |
| 230 /* This macro counts the number of operands in STMT matching FLAGS. */ | |
| 231 #define NUM_SSA_OPERANDS(STMT, FLAGS) num_ssa_operands (STMT, FLAGS) | |
| 232 | |
| 233 #endif /* GCC_TREE_SSA_OPERANDS_H */ |