PR rtl-optimization/57003
[official-gcc.git] / gcc / gimple-walk.c
blobf4f67572c81b2bb7d54b2cc61aea605f28dc6600
1 /* Gimple walk support.
3 Copyright (C) 2007-2014 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "stmt.h"
28 #include "basic-block.h"
29 #include "tree-ssa-alias.h"
30 #include "internal-fn.h"
31 #include "gimple-expr.h"
32 #include "is-a.h"
33 #include "gimple.h"
34 #include "gimple-iterator.h"
35 #include "gimple-walk.h"
36 #include "gimple-walk.h"
37 #include "demangle.h"
39 /* Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt
40 on each one. WI is as in walk_gimple_stmt.
42 If walk_gimple_stmt returns non-NULL, the walk is stopped, and the
43 value is stored in WI->CALLBACK_RESULT. Also, the statement that
44 produced the value is returned if this statement has not been
45 removed by a callback (wi->removed_stmt). If the statement has
46 been removed, NULL is returned.
48 Otherwise, all the statements are walked and NULL returned. */
50 gimple
51 walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
52 walk_tree_fn callback_op, struct walk_stmt_info *wi)
54 gimple_stmt_iterator gsi;
56 for (gsi = gsi_start (*pseq); !gsi_end_p (gsi); )
58 tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
59 if (ret)
61 /* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
62 to hold it. */
63 gcc_assert (wi);
64 wi->callback_result = ret;
66 return wi->removed_stmt ? NULL : gsi_stmt (gsi);
69 if (!wi->removed_stmt)
70 gsi_next (&gsi);
73 if (wi)
74 wi->callback_result = NULL_TREE;
76 return NULL;
80 /* Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't
81 changed by the callbacks. */
83 gimple
84 walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
85 walk_tree_fn callback_op, struct walk_stmt_info *wi)
87 gimple_seq seq2 = seq;
88 gimple ret = walk_gimple_seq_mod (&seq2, callback_stmt, callback_op, wi);
89 gcc_assert (seq2 == seq);
90 return ret;
94 /* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
96 static tree
97 walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
98 struct walk_stmt_info *wi)
100 tree ret, op;
101 unsigned noutputs;
102 const char **oconstraints;
103 unsigned i, n;
104 const char *constraint;
105 bool allows_mem, allows_reg, is_inout;
107 noutputs = gimple_asm_noutputs (stmt);
108 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
110 if (wi)
111 wi->is_lhs = true;
113 for (i = 0; i < noutputs; i++)
115 op = gimple_asm_output_op (stmt, i);
116 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
117 oconstraints[i] = constraint;
118 parse_output_constraint (&constraint, i, 0, 0, &allows_mem, &allows_reg,
119 &is_inout);
120 if (wi)
121 wi->val_only = (allows_reg || !allows_mem);
122 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
123 if (ret)
124 return ret;
127 n = gimple_asm_ninputs (stmt);
128 for (i = 0; i < n; i++)
130 op = gimple_asm_input_op (stmt, i);
131 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
132 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
133 oconstraints, &allows_mem, &allows_reg);
134 if (wi)
136 wi->val_only = (allows_reg || !allows_mem);
137 /* Although input "m" is not really a LHS, we need a lvalue. */
138 wi->is_lhs = !wi->val_only;
140 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
141 if (ret)
142 return ret;
145 if (wi)
147 wi->is_lhs = false;
148 wi->val_only = true;
151 n = gimple_asm_nlabels (stmt);
152 for (i = 0; i < n; i++)
154 op = gimple_asm_label_op (stmt, i);
155 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
156 if (ret)
157 return ret;
160 return NULL_TREE;
164 /* Helper function of WALK_GIMPLE_STMT. Walk every tree operand in
165 STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
167 CALLBACK_OP is called on each operand of STMT via walk_tree.
168 Additional parameters to walk_tree must be stored in WI. For each operand
169 OP, walk_tree is called as:
171 walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
173 If CALLBACK_OP returns non-NULL for an operand, the remaining
174 operands are not scanned.
176 The return value is that returned by the last call to walk_tree, or
177 NULL_TREE if no CALLBACK_OP is specified. */
179 tree
180 walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
181 struct walk_stmt_info *wi)
183 hash_set<tree> *pset = (wi) ? wi->pset : NULL;
184 unsigned i;
185 tree ret = NULL_TREE;
187 switch (gimple_code (stmt))
189 case GIMPLE_ASSIGN:
190 /* Walk the RHS operands. If the LHS is of a non-renamable type or
191 is a register variable, we may use a COMPONENT_REF on the RHS. */
192 if (wi)
194 tree lhs = gimple_assign_lhs (stmt);
195 wi->val_only
196 = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
197 || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
200 for (i = 1; i < gimple_num_ops (stmt); i++)
202 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
203 pset);
204 if (ret)
205 return ret;
208 /* Walk the LHS. If the RHS is appropriate for a memory, we
209 may use a COMPONENT_REF on the LHS. */
210 if (wi)
212 /* If the RHS is of a non-renamable type or is a register variable,
213 we may use a COMPONENT_REF on the LHS. */
214 tree rhs1 = gimple_assign_rhs1 (stmt);
215 wi->val_only
216 = (is_gimple_reg_type (TREE_TYPE (rhs1)) && !is_gimple_reg (rhs1))
217 || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
218 wi->is_lhs = true;
221 ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
222 if (ret)
223 return ret;
225 if (wi)
227 wi->val_only = true;
228 wi->is_lhs = false;
230 break;
232 case GIMPLE_CALL:
233 if (wi)
235 wi->is_lhs = false;
236 wi->val_only = true;
239 ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
240 if (ret)
241 return ret;
243 ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
244 if (ret)
245 return ret;
247 for (i = 0; i < gimple_call_num_args (stmt); i++)
249 if (wi)
250 wi->val_only
251 = is_gimple_reg_type (TREE_TYPE (gimple_call_arg (stmt, i)));
252 ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
253 pset);
254 if (ret)
255 return ret;
258 if (gimple_call_lhs (stmt))
260 if (wi)
262 wi->is_lhs = true;
263 wi->val_only
264 = is_gimple_reg_type (TREE_TYPE (gimple_call_lhs (stmt)));
267 ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
268 if (ret)
269 return ret;
272 if (wi)
274 wi->is_lhs = false;
275 wi->val_only = true;
277 break;
279 case GIMPLE_CATCH:
280 ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
281 pset);
282 if (ret)
283 return ret;
284 break;
286 case GIMPLE_EH_FILTER:
287 ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
288 pset);
289 if (ret)
290 return ret;
291 break;
293 case GIMPLE_ASM:
294 ret = walk_gimple_asm (stmt, callback_op, wi);
295 if (ret)
296 return ret;
297 break;
299 case GIMPLE_OMP_CONTINUE:
300 ret = walk_tree (gimple_omp_continue_control_def_ptr (stmt),
301 callback_op, wi, pset);
302 if (ret)
303 return ret;
305 ret = walk_tree (gimple_omp_continue_control_use_ptr (stmt),
306 callback_op, wi, pset);
307 if (ret)
308 return ret;
309 break;
311 case GIMPLE_OMP_CRITICAL:
312 ret = walk_tree (gimple_omp_critical_name_ptr (stmt), callback_op, wi,
313 pset);
314 if (ret)
315 return ret;
316 break;
318 case GIMPLE_OMP_FOR:
319 ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
320 pset);
321 if (ret)
322 return ret;
323 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
325 ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
326 wi, pset);
327 if (ret)
328 return ret;
329 ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
330 wi, pset);
331 if (ret)
332 return ret;
333 ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
334 wi, pset);
335 if (ret)
336 return ret;
337 ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
338 wi, pset);
340 if (ret)
341 return ret;
342 break;
344 case GIMPLE_OMP_PARALLEL:
345 ret = walk_tree (gimple_omp_parallel_clauses_ptr (stmt), callback_op,
346 wi, pset);
347 if (ret)
348 return ret;
349 ret = walk_tree (gimple_omp_parallel_child_fn_ptr (stmt), callback_op,
350 wi, pset);
351 if (ret)
352 return ret;
353 ret = walk_tree (gimple_omp_parallel_data_arg_ptr (stmt), callback_op,
354 wi, pset);
355 if (ret)
356 return ret;
357 break;
359 case GIMPLE_OMP_TASK:
360 ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
361 wi, pset);
362 if (ret)
363 return ret;
364 ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
365 wi, pset);
366 if (ret)
367 return ret;
368 ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
369 wi, pset);
370 if (ret)
371 return ret;
372 ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
373 wi, pset);
374 if (ret)
375 return ret;
376 ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
377 wi, pset);
378 if (ret)
379 return ret;
380 ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
381 wi, pset);
382 if (ret)
383 return ret;
384 break;
386 case GIMPLE_OMP_SECTIONS:
387 ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
388 wi, pset);
389 if (ret)
390 return ret;
392 ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
393 wi, pset);
394 if (ret)
395 return ret;
397 break;
399 case GIMPLE_OMP_SINGLE:
400 ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
401 pset);
402 if (ret)
403 return ret;
404 break;
406 case GIMPLE_OMP_TARGET:
407 ret = walk_tree (gimple_omp_target_clauses_ptr (stmt), callback_op, wi,
408 pset);
409 if (ret)
410 return ret;
411 break;
413 case GIMPLE_OMP_TEAMS:
414 ret = walk_tree (gimple_omp_teams_clauses_ptr (stmt), callback_op, wi,
415 pset);
416 if (ret)
417 return ret;
418 break;
420 case GIMPLE_OMP_ATOMIC_LOAD:
421 ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi,
422 pset);
423 if (ret)
424 return ret;
426 ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi,
427 pset);
428 if (ret)
429 return ret;
430 break;
432 case GIMPLE_OMP_ATOMIC_STORE:
433 ret = walk_tree (gimple_omp_atomic_store_val_ptr (stmt), callback_op,
434 wi, pset);
435 if (ret)
436 return ret;
437 break;
439 case GIMPLE_TRANSACTION:
440 ret = walk_tree (gimple_transaction_label_ptr (stmt), callback_op,
441 wi, pset);
442 if (ret)
443 return ret;
444 break;
446 case GIMPLE_OMP_RETURN:
447 ret = walk_tree (gimple_omp_return_lhs_ptr (stmt), callback_op, wi,
448 pset);
449 if (ret)
450 return ret;
451 break;
453 /* Tuples that do not have operands. */
454 case GIMPLE_NOP:
455 case GIMPLE_RESX:
456 case GIMPLE_PREDICT:
457 break;
459 default:
461 enum gimple_statement_structure_enum gss;
462 gss = gimple_statement_structure (stmt);
463 if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
464 for (i = 0; i < gimple_num_ops (stmt); i++)
466 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
467 if (ret)
468 return ret;
471 break;
474 return NULL_TREE;
478 /* Walk the current statement in GSI (optionally using traversal state
479 stored in WI). If WI is NULL, no state is kept during traversal.
480 The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates
481 that it has handled all the operands of the statement, its return
482 value is returned. Otherwise, the return value from CALLBACK_STMT
483 is discarded and its operands are scanned.
485 If CALLBACK_STMT is NULL or it didn't handle the operands,
486 CALLBACK_OP is called on each operand of the statement via
487 walk_gimple_op. If walk_gimple_op returns non-NULL for any
488 operand, the remaining operands are not scanned. In this case, the
489 return value from CALLBACK_OP is returned.
491 In any other case, NULL_TREE is returned. */
493 tree
494 walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
495 walk_tree_fn callback_op, struct walk_stmt_info *wi)
497 gimple ret;
498 tree tree_ret;
499 gimple stmt = gsi_stmt (*gsi);
501 if (wi)
503 wi->gsi = *gsi;
504 wi->removed_stmt = false;
506 if (wi->want_locations && gimple_has_location (stmt))
507 input_location = gimple_location (stmt);
510 ret = NULL;
512 /* Invoke the statement callback. Return if the callback handled
513 all of STMT operands by itself. */
514 if (callback_stmt)
516 bool handled_ops = false;
517 tree_ret = callback_stmt (gsi, &handled_ops, wi);
518 if (handled_ops)
519 return tree_ret;
521 /* If CALLBACK_STMT did not handle operands, it should not have
522 a value to return. */
523 gcc_assert (tree_ret == NULL);
525 if (wi && wi->removed_stmt)
526 return NULL;
528 /* Re-read stmt in case the callback changed it. */
529 stmt = gsi_stmt (*gsi);
532 /* If CALLBACK_OP is defined, invoke it on every operand of STMT. */
533 if (callback_op)
535 tree_ret = walk_gimple_op (stmt, callback_op, wi);
536 if (tree_ret)
537 return tree_ret;
540 /* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them. */
541 switch (gimple_code (stmt))
543 case GIMPLE_BIND:
544 ret = walk_gimple_seq_mod (gimple_bind_body_ptr (stmt), callback_stmt,
545 callback_op, wi);
546 if (ret)
547 return wi->callback_result;
548 break;
550 case GIMPLE_CATCH:
551 ret = walk_gimple_seq_mod (gimple_catch_handler_ptr (stmt), callback_stmt,
552 callback_op, wi);
553 if (ret)
554 return wi->callback_result;
555 break;
557 case GIMPLE_EH_FILTER:
558 ret = walk_gimple_seq_mod (gimple_eh_filter_failure_ptr (stmt), callback_stmt,
559 callback_op, wi);
560 if (ret)
561 return wi->callback_result;
562 break;
564 case GIMPLE_EH_ELSE:
565 ret = walk_gimple_seq_mod (gimple_eh_else_n_body_ptr (stmt),
566 callback_stmt, callback_op, wi);
567 if (ret)
568 return wi->callback_result;
569 ret = walk_gimple_seq_mod (gimple_eh_else_e_body_ptr (stmt),
570 callback_stmt, callback_op, wi);
571 if (ret)
572 return wi->callback_result;
573 break;
575 case GIMPLE_TRY:
576 ret = walk_gimple_seq_mod (gimple_try_eval_ptr (stmt), callback_stmt, callback_op,
577 wi);
578 if (ret)
579 return wi->callback_result;
581 ret = walk_gimple_seq_mod (gimple_try_cleanup_ptr (stmt), callback_stmt,
582 callback_op, wi);
583 if (ret)
584 return wi->callback_result;
585 break;
587 case GIMPLE_OMP_FOR:
588 ret = walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt), callback_stmt,
589 callback_op, wi);
590 if (ret)
591 return wi->callback_result;
593 /* FALL THROUGH. */
594 case GIMPLE_OMP_CRITICAL:
595 case GIMPLE_OMP_MASTER:
596 case GIMPLE_OMP_TASKGROUP:
597 case GIMPLE_OMP_ORDERED:
598 case GIMPLE_OMP_SECTION:
599 case GIMPLE_OMP_PARALLEL:
600 case GIMPLE_OMP_TASK:
601 case GIMPLE_OMP_SECTIONS:
602 case GIMPLE_OMP_SINGLE:
603 case GIMPLE_OMP_TARGET:
604 case GIMPLE_OMP_TEAMS:
605 ret = walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), callback_stmt,
606 callback_op, wi);
607 if (ret)
608 return wi->callback_result;
609 break;
611 case GIMPLE_WITH_CLEANUP_EXPR:
612 ret = walk_gimple_seq_mod (gimple_wce_cleanup_ptr (stmt), callback_stmt,
613 callback_op, wi);
614 if (ret)
615 return wi->callback_result;
616 break;
618 case GIMPLE_TRANSACTION:
619 ret = walk_gimple_seq_mod (gimple_transaction_body_ptr (stmt),
620 callback_stmt, callback_op, wi);
621 if (ret)
622 return wi->callback_result;
623 break;
625 default:
626 gcc_assert (!gimple_has_substatements (stmt));
627 break;
630 return NULL;
633 /* From a tree operand OP return the base of a load or store operation
634 or NULL_TREE if OP is not a load or a store. */
636 static tree
637 get_base_loadstore (tree op)
639 while (handled_component_p (op))
640 op = TREE_OPERAND (op, 0);
641 if (DECL_P (op)
642 || INDIRECT_REF_P (op)
643 || TREE_CODE (op) == MEM_REF
644 || TREE_CODE (op) == TARGET_MEM_REF)
645 return op;
646 return NULL_TREE;
650 /* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
651 VISIT_ADDR if non-NULL on loads, store and address-taken operands
652 passing the STMT, the base of the operand, the operand itself containing
653 the base and DATA to it. The base will be either a decl, an indirect
654 reference (including TARGET_MEM_REF) or the argument of an address
655 expression.
656 Returns the results of these callbacks or'ed. */
658 bool
659 walk_stmt_load_store_addr_ops (gimple stmt, void *data,
660 walk_stmt_load_store_addr_fn visit_load,
661 walk_stmt_load_store_addr_fn visit_store,
662 walk_stmt_load_store_addr_fn visit_addr)
664 bool ret = false;
665 unsigned i;
666 if (gimple_assign_single_p (stmt))
668 tree lhs, rhs, arg;
669 if (visit_store)
671 arg = gimple_assign_lhs (stmt);
672 lhs = get_base_loadstore (arg);
673 if (lhs)
674 ret |= visit_store (stmt, lhs, arg, data);
676 arg = gimple_assign_rhs1 (stmt);
677 rhs = arg;
678 while (handled_component_p (rhs))
679 rhs = TREE_OPERAND (rhs, 0);
680 if (visit_addr)
682 if (TREE_CODE (rhs) == ADDR_EXPR)
683 ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), arg, data);
684 else if (TREE_CODE (rhs) == TARGET_MEM_REF
685 && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
686 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), arg,
687 data);
688 else if (TREE_CODE (rhs) == OBJ_TYPE_REF
689 && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
690 ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
691 0), arg, data);
692 else if (TREE_CODE (rhs) == CONSTRUCTOR)
694 unsigned int ix;
695 tree val;
697 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), ix, val)
698 if (TREE_CODE (val) == ADDR_EXPR)
699 ret |= visit_addr (stmt, TREE_OPERAND (val, 0), arg, data);
700 else if (TREE_CODE (val) == OBJ_TYPE_REF
701 && TREE_CODE (OBJ_TYPE_REF_OBJECT (val)) == ADDR_EXPR)
702 ret |= visit_addr (stmt,
703 TREE_OPERAND (OBJ_TYPE_REF_OBJECT (val),
704 0), arg, data);
706 lhs = gimple_assign_lhs (stmt);
707 if (TREE_CODE (lhs) == TARGET_MEM_REF
708 && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
709 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), lhs, data);
711 if (visit_load)
713 rhs = get_base_loadstore (rhs);
714 if (rhs)
715 ret |= visit_load (stmt, rhs, arg, data);
718 else if (visit_addr
719 && (is_gimple_assign (stmt)
720 || gimple_code (stmt) == GIMPLE_COND))
722 for (i = 0; i < gimple_num_ops (stmt); ++i)
724 tree op = gimple_op (stmt, i);
725 if (op == NULL_TREE)
727 else if (TREE_CODE (op) == ADDR_EXPR)
728 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
729 /* COND_EXPR and VCOND_EXPR rhs1 argument is a comparison
730 tree with two operands. */
731 else if (i == 1 && COMPARISON_CLASS_P (op))
733 if (TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
734 ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 0),
735 0), op, data);
736 if (TREE_CODE (TREE_OPERAND (op, 1)) == ADDR_EXPR)
737 ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 1),
738 0), op, data);
742 else if (is_gimple_call (stmt))
744 if (visit_store)
746 tree arg = gimple_call_lhs (stmt);
747 if (arg)
749 tree lhs = get_base_loadstore (arg);
750 if (lhs)
751 ret |= visit_store (stmt, lhs, arg, data);
754 if (visit_load || visit_addr)
755 for (i = 0; i < gimple_call_num_args (stmt); ++i)
757 tree arg = gimple_call_arg (stmt, i);
758 if (visit_addr
759 && TREE_CODE (arg) == ADDR_EXPR)
760 ret |= visit_addr (stmt, TREE_OPERAND (arg, 0), arg, data);
761 else if (visit_load)
763 tree rhs = get_base_loadstore (arg);
764 if (rhs)
765 ret |= visit_load (stmt, rhs, arg, data);
768 if (visit_addr
769 && gimple_call_chain (stmt)
770 && TREE_CODE (gimple_call_chain (stmt)) == ADDR_EXPR)
771 ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (stmt), 0),
772 gimple_call_chain (stmt), data);
773 if (visit_addr
774 && gimple_call_return_slot_opt_p (stmt)
775 && gimple_call_lhs (stmt) != NULL_TREE
776 && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
777 ret |= visit_addr (stmt, gimple_call_lhs (stmt),
778 gimple_call_lhs (stmt), data);
780 else if (gimple_code (stmt) == GIMPLE_ASM)
782 unsigned noutputs;
783 const char *constraint;
784 const char **oconstraints;
785 bool allows_mem, allows_reg, is_inout;
786 noutputs = gimple_asm_noutputs (stmt);
787 oconstraints = XALLOCAVEC (const char *, noutputs);
788 if (visit_store || visit_addr)
789 for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
791 tree link = gimple_asm_output_op (stmt, i);
792 tree op = get_base_loadstore (TREE_VALUE (link));
793 if (op && visit_store)
794 ret |= visit_store (stmt, op, TREE_VALUE (link), data);
795 if (visit_addr)
797 constraint = TREE_STRING_POINTER
798 (TREE_VALUE (TREE_PURPOSE (link)));
799 oconstraints[i] = constraint;
800 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
801 &allows_reg, &is_inout);
802 if (op && !allows_reg && allows_mem)
803 ret |= visit_addr (stmt, op, TREE_VALUE (link), data);
806 if (visit_load || visit_addr)
807 for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
809 tree link = gimple_asm_input_op (stmt, i);
810 tree op = TREE_VALUE (link);
811 if (visit_addr
812 && TREE_CODE (op) == ADDR_EXPR)
813 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
814 else if (visit_load || visit_addr)
816 op = get_base_loadstore (op);
817 if (op)
819 if (visit_load)
820 ret |= visit_load (stmt, op, TREE_VALUE (link), data);
821 if (visit_addr)
823 constraint = TREE_STRING_POINTER
824 (TREE_VALUE (TREE_PURPOSE (link)));
825 parse_input_constraint (&constraint, 0, 0, noutputs,
826 0, oconstraints,
827 &allows_mem, &allows_reg);
828 if (!allows_reg && allows_mem)
829 ret |= visit_addr (stmt, op, TREE_VALUE (link),
830 data);
836 else if (gimple_code (stmt) == GIMPLE_RETURN)
838 tree op = gimple_return_retval (stmt);
839 if (op)
841 if (visit_addr
842 && TREE_CODE (op) == ADDR_EXPR)
843 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
844 else if (visit_load)
846 tree base = get_base_loadstore (op);
847 if (base)
848 ret |= visit_load (stmt, base, op, data);
852 else if (visit_addr
853 && gimple_code (stmt) == GIMPLE_PHI)
855 for (i = 0; i < gimple_phi_num_args (stmt); ++i)
857 tree op = gimple_phi_arg_def (stmt, i);
858 if (TREE_CODE (op) == ADDR_EXPR)
859 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
862 else if (visit_addr
863 && gimple_code (stmt) == GIMPLE_GOTO)
865 tree op = gimple_goto_dest (stmt);
866 if (TREE_CODE (op) == ADDR_EXPR)
867 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
870 return ret;
873 /* Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP
874 should make a faster clone for this case. */
876 bool
877 walk_stmt_load_store_ops (gimple stmt, void *data,
878 walk_stmt_load_store_addr_fn visit_load,
879 walk_stmt_load_store_addr_fn visit_store)
881 return walk_stmt_load_store_addr_ops (stmt, data,
882 visit_load, visit_store, NULL);