1*38fd1498Szrj /* Gimple walk support.
2*38fd1498Szrj
3*38fd1498Szrj Copyright (C) 2007-2018 Free Software Foundation, Inc.
4*38fd1498Szrj Contributed by Aldy Hernandez <aldyh@redhat.com>
5*38fd1498Szrj
6*38fd1498Szrj This file is part of GCC.
7*38fd1498Szrj
8*38fd1498Szrj GCC is free software; you can redistribute it and/or modify it under
9*38fd1498Szrj the terms of the GNU General Public License as published by the Free
10*38fd1498Szrj Software Foundation; either version 3, or (at your option) any later
11*38fd1498Szrj version.
12*38fd1498Szrj
13*38fd1498Szrj GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14*38fd1498Szrj WARRANTY; without even the implied warranty of MERCHANTABILITY or
15*38fd1498Szrj FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16*38fd1498Szrj for more details.
17*38fd1498Szrj
18*38fd1498Szrj You should have received a copy of the GNU General Public License
19*38fd1498Szrj along with GCC; see the file COPYING3. If not see
20*38fd1498Szrj <http://www.gnu.org/licenses/>. */
21*38fd1498Szrj
22*38fd1498Szrj #include "config.h"
23*38fd1498Szrj #include "system.h"
24*38fd1498Szrj #include "coretypes.h"
25*38fd1498Szrj #include "backend.h"
26*38fd1498Szrj #include "tree.h"
27*38fd1498Szrj #include "gimple.h"
28*38fd1498Szrj #include "gimple-iterator.h"
29*38fd1498Szrj #include "gimple-walk.h"
30*38fd1498Szrj #include "stmt.h"
31*38fd1498Szrj
32*38fd1498Szrj /* Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt
33*38fd1498Szrj on each one. WI is as in walk_gimple_stmt.
34*38fd1498Szrj
35*38fd1498Szrj If walk_gimple_stmt returns non-NULL, the walk is stopped, and the
36*38fd1498Szrj value is stored in WI->CALLBACK_RESULT. Also, the statement that
37*38fd1498Szrj produced the value is returned if this statement has not been
38*38fd1498Szrj removed by a callback (wi->removed_stmt). If the statement has
39*38fd1498Szrj been removed, NULL is returned.
40*38fd1498Szrj
41*38fd1498Szrj Otherwise, all the statements are walked and NULL returned. */
42*38fd1498Szrj
43*38fd1498Szrj gimple *
walk_gimple_seq_mod(gimple_seq * pseq,walk_stmt_fn callback_stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)44*38fd1498Szrj walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
45*38fd1498Szrj walk_tree_fn callback_op, struct walk_stmt_info *wi)
46*38fd1498Szrj {
47*38fd1498Szrj gimple_stmt_iterator gsi;
48*38fd1498Szrj
49*38fd1498Szrj for (gsi = gsi_start (*pseq); !gsi_end_p (gsi); )
50*38fd1498Szrj {
51*38fd1498Szrj tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
52*38fd1498Szrj if (ret)
53*38fd1498Szrj {
54*38fd1498Szrj /* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
55*38fd1498Szrj to hold it. */
56*38fd1498Szrj gcc_assert (wi);
57*38fd1498Szrj wi->callback_result = ret;
58*38fd1498Szrj
59*38fd1498Szrj return wi->removed_stmt ? NULL : gsi_stmt (gsi);
60*38fd1498Szrj }
61*38fd1498Szrj
62*38fd1498Szrj if (!wi->removed_stmt)
63*38fd1498Szrj gsi_next (&gsi);
64*38fd1498Szrj }
65*38fd1498Szrj
66*38fd1498Szrj if (wi)
67*38fd1498Szrj wi->callback_result = NULL_TREE;
68*38fd1498Szrj
69*38fd1498Szrj return NULL;
70*38fd1498Szrj }
71*38fd1498Szrj
72*38fd1498Szrj
73*38fd1498Szrj /* Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't
74*38fd1498Szrj changed by the callbacks. */
75*38fd1498Szrj
76*38fd1498Szrj gimple *
walk_gimple_seq(gimple_seq seq,walk_stmt_fn callback_stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)77*38fd1498Szrj walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
78*38fd1498Szrj walk_tree_fn callback_op, struct walk_stmt_info *wi)
79*38fd1498Szrj {
80*38fd1498Szrj gimple_seq seq2 = seq;
81*38fd1498Szrj gimple *ret = walk_gimple_seq_mod (&seq2, callback_stmt, callback_op, wi);
82*38fd1498Szrj gcc_assert (seq2 == seq);
83*38fd1498Szrj return ret;
84*38fd1498Szrj }
85*38fd1498Szrj
86*38fd1498Szrj
87*38fd1498Szrj /* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
88*38fd1498Szrj
89*38fd1498Szrj static tree
walk_gimple_asm(gasm * stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)90*38fd1498Szrj walk_gimple_asm (gasm *stmt, walk_tree_fn callback_op,
91*38fd1498Szrj struct walk_stmt_info *wi)
92*38fd1498Szrj {
93*38fd1498Szrj tree ret, op;
94*38fd1498Szrj unsigned noutputs;
95*38fd1498Szrj const char **oconstraints;
96*38fd1498Szrj unsigned i, n;
97*38fd1498Szrj const char *constraint;
98*38fd1498Szrj bool allows_mem, allows_reg, is_inout;
99*38fd1498Szrj
100*38fd1498Szrj noutputs = gimple_asm_noutputs (stmt);
101*38fd1498Szrj oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
102*38fd1498Szrj
103*38fd1498Szrj for (i = 0; i < noutputs; i++)
104*38fd1498Szrj {
105*38fd1498Szrj op = gimple_asm_output_op (stmt, i);
106*38fd1498Szrj constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
107*38fd1498Szrj oconstraints[i] = constraint;
108*38fd1498Szrj if (wi)
109*38fd1498Szrj {
110*38fd1498Szrj if (parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
111*38fd1498Szrj &allows_reg, &is_inout))
112*38fd1498Szrj wi->val_only = (allows_reg || !allows_mem);
113*38fd1498Szrj }
114*38fd1498Szrj if (wi)
115*38fd1498Szrj wi->is_lhs = true;
116*38fd1498Szrj ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
117*38fd1498Szrj if (ret)
118*38fd1498Szrj return ret;
119*38fd1498Szrj }
120*38fd1498Szrj
121*38fd1498Szrj n = gimple_asm_ninputs (stmt);
122*38fd1498Szrj for (i = 0; i < n; i++)
123*38fd1498Szrj {
124*38fd1498Szrj op = gimple_asm_input_op (stmt, i);
125*38fd1498Szrj constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
126*38fd1498Szrj
127*38fd1498Szrj if (wi)
128*38fd1498Szrj {
129*38fd1498Szrj if (parse_input_constraint (&constraint, 0, 0, noutputs, 0,
130*38fd1498Szrj oconstraints, &allows_mem, &allows_reg))
131*38fd1498Szrj {
132*38fd1498Szrj wi->val_only = (allows_reg || !allows_mem);
133*38fd1498Szrj /* Although input "m" is not really a LHS, we need a lvalue. */
134*38fd1498Szrj wi->is_lhs = !wi->val_only;
135*38fd1498Szrj }
136*38fd1498Szrj }
137*38fd1498Szrj ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
138*38fd1498Szrj if (ret)
139*38fd1498Szrj return ret;
140*38fd1498Szrj }
141*38fd1498Szrj
142*38fd1498Szrj if (wi)
143*38fd1498Szrj {
144*38fd1498Szrj wi->is_lhs = false;
145*38fd1498Szrj wi->val_only = true;
146*38fd1498Szrj }
147*38fd1498Szrj
148*38fd1498Szrj n = gimple_asm_nlabels (stmt);
149*38fd1498Szrj for (i = 0; i < n; i++)
150*38fd1498Szrj {
151*38fd1498Szrj op = gimple_asm_label_op (stmt, i);
152*38fd1498Szrj ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
153*38fd1498Szrj if (ret)
154*38fd1498Szrj return ret;
155*38fd1498Szrj }
156*38fd1498Szrj
157*38fd1498Szrj return NULL_TREE;
158*38fd1498Szrj }
159*38fd1498Szrj
160*38fd1498Szrj
161*38fd1498Szrj /* Helper function of WALK_GIMPLE_STMT. Walk every tree operand in
162*38fd1498Szrj STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
163*38fd1498Szrj
164*38fd1498Szrj CALLBACK_OP is called on each operand of STMT via walk_tree.
165*38fd1498Szrj Additional parameters to walk_tree must be stored in WI. For each operand
166*38fd1498Szrj OP, walk_tree is called as:
167*38fd1498Szrj
168*38fd1498Szrj walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
169*38fd1498Szrj
170*38fd1498Szrj If CALLBACK_OP returns non-NULL for an operand, the remaining
171*38fd1498Szrj operands are not scanned.
172*38fd1498Szrj
173*38fd1498Szrj The return value is that returned by the last call to walk_tree, or
174*38fd1498Szrj NULL_TREE if no CALLBACK_OP is specified. */
175*38fd1498Szrj
176*38fd1498Szrj tree
walk_gimple_op(gimple * stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)177*38fd1498Szrj walk_gimple_op (gimple *stmt, walk_tree_fn callback_op,
178*38fd1498Szrj struct walk_stmt_info *wi)
179*38fd1498Szrj {
180*38fd1498Szrj hash_set<tree> *pset = (wi) ? wi->pset : NULL;
181*38fd1498Szrj unsigned i;
182*38fd1498Szrj tree ret = NULL_TREE;
183*38fd1498Szrj
184*38fd1498Szrj if (wi)
185*38fd1498Szrj wi->stmt = stmt;
186*38fd1498Szrj
187*38fd1498Szrj switch (gimple_code (stmt))
188*38fd1498Szrj {
189*38fd1498Szrj case GIMPLE_ASSIGN:
190*38fd1498Szrj /* Walk the RHS operands. If the LHS is of a non-renamable type or
191*38fd1498Szrj is a register variable, we may use a COMPONENT_REF on the RHS. */
192*38fd1498Szrj if (wi)
193*38fd1498Szrj {
194*38fd1498Szrj tree lhs = gimple_assign_lhs (stmt);
195*38fd1498Szrj wi->val_only
196*38fd1498Szrj = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
197*38fd1498Szrj || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
198*38fd1498Szrj }
199*38fd1498Szrj
200*38fd1498Szrj for (i = 1; i < gimple_num_ops (stmt); i++)
201*38fd1498Szrj {
202*38fd1498Szrj ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
203*38fd1498Szrj pset);
204*38fd1498Szrj if (ret)
205*38fd1498Szrj return ret;
206*38fd1498Szrj }
207*38fd1498Szrj
208*38fd1498Szrj /* Walk the LHS. If the RHS is appropriate for a memory, we
209*38fd1498Szrj may use a COMPONENT_REF on the LHS. */
210*38fd1498Szrj if (wi)
211*38fd1498Szrj {
212*38fd1498Szrj /* If the RHS is of a non-renamable type or is a register variable,
213*38fd1498Szrj we may use a COMPONENT_REF on the LHS. */
214*38fd1498Szrj tree rhs1 = gimple_assign_rhs1 (stmt);
215*38fd1498Szrj wi->val_only
216*38fd1498Szrj = (is_gimple_reg_type (TREE_TYPE (rhs1)) && !is_gimple_reg (rhs1))
217*38fd1498Szrj || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
218*38fd1498Szrj wi->is_lhs = true;
219*38fd1498Szrj }
220*38fd1498Szrj
221*38fd1498Szrj ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
222*38fd1498Szrj if (ret)
223*38fd1498Szrj return ret;
224*38fd1498Szrj
225*38fd1498Szrj if (wi)
226*38fd1498Szrj {
227*38fd1498Szrj wi->val_only = true;
228*38fd1498Szrj wi->is_lhs = false;
229*38fd1498Szrj }
230*38fd1498Szrj break;
231*38fd1498Szrj
232*38fd1498Szrj case GIMPLE_CALL:
233*38fd1498Szrj if (wi)
234*38fd1498Szrj {
235*38fd1498Szrj wi->is_lhs = false;
236*38fd1498Szrj wi->val_only = true;
237*38fd1498Szrj }
238*38fd1498Szrj
239*38fd1498Szrj ret = walk_tree (gimple_call_chain_ptr (as_a <gcall *> (stmt)),
240*38fd1498Szrj callback_op, wi, pset);
241*38fd1498Szrj if (ret)
242*38fd1498Szrj return ret;
243*38fd1498Szrj
244*38fd1498Szrj ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
245*38fd1498Szrj if (ret)
246*38fd1498Szrj return ret;
247*38fd1498Szrj
248*38fd1498Szrj for (i = 0; i < gimple_call_num_args (stmt); i++)
249*38fd1498Szrj {
250*38fd1498Szrj if (wi)
251*38fd1498Szrj wi->val_only
252*38fd1498Szrj = is_gimple_reg_type (TREE_TYPE (gimple_call_arg (stmt, i)));
253*38fd1498Szrj ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
254*38fd1498Szrj pset);
255*38fd1498Szrj if (ret)
256*38fd1498Szrj return ret;
257*38fd1498Szrj }
258*38fd1498Szrj
259*38fd1498Szrj if (gimple_call_lhs (stmt))
260*38fd1498Szrj {
261*38fd1498Szrj if (wi)
262*38fd1498Szrj {
263*38fd1498Szrj wi->is_lhs = true;
264*38fd1498Szrj wi->val_only
265*38fd1498Szrj = is_gimple_reg_type (TREE_TYPE (gimple_call_lhs (stmt)));
266*38fd1498Szrj }
267*38fd1498Szrj
268*38fd1498Szrj ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
269*38fd1498Szrj if (ret)
270*38fd1498Szrj return ret;
271*38fd1498Szrj }
272*38fd1498Szrj
273*38fd1498Szrj if (wi)
274*38fd1498Szrj {
275*38fd1498Szrj wi->is_lhs = false;
276*38fd1498Szrj wi->val_only = true;
277*38fd1498Szrj }
278*38fd1498Szrj break;
279*38fd1498Szrj
280*38fd1498Szrj case GIMPLE_CATCH:
281*38fd1498Szrj ret = walk_tree (gimple_catch_types_ptr (as_a <gcatch *> (stmt)),
282*38fd1498Szrj callback_op, wi, pset);
283*38fd1498Szrj if (ret)
284*38fd1498Szrj return ret;
285*38fd1498Szrj break;
286*38fd1498Szrj
287*38fd1498Szrj case GIMPLE_EH_FILTER:
288*38fd1498Szrj ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
289*38fd1498Szrj pset);
290*38fd1498Szrj if (ret)
291*38fd1498Szrj return ret;
292*38fd1498Szrj break;
293*38fd1498Szrj
294*38fd1498Szrj case GIMPLE_ASM:
295*38fd1498Szrj ret = walk_gimple_asm (as_a <gasm *> (stmt), callback_op, wi);
296*38fd1498Szrj if (ret)
297*38fd1498Szrj return ret;
298*38fd1498Szrj break;
299*38fd1498Szrj
300*38fd1498Szrj case GIMPLE_OMP_CONTINUE:
301*38fd1498Szrj {
302*38fd1498Szrj gomp_continue *cont_stmt = as_a <gomp_continue *> (stmt);
303*38fd1498Szrj ret = walk_tree (gimple_omp_continue_control_def_ptr (cont_stmt),
304*38fd1498Szrj callback_op, wi, pset);
305*38fd1498Szrj if (ret)
306*38fd1498Szrj return ret;
307*38fd1498Szrj
308*38fd1498Szrj ret = walk_tree (gimple_omp_continue_control_use_ptr (cont_stmt),
309*38fd1498Szrj callback_op, wi, pset);
310*38fd1498Szrj if (ret)
311*38fd1498Szrj return ret;
312*38fd1498Szrj }
313*38fd1498Szrj break;
314*38fd1498Szrj
315*38fd1498Szrj case GIMPLE_OMP_CRITICAL:
316*38fd1498Szrj {
317*38fd1498Szrj gomp_critical *omp_stmt = as_a <gomp_critical *> (stmt);
318*38fd1498Szrj ret = walk_tree (gimple_omp_critical_name_ptr (omp_stmt),
319*38fd1498Szrj callback_op, wi, pset);
320*38fd1498Szrj if (ret)
321*38fd1498Szrj return ret;
322*38fd1498Szrj ret = walk_tree (gimple_omp_critical_clauses_ptr (omp_stmt),
323*38fd1498Szrj callback_op, wi, pset);
324*38fd1498Szrj if (ret)
325*38fd1498Szrj return ret;
326*38fd1498Szrj }
327*38fd1498Szrj break;
328*38fd1498Szrj
329*38fd1498Szrj case GIMPLE_OMP_ORDERED:
330*38fd1498Szrj {
331*38fd1498Szrj gomp_ordered *omp_stmt = as_a <gomp_ordered *> (stmt);
332*38fd1498Szrj ret = walk_tree (gimple_omp_ordered_clauses_ptr (omp_stmt),
333*38fd1498Szrj callback_op, wi, pset);
334*38fd1498Szrj if (ret)
335*38fd1498Szrj return ret;
336*38fd1498Szrj }
337*38fd1498Szrj break;
338*38fd1498Szrj
339*38fd1498Szrj case GIMPLE_OMP_FOR:
340*38fd1498Szrj ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
341*38fd1498Szrj pset);
342*38fd1498Szrj if (ret)
343*38fd1498Szrj return ret;
344*38fd1498Szrj for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
345*38fd1498Szrj {
346*38fd1498Szrj ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
347*38fd1498Szrj wi, pset);
348*38fd1498Szrj if (ret)
349*38fd1498Szrj return ret;
350*38fd1498Szrj ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
351*38fd1498Szrj wi, pset);
352*38fd1498Szrj if (ret)
353*38fd1498Szrj return ret;
354*38fd1498Szrj ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
355*38fd1498Szrj wi, pset);
356*38fd1498Szrj if (ret)
357*38fd1498Szrj return ret;
358*38fd1498Szrj ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
359*38fd1498Szrj wi, pset);
360*38fd1498Szrj if (ret)
361*38fd1498Szrj return ret;
362*38fd1498Szrj }
363*38fd1498Szrj break;
364*38fd1498Szrj
365*38fd1498Szrj case GIMPLE_OMP_PARALLEL:
366*38fd1498Szrj {
367*38fd1498Szrj gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
368*38fd1498Szrj ret = walk_tree (gimple_omp_parallel_clauses_ptr (omp_par_stmt),
369*38fd1498Szrj callback_op, wi, pset);
370*38fd1498Szrj if (ret)
371*38fd1498Szrj return ret;
372*38fd1498Szrj ret = walk_tree (gimple_omp_parallel_child_fn_ptr (omp_par_stmt),
373*38fd1498Szrj callback_op, wi, pset);
374*38fd1498Szrj if (ret)
375*38fd1498Szrj return ret;
376*38fd1498Szrj ret = walk_tree (gimple_omp_parallel_data_arg_ptr (omp_par_stmt),
377*38fd1498Szrj callback_op, wi, pset);
378*38fd1498Szrj if (ret)
379*38fd1498Szrj return ret;
380*38fd1498Szrj }
381*38fd1498Szrj break;
382*38fd1498Szrj
383*38fd1498Szrj case GIMPLE_OMP_TASK:
384*38fd1498Szrj ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
385*38fd1498Szrj wi, pset);
386*38fd1498Szrj if (ret)
387*38fd1498Szrj return ret;
388*38fd1498Szrj ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
389*38fd1498Szrj wi, pset);
390*38fd1498Szrj if (ret)
391*38fd1498Szrj return ret;
392*38fd1498Szrj ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
393*38fd1498Szrj wi, pset);
394*38fd1498Szrj if (ret)
395*38fd1498Szrj return ret;
396*38fd1498Szrj ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
397*38fd1498Szrj wi, pset);
398*38fd1498Szrj if (ret)
399*38fd1498Szrj return ret;
400*38fd1498Szrj ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
401*38fd1498Szrj wi, pset);
402*38fd1498Szrj if (ret)
403*38fd1498Szrj return ret;
404*38fd1498Szrj ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
405*38fd1498Szrj wi, pset);
406*38fd1498Szrj if (ret)
407*38fd1498Szrj return ret;
408*38fd1498Szrj break;
409*38fd1498Szrj
410*38fd1498Szrj case GIMPLE_OMP_SECTIONS:
411*38fd1498Szrj ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
412*38fd1498Szrj wi, pset);
413*38fd1498Szrj if (ret)
414*38fd1498Szrj return ret;
415*38fd1498Szrj ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
416*38fd1498Szrj wi, pset);
417*38fd1498Szrj if (ret)
418*38fd1498Szrj return ret;
419*38fd1498Szrj
420*38fd1498Szrj break;
421*38fd1498Szrj
422*38fd1498Szrj case GIMPLE_OMP_SINGLE:
423*38fd1498Szrj ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
424*38fd1498Szrj pset);
425*38fd1498Szrj if (ret)
426*38fd1498Szrj return ret;
427*38fd1498Szrj break;
428*38fd1498Szrj
429*38fd1498Szrj case GIMPLE_OMP_TARGET:
430*38fd1498Szrj {
431*38fd1498Szrj gomp_target *omp_stmt = as_a <gomp_target *> (stmt);
432*38fd1498Szrj ret = walk_tree (gimple_omp_target_clauses_ptr (omp_stmt),
433*38fd1498Szrj callback_op, wi, pset);
434*38fd1498Szrj if (ret)
435*38fd1498Szrj return ret;
436*38fd1498Szrj ret = walk_tree (gimple_omp_target_child_fn_ptr (omp_stmt),
437*38fd1498Szrj callback_op, wi, pset);
438*38fd1498Szrj if (ret)
439*38fd1498Szrj return ret;
440*38fd1498Szrj ret = walk_tree (gimple_omp_target_data_arg_ptr (omp_stmt),
441*38fd1498Szrj callback_op, wi, pset);
442*38fd1498Szrj if (ret)
443*38fd1498Szrj return ret;
444*38fd1498Szrj }
445*38fd1498Szrj break;
446*38fd1498Szrj
447*38fd1498Szrj case GIMPLE_OMP_TEAMS:
448*38fd1498Szrj ret = walk_tree (gimple_omp_teams_clauses_ptr (stmt), callback_op, wi,
449*38fd1498Szrj pset);
450*38fd1498Szrj if (ret)
451*38fd1498Szrj return ret;
452*38fd1498Szrj break;
453*38fd1498Szrj
454*38fd1498Szrj case GIMPLE_OMP_ATOMIC_LOAD:
455*38fd1498Szrj {
456*38fd1498Szrj gomp_atomic_load *omp_stmt = as_a <gomp_atomic_load *> (stmt);
457*38fd1498Szrj ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (omp_stmt),
458*38fd1498Szrj callback_op, wi, pset);
459*38fd1498Szrj if (ret)
460*38fd1498Szrj return ret;
461*38fd1498Szrj ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (omp_stmt),
462*38fd1498Szrj callback_op, wi, pset);
463*38fd1498Szrj if (ret)
464*38fd1498Szrj return ret;
465*38fd1498Szrj }
466*38fd1498Szrj break;
467*38fd1498Szrj
468*38fd1498Szrj case GIMPLE_OMP_ATOMIC_STORE:
469*38fd1498Szrj {
470*38fd1498Szrj gomp_atomic_store *omp_stmt = as_a <gomp_atomic_store *> (stmt);
471*38fd1498Szrj ret = walk_tree (gimple_omp_atomic_store_val_ptr (omp_stmt),
472*38fd1498Szrj callback_op, wi, pset);
473*38fd1498Szrj if (ret)
474*38fd1498Szrj return ret;
475*38fd1498Szrj }
476*38fd1498Szrj break;
477*38fd1498Szrj
478*38fd1498Szrj case GIMPLE_TRANSACTION:
479*38fd1498Szrj {
480*38fd1498Szrj gtransaction *txn = as_a <gtransaction *> (stmt);
481*38fd1498Szrj
482*38fd1498Szrj ret = walk_tree (gimple_transaction_label_norm_ptr (txn),
483*38fd1498Szrj callback_op, wi, pset);
484*38fd1498Szrj if (ret)
485*38fd1498Szrj return ret;
486*38fd1498Szrj ret = walk_tree (gimple_transaction_label_uninst_ptr (txn),
487*38fd1498Szrj callback_op, wi, pset);
488*38fd1498Szrj if (ret)
489*38fd1498Szrj return ret;
490*38fd1498Szrj ret = walk_tree (gimple_transaction_label_over_ptr (txn),
491*38fd1498Szrj callback_op, wi, pset);
492*38fd1498Szrj if (ret)
493*38fd1498Szrj return ret;
494*38fd1498Szrj }
495*38fd1498Szrj break;
496*38fd1498Szrj
497*38fd1498Szrj case GIMPLE_OMP_RETURN:
498*38fd1498Szrj ret = walk_tree (gimple_omp_return_lhs_ptr (stmt), callback_op, wi,
499*38fd1498Szrj pset);
500*38fd1498Szrj if (ret)
501*38fd1498Szrj return ret;
502*38fd1498Szrj break;
503*38fd1498Szrj
504*38fd1498Szrj /* Tuples that do not have operands. */
505*38fd1498Szrj case GIMPLE_NOP:
506*38fd1498Szrj case GIMPLE_RESX:
507*38fd1498Szrj case GIMPLE_PREDICT:
508*38fd1498Szrj break;
509*38fd1498Szrj
510*38fd1498Szrj default:
511*38fd1498Szrj {
512*38fd1498Szrj enum gimple_statement_structure_enum gss;
513*38fd1498Szrj gss = gimple_statement_structure (stmt);
514*38fd1498Szrj if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
515*38fd1498Szrj for (i = 0; i < gimple_num_ops (stmt); i++)
516*38fd1498Szrj {
517*38fd1498Szrj ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
518*38fd1498Szrj if (ret)
519*38fd1498Szrj return ret;
520*38fd1498Szrj }
521*38fd1498Szrj }
522*38fd1498Szrj break;
523*38fd1498Szrj }
524*38fd1498Szrj
525*38fd1498Szrj return NULL_TREE;
526*38fd1498Szrj }
527*38fd1498Szrj
528*38fd1498Szrj
529*38fd1498Szrj /* Walk the current statement in GSI (optionally using traversal state
530*38fd1498Szrj stored in WI). If WI is NULL, no state is kept during traversal.
531*38fd1498Szrj The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates
532*38fd1498Szrj that it has handled all the operands of the statement, its return
533*38fd1498Szrj value is returned. Otherwise, the return value from CALLBACK_STMT
534*38fd1498Szrj is discarded and its operands are scanned.
535*38fd1498Szrj
536*38fd1498Szrj If CALLBACK_STMT is NULL or it didn't handle the operands,
537*38fd1498Szrj CALLBACK_OP is called on each operand of the statement via
538*38fd1498Szrj walk_gimple_op. If walk_gimple_op returns non-NULL for any
539*38fd1498Szrj operand, the remaining operands are not scanned. In this case, the
540*38fd1498Szrj return value from CALLBACK_OP is returned.
541*38fd1498Szrj
542*38fd1498Szrj In any other case, NULL_TREE is returned. */
543*38fd1498Szrj
544*38fd1498Szrj tree
walk_gimple_stmt(gimple_stmt_iterator * gsi,walk_stmt_fn callback_stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)545*38fd1498Szrj walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
546*38fd1498Szrj walk_tree_fn callback_op, struct walk_stmt_info *wi)
547*38fd1498Szrj {
548*38fd1498Szrj gimple *ret;
549*38fd1498Szrj tree tree_ret;
550*38fd1498Szrj gimple *stmt = gsi_stmt (*gsi);
551*38fd1498Szrj
552*38fd1498Szrj if (wi)
553*38fd1498Szrj {
554*38fd1498Szrj wi->gsi = *gsi;
555*38fd1498Szrj wi->removed_stmt = false;
556*38fd1498Szrj
557*38fd1498Szrj if (wi->want_locations && gimple_has_location (stmt))
558*38fd1498Szrj input_location = gimple_location (stmt);
559*38fd1498Szrj }
560*38fd1498Szrj
561*38fd1498Szrj ret = NULL;
562*38fd1498Szrj
563*38fd1498Szrj /* Invoke the statement callback. Return if the callback handled
564*38fd1498Szrj all of STMT operands by itself. */
565*38fd1498Szrj if (callback_stmt)
566*38fd1498Szrj {
567*38fd1498Szrj bool handled_ops = false;
568*38fd1498Szrj tree_ret = callback_stmt (gsi, &handled_ops, wi);
569*38fd1498Szrj if (handled_ops)
570*38fd1498Szrj return tree_ret;
571*38fd1498Szrj
572*38fd1498Szrj /* If CALLBACK_STMT did not handle operands, it should not have
573*38fd1498Szrj a value to return. */
574*38fd1498Szrj gcc_assert (tree_ret == NULL);
575*38fd1498Szrj
576*38fd1498Szrj if (wi && wi->removed_stmt)
577*38fd1498Szrj return NULL;
578*38fd1498Szrj
579*38fd1498Szrj /* Re-read stmt in case the callback changed it. */
580*38fd1498Szrj stmt = gsi_stmt (*gsi);
581*38fd1498Szrj }
582*38fd1498Szrj
583*38fd1498Szrj /* If CALLBACK_OP is defined, invoke it on every operand of STMT. */
584*38fd1498Szrj if (callback_op)
585*38fd1498Szrj {
586*38fd1498Szrj tree_ret = walk_gimple_op (stmt, callback_op, wi);
587*38fd1498Szrj if (tree_ret)
588*38fd1498Szrj return tree_ret;
589*38fd1498Szrj }
590*38fd1498Szrj
591*38fd1498Szrj /* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them. */
592*38fd1498Szrj switch (gimple_code (stmt))
593*38fd1498Szrj {
594*38fd1498Szrj case GIMPLE_BIND:
595*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_bind_body_ptr (as_a <gbind *> (stmt)),
596*38fd1498Szrj callback_stmt, callback_op, wi);
597*38fd1498Szrj if (ret)
598*38fd1498Szrj return wi->callback_result;
599*38fd1498Szrj break;
600*38fd1498Szrj
601*38fd1498Szrj case GIMPLE_CATCH:
602*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_catch_handler_ptr (
603*38fd1498Szrj as_a <gcatch *> (stmt)),
604*38fd1498Szrj callback_stmt, callback_op, wi);
605*38fd1498Szrj if (ret)
606*38fd1498Szrj return wi->callback_result;
607*38fd1498Szrj break;
608*38fd1498Szrj
609*38fd1498Szrj case GIMPLE_EH_FILTER:
610*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_eh_filter_failure_ptr (stmt), callback_stmt,
611*38fd1498Szrj callback_op, wi);
612*38fd1498Szrj if (ret)
613*38fd1498Szrj return wi->callback_result;
614*38fd1498Szrj break;
615*38fd1498Szrj
616*38fd1498Szrj case GIMPLE_EH_ELSE:
617*38fd1498Szrj {
618*38fd1498Szrj geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
619*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_eh_else_n_body_ptr (eh_else_stmt),
620*38fd1498Szrj callback_stmt, callback_op, wi);
621*38fd1498Szrj if (ret)
622*38fd1498Szrj return wi->callback_result;
623*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_eh_else_e_body_ptr (eh_else_stmt),
624*38fd1498Szrj callback_stmt, callback_op, wi);
625*38fd1498Szrj if (ret)
626*38fd1498Szrj return wi->callback_result;
627*38fd1498Szrj }
628*38fd1498Szrj break;
629*38fd1498Szrj
630*38fd1498Szrj case GIMPLE_TRY:
631*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_try_eval_ptr (stmt), callback_stmt, callback_op,
632*38fd1498Szrj wi);
633*38fd1498Szrj if (ret)
634*38fd1498Szrj return wi->callback_result;
635*38fd1498Szrj
636*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_try_cleanup_ptr (stmt), callback_stmt,
637*38fd1498Szrj callback_op, wi);
638*38fd1498Szrj if (ret)
639*38fd1498Szrj return wi->callback_result;
640*38fd1498Szrj break;
641*38fd1498Szrj
642*38fd1498Szrj case GIMPLE_OMP_FOR:
643*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt), callback_stmt,
644*38fd1498Szrj callback_op, wi);
645*38fd1498Szrj if (ret)
646*38fd1498Szrj return wi->callback_result;
647*38fd1498Szrj
648*38fd1498Szrj /* FALL THROUGH. */
649*38fd1498Szrj case GIMPLE_OMP_CRITICAL:
650*38fd1498Szrj case GIMPLE_OMP_MASTER:
651*38fd1498Szrj case GIMPLE_OMP_TASKGROUP:
652*38fd1498Szrj case GIMPLE_OMP_ORDERED:
653*38fd1498Szrj case GIMPLE_OMP_SECTION:
654*38fd1498Szrj case GIMPLE_OMP_PARALLEL:
655*38fd1498Szrj case GIMPLE_OMP_TASK:
656*38fd1498Szrj case GIMPLE_OMP_SECTIONS:
657*38fd1498Szrj case GIMPLE_OMP_SINGLE:
658*38fd1498Szrj case GIMPLE_OMP_TARGET:
659*38fd1498Szrj case GIMPLE_OMP_TEAMS:
660*38fd1498Szrj case GIMPLE_OMP_GRID_BODY:
661*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), callback_stmt,
662*38fd1498Szrj callback_op, wi);
663*38fd1498Szrj if (ret)
664*38fd1498Szrj return wi->callback_result;
665*38fd1498Szrj break;
666*38fd1498Szrj
667*38fd1498Szrj case GIMPLE_WITH_CLEANUP_EXPR:
668*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_wce_cleanup_ptr (stmt), callback_stmt,
669*38fd1498Szrj callback_op, wi);
670*38fd1498Szrj if (ret)
671*38fd1498Szrj return wi->callback_result;
672*38fd1498Szrj break;
673*38fd1498Szrj
674*38fd1498Szrj case GIMPLE_TRANSACTION:
675*38fd1498Szrj ret = walk_gimple_seq_mod (gimple_transaction_body_ptr (
676*38fd1498Szrj as_a <gtransaction *> (stmt)),
677*38fd1498Szrj callback_stmt, callback_op, wi);
678*38fd1498Szrj if (ret)
679*38fd1498Szrj return wi->callback_result;
680*38fd1498Szrj break;
681*38fd1498Szrj
682*38fd1498Szrj default:
683*38fd1498Szrj gcc_assert (!gimple_has_substatements (stmt));
684*38fd1498Szrj break;
685*38fd1498Szrj }
686*38fd1498Szrj
687*38fd1498Szrj return NULL;
688*38fd1498Szrj }
689*38fd1498Szrj
690*38fd1498Szrj /* From a tree operand OP return the base of a load or store operation
691*38fd1498Szrj or NULL_TREE if OP is not a load or a store. */
692*38fd1498Szrj
693*38fd1498Szrj static tree
get_base_loadstore(tree op)694*38fd1498Szrj get_base_loadstore (tree op)
695*38fd1498Szrj {
696*38fd1498Szrj while (handled_component_p (op))
697*38fd1498Szrj op = TREE_OPERAND (op, 0);
698*38fd1498Szrj if (DECL_P (op)
699*38fd1498Szrj || INDIRECT_REF_P (op)
700*38fd1498Szrj || TREE_CODE (op) == MEM_REF
701*38fd1498Szrj || TREE_CODE (op) == TARGET_MEM_REF)
702*38fd1498Szrj return op;
703*38fd1498Szrj return NULL_TREE;
704*38fd1498Szrj }
705*38fd1498Szrj
706*38fd1498Szrj
707*38fd1498Szrj /* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
708*38fd1498Szrj VISIT_ADDR if non-NULL on loads, store and address-taken operands
709*38fd1498Szrj passing the STMT, the base of the operand, the operand itself containing
710*38fd1498Szrj the base and DATA to it. The base will be either a decl, an indirect
711*38fd1498Szrj reference (including TARGET_MEM_REF) or the argument of an address
712*38fd1498Szrj expression.
713*38fd1498Szrj Returns the results of these callbacks or'ed. */
714*38fd1498Szrj
715*38fd1498Szrj bool
walk_stmt_load_store_addr_ops(gimple * stmt,void * data,walk_stmt_load_store_addr_fn visit_load,walk_stmt_load_store_addr_fn visit_store,walk_stmt_load_store_addr_fn visit_addr)716*38fd1498Szrj walk_stmt_load_store_addr_ops (gimple *stmt, void *data,
717*38fd1498Szrj walk_stmt_load_store_addr_fn visit_load,
718*38fd1498Szrj walk_stmt_load_store_addr_fn visit_store,
719*38fd1498Szrj walk_stmt_load_store_addr_fn visit_addr)
720*38fd1498Szrj {
721*38fd1498Szrj bool ret = false;
722*38fd1498Szrj unsigned i;
723*38fd1498Szrj if (gimple_assign_single_p (stmt))
724*38fd1498Szrj {
725*38fd1498Szrj tree lhs, rhs, arg;
726*38fd1498Szrj if (visit_store)
727*38fd1498Szrj {
728*38fd1498Szrj arg = gimple_assign_lhs (stmt);
729*38fd1498Szrj lhs = get_base_loadstore (arg);
730*38fd1498Szrj if (lhs)
731*38fd1498Szrj ret |= visit_store (stmt, lhs, arg, data);
732*38fd1498Szrj }
733*38fd1498Szrj arg = gimple_assign_rhs1 (stmt);
734*38fd1498Szrj rhs = arg;
735*38fd1498Szrj while (handled_component_p (rhs))
736*38fd1498Szrj rhs = TREE_OPERAND (rhs, 0);
737*38fd1498Szrj if (visit_addr)
738*38fd1498Szrj {
739*38fd1498Szrj if (TREE_CODE (rhs) == ADDR_EXPR)
740*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), arg, data);
741*38fd1498Szrj else if (TREE_CODE (rhs) == TARGET_MEM_REF
742*38fd1498Szrj && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
743*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), arg,
744*38fd1498Szrj data);
745*38fd1498Szrj else if (TREE_CODE (rhs) == OBJ_TYPE_REF
746*38fd1498Szrj && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
747*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
748*38fd1498Szrj 0), arg, data);
749*38fd1498Szrj else if (TREE_CODE (rhs) == CONSTRUCTOR)
750*38fd1498Szrj {
751*38fd1498Szrj unsigned int ix;
752*38fd1498Szrj tree val;
753*38fd1498Szrj
754*38fd1498Szrj FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), ix, val)
755*38fd1498Szrj if (TREE_CODE (val) == ADDR_EXPR)
756*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (val, 0), arg, data);
757*38fd1498Szrj else if (TREE_CODE (val) == OBJ_TYPE_REF
758*38fd1498Szrj && TREE_CODE (OBJ_TYPE_REF_OBJECT (val)) == ADDR_EXPR)
759*38fd1498Szrj ret |= visit_addr (stmt,
760*38fd1498Szrj TREE_OPERAND (OBJ_TYPE_REF_OBJECT (val),
761*38fd1498Szrj 0), arg, data);
762*38fd1498Szrj }
763*38fd1498Szrj lhs = gimple_assign_lhs (stmt);
764*38fd1498Szrj if (TREE_CODE (lhs) == TARGET_MEM_REF
765*38fd1498Szrj && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
766*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), lhs, data);
767*38fd1498Szrj }
768*38fd1498Szrj if (visit_load)
769*38fd1498Szrj {
770*38fd1498Szrj rhs = get_base_loadstore (rhs);
771*38fd1498Szrj if (rhs)
772*38fd1498Szrj ret |= visit_load (stmt, rhs, arg, data);
773*38fd1498Szrj }
774*38fd1498Szrj }
775*38fd1498Szrj else if (visit_addr
776*38fd1498Szrj && (is_gimple_assign (stmt)
777*38fd1498Szrj || gimple_code (stmt) == GIMPLE_COND))
778*38fd1498Szrj {
779*38fd1498Szrj for (i = 0; i < gimple_num_ops (stmt); ++i)
780*38fd1498Szrj {
781*38fd1498Szrj tree op = gimple_op (stmt, i);
782*38fd1498Szrj if (op == NULL_TREE)
783*38fd1498Szrj ;
784*38fd1498Szrj else if (TREE_CODE (op) == ADDR_EXPR)
785*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
786*38fd1498Szrj /* COND_EXPR and VCOND_EXPR rhs1 argument is a comparison
787*38fd1498Szrj tree with two operands. */
788*38fd1498Szrj else if (i == 1 && COMPARISON_CLASS_P (op))
789*38fd1498Szrj {
790*38fd1498Szrj if (TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
791*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 0),
792*38fd1498Szrj 0), op, data);
793*38fd1498Szrj if (TREE_CODE (TREE_OPERAND (op, 1)) == ADDR_EXPR)
794*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 1),
795*38fd1498Szrj 0), op, data);
796*38fd1498Szrj }
797*38fd1498Szrj }
798*38fd1498Szrj }
799*38fd1498Szrj else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
800*38fd1498Szrj {
801*38fd1498Szrj if (visit_store)
802*38fd1498Szrj {
803*38fd1498Szrj tree arg = gimple_call_lhs (call_stmt);
804*38fd1498Szrj if (arg)
805*38fd1498Szrj {
806*38fd1498Szrj tree lhs = get_base_loadstore (arg);
807*38fd1498Szrj if (lhs)
808*38fd1498Szrj ret |= visit_store (stmt, lhs, arg, data);
809*38fd1498Szrj }
810*38fd1498Szrj }
811*38fd1498Szrj if (visit_load || visit_addr)
812*38fd1498Szrj for (i = 0; i < gimple_call_num_args (call_stmt); ++i)
813*38fd1498Szrj {
814*38fd1498Szrj tree arg = gimple_call_arg (call_stmt, i);
815*38fd1498Szrj if (visit_addr
816*38fd1498Szrj && TREE_CODE (arg) == ADDR_EXPR)
817*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (arg, 0), arg, data);
818*38fd1498Szrj else if (visit_load)
819*38fd1498Szrj {
820*38fd1498Szrj tree rhs = get_base_loadstore (arg);
821*38fd1498Szrj if (rhs)
822*38fd1498Szrj ret |= visit_load (stmt, rhs, arg, data);
823*38fd1498Szrj }
824*38fd1498Szrj }
825*38fd1498Szrj if (visit_addr
826*38fd1498Szrj && gimple_call_chain (call_stmt)
827*38fd1498Szrj && TREE_CODE (gimple_call_chain (call_stmt)) == ADDR_EXPR)
828*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (call_stmt), 0),
829*38fd1498Szrj gimple_call_chain (call_stmt), data);
830*38fd1498Szrj if (visit_addr
831*38fd1498Szrj && gimple_call_return_slot_opt_p (call_stmt)
832*38fd1498Szrj && gimple_call_lhs (call_stmt) != NULL_TREE
833*38fd1498Szrj && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (call_stmt))))
834*38fd1498Szrj ret |= visit_addr (stmt, gimple_call_lhs (call_stmt),
835*38fd1498Szrj gimple_call_lhs (call_stmt), data);
836*38fd1498Szrj }
837*38fd1498Szrj else if (gasm *asm_stmt = dyn_cast <gasm *> (stmt))
838*38fd1498Szrj {
839*38fd1498Szrj unsigned noutputs;
840*38fd1498Szrj const char *constraint;
841*38fd1498Szrj const char **oconstraints;
842*38fd1498Szrj bool allows_mem, allows_reg, is_inout;
843*38fd1498Szrj noutputs = gimple_asm_noutputs (asm_stmt);
844*38fd1498Szrj oconstraints = XALLOCAVEC (const char *, noutputs);
845*38fd1498Szrj if (visit_store || visit_addr)
846*38fd1498Szrj for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
847*38fd1498Szrj {
848*38fd1498Szrj tree link = gimple_asm_output_op (asm_stmt, i);
849*38fd1498Szrj tree op = get_base_loadstore (TREE_VALUE (link));
850*38fd1498Szrj if (op && visit_store)
851*38fd1498Szrj ret |= visit_store (stmt, op, TREE_VALUE (link), data);
852*38fd1498Szrj if (visit_addr)
853*38fd1498Szrj {
854*38fd1498Szrj constraint = TREE_STRING_POINTER
855*38fd1498Szrj (TREE_VALUE (TREE_PURPOSE (link)));
856*38fd1498Szrj oconstraints[i] = constraint;
857*38fd1498Szrj parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
858*38fd1498Szrj &allows_reg, &is_inout);
859*38fd1498Szrj if (op && !allows_reg && allows_mem)
860*38fd1498Szrj ret |= visit_addr (stmt, op, TREE_VALUE (link), data);
861*38fd1498Szrj }
862*38fd1498Szrj }
863*38fd1498Szrj if (visit_load || visit_addr)
864*38fd1498Szrj for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
865*38fd1498Szrj {
866*38fd1498Szrj tree link = gimple_asm_input_op (asm_stmt, i);
867*38fd1498Szrj tree op = TREE_VALUE (link);
868*38fd1498Szrj if (visit_addr
869*38fd1498Szrj && TREE_CODE (op) == ADDR_EXPR)
870*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
871*38fd1498Szrj else if (visit_load || visit_addr)
872*38fd1498Szrj {
873*38fd1498Szrj op = get_base_loadstore (op);
874*38fd1498Szrj if (op)
875*38fd1498Szrj {
876*38fd1498Szrj if (visit_load)
877*38fd1498Szrj ret |= visit_load (stmt, op, TREE_VALUE (link), data);
878*38fd1498Szrj if (visit_addr)
879*38fd1498Szrj {
880*38fd1498Szrj constraint = TREE_STRING_POINTER
881*38fd1498Szrj (TREE_VALUE (TREE_PURPOSE (link)));
882*38fd1498Szrj parse_input_constraint (&constraint, 0, 0, noutputs,
883*38fd1498Szrj 0, oconstraints,
884*38fd1498Szrj &allows_mem, &allows_reg);
885*38fd1498Szrj if (!allows_reg && allows_mem)
886*38fd1498Szrj ret |= visit_addr (stmt, op, TREE_VALUE (link),
887*38fd1498Szrj data);
888*38fd1498Szrj }
889*38fd1498Szrj }
890*38fd1498Szrj }
891*38fd1498Szrj }
892*38fd1498Szrj }
893*38fd1498Szrj else if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
894*38fd1498Szrj {
895*38fd1498Szrj tree op = gimple_return_retval (return_stmt);
896*38fd1498Szrj if (op)
897*38fd1498Szrj {
898*38fd1498Szrj if (visit_addr
899*38fd1498Szrj && TREE_CODE (op) == ADDR_EXPR)
900*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
901*38fd1498Szrj else if (visit_load)
902*38fd1498Szrj {
903*38fd1498Szrj tree base = get_base_loadstore (op);
904*38fd1498Szrj if (base)
905*38fd1498Szrj ret |= visit_load (stmt, base, op, data);
906*38fd1498Szrj }
907*38fd1498Szrj }
908*38fd1498Szrj }
909*38fd1498Szrj else if (visit_addr
910*38fd1498Szrj && gimple_code (stmt) == GIMPLE_PHI)
911*38fd1498Szrj {
912*38fd1498Szrj for (i = 0; i < gimple_phi_num_args (stmt); ++i)
913*38fd1498Szrj {
914*38fd1498Szrj tree op = gimple_phi_arg_def (stmt, i);
915*38fd1498Szrj if (TREE_CODE (op) == ADDR_EXPR)
916*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
917*38fd1498Szrj }
918*38fd1498Szrj }
919*38fd1498Szrj else if (visit_addr
920*38fd1498Szrj && gimple_code (stmt) == GIMPLE_GOTO)
921*38fd1498Szrj {
922*38fd1498Szrj tree op = gimple_goto_dest (stmt);
923*38fd1498Szrj if (TREE_CODE (op) == ADDR_EXPR)
924*38fd1498Szrj ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
925*38fd1498Szrj }
926*38fd1498Szrj
927*38fd1498Szrj return ret;
928*38fd1498Szrj }
929*38fd1498Szrj
930*38fd1498Szrj /* Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP
931*38fd1498Szrj should make a faster clone for this case. */
932*38fd1498Szrj
933*38fd1498Szrj bool
walk_stmt_load_store_ops(gimple * stmt,void * data,walk_stmt_load_store_addr_fn visit_load,walk_stmt_load_store_addr_fn visit_store)934*38fd1498Szrj walk_stmt_load_store_ops (gimple *stmt, void *data,
935*38fd1498Szrj walk_stmt_load_store_addr_fn visit_load,
936*38fd1498Szrj walk_stmt_load_store_addr_fn visit_store)
937*38fd1498Szrj {
938*38fd1498Szrj return walk_stmt_load_store_addr_ops (stmt, data,
939*38fd1498Szrj visit_load, visit_store, NULL);
940*38fd1498Szrj }
941