1 /* Global, SSA-based optimizations using mathematical identities.
2 Copyright (C) 2005-2014 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"
93 #include "basic-block.h"
94 #include "tree-ssa-alias.h"
95 #include "internal-fn.h"
96 #include "gimple-fold.h"
97 #include "gimple-expr.h"
100 #include "gimple-iterator.h"
101 #include "gimplify-me.h"
102 #include "stor-layout.h"
103 #include "gimple-ssa.h"
104 #include "tree-cfg.h"
105 #include "tree-phinodes.h"
106 #include "ssa-iterators.h"
107 #include "stringpool.h"
108 #include "tree-ssanames.h"
110 #include "tree-dfa.h"
111 #include "tree-ssa.h"
112 #include "tree-pass.h"
113 #include "alloc-pool.h"
115 #include "gimple-pretty-print.h"
117 /* FIXME: RTL headers have to be included here for optabs. */
118 #include "rtl.h" /* Because optabs.h wants enum rtx_code. */
119 #include "expr.h" /* Because optabs.h wants sepops. */
122 /* This structure represents one basic block that either computes a
123 division, or is a common dominator for basic block that compute a
126 /* The basic block represented by this structure. */
129 /* If non-NULL, the SSA_NAME holding the definition for a reciprocal
133 /* If non-NULL, the GIMPLE_ASSIGN for a reciprocal computation that
134 was inserted in BB. */
135 gimple recip_def_stmt
;
137 /* Pointer to a list of "struct occurrence"s for blocks dominated
139 struct occurrence
*children
;
141 /* Pointer to the next "struct occurrence"s in the list of blocks
142 sharing a common dominator. */
143 struct occurrence
*next
;
145 /* The number of divisions that are in BB before compute_merit. The
146 number of divisions that are in BB or post-dominate it after
150 /* True if the basic block has a division, false if it is a common
151 dominator for basic blocks that do. If it is false and trapping
152 math is active, BB is not a candidate for inserting a reciprocal. */
153 bool bb_has_division
;
158 /* Number of 1.0/X ops inserted. */
161 /* Number of 1.0/FUNC ops inserted. */
167 /* Number of cexpi calls inserted. */
173 /* Number of hand-written 16-bit bswaps found. */
176 /* Number of hand-written 32-bit bswaps found. */
179 /* Number of hand-written 64-bit bswaps found. */
185 /* Number of widening multiplication ops inserted. */
186 int widen_mults_inserted
;
188 /* Number of integer multiply-and-accumulate ops inserted. */
191 /* Number of fp fused multiply-add ops inserted. */
195 /* The instance of "struct occurrence" representing the highest
196 interesting block in the dominator tree. */
197 static struct occurrence
*occ_head
;
199 /* Allocation pool for getting instances of "struct occurrence". */
200 static alloc_pool occ_pool
;
204 /* Allocate and return a new struct occurrence for basic block BB, and
205 whose children list is headed by CHILDREN. */
206 static struct occurrence
*
207 occ_new (basic_block bb
, struct occurrence
*children
)
209 struct occurrence
*occ
;
211 bb
->aux
= occ
= (struct occurrence
*) pool_alloc (occ_pool
);
212 memset (occ
, 0, sizeof (struct occurrence
));
215 occ
->children
= children
;
220 /* Insert NEW_OCC into our subset of the dominator tree. P_HEAD points to a
221 list of "struct occurrence"s, one per basic block, having IDOM as
222 their common dominator.
224 We try to insert NEW_OCC as deep as possible in the tree, and we also
225 insert any other block that is a common dominator for BB and one
226 block already in the tree. */
229 insert_bb (struct occurrence
*new_occ
, basic_block idom
,
230 struct occurrence
**p_head
)
232 struct occurrence
*occ
, **p_occ
;
234 for (p_occ
= p_head
; (occ
= *p_occ
) != NULL
; )
236 basic_block bb
= new_occ
->bb
, occ_bb
= occ
->bb
;
237 basic_block dom
= nearest_common_dominator (CDI_DOMINATORS
, occ_bb
, bb
);
240 /* BB dominates OCC_BB. OCC becomes NEW_OCC's child: remove OCC
243 occ
->next
= new_occ
->children
;
244 new_occ
->children
= occ
;
246 /* Try the next block (it may as well be dominated by BB). */
249 else if (dom
== occ_bb
)
251 /* OCC_BB dominates BB. Tail recurse to look deeper. */
252 insert_bb (new_occ
, dom
, &occ
->children
);
256 else if (dom
!= idom
)
258 gcc_assert (!dom
->aux
);
260 /* There is a dominator between IDOM and BB, add it and make
261 two children out of NEW_OCC and OCC. First, remove OCC from
267 /* None of the previous blocks has DOM as a dominator: if we tail
268 recursed, we would reexamine them uselessly. Just switch BB with
269 DOM, and go on looking for blocks dominated by DOM. */
270 new_occ
= occ_new (dom
, new_occ
);
275 /* Nothing special, go on with the next element. */
280 /* No place was found as a child of IDOM. Make BB a sibling of IDOM. */
281 new_occ
->next
= *p_head
;
285 /* Register that we found a division in BB. */
288 register_division_in (basic_block bb
)
290 struct occurrence
*occ
;
292 occ
= (struct occurrence
*) bb
->aux
;
295 occ
= occ_new (bb
, NULL
);
296 insert_bb (occ
, ENTRY_BLOCK_PTR_FOR_FN (cfun
), &occ_head
);
299 occ
->bb_has_division
= true;
300 occ
->num_divisions
++;
304 /* Compute the number of divisions that postdominate each block in OCC and
308 compute_merit (struct occurrence
*occ
)
310 struct occurrence
*occ_child
;
311 basic_block dom
= occ
->bb
;
313 for (occ_child
= occ
->children
; occ_child
; occ_child
= occ_child
->next
)
316 if (occ_child
->children
)
317 compute_merit (occ_child
);
320 bb
= single_noncomplex_succ (dom
);
324 if (dominated_by_p (CDI_POST_DOMINATORS
, bb
, occ_child
->bb
))
325 occ
->num_divisions
+= occ_child
->num_divisions
;
330 /* Return whether USE_STMT is a floating-point division by DEF. */
332 is_division_by (gimple use_stmt
, tree def
)
334 return is_gimple_assign (use_stmt
)
335 && gimple_assign_rhs_code (use_stmt
) == RDIV_EXPR
336 && gimple_assign_rhs2 (use_stmt
) == def
337 /* Do not recognize x / x as valid division, as we are getting
338 confused later by replacing all immediate uses x in such
340 && gimple_assign_rhs1 (use_stmt
) != def
;
343 /* Walk the subset of the dominator tree rooted at OCC, setting the
344 RECIP_DEF field to a definition of 1.0 / DEF that can be used in
345 the given basic block. The field may be left NULL, of course,
346 if it is not possible or profitable to do the optimization.
348 DEF_BSI is an iterator pointing at the statement defining DEF.
349 If RECIP_DEF is set, a dominator already has a computation that can
353 insert_reciprocals (gimple_stmt_iterator
*def_gsi
, struct occurrence
*occ
,
354 tree def
, tree recip_def
, int threshold
)
358 gimple_stmt_iterator gsi
;
359 struct occurrence
*occ_child
;
362 && (occ
->bb_has_division
|| !flag_trapping_math
)
363 && occ
->num_divisions
>= threshold
)
365 /* Make a variable with the replacement and substitute it. */
366 type
= TREE_TYPE (def
);
367 recip_def
= create_tmp_reg (type
, "reciptmp");
368 new_stmt
= gimple_build_assign_with_ops (RDIV_EXPR
, recip_def
,
369 build_one_cst (type
), def
);
371 if (occ
->bb_has_division
)
373 /* Case 1: insert before an existing division. */
374 gsi
= gsi_after_labels (occ
->bb
);
375 while (!gsi_end_p (gsi
) && !is_division_by (gsi_stmt (gsi
), def
))
378 gsi_insert_before (&gsi
, new_stmt
, GSI_SAME_STMT
);
380 else if (def_gsi
&& occ
->bb
== def_gsi
->bb
)
382 /* Case 2: insert right after the definition. Note that this will
383 never happen if the definition statement can throw, because in
384 that case the sole successor of the statement's basic block will
385 dominate all the uses as well. */
386 gsi_insert_after (def_gsi
, new_stmt
, GSI_NEW_STMT
);
390 /* Case 3: insert in a basic block not containing defs/uses. */
391 gsi
= gsi_after_labels (occ
->bb
);
392 gsi_insert_before (&gsi
, new_stmt
, GSI_SAME_STMT
);
395 reciprocal_stats
.rdivs_inserted
++;
397 occ
->recip_def_stmt
= new_stmt
;
400 occ
->recip_def
= recip_def
;
401 for (occ_child
= occ
->children
; occ_child
; occ_child
= occ_child
->next
)
402 insert_reciprocals (def_gsi
, occ_child
, def
, recip_def
, threshold
);
406 /* Replace the division at USE_P with a multiplication by the reciprocal, if
410 replace_reciprocal (use_operand_p use_p
)
412 gimple use_stmt
= USE_STMT (use_p
);
413 basic_block bb
= gimple_bb (use_stmt
);
414 struct occurrence
*occ
= (struct occurrence
*) bb
->aux
;
416 if (optimize_bb_for_speed_p (bb
)
417 && occ
->recip_def
&& use_stmt
!= occ
->recip_def_stmt
)
419 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
420 gimple_assign_set_rhs_code (use_stmt
, MULT_EXPR
);
421 SET_USE (use_p
, occ
->recip_def
);
422 fold_stmt_inplace (&gsi
);
423 update_stmt (use_stmt
);
428 /* Free OCC and return one more "struct occurrence" to be freed. */
430 static struct occurrence
*
431 free_bb (struct occurrence
*occ
)
433 struct occurrence
*child
, *next
;
435 /* First get the two pointers hanging off OCC. */
437 child
= occ
->children
;
439 pool_free (occ_pool
, occ
);
441 /* Now ensure that we don't recurse unless it is necessary. */
447 next
= free_bb (next
);
454 /* Look for floating-point divisions among DEF's uses, and try to
455 replace them by multiplications with the reciprocal. Add
456 as many statements computing the reciprocal as needed.
458 DEF must be a GIMPLE register of a floating-point type. */
461 execute_cse_reciprocals_1 (gimple_stmt_iterator
*def_gsi
, tree def
)
464 imm_use_iterator use_iter
;
465 struct occurrence
*occ
;
466 int count
= 0, threshold
;
468 gcc_assert (FLOAT_TYPE_P (TREE_TYPE (def
)) && is_gimple_reg (def
));
470 FOR_EACH_IMM_USE_FAST (use_p
, use_iter
, def
)
472 gimple use_stmt
= USE_STMT (use_p
);
473 if (is_division_by (use_stmt
, def
))
475 register_division_in (gimple_bb (use_stmt
));
480 /* Do the expensive part only if we can hope to optimize something. */
481 threshold
= targetm
.min_divisions_for_recip_mul (TYPE_MODE (TREE_TYPE (def
)));
482 if (count
>= threshold
)
485 for (occ
= occ_head
; occ
; occ
= occ
->next
)
488 insert_reciprocals (def_gsi
, occ
, def
, NULL
, threshold
);
491 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, def
)
493 if (is_division_by (use_stmt
, def
))
495 FOR_EACH_IMM_USE_ON_STMT (use_p
, use_iter
)
496 replace_reciprocal (use_p
);
501 for (occ
= occ_head
; occ
; )
507 /* Go through all the floating-point SSA_NAMEs, and call
508 execute_cse_reciprocals_1 on each of them. */
510 execute_cse_reciprocals (void)
515 occ_pool
= create_alloc_pool ("dominators for recip",
516 sizeof (struct occurrence
),
517 n_basic_blocks_for_fn (cfun
) / 3 + 1);
519 memset (&reciprocal_stats
, 0, sizeof (reciprocal_stats
));
520 calculate_dominance_info (CDI_DOMINATORS
);
521 calculate_dominance_info (CDI_POST_DOMINATORS
);
523 #ifdef ENABLE_CHECKING
524 FOR_EACH_BB_FN (bb
, cfun
)
525 gcc_assert (!bb
->aux
);
528 for (arg
= DECL_ARGUMENTS (cfun
->decl
); arg
; arg
= DECL_CHAIN (arg
))
529 if (FLOAT_TYPE_P (TREE_TYPE (arg
))
530 && is_gimple_reg (arg
))
532 tree name
= ssa_default_def (cfun
, arg
);
534 execute_cse_reciprocals_1 (NULL
, name
);
537 FOR_EACH_BB_FN (bb
, cfun
)
539 gimple_stmt_iterator gsi
;
543 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
545 phi
= gsi_stmt (gsi
);
546 def
= PHI_RESULT (phi
);
547 if (! virtual_operand_p (def
)
548 && FLOAT_TYPE_P (TREE_TYPE (def
)))
549 execute_cse_reciprocals_1 (NULL
, def
);
552 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
554 gimple stmt
= gsi_stmt (gsi
);
556 if (gimple_has_lhs (stmt
)
557 && (def
= SINGLE_SSA_TREE_OPERAND (stmt
, SSA_OP_DEF
)) != NULL
558 && FLOAT_TYPE_P (TREE_TYPE (def
))
559 && TREE_CODE (def
) == SSA_NAME
)
560 execute_cse_reciprocals_1 (&gsi
, def
);
563 if (optimize_bb_for_size_p (bb
))
566 /* Scan for a/func(b) and convert it to reciprocal a*rfunc(b). */
567 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
569 gimple stmt
= gsi_stmt (gsi
);
572 if (is_gimple_assign (stmt
)
573 && gimple_assign_rhs_code (stmt
) == RDIV_EXPR
)
575 tree arg1
= gimple_assign_rhs2 (stmt
);
578 if (TREE_CODE (arg1
) != SSA_NAME
)
581 stmt1
= SSA_NAME_DEF_STMT (arg1
);
583 if (is_gimple_call (stmt1
)
584 && gimple_call_lhs (stmt1
)
585 && (fndecl
= gimple_call_fndecl (stmt1
))
586 && (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
587 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
))
589 enum built_in_function code
;
594 code
= DECL_FUNCTION_CODE (fndecl
);
595 md_code
= DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
;
597 fndecl
= targetm
.builtin_reciprocal (code
, md_code
, false);
601 /* Check that all uses of the SSA name are divisions,
602 otherwise replacing the defining statement will do
605 FOR_EACH_IMM_USE_FAST (use_p
, ui
, arg1
)
607 gimple stmt2
= USE_STMT (use_p
);
608 if (is_gimple_debug (stmt2
))
610 if (!is_gimple_assign (stmt2
)
611 || gimple_assign_rhs_code (stmt2
) != RDIV_EXPR
612 || gimple_assign_rhs1 (stmt2
) == arg1
613 || gimple_assign_rhs2 (stmt2
) != arg1
)
622 gimple_replace_ssa_lhs (stmt1
, arg1
);
623 gimple_call_set_fndecl (stmt1
, fndecl
);
625 reciprocal_stats
.rfuncs_inserted
++;
627 FOR_EACH_IMM_USE_STMT (stmt
, ui
, arg1
)
629 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
630 gimple_assign_set_rhs_code (stmt
, MULT_EXPR
);
631 fold_stmt_inplace (&gsi
);
639 statistics_counter_event (cfun
, "reciprocal divs inserted",
640 reciprocal_stats
.rdivs_inserted
);
641 statistics_counter_event (cfun
, "reciprocal functions inserted",
642 reciprocal_stats
.rfuncs_inserted
);
644 free_dominance_info (CDI_DOMINATORS
);
645 free_dominance_info (CDI_POST_DOMINATORS
);
646 free_alloc_pool (occ_pool
);
652 const pass_data pass_data_cse_reciprocals
=
654 GIMPLE_PASS
, /* type */
656 OPTGROUP_NONE
, /* optinfo_flags */
657 true, /* has_execute */
659 PROP_ssa
, /* properties_required */
660 0, /* properties_provided */
661 0, /* properties_destroyed */
662 0, /* todo_flags_start */
663 ( TODO_update_ssa
| TODO_verify_ssa
664 | TODO_verify_stmts
), /* todo_flags_finish */
667 class pass_cse_reciprocals
: public gimple_opt_pass
670 pass_cse_reciprocals (gcc::context
*ctxt
)
671 : gimple_opt_pass (pass_data_cse_reciprocals
, ctxt
)
674 /* opt_pass methods: */
675 virtual bool gate (function
*) { return optimize
&& flag_reciprocal_math
; }
676 unsigned int execute () { return execute_cse_reciprocals (); }
678 }; // class pass_cse_reciprocals
683 make_pass_cse_reciprocals (gcc::context
*ctxt
)
685 return new pass_cse_reciprocals (ctxt
);
688 /* Records an occurrence at statement USE_STMT in the vector of trees
689 STMTS if it is dominated by *TOP_BB or dominates it or this basic block
690 is not yet initialized. Returns true if the occurrence was pushed on
691 the vector. Adjusts *TOP_BB to be the basic block dominating all
692 statements in the vector. */
695 maybe_record_sincos (vec
<gimple
> *stmts
,
696 basic_block
*top_bb
, gimple use_stmt
)
698 basic_block use_bb
= gimple_bb (use_stmt
);
700 && (*top_bb
== use_bb
701 || dominated_by_p (CDI_DOMINATORS
, use_bb
, *top_bb
)))
702 stmts
->safe_push (use_stmt
);
704 || dominated_by_p (CDI_DOMINATORS
, *top_bb
, use_bb
))
706 stmts
->safe_push (use_stmt
);
715 /* Look for sin, cos and cexpi calls with the same argument NAME and
716 create a single call to cexpi CSEing the result in this case.
717 We first walk over all immediate uses of the argument collecting
718 statements that we can CSE in a vector and in a second pass replace
719 the statement rhs with a REALPART or IMAGPART expression on the
720 result of the cexpi call we insert before the use statement that
721 dominates all other candidates. */
724 execute_cse_sincos_1 (tree name
)
726 gimple_stmt_iterator gsi
;
727 imm_use_iterator use_iter
;
728 tree fndecl
, res
, type
;
729 gimple def_stmt
, use_stmt
, stmt
;
730 int seen_cos
= 0, seen_sin
= 0, seen_cexpi
= 0;
731 vec
<gimple
> stmts
= vNULL
;
732 basic_block top_bb
= NULL
;
734 bool cfg_changed
= false;
736 type
= TREE_TYPE (name
);
737 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, name
)
739 if (gimple_code (use_stmt
) != GIMPLE_CALL
740 || !gimple_call_lhs (use_stmt
)
741 || !(fndecl
= gimple_call_fndecl (use_stmt
))
742 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
745 switch (DECL_FUNCTION_CODE (fndecl
))
747 CASE_FLT_FN (BUILT_IN_COS
):
748 seen_cos
|= maybe_record_sincos (&stmts
, &top_bb
, use_stmt
) ? 1 : 0;
751 CASE_FLT_FN (BUILT_IN_SIN
):
752 seen_sin
|= maybe_record_sincos (&stmts
, &top_bb
, use_stmt
) ? 1 : 0;
755 CASE_FLT_FN (BUILT_IN_CEXPI
):
756 seen_cexpi
|= maybe_record_sincos (&stmts
, &top_bb
, use_stmt
) ? 1 : 0;
763 if (seen_cos
+ seen_sin
+ seen_cexpi
<= 1)
769 /* Simply insert cexpi at the beginning of top_bb but not earlier than
770 the name def statement. */
771 fndecl
= mathfn_built_in (type
, BUILT_IN_CEXPI
);
774 stmt
= gimple_build_call (fndecl
, 1, name
);
775 res
= make_temp_ssa_name (TREE_TYPE (TREE_TYPE (fndecl
)), stmt
, "sincostmp");
776 gimple_call_set_lhs (stmt
, res
);
778 def_stmt
= SSA_NAME_DEF_STMT (name
);
779 if (!SSA_NAME_IS_DEFAULT_DEF (name
)
780 && gimple_code (def_stmt
) != GIMPLE_PHI
781 && gimple_bb (def_stmt
) == top_bb
)
783 gsi
= gsi_for_stmt (def_stmt
);
784 gsi_insert_after (&gsi
, stmt
, GSI_SAME_STMT
);
788 gsi
= gsi_after_labels (top_bb
);
789 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
791 sincos_stats
.inserted
++;
793 /* And adjust the recorded old call sites. */
794 for (i
= 0; stmts
.iterate (i
, &use_stmt
); ++i
)
797 fndecl
= gimple_call_fndecl (use_stmt
);
799 switch (DECL_FUNCTION_CODE (fndecl
))
801 CASE_FLT_FN (BUILT_IN_COS
):
802 rhs
= fold_build1 (REALPART_EXPR
, type
, res
);
805 CASE_FLT_FN (BUILT_IN_SIN
):
806 rhs
= fold_build1 (IMAGPART_EXPR
, type
, res
);
809 CASE_FLT_FN (BUILT_IN_CEXPI
):
817 /* Replace call with a copy. */
818 stmt
= gimple_build_assign (gimple_call_lhs (use_stmt
), rhs
);
820 gsi
= gsi_for_stmt (use_stmt
);
821 gsi_replace (&gsi
, stmt
, true);
822 if (gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
831 /* To evaluate powi(x,n), the floating point value x raised to the
832 constant integer exponent n, we use a hybrid algorithm that
833 combines the "window method" with look-up tables. For an
834 introduction to exponentiation algorithms and "addition chains",
835 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
836 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
837 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
838 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
840 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
841 multiplications to inline before calling the system library's pow
842 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
843 so this default never requires calling pow, powf or powl. */
845 #ifndef POWI_MAX_MULTS
846 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
849 /* The size of the "optimal power tree" lookup table. All
850 exponents less than this value are simply looked up in the
851 powi_table below. This threshold is also used to size the
852 cache of pseudo registers that hold intermediate results. */
853 #define POWI_TABLE_SIZE 256
855 /* The size, in bits of the window, used in the "window method"
856 exponentiation algorithm. This is equivalent to a radix of
857 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
858 #define POWI_WINDOW_SIZE 3
860 /* The following table is an efficient representation of an
861 "optimal power tree". For each value, i, the corresponding
862 value, j, in the table states than an optimal evaluation
863 sequence for calculating pow(x,i) can be found by evaluating
864 pow(x,j)*pow(x,i-j). An optimal power tree for the first
865 100 integers is given in Knuth's "Seminumerical algorithms". */
867 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
869 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
870 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
871 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
872 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
873 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
874 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
875 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
876 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
877 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
878 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
879 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
880 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
881 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
882 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
883 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
884 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
885 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
886 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
887 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
888 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
889 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
890 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
891 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
892 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
893 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
894 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
895 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
896 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
897 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
898 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
899 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
900 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
904 /* Return the number of multiplications required to calculate
905 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
906 subroutine of powi_cost. CACHE is an array indicating
907 which exponents have already been calculated. */
910 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
912 /* If we've already calculated this exponent, then this evaluation
913 doesn't require any additional multiplications. */
918 return powi_lookup_cost (n
- powi_table
[n
], cache
)
919 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
922 /* Return the number of multiplications required to calculate
923 powi(x,n) for an arbitrary x, given the exponent N. This
924 function needs to be kept in sync with powi_as_mults below. */
927 powi_cost (HOST_WIDE_INT n
)
929 bool cache
[POWI_TABLE_SIZE
];
930 unsigned HOST_WIDE_INT digit
;
931 unsigned HOST_WIDE_INT val
;
937 /* Ignore the reciprocal when calculating the cost. */
938 val
= (n
< 0) ? -n
: n
;
940 /* Initialize the exponent cache. */
941 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
946 while (val
>= POWI_TABLE_SIZE
)
950 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
951 result
+= powi_lookup_cost (digit
, cache
)
952 + POWI_WINDOW_SIZE
+ 1;
953 val
>>= POWI_WINDOW_SIZE
;
962 return result
+ powi_lookup_cost (val
, cache
);
965 /* Recursive subroutine of powi_as_mults. This function takes the
966 array, CACHE, of already calculated exponents and an exponent N and
967 returns a tree that corresponds to CACHE[1]**N, with type TYPE. */
970 powi_as_mults_1 (gimple_stmt_iterator
*gsi
, location_t loc
, tree type
,
971 HOST_WIDE_INT n
, tree
*cache
)
973 tree op0
, op1
, ssa_target
;
974 unsigned HOST_WIDE_INT digit
;
977 if (n
< POWI_TABLE_SIZE
&& cache
[n
])
980 ssa_target
= make_temp_ssa_name (type
, NULL
, "powmult");
982 if (n
< POWI_TABLE_SIZE
)
984 cache
[n
] = ssa_target
;
985 op0
= powi_as_mults_1 (gsi
, loc
, type
, n
- powi_table
[n
], cache
);
986 op1
= powi_as_mults_1 (gsi
, loc
, type
, powi_table
[n
], cache
);
990 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
991 op0
= powi_as_mults_1 (gsi
, loc
, type
, n
- digit
, cache
);
992 op1
= powi_as_mults_1 (gsi
, loc
, type
, digit
, cache
);
996 op0
= powi_as_mults_1 (gsi
, loc
, type
, n
>> 1, cache
);
1000 mult_stmt
= gimple_build_assign_with_ops (MULT_EXPR
, ssa_target
, op0
, op1
);
1001 gimple_set_location (mult_stmt
, loc
);
1002 gsi_insert_before (gsi
, mult_stmt
, GSI_SAME_STMT
);
1007 /* Convert ARG0**N to a tree of multiplications of ARG0 with itself.
1008 This function needs to be kept in sync with powi_cost above. */
1011 powi_as_mults (gimple_stmt_iterator
*gsi
, location_t loc
,
1012 tree arg0
, HOST_WIDE_INT n
)
1014 tree cache
[POWI_TABLE_SIZE
], result
, type
= TREE_TYPE (arg0
);
1019 return build_real (type
, dconst1
);
1021 memset (cache
, 0, sizeof (cache
));
1024 result
= powi_as_mults_1 (gsi
, loc
, type
, (n
< 0) ? -n
: n
, cache
);
1028 /* If the original exponent was negative, reciprocate the result. */
1029 target
= make_temp_ssa_name (type
, NULL
, "powmult");
1030 div_stmt
= gimple_build_assign_with_ops (RDIV_EXPR
, target
,
1031 build_real (type
, dconst1
),
1033 gimple_set_location (div_stmt
, loc
);
1034 gsi_insert_before (gsi
, div_stmt
, GSI_SAME_STMT
);
1039 /* ARG0 and N are the two arguments to a powi builtin in GSI with
1040 location info LOC. If the arguments are appropriate, create an
1041 equivalent sequence of statements prior to GSI using an optimal
1042 number of multiplications, and return an expession holding the
1046 gimple_expand_builtin_powi (gimple_stmt_iterator
*gsi
, location_t loc
,
1047 tree arg0
, HOST_WIDE_INT n
)
1049 /* Avoid largest negative number. */
1051 && ((n
>= -1 && n
<= 2)
1052 || (optimize_function_for_speed_p (cfun
)
1053 && powi_cost (n
) <= POWI_MAX_MULTS
)))
1054 return powi_as_mults (gsi
, loc
, arg0
, n
);
1059 /* Build a gimple call statement that calls FN with argument ARG.
1060 Set the lhs of the call statement to a fresh SSA name. Insert the
1061 statement prior to GSI's current position, and return the fresh
1065 build_and_insert_call (gimple_stmt_iterator
*gsi
, location_t loc
,
1071 call_stmt
= gimple_build_call (fn
, 1, arg
);
1072 ssa_target
= make_temp_ssa_name (TREE_TYPE (arg
), NULL
, "powroot");
1073 gimple_set_lhs (call_stmt
, ssa_target
);
1074 gimple_set_location (call_stmt
, loc
);
1075 gsi_insert_before (gsi
, call_stmt
, GSI_SAME_STMT
);
1080 /* Build a gimple binary operation with the given CODE and arguments
1081 ARG0, ARG1, assigning the result to a new SSA name for variable
1082 TARGET. Insert the statement prior to GSI's current position, and
1083 return the fresh SSA name.*/
1086 build_and_insert_binop (gimple_stmt_iterator
*gsi
, location_t loc
,
1087 const char *name
, enum tree_code code
,
1088 tree arg0
, tree arg1
)
1090 tree result
= make_temp_ssa_name (TREE_TYPE (arg0
), NULL
, name
);
1091 gimple stmt
= gimple_build_assign_with_ops (code
, result
, arg0
, arg1
);
1092 gimple_set_location (stmt
, loc
);
1093 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1097 /* Build a gimple reference operation with the given CODE and argument
1098 ARG, assigning the result to a new SSA name of TYPE with NAME.
1099 Insert the statement prior to GSI's current position, and return
1100 the fresh SSA name. */
1103 build_and_insert_ref (gimple_stmt_iterator
*gsi
, location_t loc
, tree type
,
1104 const char *name
, enum tree_code code
, tree arg0
)
1106 tree result
= make_temp_ssa_name (type
, NULL
, name
);
1107 gimple stmt
= gimple_build_assign (result
, build1 (code
, type
, arg0
));
1108 gimple_set_location (stmt
, loc
);
1109 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1113 /* Build a gimple assignment to cast VAL to TYPE. Insert the statement
1114 prior to GSI's current position, and return the fresh SSA name. */
1117 build_and_insert_cast (gimple_stmt_iterator
*gsi
, location_t loc
,
1118 tree type
, tree val
)
1120 tree result
= make_ssa_name (type
, NULL
);
1121 gimple stmt
= gimple_build_assign_with_ops (NOP_EXPR
, result
, val
, NULL_TREE
);
1122 gimple_set_location (stmt
, loc
);
1123 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1127 /* ARG0 and ARG1 are the two arguments to a pow builtin call in GSI
1128 with location info LOC. If possible, create an equivalent and
1129 less expensive sequence of statements prior to GSI, and return an
1130 expession holding the result. */
1133 gimple_expand_builtin_pow (gimple_stmt_iterator
*gsi
, location_t loc
,
1134 tree arg0
, tree arg1
)
1136 REAL_VALUE_TYPE c
, cint
, dconst1_4
, dconst3_4
, dconst1_3
, dconst1_6
;
1137 REAL_VALUE_TYPE c2
, dconst3
;
1139 tree type
, sqrtfn
, cbrtfn
, sqrt_arg0
, sqrt_sqrt
, result
, cbrt_x
, powi_cbrt_x
;
1140 enum machine_mode mode
;
1141 bool hw_sqrt_exists
, c_is_int
, c2_is_int
;
1143 /* If the exponent isn't a constant, there's nothing of interest
1145 if (TREE_CODE (arg1
) != REAL_CST
)
1148 /* If the exponent is equivalent to an integer, expand to an optimal
1149 multiplication sequence when profitable. */
1150 c
= TREE_REAL_CST (arg1
);
1151 n
= real_to_integer (&c
);
1152 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
1153 c_is_int
= real_identical (&c
, &cint
);
1156 && ((n
>= -1 && n
<= 2)
1157 || (flag_unsafe_math_optimizations
1158 && optimize_bb_for_speed_p (gsi_bb (*gsi
))
1159 && powi_cost (n
) <= POWI_MAX_MULTS
)))
1160 return gimple_expand_builtin_powi (gsi
, loc
, arg0
, n
);
1162 /* Attempt various optimizations using sqrt and cbrt. */
1163 type
= TREE_TYPE (arg0
);
1164 mode
= TYPE_MODE (type
);
1165 sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
1167 /* Optimize pow(x,0.5) = sqrt(x). This replacement is always safe
1168 unless signed zeros must be maintained. pow(-0,0.5) = +0, while
1171 && REAL_VALUES_EQUAL (c
, dconsthalf
)
1172 && !HONOR_SIGNED_ZEROS (mode
))
1173 return build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1175 /* Optimize pow(x,0.25) = sqrt(sqrt(x)). Assume on most machines that
1176 a builtin sqrt instruction is smaller than a call to pow with 0.25,
1177 so do this optimization even if -Os. Don't do this optimization
1178 if we don't have a hardware sqrt insn. */
1179 dconst1_4
= dconst1
;
1180 SET_REAL_EXP (&dconst1_4
, REAL_EXP (&dconst1_4
) - 2);
1181 hw_sqrt_exists
= optab_handler (sqrt_optab
, mode
) != CODE_FOR_nothing
;
1183 if (flag_unsafe_math_optimizations
1185 && REAL_VALUES_EQUAL (c
, dconst1_4
)
1189 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1192 return build_and_insert_call (gsi
, loc
, sqrtfn
, sqrt_arg0
);
1195 /* Optimize pow(x,0.75) = sqrt(x) * sqrt(sqrt(x)) unless we are
1196 optimizing for space. Don't do this optimization if we don't have
1197 a hardware sqrt insn. */
1198 real_from_integer (&dconst3_4
, VOIDmode
, 3, 0, 0);
1199 SET_REAL_EXP (&dconst3_4
, REAL_EXP (&dconst3_4
) - 2);
1201 if (flag_unsafe_math_optimizations
1203 && optimize_function_for_speed_p (cfun
)
1204 && REAL_VALUES_EQUAL (c
, dconst3_4
)
1208 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1211 sqrt_sqrt
= build_and_insert_call (gsi
, loc
, sqrtfn
, sqrt_arg0
);
1213 /* sqrt(x) * sqrt(sqrt(x)) */
1214 return build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1215 sqrt_arg0
, sqrt_sqrt
);
1218 /* Optimize pow(x,1./3.) = cbrt(x). This requires unsafe math
1219 optimizations since 1./3. is not exactly representable. If x
1220 is negative and finite, the correct value of pow(x,1./3.) is
1221 a NaN with the "invalid" exception raised, because the value
1222 of 1./3. actually has an even denominator. The correct value
1223 of cbrt(x) is a negative real value. */
1224 cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
1225 dconst1_3
= real_value_truncate (mode
, dconst_third ());
1227 if (flag_unsafe_math_optimizations
1229 && (gimple_val_nonnegative_real_p (arg0
) || !HONOR_NANS (mode
))
1230 && REAL_VALUES_EQUAL (c
, dconst1_3
))
1231 return build_and_insert_call (gsi
, loc
, cbrtfn
, arg0
);
1233 /* Optimize pow(x,1./6.) = cbrt(sqrt(x)). Don't do this optimization
1234 if we don't have a hardware sqrt insn. */
1235 dconst1_6
= dconst1_3
;
1236 SET_REAL_EXP (&dconst1_6
, REAL_EXP (&dconst1_6
) - 1);
1238 if (flag_unsafe_math_optimizations
1241 && (gimple_val_nonnegative_real_p (arg0
) || !HONOR_NANS (mode
))
1242 && optimize_function_for_speed_p (cfun
)
1244 && REAL_VALUES_EQUAL (c
, dconst1_6
))
1247 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1250 return build_and_insert_call (gsi
, loc
, cbrtfn
, sqrt_arg0
);
1253 /* Optimize pow(x,c), where n = 2c for some nonzero integer n
1254 and c not an integer, into
1256 sqrt(x) * powi(x, n/2), n > 0;
1257 1.0 / (sqrt(x) * powi(x, abs(n/2))), n < 0.
1259 Do not calculate the powi factor when n/2 = 0. */
1260 real_arithmetic (&c2
, MULT_EXPR
, &c
, &dconst2
);
1261 n
= real_to_integer (&c2
);
1262 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
1263 c2_is_int
= real_identical (&c2
, &cint
);
1265 if (flag_unsafe_math_optimizations
1269 && optimize_function_for_speed_p (cfun
))
1271 tree powi_x_ndiv2
= NULL_TREE
;
1273 /* Attempt to fold powi(arg0, abs(n/2)) into multiplies. If not
1274 possible or profitable, give up. Skip the degenerate case when
1275 n is 1 or -1, where the result is always 1. */
1276 if (absu_hwi (n
) != 1)
1278 powi_x_ndiv2
= gimple_expand_builtin_powi (gsi
, loc
, arg0
,
1284 /* Calculate sqrt(x). When n is not 1 or -1, multiply it by the
1285 result of the optimal multiply sequence just calculated. */
1286 sqrt_arg0
= build_and_insert_call (gsi
, loc
, sqrtfn
, arg0
);
1288 if (absu_hwi (n
) == 1)
1291 result
= build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1292 sqrt_arg0
, powi_x_ndiv2
);
1294 /* If n is negative, reciprocate the result. */
1296 result
= build_and_insert_binop (gsi
, loc
, "powroot", RDIV_EXPR
,
1297 build_real (type
, dconst1
), result
);
1301 /* Optimize pow(x,c), where 3c = n for some nonzero integer n, into
1303 powi(x, n/3) * powi(cbrt(x), n%3), n > 0;
1304 1.0 / (powi(x, abs(n)/3) * powi(cbrt(x), abs(n)%3)), n < 0.
1306 Do not calculate the first factor when n/3 = 0. As cbrt(x) is
1307 different from pow(x, 1./3.) due to rounding and behavior with
1308 negative x, we need to constrain this transformation to unsafe
1309 math and positive x or finite math. */
1310 real_from_integer (&dconst3
, VOIDmode
, 3, 0, 0);
1311 real_arithmetic (&c2
, MULT_EXPR
, &c
, &dconst3
);
1312 real_round (&c2
, mode
, &c2
);
1313 n
= real_to_integer (&c2
);
1314 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
1315 real_arithmetic (&c2
, RDIV_EXPR
, &cint
, &dconst3
);
1316 real_convert (&c2
, mode
, &c2
);
1318 if (flag_unsafe_math_optimizations
1320 && (gimple_val_nonnegative_real_p (arg0
) || !HONOR_NANS (mode
))
1321 && real_identical (&c2
, &c
)
1323 && optimize_function_for_speed_p (cfun
)
1324 && powi_cost (n
/ 3) <= POWI_MAX_MULTS
)
1326 tree powi_x_ndiv3
= NULL_TREE
;
1328 /* Attempt to fold powi(arg0, abs(n/3)) into multiplies. If not
1329 possible or profitable, give up. Skip the degenerate case when
1330 abs(n) < 3, where the result is always 1. */
1331 if (absu_hwi (n
) >= 3)
1333 powi_x_ndiv3
= gimple_expand_builtin_powi (gsi
, loc
, arg0
,
1339 /* Calculate powi(cbrt(x), n%3). Don't use gimple_expand_builtin_powi
1340 as that creates an unnecessary variable. Instead, just produce
1341 either cbrt(x) or cbrt(x) * cbrt(x). */
1342 cbrt_x
= build_and_insert_call (gsi
, loc
, cbrtfn
, arg0
);
1344 if (absu_hwi (n
) % 3 == 1)
1345 powi_cbrt_x
= cbrt_x
;
1347 powi_cbrt_x
= build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1350 /* Multiply the two subexpressions, unless powi(x,abs(n)/3) = 1. */
1351 if (absu_hwi (n
) < 3)
1352 result
= powi_cbrt_x
;
1354 result
= build_and_insert_binop (gsi
, loc
, "powroot", MULT_EXPR
,
1355 powi_x_ndiv3
, powi_cbrt_x
);
1357 /* If n is negative, reciprocate the result. */
1359 result
= build_and_insert_binop (gsi
, loc
, "powroot", RDIV_EXPR
,
1360 build_real (type
, dconst1
), result
);
1365 /* No optimizations succeeded. */
1369 /* ARG is the argument to a cabs builtin call in GSI with location info
1370 LOC. Create a sequence of statements prior to GSI that calculates
1371 sqrt(R*R + I*I), where R and I are the real and imaginary components
1372 of ARG, respectively. Return an expression holding the result. */
1375 gimple_expand_builtin_cabs (gimple_stmt_iterator
*gsi
, location_t loc
, tree arg
)
1377 tree real_part
, imag_part
, addend1
, addend2
, sum
, result
;
1378 tree type
= TREE_TYPE (TREE_TYPE (arg
));
1379 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
1380 enum machine_mode mode
= TYPE_MODE (type
);
1382 if (!flag_unsafe_math_optimizations
1383 || !optimize_bb_for_speed_p (gimple_bb (gsi_stmt (*gsi
)))
1385 || optab_handler (sqrt_optab
, mode
) == CODE_FOR_nothing
)
1388 real_part
= build_and_insert_ref (gsi
, loc
, type
, "cabs",
1389 REALPART_EXPR
, arg
);
1390 addend1
= build_and_insert_binop (gsi
, loc
, "cabs", MULT_EXPR
,
1391 real_part
, real_part
);
1392 imag_part
= build_and_insert_ref (gsi
, loc
, type
, "cabs",
1393 IMAGPART_EXPR
, arg
);
1394 addend2
= build_and_insert_binop (gsi
, loc
, "cabs", MULT_EXPR
,
1395 imag_part
, imag_part
);
1396 sum
= build_and_insert_binop (gsi
, loc
, "cabs", PLUS_EXPR
, addend1
, addend2
);
1397 result
= build_and_insert_call (gsi
, loc
, sqrtfn
, sum
);
1402 /* Go through all calls to sin, cos and cexpi and call execute_cse_sincos_1
1403 on the SSA_NAME argument of each of them. Also expand powi(x,n) into
1404 an optimal number of multiplies, when n is a constant. */
1407 execute_cse_sincos (void)
1410 bool cfg_changed
= false;
1412 calculate_dominance_info (CDI_DOMINATORS
);
1413 memset (&sincos_stats
, 0, sizeof (sincos_stats
));
1415 FOR_EACH_BB_FN (bb
, cfun
)
1417 gimple_stmt_iterator gsi
;
1418 bool cleanup_eh
= false;
1420 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1422 gimple stmt
= gsi_stmt (gsi
);
1425 /* Only the last stmt in a bb could throw, no need to call
1426 gimple_purge_dead_eh_edges if we change something in the middle
1427 of a basic block. */
1430 if (is_gimple_call (stmt
)
1431 && gimple_call_lhs (stmt
)
1432 && (fndecl
= gimple_call_fndecl (stmt
))
1433 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1435 tree arg
, arg0
, arg1
, result
;
1439 switch (DECL_FUNCTION_CODE (fndecl
))
1441 CASE_FLT_FN (BUILT_IN_COS
):
1442 CASE_FLT_FN (BUILT_IN_SIN
):
1443 CASE_FLT_FN (BUILT_IN_CEXPI
):
1444 /* Make sure we have either sincos or cexp. */
1445 if (!targetm
.libc_has_function (function_c99_math_complex
)
1446 && !targetm
.libc_has_function (function_sincos
))
1449 arg
= gimple_call_arg (stmt
, 0);
1450 if (TREE_CODE (arg
) == SSA_NAME
)
1451 cfg_changed
|= execute_cse_sincos_1 (arg
);
1454 CASE_FLT_FN (BUILT_IN_POW
):
1455 arg0
= gimple_call_arg (stmt
, 0);
1456 arg1
= gimple_call_arg (stmt
, 1);
1458 loc
= gimple_location (stmt
);
1459 result
= gimple_expand_builtin_pow (&gsi
, loc
, arg0
, arg1
);
1463 tree lhs
= gimple_get_lhs (stmt
);
1464 gimple new_stmt
= gimple_build_assign (lhs
, result
);
1465 gimple_set_location (new_stmt
, loc
);
1466 unlink_stmt_vdef (stmt
);
1467 gsi_replace (&gsi
, new_stmt
, true);
1469 if (gimple_vdef (stmt
))
1470 release_ssa_name (gimple_vdef (stmt
));
1474 CASE_FLT_FN (BUILT_IN_POWI
):
1475 arg0
= gimple_call_arg (stmt
, 0);
1476 arg1
= gimple_call_arg (stmt
, 1);
1477 loc
= gimple_location (stmt
);
1479 if (real_minus_onep (arg0
))
1481 tree t0
, t1
, cond
, one
, minus_one
;
1484 t0
= TREE_TYPE (arg0
);
1485 t1
= TREE_TYPE (arg1
);
1486 one
= build_real (t0
, dconst1
);
1487 minus_one
= build_real (t0
, dconstm1
);
1489 cond
= make_temp_ssa_name (t1
, NULL
, "powi_cond");
1490 stmt
= gimple_build_assign_with_ops (BIT_AND_EXPR
, cond
,
1494 gimple_set_location (stmt
, loc
);
1495 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
1497 result
= make_temp_ssa_name (t0
, NULL
, "powi");
1498 stmt
= gimple_build_assign_with_ops (COND_EXPR
, result
,
1501 gimple_set_location (stmt
, loc
);
1502 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
1506 if (!tree_fits_shwi_p (arg1
))
1509 n
= tree_to_shwi (arg1
);
1510 result
= gimple_expand_builtin_powi (&gsi
, loc
, arg0
, n
);
1515 tree lhs
= gimple_get_lhs (stmt
);
1516 gimple new_stmt
= gimple_build_assign (lhs
, result
);
1517 gimple_set_location (new_stmt
, loc
);
1518 unlink_stmt_vdef (stmt
);
1519 gsi_replace (&gsi
, new_stmt
, true);
1521 if (gimple_vdef (stmt
))
1522 release_ssa_name (gimple_vdef (stmt
));
1526 CASE_FLT_FN (BUILT_IN_CABS
):
1527 arg0
= gimple_call_arg (stmt
, 0);
1528 loc
= gimple_location (stmt
);
1529 result
= gimple_expand_builtin_cabs (&gsi
, loc
, arg0
);
1533 tree lhs
= gimple_get_lhs (stmt
);
1534 gimple new_stmt
= gimple_build_assign (lhs
, result
);
1535 gimple_set_location (new_stmt
, loc
);
1536 unlink_stmt_vdef (stmt
);
1537 gsi_replace (&gsi
, new_stmt
, true);
1539 if (gimple_vdef (stmt
))
1540 release_ssa_name (gimple_vdef (stmt
));
1549 cfg_changed
|= gimple_purge_dead_eh_edges (bb
);
1552 statistics_counter_event (cfun
, "sincos statements inserted",
1553 sincos_stats
.inserted
);
1555 free_dominance_info (CDI_DOMINATORS
);
1556 return cfg_changed
? TODO_cleanup_cfg
: 0;
1561 const pass_data pass_data_cse_sincos
=
1563 GIMPLE_PASS
, /* type */
1564 "sincos", /* name */
1565 OPTGROUP_NONE
, /* optinfo_flags */
1566 true, /* has_execute */
1567 TV_NONE
, /* tv_id */
1568 PROP_ssa
, /* properties_required */
1569 0, /* properties_provided */
1570 0, /* properties_destroyed */
1571 0, /* todo_flags_start */
1572 ( TODO_update_ssa
| TODO_verify_ssa
1573 | TODO_verify_stmts
), /* todo_flags_finish */
1576 class pass_cse_sincos
: public gimple_opt_pass
1579 pass_cse_sincos (gcc::context
*ctxt
)
1580 : gimple_opt_pass (pass_data_cse_sincos
, ctxt
)
1583 /* opt_pass methods: */
1584 virtual bool gate (function
*)
1586 /* We no longer require either sincos or cexp, since powi expansion
1587 piggybacks on this pass. */
1591 unsigned int execute () { return execute_cse_sincos (); }
1593 }; // class pass_cse_sincos
1598 make_pass_cse_sincos (gcc::context
*ctxt
)
1600 return new pass_cse_sincos (ctxt
);
1603 /* A symbolic number is used to detect byte permutation and selection
1604 patterns. Therefore the field N contains an artificial number
1605 consisting of byte size markers:
1607 0 - byte has the value 0
1608 1..size - byte contains the content of the byte
1609 number indexed with that value minus one */
1611 struct symbolic_number
{
1612 unsigned HOST_WIDEST_INT n
;
1616 /* Perform a SHIFT or ROTATE operation by COUNT bits on symbolic
1617 number N. Return false if the requested operation is not permitted
1618 on a symbolic number. */
1621 do_shift_rotate (enum tree_code code
,
1622 struct symbolic_number
*n
,
1628 /* Zero out the extra bits of N in order to avoid them being shifted
1629 into the significant bits. */
1630 if (n
->size
< (int)sizeof (HOST_WIDEST_INT
))
1631 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 << (n
->size
* BITS_PER_UNIT
)) - 1;
1642 n
->n
= (n
->n
<< count
) | (n
->n
>> ((n
->size
* BITS_PER_UNIT
) - count
));
1645 n
->n
= (n
->n
>> count
) | (n
->n
<< ((n
->size
* BITS_PER_UNIT
) - count
));
1650 /* Zero unused bits for size. */
1651 if (n
->size
< (int)sizeof (HOST_WIDEST_INT
))
1652 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 << (n
->size
* BITS_PER_UNIT
)) - 1;
1656 /* Perform sanity checking for the symbolic number N and the gimple
1660 verify_symbolic_number_p (struct symbolic_number
*n
, gimple stmt
)
1664 lhs_type
= gimple_expr_type (stmt
);
1666 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
1669 if (TYPE_PRECISION (lhs_type
) != n
->size
* BITS_PER_UNIT
)
1675 /* find_bswap_1 invokes itself recursively with N and tries to perform
1676 the operation given by the rhs of STMT on the result. If the
1677 operation could successfully be executed the function returns the
1678 tree expression of the source operand and NULL otherwise. */
1681 find_bswap_1 (gimple stmt
, struct symbolic_number
*n
, int limit
)
1683 enum tree_code code
;
1684 tree rhs1
, rhs2
= NULL
;
1685 gimple rhs1_stmt
, rhs2_stmt
;
1687 enum gimple_rhs_class rhs_class
;
1689 if (!limit
|| !is_gimple_assign (stmt
))
1692 rhs1
= gimple_assign_rhs1 (stmt
);
1694 if (TREE_CODE (rhs1
) != SSA_NAME
)
1697 code
= gimple_assign_rhs_code (stmt
);
1698 rhs_class
= gimple_assign_rhs_class (stmt
);
1699 rhs1_stmt
= SSA_NAME_DEF_STMT (rhs1
);
1701 if (rhs_class
== GIMPLE_BINARY_RHS
)
1702 rhs2
= gimple_assign_rhs2 (stmt
);
1704 /* Handle unary rhs and binary rhs with integer constants as second
1707 if (rhs_class
== GIMPLE_UNARY_RHS
1708 || (rhs_class
== GIMPLE_BINARY_RHS
1709 && TREE_CODE (rhs2
) == INTEGER_CST
))
1711 if (code
!= BIT_AND_EXPR
1712 && code
!= LSHIFT_EXPR
1713 && code
!= RSHIFT_EXPR
1714 && code
!= LROTATE_EXPR
1715 && code
!= RROTATE_EXPR
1717 && code
!= CONVERT_EXPR
)
1720 source_expr1
= find_bswap_1 (rhs1_stmt
, n
, limit
- 1);
1722 /* If find_bswap_1 returned NULL STMT is a leaf node and we have
1723 to initialize the symbolic number. */
1726 /* Set up the symbolic number N by setting each byte to a
1727 value between 1 and the byte size of rhs1. The highest
1728 order byte is set to n->size and the lowest order
1730 n
->size
= TYPE_PRECISION (TREE_TYPE (rhs1
));
1731 if (n
->size
% BITS_PER_UNIT
!= 0)
1733 n
->size
/= BITS_PER_UNIT
;
1734 n
->n
= (sizeof (HOST_WIDEST_INT
) < 8 ? 0 :
1735 (unsigned HOST_WIDEST_INT
)0x08070605 << 32 | 0x04030201);
1737 if (n
->size
< (int)sizeof (HOST_WIDEST_INT
))
1738 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 <<
1739 (n
->size
* BITS_PER_UNIT
)) - 1;
1741 source_expr1
= rhs1
;
1749 unsigned HOST_WIDEST_INT val
= widest_int_cst_value (rhs2
);
1750 unsigned HOST_WIDEST_INT tmp
= val
;
1752 /* Only constants masking full bytes are allowed. */
1753 for (i
= 0; i
< n
->size
; i
++, tmp
>>= BITS_PER_UNIT
)
1754 if ((tmp
& 0xff) != 0 && (tmp
& 0xff) != 0xff)
1764 if (!do_shift_rotate (code
, n
, (int)TREE_INT_CST_LOW (rhs2
)))
1771 type_size
= TYPE_PRECISION (gimple_expr_type (stmt
));
1772 if (type_size
% BITS_PER_UNIT
!= 0)
1775 if (type_size
/ BITS_PER_UNIT
< (int)(sizeof (HOST_WIDEST_INT
)))
1777 /* If STMT casts to a smaller type mask out the bits not
1778 belonging to the target type. */
1779 n
->n
&= ((unsigned HOST_WIDEST_INT
)1 << type_size
) - 1;
1781 n
->size
= type_size
/ BITS_PER_UNIT
;
1787 return verify_symbolic_number_p (n
, stmt
) ? source_expr1
: NULL
;
1790 /* Handle binary rhs. */
1792 if (rhs_class
== GIMPLE_BINARY_RHS
)
1795 struct symbolic_number n1
, n2
;
1796 unsigned HOST_WIDEST_INT mask
;
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
)
1822 for (i
= 0, mask
= 0xff; i
< n
->size
; i
++, mask
<<= BITS_PER_UNIT
)
1824 unsigned HOST_WIDEST_INT masked1
, masked2
;
1826 masked1
= n1
.n
& mask
;
1827 masked2
= n2
.n
& mask
;
1828 if (masked1
&& masked2
&& masked1
!= masked2
)
1833 if (!verify_symbolic_number_p (n
, stmt
))
1840 return source_expr1
;
1845 /* Check if STMT completes a bswap implementation consisting of ORs,
1846 SHIFTs and ANDs. Return the source tree expression on which the
1847 byte swap is performed and NULL if no bswap was found. */
1850 find_bswap (gimple stmt
)
1852 /* The number which the find_bswap result should match in order to
1853 have a full byte swap. The number is shifted to the left according
1854 to the size of the symbolic number before using it. */
1855 unsigned HOST_WIDEST_INT cmp
=
1856 sizeof (HOST_WIDEST_INT
) < 8 ? 0 :
1857 (unsigned HOST_WIDEST_INT
)0x01020304 << 32 | 0x05060708;
1859 struct symbolic_number n
;
1863 /* The last parameter determines the depth search limit. It usually
1864 correlates directly to the number of bytes to be touched. We
1865 increase that number by three here in order to also
1866 cover signed -> unsigned converions of the src operand as can be seen
1867 in libgcc, and for initial shift/and operation of the src operand. */
1868 limit
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (gimple_expr_type (stmt
)));
1869 limit
+= 1 + (int) ceil_log2 ((unsigned HOST_WIDE_INT
) limit
);
1870 source_expr
= find_bswap_1 (stmt
, &n
, limit
);
1875 /* Zero out the extra bits of N and CMP. */
1876 if (n
.size
< (int)sizeof (HOST_WIDEST_INT
))
1878 unsigned HOST_WIDEST_INT mask
=
1879 ((unsigned HOST_WIDEST_INT
)1 << (n
.size
* BITS_PER_UNIT
)) - 1;
1882 cmp
>>= (sizeof (HOST_WIDEST_INT
) - n
.size
) * BITS_PER_UNIT
;
1885 /* A complete byte swap should make the symbolic number to start
1886 with the largest digit in the highest order byte. */
1893 /* Find manual byte swap implementations and turn them into a bswap
1894 builtin invokation. */
1897 execute_optimize_bswap (void)
1900 bool bswap16_p
, bswap32_p
, bswap64_p
;
1901 bool changed
= false;
1902 tree bswap16_type
= NULL_TREE
, bswap32_type
= NULL_TREE
, bswap64_type
= NULL_TREE
;
1904 if (BITS_PER_UNIT
!= 8)
1907 if (sizeof (HOST_WIDEST_INT
) < 8)
1910 bswap16_p
= (builtin_decl_explicit_p (BUILT_IN_BSWAP16
)
1911 && optab_handler (bswap_optab
, HImode
) != CODE_FOR_nothing
);
1912 bswap32_p
= (builtin_decl_explicit_p (BUILT_IN_BSWAP32
)
1913 && optab_handler (bswap_optab
, SImode
) != CODE_FOR_nothing
);
1914 bswap64_p
= (builtin_decl_explicit_p (BUILT_IN_BSWAP64
)
1915 && (optab_handler (bswap_optab
, DImode
) != CODE_FOR_nothing
1916 || (bswap32_p
&& word_mode
== SImode
)));
1918 if (!bswap16_p
&& !bswap32_p
&& !bswap64_p
)
1921 /* Determine the argument type of the builtins. The code later on
1922 assumes that the return and argument type are the same. */
1925 tree fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP16
);
1926 bswap16_type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
1931 tree fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP32
);
1932 bswap32_type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
1937 tree fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP64
);
1938 bswap64_type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
1941 memset (&bswap_stats
, 0, sizeof (bswap_stats
));
1943 FOR_EACH_BB_FN (bb
, cfun
)
1945 gimple_stmt_iterator gsi
;
1947 /* We do a reverse scan for bswap patterns to make sure we get the
1948 widest match. As bswap pattern matching doesn't handle
1949 previously inserted smaller bswap replacements as sub-
1950 patterns, the wider variant wouldn't be detected. */
1951 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
1953 gimple stmt
= gsi_stmt (gsi
);
1954 tree bswap_src
, bswap_type
;
1956 tree fndecl
= NULL_TREE
;
1960 if (!is_gimple_assign (stmt
)
1961 || gimple_assign_rhs_code (stmt
) != BIT_IOR_EXPR
)
1964 type_size
= TYPE_PRECISION (gimple_expr_type (stmt
));
1971 fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP16
);
1972 bswap_type
= bswap16_type
;
1978 fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP32
);
1979 bswap_type
= bswap32_type
;
1985 fndecl
= builtin_decl_explicit (BUILT_IN_BSWAP64
);
1986 bswap_type
= bswap64_type
;
1996 bswap_src
= find_bswap (stmt
);
2002 if (type_size
== 16)
2003 bswap_stats
.found_16bit
++;
2004 else if (type_size
== 32)
2005 bswap_stats
.found_32bit
++;
2007 bswap_stats
.found_64bit
++;
2009 bswap_tmp
= bswap_src
;
2011 /* Convert the src expression if necessary. */
2012 if (!useless_type_conversion_p (TREE_TYPE (bswap_tmp
), bswap_type
))
2014 gimple convert_stmt
;
2015 bswap_tmp
= make_temp_ssa_name (bswap_type
, NULL
, "bswapsrc");
2016 convert_stmt
= gimple_build_assign_with_ops
2017 (NOP_EXPR
, bswap_tmp
, bswap_src
, NULL
);
2018 gsi_insert_before (&gsi
, convert_stmt
, GSI_SAME_STMT
);
2021 call
= gimple_build_call (fndecl
, 1, bswap_tmp
);
2023 bswap_tmp
= gimple_assign_lhs (stmt
);
2025 /* Convert the result if necessary. */
2026 if (!useless_type_conversion_p (TREE_TYPE (bswap_tmp
), bswap_type
))
2028 gimple convert_stmt
;
2029 bswap_tmp
= make_temp_ssa_name (bswap_type
, NULL
, "bswapdst");
2030 convert_stmt
= gimple_build_assign_with_ops
2031 (NOP_EXPR
, gimple_assign_lhs (stmt
), bswap_tmp
, NULL
);
2032 gsi_insert_after (&gsi
, convert_stmt
, GSI_SAME_STMT
);
2035 gimple_call_set_lhs (call
, bswap_tmp
);
2039 fprintf (dump_file
, "%d bit bswap implementation found at: ",
2041 print_gimple_stmt (dump_file
, stmt
, 0, 0);
2044 gsi_insert_after (&gsi
, call
, GSI_SAME_STMT
);
2045 gsi_remove (&gsi
, true);
2049 statistics_counter_event (cfun
, "16-bit bswap implementations found",
2050 bswap_stats
.found_16bit
);
2051 statistics_counter_event (cfun
, "32-bit bswap implementations found",
2052 bswap_stats
.found_32bit
);
2053 statistics_counter_event (cfun
, "64-bit bswap implementations found",
2054 bswap_stats
.found_64bit
);
2056 return (changed
? TODO_update_ssa
| TODO_verify_ssa
2057 | TODO_verify_stmts
: 0);
2062 const pass_data pass_data_optimize_bswap
=
2064 GIMPLE_PASS
, /* type */
2066 OPTGROUP_NONE
, /* optinfo_flags */
2067 true, /* has_execute */
2068 TV_NONE
, /* tv_id */
2069 PROP_ssa
, /* properties_required */
2070 0, /* properties_provided */
2071 0, /* properties_destroyed */
2072 0, /* todo_flags_start */
2073 0, /* todo_flags_finish */
2076 class pass_optimize_bswap
: public gimple_opt_pass
2079 pass_optimize_bswap (gcc::context
*ctxt
)
2080 : gimple_opt_pass (pass_data_optimize_bswap
, ctxt
)
2083 /* opt_pass methods: */
2084 virtual bool gate (function
*)
2086 return flag_expensive_optimizations
&& optimize
;
2089 unsigned int execute () { return execute_optimize_bswap (); }
2091 }; // class pass_optimize_bswap
2096 make_pass_optimize_bswap (gcc::context
*ctxt
)
2098 return new pass_optimize_bswap (ctxt
);
2101 /* Return true if stmt is a type conversion operation that can be stripped
2102 when used in a widening multiply operation. */
2104 widening_mult_conversion_strippable_p (tree result_type
, gimple stmt
)
2106 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
2108 if (TREE_CODE (result_type
) == INTEGER_TYPE
)
2113 if (!CONVERT_EXPR_CODE_P (rhs_code
))
2116 op_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
2118 /* If the type of OP has the same precision as the result, then
2119 we can strip this conversion. The multiply operation will be
2120 selected to create the correct extension as a by-product. */
2121 if (TYPE_PRECISION (result_type
) == TYPE_PRECISION (op_type
))
2124 /* We can also strip a conversion if it preserves the signed-ness of
2125 the operation and doesn't narrow the range. */
2126 inner_op_type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
2128 /* If the inner-most type is unsigned, then we can strip any
2129 intermediate widening operation. If it's signed, then the
2130 intermediate widening operation must also be signed. */
2131 if ((TYPE_UNSIGNED (inner_op_type
)
2132 || TYPE_UNSIGNED (op_type
) == TYPE_UNSIGNED (inner_op_type
))
2133 && TYPE_PRECISION (op_type
) > TYPE_PRECISION (inner_op_type
))
2139 return rhs_code
== FIXED_CONVERT_EXPR
;
2142 /* Return true if RHS is a suitable operand for a widening multiplication,
2143 assuming a target type of TYPE.
2144 There are two cases:
2146 - RHS makes some value at least twice as wide. Store that value
2147 in *NEW_RHS_OUT if so, and store its type in *TYPE_OUT.
2149 - RHS is an integer constant. Store that value in *NEW_RHS_OUT if so,
2150 but leave *TYPE_OUT untouched. */
2153 is_widening_mult_rhs_p (tree type
, tree rhs
, tree
*type_out
,
2159 if (TREE_CODE (rhs
) == SSA_NAME
)
2161 stmt
= SSA_NAME_DEF_STMT (rhs
);
2162 if (is_gimple_assign (stmt
))
2164 if (! widening_mult_conversion_strippable_p (type
, stmt
))
2168 rhs1
= gimple_assign_rhs1 (stmt
);
2170 if (TREE_CODE (rhs1
) == INTEGER_CST
)
2172 *new_rhs_out
= rhs1
;
2181 type1
= TREE_TYPE (rhs1
);
2183 if (TREE_CODE (type1
) != TREE_CODE (type
)
2184 || TYPE_PRECISION (type1
) * 2 > TYPE_PRECISION (type
))
2187 *new_rhs_out
= rhs1
;
2192 if (TREE_CODE (rhs
) == INTEGER_CST
)
2202 /* Return true if STMT performs a widening multiplication, assuming the
2203 output type is TYPE. If so, store the unwidened types of the operands
2204 in *TYPE1_OUT and *TYPE2_OUT respectively. Also fill *RHS1_OUT and
2205 *RHS2_OUT such that converting those operands to types *TYPE1_OUT
2206 and *TYPE2_OUT would give the operands of the multiplication. */
2209 is_widening_mult_p (gimple stmt
,
2210 tree
*type1_out
, tree
*rhs1_out
,
2211 tree
*type2_out
, tree
*rhs2_out
)
2213 tree type
= TREE_TYPE (gimple_assign_lhs (stmt
));
2215 if (TREE_CODE (type
) != INTEGER_TYPE
2216 && TREE_CODE (type
) != FIXED_POINT_TYPE
)
2219 if (!is_widening_mult_rhs_p (type
, gimple_assign_rhs1 (stmt
), type1_out
,
2223 if (!is_widening_mult_rhs_p (type
, gimple_assign_rhs2 (stmt
), type2_out
,
2227 if (*type1_out
== NULL
)
2229 if (*type2_out
== NULL
|| !int_fits_type_p (*rhs1_out
, *type2_out
))
2231 *type1_out
= *type2_out
;
2234 if (*type2_out
== NULL
)
2236 if (!int_fits_type_p (*rhs2_out
, *type1_out
))
2238 *type2_out
= *type1_out
;
2241 /* Ensure that the larger of the two operands comes first. */
2242 if (TYPE_PRECISION (*type1_out
) < TYPE_PRECISION (*type2_out
))
2246 *type1_out
= *type2_out
;
2249 *rhs1_out
= *rhs2_out
;
2256 /* Process a single gimple statement STMT, which has a MULT_EXPR as
2257 its rhs, and try to convert it into a WIDEN_MULT_EXPR. The return
2258 value is true iff we converted the statement. */
2261 convert_mult_to_widen (gimple stmt
, gimple_stmt_iterator
*gsi
)
2263 tree lhs
, rhs1
, rhs2
, type
, type1
, type2
;
2264 enum insn_code handler
;
2265 enum machine_mode to_mode
, from_mode
, actual_mode
;
2267 int actual_precision
;
2268 location_t loc
= gimple_location (stmt
);
2269 bool from_unsigned1
, from_unsigned2
;
2271 lhs
= gimple_assign_lhs (stmt
);
2272 type
= TREE_TYPE (lhs
);
2273 if (TREE_CODE (type
) != INTEGER_TYPE
)
2276 if (!is_widening_mult_p (stmt
, &type1
, &rhs1
, &type2
, &rhs2
))
2279 to_mode
= TYPE_MODE (type
);
2280 from_mode
= TYPE_MODE (type1
);
2281 from_unsigned1
= TYPE_UNSIGNED (type1
);
2282 from_unsigned2
= TYPE_UNSIGNED (type2
);
2284 if (from_unsigned1
&& from_unsigned2
)
2285 op
= umul_widen_optab
;
2286 else if (!from_unsigned1
&& !from_unsigned2
)
2287 op
= smul_widen_optab
;
2289 op
= usmul_widen_optab
;
2291 handler
= find_widening_optab_handler_and_mode (op
, to_mode
, from_mode
,
2294 if (handler
== CODE_FOR_nothing
)
2296 if (op
!= smul_widen_optab
)
2298 /* We can use a signed multiply with unsigned types as long as
2299 there is a wider mode to use, or it is the smaller of the two
2300 types that is unsigned. Note that type1 >= type2, always. */
2301 if ((TYPE_UNSIGNED (type1
)
2302 && TYPE_PRECISION (type1
) == GET_MODE_PRECISION (from_mode
))
2303 || (TYPE_UNSIGNED (type2
)
2304 && TYPE_PRECISION (type2
) == GET_MODE_PRECISION (from_mode
)))
2306 from_mode
= GET_MODE_WIDER_MODE (from_mode
);
2307 if (GET_MODE_SIZE (to_mode
) <= GET_MODE_SIZE (from_mode
))
2311 op
= smul_widen_optab
;
2312 handler
= find_widening_optab_handler_and_mode (op
, to_mode
,
2316 if (handler
== CODE_FOR_nothing
)
2319 from_unsigned1
= from_unsigned2
= false;
2325 /* Ensure that the inputs to the handler are in the correct precison
2326 for the opcode. This will be the full mode size. */
2327 actual_precision
= GET_MODE_PRECISION (actual_mode
);
2328 if (2 * actual_precision
> TYPE_PRECISION (type
))
2330 if (actual_precision
!= TYPE_PRECISION (type1
)
2331 || from_unsigned1
!= TYPE_UNSIGNED (type1
))
2332 rhs1
= build_and_insert_cast (gsi
, loc
,
2333 build_nonstandard_integer_type
2334 (actual_precision
, from_unsigned1
), rhs1
);
2335 if (actual_precision
!= TYPE_PRECISION (type2
)
2336 || from_unsigned2
!= TYPE_UNSIGNED (type2
))
2337 rhs2
= build_and_insert_cast (gsi
, loc
,
2338 build_nonstandard_integer_type
2339 (actual_precision
, from_unsigned2
), rhs2
);
2341 /* Handle constants. */
2342 if (TREE_CODE (rhs1
) == INTEGER_CST
)
2343 rhs1
= fold_convert (type1
, rhs1
);
2344 if (TREE_CODE (rhs2
) == INTEGER_CST
)
2345 rhs2
= fold_convert (type2
, rhs2
);
2347 gimple_assign_set_rhs1 (stmt
, rhs1
);
2348 gimple_assign_set_rhs2 (stmt
, rhs2
);
2349 gimple_assign_set_rhs_code (stmt
, WIDEN_MULT_EXPR
);
2351 widen_mul_stats
.widen_mults_inserted
++;
2355 /* Process a single gimple statement STMT, which is found at the
2356 iterator GSI and has a either a PLUS_EXPR or a MINUS_EXPR as its
2357 rhs (given by CODE), and try to convert it into a
2358 WIDEN_MULT_PLUS_EXPR or a WIDEN_MULT_MINUS_EXPR. The return value
2359 is true iff we converted the statement. */
2362 convert_plusminus_to_widen (gimple_stmt_iterator
*gsi
, gimple stmt
,
2363 enum tree_code code
)
2365 gimple rhs1_stmt
= NULL
, rhs2_stmt
= NULL
;
2366 gimple conv1_stmt
= NULL
, conv2_stmt
= NULL
, conv_stmt
;
2367 tree type
, type1
, type2
, optype
;
2368 tree lhs
, rhs1
, rhs2
, mult_rhs1
, mult_rhs2
, add_rhs
;
2369 enum tree_code rhs1_code
= ERROR_MARK
, rhs2_code
= ERROR_MARK
;
2371 enum tree_code wmult_code
;
2372 enum insn_code handler
;
2373 enum machine_mode to_mode
, from_mode
, actual_mode
;
2374 location_t loc
= gimple_location (stmt
);
2375 int actual_precision
;
2376 bool from_unsigned1
, from_unsigned2
;
2378 lhs
= gimple_assign_lhs (stmt
);
2379 type
= TREE_TYPE (lhs
);
2380 if (TREE_CODE (type
) != INTEGER_TYPE
2381 && TREE_CODE (type
) != FIXED_POINT_TYPE
)
2384 if (code
== MINUS_EXPR
)
2385 wmult_code
= WIDEN_MULT_MINUS_EXPR
;
2387 wmult_code
= WIDEN_MULT_PLUS_EXPR
;
2389 rhs1
= gimple_assign_rhs1 (stmt
);
2390 rhs2
= gimple_assign_rhs2 (stmt
);
2392 if (TREE_CODE (rhs1
) == SSA_NAME
)
2394 rhs1_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2395 if (is_gimple_assign (rhs1_stmt
))
2396 rhs1_code
= gimple_assign_rhs_code (rhs1_stmt
);
2399 if (TREE_CODE (rhs2
) == SSA_NAME
)
2401 rhs2_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2402 if (is_gimple_assign (rhs2_stmt
))
2403 rhs2_code
= gimple_assign_rhs_code (rhs2_stmt
);
2406 /* Allow for one conversion statement between the multiply
2407 and addition/subtraction statement. If there are more than
2408 one conversions then we assume they would invalidate this
2409 transformation. If that's not the case then they should have
2410 been folded before now. */
2411 if (CONVERT_EXPR_CODE_P (rhs1_code
))
2413 conv1_stmt
= rhs1_stmt
;
2414 rhs1
= gimple_assign_rhs1 (rhs1_stmt
);
2415 if (TREE_CODE (rhs1
) == SSA_NAME
)
2417 rhs1_stmt
= SSA_NAME_DEF_STMT (rhs1
);
2418 if (is_gimple_assign (rhs1_stmt
))
2419 rhs1_code
= gimple_assign_rhs_code (rhs1_stmt
);
2424 if (CONVERT_EXPR_CODE_P (rhs2_code
))
2426 conv2_stmt
= rhs2_stmt
;
2427 rhs2
= gimple_assign_rhs1 (rhs2_stmt
);
2428 if (TREE_CODE (rhs2
) == SSA_NAME
)
2430 rhs2_stmt
= SSA_NAME_DEF_STMT (rhs2
);
2431 if (is_gimple_assign (rhs2_stmt
))
2432 rhs2_code
= gimple_assign_rhs_code (rhs2_stmt
);
2438 /* If code is WIDEN_MULT_EXPR then it would seem unnecessary to call
2439 is_widening_mult_p, but we still need the rhs returns.
2441 It might also appear that it would be sufficient to use the existing
2442 operands of the widening multiply, but that would limit the choice of
2443 multiply-and-accumulate instructions.
2445 If the widened-multiplication result has more than one uses, it is
2446 probably wiser not to do the conversion. */
2447 if (code
== PLUS_EXPR
2448 && (rhs1_code
== MULT_EXPR
|| rhs1_code
== WIDEN_MULT_EXPR
))
2450 if (!has_single_use (rhs1
)
2451 || !is_widening_mult_p (rhs1_stmt
, &type1
, &mult_rhs1
,
2452 &type2
, &mult_rhs2
))
2455 conv_stmt
= conv1_stmt
;
2457 else if (rhs2_code
== MULT_EXPR
|| rhs2_code
== WIDEN_MULT_EXPR
)
2459 if (!has_single_use (rhs2
)
2460 || !is_widening_mult_p (rhs2_stmt
, &type1
, &mult_rhs1
,
2461 &type2
, &mult_rhs2
))
2464 conv_stmt
= conv2_stmt
;
2469 to_mode
= TYPE_MODE (type
);
2470 from_mode
= TYPE_MODE (type1
);
2471 from_unsigned1
= TYPE_UNSIGNED (type1
);
2472 from_unsigned2
= TYPE_UNSIGNED (type2
);
2475 /* There's no such thing as a mixed sign madd yet, so use a wider mode. */
2476 if (from_unsigned1
!= from_unsigned2
)
2478 if (!INTEGRAL_TYPE_P (type
))
2480 /* We can use a signed multiply with unsigned types as long as
2481 there is a wider mode to use, or it is the smaller of the two
2482 types that is unsigned. Note that type1 >= type2, always. */
2484 && TYPE_PRECISION (type1
) == GET_MODE_PRECISION (from_mode
))
2486 && TYPE_PRECISION (type2
) == GET_MODE_PRECISION (from_mode
)))
2488 from_mode
= GET_MODE_WIDER_MODE (from_mode
);
2489 if (GET_MODE_SIZE (from_mode
) >= GET_MODE_SIZE (to_mode
))
2493 from_unsigned1
= from_unsigned2
= false;
2494 optype
= build_nonstandard_integer_type (GET_MODE_PRECISION (from_mode
),
2498 /* If there was a conversion between the multiply and addition
2499 then we need to make sure it fits a multiply-and-accumulate.
2500 The should be a single mode change which does not change the
2504 /* We use the original, unmodified data types for this. */
2505 tree from_type
= TREE_TYPE (gimple_assign_rhs1 (conv_stmt
));
2506 tree to_type
= TREE_TYPE (gimple_assign_lhs (conv_stmt
));
2507 int data_size
= TYPE_PRECISION (type1
) + TYPE_PRECISION (type2
);
2508 bool is_unsigned
= TYPE_UNSIGNED (type1
) && TYPE_UNSIGNED (type2
);
2510 if (TYPE_PRECISION (from_type
) > TYPE_PRECISION (to_type
))
2512 /* Conversion is a truncate. */
2513 if (TYPE_PRECISION (to_type
) < data_size
)
2516 else if (TYPE_PRECISION (from_type
) < TYPE_PRECISION (to_type
))
2518 /* Conversion is an extend. Check it's the right sort. */
2519 if (TYPE_UNSIGNED (from_type
) != is_unsigned
2520 && !(is_unsigned
&& TYPE_PRECISION (from_type
) > data_size
))
2523 /* else convert is a no-op for our purposes. */
2526 /* Verify that the machine can perform a widening multiply
2527 accumulate in this mode/signedness combination, otherwise
2528 this transformation is likely to pessimize code. */
2529 this_optab
= optab_for_tree_code (wmult_code
, optype
, optab_default
);
2530 handler
= find_widening_optab_handler_and_mode (this_optab
, to_mode
,
2531 from_mode
, 0, &actual_mode
);
2533 if (handler
== CODE_FOR_nothing
)
2536 /* Ensure that the inputs to the handler are in the correct precison
2537 for the opcode. This will be the full mode size. */
2538 actual_precision
= GET_MODE_PRECISION (actual_mode
);
2539 if (actual_precision
!= TYPE_PRECISION (type1
)
2540 || from_unsigned1
!= TYPE_UNSIGNED (type1
))
2541 mult_rhs1
= build_and_insert_cast (gsi
, loc
,
2542 build_nonstandard_integer_type
2543 (actual_precision
, from_unsigned1
),
2545 if (actual_precision
!= TYPE_PRECISION (type2
)
2546 || from_unsigned2
!= TYPE_UNSIGNED (type2
))
2547 mult_rhs2
= build_and_insert_cast (gsi
, loc
,
2548 build_nonstandard_integer_type
2549 (actual_precision
, from_unsigned2
),
2552 if (!useless_type_conversion_p (type
, TREE_TYPE (add_rhs
)))
2553 add_rhs
= build_and_insert_cast (gsi
, loc
, type
, add_rhs
);
2555 /* Handle constants. */
2556 if (TREE_CODE (mult_rhs1
) == INTEGER_CST
)
2557 mult_rhs1
= fold_convert (type1
, mult_rhs1
);
2558 if (TREE_CODE (mult_rhs2
) == INTEGER_CST
)
2559 mult_rhs2
= fold_convert (type2
, mult_rhs2
);
2561 gimple_assign_set_rhs_with_ops_1 (gsi
, wmult_code
, mult_rhs1
, mult_rhs2
,
2563 update_stmt (gsi_stmt (*gsi
));
2564 widen_mul_stats
.maccs_inserted
++;
2568 /* Combine the multiplication at MUL_STMT with operands MULOP1 and MULOP2
2569 with uses in additions and subtractions to form fused multiply-add
2570 operations. Returns true if successful and MUL_STMT should be removed. */
2573 convert_mult_to_fma (gimple mul_stmt
, tree op1
, tree op2
)
2575 tree mul_result
= gimple_get_lhs (mul_stmt
);
2576 tree type
= TREE_TYPE (mul_result
);
2577 gimple use_stmt
, neguse_stmt
, fma_stmt
;
2578 use_operand_p use_p
;
2579 imm_use_iterator imm_iter
;
2581 if (FLOAT_TYPE_P (type
)
2582 && flag_fp_contract_mode
== FP_CONTRACT_OFF
)
2585 /* We don't want to do bitfield reduction ops. */
2586 if (INTEGRAL_TYPE_P (type
)
2587 && (TYPE_PRECISION (type
)
2588 != GET_MODE_PRECISION (TYPE_MODE (type
))))
2591 /* If the target doesn't support it, don't generate it. We assume that
2592 if fma isn't available then fms, fnma or fnms are not either. */
2593 if (optab_handler (fma_optab
, TYPE_MODE (type
)) == CODE_FOR_nothing
)
2596 /* If the multiplication has zero uses, it is kept around probably because
2597 of -fnon-call-exceptions. Don't optimize it away in that case,
2599 if (has_zero_uses (mul_result
))
2602 /* Make sure that the multiplication statement becomes dead after
2603 the transformation, thus that all uses are transformed to FMAs.
2604 This means we assume that an FMA operation has the same cost
2606 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, mul_result
)
2608 enum tree_code use_code
;
2609 tree result
= mul_result
;
2610 bool negate_p
= false;
2612 use_stmt
= USE_STMT (use_p
);
2614 if (is_gimple_debug (use_stmt
))
2617 /* For now restrict this operations to single basic blocks. In theory
2618 we would want to support sinking the multiplication in
2624 to form a fma in the then block and sink the multiplication to the
2626 if (gimple_bb (use_stmt
) != gimple_bb (mul_stmt
))
2629 if (!is_gimple_assign (use_stmt
))
2632 use_code
= gimple_assign_rhs_code (use_stmt
);
2634 /* A negate on the multiplication leads to FNMA. */
2635 if (use_code
== NEGATE_EXPR
)
2640 result
= gimple_assign_lhs (use_stmt
);
2642 /* Make sure the negate statement becomes dead with this
2643 single transformation. */
2644 if (!single_imm_use (gimple_assign_lhs (use_stmt
),
2645 &use_p
, &neguse_stmt
))
2648 /* Make sure the multiplication isn't also used on that stmt. */
2649 FOR_EACH_PHI_OR_STMT_USE (usep
, neguse_stmt
, iter
, SSA_OP_USE
)
2650 if (USE_FROM_PTR (usep
) == mul_result
)
2654 use_stmt
= neguse_stmt
;
2655 if (gimple_bb (use_stmt
) != gimple_bb (mul_stmt
))
2657 if (!is_gimple_assign (use_stmt
))
2660 use_code
= gimple_assign_rhs_code (use_stmt
);
2667 if (gimple_assign_rhs2 (use_stmt
) == result
)
2668 negate_p
= !negate_p
;
2673 /* FMA can only be formed from PLUS and MINUS. */
2677 /* If the subtrahend (gimple_assign_rhs2 (use_stmt)) is computed
2678 by a MULT_EXPR that we'll visit later, we might be able to
2679 get a more profitable match with fnma.
2680 OTOH, if we don't, a negate / fma pair has likely lower latency
2681 that a mult / subtract pair. */
2682 if (use_code
== MINUS_EXPR
&& !negate_p
2683 && gimple_assign_rhs1 (use_stmt
) == result
2684 && optab_handler (fms_optab
, TYPE_MODE (type
)) == CODE_FOR_nothing
2685 && optab_handler (fnma_optab
, TYPE_MODE (type
)) != CODE_FOR_nothing
)
2687 tree rhs2
= gimple_assign_rhs2 (use_stmt
);
2689 if (TREE_CODE (rhs2
) == SSA_NAME
)
2691 gimple stmt2
= SSA_NAME_DEF_STMT (rhs2
);
2692 if (has_single_use (rhs2
)
2693 && is_gimple_assign (stmt2
)
2694 && gimple_assign_rhs_code (stmt2
) == MULT_EXPR
)
2699 /* We can't handle a * b + a * b. */
2700 if (gimple_assign_rhs1 (use_stmt
) == gimple_assign_rhs2 (use_stmt
))
2703 /* While it is possible to validate whether or not the exact form
2704 that we've recognized is available in the backend, the assumption
2705 is that the transformation is never a loss. For instance, suppose
2706 the target only has the plain FMA pattern available. Consider
2707 a*b-c -> fma(a,b,-c): we've exchanged MUL+SUB for FMA+NEG, which
2708 is still two operations. Consider -(a*b)-c -> fma(-a,b,-c): we
2709 still have 3 operations, but in the FMA form the two NEGs are
2710 independent and could be run in parallel. */
2713 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, mul_result
)
2715 gimple_stmt_iterator gsi
= gsi_for_stmt (use_stmt
);
2716 enum tree_code use_code
;
2717 tree addop
, mulop1
= op1
, result
= mul_result
;
2718 bool negate_p
= false;
2720 if (is_gimple_debug (use_stmt
))
2723 use_code
= gimple_assign_rhs_code (use_stmt
);
2724 if (use_code
== NEGATE_EXPR
)
2726 result
= gimple_assign_lhs (use_stmt
);
2727 single_imm_use (gimple_assign_lhs (use_stmt
), &use_p
, &neguse_stmt
);
2728 gsi_remove (&gsi
, true);
2729 release_defs (use_stmt
);
2731 use_stmt
= neguse_stmt
;
2732 gsi
= gsi_for_stmt (use_stmt
);
2733 use_code
= gimple_assign_rhs_code (use_stmt
);
2737 if (gimple_assign_rhs1 (use_stmt
) == result
)
2739 addop
= gimple_assign_rhs2 (use_stmt
);
2740 /* a * b - c -> a * b + (-c) */
2741 if (gimple_assign_rhs_code (use_stmt
) == MINUS_EXPR
)
2742 addop
= force_gimple_operand_gsi (&gsi
,
2743 build1 (NEGATE_EXPR
,
2745 true, NULL_TREE
, true,
2750 addop
= gimple_assign_rhs1 (use_stmt
);
2751 /* a - b * c -> (-b) * c + a */
2752 if (gimple_assign_rhs_code (use_stmt
) == MINUS_EXPR
)
2753 negate_p
= !negate_p
;
2757 mulop1
= force_gimple_operand_gsi (&gsi
,
2758 build1 (NEGATE_EXPR
,
2760 true, NULL_TREE
, true,
2763 fma_stmt
= gimple_build_assign_with_ops (FMA_EXPR
,
2764 gimple_assign_lhs (use_stmt
),
2767 gsi_replace (&gsi
, fma_stmt
, true);
2768 widen_mul_stats
.fmas_inserted
++;
2774 /* Find integer multiplications where the operands are extended from
2775 smaller types, and replace the MULT_EXPR with a WIDEN_MULT_EXPR
2776 where appropriate. */
2779 execute_optimize_widening_mul (void)
2782 bool cfg_changed
= false;
2784 memset (&widen_mul_stats
, 0, sizeof (widen_mul_stats
));
2786 FOR_EACH_BB_FN (bb
, cfun
)
2788 gimple_stmt_iterator gsi
;
2790 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
);)
2792 gimple stmt
= gsi_stmt (gsi
);
2793 enum tree_code code
;
2795 if (is_gimple_assign (stmt
))
2797 code
= gimple_assign_rhs_code (stmt
);
2801 if (!convert_mult_to_widen (stmt
, &gsi
)
2802 && convert_mult_to_fma (stmt
,
2803 gimple_assign_rhs1 (stmt
),
2804 gimple_assign_rhs2 (stmt
)))
2806 gsi_remove (&gsi
, true);
2807 release_defs (stmt
);
2814 convert_plusminus_to_widen (&gsi
, stmt
, code
);
2820 else if (is_gimple_call (stmt
)
2821 && gimple_call_lhs (stmt
))
2823 tree fndecl
= gimple_call_fndecl (stmt
);
2825 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2827 switch (DECL_FUNCTION_CODE (fndecl
))
2832 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
2833 && REAL_VALUES_EQUAL
2834 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)),
2836 && convert_mult_to_fma (stmt
,
2837 gimple_call_arg (stmt
, 0),
2838 gimple_call_arg (stmt
, 0)))
2840 unlink_stmt_vdef (stmt
);
2841 if (gsi_remove (&gsi
, true)
2842 && gimple_purge_dead_eh_edges (bb
))
2844 release_defs (stmt
);
2857 statistics_counter_event (cfun
, "widening multiplications inserted",
2858 widen_mul_stats
.widen_mults_inserted
);
2859 statistics_counter_event (cfun
, "widening maccs inserted",
2860 widen_mul_stats
.maccs_inserted
);
2861 statistics_counter_event (cfun
, "fused multiply-adds inserted",
2862 widen_mul_stats
.fmas_inserted
);
2864 return cfg_changed
? TODO_cleanup_cfg
: 0;
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_execute */
2875 TV_NONE
, /* tv_id */
2876 PROP_ssa
, /* properties_required */
2877 0, /* properties_provided */
2878 0, /* properties_destroyed */
2879 0, /* todo_flags_start */
2880 ( TODO_verify_ssa
| TODO_verify_stmts
2881 | TODO_update_ssa
), /* todo_flags_finish */
2884 class pass_optimize_widening_mul
: public gimple_opt_pass
2887 pass_optimize_widening_mul (gcc::context
*ctxt
)
2888 : gimple_opt_pass (pass_data_optimize_widening_mul
, ctxt
)
2891 /* opt_pass methods: */
2892 virtual bool gate (function
*)
2894 return flag_expensive_optimizations
&& optimize
;
2897 unsigned int execute () { return execute_optimize_widening_mul (); }
2899 }; // class pass_optimize_widening_mul
2904 make_pass_optimize_widening_mul (gcc::context
*ctxt
)
2906 return new pass_optimize_widening_mul (ctxt
);