1 /* Global, SSA-based optimizations using mathematical identities.
2 Copyright (C) 2005-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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/>. */
20 /* Currently, the only mini-pass in this file tries to CSE reciprocal
21 operations. These are common in sequences such as this one:
23 modulus = sqrt(x*x + y*y + z*z);
28 that can be optimized to
30 modulus = sqrt(x*x + y*y + z*z);
31 rmodulus = 1.0 / modulus;
36 We do this for loop invariant divisors, and with this pass whenever
37 we notice that a division has the same divisor multiple times.
39 Of course, like in PRE, we don't insert a division if a dominator
40 already has one. However, this cannot be done as an extension of
41 PRE for several reasons.
43 First of all, with some experiments it was found out that the
44 transformation is not always useful if there are only two divisions
45 hy the same divisor. This is probably because modern processors
46 can pipeline the divisions; on older, in-order processors it should
47 still be effective to optimize two divisions by the same number.
48 We make this a param, and it shall be called N in the remainder of
51 Second, if trapping math is active, we have less freedom on where
52 to insert divisions: we can only do so in basic blocks that already
53 contain one. (If divisions don't trap, instead, we can insert
54 divisions elsewhere, which will be in blocks that are common dominators
55 of those that have the division).
57 We really don't want to compute the reciprocal unless a division will
58 be found. To do this, we won't insert the division in a basic block
59 that has less than N divisions *post-dominating* it.
61 The algorithm constructs a subset of the dominator tree, holding the
62 blocks containing the divisions and the common dominators to them,
63 and walk it twice. The first walk is in post-order, and it annotates
64 each block with the number of divisions that post-dominate it: this
65 gives information on where divisions can be inserted profitably.
66 The second walk is in pre-order, and it inserts divisions as explained
67 above, and replaces divisions by multiplications.
69 In the best case, the cost of the pass is O(n_statements). In the
70 worst-case, the cost is due to creating the dominator tree subset,
71 with a cost of O(n_basic_blocks ^ 2); however this can only happen
72 for n_statements / n_basic_blocks statements. So, the amortized cost
73 of creating the dominator tree subset is O(n_basic_blocks) and the
74 worst-case cost of the pass is O(n_statements * n_basic_blocks).
76 More practically, the cost will be small because there are few
77 divisions, and they tend to be in the same basic block, so insert_bb
78 is called very few times.
80 If we did this using domwalk.c, an efficient implementation would have
81 to work on all the variables in a single pass, because we could not
82 work on just a subset of the dominator tree, as we do now, and the
83 cost would also be something like O(n_statements * n_basic_blocks).
84 The data structures would be more complex in order to work on all the
85 variables in a single pass. */
89 #include "coretypes.h"
94 #include "gimple-iterator.h"
95 #include "gimplify-me.h"
96 #include "gimple-ssa.h"
98 #include "tree-phinodes.h"
99 #include "ssa-iterators.h"
100 #include "tree-ssanames.h"
101 #include "tree-dfa.h"
102 #include "tree-ssa.h"
103 #include "tree-pass.h"
104 #include "alloc-pool.h"
105 #include "basic-block.h"
107 #include "gimple-pretty-print.h"
109 /* FIXME: RTL headers have to be included here for optabs. */
110 #include "rtl.h" /* Because optabs.h wants enum rtx_code. */
111 #include "expr.h" /* Because optabs.h wants sepops. */
114 /* This structure represents one basic block that either computes a
115 division, or is a common dominator for basic block that compute a
118 /* The basic block represented by this structure. */
121 /* If non-NULL, the SSA_NAME holding the definition for a reciprocal
125 /* If non-NULL, the GIMPLE_ASSIGN for a reciprocal computation that
126 was inserted in BB. */
127 gimple recip_def_stmt
;
129 /* Pointer to a list of "struct occurrence"s for blocks dominated
131 struct occurrence
*children
;
133 /* Pointer to the next "struct occurrence"s in the list of blocks
134 sharing a common dominator. */
135 struct occurrence
*next
;
137 /* The number of divisions that are in BB before compute_merit. The
138 number of divisions that are in BB or post-dominate it after
142 /* True if the basic block has a division, false if it is a common
143 dominator for basic blocks that do. If it is false and trapping
144 math is active, BB is not a candidate for inserting a reciprocal. */
145 bool bb_has_division
;
150 /* Number of 1.0/X ops inserted. */
153 /* Number of 1.0/FUNC ops inserted. */
159 /* Number of cexpi calls inserted. */
165 /* Number of hand-written 16-bit bswaps found. */
168 /* Number of hand-written 32-bit bswaps found. */
171 /* Number of hand-written 64-bit bswaps found. */
177 /* Number of widening multiplication ops inserted. */
178 int widen_mults_inserted
;
180 /* Number of integer multiply-and-accumulate ops inserted. */
183 /* Number of fp fused multiply-add ops inserted. */
187 /* The instance of "struct occurrence" representing the highest
188 interesting block in the dominator tree. */
189 static struct occurrence
*occ_head
;
191 /* Allocation pool for getting instances of "struct occurrence". */
192 static alloc_pool occ_pool
;
196 /* Allocate and return a new struct occurrence for basic block BB, and
197 whose children list is headed by CHILDREN. */
198 static struct occurrence
*
199 occ_new (basic_block bb
, struct occurrence
*children
)
201 struct occurrence
*occ
;
203 bb
->aux
= occ
= (struct occurrence
*) pool_alloc (occ_pool
);
204 memset (occ
, 0, sizeof (struct occurrence
));
207 occ
->children
= children
;
212 /* Insert NEW_OCC into our subset of the dominator tree. P_HEAD points to a
213 list of "struct occurrence"s, one per basic block, having IDOM as
214 their common dominator.
216 We try to insert NEW_OCC as deep as possible in the tree, and we also
217 insert any other block that is a common dominator for BB and one
218 block already in the tree. */
221 insert_bb (struct occurrence
*new_occ
, basic_block idom
,
222 struct occurrence
**p_head
)
224 struct occurrence
*occ
, **p_occ
;
226 for (p_occ
= p_head
; (occ
= *p_occ
) != NULL
; )
228 basic_block bb
= new_occ
->bb
, occ_bb
= occ
->bb
;
229 basic_block dom
= nearest_common_dominator (CDI_DOMINATORS
, occ_bb
, bb
);
232 /* BB dominates OCC_BB. OCC becomes NEW_OCC's child: remove OCC
235 occ
->next
= new_occ
->children
;
236 new_occ
->children
= occ
;
238 /* Try the next block (it may as well be dominated by BB). */
241 else if (dom
== occ_bb
)
243 /* OCC_BB dominates BB. Tail recurse to look deeper. */
244 insert_bb (new_occ
, dom
, &occ
->children
);
248 else if (dom
!= idom
)
250 gcc_assert (!dom
->aux
);
252 /* There is a dominator between IDOM and BB, add it and make
253 two children out of NEW_OCC and OCC. First, remove OCC from
259 /* None of the previous blocks has DOM as a dominator: if we tail
260 recursed, we would reexamine them uselessly. Just switch BB with
261 DOM, and go on looking for blocks dominated by DOM. */
262 new_occ
= occ_new (dom
, new_occ
);
267 /* Nothing special, go on with the next element. */
272 /* No place was found as a child of IDOM. Make BB a sibling of IDOM. */
273 new_occ
->next
= *p_head
;
277 /* Register that we found a division in BB. */
280 register_division_in (basic_block bb
)
282 struct occurrence
*occ
;
284 occ
= (struct occurrence
*) bb
->aux
;
287 occ
= occ_new (bb
, NULL
);
288 insert_bb (occ
, ENTRY_BLOCK_PTR
, &occ_head
);
291 occ
->bb_has_division
= true;
292 occ
->num_divisions
++;
296 /* Compute the number of divisions that postdominate each block in OCC and
300 compute_merit (struct occurrence
*occ
)
302 struct occurrence
*occ_child
;
303 basic_block dom
= occ
->bb
;
305 for (occ_child
= occ
->children
; occ_child
; occ_child
= occ_child
->next
)
308 if (occ_child
->children
)
309 compute_merit (occ_child
);
312 bb
= single_noncomplex_succ (dom
);
316 if (dominated_by_p (CDI_POST_DOMINATORS
, bb
, occ_child
->bb
))
317 occ
->num_divisions
+= occ_child
->num_divisions
;
322 /* Return whether USE_STMT is a floating-point division by DEF. */
324 is_division_by (gimple use_stmt
, tree def
)
326 return is_gimple_assign (use_stmt
)
327 && gimple_assign_rhs_code (use_stmt
) == RDIV_EXPR
328 && gimple_assign_rhs2 (use_stmt
) == def
329 /* Do not recognize x / x as valid division, as we are getting
330 confused later by replacing all immediate uses x in such
332 && gimple_assign_rhs1 (use_stmt
) != def
;
335 /* Walk the subset of the dominator tree rooted at OCC, setting the
336 RECIP_DEF field to a definition of 1.0 / DEF that can be used in
337 the given basic block. The field may be left NULL, of course,
338 if it is not possible or profitable to do the optimization.
340 DEF_BSI is an iterator pointing at the statement defining DEF.
341 If RECIP_DEF is set, a dominator already has a computation that can
345 insert_reciprocals (gimple_stmt_iterator
*def_gsi
, struct occurrence
*occ
,
346 tree def
, tree recip_def
, int threshold
)
350 gimple_stmt_iterator gsi
;
351 struct occurrence
*occ_child
;
354 && (occ
->bb_has_division
|| !flag_trapping_math
)
355 && occ
->num_divisions
>= threshold
)
357 /* Make a variable with the replacement and substitute it. */
358 type
= TREE_TYPE (def
);
359 recip_def
= create_tmp_reg (type
, "reciptmp");
360 new_stmt
= gimple_build_assign_with_ops (RDIV_EXPR
, recip_def
,
361 build_one_cst (type
), def
);
363 if (occ
->bb_has_division
)
365 /* Case 1: insert before an existing division. */
366 gsi
= gsi_after_labels (occ
->bb
);
367 while (!gsi_end_p (gsi
) && !is_division_by (gsi_stmt (gsi
), def
))
370 gsi_insert_before (&gsi
, new_stmt
, GSI_SAME_STMT
);
372 else if (def_gsi
&& occ
->bb
== def_gsi
->bb
)
374 /* Case 2: insert right after the definition. Note that this will
375 never happen if the definition statement can throw, because in
376 that case the sole successor of the statement's basic block will
377 dominate all the uses as well. */
378 gsi_insert_after (def_gsi
, new_stmt
, GSI_NEW_STMT
);
382 /* Case 3: insert in a basic block not containing defs/uses. */
383 gsi
= gsi_after_labels (occ
->bb
);
384 gsi_insert_before (&gsi
, new_stmt
, GSI_SAME_STMT
);
387 reciprocal_stats
.rdivs_inserted
++;
389 occ
->recip_def_stmt
= new_stmt
;
392 occ
->recip_def
= recip_def
;
393 for (occ_child
= occ
->children
; occ_child
; occ_child
= occ_child
->next
)
394 insert_reciprocals (def_gsi
, occ_child
, def
, recip_def
, threshold
);
398 /* Replace the division at USE_P with a multiplication by the reciprocal, if
402 replace_reciprocal (use_operand_p use_p
)
404 gimple use_stmt
= USE_STMT (use_p
);
405 basic_block bb
= gimple_bb (use_stmt
);
406 struct occurrence
*occ
= (struct occurrence
*) bb
->aux
;
408 if (optimize_bb_for_speed_p (bb
)
409 && occ
->recip_def
&& use_stmt
!= occ
->recip_def_stmt
)
411 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
412 gimple_assign_set_rhs_code (use_stmt
, MULT_EXPR
);
413 SET_USE (use_p
, occ
->recip_def
);
414 fold_stmt_inplace (&gsi
);
415 update_stmt (use_stmt
);
420 /* Free OCC and return one more "struct occurrence" to be freed. */
422 static struct occurrence
*
423 free_bb (struct occurrence
*occ
)
425 struct occurrence
*child
, *next
;
427 /* First get the two pointers hanging off OCC. */
429 child
= occ
->children
;
431 pool_free (occ_pool
, occ
);
433 /* Now ensure that we don't recurse unless it is necessary. */
439 next
= free_bb (next
);
446 /* Look for floating-point divisions among DEF's uses, and try to
447 replace them by multiplications with the reciprocal. Add
448 as many statements computing the reciprocal as needed.
450 DEF must be a GIMPLE register of a floating-point type. */
453 execute_cse_reciprocals_1 (gimple_stmt_iterator
*def_gsi
, tree def
)
456 imm_use_iterator use_iter
;
457 struct occurrence
*occ
;
458 int count
= 0, threshold
;
460 gcc_assert (FLOAT_TYPE_P (TREE_TYPE (def
)) && is_gimple_reg (def
));
462 FOR_EACH_IMM_USE_FAST (use_p
, use_iter
, def
)
464 gimple use_stmt
= USE_STMT (use_p
);
465 if (is_division_by (use_stmt
, def
))
467 register_division_in (gimple_bb (use_stmt
));
472 /* Do the expensive part only if we can hope to optimize something. */
473 threshold
= targetm
.min_divisions_for_recip_mul (TYPE_MODE (TREE_TYPE (def
)));
474 if (count
>= threshold
)
477 for (occ
= occ_head
; occ
; occ
= occ
->next
)
480 insert_reciprocals (def_gsi
, occ
, def
, NULL
, threshold
);
483 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, def
)
485 if (is_division_by (use_stmt
, def
))
487 FOR_EACH_IMM_USE_ON_STMT (use_p
, use_iter
)
488 replace_reciprocal (use_p
);
493 for (occ
= occ_head
; occ
; )
500 gate_cse_reciprocals (void)
502 return optimize
&& flag_reciprocal_math
;
505 /* Go through all the floating-point SSA_NAMEs, and call
506 execute_cse_reciprocals_1 on each of them. */
508 execute_cse_reciprocals (void)
513 occ_pool
= create_alloc_pool ("dominators for recip",
514 sizeof (struct occurrence
),
515 n_basic_blocks
/ 3 + 1);
517 memset (&reciprocal_stats
, 0, sizeof (reciprocal_stats
));
518 calculate_dominance_info (CDI_DOMINATORS
);
519 calculate_dominance_info (CDI_POST_DOMINATORS
);
521 #ifdef ENABLE_CHECKING
523 gcc_assert (!bb
->aux
);
526 for (arg
= DECL_ARGUMENTS (cfun
->decl
); arg
; arg
= DECL_CHAIN (arg
))
527 if (FLOAT_TYPE_P (TREE_TYPE (arg
))
528 && is_gimple_reg (arg
))
530 tree name
= ssa_default_def (cfun
, arg
);
532 execute_cse_reciprocals_1 (NULL
, name
);
537 gimple_stmt_iterator gsi
;
541 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
543 phi
= gsi_stmt (gsi
);
544 def
= PHI_RESULT (phi
);
545 if (! virtual_operand_p (def
)
546 && FLOAT_TYPE_P (TREE_TYPE (def
)))
547 execute_cse_reciprocals_1 (NULL
, def
);
550 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
552 gimple stmt
= gsi_stmt (gsi
);
554 if (gimple_has_lhs (stmt
)
555 && (def
= SINGLE_SSA_TREE_OPERAND (stmt
, SSA_OP_DEF
)) != NULL
556 && FLOAT_TYPE_P (TREE_TYPE (def
))
557 && TREE_CODE (def
) == SSA_NAME
)
558 execute_cse_reciprocals_1 (&gsi
, def
);
561 if (optimize_bb_for_size_p (bb
))
564 /* Scan for a/func(b) and convert it to reciprocal a*rfunc(b). */
565 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
567 gimple stmt
= gsi_stmt (gsi
);
570 if (is_gimple_assign (stmt
)
571 && gimple_assign_rhs_code (stmt
) == RDIV_EXPR
)
573 tree arg1
= gimple_assign_rhs2 (stmt
);
576 if (TREE_CODE (arg1
) != SSA_NAME
)
579 stmt1
= SSA_NAME_DEF_STMT (arg1
);
581 if (is_gimple_call (stmt1
)
582 && gimple_call_lhs (stmt1
)
583 && (fndecl
= gimple_call_fndecl (stmt1
))
584 && (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
585 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
))
587 enum built_in_function code
;
592 code
= DECL_FUNCTION_CODE (fndecl
);
593 md_code
= DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
;
595 fndecl
= targetm
.builtin_reciprocal (code
, md_code
, false);
599 /* Check that all uses of the SSA name are divisions,
600 otherwise replacing the defining statement will do
603 FOR_EACH_IMM_USE_FAST (use_p
, ui
, arg1
)
605 gimple stmt2
= USE_STMT (use_p
);
606 if (is_gimple_debug (stmt2
))
608 if (!is_gimple_assign (stmt2
)
609 || gimple_assign_rhs_code (stmt2
) != RDIV_EXPR
610 || gimple_assign_rhs1 (stmt2
) == arg1
611 || gimple_assign_rhs2 (stmt2
) != arg1
)
620 gimple_replace_ssa_lhs (stmt1
, arg1
);
621 gimple_call_set_fndecl (stmt1
, fndecl
);
623 reciprocal_stats
.rfuncs_inserted
++;
625 FOR_EACH_IMM_USE_STMT (stmt
, ui
, arg1
)
627 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
628 gimple_assign_set_rhs_code (stmt
, MULT_EXPR
);
629 fold_stmt_inplace (&gsi
);
637 statistics_counter_event (cfun
, "reciprocal divs inserted",
638 reciprocal_stats
.rdivs_inserted
);
639 statistics_counter_event (cfun
, "reciprocal functions inserted",
640 reciprocal_stats
.rfuncs_inserted
);
642 free_dominance_info (CDI_DOMINATORS
);
643 free_dominance_info (CDI_POST_DOMINATORS
);
644 free_alloc_pool (occ_pool
);
650 const pass_data pass_data_cse_reciprocals
=
652 GIMPLE_PASS
, /* type */
654 OPTGROUP_NONE
, /* optinfo_flags */
656 true, /* has_execute */
658 PROP_ssa
, /* properties_required */
659 0, /* properties_provided */
660 0, /* properties_destroyed */
661 0, /* todo_flags_start */
662 ( TODO_update_ssa
| TODO_verify_ssa
663 | TODO_verify_stmts
), /* todo_flags_finish */
666 class pass_cse_reciprocals
: public gimple_opt_pass
669 pass_cse_reciprocals (gcc::context
*ctxt
)
670 : gimple_opt_pass (pass_data_cse_reciprocals
, ctxt
)
673 /* opt_pass methods: */
674 bool gate () { return gate_cse_reciprocals (); }
675 unsigned int execute () { return execute_cse_reciprocals (); }
677 }; // class pass_cse_reciprocals
682 make_pass_cse_reciprocals (gcc::context
*ctxt
)
684 return new pass_cse_reciprocals (ctxt
);
687 /* Records an occurrence at statement USE_STMT in the vector of trees
688 STMTS if it is dominated by *TOP_BB or dominates it or this basic block
689 is not yet initialized. Returns true if the occurrence was pushed on
690 the vector. Adjusts *TOP_BB to be the basic block dominating all
691 statements in the vector. */
694 maybe_record_sincos (vec
<gimple
> *stmts
,
695 basic_block
*top_bb
, gimple use_stmt
)
697 basic_block use_bb
= gimple_bb (use_stmt
);
699 && (*top_bb
== use_bb
700 || dominated_by_p (CDI_DOMINATORS
, use_bb
, *top_bb
)))
701 stmts
->safe_push (use_stmt
);
703 || dominated_by_p (CDI_DOMINATORS
, *top_bb
, use_bb
))
705 stmts
->safe_push (use_stmt
);
714 /* Look for sin, cos and cexpi calls with the same argument NAME and
715 create a single call to cexpi CSEing the result in this case.
716 We first walk over all immediate uses of the argument collecting
717 statements that we can CSE in a vector and in a second pass replace
718 the statement rhs with a REALPART or IMAGPART expression on the
719 result of the cexpi call we insert before the use statement that
720 dominates all other candidates. */
723 execute_cse_sincos_1 (tree name
)
725 gimple_stmt_iterator gsi
;
726 imm_use_iterator use_iter
;
727 tree fndecl
, res
, type
;
728 gimple def_stmt
, use_stmt
, stmt
;
729 int seen_cos
= 0, seen_sin
= 0, seen_cexpi
= 0;
730 vec
<gimple
> stmts
= vNULL
;
731 basic_block top_bb
= NULL
;
733 bool cfg_changed
= false;
735 type
= TREE_TYPE (name
);
736 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, name
)
738 if (gimple_code (use_stmt
) != GIMPLE_CALL
739 || !gimple_call_lhs (use_stmt
)
740 || !(fndecl
= gimple_call_fndecl (use_stmt
))
741 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
744 switch (DECL_FUNCTION_CODE (fndecl
))
746 CASE_FLT_FN (BUILT_IN_COS
):
747 seen_cos
|= maybe_record_sincos (&stmts
, &top_bb
, use_stmt
) ? 1 : 0;
750 CASE_FLT_FN (BUILT_IN_SIN
):
751 seen_sin
|= maybe_record_sincos (&stmts
, &top_bb
, use_stmt
) ? 1 : 0;
754 CASE_FLT_FN (BUILT_IN_CEXPI
):
755 seen_cexpi
|= maybe_record_sincos (&stmts
, &top_bb
, use_stmt
) ? 1 : 0;
762 if (seen_cos
+ seen_sin
+ seen_cexpi
<= 1)
768 /* Simply insert cexpi at the beginning of top_bb but not earlier than
769 the name def statement. */
770 fndecl
= mathfn_built_in (type
, BUILT_IN_CEXPI
);
773 stmt
= gimple_build_call (fndecl
, 1, name
);
774 res
= make_temp_ssa_name (TREE_TYPE (TREE_TYPE (fndecl
)), stmt
, "sincostmp");
775 gimple_call_set_lhs (stmt
, res
);
777 def_stmt
= SSA_NAME_DEF_STMT (name
);
778 if (!SSA_NAME_IS_DEFAULT_DEF (name
)
779 && gimple_code (def_stmt
) != GIMPLE_PHI
780 && gimple_bb (def_stmt
) == top_bb
)
782 gsi
= gsi_for_stmt (def_stmt
);
783 gsi_insert_after (&gsi
, stmt
, GSI_SAME_STMT
);
787 gsi
= gsi_after_labels (top_bb
);
788 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
790 sincos_stats
.inserted
++;
792 /* And adjust the recorded old call sites. */
793 for (i
= 0; stmts
.iterate (i
, &use_stmt
); ++i
)
796 fndecl
= gimple_call_fndecl (use_stmt
);
798 switch (DECL_FUNCTION_CODE (fndecl
))
800 CASE_FLT_FN (BUILT_IN_COS
):
801 rhs
= fold_build1 (REALPART_EXPR
, type
, res
);
804 CASE_FLT_FN (BUILT_IN_SIN
):
805 rhs
= fold_build1 (IMAGPART_EXPR
, type
, res
);
808 CASE_FLT_FN (BUILT_IN_CEXPI
):
816 /* Replace call with a copy. */
817 stmt
= gimple_build_assign (gimple_call_lhs (use_stmt
), rhs
);
819 gsi
= gsi_for_stmt (use_stmt
);
820 gsi_replace (&gsi
, stmt
, true);
821 if (gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
830 /* To evaluate powi(x,n), the floating point value x raised to the
831 constant integer exponent n, we use a hybrid algorithm that
832 combines the "window method" with look-up tables. For an
833 introduction to exponentiation algorithms and "addition chains",
834 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
835 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
836 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
837 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
839 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
840 multiplications to inline before calling the system library's pow
841 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
842 so this default never requires calling pow, powf or powl. */
844 #ifndef POWI_MAX_MULTS
845 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
848 /* The size of the "optimal power tree" lookup table. All
849 exponents less than this value are simply looked up in the
850 powi_table below. This threshold is also used to size the
851 cache of pseudo registers that hold intermediate results. */
852 #define POWI_TABLE_SIZE 256
854 /* The size, in bits of the window, used in the "window method"
855 exponentiation algorithm. This is equivalent to a radix of
856 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
857 #define POWI_WINDOW_SIZE 3
859 /* The following table is an efficient representation of an
860 "optimal power tree". For each value, i, the corresponding
861 value, j, in the table states than an optimal evaluation
862 sequence for calculating pow(x,i) can be found by evaluating
863 pow(x,j)*pow(x,i-j). An optimal power tree for the first
864 100 integers is given in Knuth's "Seminumerical algorithms". */
866 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
868 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
869 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
870 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
871 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
872 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
873 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
874 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
875 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
876 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
877 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
878 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
879 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
880 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
881 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
882 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
883 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
884 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
885 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
886 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
887 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
888 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
889 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
890 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
891 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
892 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
893 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
894 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
895 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
896 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
897 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
898 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
899 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
903 /* Return the number of multiplications required to calculate
904 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
905 subroutine of powi_cost. CACHE is an array indicating
906 which exponents have already been calculated. */
909 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
911 /* If we've already calculated this exponent, then this evaluation
912 doesn't require any additional multiplications. */
917 return powi_lookup_cost (n
- powi_table
[n
], cache
)
918 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
921 /* Return the number of multiplications required to calculate
922 powi(x,n) for an arbitrary x, given the exponent N. This
923 function needs to be kept in sync with powi_as_mults below. */
926 powi_cost (HOST_WIDE_INT n
)
928 bool cache
[POWI_TABLE_SIZE
];
929 unsigned HOST_WIDE_INT digit
;
930 unsigned HOST_WIDE_INT val
;
936 /* Ignore the reciprocal when calculating the cost. */
937 val
= (n
< 0) ? -n
: n
;
939 /* Initialize the exponent cache. */
940 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
945 while (val
>= POWI_TABLE_SIZE
)
949 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
950 result
+= powi_lookup_cost (digit
, cache
)
951 + POWI_WINDOW_SIZE
+ 1;
952 val
>>= POWI_WINDOW_SIZE
;
961 return result
+ powi_lookup_cost (val
, cache
);
964 /* Recursive subroutine of powi_as_mults. This function takes the
965 array, CACHE, of already calculated exponents and an exponent N and
966 returns a tree that corresponds to CACHE[1]**N, with type TYPE. */
969 powi_as_mults_1 (gimple_stmt_iterator
*gsi
, location_t loc
, tree type
,
970 HOST_WIDE_INT n
, tree
*cache
)
972 tree op0
, op1
, ssa_target
;
973 unsigned HOST_WIDE_INT digit
;
976 if (n
< POWI_TABLE_SIZE
&& cache
[n
])
979 ssa_target
= make_temp_ssa_name (type
, NULL
, "powmult");
981 if (n
< POWI_TABLE_SIZE
)
983 cache
[n
] = ssa_target
;
984 op0
= powi_as_mults_1 (gsi
, loc
, type
, n
- powi_table
[n
], cache
);
985 op1
= powi_as_mults_1 (gsi
, loc
, type
, powi_table
[n
], cache
);
989 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
990 op0
= powi_as_mults_1 (gsi
, loc
, type
, n
- digit
, cache
);
991 op1
= powi_as_mults_1 (gsi
, loc
, type
, digit
, cache
);
995 op0
= powi_as_mults_1 (gsi
, loc
, type
, n
>> 1, cache
);
999 mult_stmt
= gimple_build_assign_with_ops (MULT_EXPR
, ssa_target
, op0
, op1
);
1000 gimple_set_location (mult_stmt
, loc
);
1001 gsi_insert_before (gsi
, mult_stmt
, GSI_SAME_STMT
);
1006 /* Convert ARG0**N to a tree of multiplications of ARG0 with itself.
1007 This function needs to be kept in sync with powi_cost above. */
1010 powi_as_mults (gimple_stmt_iterator
*gsi
, location_t loc
,
1011 tree arg0
, HOST_WIDE_INT n
)
1013 tree cache
[POWI_TABLE_SIZE
], result
, type
= TREE_TYPE (arg0
);
1018 return build_real (type
, dconst1
);
1020 memset (cache
, 0, sizeof (cache
));
1023 result
= powi_as_mults_1 (gsi
, loc
, type
, (n
< 0) ? -n
: n
, cache
);
1027 /* If the original exponent was negative, reciprocate the result. */
1028 target
= make_temp_ssa_name (type
, NULL
, "powmult");
1029 div_stmt
= gimple_build_assign_with_ops (RDIV_EXPR
, target
,
1030 build_real (type
, dconst1
),
1032 gimple_set_location (div_stmt
, loc
);
1033 gsi_insert_before (gsi
, div_stmt
, GSI_SAME_STMT
);
1038 /* ARG0 and N are the two arguments to a powi builtin in GSI with
1039 location info LOC. If the arguments are appropriate, create an
1040 equivalent sequence of statements prior to GSI using an optimal
1041 number of multiplications, and return an expession holding the
1045 gimple_expand_builtin_powi (gimple_stmt_iterator
*gsi
, location_t loc
,
1046 tree arg0
, HOST_WIDE_INT n
)
1048 /* Avoid largest negative number. */
1050 && ((n
>= -1 && n
<= 2)
1051 || (optimize_function_for_speed_p (cfun
)
1052 && powi_cost (n
) <= POWI_MAX_MULTS
)))
1053 return powi_as_mults (gsi
, loc
, arg0
, n
);
1058 /* Build a gimple call statement that calls FN with argument ARG.
1059 Set the lhs of the call statement to a fresh SSA name. Insert the
1060 statement prior to GSI's current position, and return the fresh
1064 build_and_insert_call (gimple_stmt_iterator
*gsi
, location_t loc
,
1070 call_stmt
= gimple_build_call (fn
, 1, arg
);
1071 ssa_target
= make_temp_ssa_name (TREE_TYPE (arg
), NULL
, "powroot");
1072 gimple_set_lhs (call_stmt
, ssa_target
);
1073 gimple_set_location (call_stmt
, loc
);
1074 gsi_insert_before (gsi
, call_stmt
, GSI_SAME_STMT
);
1079 /* Build a gimple binary operation with the given CODE and arguments
1080 ARG0, ARG1, assigning the result to a new SSA name for variable
1081 TARGET. Insert the statement prior to GSI's current position, and
1082 return the fresh SSA name.*/
1085 build_and_insert_binop (gimple_stmt_iterator
*gsi
, location_t loc
,
1086 const char *name
, enum tree_code code
,
1087 tree arg0
, tree arg1
)
1089 tree result
= make_temp_ssa_name (TREE_TYPE (arg0
), NULL
, name
);
1090 gimple stmt
= gimple_build_assign_with_ops (code
, result
, arg0
, arg1
);
1091 gimple_set_location (stmt
, loc
);
1092 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1096 /* Build a gimple reference operation with the given CODE and argument
1097 ARG, assigning the result to a new SSA name of TYPE with NAME.
1098 Insert the statement prior to GSI's current position, and return
1099 the fresh SSA name. */
1102 build_and_insert_ref (gimple_stmt_iterator
*gsi
, location_t loc
, tree type
,
1103 const char *name
, enum tree_code code
, tree arg0
)
1105 tree result
= make_temp_ssa_name (type
, NULL
, name
);
1106 gimple stmt
= gimple_build_assign (result
, build1 (code
, type
, arg0
));
1107 gimple_set_location (stmt
, loc
);
1108 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1112 /* Build a gimple assignment to cast VAL to TYPE. Insert the statement
1113 prior to GSI's current position, and return the fresh SSA name. */
1116 build_and_insert_cast (gimple_stmt_iterator
*gsi
, location_t loc
,
1117 tree type
, tree val
)
1119 tree result
= make_ssa_name (type
, NULL
);
1120 gimple stmt
= gimple_build_assign_with_ops (NOP_EXPR
, result
, val
, NULL_TREE
);
1121 gimple_set_location (stmt
, loc
);
1122 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1126 /* ARG0 and ARG1 are the two arguments to a pow builtin call in GSI
1127 with location info LOC. If possible, create an equivalent and
1128 less expensive sequence of statements prior to GSI, and return an
1129 expession holding the result. */
1132 gimple_expand_builtin_pow (gimple_stmt_iterator
*gsi
, location_t loc
,
1133 tree arg0
, tree arg1
)
1135 REAL_VALUE_TYPE c
, cint
, dconst1_4
, dconst3_4
, dconst1_3
, dconst1_6
;
1136 REAL_VALUE_TYPE c2
, dconst3
;
1138 tree type
, sqrtfn
, cbrtfn
, sqrt_arg0
, sqrt_sqrt
, result
, cbrt_x
, powi_cbrt_x
;
1139 enum machine_mode mode
;
1140 bool hw_sqrt_exists
, c_is_int
, c2_is_int
;
1142 /* If the exponent isn't a constant, there's nothing of interest
1144 if (TREE_CODE (arg1
) != REAL_CST
)
1147 /* If the exponent is equivalent to an integer, expand to an optimal
1148 multiplication sequence when profitable. */
1149 c
= TREE_REAL_CST (arg1
);
1150 n
= real_to_integer (&c
);
1151 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
1152 c_is_int
= real_identical (&c
, &cint
);
1155 && ((n
>= -1 && n
<= 2)
1156 || (flag_unsafe_math_optimizations
1157 && optimize_insn_for_speed_p ()
1158 && powi_cost (n
) <= POWI_MAX_MULTS
)))
1159 return gimple_expand_builtin_powi (gsi
, loc
, arg0
, n
);
1161 /* Attempt various optimizations using sqrt and cbrt. */
1162 type
= TREE_TYPE (arg0
);
1163 mode
= TYPE_MODE (type
);
1164 sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
1166 /* Optimize pow(x,0.5) = sqrt(x). This replacement is always safe
1167 unless signed zeros must be maintained. pow(-0,0.5) = +0, while
1170 && REAL_VALUES_EQUAL (c
, dconsthalf
)
1171 && !HONOR_SIGNED_ZEROS (mode
))
1172 return build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1174 /* Optimize pow(x,0.25) = sqrt(sqrt(x)). Assume on most machines that
1175 a builtin sqrt instruction is smaller than a call to pow with 0.25,
1176 so do this optimization even if -Os. Don't do this optimization
1177 if we don't have a hardware sqrt insn. */
1178 dconst1_4
= dconst1
;
1179 SET_REAL_EXP (&dconst1_4
, REAL_EXP (&dconst1_4
) - 2);
1180 hw_sqrt_exists
= optab_handler (sqrt_optab
, mode
) != CODE_FOR_nothing
;
1182 if (flag_unsafe_math_optimizations
1184 && REAL_VALUES_EQUAL (c
, dconst1_4
)
1188 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1191 return build_and_insert_call (gsi
, loc
, sqrtfn
, sqrt_arg0
);
1194 /* Optimize pow(x,0.75) = sqrt(x) * sqrt(sqrt(x)) unless we are
1195 optimizing for space. Don't do this optimization if we don't have
1196 a hardware sqrt insn. */
1197 real_from_integer (&dconst3_4
, VOIDmode
, 3, 0, 0);
1198 SET_REAL_EXP (&dconst3_4
, REAL_EXP (&dconst3_4
) - 2);
1200 if (flag_unsafe_math_optimizations
1202 && optimize_function_for_speed_p (cfun
)
1203 && REAL_VALUES_EQUAL (c
, dconst3_4
)
1207 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1210 sqrt_sqrt
= build_and_insert_call (gsi
, loc
, sqrtfn
, sqrt_arg0
);
1212 /* sqrt(x) * sqrt(sqrt(x)) */
1213 return build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1214 sqrt_arg0
, sqrt_sqrt
);
1217 /* Optimize pow(x,1./3.) = cbrt(x). This requires unsafe math
1218 optimizations since 1./3. is not exactly representable. If x
1219 is negative and finite, the correct value of pow(x,1./3.) is
1220 a NaN with the "invalid" exception raised, because the value
1221 of 1./3. actually has an even denominator. The correct value
1222 of cbrt(x) is a negative real value. */
1223 cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
1224 dconst1_3
= real_value_truncate (mode
, dconst_third ());
1226 if (flag_unsafe_math_optimizations
1228 && (gimple_val_nonnegative_real_p (arg0
) || !HONOR_NANS (mode
))
1229 && REAL_VALUES_EQUAL (c
, dconst1_3
))
1230 return build_and_insert_call (gsi
, loc
, cbrtfn
, arg0
);
1232 /* Optimize pow(x,1./6.) = cbrt(sqrt(x)). Don't do this optimization
1233 if we don't have a hardware sqrt insn. */
1234 dconst1_6
= dconst1_3
;
1235 SET_REAL_EXP (&dconst1_6
, REAL_EXP (&dconst1_6
) - 1);
1237 if (flag_unsafe_math_optimizations
1240 && (gimple_val_nonnegative_real_p (arg0
) || !HONOR_NANS (mode
))
1241 && optimize_function_for_speed_p (cfun
)
1243 && REAL_VALUES_EQUAL (c
, dconst1_6
))
1246 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1249 return build_and_insert_call (gsi
, loc
, cbrtfn
, sqrt_arg0
);
1252 /* Optimize pow(x,c), where n = 2c for some nonzero integer n
1253 and c not an integer, into
1255 sqrt(x) * powi(x, n/2), n > 0;
1256 1.0 / (sqrt(x) * powi(x, abs(n/2))), n < 0.
1258 Do not calculate the powi factor when n/2 = 0. */
1259 real_arithmetic (&c2
, MULT_EXPR
, &c
, &dconst2
);
1260 n
= real_to_integer (&c2
);
1261 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
1262 c2_is_int
= real_identical (&c2
, &cint
);
1264 if (flag_unsafe_math_optimizations
1268 && optimize_function_for_speed_p (cfun
))
1270 tree powi_x_ndiv2
= NULL_TREE
;
1272 /* Attempt to fold powi(arg0, abs(n/2)) into multiplies. If not
1273 possible or profitable, give up. Skip the degenerate case when
1274 n is 1 or -1, where the result is always 1. */
1275 if (absu_hwi (n
) != 1)
1277 powi_x_ndiv2
= gimple_expand_builtin_powi (gsi
, loc
, arg0
,
1283 /* Calculate sqrt(x). When n is not 1 or -1, multiply it by the
1284 result of the optimal multiply sequence just calculated. */
1285 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1287 if (absu_hwi (n
) == 1)
1290 result
= build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1291 sqrt_arg0
, powi_x_ndiv2
);
1293 /* If n is negative, reciprocate the result. */
1295 result
= build_and_insert_binop (gsi
, loc
, "powroot", RDIV_EXPR
,
1296 build_real (type
, dconst1
), result
);
1300 /* Optimize pow(x,c), where 3c = n for some nonzero integer n, into
1302 powi(x, n/3) * powi(cbrt(x), n%3), n > 0;
1303 1.0 / (powi(x, abs(n)/3) * powi(cbrt(x), abs(n)%3)), n < 0.
1305 Do not calculate the first factor when n/3 = 0. As cbrt(x) is
1306 different from pow(x, 1./3.) due to rounding and behavior with
1307 negative x, we need to constrain this transformation to unsafe
1308 math and positive x or finite math. */
1309 real_from_integer (&dconst3
, VOIDmode
, 3, 0, 0);
1310 real_arithmetic (&c2
, MULT_EXPR
, &c
, &dconst3
);
1311 real_round (&c2
, mode
, &c2
);
1312 n
= real_to_integer (&c2
);
1313 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
1314 real_arithmetic (&c2
, RDIV_EXPR
, &cint
, &dconst3
);
1315 real_convert (&c2
, mode
, &c2
);
1317 if (flag_unsafe_math_optimizations
1319 && (gimple_val_nonnegative_real_p (arg0
) || !HONOR_NANS (mode
))
1320 && real_identical (&c2
, &c
)
1322 && optimize_function_for_speed_p (cfun
)
1323 && powi_cost (n
/ 3) <= POWI_MAX_MULTS
)
1325 tree powi_x_ndiv3
= NULL_TREE
;
1327 /* Attempt to fold powi(arg0, abs(n/3)) into multiplies. If not
1328 possible or profitable, give up. Skip the degenerate case when
1329 abs(n) < 3, where the result is always 1. */
1330 if (absu_hwi (n
) >= 3)
1332 powi_x_ndiv3
= gimple_expand_builtin_powi (gsi
, loc
, arg0
,
1338 /* Calculate powi(cbrt(x), n%3). Don't use gimple_expand_builtin_powi
1339 as that creates an unnecessary variable. Instead, just produce
1340 either cbrt(x) or cbrt(x) * cbrt(x). */
1341 cbrt_x
= build_and_insert_call (gsi
, loc
, cbrtfn
, arg0
);
1343 if (absu_hwi (n
) % 3 == 1)
1344 powi_cbrt_x
= cbrt_x
;
1346 powi_cbrt_x
= build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1349 /* Multiply the two subexpressions, unless powi(x,abs(n)/3) = 1. */
1350 if (absu_hwi (n
) < 3)
1351 result
= powi_cbrt_x
;
1353 result
= build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1354 powi_x_ndiv3
, powi_cbrt_x
);
1356 /* If n is negative, reciprocate the result. */
1358 result
= build_and_insert_binop (gsi
, loc
, "powroot", RDIV_EXPR
,
1359 build_real (type
, dconst1
), result
);
1364 /* No optimizations succeeded. */
1368 /* ARG is the argument to a cabs builtin call in GSI with location info
1369 LOC. Create a sequence of statements prior to GSI that calculates
1370 sqrt(R*R + I*I), where R and I are the real and imaginary components
1371 of ARG, respectively. Return an expression holding the result. */
1374 gimple_expand_builtin_cabs (gimple_stmt_iterator
*gsi
, location_t loc
, tree arg
)
1376 tree real_part
, imag_part
, addend1
, addend2
, sum
, result
;
1377 tree type
= TREE_TYPE (TREE_TYPE (arg
));
1378 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
1379 enum machine_mode mode
= TYPE_MODE (type
);
1381 if (!flag_unsafe_math_optimizations
1382 || !optimize_bb_for_speed_p (gimple_bb (gsi_stmt (*gsi
)))
1384 || optab_handler (sqrt_optab
, mode
) == CODE_FOR_nothing
)
1387 real_part
= build_and_insert_ref (gsi
, loc
, type
, "cabs",
1388 REALPART_EXPR
, arg
);
1389 addend1
= build_and_insert_binop (gsi
, loc
, "cabs", MULT_EXPR
,
1390 real_part
, real_part
);
1391 imag_part
= build_and_insert_ref (gsi
, loc
, type
, "cabs",
1392 IMAGPART_EXPR
, arg
);
1393 addend2
= build_and_insert_binop (gsi
, loc
, "cabs", MULT_EXPR
,
1394 imag_part
, imag_part
);
1395 sum
= build_and_insert_binop (gsi
, loc
, "cabs", PLUS_EXPR
, addend1
, addend2
);
1396 result
= build_and_insert_call (gsi
, loc
, sqrtfn
, sum
);
1401 /* Go through all calls to sin, cos and cexpi and call execute_cse_sincos_1
1402 on the SSA_NAME argument of each of them. Also expand powi(x,n) into
1403 an optimal number of multiplies, when n is a constant. */
1406 execute_cse_sincos (void)
1409 bool cfg_changed
= false;
1411 calculate_dominance_info (CDI_DOMINATORS
);
1412 memset (&sincos_stats
, 0, sizeof (sincos_stats
));
1416 gimple_stmt_iterator gsi
;
1417 bool cleanup_eh
= false;
1419 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1421 gimple stmt
= gsi_stmt (gsi
);
1424 /* Only the last stmt in a bb could throw, no need to call
1425 gimple_purge_dead_eh_edges if we change something in the middle
1426 of a basic block. */
1429 if (is_gimple_call (stmt
)
1430 && gimple_call_lhs (stmt
)
1431 && (fndecl
= gimple_call_fndecl (stmt
))
1432 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1434 tree arg
, arg0
, arg1
, result
;
1438 switch (DECL_FUNCTION_CODE (fndecl
))
1440 CASE_FLT_FN (BUILT_IN_COS
):
1441 CASE_FLT_FN (BUILT_IN_SIN
):
1442 CASE_FLT_FN (BUILT_IN_CEXPI
):
1443 /* Make sure we have either sincos or cexp. */
1444 if (!targetm
.libc_has_function (function_c99_math_complex
)
1445 && !targetm
.libc_has_function (function_sincos
))
1448 arg
= gimple_call_arg (stmt
, 0);
1449 if (TREE_CODE (arg
) == SSA_NAME
)
1450 cfg_changed
|= execute_cse_sincos_1 (arg
);
1453 CASE_FLT_FN (BUILT_IN_POW
):
1454 arg0
= gimple_call_arg (stmt
, 0);
1455 arg1
= gimple_call_arg (stmt
, 1);
1457 loc
= gimple_location (stmt
);
1458 result
= gimple_expand_builtin_pow (&gsi
, loc
, arg0
, arg1
);
1462 tree lhs
= gimple_get_lhs (stmt
);
1463 gimple new_stmt
= gimple_build_assign (lhs
, result
);
1464 gimple_set_location (new_stmt
, loc
);
1465 unlink_stmt_vdef (stmt
);
1466 gsi_replace (&gsi
, new_stmt
, true);
1468 if (gimple_vdef (stmt
))
1469 release_ssa_name (gimple_vdef (stmt
));
1473 CASE_FLT_FN (BUILT_IN_POWI
):
1474 arg0
= gimple_call_arg (stmt
, 0);
1475 arg1
= gimple_call_arg (stmt
, 1);
1476 loc
= gimple_location (stmt
);
1478 if (real_minus_onep (arg0
))
1480 tree t0
, t1
, cond
, one
, minus_one
;
1483 t0
= TREE_TYPE (arg0
);
1484 t1
= TREE_TYPE (arg1
);
1485 one
= build_real (t0
, dconst1
);
1486 minus_one
= build_real (t0
, dconstm1
);
1488 cond
= make_temp_ssa_name (t1
, NULL
, "powi_cond");
1489 stmt
= gimple_build_assign_with_ops (BIT_AND_EXPR
, cond
,
1493 gimple_set_location (stmt
, loc
);
1494 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
1496 result
= make_temp_ssa_name (t0
, NULL
, "powi");
1497 stmt
= gimple_build_assign_with_ops (COND_EXPR
, result
,
1500 gimple_set_location (stmt
, loc
);
1501 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
1505 if (!host_integerp (arg1
, 0))
1508 n
= TREE_INT_CST_LOW (arg1
);
1509 result
= gimple_expand_builtin_powi (&gsi
, loc
, arg0
, n
);
1514 tree lhs
= gimple_get_lhs (stmt
);
1515 gimple new_stmt
= gimple_build_assign (lhs
, result
);
1516 gimple_set_location (new_stmt
, loc
);
1517 unlink_stmt_vdef (stmt
);
1518 gsi_replace (&gsi
, new_stmt
, true);
1520 if (gimple_vdef (stmt
))
1521 release_ssa_name (gimple_vdef (stmt
));
1525 CASE_FLT_FN (BUILT_IN_CABS
):
1526 arg0
= gimple_call_arg (stmt
, 0);
1527 loc
= gimple_location (stmt
);
1528 result
= gimple_expand_builtin_cabs (&gsi
, loc
, arg0
);
1532 tree lhs
= gimple_get_lhs (stmt
);
1533 gimple new_stmt
= gimple_build_assign (lhs
, result
);
1534 gimple_set_location (new_stmt
, loc
);
1535 unlink_stmt_vdef (stmt
);
1536 gsi_replace (&gsi
, new_stmt
, true);
1538 if (gimple_vdef (stmt
))
1539 release_ssa_name (gimple_vdef (stmt
));
1548 cfg_changed
|= gimple_purge_dead_eh_edges (bb
);
1551 statistics_counter_event (cfun
, "sincos statements inserted",
1552 sincos_stats
.inserted
);
1554 free_dominance_info (CDI_DOMINATORS
);
1555 return cfg_changed
? TODO_cleanup_cfg
: 0;
1559 gate_cse_sincos (void)
1561 /* We no longer require either sincos or cexp, since powi expansion
1562 piggybacks on this pass. */
1568 const pass_data pass_data_cse_sincos
=
1570 GIMPLE_PASS
, /* type */
1571 "sincos", /* name */
1572 OPTGROUP_NONE
, /* optinfo_flags */
1573 true, /* has_gate */
1574 true, /* has_execute */
1575 TV_NONE
, /* tv_id */
1576 PROP_ssa
, /* properties_required */
1577 0, /* properties_provided */
1578 0, /* properties_destroyed */
1579 0, /* todo_flags_start */
1580 ( TODO_update_ssa
| TODO_verify_ssa
1581 | TODO_verify_stmts
), /* todo_flags_finish */
1584 class pass_cse_sincos
: public gimple_opt_pass
1587 pass_cse_sincos (gcc::context
*ctxt
)
1588 : gimple_opt_pass (pass_data_cse_sincos
, ctxt
)
1591 /* opt_pass methods: */
1592 bool gate () { return gate_cse_sincos (); }
1593 unsigned int execute () { return execute_cse_sincos (); }
1595 }; // class pass_cse_sincos
1600 make_pass_cse_sincos (gcc::context
*ctxt
)
1602 return new pass_cse_sincos (ctxt
);
1605 /* A symbolic number is used to detect byte permutation and selection
1606 patterns. Therefore the field N contains an artificial number
1607 consisting of byte size markers:
1609 0 - byte has the value 0
1610 1..size - byte contains the content of the byte
1611 number indexed with that value minus one */
1613 struct symbolic_number
{
1614 unsigned HOST_WIDEST_INT n
;
1618 /* Perform a SHIFT or ROTATE operation by COUNT bits on symbolic
1619 number N. Return false if the requested operation is not permitted
1620 on a symbolic number. */
1623 do_shift_rotate (enum tree_code code
,
1624 struct symbolic_number
*n
,
1630 /* Zero out the extra bits of N in order to avoid them being shifted
1631 into the significant bits. */
1632 if (n
->size
< (int)sizeof (HOST_WIDEST_INT
))
1633 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 << (n
->size
* BITS_PER_UNIT
)) - 1;
1644 n
->n
= (n
->n
<< count
) | (n
->n
>> ((n
->size
* BITS_PER_UNIT
) - count
));
1647 n
->n
= (n
->n
>> count
) | (n
->n
<< ((n
->size
* BITS_PER_UNIT
) - count
));
1652 /* Zero unused bits for size. */
1653 if (n
->size
< (int)sizeof (HOST_WIDEST_INT
))
1654 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 << (n
->size
* BITS_PER_UNIT
)) - 1;
1658 /* Perform sanity checking for the symbolic number N and the gimple
1662 verify_symbolic_number_p (struct symbolic_number
*n
, gimple stmt
)
1666 lhs_type
= gimple_expr_type (stmt
);
1668 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
1671 if (TYPE_PRECISION (lhs_type
) != n
->size
* BITS_PER_UNIT
)
1677 /* find_bswap_1 invokes itself recursively with N and tries to perform
1678 the operation given by the rhs of STMT on the result. If the
1679 operation could successfully be executed the function returns the
1680 tree expression of the source operand and NULL otherwise. */
1683 find_bswap_1 (gimple stmt
, struct symbolic_number
*n
, int limit
)
1685 enum tree_code code
;
1686 tree rhs1
, rhs2
= NULL
;
1687 gimple rhs1_stmt
, rhs2_stmt
;
1689 enum gimple_rhs_class rhs_class
;
1691 if (!limit
|| !is_gimple_assign (stmt
))
1694 rhs1
= gimple_assign_rhs1 (stmt
);
1696 if (TREE_CODE (rhs1
) != SSA_NAME
)
1699 code
= gimple_assign_rhs_code (stmt
);
1700 rhs_class
= gimple_assign_rhs_class (stmt
);
1701 rhs1_stmt
= SSA_NAME_DEF_STMT (rhs1
);
1703 if (rhs_class
== GIMPLE_BINARY_RHS
)
1704 rhs2
= gimple_assign_rhs2 (stmt
);
1706 /* Handle unary rhs and binary rhs with integer constants as second
1709 if (rhs_class
== GIMPLE_UNARY_RHS
1710 || (rhs_class
== GIMPLE_BINARY_RHS
1711 && TREE_CODE (rhs2
) == INTEGER_CST
))
1713 if (code
!= BIT_AND_EXPR
1714 && code
!= LSHIFT_EXPR
1715 && code
!= RSHIFT_EXPR
1716 && code
!= LROTATE_EXPR
1717 && code
!= RROTATE_EXPR
1719 && code
!= CONVERT_EXPR
)
1722 source_expr1
= find_bswap_1 (rhs1_stmt
, n
, limit
- 1);
1724 /* If find_bswap_1 returned NULL STMT is a leaf node and we have
1725 to initialize the symbolic number. */
1728 /* Set up the symbolic number N by setting each byte to a
1729 value between 1 and the byte size of rhs1. The highest
1730 order byte is set to n->size and the lowest order
1732 n
->size
= TYPE_PRECISION (TREE_TYPE (rhs1
));
1733 if (n
->size
% BITS_PER_UNIT
!= 0)
1735 n
->size
/= BITS_PER_UNIT
;
1736 n
->n
= (sizeof (HOST_WIDEST_INT
) < 8 ? 0 :
1737 (unsigned HOST_WIDEST_INT
)0x08070605 << 32 | 0x04030201);
1739 if (n
->size
< (int)sizeof (HOST_WIDEST_INT
))
1740 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 <<
1741 (n
->size
* BITS_PER_UNIT
)) - 1;
1743 source_expr1
= rhs1
;
1751 unsigned HOST_WIDEST_INT val
= widest_int_cst_value (rhs2
);
1752 unsigned HOST_WIDEST_INT tmp
= val
;
1754 /* Only constants masking full bytes are allowed. */
1755 for (i
= 0; i
< n
->size
; i
++, tmp
>>= BITS_PER_UNIT
)
1756 if ((tmp
& 0xff) != 0 && (tmp
& 0xff) != 0xff)
1766 if (!do_shift_rotate (code
, n
, (int)TREE_INT_CST_LOW (rhs2
)))
1773 type_size
= TYPE_PRECISION (gimple_expr_type (stmt
));
1774 if (type_size
% BITS_PER_UNIT
!= 0)
1777 if (type_size
/ BITS_PER_UNIT
< (int)(sizeof (HOST_WIDEST_INT
)))
1779 /* If STMT casts to a smaller type mask out the bits not
1780 belonging to the target type. */
1781 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 << type_size
) - 1;
1783 n
->size
= type_size
/ BITS_PER_UNIT
;
1789 return verify_symbolic_number_p (n
, stmt
) ? source_expr1
: NULL
;
1792 /* Handle binary rhs. */
1794 if (rhs_class
== GIMPLE_BINARY_RHS
)
1796 struct symbolic_number n1
, n2
;
1799 if (code
!= BIT_IOR_EXPR
)
1802 if (TREE_CODE (rhs2
) != SSA_NAME
)
1805 rhs2_stmt
= SSA_NAME_DEF_STMT (rhs2
);
1810 source_expr1
= find_bswap_1 (rhs1_stmt
, &n1
, limit
- 1);
1815 source_expr2
= find_bswap_1 (rhs2_stmt
, &n2
, limit
- 1);
1817 if (source_expr1
!= source_expr2
1818 || n1
.size
!= n2
.size
)
1824 if (!verify_symbolic_number_p (n
, stmt
))
1831 return source_expr1
;
1836 /* Check if STMT completes a bswap implementation consisting of ORs,
1837 SHIFTs and ANDs. Return the source tree expression on which the
1838 byte swap is performed and NULL if no bswap was found. */
1841 find_bswap (gimple stmt
)
1843 /* The number which the find_bswap result should match in order to
1844 have a full byte swap. The number is shifted to the left according
1845 to the size of the symbolic number before using it. */
1846 unsigned HOST_WIDEST_INT cmp
=
1847 sizeof (HOST_WIDEST_INT
) < 8 ? 0 :
1848 (unsigned HOST_WIDEST_INT
)0x01020304 << 32 | 0x05060708;
1850 struct symbolic_number n
;
1854 /* The last parameter determines the depth search limit. It usually
1855 correlates directly to the number of bytes to be touched. We
1856 increase that number by three here in order to also
1857 cover signed -> unsigned converions of the src operand as can be seen
1858 in libgcc, and for initial shift/and operation of the src operand. */
1859 limit
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (gimple_expr_type (stmt
)));
1860 limit
+= 1 + (int) ceil_log2 ((unsigned HOST_WIDE_INT
) limit
);
1861 source_expr
= find_bswap_1 (stmt
, &n
, limit
);
1866 /* Zero out the extra bits of N and CMP. */
1867 if (n
.size
< (int)sizeof (HOST_WIDEST_INT
))
1869 unsigned HOST_WIDEST_INT mask
=
1870 ((unsigned HOST_WIDEST_INT
)1 << (n
.size
* BITS_PER_UNIT
)) - 1;
1873 cmp
>>= (sizeof (HOST_WIDEST_INT
) - n
.size
) * BITS_PER_UNIT
;
1876 /* A complete byte swap should make the symbolic number to start
1877 with the largest digit in the highest order byte. */
1884 /* Find manual byte swap implementations and turn them into a bswap
1885 builtin invokation. */
1888 execute_optimize_bswap (void)
1891 bool bswap16_p
, bswap32_p
, bswap64_p
;
1892 bool changed
= false;
1893 tree bswap16_type
= NULL_TREE
, bswap32_type
= NULL_TREE
, bswap64_type
= NULL_TREE
;
1895 if (BITS_PER_UNIT
!= 8)
1898 if (sizeof (HOST_WIDEST_INT
) < 8)
1901 bswap16_p
= (builtin_decl_explicit_p (BUILT_IN_BSWAP16
)
1902 && optab_handler (bswap_optab
, HImode
) != CODE_FOR_nothing
);
1903 bswap32_p
= (builtin_decl_explicit_p (BUILT_IN_BSWAP32
)
1904 && optab_handler (bswap_optab
, SImode
) != CODE_FOR_nothing
);
1905 bswap64_p
= (builtin_decl_explicit_p (BUILT_IN_BSWAP64
)
1906 && (optab_handler (bswap_optab
, DImode
) != CODE_FOR_nothing
1907 || (bswap32_p
&& word_mode
== SImode
)));
1909 if (!bswap16_p
&& !bswap32_p
&& !bswap64_p
)
1912 /* Determine the argument type of the builtins. The code later on
1913 assumes that the return and argument type are the same. */
1916 tree fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP16
);
1917 bswap16_type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
1922 tree fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP32
);
1923 bswap32_type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
1928 tree fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP64
);
1929 bswap64_type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
1932 memset (&bswap_stats
, 0, sizeof (bswap_stats
));
1936 gimple_stmt_iterator gsi
;
1938 /* We do a reverse scan for bswap patterns to make sure we get the
1939 widest match. As bswap pattern matching doesn't handle
1940 previously inserted smaller bswap replacements as sub-
1941 patterns, the wider variant wouldn't be detected. */
1942 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
1944 gimple stmt
= gsi_stmt (gsi
);
1945 tree bswap_src
, bswap_type
;
1947 tree fndecl
= NULL_TREE
;
1951 if (!is_gimple_assign (stmt
)
1952 || gimple_assign_rhs_code (stmt
) != BIT_IOR_EXPR
)
1955 type_size
= TYPE_PRECISION (gimple_expr_type (stmt
));
1962 fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP16
);
1963 bswap_type
= bswap16_type
;
1969 fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP32
);
1970 bswap_type
= bswap32_type
;
1976 fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP64
);
1977 bswap_type
= bswap64_type
;
1987 bswap_src
= find_bswap (stmt
);
1993 if (type_size
== 16)
1994 bswap_stats
.found_16bit
++;
1995 else if (type_size
== 32)
1996 bswap_stats
.found_32bit
++;
1998 bswap_stats
.found_64bit
++;
2000 bswap_tmp
= bswap_src
;
2002 /* Convert the src expression if necessary. */
2003 if (!useless_type_conversion_p (TREE_TYPE (bswap_tmp
), bswap_type
))
2005 gimple convert_stmt
;
2006 bswap_tmp
= make_temp_ssa_name (bswap_type
, NULL
, "bswapsrc");
2007 convert_stmt
= gimple_build_assign_with_ops
2008 (NOP_EXPR
, bswap_tmp
, bswap_src
, NULL
);
2009 gsi_insert_before (&gsi
, convert_stmt
, GSI_SAME_STMT
);
2012 call
= gimple_build_call (fndecl
, 1, bswap_tmp
);
2014 bswap_tmp
= gimple_assign_lhs (stmt
);
2016 /* Convert the result if necessary. */
2017 if (!useless_type_conversion_p (TREE_TYPE (bswap_tmp
), bswap_type
))
2019 gimple convert_stmt
;
2020 bswap_tmp
= make_temp_ssa_name (bswap_type
, NULL
, "bswapdst");
2021 convert_stmt
= gimple_build_assign_with_ops
2022 (NOP_EXPR
, gimple_assign_lhs (stmt
), bswap_tmp
, NULL
);
2023 gsi_insert_after (&gsi
, convert_stmt
, GSI_SAME_STMT
);
2026 gimple_call_set_lhs (call
, bswap_tmp
);
2030 fprintf (dump_file
, "%d bit bswap implementation found at: ",
2032 print_gimple_stmt (dump_file
, stmt
, 0, 0);
2035 gsi_insert_after (&gsi
, call
, GSI_SAME_STMT
);
2036 gsi_remove (&gsi
, true);
2040 statistics_counter_event (cfun
, "16-bit bswap implementations found",
2041 bswap_stats
.found_16bit
);
2042 statistics_counter_event (cfun
, "32-bit bswap implementations found",
2043 bswap_stats
.found_32bit
);
2044 statistics_counter_event (cfun
, "64-bit bswap implementations found",
2045 bswap_stats
.found_64bit
);
2047 return (changed
? TODO_update_ssa
| TODO_verify_ssa
2048 | TODO_verify_stmts
: 0);
2052 gate_optimize_bswap (void)
2054 return flag_expensive_optimizations
&& optimize
;
2059 const pass_data pass_data_optimize_bswap
=
2061 GIMPLE_PASS
, /* type */
2063 OPTGROUP_NONE
, /* optinfo_flags */
2064 true, /* has_gate */
2065 true, /* has_execute */
2066 TV_NONE
, /* tv_id */
2067 PROP_ssa
, /* properties_required */
2068 0, /* properties_provided */
2069 0, /* properties_destroyed */
2070 0, /* todo_flags_start */
2071 0, /* todo_flags_finish */
2074 class pass_optimize_bswap
: public gimple_opt_pass
2077 pass_optimize_bswap (gcc::context
*ctxt
)
2078 : gimple_opt_pass (pass_data_optimize_bswap
, ctxt
)
2081 /* opt_pass methods: */
2082 bool gate () { return gate_optimize_bswap (); }
2083 unsigned int execute () { return execute_optimize_bswap (); }
2085 }; // class pass_optimize_bswap
2090 make_pass_optimize_bswap (gcc::context
*ctxt
)
2092 return new pass_optimize_bswap (ctxt
);
2095 /* Return true if stmt is a type conversion operation that can be stripped
2096 when used in a widening multiply operation. */
2098 widening_mult_conversion_strippable_p (tree result_type
, gimple stmt
)
2100 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
2102 if (TREE_CODE (result_type
) == INTEGER_TYPE
)
2107 if (!CONVERT_EXPR_CODE_P (rhs_code
))
2110 op_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
2112 /* If the type of OP has the same precision as the result, then
2113 we can strip this conversion. The multiply operation will be
2114 selected to create the correct extension as a by-product. */
2115 if (TYPE_PRECISION (result_type
) == TYPE_PRECISION (op_type
))
2118 /* We can also strip a conversion if it preserves the signed-ness of
2119 the operation and doesn't narrow the range. */
2120 inner_op_type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
2122 /* If the inner-most type is unsigned, then we can strip any
2123 intermediate widening operation. If it's signed, then the
2124 intermediate widening operation must also be signed. */
2125 if ((TYPE_UNSIGNED (inner_op_type
)
2126 || TYPE_UNSIGNED (op_type
) == TYPE_UNSIGNED (inner_op_type
))
2127 && TYPE_PRECISION (op_type
) > TYPE_PRECISION (inner_op_type
))
2133 return rhs_code
== FIXED_CONVERT_EXPR
;
2136 /* Return true if RHS is a suitable operand for a widening multiplication,
2137 assuming a target type of TYPE.
2138 There are two cases:
2140 - RHS makes some value at least twice as wide. Store that value
2141 in *NEW_RHS_OUT if so, and store its type in *TYPE_OUT.
2143 - RHS is an integer constant. Store that value in *NEW_RHS_OUT if so,
2144 but leave *TYPE_OUT untouched. */
2147 is_widening_mult_rhs_p (tree type
, tree rhs
, tree
*type_out
,
2153 if (TREE_CODE (rhs
) == SSA_NAME
)
2155 stmt
= SSA_NAME_DEF_STMT (rhs
);
2156 if (is_gimple_assign (stmt
))
2158 if (! widening_mult_conversion_strippable_p (type
, stmt
))
2162 rhs1
= gimple_assign_rhs1 (stmt
);
2164 if (TREE_CODE (rhs1
) == INTEGER_CST
)
2166 *new_rhs_out
= rhs1
;
2175 type1
= TREE_TYPE (rhs1
);
2177 if (TREE_CODE (type1
) != TREE_CODE (type
)
2178 || TYPE_PRECISION (type1
) * 2 > TYPE_PRECISION (type
))
2181 *new_rhs_out
= rhs1
;
2186 if (TREE_CODE (rhs
) == INTEGER_CST
)
2196 /* Return true if STMT performs a widening multiplication, assuming the
2197 output type is TYPE. If so, store the unwidened types of the operands
2198 in *TYPE1_OUT and *TYPE2_OUT respectively. Also fill *RHS1_OUT and
2199 *RHS2_OUT such that converting those operands to types *TYPE1_OUT
2200 and *TYPE2_OUT would give the operands of the multiplication. */
2203 is_widening_mult_p (gimple stmt
,
2204 tree
*type1_out
, tree
*rhs1_out
,
2205 tree
*type2_out
, tree
*rhs2_out
)
2207 tree type
= TREE_TYPE (gimple_assign_lhs (stmt
));
2209 if (TREE_CODE (type
) != INTEGER_TYPE
2210 && TREE_CODE (type
) != FIXED_POINT_TYPE
)
2213 if (!is_widening_mult_rhs_p (type
, gimple_assign_rhs1 (stmt
), type1_out
,
2217 if (!is_widening_mult_rhs_p (type
, gimple_assign_rhs2 (stmt
), type2_out
,
2221 if (*type1_out
== NULL
)
2223 if (*type2_out
== NULL
|| !int_fits_type_p (*rhs1_out
, *type2_out
))
2225 *type1_out
= *type2_out
;
2228 if (*type2_out
== NULL
)
2230 if (!int_fits_type_p (*rhs2_out
, *type1_out
))
2232 *type2_out
= *type1_out
;
2235 /* Ensure that the larger of the two operands comes first. */
2236 if (TYPE_PRECISION (*type1_out
) < TYPE_PRECISION (*type2_out
))
2240 *type1_out
= *type2_out
;
2243 *rhs1_out
= *rhs2_out
;
2250 /* Process a single gimple statement STMT, which has a MULT_EXPR as
2251 its rhs, and try to convert it into a WIDEN_MULT_EXPR. The return
2252 value is true iff we converted the statement. */
2255 convert_mult_to_widen (gimple stmt
, gimple_stmt_iterator
*gsi
)
2257 tree lhs
, rhs1
, rhs2
, type
, type1
, type2
;
2258 enum insn_code handler
;
2259 enum machine_mode to_mode
, from_mode
, actual_mode
;
2261 int actual_precision
;
2262 location_t loc
= gimple_location (stmt
);
2263 bool from_unsigned1
, from_unsigned2
;
2265 lhs
= gimple_assign_lhs (stmt
);
2266 type
= TREE_TYPE (lhs
);
2267 if (TREE_CODE (type
) != INTEGER_TYPE
)
2270 if (!is_widening_mult_p (stmt
, &type1
, &rhs1
, &type2
, &rhs2
))
2273 to_mode
= TYPE_MODE (type
);
2274 from_mode
= TYPE_MODE (type1
);
2275 from_unsigned1
= TYPE_UNSIGNED (type1
);
2276 from_unsigned2
= TYPE_UNSIGNED (type2
);
2278 if (from_unsigned1
&& from_unsigned2
)
2279 op
= umul_widen_optab
;
2280 else if (!from_unsigned1
&& !from_unsigned2
)
2281 op
= smul_widen_optab
;
2283 op
= usmul_widen_optab
;
2285 handler
= find_widening_optab_handler_and_mode (op
, to_mode
, from_mode
,
2288 if (handler
== CODE_FOR_nothing
)
2290 if (op
!= smul_widen_optab
)
2292 /* We can use a signed multiply with unsigned types as long as
2293 there is a wider mode to use, or it is the smaller of the two
2294 types that is unsigned. Note that type1 >= type2, always. */
2295 if ((TYPE_UNSIGNED (type1
)
2296 && TYPE_PRECISION (type1
) == GET_MODE_PRECISION (from_mode
))
2297 || (TYPE_UNSIGNED (type2
)
2298 && TYPE_PRECISION (type2
) == GET_MODE_PRECISION (from_mode
)))
2300 from_mode
= GET_MODE_WIDER_MODE (from_mode
);
2301 if (GET_MODE_SIZE (to_mode
) <= GET_MODE_SIZE (from_mode
))
2305 op
= smul_widen_optab
;
2306 handler
= find_widening_optab_handler_and_mode (op
, to_mode
,
2310 if (handler
== CODE_FOR_nothing
)
2313 from_unsigned1
= from_unsigned2
= false;
2319 /* Ensure that the inputs to the handler are in the correct precison
2320 for the opcode. This will be the full mode size. */
2321 actual_precision
= GET_MODE_PRECISION (actual_mode
);
2322 if (2 * actual_precision
> TYPE_PRECISION (type
))
2324 if (actual_precision
!= TYPE_PRECISION (type1
)
2325 || from_unsigned1
!= TYPE_UNSIGNED (type1
))
2326 rhs1
= build_and_insert_cast (gsi
, loc
,
2327 build_nonstandard_integer_type
2328 (actual_precision
, from_unsigned1
), rhs1
);
2329 if (actual_precision
!= TYPE_PRECISION (type2
)
2330 || from_unsigned2
!= TYPE_UNSIGNED (type2
))
2331 rhs2
= build_and_insert_cast (gsi
, loc
,
2332 build_nonstandard_integer_type
2333 (actual_precision
, from_unsigned2
), rhs2
);
2335 /* Handle constants. */
2336 if (TREE_CODE (rhs1
) == INTEGER_CST
)
2337 rhs1
= fold_convert (type1
, rhs1
);
2338 if (TREE_CODE (rhs2
) == INTEGER_CST
)
2339 rhs2
= fold_convert (type2
, rhs2
);
2341 gimple_assign_set_rhs1 (stmt
, rhs1
);
2342 gimple_assign_set_rhs2 (stmt
, rhs2
);
2343 gimple_assign_set_rhs_code (stmt
, WIDEN_MULT_EXPR
);
2345 widen_mul_stats
.widen_mults_inserted
++;
2349 /* Process a single gimple statement STMT, which is found at the
2350 iterator GSI and has a either a PLUS_EXPR or a MINUS_EXPR as its
2351 rhs (given by CODE), and try to convert it into a
2352 WIDEN_MULT_PLUS_EXPR or a WIDEN_MULT_MINUS_EXPR. The return value
2353 is true iff we converted the statement. */
2356 convert_plusminus_to_widen (gimple_stmt_iterator
*gsi
, gimple stmt
,
2357 enum tree_code code
)
2359 gimple rhs1_stmt
= NULL
, rhs2_stmt
= NULL
;
2360 gimple conv1_stmt
= NULL
, conv2_stmt
= NULL
, conv_stmt
;
2361 tree type
, type1
, type2
, optype
;
2362 tree lhs
, rhs1
, rhs2
, mult_rhs1
, mult_rhs2
, add_rhs
;
2363 enum tree_code rhs1_code
= ERROR_MARK
, rhs2_code
= ERROR_MARK
;
2365 enum tree_code wmult_code
;
2366 enum insn_code handler
;
2367 enum machine_mode to_mode
, from_mode
, actual_mode
;
2368 location_t loc
= gimple_location (stmt
);
2369 int actual_precision
;
2370 bool from_unsigned1
, from_unsigned2
;
2372 lhs
= gimple_assign_lhs (stmt
);
2373 type
= TREE_TYPE (lhs
);
2374 if (TREE_CODE (type
) != INTEGER_TYPE
2375 && TREE_CODE (type
) != FIXED_POINT_TYPE
)
2378 if (code
== MINUS_EXPR
)
2379 wmult_code
= WIDEN_MULT_MINUS_EXPR
;
2381 wmult_code
= WIDEN_MULT_PLUS_EXPR
;
2383 rhs1
= gimple_assign_rhs1 (stmt
);
2384 rhs2
= gimple_assign_rhs2 (stmt
);
2386 if (TREE_CODE (rhs1
) == SSA_NAME
)
2388 rhs1_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2389 if (is_gimple_assign (rhs1_stmt
))
2390 rhs1_code
= gimple_assign_rhs_code (rhs1_stmt
);
2393 if (TREE_CODE (rhs2
) == SSA_NAME
)
2395 rhs2_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2396 if (is_gimple_assign (rhs2_stmt
))
2397 rhs2_code
= gimple_assign_rhs_code (rhs2_stmt
);
2400 /* Allow for one conversion statement between the multiply
2401 and addition/subtraction statement. If there are more than
2402 one conversions then we assume they would invalidate this
2403 transformation. If that's not the case then they should have
2404 been folded before now. */
2405 if (CONVERT_EXPR_CODE_P (rhs1_code
))
2407 conv1_stmt
= rhs1_stmt
;
2408 rhs1
= gimple_assign_rhs1 (rhs1_stmt
);
2409 if (TREE_CODE (rhs1
) == SSA_NAME
)
2411 rhs1_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2412 if (is_gimple_assign (rhs1_stmt
))
2413 rhs1_code
= gimple_assign_rhs_code (rhs1_stmt
);
2418 if (CONVERT_EXPR_CODE_P (rhs2_code
))
2420 conv2_stmt
= rhs2_stmt
;
2421 rhs2
= gimple_assign_rhs1 (rhs2_stmt
);
2422 if (TREE_CODE (rhs2
) == SSA_NAME
)
2424 rhs2_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2425 if (is_gimple_assign (rhs2_stmt
))
2426 rhs2_code
= gimple_assign_rhs_code (rhs2_stmt
);
2432 /* If code is WIDEN_MULT_EXPR then it would seem unnecessary to call
2433 is_widening_mult_p, but we still need the rhs returns.
2435 It might also appear that it would be sufficient to use the existing
2436 operands of the widening multiply, but that would limit the choice of
2437 multiply-and-accumulate instructions.
2439 If the widened-multiplication result has more than one uses, it is
2440 probably wiser not to do the conversion. */
2441 if (code
== PLUS_EXPR
2442 && (rhs1_code
== MULT_EXPR
|| rhs1_code
== WIDEN_MULT_EXPR
))
2444 if (!has_single_use (rhs1
)
2445 || !is_widening_mult_p (rhs1_stmt
, &type1
, &mult_rhs1
,
2446 &type2
, &mult_rhs2
))
2449 conv_stmt
= conv1_stmt
;
2451 else if (rhs2_code
== MULT_EXPR
|| rhs2_code
== WIDEN_MULT_EXPR
)
2453 if (!has_single_use (rhs2
)
2454 || !is_widening_mult_p (rhs2_stmt
, &type1
, &mult_rhs1
,
2455 &type2
, &mult_rhs2
))
2458 conv_stmt
= conv2_stmt
;
2463 to_mode
= TYPE_MODE (type
);
2464 from_mode
= TYPE_MODE (type1
);
2465 from_unsigned1
= TYPE_UNSIGNED (type1
);
2466 from_unsigned2
= TYPE_UNSIGNED (type2
);
2469 /* There's no such thing as a mixed sign madd yet, so use a wider mode. */
2470 if (from_unsigned1
!= from_unsigned2
)
2472 if (!INTEGRAL_TYPE_P (type
))
2474 /* We can use a signed multiply with unsigned types as long as
2475 there is a wider mode to use, or it is the smaller of the two
2476 types that is unsigned. Note that type1 >= type2, always. */
2478 && TYPE_PRECISION (type1
) == GET_MODE_PRECISION (from_mode
))
2480 && TYPE_PRECISION (type2
) == GET_MODE_PRECISION (from_mode
)))
2482 from_mode
= GET_MODE_WIDER_MODE (from_mode
);
2483 if (GET_MODE_SIZE (from_mode
) >= GET_MODE_SIZE (to_mode
))
2487 from_unsigned1
= from_unsigned2
= false;
2488 optype
= build_nonstandard_integer_type (GET_MODE_PRECISION (from_mode
),
2492 /* If there was a conversion between the multiply and addition
2493 then we need to make sure it fits a multiply-and-accumulate.
2494 The should be a single mode change which does not change the
2498 /* We use the original, unmodified data types for this. */
2499 tree from_type
= TREE_TYPE (gimple_assign_rhs1 (conv_stmt
));
2500 tree to_type
= TREE_TYPE (gimple_assign_lhs (conv_stmt
));
2501 int data_size
= TYPE_PRECISION (type1
) + TYPE_PRECISION (type2
);
2502 bool is_unsigned
= TYPE_UNSIGNED (type1
) && TYPE_UNSIGNED (type2
);
2504 if (TYPE_PRECISION (from_type
) > TYPE_PRECISION (to_type
))
2506 /* Conversion is a truncate. */
2507 if (TYPE_PRECISION (to_type
) < data_size
)
2510 else if (TYPE_PRECISION (from_type
) < TYPE_PRECISION (to_type
))
2512 /* Conversion is an extend. Check it's the right sort. */
2513 if (TYPE_UNSIGNED (from_type
) != is_unsigned
2514 && !(is_unsigned
&& TYPE_PRECISION (from_type
) > data_size
))
2517 /* else convert is a no-op for our purposes. */
2520 /* Verify that the machine can perform a widening multiply
2521 accumulate in this mode/signedness combination, otherwise
2522 this transformation is likely to pessimize code. */
2523 this_optab
= optab_for_tree_code (wmult_code
, optype
, optab_default
);
2524 handler
= find_widening_optab_handler_and_mode (this_optab
, to_mode
,
2525 from_mode
, 0, &actual_mode
);
2527 if (handler
== CODE_FOR_nothing
)
2530 /* Ensure that the inputs to the handler are in the correct precison
2531 for the opcode. This will be the full mode size. */
2532 actual_precision
= GET_MODE_PRECISION (actual_mode
);
2533 if (actual_precision
!= TYPE_PRECISION (type1
)
2534 || from_unsigned1
!= TYPE_UNSIGNED (type1
))
2535 mult_rhs1
= build_and_insert_cast (gsi
, loc
,
2536 build_nonstandard_integer_type
2537 (actual_precision
, from_unsigned1
),
2539 if (actual_precision
!= TYPE_PRECISION (type2
)
2540 || from_unsigned2
!= TYPE_UNSIGNED (type2
))
2541 mult_rhs2
= build_and_insert_cast (gsi
, loc
,
2542 build_nonstandard_integer_type
2543 (actual_precision
, from_unsigned2
),
2546 if (!useless_type_conversion_p (type
, TREE_TYPE (add_rhs
)))
2547 add_rhs
= build_and_insert_cast (gsi
, loc
, type
, add_rhs
);
2549 /* Handle constants. */
2550 if (TREE_CODE (mult_rhs1
) == INTEGER_CST
)
2551 mult_rhs1
= fold_convert (type1
, mult_rhs1
);
2552 if (TREE_CODE (mult_rhs2
) == INTEGER_CST
)
2553 mult_rhs2
= fold_convert (type2
, mult_rhs2
);
2555 gimple_assign_set_rhs_with_ops_1 (gsi
, wmult_code
, mult_rhs1
, mult_rhs2
,
2557 update_stmt (gsi_stmt (*gsi
));
2558 widen_mul_stats
.maccs_inserted
++;
2562 /* Combine the multiplication at MUL_STMT with operands MULOP1 and MULOP2
2563 with uses in additions and subtractions to form fused multiply-add
2564 operations. Returns true if successful and MUL_STMT should be removed. */
2567 convert_mult_to_fma (gimple mul_stmt
, tree op1
, tree op2
)
2569 tree mul_result
= gimple_get_lhs (mul_stmt
);
2570 tree type
= TREE_TYPE (mul_result
);
2571 gimple use_stmt
, neguse_stmt
, fma_stmt
;
2572 use_operand_p use_p
;
2573 imm_use_iterator imm_iter
;
2575 if (FLOAT_TYPE_P (type
)
2576 && flag_fp_contract_mode
== FP_CONTRACT_OFF
)
2579 /* We don't want to do bitfield reduction ops. */
2580 if (INTEGRAL_TYPE_P (type
)
2581 && (TYPE_PRECISION (type
)
2582 != GET_MODE_PRECISION (TYPE_MODE (type
))))
2585 /* If the target doesn't support it, don't generate it. We assume that
2586 if fma isn't available then fms, fnma or fnms are not either. */
2587 if (optab_handler (fma_optab
, TYPE_MODE (type
)) == CODE_FOR_nothing
)
2590 /* If the multiplication has zero uses, it is kept around probably because
2591 of -fnon-call-exceptions. Don't optimize it away in that case,
2593 if (has_zero_uses (mul_result
))
2596 /* Make sure that the multiplication statement becomes dead after
2597 the transformation, thus that all uses are transformed to FMAs.
2598 This means we assume that an FMA operation has the same cost
2600 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, mul_result
)
2602 enum tree_code use_code
;
2603 tree result
= mul_result
;
2604 bool negate_p
= false;
2606 use_stmt
= USE_STMT (use_p
);
2608 if (is_gimple_debug (use_stmt
))
2611 /* For now restrict this operations to single basic blocks. In theory
2612 we would want to support sinking the multiplication in
2618 to form a fma in the then block and sink the multiplication to the
2620 if (gimple_bb (use_stmt
) != gimple_bb (mul_stmt
))
2623 if (!is_gimple_assign (use_stmt
))
2626 use_code
= gimple_assign_rhs_code (use_stmt
);
2628 /* A negate on the multiplication leads to FNMA. */
2629 if (use_code
== NEGATE_EXPR
)
2634 result
= gimple_assign_lhs (use_stmt
);
2636 /* Make sure the negate statement becomes dead with this
2637 single transformation. */
2638 if (!single_imm_use (gimple_assign_lhs (use_stmt
),
2639 &use_p
, &neguse_stmt
))
2642 /* Make sure the multiplication isn't also used on that stmt. */
2643 FOR_EACH_PHI_OR_STMT_USE (usep
, neguse_stmt
, iter
, SSA_OP_USE
)
2644 if (USE_FROM_PTR (usep
) == mul_result
)
2648 use_stmt
= neguse_stmt
;
2649 if (gimple_bb (use_stmt
) != gimple_bb (mul_stmt
))
2651 if (!is_gimple_assign (use_stmt
))
2654 use_code
= gimple_assign_rhs_code (use_stmt
);
2661 if (gimple_assign_rhs2 (use_stmt
) == result
)
2662 negate_p
= !negate_p
;
2667 /* FMA can only be formed from PLUS and MINUS. */
2671 /* If the subtrahend (gimple_assign_rhs2 (use_stmt)) is computed
2672 by a MULT_EXPR that we'll visit later, we might be able to
2673 get a more profitable match with fnma.
2674 OTOH, if we don't, a negate / fma pair has likely lower latency
2675 that a mult / subtract pair. */
2676 if (use_code
== MINUS_EXPR
&& !negate_p
2677 && gimple_assign_rhs1 (use_stmt
) == result
2678 && optab_handler (fms_optab
, TYPE_MODE (type
)) == CODE_FOR_nothing
2679 && optab_handler (fnma_optab
, TYPE_MODE (type
)) != CODE_FOR_nothing
)
2681 tree rhs2
= gimple_assign_rhs2 (use_stmt
);
2683 if (TREE_CODE (rhs2
) == SSA_NAME
)
2685 gimple stmt2
= SSA_NAME_DEF_STMT (rhs2
);
2686 if (has_single_use (rhs2
)
2687 && is_gimple_assign (stmt2
)
2688 && gimple_assign_rhs_code (stmt2
) == MULT_EXPR
)
2693 /* We can't handle a * b + a * b. */
2694 if (gimple_assign_rhs1 (use_stmt
) == gimple_assign_rhs2 (use_stmt
))
2697 /* While it is possible to validate whether or not the exact form
2698 that we've recognized is available in the backend, the assumption
2699 is that the transformation is never a loss. For instance, suppose
2700 the target only has the plain FMA pattern available. Consider
2701 a*b-c -> fma(a,b,-c): we've exchanged MUL+SUB for FMA+NEG, which
2702 is still two operations. Consider -(a*b)-c -> fma(-a,b,-c): we
2703 still have 3 operations, but in the FMA form the two NEGs are
2704 independent and could be run in parallel. */
2707 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, mul_result
)
2709 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
2710 enum tree_code use_code
;
2711 tree addop
, mulop1
= op1
, result
= mul_result
;
2712 bool negate_p
= false;
2714 if (is_gimple_debug (use_stmt
))
2717 use_code
= gimple_assign_rhs_code (use_stmt
);
2718 if (use_code
== NEGATE_EXPR
)
2720 result
= gimple_assign_lhs (use_stmt
);
2721 single_imm_use (gimple_assign_lhs (use_stmt
), &use_p
, &neguse_stmt
);
2722 gsi_remove (&gsi
, true);
2723 release_defs (use_stmt
);
2725 use_stmt
= neguse_stmt
;
2726 gsi
= gsi_for_stmt (use_stmt
);
2727 use_code
= gimple_assign_rhs_code (use_stmt
);
2731 if (gimple_assign_rhs1 (use_stmt
) == result
)
2733 addop
= gimple_assign_rhs2 (use_stmt
);
2734 /* a * b - c -> a * b + (-c) */
2735 if (gimple_assign_rhs_code (use_stmt
) == MINUS_EXPR
)
2736 addop
= force_gimple_operand_gsi (&gsi
,
2737 build1 (NEGATE_EXPR
,
2739 true, NULL_TREE
, true,
2744 addop
= gimple_assign_rhs1 (use_stmt
);
2745 /* a - b * c -> (-b) * c + a */
2746 if (gimple_assign_rhs_code (use_stmt
) == MINUS_EXPR
)
2747 negate_p
= !negate_p
;
2751 mulop1
= force_gimple_operand_gsi (&gsi
,
2752 build1 (NEGATE_EXPR
,
2754 true, NULL_TREE
, true,
2757 fma_stmt
= gimple_build_assign_with_ops (FMA_EXPR
,
2758 gimple_assign_lhs (use_stmt
),
2761 gsi_replace (&gsi
, fma_stmt
, true);
2762 widen_mul_stats
.fmas_inserted
++;
2768 /* Find integer multiplications where the operands are extended from
2769 smaller types, and replace the MULT_EXPR with a WIDEN_MULT_EXPR
2770 where appropriate. */
2773 execute_optimize_widening_mul (void)
2776 bool cfg_changed
= false;
2778 memset (&widen_mul_stats
, 0, sizeof (widen_mul_stats
));
2782 gimple_stmt_iterator gsi
;
2784 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
);)
2786 gimple stmt
= gsi_stmt (gsi
);
2787 enum tree_code code
;
2789 if (is_gimple_assign (stmt
))
2791 code
= gimple_assign_rhs_code (stmt
);
2795 if (!convert_mult_to_widen (stmt
, &gsi
)
2796 && convert_mult_to_fma (stmt
,
2797 gimple_assign_rhs1 (stmt
),
2798 gimple_assign_rhs2 (stmt
)))
2800 gsi_remove (&gsi
, true);
2801 release_defs (stmt
);
2808 convert_plusminus_to_widen (&gsi
, stmt
, code
);
2814 else if (is_gimple_call (stmt
)
2815 && gimple_call_lhs (stmt
))
2817 tree fndecl
= gimple_call_fndecl (stmt
);
2819 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2821 switch (DECL_FUNCTION_CODE (fndecl
))
2826 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
2827 && REAL_VALUES_EQUAL
2828 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)),
2830 && convert_mult_to_fma (stmt
,
2831 gimple_call_arg (stmt
, 0),
2832 gimple_call_arg (stmt
, 0)))
2834 unlink_stmt_vdef (stmt
);
2835 if (gsi_remove (&gsi
, true)
2836 && gimple_purge_dead_eh_edges (bb
))
2838 release_defs (stmt
);
2851 statistics_counter_event (cfun
, "widening multiplications inserted",
2852 widen_mul_stats
.widen_mults_inserted
);
2853 statistics_counter_event (cfun
, "widening maccs inserted",
2854 widen_mul_stats
.maccs_inserted
);
2855 statistics_counter_event (cfun
, "fused multiply-adds inserted",
2856 widen_mul_stats
.fmas_inserted
);
2858 return cfg_changed
? TODO_cleanup_cfg
: 0;
2862 gate_optimize_widening_mul (void)
2864 return flag_expensive_optimizations
&& optimize
;
2869 const pass_data pass_data_optimize_widening_mul
=
2871 GIMPLE_PASS
, /* type */
2872 "widening_mul", /* name */
2873 OPTGROUP_NONE
, /* optinfo_flags */
2874 true, /* has_gate */
2875 true, /* has_execute */
2876 TV_NONE
, /* tv_id */
2877 PROP_ssa
, /* properties_required */
2878 0, /* properties_provided */
2879 0, /* properties_destroyed */
2880 0, /* todo_flags_start */
2881 ( TODO_verify_ssa
| TODO_verify_stmts
2882 | TODO_update_ssa
), /* todo_flags_finish */
2885 class pass_optimize_widening_mul
: public gimple_opt_pass
2888 pass_optimize_widening_mul (gcc::context
*ctxt
)
2889 : gimple_opt_pass (pass_data_optimize_widening_mul
, ctxt
)
2892 /* opt_pass methods: */
2893 bool gate () { return gate_optimize_widening_mul (); }
2894 unsigned int execute () { return execute_optimize_widening_mul (); }
2896 }; // class pass_optimize_widening_mul
2901 make_pass_optimize_widening_mul (gcc::context
*ctxt
)
2903 return new pass_optimize_widening_mul (ctxt
);