1 /* Forward propagation of expressions for single use variables.
2 Copyright (C) 2004-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "basic-block.h"
27 #include "gimple-pretty-print.h"
28 #include "tree-flow.h"
29 #include "tree-pass.h"
30 #include "langhooks.h"
36 #include "tree-ssa-propagate.h"
38 /* This pass propagates the RHS of assignment statements into use
39 sites of the LHS of the assignment. It's basically a specialized
40 form of tree combination. It is hoped all of this can disappear
41 when we have a generalized tree combiner.
43 One class of common cases we handle is forward propagating a single use
44 variable into a COND_EXPR.
48 if (x) goto ... else goto ...
50 Will be transformed into:
53 if (a COND b) goto ... else goto ...
55 Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
57 Or (assuming c1 and c2 are constants):
61 if (x EQ/NEQ c2) goto ... else goto ...
63 Will be transformed into:
66 if (a EQ/NEQ (c2 - c1)) goto ... else goto ...
68 Similarly for x = a - c1.
74 if (x) goto ... else goto ...
76 Will be transformed into:
79 if (a == 0) goto ... else goto ...
81 Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
82 For these cases, we propagate A into all, possibly more than one,
83 COND_EXPRs that use X.
89 if (x) goto ... else goto ...
91 Will be transformed into:
94 if (a != 0) goto ... else goto ...
96 (Assuming a is an integral type and x is a boolean or x is an
97 integral and a is a boolean.)
99 Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
100 For these cases, we propagate A into all, possibly more than one,
101 COND_EXPRs that use X.
103 In addition to eliminating the variable and the statement which assigns
104 a value to the variable, we may be able to later thread the jump without
105 adding insane complexity in the dominator optimizer.
107 Also note these transformations can cascade. We handle this by having
108 a worklist of COND_EXPR statements to examine. As we make a change to
109 a statement, we put it back on the worklist to examine on the next
110 iteration of the main loop.
112 A second class of propagation opportunities arises for ADDR_EXPR
123 ptr = (type1*)&type2var;
126 Will get turned into (if type1 and type2 are the same size
127 and neither have volatile on them):
128 res = VIEW_CONVERT_EXPR<type1>(type2var)
133 ptr2 = ptr + <constant>;
137 ptr2 = &x[constant/elementsize];
142 offset = index * element_size;
143 offset_p = (pointer) offset;
144 ptr2 = ptr + offset_p
146 Will get turned into:
154 Provided that decl has known alignment >= 2, will get turned into
158 We also propagate casts into SWITCH_EXPR and COND_EXPR conditions to
159 allow us to remove the cast and {NOT_EXPR,NEG_EXPR} into a subsequent
162 This will (of course) be extended as other needs arise. */
164 static bool forward_propagate_addr_expr (tree name
, tree rhs
);
166 /* Set to true if we delete dead edges during the optimization. */
167 static bool cfg_changed
;
169 static tree
rhs_to_tree (tree type
, gimple stmt
);
171 /* Get the next statement we can propagate NAME's value into skipping
172 trivial copies. Returns the statement that is suitable as a
173 propagation destination or NULL_TREE if there is no such one.
174 This only returns destinations in a single-use chain. FINAL_NAME_P
175 if non-NULL is written to the ssa name that represents the use. */
178 get_prop_dest_stmt (tree name
, tree
*final_name_p
)
184 /* If name has multiple uses, bail out. */
185 if (!single_imm_use (name
, &use
, &use_stmt
))
188 /* If this is not a trivial copy, we found it. */
189 if (!gimple_assign_ssa_name_copy_p (use_stmt
)
190 || gimple_assign_rhs1 (use_stmt
) != name
)
193 /* Continue searching uses of the copy destination. */
194 name
= gimple_assign_lhs (use_stmt
);
198 *final_name_p
= name
;
203 /* Get the statement we can propagate from into NAME skipping
204 trivial copies. Returns the statement which defines the
205 propagation source or NULL_TREE if there is no such one.
206 If SINGLE_USE_ONLY is set considers only sources which have
207 a single use chain up to NAME. If SINGLE_USE_P is non-null,
208 it is set to whether the chain to NAME is a single use chain
209 or not. SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set. */
212 get_prop_source_stmt (tree name
, bool single_use_only
, bool *single_use_p
)
214 bool single_use
= true;
217 gimple def_stmt
= SSA_NAME_DEF_STMT (name
);
219 if (!has_single_use (name
))
226 /* If name is defined by a PHI node or is the default def, bail out. */
227 if (!is_gimple_assign (def_stmt
))
230 /* If def_stmt is a simple copy, continue looking. */
231 if (gimple_assign_rhs_code (def_stmt
) == SSA_NAME
)
232 name
= gimple_assign_rhs1 (def_stmt
);
235 if (!single_use_only
&& single_use_p
)
236 *single_use_p
= single_use
;
243 /* Checks if the destination ssa name in DEF_STMT can be used as
244 propagation source. Returns true if so, otherwise false. */
247 can_propagate_from (gimple def_stmt
)
249 gcc_assert (is_gimple_assign (def_stmt
));
251 /* If the rhs has side-effects we cannot propagate from it. */
252 if (gimple_has_volatile_ops (def_stmt
))
255 /* If the rhs is a load we cannot propagate from it. */
256 if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt
)) == tcc_reference
257 || TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt
)) == tcc_declaration
)
260 /* Constants can be always propagated. */
261 if (gimple_assign_single_p (def_stmt
)
262 && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt
)))
265 /* We cannot propagate ssa names that occur in abnormal phi nodes. */
266 if (stmt_references_abnormal_ssa_name (def_stmt
))
269 /* If the definition is a conversion of a pointer to a function type,
270 then we can not apply optimizations as some targets require
271 function pointers to be canonicalized and in this case this
272 optimization could eliminate a necessary canonicalization. */
273 if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
275 tree rhs
= gimple_assign_rhs1 (def_stmt
);
276 if (POINTER_TYPE_P (TREE_TYPE (rhs
))
277 && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs
))) == FUNCTION_TYPE
)
284 /* Remove a chain of dead statements starting at the definition of
285 NAME. The chain is linked via the first operand of the defining statements.
286 If NAME was replaced in its only use then this function can be used
287 to clean up dead stmts. The function handles already released SSA
289 Returns true if cleanup-cfg has to run. */
292 remove_prop_source_from_use (tree name
)
294 gimple_stmt_iterator gsi
;
296 bool cfg_changed
= false;
301 if (SSA_NAME_IN_FREE_LIST (name
)
302 || SSA_NAME_IS_DEFAULT_DEF (name
)
303 || !has_zero_uses (name
))
306 stmt
= SSA_NAME_DEF_STMT (name
);
307 if (gimple_code (stmt
) == GIMPLE_PHI
308 || gimple_has_side_effects (stmt
))
311 bb
= gimple_bb (stmt
);
312 gsi
= gsi_for_stmt (stmt
);
313 unlink_stmt_vdef (stmt
);
314 if (gsi_remove (&gsi
, true))
315 cfg_changed
|= gimple_purge_dead_eh_edges (bb
);
318 name
= is_gimple_assign (stmt
) ? gimple_assign_rhs1 (stmt
) : NULL_TREE
;
319 } while (name
&& TREE_CODE (name
) == SSA_NAME
);
324 /* Return the rhs of a gimple_assign STMT in a form of a single tree,
325 converted to type TYPE.
327 This should disappear, but is needed so we can combine expressions and use
328 the fold() interfaces. Long term, we need to develop folding and combine
329 routines that deal with gimple exclusively . */
332 rhs_to_tree (tree type
, gimple stmt
)
334 location_t loc
= gimple_location (stmt
);
335 enum tree_code code
= gimple_assign_rhs_code (stmt
);
336 if (get_gimple_rhs_class (code
) == GIMPLE_TERNARY_RHS
)
337 return fold_build3_loc (loc
, code
, type
, gimple_assign_rhs1 (stmt
),
338 gimple_assign_rhs2 (stmt
),
339 gimple_assign_rhs3 (stmt
));
340 else if (get_gimple_rhs_class (code
) == GIMPLE_BINARY_RHS
)
341 return fold_build2_loc (loc
, code
, type
, gimple_assign_rhs1 (stmt
),
342 gimple_assign_rhs2 (stmt
));
343 else if (get_gimple_rhs_class (code
) == GIMPLE_UNARY_RHS
)
344 return build1 (code
, type
, gimple_assign_rhs1 (stmt
));
345 else if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
)
346 return gimple_assign_rhs1 (stmt
);
351 /* Combine OP0 CODE OP1 in the context of a COND_EXPR. Returns
352 the folded result in a form suitable for COND_EXPR_COND or
353 NULL_TREE, if there is no suitable simplified form. If
354 INVARIANT_ONLY is true only gimple_min_invariant results are
355 considered simplified. */
358 combine_cond_expr_cond (gimple stmt
, enum tree_code code
, tree type
,
359 tree op0
, tree op1
, bool invariant_only
)
363 gcc_assert (TREE_CODE_CLASS (code
) == tcc_comparison
);
365 fold_defer_overflow_warnings ();
366 t
= fold_binary_loc (gimple_location (stmt
), code
, type
, op0
, op1
);
369 fold_undefer_overflow_warnings (false, NULL
, 0);
373 /* Require that we got a boolean type out if we put one in. */
374 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TREE_CODE (type
));
376 /* Canonicalize the combined condition for use in a COND_EXPR. */
377 t
= canonicalize_cond_expr_cond (t
);
379 /* Bail out if we required an invariant but didn't get one. */
380 if (!t
|| (invariant_only
&& !is_gimple_min_invariant (t
)))
382 fold_undefer_overflow_warnings (false, NULL
, 0);
386 fold_undefer_overflow_warnings (!gimple_no_warning_p (stmt
), stmt
, 0);
391 /* Combine the comparison OP0 CODE OP1 at LOC with the defining statements
392 of its operand. Return a new comparison tree or NULL_TREE if there
393 were no simplifying combines. */
396 forward_propagate_into_comparison_1 (gimple stmt
,
397 enum tree_code code
, tree type
,
400 tree tmp
= NULL_TREE
;
401 tree rhs0
= NULL_TREE
, rhs1
= NULL_TREE
;
402 bool single_use0_p
= false, single_use1_p
= false;
404 /* For comparisons use the first operand, that is likely to
405 simplify comparisons against constants. */
406 if (TREE_CODE (op0
) == SSA_NAME
)
408 gimple def_stmt
= get_prop_source_stmt (op0
, false, &single_use0_p
);
409 if (def_stmt
&& can_propagate_from (def_stmt
))
411 rhs0
= rhs_to_tree (TREE_TYPE (op1
), def_stmt
);
412 tmp
= combine_cond_expr_cond (stmt
, code
, type
,
413 rhs0
, op1
, !single_use0_p
);
419 /* If that wasn't successful, try the second operand. */
420 if (TREE_CODE (op1
) == SSA_NAME
)
422 gimple def_stmt
= get_prop_source_stmt (op1
, false, &single_use1_p
);
423 if (def_stmt
&& can_propagate_from (def_stmt
))
425 rhs1
= rhs_to_tree (TREE_TYPE (op0
), def_stmt
);
426 tmp
= combine_cond_expr_cond (stmt
, code
, type
,
427 op0
, rhs1
, !single_use1_p
);
433 /* If that wasn't successful either, try both operands. */
434 if (rhs0
!= NULL_TREE
435 && rhs1
!= NULL_TREE
)
436 tmp
= combine_cond_expr_cond (stmt
, code
, type
,
438 !(single_use0_p
&& single_use1_p
));
443 /* Propagate from the ssa name definition statements of the assignment
444 from a comparison at *GSI into the conditional if that simplifies it.
445 Returns 1 if the stmt was modified and 2 if the CFG needs cleanup,
446 otherwise returns 0. */
449 forward_propagate_into_comparison (gimple_stmt_iterator
*gsi
)
451 gimple stmt
= gsi_stmt (*gsi
);
453 bool cfg_changed
= false;
454 tree type
= TREE_TYPE (gimple_assign_lhs (stmt
));
455 tree rhs1
= gimple_assign_rhs1 (stmt
);
456 tree rhs2
= gimple_assign_rhs2 (stmt
);
458 /* Combine the comparison with defining statements. */
459 tmp
= forward_propagate_into_comparison_1 (stmt
,
460 gimple_assign_rhs_code (stmt
),
462 if (tmp
&& useless_type_conversion_p (type
, TREE_TYPE (tmp
)))
464 gimple_assign_set_rhs_from_tree (gsi
, tmp
);
466 update_stmt (gsi_stmt (*gsi
));
468 if (TREE_CODE (rhs1
) == SSA_NAME
)
469 cfg_changed
|= remove_prop_source_from_use (rhs1
);
470 if (TREE_CODE (rhs2
) == SSA_NAME
)
471 cfg_changed
|= remove_prop_source_from_use (rhs2
);
472 return cfg_changed
? 2 : 1;
478 /* Propagate from the ssa name definition statements of COND_EXPR
479 in GIMPLE_COND statement STMT into the conditional if that simplifies it.
480 Returns zero if no statement was changed, one if there were
481 changes and two if cfg_cleanup needs to run.
483 This must be kept in sync with forward_propagate_into_cond. */
486 forward_propagate_into_gimple_cond (gimple stmt
)
489 enum tree_code code
= gimple_cond_code (stmt
);
490 bool cfg_changed
= false;
491 tree rhs1
= gimple_cond_lhs (stmt
);
492 tree rhs2
= gimple_cond_rhs (stmt
);
494 /* We can do tree combining on SSA_NAME and comparison expressions. */
495 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
498 tmp
= forward_propagate_into_comparison_1 (stmt
, code
,
503 if (dump_file
&& tmp
)
505 fprintf (dump_file
, " Replaced '");
506 print_gimple_expr (dump_file
, stmt
, 0, 0);
507 fprintf (dump_file
, "' with '");
508 print_generic_expr (dump_file
, tmp
, 0);
509 fprintf (dump_file
, "'\n");
512 gimple_cond_set_condition_from_tree (stmt
, unshare_expr (tmp
));
515 if (TREE_CODE (rhs1
) == SSA_NAME
)
516 cfg_changed
|= remove_prop_source_from_use (rhs1
);
517 if (TREE_CODE (rhs2
) == SSA_NAME
)
518 cfg_changed
|= remove_prop_source_from_use (rhs2
);
519 return (cfg_changed
|| is_gimple_min_invariant (tmp
)) ? 2 : 1;
522 /* Canonicalize _Bool == 0 and _Bool != 1 to _Bool != 0 by swapping edges. */
523 if ((TREE_CODE (TREE_TYPE (rhs1
)) == BOOLEAN_TYPE
524 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
525 && TYPE_PRECISION (TREE_TYPE (rhs1
)) == 1))
527 && integer_zerop (rhs2
))
529 && integer_onep (rhs2
))))
531 basic_block bb
= gimple_bb (stmt
);
532 gimple_cond_set_code (stmt
, NE_EXPR
);
533 gimple_cond_set_rhs (stmt
, build_zero_cst (TREE_TYPE (rhs1
)));
534 EDGE_SUCC (bb
, 0)->flags
^= (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
);
535 EDGE_SUCC (bb
, 1)->flags
^= (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
);
543 /* Propagate from the ssa name definition statements of COND_EXPR
544 in the rhs of statement STMT into the conditional if that simplifies it.
545 Returns true zero if the stmt was changed. */
548 forward_propagate_into_cond (gimple_stmt_iterator
*gsi_p
)
550 gimple stmt
= gsi_stmt (*gsi_p
);
551 tree tmp
= NULL_TREE
;
552 tree cond
= gimple_assign_rhs1 (stmt
);
553 enum tree_code code
= gimple_assign_rhs_code (stmt
);
556 /* We can do tree combining on SSA_NAME and comparison expressions. */
557 if (COMPARISON_CLASS_P (cond
))
558 tmp
= forward_propagate_into_comparison_1 (stmt
, TREE_CODE (cond
),
560 TREE_OPERAND (cond
, 0),
561 TREE_OPERAND (cond
, 1));
562 else if (TREE_CODE (cond
) == SSA_NAME
)
564 enum tree_code def_code
;
566 gimple def_stmt
= get_prop_source_stmt (name
, true, NULL
);
567 if (!def_stmt
|| !can_propagate_from (def_stmt
))
570 def_code
= gimple_assign_rhs_code (def_stmt
);
571 if (TREE_CODE_CLASS (def_code
) == tcc_comparison
)
572 tmp
= fold_build2_loc (gimple_location (def_stmt
),
575 gimple_assign_rhs1 (def_stmt
),
576 gimple_assign_rhs2 (def_stmt
));
577 else if (code
== COND_EXPR
578 && ((def_code
== BIT_NOT_EXPR
579 && TYPE_PRECISION (TREE_TYPE (cond
)) == 1)
580 || (def_code
== BIT_XOR_EXPR
581 && integer_onep (gimple_assign_rhs2 (def_stmt
)))))
583 tmp
= gimple_assign_rhs1 (def_stmt
);
589 && is_gimple_condexpr (tmp
))
591 if (dump_file
&& tmp
)
593 fprintf (dump_file
, " Replaced '");
594 print_generic_expr (dump_file
, cond
, 0);
595 fprintf (dump_file
, "' with '");
596 print_generic_expr (dump_file
, tmp
, 0);
597 fprintf (dump_file
, "'\n");
600 if ((code
== VEC_COND_EXPR
) ? integer_all_onesp (tmp
)
601 : integer_onep (tmp
))
602 gimple_assign_set_rhs_from_tree (gsi_p
, gimple_assign_rhs2 (stmt
));
603 else if (integer_zerop (tmp
))
604 gimple_assign_set_rhs_from_tree (gsi_p
, gimple_assign_rhs3 (stmt
));
607 gimple_assign_set_rhs1 (stmt
, unshare_expr (tmp
));
610 tree t
= gimple_assign_rhs2 (stmt
);
611 gimple_assign_set_rhs2 (stmt
, gimple_assign_rhs3 (stmt
));
612 gimple_assign_set_rhs3 (stmt
, t
);
615 stmt
= gsi_stmt (*gsi_p
);
624 /* Propagate from the ssa name definition statements of COND_EXPR
625 values in the rhs of statement STMT into the conditional arms
626 if that simplifies it.
627 Returns true if the stmt was changed. */
630 combine_cond_exprs (gimple_stmt_iterator
*gsi_p
)
632 gimple stmt
= gsi_stmt (*gsi_p
);
633 tree cond
, val1
, val2
;
634 bool changed
= false;
636 cond
= gimple_assign_rhs1 (stmt
);
637 val1
= gimple_assign_rhs2 (stmt
);
638 if (TREE_CODE (val1
) == SSA_NAME
)
640 gimple def_stmt
= SSA_NAME_DEF_STMT (val1
);
641 if (is_gimple_assign (def_stmt
)
642 && gimple_assign_rhs_code (def_stmt
) == gimple_assign_rhs_code (stmt
)
643 && operand_equal_p (gimple_assign_rhs1 (def_stmt
), cond
, 0))
645 val1
= unshare_expr (gimple_assign_rhs2 (def_stmt
));
646 gimple_assign_set_rhs2 (stmt
, val1
);
650 val2
= gimple_assign_rhs3 (stmt
);
651 if (TREE_CODE (val2
) == SSA_NAME
)
653 gimple def_stmt
= SSA_NAME_DEF_STMT (val2
);
654 if (is_gimple_assign (def_stmt
)
655 && gimple_assign_rhs_code (def_stmt
) == gimple_assign_rhs_code (stmt
)
656 && operand_equal_p (gimple_assign_rhs1 (def_stmt
), cond
, 0))
658 val2
= unshare_expr (gimple_assign_rhs3 (def_stmt
));
659 gimple_assign_set_rhs3 (stmt
, val2
);
663 if (operand_equal_p (val1
, val2
, 0))
665 gimple_assign_set_rhs_from_tree (gsi_p
, val1
);
666 stmt
= gsi_stmt (*gsi_p
);
676 /* We've just substituted an ADDR_EXPR into stmt. Update all the
677 relevant data structures to match. */
680 tidy_after_forward_propagate_addr (gimple stmt
)
682 /* We may have turned a trapping insn into a non-trapping insn. */
683 if (maybe_clean_or_replace_eh_stmt (stmt
, stmt
)
684 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
687 if (TREE_CODE (gimple_assign_rhs1 (stmt
)) == ADDR_EXPR
)
688 recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt
));
691 /* NAME is a SSA_NAME representing DEF_RHS which is of the form
692 ADDR_EXPR <whatever>.
694 Try to forward propagate the ADDR_EXPR into the use USE_STMT.
695 Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
696 node or for recovery of array indexing from pointer arithmetic.
698 Return true if the propagation was successful (the propagation can
699 be not totally successful, yet things may have been changed). */
702 forward_propagate_addr_expr_1 (tree name
, tree def_rhs
,
703 gimple_stmt_iterator
*use_stmt_gsi
,
706 tree lhs
, rhs
, rhs2
, array_ref
;
707 gimple use_stmt
= gsi_stmt (*use_stmt_gsi
);
708 enum tree_code rhs_code
;
711 gcc_assert (TREE_CODE (def_rhs
) == ADDR_EXPR
);
713 lhs
= gimple_assign_lhs (use_stmt
);
714 rhs_code
= gimple_assign_rhs_code (use_stmt
);
715 rhs
= gimple_assign_rhs1 (use_stmt
);
717 /* Trivial cases. The use statement could be a trivial copy or a
718 useless conversion. Recurse to the uses of the lhs as copyprop does
719 not copy through different variant pointers and FRE does not catch
720 all useless conversions. Treat the case of a single-use name and
721 a conversion to def_rhs type separate, though. */
722 if (TREE_CODE (lhs
) == SSA_NAME
723 && ((rhs_code
== SSA_NAME
&& rhs
== name
)
724 || CONVERT_EXPR_CODE_P (rhs_code
)))
726 /* Only recurse if we don't deal with a single use or we cannot
727 do the propagation to the current statement. In particular
728 we can end up with a conversion needed for a non-invariant
729 address which we cannot do in a single statement. */
731 || (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (def_rhs
))
732 && (!is_gimple_min_invariant (def_rhs
)
733 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
734 && POINTER_TYPE_P (TREE_TYPE (def_rhs
))
735 && (TYPE_PRECISION (TREE_TYPE (lhs
))
736 > TYPE_PRECISION (TREE_TYPE (def_rhs
)))))))
737 return forward_propagate_addr_expr (lhs
, def_rhs
);
739 gimple_assign_set_rhs1 (use_stmt
, unshare_expr (def_rhs
));
740 if (useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (def_rhs
)))
741 gimple_assign_set_rhs_code (use_stmt
, TREE_CODE (def_rhs
));
743 gimple_assign_set_rhs_code (use_stmt
, NOP_EXPR
);
747 /* Propagate through constant pointer adjustments. */
748 if (TREE_CODE (lhs
) == SSA_NAME
749 && rhs_code
== POINTER_PLUS_EXPR
751 && TREE_CODE (gimple_assign_rhs2 (use_stmt
)) == INTEGER_CST
)
754 /* As we come here with non-invariant addresses in def_rhs we need
755 to make sure we can build a valid constant offsetted address
756 for further propagation. Simply rely on fold building that
757 and check after the fact. */
758 new_def_rhs
= fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (rhs
)),
760 fold_convert (ptr_type_node
,
761 gimple_assign_rhs2 (use_stmt
)));
762 if (TREE_CODE (new_def_rhs
) == MEM_REF
763 && !is_gimple_mem_ref_addr (TREE_OPERAND (new_def_rhs
, 0)))
765 new_def_rhs
= build_fold_addr_expr_with_type (new_def_rhs
,
768 /* Recurse. If we could propagate into all uses of lhs do not
769 bother to replace into the current use but just pretend we did. */
770 if (TREE_CODE (new_def_rhs
) == ADDR_EXPR
771 && forward_propagate_addr_expr (lhs
, new_def_rhs
))
774 if (useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (new_def_rhs
)))
775 gimple_assign_set_rhs_with_ops (use_stmt_gsi
, TREE_CODE (new_def_rhs
),
776 new_def_rhs
, NULL_TREE
);
777 else if (is_gimple_min_invariant (new_def_rhs
))
778 gimple_assign_set_rhs_with_ops (use_stmt_gsi
, NOP_EXPR
,
779 new_def_rhs
, NULL_TREE
);
782 gcc_assert (gsi_stmt (*use_stmt_gsi
) == use_stmt
);
783 update_stmt (use_stmt
);
787 /* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS.
788 ADDR_EXPR will not appear on the LHS. */
789 lhs
= gimple_assign_lhs (use_stmt
);
790 while (handled_component_p (lhs
))
791 lhs
= TREE_OPERAND (lhs
, 0);
793 /* Now see if the LHS node is a MEM_REF using NAME. If so,
794 propagate the ADDR_EXPR into the use of NAME and fold the result. */
795 if (TREE_CODE (lhs
) == MEM_REF
796 && TREE_OPERAND (lhs
, 0) == name
)
799 HOST_WIDE_INT def_rhs_offset
;
800 /* If the address is invariant we can always fold it. */
801 if ((def_rhs_base
= get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs
, 0),
804 double_int off
= mem_ref_offset (lhs
);
806 off
+= double_int::from_shwi (def_rhs_offset
);
807 if (TREE_CODE (def_rhs_base
) == MEM_REF
)
809 off
+= mem_ref_offset (def_rhs_base
);
810 new_ptr
= TREE_OPERAND (def_rhs_base
, 0);
813 new_ptr
= build_fold_addr_expr (def_rhs_base
);
814 TREE_OPERAND (lhs
, 0) = new_ptr
;
815 TREE_OPERAND (lhs
, 1)
816 = double_int_to_tree (TREE_TYPE (TREE_OPERAND (lhs
, 1)), off
);
817 tidy_after_forward_propagate_addr (use_stmt
);
818 /* Continue propagating into the RHS if this was not the only use. */
822 /* If the LHS is a plain dereference and the value type is the same as
823 that of the pointed-to type of the address we can put the
824 dereferenced address on the LHS preserving the original alias-type. */
825 else if (gimple_assign_lhs (use_stmt
) == lhs
826 && integer_zerop (TREE_OPERAND (lhs
, 1))
827 && useless_type_conversion_p
828 (TREE_TYPE (TREE_OPERAND (def_rhs
, 0)),
829 TREE_TYPE (gimple_assign_rhs1 (use_stmt
)))
830 /* Don't forward anything into clobber stmts if it would result
831 in the lhs no longer being a MEM_REF. */
832 && (!gimple_clobber_p (use_stmt
)
833 || TREE_CODE (TREE_OPERAND (def_rhs
, 0)) == MEM_REF
))
835 tree
*def_rhs_basep
= &TREE_OPERAND (def_rhs
, 0);
836 tree new_offset
, new_base
, saved
, new_lhs
;
837 while (handled_component_p (*def_rhs_basep
))
838 def_rhs_basep
= &TREE_OPERAND (*def_rhs_basep
, 0);
839 saved
= *def_rhs_basep
;
840 if (TREE_CODE (*def_rhs_basep
) == MEM_REF
)
842 new_base
= TREE_OPERAND (*def_rhs_basep
, 0);
843 new_offset
= fold_convert (TREE_TYPE (TREE_OPERAND (lhs
, 1)),
844 TREE_OPERAND (*def_rhs_basep
, 1));
848 new_base
= build_fold_addr_expr (*def_rhs_basep
);
849 new_offset
= TREE_OPERAND (lhs
, 1);
851 *def_rhs_basep
= build2 (MEM_REF
, TREE_TYPE (*def_rhs_basep
),
852 new_base
, new_offset
);
853 TREE_THIS_VOLATILE (*def_rhs_basep
) = TREE_THIS_VOLATILE (lhs
);
854 TREE_SIDE_EFFECTS (*def_rhs_basep
) = TREE_SIDE_EFFECTS (lhs
);
855 TREE_THIS_NOTRAP (*def_rhs_basep
) = TREE_THIS_NOTRAP (lhs
);
856 new_lhs
= unshare_expr (TREE_OPERAND (def_rhs
, 0));
857 gimple_assign_set_lhs (use_stmt
, new_lhs
);
858 TREE_THIS_VOLATILE (new_lhs
) = TREE_THIS_VOLATILE (lhs
);
859 TREE_SIDE_EFFECTS (new_lhs
) = TREE_SIDE_EFFECTS (lhs
);
860 *def_rhs_basep
= saved
;
861 tidy_after_forward_propagate_addr (use_stmt
);
862 /* Continue propagating into the RHS if this was not the
868 /* We can have a struct assignment dereferencing our name twice.
869 Note that we didn't propagate into the lhs to not falsely
870 claim we did when propagating into the rhs. */
874 /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
875 nodes from the RHS. */
876 rhs
= gimple_assign_rhs1 (use_stmt
);
877 if (TREE_CODE (rhs
) == ADDR_EXPR
)
878 rhs
= TREE_OPERAND (rhs
, 0);
879 while (handled_component_p (rhs
))
880 rhs
= TREE_OPERAND (rhs
, 0);
882 /* Now see if the RHS node is a MEM_REF using NAME. If so,
883 propagate the ADDR_EXPR into the use of NAME and fold the result. */
884 if (TREE_CODE (rhs
) == MEM_REF
885 && TREE_OPERAND (rhs
, 0) == name
)
888 HOST_WIDE_INT def_rhs_offset
;
889 if ((def_rhs_base
= get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs
, 0),
892 double_int off
= mem_ref_offset (rhs
);
894 off
+= double_int::from_shwi (def_rhs_offset
);
895 if (TREE_CODE (def_rhs_base
) == MEM_REF
)
897 off
+= mem_ref_offset (def_rhs_base
);
898 new_ptr
= TREE_OPERAND (def_rhs_base
, 0);
901 new_ptr
= build_fold_addr_expr (def_rhs_base
);
902 TREE_OPERAND (rhs
, 0) = new_ptr
;
903 TREE_OPERAND (rhs
, 1)
904 = double_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs
, 1)), off
);
905 fold_stmt_inplace (use_stmt_gsi
);
906 tidy_after_forward_propagate_addr (use_stmt
);
909 /* If the RHS is a plain dereference and the value type is the same as
910 that of the pointed-to type of the address we can put the
911 dereferenced address on the RHS preserving the original alias-type. */
912 else if (gimple_assign_rhs1 (use_stmt
) == rhs
913 && integer_zerop (TREE_OPERAND (rhs
, 1))
914 && useless_type_conversion_p
915 (TREE_TYPE (gimple_assign_lhs (use_stmt
)),
916 TREE_TYPE (TREE_OPERAND (def_rhs
, 0))))
918 tree
*def_rhs_basep
= &TREE_OPERAND (def_rhs
, 0);
919 tree new_offset
, new_base
, saved
, new_rhs
;
920 while (handled_component_p (*def_rhs_basep
))
921 def_rhs_basep
= &TREE_OPERAND (*def_rhs_basep
, 0);
922 saved
= *def_rhs_basep
;
923 if (TREE_CODE (*def_rhs_basep
) == MEM_REF
)
925 new_base
= TREE_OPERAND (*def_rhs_basep
, 0);
926 new_offset
= fold_convert (TREE_TYPE (TREE_OPERAND (rhs
, 1)),
927 TREE_OPERAND (*def_rhs_basep
, 1));
931 new_base
= build_fold_addr_expr (*def_rhs_basep
);
932 new_offset
= TREE_OPERAND (rhs
, 1);
934 *def_rhs_basep
= build2 (MEM_REF
, TREE_TYPE (*def_rhs_basep
),
935 new_base
, new_offset
);
936 TREE_THIS_VOLATILE (*def_rhs_basep
) = TREE_THIS_VOLATILE (rhs
);
937 TREE_SIDE_EFFECTS (*def_rhs_basep
) = TREE_SIDE_EFFECTS (rhs
);
938 TREE_THIS_NOTRAP (*def_rhs_basep
) = TREE_THIS_NOTRAP (rhs
);
939 new_rhs
= unshare_expr (TREE_OPERAND (def_rhs
, 0));
940 gimple_assign_set_rhs1 (use_stmt
, new_rhs
);
941 TREE_THIS_VOLATILE (new_rhs
) = TREE_THIS_VOLATILE (rhs
);
942 TREE_SIDE_EFFECTS (new_rhs
) = TREE_SIDE_EFFECTS (rhs
);
943 *def_rhs_basep
= saved
;
944 fold_stmt_inplace (use_stmt_gsi
);
945 tidy_after_forward_propagate_addr (use_stmt
);
950 /* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
952 if (gimple_assign_rhs_code (use_stmt
) != POINTER_PLUS_EXPR
953 || gimple_assign_rhs1 (use_stmt
) != name
)
956 /* The remaining cases are all for turning pointer arithmetic into
957 array indexing. They only apply when we have the address of
958 element zero in an array. If that is not the case then there
960 array_ref
= TREE_OPERAND (def_rhs
, 0);
961 if ((TREE_CODE (array_ref
) != ARRAY_REF
962 || TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref
, 0))) != ARRAY_TYPE
963 || TREE_CODE (TREE_OPERAND (array_ref
, 1)) != INTEGER_CST
)
964 && TREE_CODE (TREE_TYPE (array_ref
)) != ARRAY_TYPE
)
967 rhs2
= gimple_assign_rhs2 (use_stmt
);
968 /* Optimize &x[C1] p+ C2 to &x p+ C3 with C3 = C1 * element_size + C2. */
969 if (TREE_CODE (rhs2
) == INTEGER_CST
)
971 tree new_rhs
= build1_loc (gimple_location (use_stmt
),
972 ADDR_EXPR
, TREE_TYPE (def_rhs
),
973 fold_build2 (MEM_REF
,
974 TREE_TYPE (TREE_TYPE (def_rhs
)),
975 unshare_expr (def_rhs
),
976 fold_convert (ptr_type_node
,
978 gimple_assign_set_rhs_from_tree (use_stmt_gsi
, new_rhs
);
979 use_stmt
= gsi_stmt (*use_stmt_gsi
);
980 update_stmt (use_stmt
);
981 tidy_after_forward_propagate_addr (use_stmt
);
988 /* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
990 Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME.
991 Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
992 node or for recovery of array indexing from pointer arithmetic.
993 Returns true, if all uses have been propagated into. */
996 forward_propagate_addr_expr (tree name
, tree rhs
)
998 int stmt_loop_depth
= bb_loop_depth (gimple_bb (SSA_NAME_DEF_STMT (name
)));
999 imm_use_iterator iter
;
1002 bool single_use_p
= has_single_use (name
);
1004 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, name
)
1009 /* If the use is not in a simple assignment statement, then
1010 there is nothing we can do. */
1011 if (gimple_code (use_stmt
) != GIMPLE_ASSIGN
)
1013 if (!is_gimple_debug (use_stmt
))
1018 /* If the use is in a deeper loop nest, then we do not want
1019 to propagate non-invariant ADDR_EXPRs into the loop as that
1020 is likely adding expression evaluations into the loop. */
1021 if (bb_loop_depth (gimple_bb (use_stmt
)) > stmt_loop_depth
1022 && !is_gimple_min_invariant (rhs
))
1029 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
1030 result
= forward_propagate_addr_expr_1 (name
, rhs
, &gsi
,
1032 /* If the use has moved to a different statement adjust
1033 the update machinery for the old statement too. */
1034 if (use_stmt
!= gsi_stmt (gsi
))
1036 update_stmt (use_stmt
);
1037 use_stmt
= gsi_stmt (gsi
);
1040 update_stmt (use_stmt
);
1044 /* Remove intermediate now unused copy and conversion chains. */
1045 use_rhs
= gimple_assign_rhs1 (use_stmt
);
1047 && TREE_CODE (gimple_assign_lhs (use_stmt
)) == SSA_NAME
1048 && TREE_CODE (use_rhs
) == SSA_NAME
1049 && has_zero_uses (gimple_assign_lhs (use_stmt
)))
1051 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
1052 release_defs (use_stmt
);
1053 gsi_remove (&gsi
, true);
1057 return all
&& has_zero_uses (name
);
1061 /* Forward propagate the comparison defined in *DEFGSI like
1062 cond_1 = x CMP y to uses of the form
1066 Returns true if stmt is now unused. Advance DEFGSI to the next
1070 forward_propagate_comparison (gimple_stmt_iterator
*defgsi
)
1072 gimple stmt
= gsi_stmt (*defgsi
);
1073 tree name
= gimple_assign_lhs (stmt
);
1075 tree tmp
= NULL_TREE
;
1076 gimple_stmt_iterator gsi
;
1077 enum tree_code code
;
1080 /* Don't propagate ssa names that occur in abnormal phis. */
1081 if ((TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
1082 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt
)))
1083 || (TREE_CODE (gimple_assign_rhs2 (stmt
)) == SSA_NAME
1084 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs2 (stmt
))))
1087 /* Do not un-cse comparisons. But propagate through copies. */
1088 use_stmt
= get_prop_dest_stmt (name
, &name
);
1090 || !is_gimple_assign (use_stmt
))
1093 code
= gimple_assign_rhs_code (use_stmt
);
1094 lhs
= gimple_assign_lhs (use_stmt
);
1095 if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs
)))
1098 /* We can propagate the condition into a statement that
1099 computes the logical negation of the comparison result. */
1100 if ((code
== BIT_NOT_EXPR
1101 && TYPE_PRECISION (TREE_TYPE (lhs
)) == 1)
1102 || (code
== BIT_XOR_EXPR
1103 && integer_onep (gimple_assign_rhs2 (use_stmt
))))
1105 tree type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
1106 bool nans
= HONOR_NANS (TYPE_MODE (type
));
1107 enum tree_code inv_code
;
1108 inv_code
= invert_tree_comparison (gimple_assign_rhs_code (stmt
), nans
);
1109 if (inv_code
== ERROR_MARK
)
1112 tmp
= build2 (inv_code
, TREE_TYPE (lhs
), gimple_assign_rhs1 (stmt
),
1113 gimple_assign_rhs2 (stmt
));
1118 gsi
= gsi_for_stmt (use_stmt
);
1119 gimple_assign_set_rhs_from_tree (&gsi
, unshare_expr (tmp
));
1120 use_stmt
= gsi_stmt (gsi
);
1121 update_stmt (use_stmt
);
1123 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1125 fprintf (dump_file
, " Replaced '");
1126 print_gimple_expr (dump_file
, stmt
, 0, dump_flags
);
1127 fprintf (dump_file
, "' with '");
1128 print_gimple_expr (dump_file
, use_stmt
, 0, dump_flags
);
1129 fprintf (dump_file
, "'\n");
1132 /* When we remove stmt now the iterator defgsi goes off it's current
1133 sequence, hence advance it now. */
1136 /* Remove defining statements. */
1137 return remove_prop_source_from_use (name
);
1145 /* GSI_P points to a statement which performs a narrowing integral
1148 Look for cases like:
1158 If T is narrower than X's type and C merely masks off bits outside
1159 of (T) and nothing else.
1161 Normally we'd let DCE remove the dead statement. But no DCE runs
1162 after the last forwprop/combine pass, so we remove the obviously
1163 dead code ourselves.
1165 Return TRUE if a change was made, FALSE otherwise. */
1168 simplify_conversion_from_bitmask (gimple_stmt_iterator
*gsi_p
)
1170 gimple stmt
= gsi_stmt (*gsi_p
);
1171 gimple rhs_def_stmt
= SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt
));
1173 /* See if the input for the conversion was set via a BIT_AND_EXPR and
1174 the only use of the BIT_AND_EXPR result is the conversion. */
1175 if (is_gimple_assign (rhs_def_stmt
)
1176 && gimple_assign_rhs_code (rhs_def_stmt
) == BIT_AND_EXPR
1177 && has_single_use (gimple_assign_lhs (rhs_def_stmt
)))
1179 tree rhs_def_operand1
= gimple_assign_rhs1 (rhs_def_stmt
);
1180 tree rhs_def_operand2
= gimple_assign_rhs2 (rhs_def_stmt
);
1181 tree lhs_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
1183 /* Now verify suitability of the BIT_AND_EXPR's operands.
1184 The first must be an SSA_NAME that we can propagate and the
1185 second must be an integer constant that masks out all the
1186 bits outside the final result's type, but nothing else. */
1187 if (TREE_CODE (rhs_def_operand1
) == SSA_NAME
1188 && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand1
)
1189 && TREE_CODE (rhs_def_operand2
) == INTEGER_CST
1190 && operand_equal_p (rhs_def_operand2
,
1191 build_low_bits_mask (TREE_TYPE (rhs_def_operand2
),
1192 TYPE_PRECISION (lhs_type
)),
1195 /* This is an optimizable case. Replace the source operand
1196 in the conversion with the first source operand of the
1198 gimple_assign_set_rhs1 (stmt
, rhs_def_operand1
);
1199 stmt
= gsi_stmt (*gsi_p
);
1202 /* There is no DCE after the last forwprop pass. It's
1203 easy to clean up the first order effects here. */
1204 gimple_stmt_iterator si
;
1205 si
= gsi_for_stmt (rhs_def_stmt
);
1206 gsi_remove (&si
, true);
1207 release_defs (rhs_def_stmt
);
1216 /* If we have lhs = ~x (STMT), look and see if earlier we had x = ~y.
1217 If so, we can change STMT into lhs = y which can later be copy
1218 propagated. Similarly for negation.
1220 This could trivially be formulated as a forward propagation
1221 to immediate uses. However, we already had an implementation
1222 from DOM which used backward propagation via the use-def links.
1224 It turns out that backward propagation is actually faster as
1225 there's less work to do for each NOT/NEG expression we find.
1226 Backwards propagation needs to look at the statement in a single
1227 backlink. Forward propagation needs to look at potentially more
1228 than one forward link.
1230 Returns true when the statement was changed. */
1233 simplify_not_neg_expr (gimple_stmt_iterator
*gsi_p
)
1235 gimple stmt
= gsi_stmt (*gsi_p
);
1236 tree rhs
= gimple_assign_rhs1 (stmt
);
1237 gimple rhs_def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1239 /* See if the RHS_DEF_STMT has the same form as our statement. */
1240 if (is_gimple_assign (rhs_def_stmt
)
1241 && gimple_assign_rhs_code (rhs_def_stmt
) == gimple_assign_rhs_code (stmt
))
1243 tree rhs_def_operand
= gimple_assign_rhs1 (rhs_def_stmt
);
1245 /* Verify that RHS_DEF_OPERAND is a suitable SSA_NAME. */
1246 if (TREE_CODE (rhs_def_operand
) == SSA_NAME
1247 && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand
))
1249 gimple_assign_set_rhs_from_tree (gsi_p
, rhs_def_operand
);
1250 stmt
= gsi_stmt (*gsi_p
);
1259 /* Helper function for simplify_gimple_switch. Remove case labels that
1260 have values outside the range of the new type. */
1263 simplify_gimple_switch_label_vec (gimple stmt
, tree index_type
)
1265 unsigned int branch_num
= gimple_switch_num_labels (stmt
);
1267 labels
.create (branch_num
);
1268 unsigned int i
, len
;
1270 /* Collect the existing case labels in a VEC, and preprocess it as if
1271 we are gimplifying a GENERIC SWITCH_EXPR. */
1272 for (i
= 1; i
< branch_num
; i
++)
1273 labels
.quick_push (gimple_switch_label (stmt
, i
));
1274 preprocess_case_label_vec_for_gimple (labels
, index_type
, NULL
);
1276 /* If any labels were removed, replace the existing case labels
1277 in the GIMPLE_SWITCH statement with the correct ones.
1278 Note that the type updates were done in-place on the case labels,
1279 so we only have to replace the case labels in the GIMPLE_SWITCH
1280 if the number of labels changed. */
1281 len
= labels
.length ();
1282 if (len
< branch_num
- 1)
1284 bitmap target_blocks
;
1288 /* Corner case: *all* case labels have been removed as being
1289 out-of-range for INDEX_TYPE. Push one label and let the
1290 CFG cleanups deal with this further. */
1295 label
= CASE_LABEL (gimple_switch_default_label (stmt
));
1296 elt
= build_case_label (build_int_cst (index_type
, 0), NULL
, label
);
1297 labels
.quick_push (elt
);
1301 for (i
= 0; i
< labels
.length (); i
++)
1302 gimple_switch_set_label (stmt
, i
+ 1, labels
[i
]);
1303 for (i
++ ; i
< branch_num
; i
++)
1304 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1305 gimple_switch_set_num_labels (stmt
, len
+ 1);
1307 /* Cleanup any edges that are now dead. */
1308 target_blocks
= BITMAP_ALLOC (NULL
);
1309 for (i
= 0; i
< gimple_switch_num_labels (stmt
); i
++)
1311 tree elt
= gimple_switch_label (stmt
, i
);
1312 basic_block target
= label_to_block (CASE_LABEL (elt
));
1313 bitmap_set_bit (target_blocks
, target
->index
);
1315 for (ei
= ei_start (gimple_bb (stmt
)->succs
); (e
= ei_safe_edge (ei
)); )
1317 if (! bitmap_bit_p (target_blocks
, e
->dest
->index
))
1321 free_dominance_info (CDI_DOMINATORS
);
1326 BITMAP_FREE (target_blocks
);
1332 /* STMT is a SWITCH_EXPR for which we attempt to find equivalent forms of
1333 the condition which we may be able to optimize better. */
1336 simplify_gimple_switch (gimple stmt
)
1338 tree cond
= gimple_switch_index (stmt
);
1342 /* The optimization that we really care about is removing unnecessary
1343 casts. That will let us do much better in propagating the inferred
1344 constant at the switch target. */
1345 if (TREE_CODE (cond
) == SSA_NAME
)
1347 def_stmt
= SSA_NAME_DEF_STMT (cond
);
1348 if (is_gimple_assign (def_stmt
))
1350 if (gimple_assign_rhs_code (def_stmt
) == NOP_EXPR
)
1355 def
= gimple_assign_rhs1 (def_stmt
);
1357 to
= TREE_TYPE (cond
);
1358 ti
= TREE_TYPE (def
);
1360 /* If we have an extension that preserves value, then we
1361 can copy the source value into the switch. */
1363 need_precision
= TYPE_PRECISION (ti
);
1365 if (! INTEGRAL_TYPE_P (ti
))
1367 else if (TYPE_UNSIGNED (to
) && !TYPE_UNSIGNED (ti
))
1369 else if (!TYPE_UNSIGNED (to
) && TYPE_UNSIGNED (ti
))
1370 need_precision
+= 1;
1371 if (TYPE_PRECISION (to
) < need_precision
)
1376 gimple_switch_set_index (stmt
, def
);
1377 simplify_gimple_switch_label_vec (stmt
, ti
);
1388 /* For pointers p2 and p1 return p2 - p1 if the
1389 difference is known and constant, otherwise return NULL. */
1392 constant_pointer_difference (tree p1
, tree p2
)
1395 #define CPD_ITERATIONS 5
1396 tree exps
[2][CPD_ITERATIONS
];
1397 tree offs
[2][CPD_ITERATIONS
];
1400 for (i
= 0; i
< 2; i
++)
1402 tree p
= i
? p1
: p2
;
1403 tree off
= size_zero_node
;
1405 enum tree_code code
;
1407 /* For each of p1 and p2 we need to iterate at least
1408 twice, to handle ADDR_EXPR directly in p1/p2,
1409 SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc.
1410 on definition's stmt RHS. Iterate a few extra times. */
1414 if (!POINTER_TYPE_P (TREE_TYPE (p
)))
1416 if (TREE_CODE (p
) == ADDR_EXPR
)
1418 tree q
= TREE_OPERAND (p
, 0);
1419 HOST_WIDE_INT offset
;
1420 tree base
= get_addr_base_and_unit_offset (q
, &offset
);
1425 off
= size_binop (PLUS_EXPR
, off
, size_int (offset
));
1427 if (TREE_CODE (q
) == MEM_REF
1428 && TREE_CODE (TREE_OPERAND (q
, 0)) == SSA_NAME
)
1430 p
= TREE_OPERAND (q
, 0);
1431 off
= size_binop (PLUS_EXPR
, off
,
1432 double_int_to_tree (sizetype
,
1433 mem_ref_offset (q
)));
1442 if (TREE_CODE (p
) != SSA_NAME
)
1446 if (j
== CPD_ITERATIONS
)
1448 stmt
= SSA_NAME_DEF_STMT (p
);
1449 if (!is_gimple_assign (stmt
) || gimple_assign_lhs (stmt
) != p
)
1451 code
= gimple_assign_rhs_code (stmt
);
1452 if (code
== POINTER_PLUS_EXPR
)
1454 if (TREE_CODE (gimple_assign_rhs2 (stmt
)) != INTEGER_CST
)
1456 off
= size_binop (PLUS_EXPR
, off
, gimple_assign_rhs2 (stmt
));
1457 p
= gimple_assign_rhs1 (stmt
);
1459 else if (code
== ADDR_EXPR
|| code
== NOP_EXPR
)
1460 p
= gimple_assign_rhs1 (stmt
);
1468 for (i
= 0; i
< cnt
[0]; i
++)
1469 for (j
= 0; j
< cnt
[1]; j
++)
1470 if (exps
[0][i
] == exps
[1][j
])
1471 return size_binop (MINUS_EXPR
, offs
[0][i
], offs
[1][j
]);
1476 /* *GSI_P is a GIMPLE_CALL to a builtin function.
1478 memcpy (p, "abcd", 4);
1479 memset (p + 4, ' ', 3);
1481 memcpy (p, "abcd ", 7);
1482 call if the latter can be stored by pieces during expansion. */
1485 simplify_builtin_call (gimple_stmt_iterator
*gsi_p
, tree callee2
)
1487 gimple stmt1
, stmt2
= gsi_stmt (*gsi_p
);
1488 tree vuse
= gimple_vuse (stmt2
);
1491 stmt1
= SSA_NAME_DEF_STMT (vuse
);
1493 switch (DECL_FUNCTION_CODE (callee2
))
1495 case BUILT_IN_MEMSET
:
1496 if (gimple_call_num_args (stmt2
) != 3
1497 || gimple_call_lhs (stmt2
)
1499 || BITS_PER_UNIT
!= 8)
1504 tree ptr1
, src1
, str1
, off1
, len1
, lhs1
;
1505 tree ptr2
= gimple_call_arg (stmt2
, 0);
1506 tree val2
= gimple_call_arg (stmt2
, 1);
1507 tree len2
= gimple_call_arg (stmt2
, 2);
1508 tree diff
, vdef
, new_str_cst
;
1510 unsigned int ptr1_align
;
1511 unsigned HOST_WIDE_INT src_len
;
1513 use_operand_p use_p
;
1515 if (!host_integerp (val2
, 0)
1516 || !host_integerp (len2
, 1))
1518 if (is_gimple_call (stmt1
))
1520 /* If first stmt is a call, it needs to be memcpy
1521 or mempcpy, with string literal as second argument and
1523 callee1
= gimple_call_fndecl (stmt1
);
1524 if (callee1
== NULL_TREE
1525 || DECL_BUILT_IN_CLASS (callee1
) != BUILT_IN_NORMAL
1526 || gimple_call_num_args (stmt1
) != 3)
1528 if (DECL_FUNCTION_CODE (callee1
) != BUILT_IN_MEMCPY
1529 && DECL_FUNCTION_CODE (callee1
) != BUILT_IN_MEMPCPY
)
1531 ptr1
= gimple_call_arg (stmt1
, 0);
1532 src1
= gimple_call_arg (stmt1
, 1);
1533 len1
= gimple_call_arg (stmt1
, 2);
1534 lhs1
= gimple_call_lhs (stmt1
);
1535 if (!host_integerp (len1
, 1))
1537 str1
= string_constant (src1
, &off1
);
1538 if (str1
== NULL_TREE
)
1540 if (!host_integerp (off1
, 1)
1541 || compare_tree_int (off1
, TREE_STRING_LENGTH (str1
) - 1) > 0
1542 || compare_tree_int (len1
, TREE_STRING_LENGTH (str1
)
1543 - tree_low_cst (off1
, 1)) > 0
1544 || TREE_CODE (TREE_TYPE (str1
)) != ARRAY_TYPE
1545 || TYPE_MODE (TREE_TYPE (TREE_TYPE (str1
)))
1546 != TYPE_MODE (char_type_node
))
1549 else if (gimple_assign_single_p (stmt1
))
1551 /* Otherwise look for length 1 memcpy optimized into
1553 ptr1
= gimple_assign_lhs (stmt1
);
1554 src1
= gimple_assign_rhs1 (stmt1
);
1555 if (TREE_CODE (ptr1
) != MEM_REF
1556 || TYPE_MODE (TREE_TYPE (ptr1
)) != TYPE_MODE (char_type_node
)
1557 || !host_integerp (src1
, 0))
1559 ptr1
= build_fold_addr_expr (ptr1
);
1560 callee1
= NULL_TREE
;
1561 len1
= size_one_node
;
1563 off1
= size_zero_node
;
1569 diff
= constant_pointer_difference (ptr1
, ptr2
);
1570 if (diff
== NULL
&& lhs1
!= NULL
)
1572 diff
= constant_pointer_difference (lhs1
, ptr2
);
1573 if (DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
1575 diff
= size_binop (PLUS_EXPR
, diff
,
1576 fold_convert (sizetype
, len1
));
1578 /* If the difference between the second and first destination pointer
1579 is not constant, or is bigger than memcpy length, bail out. */
1581 || !host_integerp (diff
, 1)
1582 || tree_int_cst_lt (len1
, diff
))
1585 /* Use maximum of difference plus memset length and memcpy length
1586 as the new memcpy length, if it is too big, bail out. */
1587 src_len
= tree_low_cst (diff
, 1);
1588 src_len
+= tree_low_cst (len2
, 1);
1589 if (src_len
< (unsigned HOST_WIDE_INT
) tree_low_cst (len1
, 1))
1590 src_len
= tree_low_cst (len1
, 1);
1594 /* If mempcpy value is used elsewhere, bail out, as mempcpy
1595 with bigger length will return different result. */
1596 if (lhs1
!= NULL_TREE
1597 && DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
1598 && (TREE_CODE (lhs1
) != SSA_NAME
1599 || !single_imm_use (lhs1
, &use_p
, &use_stmt
)
1600 || use_stmt
!= stmt2
))
1603 /* If anything reads memory in between memcpy and memset
1604 call, the modified memcpy call might change it. */
1605 vdef
= gimple_vdef (stmt1
);
1607 && (!single_imm_use (vdef
, &use_p
, &use_stmt
)
1608 || use_stmt
!= stmt2
))
1611 ptr1_align
= get_pointer_alignment (ptr1
);
1612 /* Construct the new source string literal. */
1613 src_buf
= XALLOCAVEC (char, src_len
+ 1);
1616 TREE_STRING_POINTER (str1
) + tree_low_cst (off1
, 1),
1617 tree_low_cst (len1
, 1));
1619 src_buf
[0] = tree_low_cst (src1
, 0);
1620 memset (src_buf
+ tree_low_cst (diff
, 1),
1621 tree_low_cst (val2
, 0), tree_low_cst (len2
, 1));
1622 src_buf
[src_len
] = '\0';
1623 /* Neither builtin_strncpy_read_str nor builtin_memcpy_read_str
1624 handle embedded '\0's. */
1625 if (strlen (src_buf
) != src_len
)
1627 rtl_profile_for_bb (gimple_bb (stmt2
));
1628 /* If the new memcpy wouldn't be emitted by storing the literal
1629 by pieces, this optimization might enlarge .rodata too much,
1630 as commonly used string literals couldn't be shared any
1632 if (!can_store_by_pieces (src_len
,
1633 builtin_strncpy_read_str
,
1634 src_buf
, ptr1_align
, false))
1637 new_str_cst
= build_string_literal (src_len
, src_buf
);
1640 /* If STMT1 is a mem{,p}cpy call, adjust it and remove
1642 if (lhs1
&& DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
)
1643 gimple_call_set_lhs (stmt1
, NULL_TREE
);
1644 gimple_call_set_arg (stmt1
, 1, new_str_cst
);
1645 gimple_call_set_arg (stmt1
, 2,
1646 build_int_cst (TREE_TYPE (len1
), src_len
));
1647 update_stmt (stmt1
);
1648 unlink_stmt_vdef (stmt2
);
1649 gsi_remove (gsi_p
, true);
1650 release_defs (stmt2
);
1651 if (lhs1
&& DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
)
1652 release_ssa_name (lhs1
);
1657 /* Otherwise, if STMT1 is length 1 memcpy optimized into
1658 assignment, remove STMT1 and change memset call into
1660 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt1
);
1662 if (!is_gimple_val (ptr1
))
1663 ptr1
= force_gimple_operand_gsi (gsi_p
, ptr1
, true, NULL_TREE
,
1664 true, GSI_SAME_STMT
);
1665 gimple_call_set_fndecl (stmt2
,
1666 builtin_decl_explicit (BUILT_IN_MEMCPY
));
1667 gimple_call_set_arg (stmt2
, 0, ptr1
);
1668 gimple_call_set_arg (stmt2
, 1, new_str_cst
);
1669 gimple_call_set_arg (stmt2
, 2,
1670 build_int_cst (TREE_TYPE (len2
), src_len
));
1671 unlink_stmt_vdef (stmt1
);
1672 gsi_remove (&gsi
, true);
1673 release_defs (stmt1
);
1674 update_stmt (stmt2
);
1685 /* Checks if expression has type of one-bit precision, or is a known
1686 truth-valued expression. */
1688 truth_valued_ssa_name (tree name
)
1691 tree type
= TREE_TYPE (name
);
1693 if (!INTEGRAL_TYPE_P (type
))
1695 /* Don't check here for BOOLEAN_TYPE as the precision isn't
1696 necessarily one and so ~X is not equal to !X. */
1697 if (TYPE_PRECISION (type
) == 1)
1699 def
= SSA_NAME_DEF_STMT (name
);
1700 if (is_gimple_assign (def
))
1701 return truth_value_p (gimple_assign_rhs_code (def
));
1705 /* Helper routine for simplify_bitwise_binary_1 function.
1706 Return for the SSA name NAME the expression X if it mets condition
1707 NAME = !X. Otherwise return NULL_TREE.
1708 Detected patterns for NAME = !X are:
1709 !X and X == 0 for X with integral type.
1710 X ^ 1, X != 1,or ~X for X with integral type with precision of one. */
1712 lookup_logical_inverted_value (tree name
)
1715 enum tree_code code
;
1718 /* If name has none-intergal type, or isn't a SSA_NAME, then
1720 if (TREE_CODE (name
) != SSA_NAME
1721 || !INTEGRAL_TYPE_P (TREE_TYPE (name
)))
1723 def
= SSA_NAME_DEF_STMT (name
);
1724 if (!is_gimple_assign (def
))
1727 code
= gimple_assign_rhs_code (def
);
1728 op1
= gimple_assign_rhs1 (def
);
1731 /* Get for EQ_EXPR or BIT_XOR_EXPR operation the second operand.
1732 If CODE isn't an EQ_EXPR, BIT_XOR_EXPR, or BIT_NOT_EXPR, then return. */
1733 if (code
== EQ_EXPR
|| code
== NE_EXPR
1734 || code
== BIT_XOR_EXPR
)
1735 op2
= gimple_assign_rhs2 (def
);
1740 if (truth_valued_ssa_name (name
))
1744 /* Check if we have X == 0 and X has an integral type. */
1745 if (!INTEGRAL_TYPE_P (TREE_TYPE (op1
)))
1747 if (integer_zerop (op2
))
1751 /* Check if we have X != 1 and X is a truth-valued. */
1752 if (!INTEGRAL_TYPE_P (TREE_TYPE (op1
)))
1754 if (integer_onep (op2
) && truth_valued_ssa_name (op1
))
1758 /* Check if we have X ^ 1 and X is truth valued. */
1759 if (integer_onep (op2
) && truth_valued_ssa_name (op1
))
1769 /* Optimize ARG1 CODE ARG2 to a constant for bitwise binary
1770 operations CODE, if one operand has the logically inverted
1771 value of the other. */
1773 simplify_bitwise_binary_1 (enum tree_code code
, tree type
,
1774 tree arg1
, tree arg2
)
1778 /* If CODE isn't a bitwise binary operation, return NULL_TREE. */
1779 if (code
!= BIT_AND_EXPR
&& code
!= BIT_IOR_EXPR
1780 && code
!= BIT_XOR_EXPR
)
1783 /* First check if operands ARG1 and ARG2 are equal. If so
1784 return NULL_TREE as this optimization is handled fold_stmt. */
1787 /* See if we have in arguments logical-not patterns. */
1788 if (((anot
= lookup_logical_inverted_value (arg1
)) == NULL_TREE
1790 && ((anot
= lookup_logical_inverted_value (arg2
)) == NULL_TREE
1795 if (code
== BIT_AND_EXPR
)
1796 return fold_convert (type
, integer_zero_node
);
1797 /* X | !X -> 1 and X ^ !X -> 1, if X is truth-valued. */
1798 if (truth_valued_ssa_name (anot
))
1799 return fold_convert (type
, integer_one_node
);
1801 /* ??? Otherwise result is (X != 0 ? X : 1). not handled. */
1805 /* Given a ssa_name in NAME see if it was defined by an assignment and
1806 set CODE to be the code and ARG1 to the first operand on the rhs and ARG2
1807 to the second operand on the rhs. */
1810 defcodefor_name (tree name
, enum tree_code
*code
, tree
*arg1
, tree
*arg2
)
1813 enum tree_code code1
;
1817 enum gimple_rhs_class grhs_class
;
1819 code1
= TREE_CODE (name
);
1822 grhs_class
= get_gimple_rhs_class (code1
);
1824 if (code1
== SSA_NAME
)
1826 def
= SSA_NAME_DEF_STMT (name
);
1828 if (def
&& is_gimple_assign (def
)
1829 && can_propagate_from (def
))
1831 code1
= gimple_assign_rhs_code (def
);
1832 arg11
= gimple_assign_rhs1 (def
);
1833 arg21
= gimple_assign_rhs2 (def
);
1834 arg31
= gimple_assign_rhs2 (def
);
1837 else if (grhs_class
== GIMPLE_TERNARY_RHS
1838 || GIMPLE_BINARY_RHS
1840 || GIMPLE_SINGLE_RHS
)
1841 extract_ops_from_tree_1 (name
, &code1
, &arg11
, &arg21
, &arg31
);
1847 /* Ignore arg3 currently. */
1850 /* Return true if a conversion of an operand from type FROM to type TO
1851 should be applied after performing the operation instead. */
1854 hoist_conversion_for_bitop_p (tree to
, tree from
)
1856 /* That's a good idea if the conversion widens the operand, thus
1857 after hoisting the conversion the operation will be narrower. */
1858 if (TYPE_PRECISION (from
) < TYPE_PRECISION (to
))
1861 /* It's also a good idea if the conversion is to a non-integer mode. */
1862 if (GET_MODE_CLASS (TYPE_MODE (to
)) != MODE_INT
)
1865 /* Or if the precision of TO is not the same as the precision
1867 if (TYPE_PRECISION (to
) != GET_MODE_PRECISION (TYPE_MODE (to
)))
1873 /* Simplify bitwise binary operations.
1874 Return true if a transformation applied, otherwise return false. */
1877 simplify_bitwise_binary (gimple_stmt_iterator
*gsi
)
1879 gimple stmt
= gsi_stmt (*gsi
);
1880 tree arg1
= gimple_assign_rhs1 (stmt
);
1881 tree arg2
= gimple_assign_rhs2 (stmt
);
1882 enum tree_code code
= gimple_assign_rhs_code (stmt
);
1884 tree def1_arg1
, def1_arg2
, def2_arg1
, def2_arg2
;
1885 enum tree_code def1_code
, def2_code
;
1887 defcodefor_name (arg1
, &def1_code
, &def1_arg1
, &def1_arg2
);
1888 defcodefor_name (arg2
, &def2_code
, &def2_arg1
, &def2_arg2
);
1890 /* Try to fold (type) X op CST -> (type) (X op ((type-x) CST))
1892 if (TREE_CODE (arg2
) == INTEGER_CST
1893 && CONVERT_EXPR_CODE_P (def1_code
)
1894 && hoist_conversion_for_bitop_p (TREE_TYPE (arg1
), TREE_TYPE (def1_arg1
))
1895 && INTEGRAL_TYPE_P (TREE_TYPE (def1_arg1
))
1896 && int_fits_type_p (arg2
, TREE_TYPE (def1_arg1
)))
1899 tree tem
= make_ssa_name (TREE_TYPE (def1_arg1
), NULL
);
1901 gimple_build_assign_with_ops (code
, tem
, def1_arg1
,
1902 fold_convert_loc (gimple_location (stmt
),
1903 TREE_TYPE (def1_arg1
),
1905 gimple_set_location (newop
, gimple_location (stmt
));
1906 gsi_insert_before (gsi
, newop
, GSI_SAME_STMT
);
1907 gimple_assign_set_rhs_with_ops_1 (gsi
, NOP_EXPR
,
1908 tem
, NULL_TREE
, NULL_TREE
);
1909 update_stmt (gsi_stmt (*gsi
));
1913 /* For bitwise binary operations apply operand conversions to the
1914 binary operation result instead of to the operands. This allows
1915 to combine successive conversions and bitwise binary operations. */
1916 if (CONVERT_EXPR_CODE_P (def1_code
)
1917 && CONVERT_EXPR_CODE_P (def2_code
)
1918 && types_compatible_p (TREE_TYPE (def1_arg1
), TREE_TYPE (def2_arg1
))
1919 && hoist_conversion_for_bitop_p (TREE_TYPE (arg1
), TREE_TYPE (def1_arg1
)))
1922 tree tem
= make_ssa_name (TREE_TYPE (def1_arg1
), NULL
);
1923 newop
= gimple_build_assign_with_ops (code
, tem
, def1_arg1
, def2_arg1
);
1924 gimple_set_location (newop
, gimple_location (stmt
));
1925 gsi_insert_before (gsi
, newop
, GSI_SAME_STMT
);
1926 gimple_assign_set_rhs_with_ops_1 (gsi
, NOP_EXPR
,
1927 tem
, NULL_TREE
, NULL_TREE
);
1928 update_stmt (gsi_stmt (*gsi
));
1933 /* Simplify (A & B) OP0 (C & B) to (A OP0 C) & B. */
1934 if (def1_code
== def2_code
1935 && def1_code
== BIT_AND_EXPR
1936 && operand_equal_for_phi_arg_p (def1_arg2
,
1942 tree inner
= fold_build2 (code
, TREE_TYPE (arg2
), a
, c
);
1943 /* If A OP0 C (this usually means C is the same as A) is 0
1944 then fold it down correctly. */
1945 if (integer_zerop (inner
))
1947 gimple_assign_set_rhs_from_tree (gsi
, inner
);
1951 /* If A OP0 C (this usually means C is the same as A) is a ssa_name
1952 then fold it down correctly. */
1953 else if (TREE_CODE (inner
) == SSA_NAME
)
1955 tree outer
= fold_build2 (def1_code
, TREE_TYPE (inner
),
1957 gimple_assign_set_rhs_from_tree (gsi
, outer
);
1965 tem
= make_ssa_name (TREE_TYPE (arg2
), NULL
);
1966 newop
= gimple_build_assign_with_ops (code
, tem
, a
, c
);
1967 gimple_set_location (newop
, gimple_location (stmt
));
1968 /* Make sure to re-process the new stmt as it's walking upwards. */
1969 gsi_insert_before (gsi
, newop
, GSI_NEW_STMT
);
1970 gimple_assign_set_rhs1 (stmt
, tem
);
1971 gimple_assign_set_rhs2 (stmt
, b
);
1972 gimple_assign_set_rhs_code (stmt
, def1_code
);
1978 /* (a | CST1) & CST2 -> (a & CST2) | (CST1 & CST2). */
1979 if (code
== BIT_AND_EXPR
1980 && def1_code
== BIT_IOR_EXPR
1981 && TREE_CODE (arg2
) == INTEGER_CST
1982 && TREE_CODE (def1_arg2
) == INTEGER_CST
)
1984 tree cst
= fold_build2 (BIT_AND_EXPR
, TREE_TYPE (arg2
),
1988 if (integer_zerop (cst
))
1990 gimple_assign_set_rhs1 (stmt
, def1_arg1
);
1994 tem
= make_ssa_name (TREE_TYPE (arg2
), NULL
);
1995 newop
= gimple_build_assign_with_ops (BIT_AND_EXPR
,
1996 tem
, def1_arg1
, arg2
);
1997 gimple_set_location (newop
, gimple_location (stmt
));
1998 /* Make sure to re-process the new stmt as it's walking upwards. */
1999 gsi_insert_before (gsi
, newop
, GSI_NEW_STMT
);
2000 gimple_assign_set_rhs1 (stmt
, tem
);
2001 gimple_assign_set_rhs2 (stmt
, cst
);
2002 gimple_assign_set_rhs_code (stmt
, BIT_IOR_EXPR
);
2007 /* Combine successive equal operations with constants. */
2008 if ((code
== BIT_AND_EXPR
2009 || code
== BIT_IOR_EXPR
2010 || code
== BIT_XOR_EXPR
)
2011 && def1_code
== code
2012 && TREE_CODE (arg2
) == INTEGER_CST
2013 && TREE_CODE (def1_arg2
) == INTEGER_CST
)
2015 tree cst
= fold_build2 (code
, TREE_TYPE (arg2
),
2017 gimple_assign_set_rhs1 (stmt
, def1_arg1
);
2018 gimple_assign_set_rhs2 (stmt
, cst
);
2023 /* Canonicalize X ^ ~0 to ~X. */
2024 if (code
== BIT_XOR_EXPR
2025 && TREE_CODE (arg2
) == INTEGER_CST
2026 && integer_all_onesp (arg2
))
2028 gimple_assign_set_rhs_with_ops (gsi
, BIT_NOT_EXPR
, arg1
, NULL_TREE
);
2029 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2034 /* Try simple folding for X op !X, and X op X. */
2035 res
= simplify_bitwise_binary_1 (code
, TREE_TYPE (arg1
), arg1
, arg2
);
2036 if (res
!= NULL_TREE
)
2038 gimple_assign_set_rhs_from_tree (gsi
, res
);
2039 update_stmt (gsi_stmt (*gsi
));
2043 if (code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
)
2045 enum tree_code ocode
= code
== BIT_AND_EXPR
? BIT_IOR_EXPR
: BIT_AND_EXPR
;
2046 if (def1_code
== ocode
)
2049 enum tree_code coden
;
2051 /* ( X | Y) & X -> X */
2052 /* ( X & Y) | X -> X */
2056 gimple_assign_set_rhs_from_tree (gsi
, x
);
2057 update_stmt (gsi_stmt (*gsi
));
2061 defcodefor_name (def1_arg1
, &coden
, &a1
, &a2
);
2062 /* (~X | Y) & X -> X & Y */
2063 /* (~X & Y) | X -> X | Y */
2064 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2066 gimple_assign_set_rhs_with_ops (gsi
, code
,
2068 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2072 defcodefor_name (def1_arg2
, &coden
, &a1
, &a2
);
2073 /* (Y | ~X) & X -> X & Y */
2074 /* (Y & ~X) | X -> X | Y */
2075 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2077 gimple_assign_set_rhs_with_ops (gsi
, code
,
2079 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2084 if (def2_code
== ocode
)
2086 enum tree_code coden
;
2089 /* X & ( X | Y) -> X */
2090 /* X | ( X & Y) -> X */
2094 gimple_assign_set_rhs_from_tree (gsi
, x
);
2095 update_stmt (gsi_stmt (*gsi
));
2098 defcodefor_name (def2_arg1
, &coden
, &a1
, NULL
);
2099 /* (~X | Y) & X -> X & Y */
2100 /* (~X & Y) | X -> X | Y */
2101 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2103 gimple_assign_set_rhs_with_ops (gsi
, code
,
2105 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2109 defcodefor_name (def2_arg2
, &coden
, &a1
, NULL
);
2110 /* (Y | ~X) & X -> X & Y */
2111 /* (Y & ~X) | X -> X | Y */
2112 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2114 gimple_assign_set_rhs_with_ops (gsi
, code
,
2116 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2127 /* Perform re-associations of the plus or minus statement STMT that are
2128 always permitted. Returns true if the CFG was changed. */
2131 associate_plusminus (gimple_stmt_iterator
*gsi
)
2133 gimple stmt
= gsi_stmt (*gsi
);
2134 tree rhs1
= gimple_assign_rhs1 (stmt
);
2135 tree rhs2
= gimple_assign_rhs2 (stmt
);
2136 enum tree_code code
= gimple_assign_rhs_code (stmt
);
2139 /* We can't reassociate at all for saturating types. */
2140 if (TYPE_SATURATING (TREE_TYPE (rhs1
)))
2143 /* First contract negates. */
2148 /* A +- (-B) -> A -+ B. */
2149 if (TREE_CODE (rhs2
) == SSA_NAME
)
2151 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2152 if (is_gimple_assign (def_stmt
)
2153 && gimple_assign_rhs_code (def_stmt
) == NEGATE_EXPR
2154 && can_propagate_from (def_stmt
))
2156 code
= (code
== MINUS_EXPR
) ? PLUS_EXPR
: MINUS_EXPR
;
2157 gimple_assign_set_rhs_code (stmt
, code
);
2158 rhs2
= gimple_assign_rhs1 (def_stmt
);
2159 gimple_assign_set_rhs2 (stmt
, rhs2
);
2160 gimple_set_modified (stmt
, true);
2165 /* (-A) + B -> B - A. */
2166 if (TREE_CODE (rhs1
) == SSA_NAME
2167 && code
== PLUS_EXPR
)
2169 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2170 if (is_gimple_assign (def_stmt
)
2171 && gimple_assign_rhs_code (def_stmt
) == NEGATE_EXPR
2172 && can_propagate_from (def_stmt
))
2175 gimple_assign_set_rhs_code (stmt
, code
);
2177 gimple_assign_set_rhs1 (stmt
, rhs1
);
2178 rhs2
= gimple_assign_rhs1 (def_stmt
);
2179 gimple_assign_set_rhs2 (stmt
, rhs2
);
2180 gimple_set_modified (stmt
, true);
2187 /* We can't reassociate floating-point or fixed-point plus or minus
2188 because of saturation to +-Inf. */
2189 if (FLOAT_TYPE_P (TREE_TYPE (rhs1
))
2190 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1
)))
2193 /* Second match patterns that allow contracting a plus-minus pair
2194 irrespective of overflow issues.
2196 (A +- B) - A -> +- B
2198 (CST +- A) +- CST -> CST +- A
2199 (A + CST) +- CST -> A + CST
2202 A - (A +- B) -> -+ B
2203 A +- (B +- A) -> +- B
2204 CST +- (CST +- A) -> CST +- A
2205 CST +- (A +- CST) -> CST +- A
2208 via commutating the addition and contracting operations to zero
2209 by reassociation. */
2211 if (TREE_CODE (rhs1
) == SSA_NAME
)
2213 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2214 if (is_gimple_assign (def_stmt
) && can_propagate_from (def_stmt
))
2216 enum tree_code def_code
= gimple_assign_rhs_code (def_stmt
);
2217 if (def_code
== PLUS_EXPR
2218 || def_code
== MINUS_EXPR
)
2220 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2221 tree def_rhs2
= gimple_assign_rhs2 (def_stmt
);
2222 if (operand_equal_p (def_rhs1
, rhs2
, 0)
2223 && code
== MINUS_EXPR
)
2225 /* (A +- B) - A -> +- B. */
2226 code
= ((def_code
== PLUS_EXPR
)
2227 ? TREE_CODE (def_rhs2
) : NEGATE_EXPR
);
2230 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2231 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2232 gimple_set_modified (stmt
, true);
2234 else if (operand_equal_p (def_rhs2
, rhs2
, 0)
2235 && code
!= def_code
)
2237 /* (A +- B) -+ B -> A. */
2238 code
= TREE_CODE (def_rhs1
);
2241 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2242 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2243 gimple_set_modified (stmt
, true);
2245 else if (TREE_CODE (rhs2
) == INTEGER_CST
2246 && TREE_CODE (def_rhs1
) == INTEGER_CST
)
2248 /* (CST +- A) +- CST -> CST +- A. */
2249 tree cst
= fold_binary (code
, TREE_TYPE (rhs1
),
2251 if (cst
&& !TREE_OVERFLOW (cst
))
2254 gimple_assign_set_rhs_code (stmt
, code
);
2256 gimple_assign_set_rhs1 (stmt
, rhs1
);
2258 gimple_assign_set_rhs2 (stmt
, rhs2
);
2259 gimple_set_modified (stmt
, true);
2262 else if (TREE_CODE (rhs2
) == INTEGER_CST
2263 && TREE_CODE (def_rhs2
) == INTEGER_CST
2264 && def_code
== PLUS_EXPR
)
2266 /* (A + CST) +- CST -> A + CST. */
2267 tree cst
= fold_binary (code
, TREE_TYPE (rhs1
),
2269 if (cst
&& !TREE_OVERFLOW (cst
))
2272 gimple_assign_set_rhs_code (stmt
, code
);
2274 gimple_assign_set_rhs1 (stmt
, rhs1
);
2276 gimple_assign_set_rhs2 (stmt
, rhs2
);
2277 gimple_set_modified (stmt
, true);
2281 else if (def_code
== BIT_NOT_EXPR
2282 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
2284 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2285 if (code
== PLUS_EXPR
2286 && operand_equal_p (def_rhs1
, rhs2
, 0))
2290 rhs1
= build_int_cst_type (TREE_TYPE (rhs2
), -1);
2292 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2293 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2294 gimple_set_modified (stmt
, true);
2296 else if (code
== PLUS_EXPR
2297 && integer_onep (rhs1
))
2303 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2304 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2305 gimple_set_modified (stmt
, true);
2311 if (rhs2
&& TREE_CODE (rhs2
) == SSA_NAME
)
2313 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2314 if (is_gimple_assign (def_stmt
) && can_propagate_from (def_stmt
))
2316 enum tree_code def_code
= gimple_assign_rhs_code (def_stmt
);
2317 if (def_code
== PLUS_EXPR
2318 || def_code
== MINUS_EXPR
)
2320 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2321 tree def_rhs2
= gimple_assign_rhs2 (def_stmt
);
2322 if (operand_equal_p (def_rhs1
, rhs1
, 0)
2323 && code
== MINUS_EXPR
)
2325 /* A - (A +- B) -> -+ B. */
2326 code
= ((def_code
== PLUS_EXPR
)
2327 ? NEGATE_EXPR
: TREE_CODE (def_rhs2
));
2330 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2331 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2332 gimple_set_modified (stmt
, true);
2334 else if (operand_equal_p (def_rhs2
, rhs1
, 0)
2335 && code
!= def_code
)
2337 /* A +- (B +- A) -> +- B. */
2338 code
= ((code
== PLUS_EXPR
)
2339 ? TREE_CODE (def_rhs1
) : NEGATE_EXPR
);
2342 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2343 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2344 gimple_set_modified (stmt
, true);
2346 else if (TREE_CODE (rhs1
) == INTEGER_CST
2347 && TREE_CODE (def_rhs1
) == INTEGER_CST
)
2349 /* CST +- (CST +- A) -> CST +- A. */
2350 tree cst
= fold_binary (code
, TREE_TYPE (rhs2
),
2352 if (cst
&& !TREE_OVERFLOW (cst
))
2354 code
= (code
== def_code
? PLUS_EXPR
: MINUS_EXPR
);
2355 gimple_assign_set_rhs_code (stmt
, code
);
2357 gimple_assign_set_rhs1 (stmt
, rhs1
);
2359 gimple_assign_set_rhs2 (stmt
, rhs2
);
2360 gimple_set_modified (stmt
, true);
2363 else if (TREE_CODE (rhs1
) == INTEGER_CST
2364 && TREE_CODE (def_rhs2
) == INTEGER_CST
)
2366 /* CST +- (A +- CST) -> CST +- A. */
2367 tree cst
= fold_binary (def_code
== code
2368 ? PLUS_EXPR
: MINUS_EXPR
,
2371 if (cst
&& !TREE_OVERFLOW (cst
))
2374 gimple_assign_set_rhs1 (stmt
, rhs1
);
2376 gimple_assign_set_rhs2 (stmt
, rhs2
);
2377 gimple_set_modified (stmt
, true);
2381 else if (def_code
== BIT_NOT_EXPR
2382 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2
)))
2384 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2385 if (code
== PLUS_EXPR
2386 && operand_equal_p (def_rhs1
, rhs1
, 0))
2390 rhs1
= build_int_cst_type (TREE_TYPE (rhs1
), -1);
2392 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2393 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2394 gimple_set_modified (stmt
, true);
2401 if (gimple_modified_p (stmt
))
2403 fold_stmt_inplace (gsi
);
2405 if (maybe_clean_or_replace_eh_stmt (stmt
, stmt
)
2406 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
2413 /* Associate operands of a POINTER_PLUS_EXPR assignmen at *GSI. Returns
2414 true if anything changed, false otherwise. */
2417 associate_pointerplus (gimple_stmt_iterator
*gsi
)
2419 gimple stmt
= gsi_stmt (*gsi
);
2421 tree ptr
, rhs
, algn
;
2424 tem = (sizetype) ptr;
2428 and produce the simpler and easier to analyze with respect to alignment
2429 ... = ptr & ~algn; */
2430 ptr
= gimple_assign_rhs1 (stmt
);
2431 rhs
= gimple_assign_rhs2 (stmt
);
2432 if (TREE_CODE (rhs
) != SSA_NAME
)
2434 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2435 if (!is_gimple_assign (def_stmt
)
2436 || gimple_assign_rhs_code (def_stmt
) != NEGATE_EXPR
)
2438 rhs
= gimple_assign_rhs1 (def_stmt
);
2439 if (TREE_CODE (rhs
) != SSA_NAME
)
2441 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2442 if (!is_gimple_assign (def_stmt
)
2443 || gimple_assign_rhs_code (def_stmt
) != BIT_AND_EXPR
)
2445 rhs
= gimple_assign_rhs1 (def_stmt
);
2446 algn
= gimple_assign_rhs2 (def_stmt
);
2447 if (TREE_CODE (rhs
) != SSA_NAME
2448 || TREE_CODE (algn
) != INTEGER_CST
)
2450 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2451 if (!is_gimple_assign (def_stmt
)
2452 || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
2454 if (gimple_assign_rhs1 (def_stmt
) != ptr
)
2457 algn
= double_int_to_tree (TREE_TYPE (ptr
), ~tree_to_double_int (algn
));
2458 gimple_assign_set_rhs_with_ops (gsi
, BIT_AND_EXPR
, ptr
, algn
);
2459 fold_stmt_inplace (gsi
);
2465 /* Combine two conversions in a row for the second conversion at *GSI.
2466 Returns 1 if there were any changes made, 2 if cfg-cleanup needs to
2467 run. Else it returns 0. */
2470 combine_conversions (gimple_stmt_iterator
*gsi
)
2472 gimple stmt
= gsi_stmt (*gsi
);
2475 enum tree_code code
= gimple_assign_rhs_code (stmt
);
2476 enum tree_code code2
;
2478 gcc_checking_assert (CONVERT_EXPR_CODE_P (code
)
2479 || code
== FLOAT_EXPR
2480 || code
== FIX_TRUNC_EXPR
);
2482 lhs
= gimple_assign_lhs (stmt
);
2483 op0
= gimple_assign_rhs1 (stmt
);
2484 if (useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (op0
)))
2486 gimple_assign_set_rhs_code (stmt
, TREE_CODE (op0
));
2490 if (TREE_CODE (op0
) != SSA_NAME
)
2493 def_stmt
= SSA_NAME_DEF_STMT (op0
);
2494 if (!is_gimple_assign (def_stmt
))
2497 code2
= gimple_assign_rhs_code (def_stmt
);
2499 if (CONVERT_EXPR_CODE_P (code2
) || code2
== FLOAT_EXPR
)
2501 tree defop0
= gimple_assign_rhs1 (def_stmt
);
2502 tree type
= TREE_TYPE (lhs
);
2503 tree inside_type
= TREE_TYPE (defop0
);
2504 tree inter_type
= TREE_TYPE (op0
);
2505 int inside_int
= INTEGRAL_TYPE_P (inside_type
);
2506 int inside_ptr
= POINTER_TYPE_P (inside_type
);
2507 int inside_float
= FLOAT_TYPE_P (inside_type
);
2508 int inside_vec
= TREE_CODE (inside_type
) == VECTOR_TYPE
;
2509 unsigned int inside_prec
= TYPE_PRECISION (inside_type
);
2510 int inside_unsignedp
= TYPE_UNSIGNED (inside_type
);
2511 int inter_int
= INTEGRAL_TYPE_P (inter_type
);
2512 int inter_ptr
= POINTER_TYPE_P (inter_type
);
2513 int inter_float
= FLOAT_TYPE_P (inter_type
);
2514 int inter_vec
= TREE_CODE (inter_type
) == VECTOR_TYPE
;
2515 unsigned int inter_prec
= TYPE_PRECISION (inter_type
);
2516 int inter_unsignedp
= TYPE_UNSIGNED (inter_type
);
2517 int final_int
= INTEGRAL_TYPE_P (type
);
2518 int final_ptr
= POINTER_TYPE_P (type
);
2519 int final_float
= FLOAT_TYPE_P (type
);
2520 int final_vec
= TREE_CODE (type
) == VECTOR_TYPE
;
2521 unsigned int final_prec
= TYPE_PRECISION (type
);
2522 int final_unsignedp
= TYPE_UNSIGNED (type
);
2524 /* Don't propagate ssa names that occur in abnormal phis. */
2525 if (TREE_CODE (defop0
) == SSA_NAME
2526 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (defop0
))
2529 /* In addition to the cases of two conversions in a row
2530 handled below, if we are converting something to its own
2531 type via an object of identical or wider precision, neither
2532 conversion is needed. */
2533 if (useless_type_conversion_p (type
, inside_type
)
2534 && (((inter_int
|| inter_ptr
) && final_int
)
2535 || (inter_float
&& final_float
))
2536 && inter_prec
>= final_prec
)
2538 gimple_assign_set_rhs1 (stmt
, unshare_expr (defop0
));
2539 gimple_assign_set_rhs_code (stmt
, TREE_CODE (defop0
));
2541 return remove_prop_source_from_use (op0
) ? 2 : 1;
2544 /* Likewise, if the intermediate and initial types are either both
2545 float or both integer, we don't need the middle conversion if the
2546 former is wider than the latter and doesn't change the signedness
2547 (for integers). Avoid this if the final type is a pointer since
2548 then we sometimes need the middle conversion. Likewise if the
2549 final type has a precision not equal to the size of its mode. */
2550 if (((inter_int
&& inside_int
)
2551 || (inter_float
&& inside_float
)
2552 || (inter_vec
&& inside_vec
))
2553 && inter_prec
>= inside_prec
2554 && (inter_float
|| inter_vec
2555 || inter_unsignedp
== inside_unsignedp
)
2556 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
2557 && TYPE_MODE (type
) == TYPE_MODE (inter_type
))
2559 && (! final_vec
|| inter_prec
== inside_prec
))
2561 gimple_assign_set_rhs1 (stmt
, defop0
);
2563 return remove_prop_source_from_use (op0
) ? 2 : 1;
2566 /* If we have a sign-extension of a zero-extended value, we can
2567 replace that by a single zero-extension. Likewise if the
2568 final conversion does not change precision we can drop the
2569 intermediate conversion. */
2570 if (inside_int
&& inter_int
&& final_int
2571 && ((inside_prec
< inter_prec
&& inter_prec
< final_prec
2572 && inside_unsignedp
&& !inter_unsignedp
)
2573 || final_prec
== inter_prec
))
2575 gimple_assign_set_rhs1 (stmt
, defop0
);
2577 return remove_prop_source_from_use (op0
) ? 2 : 1;
2580 /* Two conversions in a row are not needed unless:
2581 - some conversion is floating-point (overstrict for now), or
2582 - some conversion is a vector (overstrict for now), or
2583 - the intermediate type is narrower than both initial and
2585 - the intermediate type and innermost type differ in signedness,
2586 and the outermost type is wider than the intermediate, or
2587 - the initial type is a pointer type and the precisions of the
2588 intermediate and final types differ, or
2589 - the final type is a pointer type and the precisions of the
2590 initial and intermediate types differ. */
2591 if (! inside_float
&& ! inter_float
&& ! final_float
2592 && ! inside_vec
&& ! inter_vec
&& ! final_vec
2593 && (inter_prec
>= inside_prec
|| inter_prec
>= final_prec
)
2594 && ! (inside_int
&& inter_int
2595 && inter_unsignedp
!= inside_unsignedp
2596 && inter_prec
< final_prec
)
2597 && ((inter_unsignedp
&& inter_prec
> inside_prec
)
2598 == (final_unsignedp
&& final_prec
> inter_prec
))
2599 && ! (inside_ptr
&& inter_prec
!= final_prec
)
2600 && ! (final_ptr
&& inside_prec
!= inter_prec
)
2601 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
2602 && TYPE_MODE (type
) == TYPE_MODE (inter_type
)))
2604 gimple_assign_set_rhs1 (stmt
, defop0
);
2606 return remove_prop_source_from_use (op0
) ? 2 : 1;
2609 /* A truncation to an unsigned type should be canonicalized as
2610 bitwise and of a mask. */
2611 if (final_int
&& inter_int
&& inside_int
2612 && final_prec
== inside_prec
2613 && final_prec
> inter_prec
2617 tem
= fold_build2 (BIT_AND_EXPR
, inside_type
,
2620 (inside_type
, double_int::mask (inter_prec
)));
2621 if (!useless_type_conversion_p (type
, inside_type
))
2623 tem
= force_gimple_operand_gsi (gsi
, tem
, true, NULL_TREE
, true,
2625 gimple_assign_set_rhs1 (stmt
, tem
);
2628 gimple_assign_set_rhs_from_tree (gsi
, tem
);
2629 update_stmt (gsi_stmt (*gsi
));
2633 /* If we are converting an integer to a floating-point that can
2634 represent it exactly and back to an integer, we can skip the
2635 floating-point conversion. */
2636 if (inside_int
&& inter_float
&& final_int
&&
2637 (unsigned) significand_size (TYPE_MODE (inter_type
))
2638 >= inside_prec
- !inside_unsignedp
)
2640 if (useless_type_conversion_p (type
, inside_type
))
2642 gimple_assign_set_rhs1 (stmt
, unshare_expr (defop0
));
2643 gimple_assign_set_rhs_code (stmt
, TREE_CODE (defop0
));
2645 return remove_prop_source_from_use (op0
) ? 2 : 1;
2649 gimple_assign_set_rhs1 (stmt
, defop0
);
2650 gimple_assign_set_rhs_code (stmt
, CONVERT_EXPR
);
2652 return remove_prop_source_from_use (op0
) ? 2 : 1;
2660 /* Combine an element access with a shuffle. Returns true if there were
2661 any changes made, else it returns false. */
2664 simplify_bitfield_ref (gimple_stmt_iterator
*gsi
)
2666 gimple stmt
= gsi_stmt (*gsi
);
2668 tree op
, op0
, op1
, op2
;
2670 unsigned idx
, n
, size
;
2671 enum tree_code code
;
2673 op
= gimple_assign_rhs1 (stmt
);
2674 gcc_checking_assert (TREE_CODE (op
) == BIT_FIELD_REF
);
2676 op0
= TREE_OPERAND (op
, 0);
2677 if (TREE_CODE (op0
) != SSA_NAME
2678 || TREE_CODE (TREE_TYPE (op0
)) != VECTOR_TYPE
)
2681 def_stmt
= get_prop_source_stmt (op0
, false, NULL
);
2682 if (!def_stmt
|| !can_propagate_from (def_stmt
))
2685 op1
= TREE_OPERAND (op
, 1);
2686 op2
= TREE_OPERAND (op
, 2);
2687 code
= gimple_assign_rhs_code (def_stmt
);
2689 if (code
== CONSTRUCTOR
)
2691 tree tem
= fold_ternary (BIT_FIELD_REF
, TREE_TYPE (op
),
2692 gimple_assign_rhs1 (def_stmt
), op1
, op2
);
2693 if (!tem
|| !valid_gimple_rhs_p (tem
))
2695 gimple_assign_set_rhs_from_tree (gsi
, tem
);
2696 update_stmt (gsi_stmt (*gsi
));
2700 elem_type
= TREE_TYPE (TREE_TYPE (op0
));
2701 if (TREE_TYPE (op
) != elem_type
)
2704 size
= TREE_INT_CST_LOW (TYPE_SIZE (elem_type
));
2705 n
= TREE_INT_CST_LOW (op1
) / size
;
2708 idx
= TREE_INT_CST_LOW (op2
) / size
;
2710 if (code
== VEC_PERM_EXPR
)
2712 tree p
, m
, index
, tem
;
2714 m
= gimple_assign_rhs3 (def_stmt
);
2715 if (TREE_CODE (m
) != VECTOR_CST
)
2717 nelts
= VECTOR_CST_NELTS (m
);
2718 idx
= TREE_INT_CST_LOW (VECTOR_CST_ELT (m
, idx
));
2722 p
= gimple_assign_rhs1 (def_stmt
);
2726 p
= gimple_assign_rhs2 (def_stmt
);
2729 index
= build_int_cst (TREE_TYPE (TREE_TYPE (m
)), idx
* size
);
2730 tem
= build3 (BIT_FIELD_REF
, TREE_TYPE (op
),
2731 unshare_expr (p
), op1
, index
);
2732 gimple_assign_set_rhs1 (stmt
, tem
);
2734 update_stmt (gsi_stmt (*gsi
));
2741 /* Determine whether applying the 2 permutations (mask1 then mask2)
2742 gives back one of the input. */
2745 is_combined_permutation_identity (tree mask1
, tree mask2
)
2748 unsigned int nelts
, i
, j
;
2749 bool maybe_identity1
= true;
2750 bool maybe_identity2
= true;
2752 gcc_checking_assert (TREE_CODE (mask1
) == VECTOR_CST
2753 && TREE_CODE (mask2
) == VECTOR_CST
);
2754 mask
= fold_ternary (VEC_PERM_EXPR
, TREE_TYPE (mask1
), mask1
, mask1
, mask2
);
2755 gcc_assert (TREE_CODE (mask
) == VECTOR_CST
);
2757 nelts
= VECTOR_CST_NELTS (mask
);
2758 for (i
= 0; i
< nelts
; i
++)
2760 tree val
= VECTOR_CST_ELT (mask
, i
);
2761 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
2762 j
= TREE_INT_CST_LOW (val
) & (2 * nelts
- 1);
2764 maybe_identity2
= false;
2765 else if (j
== i
+ nelts
)
2766 maybe_identity1
= false;
2770 return maybe_identity1
? 1 : maybe_identity2
? 2 : 0;
2773 /* Combine a shuffle with its arguments. Returns 1 if there were any
2774 changes made, 2 if cfg-cleanup needs to run. Else it returns 0. */
2777 simplify_permutation (gimple_stmt_iterator
*gsi
)
2779 gimple stmt
= gsi_stmt (*gsi
);
2781 tree op0
, op1
, op2
, op3
, arg0
, arg1
;
2782 enum tree_code code
;
2783 bool single_use_op0
= false;
2785 gcc_checking_assert (gimple_assign_rhs_code (stmt
) == VEC_PERM_EXPR
);
2787 op0
= gimple_assign_rhs1 (stmt
);
2788 op1
= gimple_assign_rhs2 (stmt
);
2789 op2
= gimple_assign_rhs3 (stmt
);
2791 if (TREE_CODE (op2
) != VECTOR_CST
)
2794 if (TREE_CODE (op0
) == VECTOR_CST
)
2799 else if (TREE_CODE (op0
) == SSA_NAME
)
2801 def_stmt
= get_prop_source_stmt (op0
, false, &single_use_op0
);
2802 if (!def_stmt
|| !can_propagate_from (def_stmt
))
2805 code
= gimple_assign_rhs_code (def_stmt
);
2806 arg0
= gimple_assign_rhs1 (def_stmt
);
2811 /* Two consecutive shuffles. */
2812 if (code
== VEC_PERM_EXPR
)
2819 op3
= gimple_assign_rhs3 (def_stmt
);
2820 if (TREE_CODE (op3
) != VECTOR_CST
)
2822 ident
= is_combined_permutation_identity (op3
, op2
);
2825 orig
= (ident
== 1) ? gimple_assign_rhs1 (def_stmt
)
2826 : gimple_assign_rhs2 (def_stmt
);
2827 gimple_assign_set_rhs1 (stmt
, unshare_expr (orig
));
2828 gimple_assign_set_rhs_code (stmt
, TREE_CODE (orig
));
2829 gimple_set_num_ops (stmt
, 2);
2831 return remove_prop_source_from_use (op0
) ? 2 : 1;
2834 /* Shuffle of a constructor. */
2835 else if (code
== CONSTRUCTOR
|| code
== VECTOR_CST
)
2841 if (TREE_CODE (op0
) == SSA_NAME
&& !single_use_op0
)
2844 if (TREE_CODE (op1
) == VECTOR_CST
)
2846 else if (TREE_CODE (op1
) == SSA_NAME
)
2848 enum tree_code code2
;
2850 gimple def_stmt2
= get_prop_source_stmt (op1
, true, NULL
);
2851 if (!def_stmt2
|| !can_propagate_from (def_stmt2
))
2854 code2
= gimple_assign_rhs_code (def_stmt2
);
2855 if (code2
!= CONSTRUCTOR
&& code2
!= VECTOR_CST
)
2857 arg1
= gimple_assign_rhs1 (def_stmt2
);
2864 /* Already used twice in this statement. */
2865 if (TREE_CODE (op0
) == SSA_NAME
&& num_imm_uses (op0
) > 2)
2869 opt
= fold_ternary (VEC_PERM_EXPR
, TREE_TYPE(op0
), arg0
, arg1
, op2
);
2871 || (TREE_CODE (opt
) != CONSTRUCTOR
&& TREE_CODE(opt
) != VECTOR_CST
))
2873 gimple_assign_set_rhs_from_tree (gsi
, opt
);
2874 update_stmt (gsi_stmt (*gsi
));
2875 if (TREE_CODE (op0
) == SSA_NAME
)
2876 ret
= remove_prop_source_from_use (op0
);
2877 if (op0
!= op1
&& TREE_CODE (op1
) == SSA_NAME
)
2878 ret
|= remove_prop_source_from_use (op1
);
2885 /* Recognize a VEC_PERM_EXPR. Returns true if there were any changes. */
2888 simplify_vector_constructor (gimple_stmt_iterator
*gsi
)
2890 gimple stmt
= gsi_stmt (*gsi
);
2892 tree op
, op2
, orig
, type
, elem_type
;
2893 unsigned elem_size
, nelts
, i
;
2894 enum tree_code code
;
2895 constructor_elt
*elt
;
2899 gcc_checking_assert (gimple_assign_rhs_code (stmt
) == CONSTRUCTOR
);
2901 op
= gimple_assign_rhs1 (stmt
);
2902 type
= TREE_TYPE (op
);
2903 gcc_checking_assert (TREE_CODE (type
) == VECTOR_TYPE
);
2905 nelts
= TYPE_VECTOR_SUBPARTS (type
);
2906 elem_type
= TREE_TYPE (type
);
2907 elem_size
= TREE_INT_CST_LOW (TYPE_SIZE (elem_type
));
2909 sel
= XALLOCAVEC (unsigned char, nelts
);
2912 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (op
), i
, elt
)
2919 if (TREE_CODE (elt
->value
) != SSA_NAME
)
2921 def_stmt
= get_prop_source_stmt (elt
->value
, false, NULL
);
2924 code
= gimple_assign_rhs_code (def_stmt
);
2925 if (code
!= BIT_FIELD_REF
)
2927 op1
= gimple_assign_rhs1 (def_stmt
);
2928 ref
= TREE_OPERAND (op1
, 0);
2936 if (TREE_CODE (ref
) != SSA_NAME
)
2938 if (!useless_type_conversion_p (type
, TREE_TYPE (ref
)))
2942 if (TREE_INT_CST_LOW (TREE_OPERAND (op1
, 1)) != elem_size
)
2944 sel
[i
] = TREE_INT_CST_LOW (TREE_OPERAND (op1
, 2)) / elem_size
;
2945 if (sel
[i
] != i
) maybe_ident
= false;
2951 gimple_assign_set_rhs_from_tree (gsi
, orig
);
2954 tree mask_type
, *mask_elts
;
2956 if (!can_vec_perm_p (TYPE_MODE (type
), false, sel
))
2959 = build_vector_type (build_nonstandard_integer_type (elem_size
, 1),
2961 if (GET_MODE_CLASS (TYPE_MODE (mask_type
)) != MODE_VECTOR_INT
2962 || GET_MODE_SIZE (TYPE_MODE (mask_type
))
2963 != GET_MODE_SIZE (TYPE_MODE (type
)))
2965 mask_elts
= XALLOCAVEC (tree
, nelts
);
2966 for (i
= 0; i
< nelts
; i
++)
2967 mask_elts
[i
] = build_int_cst (TREE_TYPE (mask_type
), sel
[i
]);
2968 op2
= build_vector (mask_type
, mask_elts
);
2969 gimple_assign_set_rhs_with_ops_1 (gsi
, VEC_PERM_EXPR
, orig
, orig
, op2
);
2971 update_stmt (gsi_stmt (*gsi
));
2975 /* Main entry point for the forward propagation and statement combine
2979 ssa_forward_propagate_and_combine (void)
2982 unsigned int todoflags
= 0;
2984 cfg_changed
= false;
2988 gimple_stmt_iterator gsi
;
2990 /* Apply forward propagation to all stmts in the basic-block.
2991 Note we update GSI within the loop as necessary. */
2992 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
2994 gimple stmt
= gsi_stmt (gsi
);
2996 enum tree_code code
;
2998 if (!is_gimple_assign (stmt
))
3004 lhs
= gimple_assign_lhs (stmt
);
3005 rhs
= gimple_assign_rhs1 (stmt
);
3006 code
= gimple_assign_rhs_code (stmt
);
3007 if (TREE_CODE (lhs
) != SSA_NAME
3008 || has_zero_uses (lhs
))
3014 /* If this statement sets an SSA_NAME to an address,
3015 try to propagate the address into the uses of the SSA_NAME. */
3016 if (code
== ADDR_EXPR
3017 /* Handle pointer conversions on invariant addresses
3018 as well, as this is valid gimple. */
3019 || (CONVERT_EXPR_CODE_P (code
)
3020 && TREE_CODE (rhs
) == ADDR_EXPR
3021 && POINTER_TYPE_P (TREE_TYPE (lhs
))))
3023 tree base
= get_base_address (TREE_OPERAND (rhs
, 0));
3026 || decl_address_invariant_p (base
))
3027 && !stmt_references_abnormal_ssa_name (stmt
)
3028 && forward_propagate_addr_expr (lhs
, rhs
))
3030 release_defs (stmt
);
3031 gsi_remove (&gsi
, true);
3036 else if (code
== POINTER_PLUS_EXPR
)
3038 tree off
= gimple_assign_rhs2 (stmt
);
3039 if (TREE_CODE (off
) == INTEGER_CST
3040 && can_propagate_from (stmt
)
3041 && !simple_iv_increment_p (stmt
)
3042 /* ??? Better adjust the interface to that function
3043 instead of building new trees here. */
3044 && forward_propagate_addr_expr
3046 build1_loc (gimple_location (stmt
),
3047 ADDR_EXPR
, TREE_TYPE (rhs
),
3048 fold_build2 (MEM_REF
,
3049 TREE_TYPE (TREE_TYPE (rhs
)),
3051 fold_convert (ptr_type_node
,
3054 release_defs (stmt
);
3055 gsi_remove (&gsi
, true);
3057 else if (is_gimple_min_invariant (rhs
))
3059 /* Make sure to fold &a[0] + off_1 here. */
3060 fold_stmt_inplace (&gsi
);
3062 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
3068 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3070 if (forward_propagate_comparison (&gsi
))
3077 /* Combine stmts with the stmts defining their operands.
3078 Note we update GSI within the loop as necessary. */
3079 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
3081 gimple stmt
= gsi_stmt (gsi
);
3082 bool changed
= false;
3084 /* Mark stmt as potentially needing revisiting. */
3085 gimple_set_plf (stmt
, GF_PLF_1
, false);
3087 switch (gimple_code (stmt
))
3091 tree rhs1
= gimple_assign_rhs1 (stmt
);
3092 enum tree_code code
= gimple_assign_rhs_code (stmt
);
3094 if ((code
== BIT_NOT_EXPR
3095 || code
== NEGATE_EXPR
)
3096 && TREE_CODE (rhs1
) == SSA_NAME
)
3097 changed
= simplify_not_neg_expr (&gsi
);
3098 else if (code
== COND_EXPR
3099 || code
== VEC_COND_EXPR
)
3101 /* In this case the entire COND_EXPR is in rhs1. */
3102 if (forward_propagate_into_cond (&gsi
)
3103 || combine_cond_exprs (&gsi
))
3106 stmt
= gsi_stmt (gsi
);
3109 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3112 did_something
= forward_propagate_into_comparison (&gsi
);
3113 if (did_something
== 2)
3115 changed
= did_something
!= 0;
3117 else if (code
== BIT_AND_EXPR
3118 || code
== BIT_IOR_EXPR
3119 || code
== BIT_XOR_EXPR
)
3120 changed
= simplify_bitwise_binary (&gsi
);
3121 else if (code
== PLUS_EXPR
3122 || code
== MINUS_EXPR
)
3123 changed
= associate_plusminus (&gsi
);
3124 else if (code
== POINTER_PLUS_EXPR
)
3125 changed
= associate_pointerplus (&gsi
);
3126 else if (CONVERT_EXPR_CODE_P (code
)
3127 || code
== FLOAT_EXPR
3128 || code
== FIX_TRUNC_EXPR
)
3130 int did_something
= combine_conversions (&gsi
);
3131 if (did_something
== 2)
3134 /* If we have a narrowing conversion to an integral
3135 type that is fed by a BIT_AND_EXPR, we might be
3136 able to remove the BIT_AND_EXPR if it merely
3137 masks off bits outside the final type (and nothing
3139 if (! did_something
)
3141 tree outer_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
3142 tree inner_type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
3143 if (INTEGRAL_TYPE_P (outer_type
)
3144 && INTEGRAL_TYPE_P (inner_type
)
3145 && (TYPE_PRECISION (outer_type
)
3146 <= TYPE_PRECISION (inner_type
)))
3147 did_something
= simplify_conversion_from_bitmask (&gsi
);
3150 changed
= did_something
!= 0;
3152 else if (code
== VEC_PERM_EXPR
)
3154 int did_something
= simplify_permutation (&gsi
);
3155 if (did_something
== 2)
3157 changed
= did_something
!= 0;
3159 else if (code
== BIT_FIELD_REF
)
3160 changed
= simplify_bitfield_ref (&gsi
);
3161 else if (code
== CONSTRUCTOR
3162 && TREE_CODE (TREE_TYPE (rhs1
)) == VECTOR_TYPE
)
3163 changed
= simplify_vector_constructor (&gsi
);
3168 changed
= simplify_gimple_switch (stmt
);
3174 did_something
= forward_propagate_into_gimple_cond (stmt
);
3175 if (did_something
== 2)
3177 changed
= did_something
!= 0;
3183 tree callee
= gimple_call_fndecl (stmt
);
3184 if (callee
!= NULL_TREE
3185 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
3186 changed
= simplify_builtin_call (&gsi
, callee
);
3195 /* If the stmt changed then re-visit it and the statements
3196 inserted before it. */
3197 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
3198 if (gimple_plf (gsi_stmt (gsi
), GF_PLF_1
))
3200 if (gsi_end_p (gsi
))
3201 gsi
= gsi_start_bb (bb
);
3207 /* Stmt no longer needs to be revisited. */
3208 gimple_set_plf (stmt
, GF_PLF_1
, true);
3215 todoflags
|= TODO_cleanup_cfg
;
3222 gate_forwprop (void)
3224 return flag_tree_forwprop
;
3227 struct gimple_opt_pass pass_forwprop
=
3231 "forwprop", /* name */
3232 OPTGROUP_NONE
, /* optinfo_flags */
3233 gate_forwprop
, /* gate */
3234 ssa_forward_propagate_and_combine
, /* execute */
3237 0, /* static_pass_number */
3238 TV_TREE_FORWPROP
, /* tv_id */
3239 PROP_cfg
| PROP_ssa
, /* properties_required */
3240 0, /* properties_provided */
3241 0, /* properties_destroyed */
3242 0, /* todo_flags_start */
3244 | TODO_verify_ssa
/* todo_flags_finish */