1 /* Forward propagation of expressions for single use variables.
2 Copyright (C) 2004-2014 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"
25 #include "stor-layout.h"
27 #include "basic-block.h"
28 #include "gimple-pretty-print.h"
29 #include "tree-ssa-alias.h"
30 #include "internal-fn.h"
31 #include "gimple-fold.h"
33 #include "gimple-expr.h"
37 #include "gimple-iterator.h"
38 #include "gimplify-me.h"
39 #include "gimple-ssa.h"
41 #include "tree-phinodes.h"
42 #include "ssa-iterators.h"
43 #include "stringpool.h"
44 #include "tree-ssanames.h"
47 #include "tree-pass.h"
48 #include "langhooks.h"
53 #include "tree-ssa-propagate.h"
54 #include "tree-ssa-dom.h"
56 /* This pass propagates the RHS of assignment statements into use
57 sites of the LHS of the assignment. It's basically a specialized
58 form of tree combination. It is hoped all of this can disappear
59 when we have a generalized tree combiner.
61 One class of common cases we handle is forward propagating a single use
62 variable into a COND_EXPR.
66 if (x) goto ... else goto ...
68 Will be transformed into:
71 if (a COND b) goto ... else goto ...
73 Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
75 Or (assuming c1 and c2 are constants):
79 if (x EQ/NEQ c2) goto ... else goto ...
81 Will be transformed into:
84 if (a EQ/NEQ (c2 - c1)) goto ... else goto ...
86 Similarly for x = a - c1.
92 if (x) goto ... else goto ...
94 Will be transformed into:
97 if (a == 0) goto ... else goto ...
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.
107 if (x) goto ... else goto ...
109 Will be transformed into:
112 if (a != 0) goto ... else goto ...
114 (Assuming a is an integral type and x is a boolean or x is an
115 integral and a is a boolean.)
117 Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
118 For these cases, we propagate A into all, possibly more than one,
119 COND_EXPRs that use X.
121 In addition to eliminating the variable and the statement which assigns
122 a value to the variable, we may be able to later thread the jump without
123 adding insane complexity in the dominator optimizer.
125 Also note these transformations can cascade. We handle this by having
126 a worklist of COND_EXPR statements to examine. As we make a change to
127 a statement, we put it back on the worklist to examine on the next
128 iteration of the main loop.
130 A second class of propagation opportunities arises for ADDR_EXPR
141 ptr = (type1*)&type2var;
144 Will get turned into (if type1 and type2 are the same size
145 and neither have volatile on them):
146 res = VIEW_CONVERT_EXPR<type1>(type2var)
151 ptr2 = ptr + <constant>;
155 ptr2 = &x[constant/elementsize];
160 offset = index * element_size;
161 offset_p = (pointer) offset;
162 ptr2 = ptr + offset_p
164 Will get turned into:
172 Provided that decl has known alignment >= 2, will get turned into
176 We also propagate casts into SWITCH_EXPR and COND_EXPR conditions to
177 allow us to remove the cast and {NOT_EXPR,NEG_EXPR} into a subsequent
180 This will (of course) be extended as other needs arise. */
182 static bool forward_propagate_addr_expr (tree
, tree
, bool);
184 /* Set to true if we delete dead edges during the optimization. */
185 static bool cfg_changed
;
187 static tree
rhs_to_tree (tree type
, gimple stmt
);
189 /* Get the next statement we can propagate NAME's value into skipping
190 trivial copies. Returns the statement that is suitable as a
191 propagation destination or NULL_TREE if there is no such one.
192 This only returns destinations in a single-use chain. FINAL_NAME_P
193 if non-NULL is written to the ssa name that represents the use. */
196 get_prop_dest_stmt (tree name
, tree
*final_name_p
)
202 /* If name has multiple uses, bail out. */
203 if (!single_imm_use (name
, &use
, &use_stmt
))
206 /* If this is not a trivial copy, we found it. */
207 if (!gimple_assign_ssa_name_copy_p (use_stmt
)
208 || gimple_assign_rhs1 (use_stmt
) != name
)
211 /* Continue searching uses of the copy destination. */
212 name
= gimple_assign_lhs (use_stmt
);
216 *final_name_p
= name
;
221 /* Get the statement we can propagate from into NAME skipping
222 trivial copies. Returns the statement which defines the
223 propagation source or NULL_TREE if there is no such one.
224 If SINGLE_USE_ONLY is set considers only sources which have
225 a single use chain up to NAME. If SINGLE_USE_P is non-null,
226 it is set to whether the chain to NAME is a single use chain
227 or not. SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set. */
230 get_prop_source_stmt (tree name
, bool single_use_only
, bool *single_use_p
)
232 bool single_use
= true;
235 gimple def_stmt
= SSA_NAME_DEF_STMT (name
);
237 if (!has_single_use (name
))
244 /* If name is defined by a PHI node or is the default def, bail out. */
245 if (!is_gimple_assign (def_stmt
))
248 /* If def_stmt is a simple copy, continue looking. */
249 if (gimple_assign_rhs_code (def_stmt
) == SSA_NAME
)
250 name
= gimple_assign_rhs1 (def_stmt
);
253 if (!single_use_only
&& single_use_p
)
254 *single_use_p
= single_use
;
261 /* Checks if the destination ssa name in DEF_STMT can be used as
262 propagation source. Returns true if so, otherwise false. */
265 can_propagate_from (gimple def_stmt
)
267 gcc_assert (is_gimple_assign (def_stmt
));
269 /* If the rhs has side-effects we cannot propagate from it. */
270 if (gimple_has_volatile_ops (def_stmt
))
273 /* If the rhs is a load we cannot propagate from it. */
274 if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt
)) == tcc_reference
275 || TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt
)) == tcc_declaration
)
278 /* Constants can be always propagated. */
279 if (gimple_assign_single_p (def_stmt
)
280 && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt
)))
283 /* We cannot propagate ssa names that occur in abnormal phi nodes. */
284 if (stmt_references_abnormal_ssa_name (def_stmt
))
287 /* If the definition is a conversion of a pointer to a function type,
288 then we can not apply optimizations as some targets require
289 function pointers to be canonicalized and in this case this
290 optimization could eliminate a necessary canonicalization. */
291 if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
293 tree rhs
= gimple_assign_rhs1 (def_stmt
);
294 if (POINTER_TYPE_P (TREE_TYPE (rhs
))
295 && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs
))) == FUNCTION_TYPE
)
302 /* Remove a chain of dead statements starting at the definition of
303 NAME. The chain is linked via the first operand of the defining statements.
304 If NAME was replaced in its only use then this function can be used
305 to clean up dead stmts. The function handles already released SSA
307 Returns true if cleanup-cfg has to run. */
310 remove_prop_source_from_use (tree name
)
312 gimple_stmt_iterator gsi
;
314 bool cfg_changed
= false;
319 if (SSA_NAME_IN_FREE_LIST (name
)
320 || SSA_NAME_IS_DEFAULT_DEF (name
)
321 || !has_zero_uses (name
))
324 stmt
= SSA_NAME_DEF_STMT (name
);
325 if (gimple_code (stmt
) == GIMPLE_PHI
326 || gimple_has_side_effects (stmt
))
329 bb
= gimple_bb (stmt
);
330 gsi
= gsi_for_stmt (stmt
);
331 unlink_stmt_vdef (stmt
);
332 if (gsi_remove (&gsi
, true))
333 cfg_changed
|= gimple_purge_dead_eh_edges (bb
);
336 name
= is_gimple_assign (stmt
) ? gimple_assign_rhs1 (stmt
) : NULL_TREE
;
337 } while (name
&& TREE_CODE (name
) == SSA_NAME
);
342 /* Return the rhs of a gimple_assign STMT in a form of a single tree,
343 converted to type TYPE.
345 This should disappear, but is needed so we can combine expressions and use
346 the fold() interfaces. Long term, we need to develop folding and combine
347 routines that deal with gimple exclusively . */
350 rhs_to_tree (tree type
, gimple stmt
)
352 location_t loc
= gimple_location (stmt
);
353 enum tree_code code
= gimple_assign_rhs_code (stmt
);
354 if (get_gimple_rhs_class (code
) == GIMPLE_TERNARY_RHS
)
355 return fold_build3_loc (loc
, code
, type
, gimple_assign_rhs1 (stmt
),
356 gimple_assign_rhs2 (stmt
),
357 gimple_assign_rhs3 (stmt
));
358 else if (get_gimple_rhs_class (code
) == GIMPLE_BINARY_RHS
)
359 return fold_build2_loc (loc
, code
, type
, gimple_assign_rhs1 (stmt
),
360 gimple_assign_rhs2 (stmt
));
361 else if (get_gimple_rhs_class (code
) == GIMPLE_UNARY_RHS
)
362 return build1 (code
, type
, gimple_assign_rhs1 (stmt
));
363 else if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
)
364 return gimple_assign_rhs1 (stmt
);
369 /* Combine OP0 CODE OP1 in the context of a COND_EXPR. Returns
370 the folded result in a form suitable for COND_EXPR_COND or
371 NULL_TREE, if there is no suitable simplified form. If
372 INVARIANT_ONLY is true only gimple_min_invariant results are
373 considered simplified. */
376 combine_cond_expr_cond (gimple stmt
, enum tree_code code
, tree type
,
377 tree op0
, tree op1
, bool invariant_only
)
381 gcc_assert (TREE_CODE_CLASS (code
) == tcc_comparison
);
383 fold_defer_overflow_warnings ();
384 t
= fold_binary_loc (gimple_location (stmt
), code
, type
, op0
, op1
);
387 fold_undefer_overflow_warnings (false, NULL
, 0);
391 /* Require that we got a boolean type out if we put one in. */
392 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TREE_CODE (type
));
394 /* Canonicalize the combined condition for use in a COND_EXPR. */
395 t
= canonicalize_cond_expr_cond (t
);
397 /* Bail out if we required an invariant but didn't get one. */
398 if (!t
|| (invariant_only
&& !is_gimple_min_invariant (t
)))
400 fold_undefer_overflow_warnings (false, NULL
, 0);
404 fold_undefer_overflow_warnings (!gimple_no_warning_p (stmt
), stmt
, 0);
409 /* Combine the comparison OP0 CODE OP1 at LOC with the defining statements
410 of its operand. Return a new comparison tree or NULL_TREE if there
411 were no simplifying combines. */
414 forward_propagate_into_comparison_1 (gimple stmt
,
415 enum tree_code code
, tree type
,
418 tree tmp
= NULL_TREE
;
419 tree rhs0
= NULL_TREE
, rhs1
= NULL_TREE
;
420 bool single_use0_p
= false, single_use1_p
= false;
422 /* For comparisons use the first operand, that is likely to
423 simplify comparisons against constants. */
424 if (TREE_CODE (op0
) == SSA_NAME
)
426 gimple def_stmt
= get_prop_source_stmt (op0
, false, &single_use0_p
);
427 if (def_stmt
&& can_propagate_from (def_stmt
))
429 rhs0
= rhs_to_tree (TREE_TYPE (op1
), def_stmt
);
430 tmp
= combine_cond_expr_cond (stmt
, code
, type
,
431 rhs0
, op1
, !single_use0_p
);
437 /* If that wasn't successful, try the second operand. */
438 if (TREE_CODE (op1
) == SSA_NAME
)
440 gimple def_stmt
= get_prop_source_stmt (op1
, false, &single_use1_p
);
441 if (def_stmt
&& can_propagate_from (def_stmt
))
443 rhs1
= rhs_to_tree (TREE_TYPE (op0
), def_stmt
);
444 tmp
= combine_cond_expr_cond (stmt
, code
, type
,
445 op0
, rhs1
, !single_use1_p
);
451 /* If that wasn't successful either, try both operands. */
452 if (rhs0
!= NULL_TREE
453 && rhs1
!= NULL_TREE
)
454 tmp
= combine_cond_expr_cond (stmt
, code
, type
,
456 !(single_use0_p
&& single_use1_p
));
461 /* Propagate from the ssa name definition statements of the assignment
462 from a comparison at *GSI into the conditional if that simplifies it.
463 Returns 1 if the stmt was modified and 2 if the CFG needs cleanup,
464 otherwise returns 0. */
467 forward_propagate_into_comparison (gimple_stmt_iterator
*gsi
)
469 gimple stmt
= gsi_stmt (*gsi
);
471 bool cfg_changed
= false;
472 tree type
= TREE_TYPE (gimple_assign_lhs (stmt
));
473 tree rhs1
= gimple_assign_rhs1 (stmt
);
474 tree rhs2
= gimple_assign_rhs2 (stmt
);
476 /* Combine the comparison with defining statements. */
477 tmp
= forward_propagate_into_comparison_1 (stmt
,
478 gimple_assign_rhs_code (stmt
),
480 if (tmp
&& useless_type_conversion_p (type
, TREE_TYPE (tmp
)))
482 gimple_assign_set_rhs_from_tree (gsi
, tmp
);
484 update_stmt (gsi_stmt (*gsi
));
486 if (TREE_CODE (rhs1
) == SSA_NAME
)
487 cfg_changed
|= remove_prop_source_from_use (rhs1
);
488 if (TREE_CODE (rhs2
) == SSA_NAME
)
489 cfg_changed
|= remove_prop_source_from_use (rhs2
);
490 return cfg_changed
? 2 : 1;
496 /* Propagate from the ssa name definition statements of COND_EXPR
497 in GIMPLE_COND statement STMT into the conditional if that simplifies it.
498 Returns zero if no statement was changed, one if there were
499 changes and two if cfg_cleanup needs to run.
501 This must be kept in sync with forward_propagate_into_cond. */
504 forward_propagate_into_gimple_cond (gimple stmt
)
507 enum tree_code code
= gimple_cond_code (stmt
);
508 bool cfg_changed
= false;
509 tree rhs1
= gimple_cond_lhs (stmt
);
510 tree rhs2
= gimple_cond_rhs (stmt
);
512 /* We can do tree combining on SSA_NAME and comparison expressions. */
513 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
516 tmp
= forward_propagate_into_comparison_1 (stmt
, code
,
521 if (dump_file
&& tmp
)
523 fprintf (dump_file
, " Replaced '");
524 print_gimple_expr (dump_file
, stmt
, 0, 0);
525 fprintf (dump_file
, "' with '");
526 print_generic_expr (dump_file
, tmp
, 0);
527 fprintf (dump_file
, "'\n");
530 gimple_cond_set_condition_from_tree (stmt
, unshare_expr (tmp
));
533 if (TREE_CODE (rhs1
) == SSA_NAME
)
534 cfg_changed
|= remove_prop_source_from_use (rhs1
);
535 if (TREE_CODE (rhs2
) == SSA_NAME
)
536 cfg_changed
|= remove_prop_source_from_use (rhs2
);
537 return (cfg_changed
|| is_gimple_min_invariant (tmp
)) ? 2 : 1;
540 /* Canonicalize _Bool == 0 and _Bool != 1 to _Bool != 0 by swapping edges. */
541 if ((TREE_CODE (TREE_TYPE (rhs1
)) == BOOLEAN_TYPE
542 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
543 && TYPE_PRECISION (TREE_TYPE (rhs1
)) == 1))
545 && integer_zerop (rhs2
))
547 && integer_onep (rhs2
))))
549 basic_block bb
= gimple_bb (stmt
);
550 gimple_cond_set_code (stmt
, NE_EXPR
);
551 gimple_cond_set_rhs (stmt
, build_zero_cst (TREE_TYPE (rhs1
)));
552 EDGE_SUCC (bb
, 0)->flags
^= (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
);
553 EDGE_SUCC (bb
, 1)->flags
^= (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
);
561 /* Propagate from the ssa name definition statements of COND_EXPR
562 in the rhs of statement STMT into the conditional if that simplifies it.
563 Returns true zero if the stmt was changed. */
566 forward_propagate_into_cond (gimple_stmt_iterator
*gsi_p
)
568 gimple stmt
= gsi_stmt (*gsi_p
);
569 tree tmp
= NULL_TREE
;
570 tree cond
= gimple_assign_rhs1 (stmt
);
571 enum tree_code code
= gimple_assign_rhs_code (stmt
);
574 /* We can do tree combining on SSA_NAME and comparison expressions. */
575 if (COMPARISON_CLASS_P (cond
))
576 tmp
= forward_propagate_into_comparison_1 (stmt
, TREE_CODE (cond
),
578 TREE_OPERAND (cond
, 0),
579 TREE_OPERAND (cond
, 1));
580 else if (TREE_CODE (cond
) == SSA_NAME
)
582 enum tree_code def_code
;
584 gimple def_stmt
= get_prop_source_stmt (name
, true, NULL
);
585 if (!def_stmt
|| !can_propagate_from (def_stmt
))
588 def_code
= gimple_assign_rhs_code (def_stmt
);
589 if (TREE_CODE_CLASS (def_code
) == tcc_comparison
)
590 tmp
= fold_build2_loc (gimple_location (def_stmt
),
593 gimple_assign_rhs1 (def_stmt
),
594 gimple_assign_rhs2 (def_stmt
));
595 else if (code
== COND_EXPR
596 && ((def_code
== BIT_NOT_EXPR
597 && TYPE_PRECISION (TREE_TYPE (cond
)) == 1)
598 || (def_code
== BIT_XOR_EXPR
599 && integer_onep (gimple_assign_rhs2 (def_stmt
)))))
601 tmp
= gimple_assign_rhs1 (def_stmt
);
607 && is_gimple_condexpr (tmp
))
609 if (dump_file
&& tmp
)
611 fprintf (dump_file
, " Replaced '");
612 print_generic_expr (dump_file
, cond
, 0);
613 fprintf (dump_file
, "' with '");
614 print_generic_expr (dump_file
, tmp
, 0);
615 fprintf (dump_file
, "'\n");
618 if ((code
== VEC_COND_EXPR
) ? integer_all_onesp (tmp
)
619 : integer_onep (tmp
))
620 gimple_assign_set_rhs_from_tree (gsi_p
, gimple_assign_rhs2 (stmt
));
621 else if (integer_zerop (tmp
))
622 gimple_assign_set_rhs_from_tree (gsi_p
, gimple_assign_rhs3 (stmt
));
625 gimple_assign_set_rhs1 (stmt
, unshare_expr (tmp
));
628 tree t
= gimple_assign_rhs2 (stmt
);
629 gimple_assign_set_rhs2 (stmt
, gimple_assign_rhs3 (stmt
));
630 gimple_assign_set_rhs3 (stmt
, t
);
633 stmt
= gsi_stmt (*gsi_p
);
642 /* Propagate from the ssa name definition statements of COND_EXPR
643 values in the rhs of statement STMT into the conditional arms
644 if that simplifies it.
645 Returns true if the stmt was changed. */
648 combine_cond_exprs (gimple_stmt_iterator
*gsi_p
)
650 gimple stmt
= gsi_stmt (*gsi_p
);
651 tree cond
, val1
, val2
;
652 bool changed
= false;
654 cond
= gimple_assign_rhs1 (stmt
);
655 val1
= gimple_assign_rhs2 (stmt
);
656 if (TREE_CODE (val1
) == SSA_NAME
)
658 gimple def_stmt
= SSA_NAME_DEF_STMT (val1
);
659 if (is_gimple_assign (def_stmt
)
660 && gimple_assign_rhs_code (def_stmt
) == gimple_assign_rhs_code (stmt
)
661 && operand_equal_p (gimple_assign_rhs1 (def_stmt
), cond
, 0))
663 val1
= unshare_expr (gimple_assign_rhs2 (def_stmt
));
664 gimple_assign_set_rhs2 (stmt
, val1
);
668 val2
= gimple_assign_rhs3 (stmt
);
669 if (TREE_CODE (val2
) == SSA_NAME
)
671 gimple def_stmt
= SSA_NAME_DEF_STMT (val2
);
672 if (is_gimple_assign (def_stmt
)
673 && gimple_assign_rhs_code (def_stmt
) == gimple_assign_rhs_code (stmt
)
674 && operand_equal_p (gimple_assign_rhs1 (def_stmt
), cond
, 0))
676 val2
= unshare_expr (gimple_assign_rhs3 (def_stmt
));
677 gimple_assign_set_rhs3 (stmt
, val2
);
681 if (operand_equal_p (val1
, val2
, 0))
683 gimple_assign_set_rhs_from_tree (gsi_p
, val1
);
684 stmt
= gsi_stmt (*gsi_p
);
694 /* We've just substituted an ADDR_EXPR into stmt. Update all the
695 relevant data structures to match. */
698 tidy_after_forward_propagate_addr (gimple stmt
)
700 /* We may have turned a trapping insn into a non-trapping insn. */
701 if (maybe_clean_or_replace_eh_stmt (stmt
, stmt
)
702 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
705 if (TREE_CODE (gimple_assign_rhs1 (stmt
)) == ADDR_EXPR
)
706 recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt
));
709 /* NAME is a SSA_NAME representing DEF_RHS which is of the form
710 ADDR_EXPR <whatever>.
712 Try to forward propagate the ADDR_EXPR into the use USE_STMT.
713 Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
714 node or for recovery of array indexing from pointer arithmetic.
716 Return true if the propagation was successful (the propagation can
717 be not totally successful, yet things may have been changed). */
720 forward_propagate_addr_expr_1 (tree name
, tree def_rhs
,
721 gimple_stmt_iterator
*use_stmt_gsi
,
724 tree lhs
, rhs
, rhs2
, array_ref
;
725 gimple use_stmt
= gsi_stmt (*use_stmt_gsi
);
726 enum tree_code rhs_code
;
729 gcc_assert (TREE_CODE (def_rhs
) == ADDR_EXPR
);
731 lhs
= gimple_assign_lhs (use_stmt
);
732 rhs_code
= gimple_assign_rhs_code (use_stmt
);
733 rhs
= gimple_assign_rhs1 (use_stmt
);
735 /* Do not perform copy-propagation but recurse through copy chains. */
736 if (TREE_CODE (lhs
) == SSA_NAME
737 && rhs_code
== SSA_NAME
)
738 return forward_propagate_addr_expr (lhs
, def_rhs
, single_use_p
);
740 /* The use statement could be a conversion. Recurse to the uses of the
741 lhs as copyprop does not copy through pointer to integer to pointer
742 conversions and FRE does not catch all cases either.
743 Treat the case of a single-use name and
744 a conversion to def_rhs type separate, though. */
745 if (TREE_CODE (lhs
) == SSA_NAME
746 && CONVERT_EXPR_CODE_P (rhs_code
))
748 /* If there is a point in a conversion chain where the types match
749 so we can remove a conversion re-materialize the address here
752 && useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (def_rhs
)))
754 gimple_assign_set_rhs1 (use_stmt
, unshare_expr (def_rhs
));
755 gimple_assign_set_rhs_code (use_stmt
, TREE_CODE (def_rhs
));
759 /* Else recurse if the conversion preserves the address value. */
760 if ((INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
761 || POINTER_TYPE_P (TREE_TYPE (lhs
)))
762 && (TYPE_PRECISION (TREE_TYPE (lhs
))
763 >= TYPE_PRECISION (TREE_TYPE (def_rhs
))))
764 return forward_propagate_addr_expr (lhs
, def_rhs
, single_use_p
);
769 /* If this isn't a conversion chain from this on we only can propagate
770 into compatible pointer contexts. */
771 if (!types_compatible_p (TREE_TYPE (name
), TREE_TYPE (def_rhs
)))
774 /* Propagate through constant pointer adjustments. */
775 if (TREE_CODE (lhs
) == SSA_NAME
776 && rhs_code
== POINTER_PLUS_EXPR
778 && TREE_CODE (gimple_assign_rhs2 (use_stmt
)) == INTEGER_CST
)
781 /* As we come here with non-invariant addresses in def_rhs we need
782 to make sure we can build a valid constant offsetted address
783 for further propagation. Simply rely on fold building that
784 and check after the fact. */
785 new_def_rhs
= fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (rhs
)),
787 fold_convert (ptr_type_node
,
788 gimple_assign_rhs2 (use_stmt
)));
789 if (TREE_CODE (new_def_rhs
) == MEM_REF
790 && !is_gimple_mem_ref_addr (TREE_OPERAND (new_def_rhs
, 0)))
792 new_def_rhs
= build_fold_addr_expr_with_type (new_def_rhs
,
795 /* Recurse. If we could propagate into all uses of lhs do not
796 bother to replace into the current use but just pretend we did. */
797 if (TREE_CODE (new_def_rhs
) == ADDR_EXPR
798 && forward_propagate_addr_expr (lhs
, new_def_rhs
, single_use_p
))
801 if (useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (new_def_rhs
)))
802 gimple_assign_set_rhs_with_ops (use_stmt_gsi
, TREE_CODE (new_def_rhs
),
803 new_def_rhs
, NULL_TREE
);
804 else if (is_gimple_min_invariant (new_def_rhs
))
805 gimple_assign_set_rhs_with_ops (use_stmt_gsi
, NOP_EXPR
,
806 new_def_rhs
, NULL_TREE
);
809 gcc_assert (gsi_stmt (*use_stmt_gsi
) == use_stmt
);
810 update_stmt (use_stmt
);
814 /* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS.
815 ADDR_EXPR will not appear on the LHS. */
816 tree
*lhsp
= gimple_assign_lhs_ptr (use_stmt
);
817 while (handled_component_p (*lhsp
))
818 lhsp
= &TREE_OPERAND (*lhsp
, 0);
821 /* Now see if the LHS node is a MEM_REF using NAME. If so,
822 propagate the ADDR_EXPR into the use of NAME and fold the result. */
823 if (TREE_CODE (lhs
) == MEM_REF
824 && TREE_OPERAND (lhs
, 0) == name
)
827 HOST_WIDE_INT def_rhs_offset
;
828 /* If the address is invariant we can always fold it. */
829 if ((def_rhs_base
= get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs
, 0),
832 double_int off
= mem_ref_offset (lhs
);
834 off
+= double_int::from_shwi (def_rhs_offset
);
835 if (TREE_CODE (def_rhs_base
) == MEM_REF
)
837 off
+= mem_ref_offset (def_rhs_base
);
838 new_ptr
= TREE_OPERAND (def_rhs_base
, 0);
841 new_ptr
= build_fold_addr_expr (def_rhs_base
);
842 TREE_OPERAND (lhs
, 0) = new_ptr
;
843 TREE_OPERAND (lhs
, 1)
844 = double_int_to_tree (TREE_TYPE (TREE_OPERAND (lhs
, 1)), off
);
845 tidy_after_forward_propagate_addr (use_stmt
);
846 /* Continue propagating into the RHS if this was not the only use. */
850 /* If the LHS is a plain dereference and the value type is the same as
851 that of the pointed-to type of the address we can put the
852 dereferenced address on the LHS preserving the original alias-type. */
853 else if (integer_zerop (TREE_OPERAND (lhs
, 1))
854 && ((gimple_assign_lhs (use_stmt
) == lhs
855 && useless_type_conversion_p
856 (TREE_TYPE (TREE_OPERAND (def_rhs
, 0)),
857 TREE_TYPE (gimple_assign_rhs1 (use_stmt
))))
858 || types_compatible_p (TREE_TYPE (lhs
),
859 TREE_TYPE (TREE_OPERAND (def_rhs
, 0))))
860 /* Don't forward anything into clobber stmts if it would result
861 in the lhs no longer being a MEM_REF. */
862 && (!gimple_clobber_p (use_stmt
)
863 || TREE_CODE (TREE_OPERAND (def_rhs
, 0)) == MEM_REF
))
865 tree
*def_rhs_basep
= &TREE_OPERAND (def_rhs
, 0);
866 tree new_offset
, new_base
, saved
, new_lhs
;
867 while (handled_component_p (*def_rhs_basep
))
868 def_rhs_basep
= &TREE_OPERAND (*def_rhs_basep
, 0);
869 saved
= *def_rhs_basep
;
870 if (TREE_CODE (*def_rhs_basep
) == MEM_REF
)
872 new_base
= TREE_OPERAND (*def_rhs_basep
, 0);
873 new_offset
= fold_convert (TREE_TYPE (TREE_OPERAND (lhs
, 1)),
874 TREE_OPERAND (*def_rhs_basep
, 1));
878 new_base
= build_fold_addr_expr (*def_rhs_basep
);
879 new_offset
= TREE_OPERAND (lhs
, 1);
881 *def_rhs_basep
= build2 (MEM_REF
, TREE_TYPE (*def_rhs_basep
),
882 new_base
, new_offset
);
883 TREE_THIS_VOLATILE (*def_rhs_basep
) = TREE_THIS_VOLATILE (lhs
);
884 TREE_SIDE_EFFECTS (*def_rhs_basep
) = TREE_SIDE_EFFECTS (lhs
);
885 TREE_THIS_NOTRAP (*def_rhs_basep
) = TREE_THIS_NOTRAP (lhs
);
886 new_lhs
= unshare_expr (TREE_OPERAND (def_rhs
, 0));
888 TREE_THIS_VOLATILE (new_lhs
) = TREE_THIS_VOLATILE (lhs
);
889 TREE_SIDE_EFFECTS (new_lhs
) = TREE_SIDE_EFFECTS (lhs
);
890 *def_rhs_basep
= saved
;
891 tidy_after_forward_propagate_addr (use_stmt
);
892 /* Continue propagating into the RHS if this was not the
898 /* We can have a struct assignment dereferencing our name twice.
899 Note that we didn't propagate into the lhs to not falsely
900 claim we did when propagating into the rhs. */
904 /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
905 nodes from the RHS. */
906 tree
*rhsp
= gimple_assign_rhs1_ptr (use_stmt
);
907 if (TREE_CODE (*rhsp
) == ADDR_EXPR
)
908 rhsp
= &TREE_OPERAND (*rhsp
, 0);
909 while (handled_component_p (*rhsp
))
910 rhsp
= &TREE_OPERAND (*rhsp
, 0);
913 /* Now see if the RHS node is a MEM_REF using NAME. If so,
914 propagate the ADDR_EXPR into the use of NAME and fold the result. */
915 if (TREE_CODE (rhs
) == MEM_REF
916 && TREE_OPERAND (rhs
, 0) == name
)
919 HOST_WIDE_INT def_rhs_offset
;
920 if ((def_rhs_base
= get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs
, 0),
923 double_int off
= mem_ref_offset (rhs
);
925 off
+= double_int::from_shwi (def_rhs_offset
);
926 if (TREE_CODE (def_rhs_base
) == MEM_REF
)
928 off
+= mem_ref_offset (def_rhs_base
);
929 new_ptr
= TREE_OPERAND (def_rhs_base
, 0);
932 new_ptr
= build_fold_addr_expr (def_rhs_base
);
933 TREE_OPERAND (rhs
, 0) = new_ptr
;
934 TREE_OPERAND (rhs
, 1)
935 = double_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs
, 1)), off
);
936 fold_stmt_inplace (use_stmt_gsi
);
937 tidy_after_forward_propagate_addr (use_stmt
);
940 /* If the RHS is a plain dereference and the value type is the same as
941 that of the pointed-to type of the address we can put the
942 dereferenced address on the RHS preserving the original alias-type. */
943 else if (integer_zerop (TREE_OPERAND (rhs
, 1))
944 && ((gimple_assign_rhs1 (use_stmt
) == rhs
945 && useless_type_conversion_p
946 (TREE_TYPE (gimple_assign_lhs (use_stmt
)),
947 TREE_TYPE (TREE_OPERAND (def_rhs
, 0))))
948 || types_compatible_p (TREE_TYPE (rhs
),
949 TREE_TYPE (TREE_OPERAND (def_rhs
, 0)))))
951 tree
*def_rhs_basep
= &TREE_OPERAND (def_rhs
, 0);
952 tree new_offset
, new_base
, saved
, new_rhs
;
953 while (handled_component_p (*def_rhs_basep
))
954 def_rhs_basep
= &TREE_OPERAND (*def_rhs_basep
, 0);
955 saved
= *def_rhs_basep
;
956 if (TREE_CODE (*def_rhs_basep
) == MEM_REF
)
958 new_base
= TREE_OPERAND (*def_rhs_basep
, 0);
959 new_offset
= fold_convert (TREE_TYPE (TREE_OPERAND (rhs
, 1)),
960 TREE_OPERAND (*def_rhs_basep
, 1));
964 new_base
= build_fold_addr_expr (*def_rhs_basep
);
965 new_offset
= TREE_OPERAND (rhs
, 1);
967 *def_rhs_basep
= build2 (MEM_REF
, TREE_TYPE (*def_rhs_basep
),
968 new_base
, new_offset
);
969 TREE_THIS_VOLATILE (*def_rhs_basep
) = TREE_THIS_VOLATILE (rhs
);
970 TREE_SIDE_EFFECTS (*def_rhs_basep
) = TREE_SIDE_EFFECTS (rhs
);
971 TREE_THIS_NOTRAP (*def_rhs_basep
) = TREE_THIS_NOTRAP (rhs
);
972 new_rhs
= unshare_expr (TREE_OPERAND (def_rhs
, 0));
974 TREE_THIS_VOLATILE (new_rhs
) = TREE_THIS_VOLATILE (rhs
);
975 TREE_SIDE_EFFECTS (new_rhs
) = TREE_SIDE_EFFECTS (rhs
);
976 *def_rhs_basep
= saved
;
977 fold_stmt_inplace (use_stmt_gsi
);
978 tidy_after_forward_propagate_addr (use_stmt
);
983 /* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
985 if (gimple_assign_rhs_code (use_stmt
) != POINTER_PLUS_EXPR
986 || gimple_assign_rhs1 (use_stmt
) != name
)
989 /* The remaining cases are all for turning pointer arithmetic into
990 array indexing. They only apply when we have the address of
991 element zero in an array. If that is not the case then there
993 array_ref
= TREE_OPERAND (def_rhs
, 0);
994 if ((TREE_CODE (array_ref
) != ARRAY_REF
995 || TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref
, 0))) != ARRAY_TYPE
996 || TREE_CODE (TREE_OPERAND (array_ref
, 1)) != INTEGER_CST
)
997 && TREE_CODE (TREE_TYPE (array_ref
)) != ARRAY_TYPE
)
1000 rhs2
= gimple_assign_rhs2 (use_stmt
);
1001 /* Optimize &x[C1] p+ C2 to &x p+ C3 with C3 = C1 * element_size + C2. */
1002 if (TREE_CODE (rhs2
) == INTEGER_CST
)
1004 tree new_rhs
= build1_loc (gimple_location (use_stmt
),
1005 ADDR_EXPR
, TREE_TYPE (def_rhs
),
1006 fold_build2 (MEM_REF
,
1007 TREE_TYPE (TREE_TYPE (def_rhs
)),
1008 unshare_expr (def_rhs
),
1009 fold_convert (ptr_type_node
,
1011 gimple_assign_set_rhs_from_tree (use_stmt_gsi
, new_rhs
);
1012 use_stmt
= gsi_stmt (*use_stmt_gsi
);
1013 update_stmt (use_stmt
);
1014 tidy_after_forward_propagate_addr (use_stmt
);
1021 /* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
1023 Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME.
1024 Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
1025 node or for recovery of array indexing from pointer arithmetic.
1027 PARENT_SINGLE_USE_P tells if, when in a recursive invocation, NAME was
1028 the single use in the previous invocation. Pass true when calling
1031 Returns true, if all uses have been propagated into. */
1034 forward_propagate_addr_expr (tree name
, tree rhs
, bool parent_single_use_p
)
1036 imm_use_iterator iter
;
1039 bool single_use_p
= parent_single_use_p
&& has_single_use (name
);
1041 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, name
)
1046 /* If the use is not in a simple assignment statement, then
1047 there is nothing we can do. */
1048 if (!is_gimple_assign (use_stmt
))
1050 if (!is_gimple_debug (use_stmt
))
1055 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
1056 result
= forward_propagate_addr_expr_1 (name
, rhs
, &gsi
,
1058 /* If the use has moved to a different statement adjust
1059 the update machinery for the old statement too. */
1060 if (use_stmt
!= gsi_stmt (gsi
))
1062 update_stmt (use_stmt
);
1063 use_stmt
= gsi_stmt (gsi
);
1065 update_stmt (use_stmt
);
1068 /* Remove intermediate now unused copy and conversion chains. */
1069 use_rhs
= gimple_assign_rhs1 (use_stmt
);
1071 && TREE_CODE (gimple_assign_lhs (use_stmt
)) == SSA_NAME
1072 && TREE_CODE (use_rhs
) == SSA_NAME
1073 && has_zero_uses (gimple_assign_lhs (use_stmt
)))
1075 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
1076 release_defs (use_stmt
);
1077 gsi_remove (&gsi
, true);
1081 return all
&& has_zero_uses (name
);
1085 /* Forward propagate the comparison defined in *DEFGSI like
1086 cond_1 = x CMP y to uses of the form
1090 Returns true if stmt is now unused. Advance DEFGSI to the next
1094 forward_propagate_comparison (gimple_stmt_iterator
*defgsi
)
1096 gimple stmt
= gsi_stmt (*defgsi
);
1097 tree name
= gimple_assign_lhs (stmt
);
1099 tree tmp
= NULL_TREE
;
1100 gimple_stmt_iterator gsi
;
1101 enum tree_code code
;
1104 /* Don't propagate ssa names that occur in abnormal phis. */
1105 if ((TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
1106 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt
)))
1107 || (TREE_CODE (gimple_assign_rhs2 (stmt
)) == SSA_NAME
1108 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs2 (stmt
))))
1111 /* Do not un-cse comparisons. But propagate through copies. */
1112 use_stmt
= get_prop_dest_stmt (name
, &name
);
1114 || !is_gimple_assign (use_stmt
))
1117 code
= gimple_assign_rhs_code (use_stmt
);
1118 lhs
= gimple_assign_lhs (use_stmt
);
1119 if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs
)))
1122 /* We can propagate the condition into a statement that
1123 computes the logical negation of the comparison result. */
1124 if ((code
== BIT_NOT_EXPR
1125 && TYPE_PRECISION (TREE_TYPE (lhs
)) == 1)
1126 || (code
== BIT_XOR_EXPR
1127 && integer_onep (gimple_assign_rhs2 (use_stmt
))))
1129 tree type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
1130 bool nans
= HONOR_NANS (TYPE_MODE (type
));
1131 enum tree_code inv_code
;
1132 inv_code
= invert_tree_comparison (gimple_assign_rhs_code (stmt
), nans
);
1133 if (inv_code
== ERROR_MARK
)
1136 tmp
= build2 (inv_code
, TREE_TYPE (lhs
), gimple_assign_rhs1 (stmt
),
1137 gimple_assign_rhs2 (stmt
));
1142 gsi
= gsi_for_stmt (use_stmt
);
1143 gimple_assign_set_rhs_from_tree (&gsi
, unshare_expr (tmp
));
1144 use_stmt
= gsi_stmt (gsi
);
1145 update_stmt (use_stmt
);
1147 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1149 fprintf (dump_file
, " Replaced '");
1150 print_gimple_expr (dump_file
, stmt
, 0, dump_flags
);
1151 fprintf (dump_file
, "' with '");
1152 print_gimple_expr (dump_file
, use_stmt
, 0, dump_flags
);
1153 fprintf (dump_file
, "'\n");
1156 /* When we remove stmt now the iterator defgsi goes off it's current
1157 sequence, hence advance it now. */
1160 /* Remove defining statements. */
1161 return remove_prop_source_from_use (name
);
1169 /* GSI_P points to a statement which performs a narrowing integral
1172 Look for cases like:
1182 If T is narrower than X's type and C merely masks off bits outside
1183 of (T) and nothing else.
1185 Normally we'd let DCE remove the dead statement. But no DCE runs
1186 after the last forwprop/combine pass, so we remove the obviously
1187 dead code ourselves.
1189 Return TRUE if a change was made, FALSE otherwise. */
1192 simplify_conversion_from_bitmask (gimple_stmt_iterator
*gsi_p
)
1194 gimple stmt
= gsi_stmt (*gsi_p
);
1195 gimple rhs_def_stmt
= SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt
));
1197 /* See if the input for the conversion was set via a BIT_AND_EXPR and
1198 the only use of the BIT_AND_EXPR result is the conversion. */
1199 if (is_gimple_assign (rhs_def_stmt
)
1200 && gimple_assign_rhs_code (rhs_def_stmt
) == BIT_AND_EXPR
1201 && has_single_use (gimple_assign_lhs (rhs_def_stmt
)))
1203 tree rhs_def_operand1
= gimple_assign_rhs1 (rhs_def_stmt
);
1204 tree rhs_def_operand2
= gimple_assign_rhs2 (rhs_def_stmt
);
1205 tree lhs_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
1207 /* Now verify suitability of the BIT_AND_EXPR's operands.
1208 The first must be an SSA_NAME that we can propagate and the
1209 second must be an integer constant that masks out all the
1210 bits outside the final result's type, but nothing else. */
1211 if (TREE_CODE (rhs_def_operand1
) == SSA_NAME
1212 && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand1
)
1213 && TREE_CODE (rhs_def_operand2
) == INTEGER_CST
1214 && operand_equal_p (rhs_def_operand2
,
1215 build_low_bits_mask (TREE_TYPE (rhs_def_operand2
),
1216 TYPE_PRECISION (lhs_type
)),
1219 /* This is an optimizable case. Replace the source operand
1220 in the conversion with the first source operand of the
1222 gimple_assign_set_rhs1 (stmt
, rhs_def_operand1
);
1223 stmt
= gsi_stmt (*gsi_p
);
1226 /* There is no DCE after the last forwprop pass. It's
1227 easy to clean up the first order effects here. */
1228 gimple_stmt_iterator si
;
1229 si
= gsi_for_stmt (rhs_def_stmt
);
1230 gsi_remove (&si
, true);
1231 release_defs (rhs_def_stmt
);
1240 /* If we have lhs = ~x (STMT), look and see if earlier we had x = ~y.
1241 If so, we can change STMT into lhs = y which can later be copy
1242 propagated. Similarly for negation.
1244 This could trivially be formulated as a forward propagation
1245 to immediate uses. However, we already had an implementation
1246 from DOM which used backward propagation via the use-def links.
1248 It turns out that backward propagation is actually faster as
1249 there's less work to do for each NOT/NEG expression we find.
1250 Backwards propagation needs to look at the statement in a single
1251 backlink. Forward propagation needs to look at potentially more
1252 than one forward link.
1254 Returns true when the statement was changed. */
1257 simplify_not_neg_expr (gimple_stmt_iterator
*gsi_p
)
1259 gimple stmt
= gsi_stmt (*gsi_p
);
1260 tree rhs
= gimple_assign_rhs1 (stmt
);
1261 gimple rhs_def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1263 /* See if the RHS_DEF_STMT has the same form as our statement. */
1264 if (is_gimple_assign (rhs_def_stmt
)
1265 && gimple_assign_rhs_code (rhs_def_stmt
) == gimple_assign_rhs_code (stmt
))
1267 tree rhs_def_operand
= gimple_assign_rhs1 (rhs_def_stmt
);
1269 /* Verify that RHS_DEF_OPERAND is a suitable SSA_NAME. */
1270 if (TREE_CODE (rhs_def_operand
) == SSA_NAME
1271 && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand
))
1273 gimple_assign_set_rhs_from_tree (gsi_p
, rhs_def_operand
);
1274 stmt
= gsi_stmt (*gsi_p
);
1283 /* Helper function for simplify_gimple_switch. Remove case labels that
1284 have values outside the range of the new type. */
1287 simplify_gimple_switch_label_vec (gimple stmt
, tree index_type
)
1289 unsigned int branch_num
= gimple_switch_num_labels (stmt
);
1290 auto_vec
<tree
> labels (branch_num
);
1291 unsigned int i
, len
;
1293 /* Collect the existing case labels in a VEC, and preprocess it as if
1294 we are gimplifying a GENERIC SWITCH_EXPR. */
1295 for (i
= 1; i
< branch_num
; i
++)
1296 labels
.quick_push (gimple_switch_label (stmt
, i
));
1297 preprocess_case_label_vec_for_gimple (labels
, index_type
, NULL
);
1299 /* If any labels were removed, replace the existing case labels
1300 in the GIMPLE_SWITCH statement with the correct ones.
1301 Note that the type updates were done in-place on the case labels,
1302 so we only have to replace the case labels in the GIMPLE_SWITCH
1303 if the number of labels changed. */
1304 len
= labels
.length ();
1305 if (len
< branch_num
- 1)
1307 bitmap target_blocks
;
1311 /* Corner case: *all* case labels have been removed as being
1312 out-of-range for INDEX_TYPE. Push one label and let the
1313 CFG cleanups deal with this further. */
1318 label
= CASE_LABEL (gimple_switch_default_label (stmt
));
1319 elt
= build_case_label (build_int_cst (index_type
, 0), NULL
, label
);
1320 labels
.quick_push (elt
);
1324 for (i
= 0; i
< labels
.length (); i
++)
1325 gimple_switch_set_label (stmt
, i
+ 1, labels
[i
]);
1326 for (i
++ ; i
< branch_num
; i
++)
1327 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1328 gimple_switch_set_num_labels (stmt
, len
+ 1);
1330 /* Cleanup any edges that are now dead. */
1331 target_blocks
= BITMAP_ALLOC (NULL
);
1332 for (i
= 0; i
< gimple_switch_num_labels (stmt
); i
++)
1334 tree elt
= gimple_switch_label (stmt
, i
);
1335 basic_block target
= label_to_block (CASE_LABEL (elt
));
1336 bitmap_set_bit (target_blocks
, target
->index
);
1338 for (ei
= ei_start (gimple_bb (stmt
)->succs
); (e
= ei_safe_edge (ei
)); )
1340 if (! bitmap_bit_p (target_blocks
, e
->dest
->index
))
1344 free_dominance_info (CDI_DOMINATORS
);
1349 BITMAP_FREE (target_blocks
);
1353 /* STMT is a SWITCH_EXPR for which we attempt to find equivalent forms of
1354 the condition which we may be able to optimize better. */
1357 simplify_gimple_switch (gimple stmt
)
1359 /* The optimization that we really care about is removing unnecessary
1360 casts. That will let us do much better in propagating the inferred
1361 constant at the switch target. */
1362 tree cond
= gimple_switch_index (stmt
);
1363 if (TREE_CODE (cond
) == SSA_NAME
)
1365 gimple def_stmt
= SSA_NAME_DEF_STMT (cond
);
1366 if (gimple_assign_cast_p (def_stmt
))
1368 tree def
= gimple_assign_rhs1 (def_stmt
);
1369 if (TREE_CODE (def
) != SSA_NAME
)
1372 /* If we have an extension or sign-change that preserves the
1373 values we check against then we can copy the source value into
1375 tree ti
= TREE_TYPE (def
);
1376 if (INTEGRAL_TYPE_P (ti
)
1377 && TYPE_PRECISION (ti
) <= TYPE_PRECISION (TREE_TYPE (cond
)))
1379 size_t n
= gimple_switch_num_labels (stmt
);
1380 tree min
= NULL_TREE
, max
= NULL_TREE
;
1383 min
= CASE_LOW (gimple_switch_label (stmt
, 1));
1384 if (CASE_HIGH (gimple_switch_label (stmt
, n
- 1)))
1385 max
= CASE_HIGH (gimple_switch_label (stmt
, n
- 1));
1387 max
= CASE_LOW (gimple_switch_label (stmt
, n
- 1));
1389 if ((!min
|| int_fits_type_p (min
, ti
))
1390 && (!max
|| int_fits_type_p (max
, ti
)))
1392 gimple_switch_set_index (stmt
, def
);
1393 simplify_gimple_switch_label_vec (stmt
, ti
);
1404 /* For pointers p2 and p1 return p2 - p1 if the
1405 difference is known and constant, otherwise return NULL. */
1408 constant_pointer_difference (tree p1
, tree p2
)
1411 #define CPD_ITERATIONS 5
1412 tree exps
[2][CPD_ITERATIONS
];
1413 tree offs
[2][CPD_ITERATIONS
];
1416 for (i
= 0; i
< 2; i
++)
1418 tree p
= i
? p1
: p2
;
1419 tree off
= size_zero_node
;
1421 enum tree_code code
;
1423 /* For each of p1 and p2 we need to iterate at least
1424 twice, to handle ADDR_EXPR directly in p1/p2,
1425 SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc.
1426 on definition's stmt RHS. Iterate a few extra times. */
1430 if (!POINTER_TYPE_P (TREE_TYPE (p
)))
1432 if (TREE_CODE (p
) == ADDR_EXPR
)
1434 tree q
= TREE_OPERAND (p
, 0);
1435 HOST_WIDE_INT offset
;
1436 tree base
= get_addr_base_and_unit_offset (q
, &offset
);
1441 off
= size_binop (PLUS_EXPR
, off
, size_int (offset
));
1443 if (TREE_CODE (q
) == MEM_REF
1444 && TREE_CODE (TREE_OPERAND (q
, 0)) == SSA_NAME
)
1446 p
= TREE_OPERAND (q
, 0);
1447 off
= size_binop (PLUS_EXPR
, off
,
1448 double_int_to_tree (sizetype
,
1449 mem_ref_offset (q
)));
1458 if (TREE_CODE (p
) != SSA_NAME
)
1462 if (j
== CPD_ITERATIONS
)
1464 stmt
= SSA_NAME_DEF_STMT (p
);
1465 if (!is_gimple_assign (stmt
) || gimple_assign_lhs (stmt
) != p
)
1467 code
= gimple_assign_rhs_code (stmt
);
1468 if (code
== POINTER_PLUS_EXPR
)
1470 if (TREE_CODE (gimple_assign_rhs2 (stmt
)) != INTEGER_CST
)
1472 off
= size_binop (PLUS_EXPR
, off
, gimple_assign_rhs2 (stmt
));
1473 p
= gimple_assign_rhs1 (stmt
);
1475 else if (code
== ADDR_EXPR
|| code
== NOP_EXPR
)
1476 p
= gimple_assign_rhs1 (stmt
);
1484 for (i
= 0; i
< cnt
[0]; i
++)
1485 for (j
= 0; j
< cnt
[1]; j
++)
1486 if (exps
[0][i
] == exps
[1][j
])
1487 return size_binop (MINUS_EXPR
, offs
[0][i
], offs
[1][j
]);
1492 /* *GSI_P is a GIMPLE_CALL to a builtin function.
1494 memcpy (p, "abcd", 4);
1495 memset (p + 4, ' ', 3);
1497 memcpy (p, "abcd ", 7);
1498 call if the latter can be stored by pieces during expansion. */
1501 simplify_builtin_call (gimple_stmt_iterator
*gsi_p
, tree callee2
)
1503 gimple stmt1
, stmt2
= gsi_stmt (*gsi_p
);
1504 tree vuse
= gimple_vuse (stmt2
);
1507 stmt1
= SSA_NAME_DEF_STMT (vuse
);
1509 switch (DECL_FUNCTION_CODE (callee2
))
1511 case BUILT_IN_MEMSET
:
1512 if (gimple_call_num_args (stmt2
) != 3
1513 || gimple_call_lhs (stmt2
)
1515 || BITS_PER_UNIT
!= 8)
1520 tree ptr1
, src1
, str1
, off1
, len1
, lhs1
;
1521 tree ptr2
= gimple_call_arg (stmt2
, 0);
1522 tree val2
= gimple_call_arg (stmt2
, 1);
1523 tree len2
= gimple_call_arg (stmt2
, 2);
1524 tree diff
, vdef
, new_str_cst
;
1526 unsigned int ptr1_align
;
1527 unsigned HOST_WIDE_INT src_len
;
1529 use_operand_p use_p
;
1531 if (!tree_fits_shwi_p (val2
)
1532 || !tree_fits_uhwi_p (len2
)
1533 || compare_tree_int (len2
, 1024) == 1)
1535 if (is_gimple_call (stmt1
))
1537 /* If first stmt is a call, it needs to be memcpy
1538 or mempcpy, with string literal as second argument and
1540 callee1
= gimple_call_fndecl (stmt1
);
1541 if (callee1
== NULL_TREE
1542 || DECL_BUILT_IN_CLASS (callee1
) != BUILT_IN_NORMAL
1543 || gimple_call_num_args (stmt1
) != 3)
1545 if (DECL_FUNCTION_CODE (callee1
) != BUILT_IN_MEMCPY
1546 && DECL_FUNCTION_CODE (callee1
) != BUILT_IN_MEMPCPY
)
1548 ptr1
= gimple_call_arg (stmt1
, 0);
1549 src1
= gimple_call_arg (stmt1
, 1);
1550 len1
= gimple_call_arg (stmt1
, 2);
1551 lhs1
= gimple_call_lhs (stmt1
);
1552 if (!tree_fits_uhwi_p (len1
))
1554 str1
= string_constant (src1
, &off1
);
1555 if (str1
== NULL_TREE
)
1557 if (!tree_fits_uhwi_p (off1
)
1558 || compare_tree_int (off1
, TREE_STRING_LENGTH (str1
) - 1) > 0
1559 || compare_tree_int (len1
, TREE_STRING_LENGTH (str1
)
1560 - tree_to_uhwi (off1
)) > 0
1561 || TREE_CODE (TREE_TYPE (str1
)) != ARRAY_TYPE
1562 || TYPE_MODE (TREE_TYPE (TREE_TYPE (str1
)))
1563 != TYPE_MODE (char_type_node
))
1566 else if (gimple_assign_single_p (stmt1
))
1568 /* Otherwise look for length 1 memcpy optimized into
1570 ptr1
= gimple_assign_lhs (stmt1
);
1571 src1
= gimple_assign_rhs1 (stmt1
);
1572 if (TREE_CODE (ptr1
) != MEM_REF
1573 || TYPE_MODE (TREE_TYPE (ptr1
)) != TYPE_MODE (char_type_node
)
1574 || !tree_fits_shwi_p (src1
))
1576 ptr1
= build_fold_addr_expr (ptr1
);
1577 callee1
= NULL_TREE
;
1578 len1
= size_one_node
;
1580 off1
= size_zero_node
;
1586 diff
= constant_pointer_difference (ptr1
, ptr2
);
1587 if (diff
== NULL
&& lhs1
!= NULL
)
1589 diff
= constant_pointer_difference (lhs1
, ptr2
);
1590 if (DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
1592 diff
= size_binop (PLUS_EXPR
, diff
,
1593 fold_convert (sizetype
, len1
));
1595 /* If the difference between the second and first destination pointer
1596 is not constant, or is bigger than memcpy length, bail out. */
1598 || !tree_fits_uhwi_p (diff
)
1599 || tree_int_cst_lt (len1
, diff
)
1600 || compare_tree_int (diff
, 1024) == 1)
1603 /* Use maximum of difference plus memset length and memcpy length
1604 as the new memcpy length, if it is too big, bail out. */
1605 src_len
= tree_to_uhwi (diff
);
1606 src_len
+= tree_to_uhwi (len2
);
1607 if (src_len
< tree_to_uhwi (len1
))
1608 src_len
= tree_to_uhwi (len1
);
1612 /* If mempcpy value is used elsewhere, bail out, as mempcpy
1613 with bigger length will return different result. */
1614 if (lhs1
!= NULL_TREE
1615 && DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
1616 && (TREE_CODE (lhs1
) != SSA_NAME
1617 || !single_imm_use (lhs1
, &use_p
, &use_stmt
)
1618 || use_stmt
!= stmt2
))
1621 /* If anything reads memory in between memcpy and memset
1622 call, the modified memcpy call might change it. */
1623 vdef
= gimple_vdef (stmt1
);
1625 && (!single_imm_use (vdef
, &use_p
, &use_stmt
)
1626 || use_stmt
!= stmt2
))
1629 ptr1_align
= get_pointer_alignment (ptr1
);
1630 /* Construct the new source string literal. */
1631 src_buf
= XALLOCAVEC (char, src_len
+ 1);
1634 TREE_STRING_POINTER (str1
) + tree_to_uhwi (off1
),
1635 tree_to_uhwi (len1
));
1637 src_buf
[0] = tree_to_shwi (src1
);
1638 memset (src_buf
+ tree_to_uhwi (diff
),
1639 tree_to_shwi (val2
), tree_to_uhwi (len2
));
1640 src_buf
[src_len
] = '\0';
1641 /* Neither builtin_strncpy_read_str nor builtin_memcpy_read_str
1642 handle embedded '\0's. */
1643 if (strlen (src_buf
) != src_len
)
1645 rtl_profile_for_bb (gimple_bb (stmt2
));
1646 /* If the new memcpy wouldn't be emitted by storing the literal
1647 by pieces, this optimization might enlarge .rodata too much,
1648 as commonly used string literals couldn't be shared any
1650 if (!can_store_by_pieces (src_len
,
1651 builtin_strncpy_read_str
,
1652 src_buf
, ptr1_align
, false))
1655 new_str_cst
= build_string_literal (src_len
, src_buf
);
1658 /* If STMT1 is a mem{,p}cpy call, adjust it and remove
1660 if (lhs1
&& DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
)
1661 gimple_call_set_lhs (stmt1
, NULL_TREE
);
1662 gimple_call_set_arg (stmt1
, 1, new_str_cst
);
1663 gimple_call_set_arg (stmt1
, 2,
1664 build_int_cst (TREE_TYPE (len1
), src_len
));
1665 update_stmt (stmt1
);
1666 unlink_stmt_vdef (stmt2
);
1667 gsi_remove (gsi_p
, true);
1668 release_defs (stmt2
);
1669 if (lhs1
&& DECL_FUNCTION_CODE (callee1
) == BUILT_IN_MEMPCPY
)
1670 release_ssa_name (lhs1
);
1675 /* Otherwise, if STMT1 is length 1 memcpy optimized into
1676 assignment, remove STMT1 and change memset call into
1678 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt1
);
1680 if (!is_gimple_val (ptr1
))
1681 ptr1
= force_gimple_operand_gsi (gsi_p
, ptr1
, true, NULL_TREE
,
1682 true, GSI_SAME_STMT
);
1683 gimple_call_set_fndecl (stmt2
,
1684 builtin_decl_explicit (BUILT_IN_MEMCPY
));
1685 gimple_call_set_arg (stmt2
, 0, ptr1
);
1686 gimple_call_set_arg (stmt2
, 1, new_str_cst
);
1687 gimple_call_set_arg (stmt2
, 2,
1688 build_int_cst (TREE_TYPE (len2
), src_len
));
1689 unlink_stmt_vdef (stmt1
);
1690 gsi_remove (&gsi
, true);
1691 release_defs (stmt1
);
1692 update_stmt (stmt2
);
1703 /* Checks if expression has type of one-bit precision, or is a known
1704 truth-valued expression. */
1706 truth_valued_ssa_name (tree name
)
1709 tree type
= TREE_TYPE (name
);
1711 if (!INTEGRAL_TYPE_P (type
))
1713 /* Don't check here for BOOLEAN_TYPE as the precision isn't
1714 necessarily one and so ~X is not equal to !X. */
1715 if (TYPE_PRECISION (type
) == 1)
1717 def
= SSA_NAME_DEF_STMT (name
);
1718 if (is_gimple_assign (def
))
1719 return truth_value_p (gimple_assign_rhs_code (def
));
1723 /* Helper routine for simplify_bitwise_binary_1 function.
1724 Return for the SSA name NAME the expression X if it mets condition
1725 NAME = !X. Otherwise return NULL_TREE.
1726 Detected patterns for NAME = !X are:
1727 !X and X == 0 for X with integral type.
1728 X ^ 1, X != 1,or ~X for X with integral type with precision of one. */
1730 lookup_logical_inverted_value (tree name
)
1733 enum tree_code code
;
1736 /* If name has none-intergal type, or isn't a SSA_NAME, then
1738 if (TREE_CODE (name
) != SSA_NAME
1739 || !INTEGRAL_TYPE_P (TREE_TYPE (name
)))
1741 def
= SSA_NAME_DEF_STMT (name
);
1742 if (!is_gimple_assign (def
))
1745 code
= gimple_assign_rhs_code (def
);
1746 op1
= gimple_assign_rhs1 (def
);
1749 /* Get for EQ_EXPR or BIT_XOR_EXPR operation the second operand.
1750 If CODE isn't an EQ_EXPR, BIT_XOR_EXPR, or BIT_NOT_EXPR, then return. */
1751 if (code
== EQ_EXPR
|| code
== NE_EXPR
1752 || code
== BIT_XOR_EXPR
)
1753 op2
= gimple_assign_rhs2 (def
);
1758 if (truth_valued_ssa_name (name
))
1762 /* Check if we have X == 0 and X has an integral type. */
1763 if (!INTEGRAL_TYPE_P (TREE_TYPE (op1
)))
1765 if (integer_zerop (op2
))
1769 /* Check if we have X != 1 and X is a truth-valued. */
1770 if (!INTEGRAL_TYPE_P (TREE_TYPE (op1
)))
1772 if (integer_onep (op2
) && truth_valued_ssa_name (op1
))
1776 /* Check if we have X ^ 1 and X is truth valued. */
1777 if (integer_onep (op2
) && truth_valued_ssa_name (op1
))
1787 /* Optimize ARG1 CODE ARG2 to a constant for bitwise binary
1788 operations CODE, if one operand has the logically inverted
1789 value of the other. */
1791 simplify_bitwise_binary_1 (enum tree_code code
, tree type
,
1792 tree arg1
, tree arg2
)
1796 /* If CODE isn't a bitwise binary operation, return NULL_TREE. */
1797 if (code
!= BIT_AND_EXPR
&& code
!= BIT_IOR_EXPR
1798 && code
!= BIT_XOR_EXPR
)
1801 /* First check if operands ARG1 and ARG2 are equal. If so
1802 return NULL_TREE as this optimization is handled fold_stmt. */
1805 /* See if we have in arguments logical-not patterns. */
1806 if (((anot
= lookup_logical_inverted_value (arg1
)) == NULL_TREE
1808 && ((anot
= lookup_logical_inverted_value (arg2
)) == NULL_TREE
1813 if (code
== BIT_AND_EXPR
)
1814 return fold_convert (type
, integer_zero_node
);
1815 /* X | !X -> 1 and X ^ !X -> 1, if X is truth-valued. */
1816 if (truth_valued_ssa_name (anot
))
1817 return fold_convert (type
, integer_one_node
);
1819 /* ??? Otherwise result is (X != 0 ? X : 1). not handled. */
1823 /* Given a ssa_name in NAME see if it was defined by an assignment and
1824 set CODE to be the code and ARG1 to the first operand on the rhs and ARG2
1825 to the second operand on the rhs. */
1828 defcodefor_name (tree name
, enum tree_code
*code
, tree
*arg1
, tree
*arg2
)
1831 enum tree_code code1
;
1835 enum gimple_rhs_class grhs_class
;
1837 code1
= TREE_CODE (name
);
1840 grhs_class
= get_gimple_rhs_class (code1
);
1842 if (code1
== SSA_NAME
)
1844 def
= SSA_NAME_DEF_STMT (name
);
1846 if (def
&& is_gimple_assign (def
)
1847 && can_propagate_from (def
))
1849 code1
= gimple_assign_rhs_code (def
);
1850 arg11
= gimple_assign_rhs1 (def
);
1851 arg21
= gimple_assign_rhs2 (def
);
1852 arg31
= gimple_assign_rhs2 (def
);
1855 else if (grhs_class
== GIMPLE_TERNARY_RHS
1856 || GIMPLE_BINARY_RHS
1858 || GIMPLE_SINGLE_RHS
)
1859 extract_ops_from_tree_1 (name
, &code1
, &arg11
, &arg21
, &arg31
);
1865 /* Ignore arg3 currently. */
1868 /* Return true if a conversion of an operand from type FROM to type TO
1869 should be applied after performing the operation instead. */
1872 hoist_conversion_for_bitop_p (tree to
, tree from
)
1874 /* That's a good idea if the conversion widens the operand, thus
1875 after hoisting the conversion the operation will be narrower. */
1876 if (TYPE_PRECISION (from
) < TYPE_PRECISION (to
))
1879 /* It's also a good idea if the conversion is to a non-integer mode. */
1880 if (GET_MODE_CLASS (TYPE_MODE (to
)) != MODE_INT
)
1883 /* Or if the precision of TO is not the same as the precision
1885 if (TYPE_PRECISION (to
) != GET_MODE_PRECISION (TYPE_MODE (to
)))
1891 /* GSI points to a statement of the form
1893 result = OP0 CODE OP1
1895 Where OP0 and OP1 are single bit SSA_NAMEs and CODE is either
1896 BIT_AND_EXPR or BIT_IOR_EXPR.
1898 If OP0 is fed by a bitwise negation of another single bit SSA_NAME,
1899 then we can simplify the two statements into a single LT_EXPR or LE_EXPR
1900 when code is BIT_AND_EXPR and BIT_IOR_EXPR respectively.
1902 If a simplification is made, return TRUE, else return FALSE. */
1904 simplify_bitwise_binary_boolean (gimple_stmt_iterator
*gsi
,
1905 enum tree_code code
,
1908 gimple op0_def_stmt
= SSA_NAME_DEF_STMT (op0
);
1910 if (!is_gimple_assign (op0_def_stmt
)
1911 || (gimple_assign_rhs_code (op0_def_stmt
) != BIT_NOT_EXPR
))
1914 tree x
= gimple_assign_rhs1 (op0_def_stmt
);
1915 if (TREE_CODE (x
) == SSA_NAME
1916 && INTEGRAL_TYPE_P (TREE_TYPE (x
))
1917 && TYPE_PRECISION (TREE_TYPE (x
)) == 1
1918 && TYPE_UNSIGNED (TREE_TYPE (x
)) == TYPE_UNSIGNED (TREE_TYPE (op1
)))
1920 enum tree_code newcode
;
1922 gimple stmt
= gsi_stmt (*gsi
);
1923 gimple_assign_set_rhs1 (stmt
, x
);
1924 gimple_assign_set_rhs2 (stmt
, op1
);
1925 if (code
== BIT_AND_EXPR
)
1926 newcode
= TYPE_UNSIGNED (TREE_TYPE (x
)) ? LT_EXPR
: GT_EXPR
;
1928 newcode
= TYPE_UNSIGNED (TREE_TYPE (x
)) ? LE_EXPR
: GE_EXPR
;
1929 gimple_assign_set_rhs_code (stmt
, newcode
);
1937 /* Simplify bitwise binary operations.
1938 Return true if a transformation applied, otherwise return false. */
1941 simplify_bitwise_binary (gimple_stmt_iterator
*gsi
)
1943 gimple stmt
= gsi_stmt (*gsi
);
1944 tree arg1
= gimple_assign_rhs1 (stmt
);
1945 tree arg2
= gimple_assign_rhs2 (stmt
);
1946 enum tree_code code
= gimple_assign_rhs_code (stmt
);
1948 tree def1_arg1
, def1_arg2
, def2_arg1
, def2_arg2
;
1949 enum tree_code def1_code
, def2_code
;
1951 defcodefor_name (arg1
, &def1_code
, &def1_arg1
, &def1_arg2
);
1952 defcodefor_name (arg2
, &def2_code
, &def2_arg1
, &def2_arg2
);
1954 /* Try to fold (type) X op CST -> (type) (X op ((type-x) CST))
1956 if (TREE_CODE (arg2
) == INTEGER_CST
1957 && CONVERT_EXPR_CODE_P (def1_code
)
1958 && hoist_conversion_for_bitop_p (TREE_TYPE (arg1
), TREE_TYPE (def1_arg1
))
1959 && INTEGRAL_TYPE_P (TREE_TYPE (def1_arg1
))
1960 && int_fits_type_p (arg2
, TREE_TYPE (def1_arg1
)))
1963 tree tem
= make_ssa_name (TREE_TYPE (def1_arg1
), NULL
);
1965 gimple_build_assign_with_ops (code
, tem
, def1_arg1
,
1966 fold_convert_loc (gimple_location (stmt
),
1967 TREE_TYPE (def1_arg1
),
1969 gimple_set_location (newop
, gimple_location (stmt
));
1970 gsi_insert_before (gsi
, newop
, GSI_SAME_STMT
);
1971 gimple_assign_set_rhs_with_ops_1 (gsi
, NOP_EXPR
,
1972 tem
, NULL_TREE
, NULL_TREE
);
1973 update_stmt (gsi_stmt (*gsi
));
1977 /* For bitwise binary operations apply operand conversions to the
1978 binary operation result instead of to the operands. This allows
1979 to combine successive conversions and bitwise binary operations. */
1980 if (CONVERT_EXPR_CODE_P (def1_code
)
1981 && CONVERT_EXPR_CODE_P (def2_code
)
1982 && types_compatible_p (TREE_TYPE (def1_arg1
), TREE_TYPE (def2_arg1
))
1983 && hoist_conversion_for_bitop_p (TREE_TYPE (arg1
), TREE_TYPE (def1_arg1
)))
1986 tree tem
= make_ssa_name (TREE_TYPE (def1_arg1
), NULL
);
1987 newop
= gimple_build_assign_with_ops (code
, tem
, def1_arg1
, def2_arg1
);
1988 gimple_set_location (newop
, gimple_location (stmt
));
1989 gsi_insert_before (gsi
, newop
, GSI_SAME_STMT
);
1990 gimple_assign_set_rhs_with_ops_1 (gsi
, NOP_EXPR
,
1991 tem
, NULL_TREE
, NULL_TREE
);
1992 update_stmt (gsi_stmt (*gsi
));
1997 /* Simplify (A & B) OP0 (C & B) to (A OP0 C) & B. */
1998 if (def1_code
== def2_code
1999 && def1_code
== BIT_AND_EXPR
2000 && operand_equal_for_phi_arg_p (def1_arg2
,
2006 tree inner
= fold_build2 (code
, TREE_TYPE (arg2
), a
, c
);
2007 /* If A OP0 C (this usually means C is the same as A) is 0
2008 then fold it down correctly. */
2009 if (integer_zerop (inner
))
2011 gimple_assign_set_rhs_from_tree (gsi
, inner
);
2015 /* If A OP0 C (this usually means C is the same as A) is a ssa_name
2016 then fold it down correctly. */
2017 else if (TREE_CODE (inner
) == SSA_NAME
)
2019 tree outer
= fold_build2 (def1_code
, TREE_TYPE (inner
),
2021 gimple_assign_set_rhs_from_tree (gsi
, outer
);
2029 tem
= make_ssa_name (TREE_TYPE (arg2
), NULL
);
2030 newop
= gimple_build_assign_with_ops (code
, tem
, a
, c
);
2031 gimple_set_location (newop
, gimple_location (stmt
));
2032 /* Make sure to re-process the new stmt as it's walking upwards. */
2033 gsi_insert_before (gsi
, newop
, GSI_NEW_STMT
);
2034 gimple_assign_set_rhs1 (stmt
, tem
);
2035 gimple_assign_set_rhs2 (stmt
, b
);
2036 gimple_assign_set_rhs_code (stmt
, def1_code
);
2042 /* (a | CST1) & CST2 -> (a & CST2) | (CST1 & CST2). */
2043 if (code
== BIT_AND_EXPR
2044 && def1_code
== BIT_IOR_EXPR
2045 && CONSTANT_CLASS_P (arg2
)
2046 && CONSTANT_CLASS_P (def1_arg2
))
2048 tree cst
= fold_build2 (BIT_AND_EXPR
, TREE_TYPE (arg2
),
2052 if (integer_zerop (cst
))
2054 gimple_assign_set_rhs1 (stmt
, def1_arg1
);
2058 tem
= make_ssa_name (TREE_TYPE (arg2
), NULL
);
2059 newop
= gimple_build_assign_with_ops (BIT_AND_EXPR
,
2060 tem
, def1_arg1
, arg2
);
2061 gimple_set_location (newop
, gimple_location (stmt
));
2062 /* Make sure to re-process the new stmt as it's walking upwards. */
2063 gsi_insert_before (gsi
, newop
, GSI_NEW_STMT
);
2064 gimple_assign_set_rhs1 (stmt
, tem
);
2065 gimple_assign_set_rhs2 (stmt
, cst
);
2066 gimple_assign_set_rhs_code (stmt
, BIT_IOR_EXPR
);
2071 /* Combine successive equal operations with constants. */
2072 if ((code
== BIT_AND_EXPR
2073 || code
== BIT_IOR_EXPR
2074 || code
== BIT_XOR_EXPR
)
2075 && def1_code
== code
2076 && CONSTANT_CLASS_P (arg2
)
2077 && CONSTANT_CLASS_P (def1_arg2
))
2079 tree cst
= fold_build2 (code
, TREE_TYPE (arg2
),
2081 gimple_assign_set_rhs1 (stmt
, def1_arg1
);
2082 gimple_assign_set_rhs2 (stmt
, cst
);
2087 /* Canonicalize X ^ ~0 to ~X. */
2088 if (code
== BIT_XOR_EXPR
2089 && integer_all_onesp (arg2
))
2091 gimple_assign_set_rhs_with_ops (gsi
, BIT_NOT_EXPR
, arg1
, NULL_TREE
);
2092 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2097 /* Try simple folding for X op !X, and X op X. */
2098 res
= simplify_bitwise_binary_1 (code
, TREE_TYPE (arg1
), arg1
, arg2
);
2099 if (res
!= NULL_TREE
)
2101 gimple_assign_set_rhs_from_tree (gsi
, res
);
2102 update_stmt (gsi_stmt (*gsi
));
2106 if (code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
)
2108 enum tree_code ocode
= code
== BIT_AND_EXPR
? BIT_IOR_EXPR
: BIT_AND_EXPR
;
2109 if (def1_code
== ocode
)
2112 enum tree_code coden
;
2114 /* ( X | Y) & X -> X */
2115 /* ( X & Y) | X -> X */
2119 gimple_assign_set_rhs_from_tree (gsi
, x
);
2120 update_stmt (gsi_stmt (*gsi
));
2124 defcodefor_name (def1_arg1
, &coden
, &a1
, &a2
);
2125 /* (~X | Y) & X -> X & Y */
2126 /* (~X & Y) | X -> X | Y */
2127 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2129 gimple_assign_set_rhs_with_ops (gsi
, code
,
2131 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2135 defcodefor_name (def1_arg2
, &coden
, &a1
, &a2
);
2136 /* (Y | ~X) & X -> X & Y */
2137 /* (Y & ~X) | X -> X | Y */
2138 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2140 gimple_assign_set_rhs_with_ops (gsi
, code
,
2142 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2147 if (def2_code
== ocode
)
2149 enum tree_code coden
;
2152 /* X & ( X | Y) -> X */
2153 /* X | ( X & Y) -> X */
2157 gimple_assign_set_rhs_from_tree (gsi
, x
);
2158 update_stmt (gsi_stmt (*gsi
));
2161 defcodefor_name (def2_arg1
, &coden
, &a1
, NULL
);
2162 /* (~X | Y) & X -> X & Y */
2163 /* (~X & Y) | X -> X | Y */
2164 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2166 gimple_assign_set_rhs_with_ops (gsi
, code
,
2168 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2172 defcodefor_name (def2_arg2
, &coden
, &a1
, NULL
);
2173 /* (Y | ~X) & X -> X & Y */
2174 /* (Y & ~X) | X -> X | Y */
2175 if (coden
== BIT_NOT_EXPR
&& a1
== x
)
2177 gimple_assign_set_rhs_with_ops (gsi
, code
,
2179 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2185 /* If arg1 and arg2 are booleans (or any single bit type)
2186 then try to simplify:
2193 But only do this if our result feeds into a comparison as
2194 this transformation is not always a win, particularly on
2195 targets with and-not instructions. */
2196 if (TREE_CODE (arg1
) == SSA_NAME
2197 && TREE_CODE (arg2
) == SSA_NAME
2198 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
2199 && TYPE_PRECISION (TREE_TYPE (arg1
)) == 1
2200 && TYPE_PRECISION (TREE_TYPE (arg2
)) == 1
2201 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
2202 == TYPE_UNSIGNED (TREE_TYPE (arg2
))))
2204 use_operand_p use_p
;
2207 if (single_imm_use (gimple_assign_lhs (stmt
), &use_p
, &use_stmt
))
2209 if (gimple_code (use_stmt
) == GIMPLE_COND
2210 && gimple_cond_lhs (use_stmt
) == gimple_assign_lhs (stmt
)
2211 && integer_zerop (gimple_cond_rhs (use_stmt
))
2212 && gimple_cond_code (use_stmt
) == NE_EXPR
)
2214 if (simplify_bitwise_binary_boolean (gsi
, code
, arg1
, arg2
))
2216 if (simplify_bitwise_binary_boolean (gsi
, code
, arg2
, arg1
))
2226 /* Recognize rotation patterns. Return true if a transformation
2227 applied, otherwise return false.
2229 We are looking for X with unsigned type T with bitsize B, OP being
2230 +, | or ^, some type T2 wider than T and
2231 (X << CNT1) OP (X >> CNT2) iff CNT1 + CNT2 == B
2232 ((T) ((T2) X << CNT1)) OP ((T) ((T2) X >> CNT2)) iff CNT1 + CNT2 == B
2233 (X << Y) OP (X >> (B - Y))
2234 (X << (int) Y) OP (X >> (int) (B - Y))
2235 ((T) ((T2) X << Y)) OP ((T) ((T2) X >> (B - Y)))
2236 ((T) ((T2) X << (int) Y)) OP ((T) ((T2) X >> (int) (B - Y)))
2237 (X << Y) | (X >> ((-Y) & (B - 1)))
2238 (X << (int) Y) | (X >> (int) ((-Y) & (B - 1)))
2239 ((T) ((T2) X << Y)) | ((T) ((T2) X >> ((-Y) & (B - 1))))
2240 ((T) ((T2) X << (int) Y)) | ((T) ((T2) X >> (int) ((-Y) & (B - 1))))
2242 and transform these into:
2246 Note, in the patterns with T2 type, the type of OP operands
2247 might be even a signed type, but should have precision B. */
2250 simplify_rotate (gimple_stmt_iterator
*gsi
)
2252 gimple stmt
= gsi_stmt (*gsi
);
2253 tree arg
[2], rtype
, rotcnt
= NULL_TREE
;
2254 tree def_arg1
[2], def_arg2
[2];
2255 enum tree_code def_code
[2];
2258 bool swapped_p
= false;
2261 arg
[0] = gimple_assign_rhs1 (stmt
);
2262 arg
[1] = gimple_assign_rhs2 (stmt
);
2263 rtype
= TREE_TYPE (arg
[0]);
2265 /* Only create rotates in complete modes. Other cases are not
2266 expanded properly. */
2267 if (!INTEGRAL_TYPE_P (rtype
)
2268 || TYPE_PRECISION (rtype
) != GET_MODE_PRECISION (TYPE_MODE (rtype
)))
2271 for (i
= 0; i
< 2; i
++)
2272 defcodefor_name (arg
[i
], &def_code
[i
], &def_arg1
[i
], &def_arg2
[i
]);
2274 /* Look through narrowing conversions. */
2275 if (CONVERT_EXPR_CODE_P (def_code
[0])
2276 && CONVERT_EXPR_CODE_P (def_code
[1])
2277 && INTEGRAL_TYPE_P (TREE_TYPE (def_arg1
[0]))
2278 && INTEGRAL_TYPE_P (TREE_TYPE (def_arg1
[1]))
2279 && TYPE_PRECISION (TREE_TYPE (def_arg1
[0]))
2280 == TYPE_PRECISION (TREE_TYPE (def_arg1
[1]))
2281 && TYPE_PRECISION (TREE_TYPE (def_arg1
[0])) > TYPE_PRECISION (rtype
)
2282 && has_single_use (arg
[0])
2283 && has_single_use (arg
[1]))
2285 for (i
= 0; i
< 2; i
++)
2287 arg
[i
] = def_arg1
[i
];
2288 defcodefor_name (arg
[i
], &def_code
[i
], &def_arg1
[i
], &def_arg2
[i
]);
2292 /* One operand has to be LSHIFT_EXPR and one RSHIFT_EXPR. */
2293 for (i
= 0; i
< 2; i
++)
2294 if (def_code
[i
] != LSHIFT_EXPR
&& def_code
[i
] != RSHIFT_EXPR
)
2296 else if (!has_single_use (arg
[i
]))
2298 if (def_code
[0] == def_code
[1])
2301 /* If we've looked through narrowing conversions before, look through
2302 widening conversions from unsigned type with the same precision
2304 if (TYPE_PRECISION (TREE_TYPE (def_arg1
[0])) != TYPE_PRECISION (rtype
))
2305 for (i
= 0; i
< 2; i
++)
2308 enum tree_code code
;
2309 defcodefor_name (def_arg1
[i
], &code
, &tem
, NULL
);
2310 if (!CONVERT_EXPR_CODE_P (code
)
2311 || !INTEGRAL_TYPE_P (TREE_TYPE (tem
))
2312 || TYPE_PRECISION (TREE_TYPE (tem
)) != TYPE_PRECISION (rtype
))
2316 /* Both shifts have to use the same first operand. */
2317 if (TREE_CODE (def_arg1
[0]) != SSA_NAME
|| def_arg1
[0] != def_arg1
[1])
2319 if (!TYPE_UNSIGNED (TREE_TYPE (def_arg1
[0])))
2322 /* CNT1 + CNT2 == B case above. */
2323 if (tree_fits_uhwi_p (def_arg2
[0])
2324 && tree_fits_uhwi_p (def_arg2
[1])
2325 && tree_to_uhwi (def_arg2
[0])
2326 + tree_to_uhwi (def_arg2
[1]) == TYPE_PRECISION (rtype
))
2327 rotcnt
= def_arg2
[0];
2328 else if (TREE_CODE (def_arg2
[0]) != SSA_NAME
2329 || TREE_CODE (def_arg2
[1]) != SSA_NAME
)
2333 tree cdef_arg1
[2], cdef_arg2
[2], def_arg2_alt
[2];
2334 enum tree_code cdef_code
[2];
2335 /* Look through conversion of the shift count argument.
2336 The C/C++ FE cast any shift count argument to integer_type_node.
2337 The only problem might be if the shift count type maximum value
2338 is equal or smaller than number of bits in rtype. */
2339 for (i
= 0; i
< 2; i
++)
2341 def_arg2_alt
[i
] = def_arg2
[i
];
2342 defcodefor_name (def_arg2
[i
], &cdef_code
[i
],
2343 &cdef_arg1
[i
], &cdef_arg2
[i
]);
2344 if (CONVERT_EXPR_CODE_P (cdef_code
[i
])
2345 && INTEGRAL_TYPE_P (TREE_TYPE (cdef_arg1
[i
]))
2346 && TYPE_PRECISION (TREE_TYPE (cdef_arg1
[i
]))
2347 > floor_log2 (TYPE_PRECISION (rtype
))
2348 && TYPE_PRECISION (TREE_TYPE (cdef_arg1
[i
]))
2349 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (cdef_arg1
[i
]))))
2351 def_arg2_alt
[i
] = cdef_arg1
[i
];
2352 defcodefor_name (def_arg2_alt
[i
], &cdef_code
[i
],
2353 &cdef_arg1
[i
], &cdef_arg2
[i
]);
2356 for (i
= 0; i
< 2; i
++)
2357 /* Check for one shift count being Y and the other B - Y,
2358 with optional casts. */
2359 if (cdef_code
[i
] == MINUS_EXPR
2360 && tree_fits_shwi_p (cdef_arg1
[i
])
2361 && tree_to_shwi (cdef_arg1
[i
]) == TYPE_PRECISION (rtype
)
2362 && TREE_CODE (cdef_arg2
[i
]) == SSA_NAME
)
2365 enum tree_code code
;
2367 if (cdef_arg2
[i
] == def_arg2
[1 - i
]
2368 || cdef_arg2
[i
] == def_arg2_alt
[1 - i
])
2370 rotcnt
= cdef_arg2
[i
];
2373 defcodefor_name (cdef_arg2
[i
], &code
, &tem
, NULL
);
2374 if (CONVERT_EXPR_CODE_P (code
)
2375 && INTEGRAL_TYPE_P (TREE_TYPE (tem
))
2376 && TYPE_PRECISION (TREE_TYPE (tem
))
2377 > floor_log2 (TYPE_PRECISION (rtype
))
2378 && TYPE_PRECISION (TREE_TYPE (tem
))
2379 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (tem
)))
2380 && (tem
== def_arg2
[1 - i
]
2381 || tem
== def_arg2_alt
[1 - i
]))
2387 /* The above sequence isn't safe for Y being 0,
2388 because then one of the shifts triggers undefined behavior.
2389 This alternative is safe even for rotation count of 0.
2390 One shift count is Y and the other (-Y) & (B - 1). */
2391 else if (cdef_code
[i
] == BIT_AND_EXPR
2392 && tree_fits_shwi_p (cdef_arg2
[i
])
2393 && tree_to_shwi (cdef_arg2
[i
])
2394 == TYPE_PRECISION (rtype
) - 1
2395 && TREE_CODE (cdef_arg1
[i
]) == SSA_NAME
2396 && gimple_assign_rhs_code (stmt
) == BIT_IOR_EXPR
)
2399 enum tree_code code
;
2401 defcodefor_name (cdef_arg1
[i
], &code
, &tem
, NULL
);
2402 if (CONVERT_EXPR_CODE_P (code
)
2403 && INTEGRAL_TYPE_P (TREE_TYPE (tem
))
2404 && TYPE_PRECISION (TREE_TYPE (tem
))
2405 > floor_log2 (TYPE_PRECISION (rtype
))
2406 && TYPE_PRECISION (TREE_TYPE (tem
))
2407 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (tem
))))
2408 defcodefor_name (tem
, &code
, &tem
, NULL
);
2410 if (code
== NEGATE_EXPR
)
2412 if (tem
== def_arg2
[1 - i
] || tem
== def_arg2_alt
[1 - i
])
2417 defcodefor_name (tem
, &code
, &tem
, NULL
);
2418 if (CONVERT_EXPR_CODE_P (code
)
2419 && INTEGRAL_TYPE_P (TREE_TYPE (tem
))
2420 && TYPE_PRECISION (TREE_TYPE (tem
))
2421 > floor_log2 (TYPE_PRECISION (rtype
))
2422 && TYPE_PRECISION (TREE_TYPE (tem
))
2423 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (tem
)))
2424 && (tem
== def_arg2
[1 - i
]
2425 || tem
== def_arg2_alt
[1 - i
]))
2432 if (rotcnt
== NULL_TREE
)
2437 if (!useless_type_conversion_p (TREE_TYPE (def_arg2
[0]),
2438 TREE_TYPE (rotcnt
)))
2440 g
= gimple_build_assign_with_ops (NOP_EXPR
,
2441 make_ssa_name (TREE_TYPE (def_arg2
[0]),
2444 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
2445 rotcnt
= gimple_assign_lhs (g
);
2447 lhs
= gimple_assign_lhs (stmt
);
2448 if (!useless_type_conversion_p (rtype
, TREE_TYPE (def_arg1
[0])))
2449 lhs
= make_ssa_name (TREE_TYPE (def_arg1
[0]), NULL
);
2450 g
= gimple_build_assign_with_ops (((def_code
[0] == LSHIFT_EXPR
) ^ swapped_p
)
2451 ? LROTATE_EXPR
: RROTATE_EXPR
,
2452 lhs
, def_arg1
[0], rotcnt
);
2453 if (!useless_type_conversion_p (rtype
, TREE_TYPE (def_arg1
[0])))
2455 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
2456 g
= gimple_build_assign_with_ops (NOP_EXPR
, gimple_assign_lhs (stmt
),
2459 gsi_replace (gsi
, g
, false);
2463 /* Perform re-associations of the plus or minus statement STMT that are
2464 always permitted. Returns true if the CFG was changed. */
2467 associate_plusminus (gimple_stmt_iterator
*gsi
)
2469 gimple stmt
= gsi_stmt (*gsi
);
2470 tree rhs1
= gimple_assign_rhs1 (stmt
);
2471 tree rhs2
= gimple_assign_rhs2 (stmt
);
2472 enum tree_code code
= gimple_assign_rhs_code (stmt
);
2475 /* We can't reassociate at all for saturating types. */
2476 if (TYPE_SATURATING (TREE_TYPE (rhs1
)))
2479 /* First contract negates. */
2484 /* A +- (-B) -> A -+ B. */
2485 if (TREE_CODE (rhs2
) == SSA_NAME
)
2487 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2488 if (is_gimple_assign (def_stmt
)
2489 && gimple_assign_rhs_code (def_stmt
) == NEGATE_EXPR
2490 && can_propagate_from (def_stmt
))
2492 code
= (code
== MINUS_EXPR
) ? PLUS_EXPR
: MINUS_EXPR
;
2493 gimple_assign_set_rhs_code (stmt
, code
);
2494 rhs2
= gimple_assign_rhs1 (def_stmt
);
2495 gimple_assign_set_rhs2 (stmt
, rhs2
);
2496 gimple_set_modified (stmt
, true);
2501 /* (-A) + B -> B - A. */
2502 if (TREE_CODE (rhs1
) == SSA_NAME
2503 && code
== PLUS_EXPR
)
2505 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2506 if (is_gimple_assign (def_stmt
)
2507 && gimple_assign_rhs_code (def_stmt
) == NEGATE_EXPR
2508 && can_propagate_from (def_stmt
))
2511 gimple_assign_set_rhs_code (stmt
, code
);
2513 gimple_assign_set_rhs1 (stmt
, rhs1
);
2514 rhs2
= gimple_assign_rhs1 (def_stmt
);
2515 gimple_assign_set_rhs2 (stmt
, rhs2
);
2516 gimple_set_modified (stmt
, true);
2523 /* We can't reassociate floating-point or fixed-point plus or minus
2524 because of saturation to +-Inf. */
2525 if (FLOAT_TYPE_P (TREE_TYPE (rhs1
))
2526 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1
)))
2529 /* Second match patterns that allow contracting a plus-minus pair
2530 irrespective of overflow issues.
2532 (A +- B) - A -> +- B
2534 (CST +- A) +- CST -> CST +- A
2535 (A +- CST) +- CST -> A +- CST
2538 A - (A +- B) -> -+ B
2539 A +- (B +- A) -> +- B
2540 CST +- (CST +- A) -> CST +- A
2541 CST +- (A +- CST) -> CST +- A
2543 (T)(P + A) - (T)P -> (T)A
2545 via commutating the addition and contracting operations to zero
2546 by reassociation. */
2548 if (TREE_CODE (rhs1
) == SSA_NAME
)
2550 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2551 if (is_gimple_assign (def_stmt
) && can_propagate_from (def_stmt
))
2553 enum tree_code def_code
= gimple_assign_rhs_code (def_stmt
);
2554 if (def_code
== PLUS_EXPR
2555 || def_code
== MINUS_EXPR
)
2557 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2558 tree def_rhs2
= gimple_assign_rhs2 (def_stmt
);
2559 if (operand_equal_p (def_rhs1
, rhs2
, 0)
2560 && code
== MINUS_EXPR
)
2562 /* (A +- B) - A -> +- B. */
2563 code
= ((def_code
== PLUS_EXPR
)
2564 ? TREE_CODE (def_rhs2
) : NEGATE_EXPR
);
2567 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2568 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2569 gimple_set_modified (stmt
, true);
2571 else if (operand_equal_p (def_rhs2
, rhs2
, 0)
2572 && code
!= def_code
)
2574 /* (A +- B) -+ B -> A. */
2575 code
= TREE_CODE (def_rhs1
);
2578 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2579 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2580 gimple_set_modified (stmt
, true);
2582 else if (CONSTANT_CLASS_P (rhs2
)
2583 && CONSTANT_CLASS_P (def_rhs1
))
2585 /* (CST +- A) +- CST -> CST +- A. */
2586 tree cst
= fold_binary (code
, TREE_TYPE (rhs1
),
2588 if (cst
&& !TREE_OVERFLOW (cst
))
2591 gimple_assign_set_rhs_code (stmt
, code
);
2593 gimple_assign_set_rhs1 (stmt
, rhs1
);
2595 gimple_assign_set_rhs2 (stmt
, rhs2
);
2596 gimple_set_modified (stmt
, true);
2599 else if (CONSTANT_CLASS_P (rhs2
)
2600 && CONSTANT_CLASS_P (def_rhs2
))
2602 /* (A +- CST) +- CST -> A +- CST. */
2603 enum tree_code mix
= (code
== def_code
)
2604 ? PLUS_EXPR
: MINUS_EXPR
;
2605 tree cst
= fold_binary (mix
, TREE_TYPE (rhs1
),
2607 if (cst
&& !TREE_OVERFLOW (cst
))
2610 gimple_assign_set_rhs_code (stmt
, code
);
2612 gimple_assign_set_rhs1 (stmt
, rhs1
);
2614 gimple_assign_set_rhs2 (stmt
, rhs2
);
2615 gimple_set_modified (stmt
, true);
2619 else if (def_code
== BIT_NOT_EXPR
&& code
== PLUS_EXPR
)
2621 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2622 if (operand_equal_p (def_rhs1
, rhs2
, 0))
2625 rhs1
= build_all_ones_cst (TREE_TYPE (rhs2
));
2627 code
= TREE_CODE (rhs1
);
2628 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2629 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2630 gimple_set_modified (stmt
, true);
2632 else if ((TREE_CODE (TREE_TYPE (rhs2
)) != COMPLEX_TYPE
2633 && integer_onep (rhs2
))
2634 || (TREE_CODE (rhs2
) == COMPLEX_CST
2635 && integer_onep (TREE_REALPART (rhs2
))
2636 && integer_onep (TREE_IMAGPART (rhs2
))))
2642 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2643 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2644 gimple_set_modified (stmt
, true);
2647 else if (CONVERT_EXPR_CODE_P (def_code
) && code
== MINUS_EXPR
2648 && TREE_CODE (rhs2
) == SSA_NAME
)
2650 /* (T)(ptr + adj) - (T)ptr -> (T)adj. */
2651 gimple def_stmt2
= SSA_NAME_DEF_STMT (rhs2
);
2652 if (TREE_CODE (gimple_assign_rhs1 (def_stmt
)) == SSA_NAME
2653 && is_gimple_assign (def_stmt2
)
2654 && can_propagate_from (def_stmt2
)
2655 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt2
))
2656 && TREE_CODE (gimple_assign_rhs1 (def_stmt2
)) == SSA_NAME
)
2658 /* Now we have (T)A - (T)ptr. */
2659 tree ptr
= gimple_assign_rhs1 (def_stmt2
);
2660 def_stmt2
= SSA_NAME_DEF_STMT (gimple_assign_rhs1 (def_stmt
));
2661 if (is_gimple_assign (def_stmt2
)
2662 && gimple_assign_rhs_code (def_stmt2
) == POINTER_PLUS_EXPR
2663 && gimple_assign_rhs1 (def_stmt2
) == ptr
)
2665 /* And finally (T)(ptr + X) - (T)ptr. */
2666 tree adj
= gimple_assign_rhs2 (def_stmt2
);
2667 /* If the conversion of the pointer adjustment to the
2668 final type requires a sign- or zero-extension we
2669 have to punt - it is not defined which one is
2671 if (TYPE_PRECISION (TREE_TYPE (rhs1
))
2672 <= TYPE_PRECISION (TREE_TYPE (adj
))
2673 || (TREE_CODE (adj
) == INTEGER_CST
2674 && tree_int_cst_sign_bit (adj
) == 0))
2676 if (useless_type_conversion_p (TREE_TYPE (rhs1
),
2679 code
= TREE_CODE (adj
);
2688 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
,
2690 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2691 gimple_set_modified (stmt
, true);
2699 if (rhs2
&& TREE_CODE (rhs2
) == SSA_NAME
)
2701 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2702 if (is_gimple_assign (def_stmt
) && can_propagate_from (def_stmt
))
2704 enum tree_code def_code
= gimple_assign_rhs_code (def_stmt
);
2705 if (def_code
== PLUS_EXPR
2706 || def_code
== MINUS_EXPR
)
2708 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2709 tree def_rhs2
= gimple_assign_rhs2 (def_stmt
);
2710 if (operand_equal_p (def_rhs1
, rhs1
, 0)
2711 && code
== MINUS_EXPR
)
2713 /* A - (A +- B) -> -+ B. */
2714 code
= ((def_code
== PLUS_EXPR
)
2715 ? NEGATE_EXPR
: TREE_CODE (def_rhs2
));
2718 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2719 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2720 gimple_set_modified (stmt
, true);
2722 else if (operand_equal_p (def_rhs2
, rhs1
, 0)
2723 && code
!= def_code
)
2725 /* A +- (B +- A) -> +- B. */
2726 code
= ((code
== PLUS_EXPR
)
2727 ? TREE_CODE (def_rhs1
) : NEGATE_EXPR
);
2730 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2731 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2732 gimple_set_modified (stmt
, true);
2734 else if (CONSTANT_CLASS_P (rhs1
)
2735 && CONSTANT_CLASS_P (def_rhs1
))
2737 /* CST +- (CST +- A) -> CST +- A. */
2738 tree cst
= fold_binary (code
, TREE_TYPE (rhs2
),
2740 if (cst
&& !TREE_OVERFLOW (cst
))
2742 code
= (code
== def_code
? PLUS_EXPR
: MINUS_EXPR
);
2743 gimple_assign_set_rhs_code (stmt
, code
);
2745 gimple_assign_set_rhs1 (stmt
, rhs1
);
2747 gimple_assign_set_rhs2 (stmt
, rhs2
);
2748 gimple_set_modified (stmt
, true);
2751 else if (CONSTANT_CLASS_P (rhs1
)
2752 && CONSTANT_CLASS_P (def_rhs2
))
2754 /* CST +- (A +- CST) -> CST +- A. */
2755 tree cst
= fold_binary (def_code
== code
2756 ? PLUS_EXPR
: MINUS_EXPR
,
2759 if (cst
&& !TREE_OVERFLOW (cst
))
2762 gimple_assign_set_rhs1 (stmt
, rhs1
);
2764 gimple_assign_set_rhs2 (stmt
, rhs2
);
2765 gimple_set_modified (stmt
, true);
2769 else if (def_code
== BIT_NOT_EXPR
)
2771 tree def_rhs1
= gimple_assign_rhs1 (def_stmt
);
2772 if (code
== PLUS_EXPR
2773 && operand_equal_p (def_rhs1
, rhs1
, 0))
2776 rhs1
= build_all_ones_cst (TREE_TYPE (rhs1
));
2778 code
= TREE_CODE (rhs1
);
2779 gimple_assign_set_rhs_with_ops (gsi
, code
, rhs1
, NULL_TREE
);
2780 gcc_assert (gsi_stmt (*gsi
) == stmt
);
2781 gimple_set_modified (stmt
, true);
2788 if (gimple_modified_p (stmt
))
2790 fold_stmt_inplace (gsi
);
2798 /* Associate operands of a POINTER_PLUS_EXPR assignmen at *GSI. Returns
2799 true if anything changed, false otherwise. */
2802 associate_pointerplus_align (gimple_stmt_iterator
*gsi
)
2804 gimple stmt
= gsi_stmt (*gsi
);
2806 tree ptr
, rhs
, algn
;
2809 tem = (sizetype) ptr;
2813 and produce the simpler and easier to analyze with respect to alignment
2814 ... = ptr & ~algn; */
2815 ptr
= gimple_assign_rhs1 (stmt
);
2816 rhs
= gimple_assign_rhs2 (stmt
);
2817 if (TREE_CODE (rhs
) != SSA_NAME
)
2819 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2820 if (!is_gimple_assign (def_stmt
)
2821 || gimple_assign_rhs_code (def_stmt
) != NEGATE_EXPR
)
2823 rhs
= gimple_assign_rhs1 (def_stmt
);
2824 if (TREE_CODE (rhs
) != SSA_NAME
)
2826 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2827 if (!is_gimple_assign (def_stmt
)
2828 || gimple_assign_rhs_code (def_stmt
) != BIT_AND_EXPR
)
2830 rhs
= gimple_assign_rhs1 (def_stmt
);
2831 algn
= gimple_assign_rhs2 (def_stmt
);
2832 if (TREE_CODE (rhs
) != SSA_NAME
2833 || TREE_CODE (algn
) != INTEGER_CST
)
2835 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2836 if (!is_gimple_assign (def_stmt
)
2837 || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
2839 if (gimple_assign_rhs1 (def_stmt
) != ptr
)
2842 algn
= double_int_to_tree (TREE_TYPE (ptr
), ~tree_to_double_int (algn
));
2843 gimple_assign_set_rhs_with_ops (gsi
, BIT_AND_EXPR
, ptr
, algn
);
2844 fold_stmt_inplace (gsi
);
2850 /* Associate operands of a POINTER_PLUS_EXPR assignmen at *GSI. Returns
2851 true if anything changed, false otherwise. */
2854 associate_pointerplus_diff (gimple_stmt_iterator
*gsi
)
2856 gimple stmt
= gsi_stmt (*gsi
);
2864 tem4 = (unsigned long) tem3;
2868 ptr1
= gimple_assign_rhs1 (stmt
);
2869 rhs
= gimple_assign_rhs2 (stmt
);
2870 if (TREE_CODE (rhs
) != SSA_NAME
)
2872 gimple minus
= SSA_NAME_DEF_STMT (rhs
);
2873 /* Conditionally look through a sign-changing conversion. */
2874 if (is_gimple_assign (minus
)
2875 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (minus
))
2876 && (TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (minus
)))
2877 == TYPE_PRECISION (TREE_TYPE (rhs
)))
2878 && TREE_CODE (gimple_assign_rhs1 (minus
)) == SSA_NAME
)
2879 minus
= SSA_NAME_DEF_STMT (gimple_assign_rhs1 (minus
));
2880 if (!is_gimple_assign (minus
))
2882 if (gimple_assign_rhs_code (minus
) != MINUS_EXPR
)
2884 rhs
= gimple_assign_rhs2 (minus
);
2885 if (TREE_CODE (rhs
) != SSA_NAME
)
2887 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2888 if (!is_gimple_assign (def_stmt
)
2889 || ! CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
))
2890 || gimple_assign_rhs1 (def_stmt
) != ptr1
)
2892 rhs
= gimple_assign_rhs1 (minus
);
2893 if (TREE_CODE (rhs
) != SSA_NAME
)
2895 def_stmt
= SSA_NAME_DEF_STMT (rhs
);
2896 if (!is_gimple_assign (def_stmt
)
2897 || ! CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
2899 rhs
= gimple_assign_rhs1 (def_stmt
);
2900 if (! useless_type_conversion_p (TREE_TYPE (ptr1
), TREE_TYPE (rhs
)))
2903 gimple_assign_set_rhs_with_ops (gsi
, TREE_CODE (rhs
), rhs
, NULL_TREE
);
2909 /* Associate operands of a POINTER_PLUS_EXPR assignmen at *GSI. Returns
2910 true if anything changed, false otherwise. */
2913 associate_pointerplus (gimple_stmt_iterator
*gsi
)
2915 gimple stmt
= gsi_stmt (*gsi
);
2917 tree ptr
, off1
, off2
;
2919 if (associate_pointerplus_align (gsi
)
2920 || associate_pointerplus_diff (gsi
))
2923 /* Associate (p +p off1) +p off2 as (p +p (off1 + off2)). */
2924 ptr
= gimple_assign_rhs1 (stmt
);
2925 off1
= gimple_assign_rhs2 (stmt
);
2926 if (TREE_CODE (ptr
) != SSA_NAME
2927 || !has_single_use (ptr
))
2929 def_stmt
= SSA_NAME_DEF_STMT (ptr
);
2930 if (!is_gimple_assign (def_stmt
)
2931 || gimple_assign_rhs_code (def_stmt
) != POINTER_PLUS_EXPR
2932 || !can_propagate_from (def_stmt
))
2934 ptr
= gimple_assign_rhs1 (def_stmt
);
2935 off2
= gimple_assign_rhs2 (def_stmt
);
2936 if (!types_compatible_p (TREE_TYPE (off1
), TREE_TYPE (off2
)))
2939 tree off
= make_ssa_name (TREE_TYPE (off1
), NULL
);
2940 gimple ostmt
= gimple_build_assign_with_ops (PLUS_EXPR
, off
, off1
, off2
);
2941 gsi_insert_before (gsi
, ostmt
, GSI_SAME_STMT
);
2943 gimple_assign_set_rhs_with_ops (gsi
, POINTER_PLUS_EXPR
, ptr
, off
);
2949 /* Combine two conversions in a row for the second conversion at *GSI.
2950 Returns 1 if there were any changes made, 2 if cfg-cleanup needs to
2951 run. Else it returns 0. */
2954 combine_conversions (gimple_stmt_iterator
*gsi
)
2956 gimple stmt
= gsi_stmt (*gsi
);
2959 enum tree_code code
= gimple_assign_rhs_code (stmt
);
2960 enum tree_code code2
;
2962 gcc_checking_assert (CONVERT_EXPR_CODE_P (code
)
2963 || code
== FLOAT_EXPR
2964 || code
== FIX_TRUNC_EXPR
);
2966 lhs
= gimple_assign_lhs (stmt
);
2967 op0
= gimple_assign_rhs1 (stmt
);
2968 if (useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (op0
)))
2970 gimple_assign_set_rhs_code (stmt
, TREE_CODE (op0
));
2974 if (TREE_CODE (op0
) != SSA_NAME
)
2977 def_stmt
= SSA_NAME_DEF_STMT (op0
);
2978 if (!is_gimple_assign (def_stmt
))
2981 code2
= gimple_assign_rhs_code (def_stmt
);
2983 if (CONVERT_EXPR_CODE_P (code2
) || code2
== FLOAT_EXPR
)
2985 tree defop0
= gimple_assign_rhs1 (def_stmt
);
2986 tree type
= TREE_TYPE (lhs
);
2987 tree inside_type
= TREE_TYPE (defop0
);
2988 tree inter_type
= TREE_TYPE (op0
);
2989 int inside_int
= INTEGRAL_TYPE_P (inside_type
);
2990 int inside_ptr
= POINTER_TYPE_P (inside_type
);
2991 int inside_float
= FLOAT_TYPE_P (inside_type
);
2992 int inside_vec
= TREE_CODE (inside_type
) == VECTOR_TYPE
;
2993 unsigned int inside_prec
= TYPE_PRECISION (inside_type
);
2994 int inside_unsignedp
= TYPE_UNSIGNED (inside_type
);
2995 int inter_int
= INTEGRAL_TYPE_P (inter_type
);
2996 int inter_ptr
= POINTER_TYPE_P (inter_type
);
2997 int inter_float
= FLOAT_TYPE_P (inter_type
);
2998 int inter_vec
= TREE_CODE (inter_type
) == VECTOR_TYPE
;
2999 unsigned int inter_prec
= TYPE_PRECISION (inter_type
);
3000 int inter_unsignedp
= TYPE_UNSIGNED (inter_type
);
3001 int final_int
= INTEGRAL_TYPE_P (type
);
3002 int final_ptr
= POINTER_TYPE_P (type
);
3003 int final_float
= FLOAT_TYPE_P (type
);
3004 int final_vec
= TREE_CODE (type
) == VECTOR_TYPE
;
3005 unsigned int final_prec
= TYPE_PRECISION (type
);
3006 int final_unsignedp
= TYPE_UNSIGNED (type
);
3008 /* Don't propagate ssa names that occur in abnormal phis. */
3009 if (TREE_CODE (defop0
) == SSA_NAME
3010 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (defop0
))
3013 /* In addition to the cases of two conversions in a row
3014 handled below, if we are converting something to its own
3015 type via an object of identical or wider precision, neither
3016 conversion is needed. */
3017 if (useless_type_conversion_p (type
, inside_type
)
3018 && (((inter_int
|| inter_ptr
) && final_int
)
3019 || (inter_float
&& final_float
))
3020 && inter_prec
>= final_prec
)
3022 gimple_assign_set_rhs1 (stmt
, unshare_expr (defop0
));
3023 gimple_assign_set_rhs_code (stmt
, TREE_CODE (defop0
));
3025 return remove_prop_source_from_use (op0
) ? 2 : 1;
3028 /* Likewise, if the intermediate and initial types are either both
3029 float or both integer, we don't need the middle conversion if the
3030 former is wider than the latter and doesn't change the signedness
3031 (for integers). Avoid this if the final type is a pointer since
3032 then we sometimes need the middle conversion. Likewise if the
3033 final type has a precision not equal to the size of its mode. */
3034 if (((inter_int
&& inside_int
)
3035 || (inter_float
&& inside_float
)
3036 || (inter_vec
&& inside_vec
))
3037 && inter_prec
>= inside_prec
3038 && (inter_float
|| inter_vec
3039 || inter_unsignedp
== inside_unsignedp
)
3040 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
3041 && TYPE_MODE (type
) == TYPE_MODE (inter_type
))
3043 && (! final_vec
|| inter_prec
== inside_prec
))
3045 gimple_assign_set_rhs1 (stmt
, defop0
);
3047 return remove_prop_source_from_use (op0
) ? 2 : 1;
3050 /* If we have a sign-extension of a zero-extended value, we can
3051 replace that by a single zero-extension. Likewise if the
3052 final conversion does not change precision we can drop the
3053 intermediate conversion. */
3054 if (inside_int
&& inter_int
&& final_int
3055 && ((inside_prec
< inter_prec
&& inter_prec
< final_prec
3056 && inside_unsignedp
&& !inter_unsignedp
)
3057 || final_prec
== inter_prec
))
3059 gimple_assign_set_rhs1 (stmt
, defop0
);
3061 return remove_prop_source_from_use (op0
) ? 2 : 1;
3064 /* Two conversions in a row are not needed unless:
3065 - some conversion is floating-point (overstrict for now), or
3066 - some conversion is a vector (overstrict for now), or
3067 - the intermediate type is narrower than both initial and
3069 - the intermediate type and innermost type differ in signedness,
3070 and the outermost type is wider than the intermediate, or
3071 - the initial type is a pointer type and the precisions of the
3072 intermediate and final types differ, or
3073 - the final type is a pointer type and the precisions of the
3074 initial and intermediate types differ. */
3075 if (! inside_float
&& ! inter_float
&& ! final_float
3076 && ! inside_vec
&& ! inter_vec
&& ! final_vec
3077 && (inter_prec
>= inside_prec
|| inter_prec
>= final_prec
)
3078 && ! (inside_int
&& inter_int
3079 && inter_unsignedp
!= inside_unsignedp
3080 && inter_prec
< final_prec
)
3081 && ((inter_unsignedp
&& inter_prec
> inside_prec
)
3082 == (final_unsignedp
&& final_prec
> inter_prec
))
3083 && ! (inside_ptr
&& inter_prec
!= final_prec
)
3084 && ! (final_ptr
&& inside_prec
!= inter_prec
)
3085 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
3086 && TYPE_MODE (type
) == TYPE_MODE (inter_type
)))
3088 gimple_assign_set_rhs1 (stmt
, defop0
);
3090 return remove_prop_source_from_use (op0
) ? 2 : 1;
3093 /* A truncation to an unsigned type should be canonicalized as
3094 bitwise and of a mask. */
3095 if (final_int
&& inter_int
&& inside_int
3096 && final_prec
== inside_prec
3097 && final_prec
> inter_prec
3101 tem
= fold_build2 (BIT_AND_EXPR
, inside_type
,
3104 (inside_type
, double_int::mask (inter_prec
)));
3105 if (!useless_type_conversion_p (type
, inside_type
))
3107 tem
= force_gimple_operand_gsi (gsi
, tem
, true, NULL_TREE
, true,
3109 gimple_assign_set_rhs1 (stmt
, tem
);
3112 gimple_assign_set_rhs_from_tree (gsi
, tem
);
3113 update_stmt (gsi_stmt (*gsi
));
3117 /* If we are converting an integer to a floating-point that can
3118 represent it exactly and back to an integer, we can skip the
3119 floating-point conversion. */
3120 if (inside_int
&& inter_float
&& final_int
&&
3121 (unsigned) significand_size (TYPE_MODE (inter_type
))
3122 >= inside_prec
- !inside_unsignedp
)
3124 if (useless_type_conversion_p (type
, inside_type
))
3126 gimple_assign_set_rhs1 (stmt
, unshare_expr (defop0
));
3127 gimple_assign_set_rhs_code (stmt
, TREE_CODE (defop0
));
3129 return remove_prop_source_from_use (op0
) ? 2 : 1;
3133 gimple_assign_set_rhs1 (stmt
, defop0
);
3134 gimple_assign_set_rhs_code (stmt
, CONVERT_EXPR
);
3136 return remove_prop_source_from_use (op0
) ? 2 : 1;
3144 /* Combine VIEW_CONVERT_EXPRs with their defining statement. */
3147 simplify_vce (gimple_stmt_iterator
*gsi
)
3149 gimple stmt
= gsi_stmt (*gsi
);
3150 tree type
= TREE_TYPE (gimple_assign_lhs (stmt
));
3152 /* Drop useless VIEW_CONVERT_EXPRs. */
3153 tree op
= TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0);
3154 if (useless_type_conversion_p (type
, TREE_TYPE (op
)))
3156 gimple_assign_set_rhs1 (stmt
, op
);
3161 if (TREE_CODE (op
) != SSA_NAME
)
3164 gimple def_stmt
= SSA_NAME_DEF_STMT (op
);
3165 if (!is_gimple_assign (def_stmt
))
3168 tree def_op
= gimple_assign_rhs1 (def_stmt
);
3169 switch (gimple_assign_rhs_code (def_stmt
))
3172 /* Strip integral conversions that do not change the precision. */
3173 if ((INTEGRAL_TYPE_P (TREE_TYPE (op
))
3174 || POINTER_TYPE_P (TREE_TYPE (op
)))
3175 && (INTEGRAL_TYPE_P (TREE_TYPE (def_op
))
3176 || POINTER_TYPE_P (TREE_TYPE (def_op
)))
3177 && (TYPE_PRECISION (TREE_TYPE (op
))
3178 == TYPE_PRECISION (TREE_TYPE (def_op
)))
3179 && (TYPE_SIZE (TREE_TYPE (op
))
3180 == TYPE_SIZE (TREE_TYPE (def_op
))))
3182 TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0) = def_op
;
3188 case VIEW_CONVERT_EXPR
:
3189 /* Series of VIEW_CONVERT_EXPRs on register operands can
3191 if (TREE_CODE (TREE_OPERAND (def_op
, 0)) == SSA_NAME
)
3193 if (useless_type_conversion_p (type
,
3194 TREE_TYPE (TREE_OPERAND (def_op
, 0))))
3195 gimple_assign_set_rhs1 (stmt
, TREE_OPERAND (def_op
, 0));
3197 TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0)
3198 = TREE_OPERAND (def_op
, 0);
3209 /* Combine an element access with a shuffle. Returns true if there were
3210 any changes made, else it returns false. */
3213 simplify_bitfield_ref (gimple_stmt_iterator
*gsi
)
3215 gimple stmt
= gsi_stmt (*gsi
);
3217 tree op
, op0
, op1
, op2
;
3219 unsigned idx
, n
, size
;
3220 enum tree_code code
;
3222 op
= gimple_assign_rhs1 (stmt
);
3223 gcc_checking_assert (TREE_CODE (op
) == BIT_FIELD_REF
);
3225 op0
= TREE_OPERAND (op
, 0);
3226 if (TREE_CODE (op0
) != SSA_NAME
3227 || TREE_CODE (TREE_TYPE (op0
)) != VECTOR_TYPE
)
3230 def_stmt
= get_prop_source_stmt (op0
, false, NULL
);
3231 if (!def_stmt
|| !can_propagate_from (def_stmt
))
3234 op1
= TREE_OPERAND (op
, 1);
3235 op2
= TREE_OPERAND (op
, 2);
3236 code
= gimple_assign_rhs_code (def_stmt
);
3238 if (code
== CONSTRUCTOR
)
3240 tree tem
= fold_ternary (BIT_FIELD_REF
, TREE_TYPE (op
),
3241 gimple_assign_rhs1 (def_stmt
), op1
, op2
);
3242 if (!tem
|| !valid_gimple_rhs_p (tem
))
3244 gimple_assign_set_rhs_from_tree (gsi
, tem
);
3245 update_stmt (gsi_stmt (*gsi
));
3249 elem_type
= TREE_TYPE (TREE_TYPE (op0
));
3250 if (TREE_TYPE (op
) != elem_type
)
3253 size
= TREE_INT_CST_LOW (TYPE_SIZE (elem_type
));
3254 n
= TREE_INT_CST_LOW (op1
) / size
;
3257 idx
= TREE_INT_CST_LOW (op2
) / size
;
3259 if (code
== VEC_PERM_EXPR
)
3261 tree p
, m
, index
, tem
;
3263 m
= gimple_assign_rhs3 (def_stmt
);
3264 if (TREE_CODE (m
) != VECTOR_CST
)
3266 nelts
= VECTOR_CST_NELTS (m
);
3267 idx
= TREE_INT_CST_LOW (VECTOR_CST_ELT (m
, idx
));
3271 p
= gimple_assign_rhs1 (def_stmt
);
3275 p
= gimple_assign_rhs2 (def_stmt
);
3278 index
= build_int_cst (TREE_TYPE (TREE_TYPE (m
)), idx
* size
);
3279 tem
= build3 (BIT_FIELD_REF
, TREE_TYPE (op
),
3280 unshare_expr (p
), op1
, index
);
3281 gimple_assign_set_rhs1 (stmt
, tem
);
3283 update_stmt (gsi_stmt (*gsi
));
3290 /* Determine whether applying the 2 permutations (mask1 then mask2)
3291 gives back one of the input. */
3294 is_combined_permutation_identity (tree mask1
, tree mask2
)
3297 unsigned int nelts
, i
, j
;
3298 bool maybe_identity1
= true;
3299 bool maybe_identity2
= true;
3301 gcc_checking_assert (TREE_CODE (mask1
) == VECTOR_CST
3302 && TREE_CODE (mask2
) == VECTOR_CST
);
3303 mask
= fold_ternary (VEC_PERM_EXPR
, TREE_TYPE (mask1
), mask1
, mask1
, mask2
);
3304 gcc_assert (TREE_CODE (mask
) == VECTOR_CST
);
3306 nelts
= VECTOR_CST_NELTS (mask
);
3307 for (i
= 0; i
< nelts
; i
++)
3309 tree val
= VECTOR_CST_ELT (mask
, i
);
3310 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
3311 j
= TREE_INT_CST_LOW (val
) & (2 * nelts
- 1);
3313 maybe_identity2
= false;
3314 else if (j
== i
+ nelts
)
3315 maybe_identity1
= false;
3319 return maybe_identity1
? 1 : maybe_identity2
? 2 : 0;
3322 /* Combine a shuffle with its arguments. Returns 1 if there were any
3323 changes made, 2 if cfg-cleanup needs to run. Else it returns 0. */
3326 simplify_permutation (gimple_stmt_iterator
*gsi
)
3328 gimple stmt
= gsi_stmt (*gsi
);
3330 tree op0
, op1
, op2
, op3
, arg0
, arg1
;
3331 enum tree_code code
;
3332 bool single_use_op0
= false;
3334 gcc_checking_assert (gimple_assign_rhs_code (stmt
) == VEC_PERM_EXPR
);
3336 op0
= gimple_assign_rhs1 (stmt
);
3337 op1
= gimple_assign_rhs2 (stmt
);
3338 op2
= gimple_assign_rhs3 (stmt
);
3340 if (TREE_CODE (op2
) != VECTOR_CST
)
3343 if (TREE_CODE (op0
) == VECTOR_CST
)
3348 else if (TREE_CODE (op0
) == SSA_NAME
)
3350 def_stmt
= get_prop_source_stmt (op0
, false, &single_use_op0
);
3351 if (!def_stmt
|| !can_propagate_from (def_stmt
))
3354 code
= gimple_assign_rhs_code (def_stmt
);
3355 arg0
= gimple_assign_rhs1 (def_stmt
);
3360 /* Two consecutive shuffles. */
3361 if (code
== VEC_PERM_EXPR
)
3368 op3
= gimple_assign_rhs3 (def_stmt
);
3369 if (TREE_CODE (op3
) != VECTOR_CST
)
3371 ident
= is_combined_permutation_identity (op3
, op2
);
3374 orig
= (ident
== 1) ? gimple_assign_rhs1 (def_stmt
)
3375 : gimple_assign_rhs2 (def_stmt
);
3376 gimple_assign_set_rhs1 (stmt
, unshare_expr (orig
));
3377 gimple_assign_set_rhs_code (stmt
, TREE_CODE (orig
));
3378 gimple_set_num_ops (stmt
, 2);
3380 return remove_prop_source_from_use (op0
) ? 2 : 1;
3383 /* Shuffle of a constructor. */
3384 else if (code
== CONSTRUCTOR
|| code
== VECTOR_CST
)
3390 if (TREE_CODE (op0
) == SSA_NAME
&& !single_use_op0
)
3393 if (TREE_CODE (op1
) == VECTOR_CST
)
3395 else if (TREE_CODE (op1
) == SSA_NAME
)
3397 enum tree_code code2
;
3399 gimple def_stmt2
= get_prop_source_stmt (op1
, true, NULL
);
3400 if (!def_stmt2
|| !can_propagate_from (def_stmt2
))
3403 code2
= gimple_assign_rhs_code (def_stmt2
);
3404 if (code2
!= CONSTRUCTOR
&& code2
!= VECTOR_CST
)
3406 arg1
= gimple_assign_rhs1 (def_stmt2
);
3413 /* Already used twice in this statement. */
3414 if (TREE_CODE (op0
) == SSA_NAME
&& num_imm_uses (op0
) > 2)
3418 opt
= fold_ternary (VEC_PERM_EXPR
, TREE_TYPE (op0
), arg0
, arg1
, op2
);
3420 || (TREE_CODE (opt
) != CONSTRUCTOR
&& TREE_CODE (opt
) != VECTOR_CST
))
3422 gimple_assign_set_rhs_from_tree (gsi
, opt
);
3423 update_stmt (gsi_stmt (*gsi
));
3424 if (TREE_CODE (op0
) == SSA_NAME
)
3425 ret
= remove_prop_source_from_use (op0
);
3426 if (op0
!= op1
&& TREE_CODE (op1
) == SSA_NAME
)
3427 ret
|= remove_prop_source_from_use (op1
);
3434 /* Recognize a VEC_PERM_EXPR. Returns true if there were any changes. */
3437 simplify_vector_constructor (gimple_stmt_iterator
*gsi
)
3439 gimple stmt
= gsi_stmt (*gsi
);
3441 tree op
, op2
, orig
, type
, elem_type
;
3442 unsigned elem_size
, nelts
, i
;
3443 enum tree_code code
;
3444 constructor_elt
*elt
;
3448 gcc_checking_assert (gimple_assign_rhs_code (stmt
) == CONSTRUCTOR
);
3450 op
= gimple_assign_rhs1 (stmt
);
3451 type
= TREE_TYPE (op
);
3452 gcc_checking_assert (TREE_CODE (type
) == VECTOR_TYPE
);
3454 nelts
= TYPE_VECTOR_SUBPARTS (type
);
3455 elem_type
= TREE_TYPE (type
);
3456 elem_size
= TREE_INT_CST_LOW (TYPE_SIZE (elem_type
));
3458 sel
= XALLOCAVEC (unsigned char, nelts
);
3461 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (op
), i
, elt
)
3468 if (TREE_CODE (elt
->value
) != SSA_NAME
)
3470 def_stmt
= get_prop_source_stmt (elt
->value
, false, NULL
);
3473 code
= gimple_assign_rhs_code (def_stmt
);
3474 if (code
!= BIT_FIELD_REF
)
3476 op1
= gimple_assign_rhs1 (def_stmt
);
3477 ref
= TREE_OPERAND (op1
, 0);
3485 if (TREE_CODE (ref
) != SSA_NAME
)
3487 if (!useless_type_conversion_p (type
, TREE_TYPE (ref
)))
3491 if (TREE_INT_CST_LOW (TREE_OPERAND (op1
, 1)) != elem_size
)
3493 sel
[i
] = TREE_INT_CST_LOW (TREE_OPERAND (op1
, 2)) / elem_size
;
3494 if (sel
[i
] != i
) maybe_ident
= false;
3500 gimple_assign_set_rhs_from_tree (gsi
, orig
);
3503 tree mask_type
, *mask_elts
;
3505 if (!can_vec_perm_p (TYPE_MODE (type
), false, sel
))
3508 = build_vector_type (build_nonstandard_integer_type (elem_size
, 1),
3510 if (GET_MODE_CLASS (TYPE_MODE (mask_type
)) != MODE_VECTOR_INT
3511 || GET_MODE_SIZE (TYPE_MODE (mask_type
))
3512 != GET_MODE_SIZE (TYPE_MODE (type
)))
3514 mask_elts
= XALLOCAVEC (tree
, nelts
);
3515 for (i
= 0; i
< nelts
; i
++)
3516 mask_elts
[i
] = build_int_cst (TREE_TYPE (mask_type
), sel
[i
]);
3517 op2
= build_vector (mask_type
, mask_elts
);
3518 gimple_assign_set_rhs_with_ops_1 (gsi
, VEC_PERM_EXPR
, orig
, orig
, op2
);
3520 update_stmt (gsi_stmt (*gsi
));
3524 /* Simplify multiplications.
3525 Return true if a transformation applied, otherwise return false. */
3528 simplify_mult (gimple_stmt_iterator
*gsi
)
3530 gimple stmt
= gsi_stmt (*gsi
);
3531 tree arg1
= gimple_assign_rhs1 (stmt
);
3532 tree arg2
= gimple_assign_rhs2 (stmt
);
3534 if (TREE_CODE (arg1
) != SSA_NAME
)
3537 gimple def_stmt
= SSA_NAME_DEF_STMT (arg1
);
3538 if (!is_gimple_assign (def_stmt
))
3541 /* Look through a sign-changing conversion. */
3542 if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
3544 if (TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (def_stmt
)))
3545 != TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt
)))
3546 || TREE_CODE (gimple_assign_rhs1 (def_stmt
)) != SSA_NAME
)
3548 def_stmt
= SSA_NAME_DEF_STMT (gimple_assign_rhs1 (def_stmt
));
3549 if (!is_gimple_assign (def_stmt
))
3553 if (gimple_assign_rhs_code (def_stmt
) == EXACT_DIV_EXPR
)
3555 if (operand_equal_p (gimple_assign_rhs2 (def_stmt
), arg2
, 0))
3557 tree res
= gimple_assign_rhs1 (def_stmt
);
3558 if (useless_type_conversion_p (TREE_TYPE (arg1
), TREE_TYPE (res
)))
3559 gimple_assign_set_rhs_with_ops (gsi
, TREE_CODE (res
), res
,
3562 gimple_assign_set_rhs_with_ops (gsi
, NOP_EXPR
, res
, NULL_TREE
);
3563 gcc_assert (gsi_stmt (*gsi
) == stmt
);
3571 /* Main entry point for the forward propagation and statement combine
3575 ssa_forward_propagate_and_combine (void)
3578 unsigned int todoflags
= 0;
3580 cfg_changed
= false;
3582 FOR_EACH_BB_FN (bb
, cfun
)
3584 gimple_stmt_iterator gsi
;
3586 /* Apply forward propagation to all stmts in the basic-block.
3587 Note we update GSI within the loop as necessary. */
3588 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
3590 gimple stmt
= gsi_stmt (gsi
);
3592 enum tree_code code
;
3594 if (!is_gimple_assign (stmt
))
3600 lhs
= gimple_assign_lhs (stmt
);
3601 rhs
= gimple_assign_rhs1 (stmt
);
3602 code
= gimple_assign_rhs_code (stmt
);
3603 if (TREE_CODE (lhs
) != SSA_NAME
3604 || has_zero_uses (lhs
))
3610 /* If this statement sets an SSA_NAME to an address,
3611 try to propagate the address into the uses of the SSA_NAME. */
3612 if (code
== ADDR_EXPR
3613 /* Handle pointer conversions on invariant addresses
3614 as well, as this is valid gimple. */
3615 || (CONVERT_EXPR_CODE_P (code
)
3616 && TREE_CODE (rhs
) == ADDR_EXPR
3617 && POINTER_TYPE_P (TREE_TYPE (lhs
))))
3619 tree base
= get_base_address (TREE_OPERAND (rhs
, 0));
3622 || decl_address_invariant_p (base
))
3623 && !stmt_references_abnormal_ssa_name (stmt
)
3624 && forward_propagate_addr_expr (lhs
, rhs
, true))
3626 release_defs (stmt
);
3627 gsi_remove (&gsi
, true);
3632 else if (code
== POINTER_PLUS_EXPR
)
3634 tree off
= gimple_assign_rhs2 (stmt
);
3635 if (TREE_CODE (off
) == INTEGER_CST
3636 && can_propagate_from (stmt
)
3637 && !simple_iv_increment_p (stmt
)
3638 /* ??? Better adjust the interface to that function
3639 instead of building new trees here. */
3640 && forward_propagate_addr_expr
3642 build1_loc (gimple_location (stmt
),
3643 ADDR_EXPR
, TREE_TYPE (rhs
),
3644 fold_build2 (MEM_REF
,
3645 TREE_TYPE (TREE_TYPE (rhs
)),
3647 fold_convert (ptr_type_node
,
3650 release_defs (stmt
);
3651 gsi_remove (&gsi
, true);
3653 else if (is_gimple_min_invariant (rhs
))
3655 /* Make sure to fold &a[0] + off_1 here. */
3656 fold_stmt_inplace (&gsi
);
3658 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
3664 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3666 if (forward_propagate_comparison (&gsi
))
3673 /* Combine stmts with the stmts defining their operands.
3674 Note we update GSI within the loop as necessary. */
3675 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
3677 gimple stmt
= gsi_stmt (gsi
);
3678 bool changed
= false;
3680 /* Mark stmt as potentially needing revisiting. */
3681 gimple_set_plf (stmt
, GF_PLF_1
, false);
3683 switch (gimple_code (stmt
))
3687 tree rhs1
= gimple_assign_rhs1 (stmt
);
3688 enum tree_code code
= gimple_assign_rhs_code (stmt
);
3690 if ((code
== BIT_NOT_EXPR
3691 || code
== NEGATE_EXPR
)
3692 && TREE_CODE (rhs1
) == SSA_NAME
)
3693 changed
= simplify_not_neg_expr (&gsi
);
3694 else if (code
== COND_EXPR
3695 || code
== VEC_COND_EXPR
)
3697 /* In this case the entire COND_EXPR is in rhs1. */
3698 if (forward_propagate_into_cond (&gsi
)
3699 || combine_cond_exprs (&gsi
))
3702 stmt
= gsi_stmt (gsi
);
3705 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3708 did_something
= forward_propagate_into_comparison (&gsi
);
3709 if (did_something
== 2)
3711 changed
= did_something
!= 0;
3713 else if ((code
== PLUS_EXPR
3714 || code
== BIT_IOR_EXPR
3715 || code
== BIT_XOR_EXPR
)
3716 && simplify_rotate (&gsi
))
3718 else if (code
== BIT_AND_EXPR
3719 || code
== BIT_IOR_EXPR
3720 || code
== BIT_XOR_EXPR
)
3721 changed
= simplify_bitwise_binary (&gsi
);
3722 else if (code
== MULT_EXPR
)
3724 changed
= simplify_mult (&gsi
);
3726 && maybe_clean_or_replace_eh_stmt (stmt
, stmt
)
3727 && gimple_purge_dead_eh_edges (bb
))
3730 else if (code
== PLUS_EXPR
3731 || code
== MINUS_EXPR
)
3733 changed
= associate_plusminus (&gsi
);
3735 && maybe_clean_or_replace_eh_stmt (stmt
, stmt
)
3736 && gimple_purge_dead_eh_edges (bb
))
3739 else if (code
== POINTER_PLUS_EXPR
)
3740 changed
= associate_pointerplus (&gsi
);
3741 else if (CONVERT_EXPR_CODE_P (code
)
3742 || code
== FLOAT_EXPR
3743 || code
== FIX_TRUNC_EXPR
)
3745 int did_something
= combine_conversions (&gsi
);
3746 if (did_something
== 2)
3749 /* If we have a narrowing conversion to an integral
3750 type that is fed by a BIT_AND_EXPR, we might be
3751 able to remove the BIT_AND_EXPR if it merely
3752 masks off bits outside the final type (and nothing
3754 if (! did_something
)
3756 tree outer_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
3757 tree inner_type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
3758 if (TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
3759 && INTEGRAL_TYPE_P (outer_type
)
3760 && INTEGRAL_TYPE_P (inner_type
)
3761 && (TYPE_PRECISION (outer_type
)
3762 <= TYPE_PRECISION (inner_type
)))
3763 did_something
= simplify_conversion_from_bitmask (&gsi
);
3766 changed
= did_something
!= 0;
3768 else if (code
== VIEW_CONVERT_EXPR
)
3769 changed
= simplify_vce (&gsi
);
3770 else if (code
== VEC_PERM_EXPR
)
3772 int did_something
= simplify_permutation (&gsi
);
3773 if (did_something
== 2)
3775 changed
= did_something
!= 0;
3777 else if (code
== BIT_FIELD_REF
)
3778 changed
= simplify_bitfield_ref (&gsi
);
3779 else if (code
== CONSTRUCTOR
3780 && TREE_CODE (TREE_TYPE (rhs1
)) == VECTOR_TYPE
)
3781 changed
= simplify_vector_constructor (&gsi
);
3786 changed
= simplify_gimple_switch (stmt
);
3792 did_something
= forward_propagate_into_gimple_cond (stmt
);
3793 if (did_something
== 2)
3795 changed
= did_something
!= 0;
3801 tree callee
= gimple_call_fndecl (stmt
);
3802 if (callee
!= NULL_TREE
3803 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
3804 changed
= simplify_builtin_call (&gsi
, callee
);
3813 /* If the stmt changed then re-visit it and the statements
3814 inserted before it. */
3815 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
3816 if (gimple_plf (gsi_stmt (gsi
), GF_PLF_1
))
3818 if (gsi_end_p (gsi
))
3819 gsi
= gsi_start_bb (bb
);
3825 /* Stmt no longer needs to be revisited. */
3826 gimple_set_plf (stmt
, GF_PLF_1
, true);
3833 todoflags
|= TODO_cleanup_cfg
;
3840 gate_forwprop (void)
3842 return flag_tree_forwprop
;
3847 const pass_data pass_data_forwprop
=
3849 GIMPLE_PASS
, /* type */
3850 "forwprop", /* name */
3851 OPTGROUP_NONE
, /* optinfo_flags */
3852 true, /* has_gate */
3853 true, /* has_execute */
3854 TV_TREE_FORWPROP
, /* tv_id */
3855 ( PROP_cfg
| PROP_ssa
), /* properties_required */
3856 0, /* properties_provided */
3857 0, /* properties_destroyed */
3858 0, /* todo_flags_start */
3859 ( TODO_update_ssa
| TODO_verify_ssa
), /* todo_flags_finish */
3862 class pass_forwprop
: public gimple_opt_pass
3865 pass_forwprop (gcc::context
*ctxt
)
3866 : gimple_opt_pass (pass_data_forwprop
, ctxt
)
3869 /* opt_pass methods: */
3870 opt_pass
* clone () { return new pass_forwprop (m_ctxt
); }
3871 bool gate () { return gate_forwprop (); }
3872 unsigned int execute () { return ssa_forward_propagate_and_combine (); }
3874 }; // class pass_forwprop
3879 make_pass_forwprop (gcc::context
*ctxt
)
3881 return new pass_forwprop (ctxt
);