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