1 /* Lower GIMPLE_SWITCH expressions to something more efficient than
3 Copyright (C) 2006-2015 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
22 /* This file handles the lowering of GIMPLE_SWITCH to an indexed
23 load, or a series of bit-test-and-branch expressions. */
27 #include "coretypes.h"
39 #include "fold-const.h"
41 #include "stor-layout.h"
43 #include "hard-reg-set.h"
45 #include "dominance.h"
48 #include "basic-block.h"
49 #include "tree-ssa-alias.h"
50 #include "internal-fn.h"
51 #include "gimple-expr.h"
55 #include "gimple-iterator.h"
56 #include "gimplify-me.h"
57 #include "gimple-ssa.h"
59 #include "plugin-api.h"
63 #include "tree-phinodes.h"
64 #include "stringpool.h"
65 #include "tree-ssanames.h"
66 #include "tree-pass.h"
67 #include "gimple-pretty-print.h"
70 /* ??? For lang_hooks.types.type_for_mode, but is there a word_mode
71 type in the GIMPLE type system that is language-independent? */
72 #include "langhooks.h"
74 /* Need to include expr.h and optabs.h for lshift_cheap_p. */
77 #include "statistics.h"
78 #include "insn-config.h"
86 #include "insn-codes.h"
89 /* Maximum number of case bit tests.
90 FIXME: This should be derived from PARAM_CASE_VALUES_THRESHOLD and
91 targetm.case_values_threshold(), or be its own param. */
92 #define MAX_CASE_BIT_TESTS 3
94 /* Split the basic block at the statement pointed to by GSIP, and insert
95 a branch to the target basic block of E_TRUE conditional on tree
98 It is assumed that there is already an edge from the to-be-split
99 basic block to E_TRUE->dest block. This edge is removed, and the
100 profile information on the edge is re-used for the new conditional
103 The CFG is updated. The dominator tree will not be valid after
104 this transformation, but the immediate dominators are updated if
105 UPDATE_DOMINATORS is true.
107 Returns the newly created basic block. */
110 hoist_edge_and_branch_if_true (gimple_stmt_iterator
*gsip
,
111 tree cond
, edge e_true
,
112 bool update_dominators
)
117 basic_block new_bb
, split_bb
= gsi_bb (*gsip
);
118 bool dominated_e_true
= false;
120 gcc_assert (e_true
->src
== split_bb
);
122 if (update_dominators
123 && get_immediate_dominator (CDI_DOMINATORS
, e_true
->dest
) == split_bb
)
124 dominated_e_true
= true;
126 tmp
= force_gimple_operand_gsi (gsip
, cond
, /*simple=*/true, NULL
,
127 /*before=*/true, GSI_SAME_STMT
);
128 cond_stmt
= gimple_build_cond_from_tree (tmp
, NULL_TREE
, NULL_TREE
);
129 gsi_insert_before (gsip
, cond_stmt
, GSI_SAME_STMT
);
131 e_false
= split_block (split_bb
, cond_stmt
);
132 new_bb
= e_false
->dest
;
133 redirect_edge_pred (e_true
, split_bb
);
135 e_true
->flags
&= ~EDGE_FALLTHRU
;
136 e_true
->flags
|= EDGE_TRUE_VALUE
;
138 e_false
->flags
&= ~EDGE_FALLTHRU
;
139 e_false
->flags
|= EDGE_FALSE_VALUE
;
140 e_false
->probability
= REG_BR_PROB_BASE
- e_true
->probability
;
141 e_false
->count
= split_bb
->count
- e_true
->count
;
142 new_bb
->count
= e_false
->count
;
144 if (update_dominators
)
146 if (dominated_e_true
)
147 set_immediate_dominator (CDI_DOMINATORS
, e_true
->dest
, split_bb
);
148 set_immediate_dominator (CDI_DOMINATORS
, e_false
->dest
, split_bb
);
155 /* Return true if a switch should be expanded as a bit test.
156 RANGE is the difference between highest and lowest case.
157 UNIQ is number of unique case node targets, not counting the default case.
158 COUNT is the number of comparisons needed, not counting the default case. */
161 expand_switch_using_bit_tests_p (tree range
,
163 unsigned int count
, bool speed_p
)
165 return (((uniq
== 1 && count
>= 3)
166 || (uniq
== 2 && count
>= 5)
167 || (uniq
== 3 && count
>= 6))
168 && lshift_cheap_p (speed_p
)
169 && compare_tree_int (range
, GET_MODE_BITSIZE (word_mode
)) < 0
170 && compare_tree_int (range
, 0) > 0);
173 /* Implement switch statements with bit tests
175 A GIMPLE switch statement can be expanded to a short sequence of bit-wise
176 comparisons. "switch(x)" is converted into "if ((1 << (x-MINVAL)) & CST)"
177 where CST and MINVAL are integer constants. This is better than a series
178 of compare-and-banch insns in some cases, e.g. we can implement:
180 if ((x==4) || (x==6) || (x==9) || (x==11))
182 as a single bit test:
184 if ((1<<x) & ((1<<4)|(1<<6)|(1<<9)|(1<<11)))
186 This transformation is only applied if the number of case targets is small,
187 if CST constains at least 3 bits, and "1 << x" is cheap. The bit tests are
188 performed in "word_mode".
190 The following example shows the code the transformation generates:
196 case '0': case '1': case '2': case '3': case '4':
197 case '5': case '6': case '7': case '8': case '9':
198 case 'A': case 'B': case 'C': case 'D': case 'E':
210 if (tmp1 > (70 - 48)) goto L2;
212 tmp3 = 0b11111100000001111111111;
213 if ((tmp2 & tmp3) != 0) goto L1 ; else goto L2;
220 TODO: There are still some improvements to this transformation that could
223 * A narrower mode than word_mode could be used if that is cheaper, e.g.
224 for x86_64 where a narrower-mode shift may result in smaller code.
226 * The compounded constant could be shifted rather than the one. The
227 test would be either on the sign bit or on the least significant bit,
228 depending on the direction of the shift. On some machines, the test
229 for the branch would be free if the bit to test is already set by the
232 This transformation was contributed by Roger Sayle, see this e-mail:
233 http://gcc.gnu.org/ml/gcc-patches/2003-01/msg01950.html
236 /* A case_bit_test represents a set of case nodes that may be
237 selected from using a bit-wise comparison. HI and LO hold
238 the integer to be tested against, TARGET_EDGE contains the
239 edge to the basic block to jump to upon success and BITS
240 counts the number of case nodes handled by this test,
241 typically the number of bits set in HI:LO. The LABEL field
242 is used to quickly identify all cases in this set without
243 looking at label_to_block for every case label. */
253 /* Comparison function for qsort to order bit tests by decreasing
254 probability of execution. Our best guess comes from a measured
255 profile. If the profile counts are equal, break even on the
256 number of case nodes, i.e. the node with the most cases gets
259 TODO: Actually this currently runs before a profile is available.
260 Therefore the case-as-bit-tests transformation should be done
261 later in the pass pipeline, or something along the lines of
262 "Efficient and effective branch reordering using profile data"
263 (Yang et. al., 2002) should be implemented (although, how good
264 is a paper is called "Efficient and effective ..." when the
265 latter is implied by the former, but oh well...). */
268 case_bit_test_cmp (const void *p1
, const void *p2
)
270 const struct case_bit_test
*const d1
= (const struct case_bit_test
*) p1
;
271 const struct case_bit_test
*const d2
= (const struct case_bit_test
*) p2
;
273 if (d2
->target_edge
->count
!= d1
->target_edge
->count
)
274 return d2
->target_edge
->count
- d1
->target_edge
->count
;
275 if (d2
->bits
!= d1
->bits
)
276 return d2
->bits
- d1
->bits
;
278 /* Stabilize the sort. */
279 return LABEL_DECL_UID (d2
->label
) - LABEL_DECL_UID (d1
->label
);
282 /* Expand a switch statement by a short sequence of bit-wise
283 comparisons. "switch(x)" is effectively converted into
284 "if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
287 INDEX_EXPR is the value being switched on.
289 MINVAL is the lowest case value of in the case nodes,
290 and RANGE is highest value minus MINVAL. MINVAL and RANGE
291 are not guaranteed to be of the same type as INDEX_EXPR
292 (the gimplifier doesn't change the type of case label values,
293 and MINVAL and RANGE are derived from those values).
294 MAXVAL is MINVAL + RANGE.
296 There *MUST* be MAX_CASE_BIT_TESTS or less unique case
300 emit_case_bit_tests (gswitch
*swtch
, tree index_expr
,
301 tree minval
, tree range
, tree maxval
)
303 struct case_bit_test test
[MAX_CASE_BIT_TESTS
];
304 unsigned int i
, j
, k
;
307 basic_block switch_bb
= gimple_bb (swtch
);
308 basic_block default_bb
, new_default_bb
, new_bb
;
310 bool update_dom
= dom_info_available_p (CDI_DOMINATORS
);
312 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
314 tree index_type
= TREE_TYPE (index_expr
);
315 tree unsigned_index_type
= unsigned_type_for (index_type
);
316 unsigned int branch_num
= gimple_switch_num_labels (swtch
);
318 gimple_stmt_iterator gsi
;
322 tree word_type_node
= lang_hooks
.types
.type_for_mode (word_mode
, 1);
323 tree word_mode_zero
= fold_convert (word_type_node
, integer_zero_node
);
324 tree word_mode_one
= fold_convert (word_type_node
, integer_one_node
);
325 int prec
= TYPE_PRECISION (word_type_node
);
326 wide_int wone
= wi::one (prec
);
328 memset (&test
, 0, sizeof (test
));
330 /* Get the edge for the default case. */
331 tmp
= gimple_switch_default_label (swtch
);
332 default_bb
= label_to_block (CASE_LABEL (tmp
));
333 default_edge
= find_edge (switch_bb
, default_bb
);
335 /* Go through all case labels, and collect the case labels, profile
336 counts, and other information we need to build the branch tests. */
338 for (i
= 1; i
< branch_num
; i
++)
341 tree cs
= gimple_switch_label (swtch
, i
);
342 tree label
= CASE_LABEL (cs
);
343 edge e
= find_edge (switch_bb
, label_to_block (label
));
344 for (k
= 0; k
< count
; k
++)
345 if (e
== test
[k
].target_edge
)
350 gcc_checking_assert (count
< MAX_CASE_BIT_TESTS
);
351 test
[k
].mask
= wi::zero (prec
);
352 test
[k
].target_edge
= e
;
353 test
[k
].label
= label
;
360 lo
= tree_to_uhwi (int_const_binop (MINUS_EXPR
,
361 CASE_LOW (cs
), minval
));
362 if (CASE_HIGH (cs
) == NULL_TREE
)
365 hi
= tree_to_uhwi (int_const_binop (MINUS_EXPR
,
366 CASE_HIGH (cs
), minval
));
368 for (j
= lo
; j
<= hi
; j
++)
369 test
[k
].mask
|= wi::lshift (wone
, j
);
372 qsort (test
, count
, sizeof (*test
), case_bit_test_cmp
);
374 /* If all values are in the 0 .. BITS_PER_WORD-1 range, we can get rid of
375 the minval subtractions, but it might make the mask constants more
376 expensive. So, compare the costs. */
377 if (compare_tree_int (minval
, 0) > 0
378 && compare_tree_int (maxval
, GET_MODE_BITSIZE (word_mode
)) < 0)
381 HOST_WIDE_INT m
= tree_to_uhwi (minval
);
382 rtx reg
= gen_raw_REG (word_mode
, 10000);
383 bool speed_p
= optimize_bb_for_speed_p (gimple_bb (swtch
));
384 cost_diff
= set_rtx_cost (gen_rtx_PLUS (word_mode
, reg
,
385 GEN_INT (-m
)), speed_p
);
386 for (i
= 0; i
< count
; i
++)
388 rtx r
= immed_wide_int_const (test
[i
].mask
, word_mode
);
389 cost_diff
+= set_src_cost (gen_rtx_AND (word_mode
, reg
, r
), speed_p
);
390 r
= immed_wide_int_const (wi::lshift (test
[i
].mask
, m
), word_mode
);
391 cost_diff
-= set_src_cost (gen_rtx_AND (word_mode
, reg
, r
), speed_p
);
395 for (i
= 0; i
< count
; i
++)
396 test
[i
].mask
= wi::lshift (test
[i
].mask
, m
);
397 minval
= build_zero_cst (TREE_TYPE (minval
));
402 /* We generate two jumps to the default case label.
403 Split the default edge, so that we don't have to do any PHI node
405 new_default_bb
= split_edge (default_edge
);
409 bbs_to_fix_dom
.create (10);
410 bbs_to_fix_dom
.quick_push (switch_bb
);
411 bbs_to_fix_dom
.quick_push (default_bb
);
412 bbs_to_fix_dom
.quick_push (new_default_bb
);
415 /* Now build the test-and-branch code. */
417 gsi
= gsi_last_bb (switch_bb
);
419 /* idx = (unsigned)x - minval. */
420 idx
= fold_convert (unsigned_index_type
, index_expr
);
421 idx
= fold_build2 (MINUS_EXPR
, unsigned_index_type
, idx
,
422 fold_convert (unsigned_index_type
, minval
));
423 idx
= force_gimple_operand_gsi (&gsi
, idx
,
424 /*simple=*/true, NULL_TREE
,
425 /*before=*/true, GSI_SAME_STMT
);
427 /* if (idx > range) goto default */
428 range
= force_gimple_operand_gsi (&gsi
,
429 fold_convert (unsigned_index_type
, range
),
430 /*simple=*/true, NULL_TREE
,
431 /*before=*/true, GSI_SAME_STMT
);
432 tmp
= fold_build2 (GT_EXPR
, boolean_type_node
, idx
, range
);
433 new_bb
= hoist_edge_and_branch_if_true (&gsi
, tmp
, default_edge
, update_dom
);
435 bbs_to_fix_dom
.quick_push (new_bb
);
436 gcc_assert (gimple_bb (swtch
) == new_bb
);
437 gsi
= gsi_last_bb (new_bb
);
439 /* Any blocks dominated by the GIMPLE_SWITCH, but that are not successors
440 of NEW_BB, are still immediately dominated by SWITCH_BB. Make it so. */
443 vec
<basic_block
> dom_bbs
;
446 dom_bbs
= get_dominated_by (CDI_DOMINATORS
, new_bb
);
447 FOR_EACH_VEC_ELT (dom_bbs
, i
, dom_son
)
449 edge e
= find_edge (new_bb
, dom_son
);
450 if (e
&& single_pred_p (e
->dest
))
452 set_immediate_dominator (CDI_DOMINATORS
, dom_son
, switch_bb
);
453 bbs_to_fix_dom
.safe_push (dom_son
);
458 /* csui = (1 << (word_mode) idx) */
459 csui
= make_ssa_name (word_type_node
);
460 tmp
= fold_build2 (LSHIFT_EXPR
, word_type_node
, word_mode_one
,
461 fold_convert (word_type_node
, idx
));
462 tmp
= force_gimple_operand_gsi (&gsi
, tmp
,
463 /*simple=*/false, NULL_TREE
,
464 /*before=*/true, GSI_SAME_STMT
);
465 shift_stmt
= gimple_build_assign (csui
, tmp
);
466 gsi_insert_before (&gsi
, shift_stmt
, GSI_SAME_STMT
);
467 update_stmt (shift_stmt
);
469 /* for each unique set of cases:
470 if (const & csui) goto target */
471 for (k
= 0; k
< count
; k
++)
473 tmp
= wide_int_to_tree (word_type_node
, test
[k
].mask
);
474 tmp
= fold_build2 (BIT_AND_EXPR
, word_type_node
, csui
, tmp
);
475 tmp
= force_gimple_operand_gsi (&gsi
, tmp
,
476 /*simple=*/true, NULL_TREE
,
477 /*before=*/true, GSI_SAME_STMT
);
478 tmp
= fold_build2 (NE_EXPR
, boolean_type_node
, tmp
, word_mode_zero
);
479 new_bb
= hoist_edge_and_branch_if_true (&gsi
, tmp
, test
[k
].target_edge
,
482 bbs_to_fix_dom
.safe_push (new_bb
);
483 gcc_assert (gimple_bb (swtch
) == new_bb
);
484 gsi
= gsi_last_bb (new_bb
);
487 /* We should have removed all edges now. */
488 gcc_assert (EDGE_COUNT (gsi_bb (gsi
)->succs
) == 0);
490 /* If nothing matched, go to the default label. */
491 make_edge (gsi_bb (gsi
), new_default_bb
, EDGE_FALLTHRU
);
493 /* The GIMPLE_SWITCH is now redundant. */
494 gsi_remove (&gsi
, true);
498 /* Fix up the dominator tree. */
499 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
500 bbs_to_fix_dom
.release ();
505 Switch initialization conversion
507 The following pass changes simple initializations of scalars in a switch
508 statement into initializations from a static array. Obviously, the values
509 must be constant and known at compile time and a default branch must be
510 provided. For example, the following code:
534 a_5 = PHI <a_1, a_2, a_3, a_4>
535 b_5 = PHI <b_1, b_2, b_3, b_4>
540 static const int = CSWTCH01[] = {6, 6, 5, 1, 1, 1, 1, 1, 1, 1, 1, 4};
541 static const int = CSWTCH02[] = {8, 8, 9, 16, 16, 16, 16, 16, 16, 16,
544 if (((unsigned) argc) - 1 < 11)
546 a_6 = CSWTCH02[argc - 1];
547 b_6 = CSWTCH01[argc - 1];
557 There are further constraints. Specifically, the range of values across all
558 case labels must not be bigger than SWITCH_CONVERSION_BRANCH_RATIO (default
559 eight) times the number of the actual switch branches.
561 This transformation was contributed by Martin Jambor, see this e-mail:
562 http://gcc.gnu.org/ml/gcc-patches/2008-07/msg00011.html */
564 /* The main structure of the pass. */
565 struct switch_conv_info
567 /* The expression used to decide the switch branch. */
570 /* The following integer constants store the minimum and maximum value
571 covered by the case labels. */
575 /* The difference between the above two numbers. Stored here because it
576 is used in all the conversion heuristics, as well as for some of the
577 transformation, and it is expensive to re-compute it all the time. */
580 /* Basic block that contains the actual GIMPLE_SWITCH. */
581 basic_block switch_bb
;
583 /* Basic block that is the target of the default case. */
584 basic_block default_bb
;
586 /* The single successor block of all branches out of the GIMPLE_SWITCH,
587 if such a block exists. Otherwise NULL. */
588 basic_block final_bb
;
590 /* The probability of the default edge in the replaced switch. */
593 /* The count of the default edge in the replaced switch. */
594 gcov_type default_count
;
596 /* Combined count of all other (non-default) edges in the replaced switch. */
597 gcov_type other_count
;
599 /* Number of phi nodes in the final bb (that we'll be replacing). */
602 /* Array of default values, in the same order as phi nodes. */
603 tree
*default_values
;
605 /* Constructors of new static arrays. */
606 vec
<constructor_elt
, va_gc
> **constructors
;
608 /* Array of ssa names that are initialized with a value from a new static
610 tree
*target_inbound_names
;
612 /* Array of ssa names that are initialized with the default value if the
613 switch expression is out of range. */
614 tree
*target_outbound_names
;
616 /* The first load statement that loads a temporary from a new static array.
618 gimple arr_ref_first
;
620 /* The last load statement that loads a temporary from a new static array. */
623 /* String reason why the case wasn't a good candidate that is written to the
624 dump file, if there is one. */
627 /* Parameters for expand_switch_using_bit_tests. Should be computed
628 the same way as in expand_case. */
633 /* Collect information about GIMPLE_SWITCH statement SWTCH into INFO. */
636 collect_switch_conv_info (gswitch
*swtch
, struct switch_conv_info
*info
)
638 unsigned int branch_num
= gimple_switch_num_labels (swtch
);
639 tree min_case
, max_case
;
640 unsigned int count
, i
;
644 memset (info
, 0, sizeof (*info
));
646 /* The gimplifier has already sorted the cases by CASE_LOW and ensured there
647 is a default label which is the first in the vector.
648 Collect the bits we can deduce from the CFG. */
649 info
->index_expr
= gimple_switch_index (swtch
);
650 info
->switch_bb
= gimple_bb (swtch
);
652 label_to_block (CASE_LABEL (gimple_switch_default_label (swtch
)));
653 e_default
= find_edge (info
->switch_bb
, info
->default_bb
);
654 info
->default_prob
= e_default
->probability
;
655 info
->default_count
= e_default
->count
;
656 FOR_EACH_EDGE (e
, ei
, info
->switch_bb
->succs
)
658 info
->other_count
+= e
->count
;
660 /* See if there is one common successor block for all branch
661 targets. If it exists, record it in FINAL_BB.
662 Start with the destination of the default case as guess
663 or its destination in case it is a forwarder block. */
664 if (! single_pred_p (e_default
->dest
))
665 info
->final_bb
= e_default
->dest
;
666 else if (single_succ_p (e_default
->dest
)
667 && ! single_pred_p (single_succ (e_default
->dest
)))
668 info
->final_bb
= single_succ (e_default
->dest
);
669 /* Require that all switch destinations are either that common
670 FINAL_BB or a forwarder to it. */
672 FOR_EACH_EDGE (e
, ei
, info
->switch_bb
->succs
)
674 if (e
->dest
== info
->final_bb
)
677 if (single_pred_p (e
->dest
)
678 && single_succ_p (e
->dest
)
679 && single_succ (e
->dest
) == info
->final_bb
)
682 info
->final_bb
= NULL
;
686 /* Get upper and lower bounds of case values, and the covered range. */
687 min_case
= gimple_switch_label (swtch
, 1);
688 max_case
= gimple_switch_label (swtch
, branch_num
- 1);
690 info
->range_min
= CASE_LOW (min_case
);
691 if (CASE_HIGH (max_case
) != NULL_TREE
)
692 info
->range_max
= CASE_HIGH (max_case
);
694 info
->range_max
= CASE_LOW (max_case
);
697 int_const_binop (MINUS_EXPR
, info
->range_max
, info
->range_min
);
699 /* Get a count of the number of case labels. Single-valued case labels
700 simply count as one, but a case range counts double, since it may
701 require two compares if it gets lowered as a branching tree. */
703 for (i
= 1; i
< branch_num
; i
++)
705 tree elt
= gimple_switch_label (swtch
, i
);
708 && ! tree_int_cst_equal (CASE_LOW (elt
), CASE_HIGH (elt
)))
713 /* Get the number of unique non-default targets out of the GIMPLE_SWITCH
714 block. Assume a CFG cleanup would have already removed degenerate
715 switch statements, this allows us to just use EDGE_COUNT. */
716 info
->uniq
= EDGE_COUNT (gimple_bb (swtch
)->succs
) - 1;
719 /* Checks whether the range given by individual case statements of the SWTCH
720 switch statement isn't too big and whether the number of branches actually
721 satisfies the size of the new array. */
724 check_range (struct switch_conv_info
*info
)
726 gcc_assert (info
->range_size
);
727 if (!tree_fits_uhwi_p (info
->range_size
))
729 info
->reason
= "index range way too large or otherwise unusable";
733 if (tree_to_uhwi (info
->range_size
)
734 > ((unsigned) info
->count
* SWITCH_CONVERSION_BRANCH_RATIO
))
736 info
->reason
= "the maximum range-branch ratio exceeded";
743 /* Checks whether all but the FINAL_BB basic blocks are empty. */
746 check_all_empty_except_final (struct switch_conv_info
*info
)
751 FOR_EACH_EDGE (e
, ei
, info
->switch_bb
->succs
)
753 if (e
->dest
== info
->final_bb
)
756 if (!empty_block_p (e
->dest
))
758 info
->reason
= "bad case - a non-final BB not empty";
766 /* This function checks whether all required values in phi nodes in final_bb
767 are constants. Required values are those that correspond to a basic block
768 which is a part of the examined switch statement. It returns true if the
769 phi nodes are OK, otherwise false. */
772 check_final_bb (struct switch_conv_info
*info
)
777 for (gsi
= gsi_start_phis (info
->final_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
779 gphi
*phi
= gsi
.phi ();
784 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
786 basic_block bb
= gimple_phi_arg_edge (phi
, i
)->src
;
788 if (bb
== info
->switch_bb
789 || (single_pred_p (bb
) && single_pred (bb
) == info
->switch_bb
))
793 val
= gimple_phi_arg_def (phi
, i
);
794 if (!is_gimple_ip_invariant (val
))
796 info
->reason
= "non-invariant value from a case";
797 return false; /* Non-invariant argument. */
799 reloc
= initializer_constant_valid_p (val
, TREE_TYPE (val
));
800 if ((flag_pic
&& reloc
!= null_pointer_node
)
801 || (!flag_pic
&& reloc
== NULL_TREE
))
805 = "value from a case would need runtime relocations";
808 = "value from a case is not a valid initializer";
818 /* The following function allocates default_values, target_{in,out}_names and
819 constructors arrays. The last one is also populated with pointers to
820 vectors that will become constructors of new arrays. */
823 create_temp_arrays (struct switch_conv_info
*info
)
827 info
->default_values
= XCNEWVEC (tree
, info
->phi_count
* 3);
828 /* ??? Macros do not support multi argument templates in their
829 argument list. We create a typedef to work around that problem. */
830 typedef vec
<constructor_elt
, va_gc
> *vec_constructor_elt_gc
;
831 info
->constructors
= XCNEWVEC (vec_constructor_elt_gc
, info
->phi_count
);
832 info
->target_inbound_names
= info
->default_values
+ info
->phi_count
;
833 info
->target_outbound_names
= info
->target_inbound_names
+ info
->phi_count
;
834 for (i
= 0; i
< info
->phi_count
; i
++)
835 vec_alloc (info
->constructors
[i
], tree_to_uhwi (info
->range_size
) + 1);
838 /* Free the arrays created by create_temp_arrays(). The vectors that are
839 created by that function are not freed here, however, because they have
840 already become constructors and must be preserved. */
843 free_temp_arrays (struct switch_conv_info
*info
)
845 XDELETEVEC (info
->constructors
);
846 XDELETEVEC (info
->default_values
);
849 /* Populate the array of default values in the order of phi nodes.
850 DEFAULT_CASE is the CASE_LABEL_EXPR for the default switch branch. */
853 gather_default_values (tree default_case
, struct switch_conv_info
*info
)
856 basic_block bb
= label_to_block (CASE_LABEL (default_case
));
860 gcc_assert (CASE_LOW (default_case
) == NULL_TREE
);
862 if (bb
== info
->final_bb
)
863 e
= find_edge (info
->switch_bb
, bb
);
865 e
= single_succ_edge (bb
);
867 for (gsi
= gsi_start_phis (info
->final_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
869 gphi
*phi
= gsi
.phi ();
870 tree val
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
872 info
->default_values
[i
++] = val
;
876 /* The following function populates the vectors in the constructors array with
877 future contents of the static arrays. The vectors are populated in the
878 order of phi nodes. SWTCH is the switch statement being converted. */
881 build_constructors (gswitch
*swtch
, struct switch_conv_info
*info
)
883 unsigned i
, branch_num
= gimple_switch_num_labels (swtch
);
884 tree pos
= info
->range_min
;
886 for (i
= 1; i
< branch_num
; i
++)
888 tree cs
= gimple_switch_label (swtch
, i
);
889 basic_block bb
= label_to_block (CASE_LABEL (cs
));
895 if (bb
== info
->final_bb
)
896 e
= find_edge (info
->switch_bb
, bb
);
898 e
= single_succ_edge (bb
);
901 while (tree_int_cst_lt (pos
, CASE_LOW (cs
)))
904 for (k
= 0; k
< info
->phi_count
; k
++)
908 elt
.index
= int_const_binop (MINUS_EXPR
, pos
, info
->range_min
);
910 = unshare_expr_without_location (info
->default_values
[k
]);
911 info
->constructors
[k
]->quick_push (elt
);
914 pos
= int_const_binop (PLUS_EXPR
, pos
,
915 build_int_cst (TREE_TYPE (pos
), 1));
917 gcc_assert (tree_int_cst_equal (pos
, CASE_LOW (cs
)));
921 high
= CASE_HIGH (cs
);
923 high
= CASE_LOW (cs
);
924 for (gsi
= gsi_start_phis (info
->final_bb
);
925 !gsi_end_p (gsi
); gsi_next (&gsi
))
927 gphi
*phi
= gsi
.phi ();
928 tree val
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
929 tree low
= CASE_LOW (cs
);
936 elt
.index
= int_const_binop (MINUS_EXPR
, pos
, info
->range_min
);
937 elt
.value
= unshare_expr_without_location (val
);
938 info
->constructors
[j
]->quick_push (elt
);
940 pos
= int_const_binop (PLUS_EXPR
, pos
,
941 build_int_cst (TREE_TYPE (pos
), 1));
942 } while (!tree_int_cst_lt (high
, pos
)
943 && tree_int_cst_lt (low
, pos
));
949 /* If all values in the constructor vector are the same, return the value.
950 Otherwise return NULL_TREE. Not supposed to be called for empty
954 constructor_contains_same_values_p (vec
<constructor_elt
, va_gc
> *vec
)
957 tree prev
= NULL_TREE
;
958 constructor_elt
*elt
;
960 FOR_EACH_VEC_SAFE_ELT (vec
, i
, elt
)
964 else if (!operand_equal_p (elt
->value
, prev
, OEP_ONLY_CONST
))
970 /* Return type which should be used for array elements, either TYPE,
971 or for integral type some smaller integral type that can still hold
972 all the constants. */
975 array_value_type (gswitch
*swtch
, tree type
, int num
,
976 struct switch_conv_info
*info
)
978 unsigned int i
, len
= vec_safe_length (info
->constructors
[num
]);
979 constructor_elt
*elt
;
984 if (!INTEGRAL_TYPE_P (type
))
987 mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (TYPE_MODE (type
)));
988 if (GET_MODE_SIZE (TYPE_MODE (type
)) <= GET_MODE_SIZE (mode
))
991 if (len
< (optimize_bb_for_size_p (gimple_bb (swtch
)) ? 2 : 32))
994 FOR_EACH_VEC_SAFE_ELT (info
->constructors
[num
], i
, elt
)
998 if (TREE_CODE (elt
->value
) != INTEGER_CST
)
1004 unsigned int prec
= GET_MODE_BITSIZE (mode
);
1005 if (prec
> HOST_BITS_PER_WIDE_INT
)
1008 if (sign
>= 0 && cst
== wi::zext (cst
, prec
))
1010 if (sign
== 0 && cst
== wi::sext (cst
, prec
))
1015 if (sign
<= 0 && cst
== wi::sext (cst
, prec
))
1024 mode
= GET_MODE_WIDER_MODE (mode
);
1025 if (mode
== VOIDmode
1026 || GET_MODE_SIZE (mode
) >= GET_MODE_SIZE (TYPE_MODE (type
)))
1032 sign
= TYPE_UNSIGNED (type
) ? 1 : -1;
1033 smaller_type
= lang_hooks
.types
.type_for_mode (mode
, sign
>= 0);
1034 if (GET_MODE_SIZE (TYPE_MODE (type
))
1035 <= GET_MODE_SIZE (TYPE_MODE (smaller_type
)))
1038 return smaller_type
;
1041 /* Create an appropriate array type and declaration and assemble a static array
1042 variable. Also create a load statement that initializes the variable in
1043 question with a value from the static array. SWTCH is the switch statement
1044 being converted, NUM is the index to arrays of constructors, default values
1045 and target SSA names for this particular array. ARR_INDEX_TYPE is the type
1046 of the index of the new array, PHI is the phi node of the final BB that
1047 corresponds to the value that will be loaded from the created array. TIDX
1048 is an ssa name of a temporary variable holding the index for loads from the
1052 build_one_array (gswitch
*swtch
, int num
, tree arr_index_type
,
1053 gphi
*phi
, tree tidx
, struct switch_conv_info
*info
)
1057 gimple_stmt_iterator gsi
= gsi_for_stmt (swtch
);
1058 location_t loc
= gimple_location (swtch
);
1060 gcc_assert (info
->default_values
[num
]);
1062 name
= copy_ssa_name (PHI_RESULT (phi
));
1063 info
->target_inbound_names
[num
] = name
;
1065 cst
= constructor_contains_same_values_p (info
->constructors
[num
]);
1067 load
= gimple_build_assign (name
, cst
);
1070 tree array_type
, ctor
, decl
, value_type
, fetch
, default_type
;
1072 default_type
= TREE_TYPE (info
->default_values
[num
]);
1073 value_type
= array_value_type (swtch
, default_type
, num
, info
);
1074 array_type
= build_array_type (value_type
, arr_index_type
);
1075 if (default_type
!= value_type
)
1078 constructor_elt
*elt
;
1080 FOR_EACH_VEC_SAFE_ELT (info
->constructors
[num
], i
, elt
)
1081 elt
->value
= fold_convert (value_type
, elt
->value
);
1083 ctor
= build_constructor (array_type
, info
->constructors
[num
]);
1084 TREE_CONSTANT (ctor
) = true;
1085 TREE_STATIC (ctor
) = true;
1087 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, array_type
);
1088 TREE_STATIC (decl
) = 1;
1089 DECL_INITIAL (decl
) = ctor
;
1091 DECL_NAME (decl
) = create_tmp_var_name ("CSWTCH");
1092 DECL_ARTIFICIAL (decl
) = 1;
1093 DECL_IGNORED_P (decl
) = 1;
1094 TREE_CONSTANT (decl
) = 1;
1095 TREE_READONLY (decl
) = 1;
1096 DECL_IGNORED_P (decl
) = 1;
1097 varpool_node::finalize_decl (decl
);
1099 fetch
= build4 (ARRAY_REF
, value_type
, decl
, tidx
, NULL_TREE
,
1101 if (default_type
!= value_type
)
1103 fetch
= fold_convert (default_type
, fetch
);
1104 fetch
= force_gimple_operand_gsi (&gsi
, fetch
, true, NULL_TREE
,
1105 true, GSI_SAME_STMT
);
1107 load
= gimple_build_assign (name
, fetch
);
1110 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
1112 info
->arr_ref_last
= load
;
1115 /* Builds and initializes static arrays initialized with values gathered from
1116 the SWTCH switch statement. Also creates statements that load values from
1120 build_arrays (gswitch
*swtch
, struct switch_conv_info
*info
)
1122 tree arr_index_type
;
1123 tree tidx
, sub
, utype
;
1125 gimple_stmt_iterator gsi
;
1128 location_t loc
= gimple_location (swtch
);
1130 gsi
= gsi_for_stmt (swtch
);
1132 /* Make sure we do not generate arithmetics in a subrange. */
1133 utype
= TREE_TYPE (info
->index_expr
);
1134 if (TREE_TYPE (utype
))
1135 utype
= lang_hooks
.types
.type_for_mode (TYPE_MODE (TREE_TYPE (utype
)), 1);
1137 utype
= lang_hooks
.types
.type_for_mode (TYPE_MODE (utype
), 1);
1139 arr_index_type
= build_index_type (info
->range_size
);
1140 tidx
= make_ssa_name (utype
);
1141 sub
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
1142 fold_convert_loc (loc
, utype
, info
->index_expr
),
1143 fold_convert_loc (loc
, utype
, info
->range_min
));
1144 sub
= force_gimple_operand_gsi (&gsi
, sub
,
1145 false, NULL
, true, GSI_SAME_STMT
);
1146 stmt
= gimple_build_assign (tidx
, sub
);
1148 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
1150 info
->arr_ref_first
= stmt
;
1152 for (gpi
= gsi_start_phis (info
->final_bb
), i
= 0;
1153 !gsi_end_p (gpi
); gsi_next (&gpi
), i
++)
1154 build_one_array (swtch
, i
, arr_index_type
, gpi
.phi (), tidx
, info
);
1157 /* Generates and appropriately inserts loads of default values at the position
1158 given by BSI. Returns the last inserted statement. */
1161 gen_def_assigns (gimple_stmt_iterator
*gsi
, struct switch_conv_info
*info
)
1164 gassign
*assign
= NULL
;
1166 for (i
= 0; i
< info
->phi_count
; i
++)
1168 tree name
= copy_ssa_name (info
->target_inbound_names
[i
]);
1169 info
->target_outbound_names
[i
] = name
;
1170 assign
= gimple_build_assign (name
, info
->default_values
[i
]);
1171 gsi_insert_before (gsi
, assign
, GSI_SAME_STMT
);
1172 update_stmt (assign
);
1177 /* Deletes the unused bbs and edges that now contain the switch statement and
1178 its empty branch bbs. BBD is the now dead BB containing the original switch
1179 statement, FINAL is the last BB of the converted switch statement (in terms
1183 prune_bbs (basic_block bbd
, basic_block final
)
1188 for (ei
= ei_start (bbd
->succs
); (e
= ei_safe_edge (ei
)); )
1194 delete_basic_block (bb
);
1196 delete_basic_block (bbd
);
1199 /* Add values to phi nodes in final_bb for the two new edges. E1F is the edge
1200 from the basic block loading values from an array and E2F from the basic
1201 block loading default values. BBF is the last switch basic block (see the
1202 bbf description in the comment below). */
1205 fix_phi_nodes (edge e1f
, edge e2f
, basic_block bbf
,
1206 struct switch_conv_info
*info
)
1211 for (gsi
= gsi_start_phis (bbf
), i
= 0;
1212 !gsi_end_p (gsi
); gsi_next (&gsi
), i
++)
1214 gphi
*phi
= gsi
.phi ();
1215 add_phi_arg (phi
, info
->target_inbound_names
[i
], e1f
, UNKNOWN_LOCATION
);
1216 add_phi_arg (phi
, info
->target_outbound_names
[i
], e2f
, UNKNOWN_LOCATION
);
1220 /* Creates a check whether the switch expression value actually falls into the
1221 range given by all the cases. If it does not, the temporaries are loaded
1222 with default values instead. SWTCH is the switch statement being converted.
1224 bb0 is the bb with the switch statement, however, we'll end it with a
1227 bb1 is the bb to be used when the range check went ok. It is derived from
1230 bb2 is the bb taken when the expression evaluated outside of the range
1231 covered by the created arrays. It is populated by loads of default
1234 bbF is a fall through for both bb1 and bb2 and contains exactly what
1235 originally followed the switch statement.
1237 bbD contains the switch statement (in the end). It is unreachable but we
1238 still need to strip off its edges.
1242 gen_inbound_check (gswitch
*swtch
, struct switch_conv_info
*info
)
1244 tree label_decl1
= create_artificial_label (UNKNOWN_LOCATION
);
1245 tree label_decl2
= create_artificial_label (UNKNOWN_LOCATION
);
1246 tree label_decl3
= create_artificial_label (UNKNOWN_LOCATION
);
1247 glabel
*label1
, *label2
, *label3
;
1253 gassign
*last_assign
;
1254 gimple_stmt_iterator gsi
;
1255 basic_block bb0
, bb1
, bb2
, bbf
, bbd
;
1256 edge e01
, e02
, e21
, e1d
, e1f
, e2f
;
1257 location_t loc
= gimple_location (swtch
);
1259 gcc_assert (info
->default_values
);
1261 bb0
= gimple_bb (swtch
);
1263 tidx
= gimple_assign_lhs (info
->arr_ref_first
);
1264 utype
= TREE_TYPE (tidx
);
1266 /* (end of) block 0 */
1267 gsi
= gsi_for_stmt (info
->arr_ref_first
);
1270 bound
= fold_convert_loc (loc
, utype
, info
->range_size
);
1271 cond_stmt
= gimple_build_cond (LE_EXPR
, tidx
, bound
, NULL_TREE
, NULL_TREE
);
1272 gsi_insert_before (&gsi
, cond_stmt
, GSI_SAME_STMT
);
1273 update_stmt (cond_stmt
);
1276 label2
= gimple_build_label (label_decl2
);
1277 gsi_insert_before (&gsi
, label2
, GSI_SAME_STMT
);
1278 last_assign
= gen_def_assigns (&gsi
, info
);
1281 label1
= gimple_build_label (label_decl1
);
1282 gsi_insert_before (&gsi
, label1
, GSI_SAME_STMT
);
1285 gsi
= gsi_start_bb (info
->final_bb
);
1286 label3
= gimple_build_label (label_decl3
);
1287 gsi_insert_before (&gsi
, label3
, GSI_SAME_STMT
);
1290 e02
= split_block (bb0
, cond_stmt
);
1293 e21
= split_block (bb2
, last_assign
);
1297 e1d
= split_block (bb1
, info
->arr_ref_last
);
1301 /* flags and profiles of the edge for in-range values */
1302 e01
= make_edge (bb0
, bb1
, EDGE_TRUE_VALUE
);
1303 e01
->probability
= REG_BR_PROB_BASE
- info
->default_prob
;
1304 e01
->count
= info
->other_count
;
1306 /* flags and profiles of the edge taking care of out-of-range values */
1307 e02
->flags
&= ~EDGE_FALLTHRU
;
1308 e02
->flags
|= EDGE_FALSE_VALUE
;
1309 e02
->probability
= info
->default_prob
;
1310 e02
->count
= info
->default_count
;
1312 bbf
= info
->final_bb
;
1314 e1f
= make_edge (bb1
, bbf
, EDGE_FALLTHRU
);
1315 e1f
->probability
= REG_BR_PROB_BASE
;
1316 e1f
->count
= info
->other_count
;
1318 e2f
= make_edge (bb2
, bbf
, EDGE_FALLTHRU
);
1319 e2f
->probability
= REG_BR_PROB_BASE
;
1320 e2f
->count
= info
->default_count
;
1322 /* frequencies of the new BBs */
1323 bb1
->frequency
= EDGE_FREQUENCY (e01
);
1324 bb2
->frequency
= EDGE_FREQUENCY (e02
);
1325 bbf
->frequency
= EDGE_FREQUENCY (e1f
) + EDGE_FREQUENCY (e2f
);
1327 /* Tidy blocks that have become unreachable. */
1328 prune_bbs (bbd
, info
->final_bb
);
1330 /* Fixup the PHI nodes in bbF. */
1331 fix_phi_nodes (e1f
, e2f
, bbf
, info
);
1333 /* Fix the dominator tree, if it is available. */
1334 if (dom_info_available_p (CDI_DOMINATORS
))
1336 vec
<basic_block
> bbs_to_fix_dom
;
1338 set_immediate_dominator (CDI_DOMINATORS
, bb1
, bb0
);
1339 set_immediate_dominator (CDI_DOMINATORS
, bb2
, bb0
);
1340 if (! get_immediate_dominator (CDI_DOMINATORS
, bbf
))
1341 /* If bbD was the immediate dominator ... */
1342 set_immediate_dominator (CDI_DOMINATORS
, bbf
, bb0
);
1344 bbs_to_fix_dom
.create (4);
1345 bbs_to_fix_dom
.quick_push (bb0
);
1346 bbs_to_fix_dom
.quick_push (bb1
);
1347 bbs_to_fix_dom
.quick_push (bb2
);
1348 bbs_to_fix_dom
.quick_push (bbf
);
1350 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
1351 bbs_to_fix_dom
.release ();
1355 /* The following function is invoked on every switch statement (the current one
1356 is given in SWTCH) and runs the individual phases of switch conversion on it
1357 one after another until one fails or the conversion is completed.
1358 Returns NULL on success, or a pointer to a string with the reason why the
1359 conversion failed. */
1362 process_switch (gswitch
*swtch
)
1364 struct switch_conv_info info
;
1366 /* Group case labels so that we get the right results from the heuristics
1367 that decide on the code generation approach for this switch. */
1368 group_case_labels_stmt (swtch
);
1370 /* If this switch is now a degenerate case with only a default label,
1371 there is nothing left for us to do. */
1372 if (gimple_switch_num_labels (swtch
) < 2)
1373 return "switch is a degenerate case";
1375 collect_switch_conv_info (swtch
, &info
);
1377 /* No error markers should reach here (they should be filtered out
1378 during gimplification). */
1379 gcc_checking_assert (TREE_TYPE (info
.index_expr
) != error_mark_node
);
1381 /* A switch on a constant should have been optimized in tree-cfg-cleanup. */
1382 gcc_checking_assert (! TREE_CONSTANT (info
.index_expr
));
1384 if (info
.uniq
<= MAX_CASE_BIT_TESTS
)
1386 if (expand_switch_using_bit_tests_p (info
.range_size
,
1387 info
.uniq
, info
.count
,
1388 optimize_bb_for_speed_p
1389 (gimple_bb (swtch
))))
1392 fputs (" expanding as bit test is preferable\n", dump_file
);
1393 emit_case_bit_tests (swtch
, info
.index_expr
, info
.range_min
,
1394 info
.range_size
, info
.range_max
);
1395 loops_state_set (LOOPS_NEED_FIXUP
);
1400 /* This will be expanded as a decision tree in stmt.c:expand_case. */
1401 return " expanding as jumps is preferable";
1404 /* If there is no common successor, we cannot do the transformation. */
1405 if (! info
.final_bb
)
1406 return "no common successor to all case label target blocks found";
1408 /* Check the case label values are within reasonable range: */
1409 if (!check_range (&info
))
1411 gcc_assert (info
.reason
);
1415 /* For all the cases, see whether they are empty, the assignments they
1416 represent constant and so on... */
1417 if (! check_all_empty_except_final (&info
))
1419 gcc_assert (info
.reason
);
1422 if (!check_final_bb (&info
))
1424 gcc_assert (info
.reason
);
1428 /* At this point all checks have passed and we can proceed with the
1431 create_temp_arrays (&info
);
1432 gather_default_values (gimple_switch_default_label (swtch
), &info
);
1433 build_constructors (swtch
, &info
);
1435 build_arrays (swtch
, &info
); /* Build the static arrays and assignments. */
1436 gen_inbound_check (swtch
, &info
); /* Build the bounds check. */
1439 free_temp_arrays (&info
);
1443 /* The main function of the pass scans statements for switches and invokes
1444 process_switch on them. */
1448 const pass_data pass_data_convert_switch
=
1450 GIMPLE_PASS
, /* type */
1451 "switchconv", /* name */
1452 OPTGROUP_NONE
, /* optinfo_flags */
1453 TV_TREE_SWITCH_CONVERSION
, /* tv_id */
1454 ( PROP_cfg
| PROP_ssa
), /* properties_required */
1455 0, /* properties_provided */
1456 0, /* properties_destroyed */
1457 0, /* todo_flags_start */
1458 TODO_update_ssa
, /* todo_flags_finish */
1461 class pass_convert_switch
: public gimple_opt_pass
1464 pass_convert_switch (gcc::context
*ctxt
)
1465 : gimple_opt_pass (pass_data_convert_switch
, ctxt
)
1468 /* opt_pass methods: */
1469 virtual bool gate (function
*) { return flag_tree_switch_conversion
!= 0; }
1470 virtual unsigned int execute (function
*);
1472 }; // class pass_convert_switch
1475 pass_convert_switch::execute (function
*fun
)
1479 FOR_EACH_BB_FN (bb
, fun
)
1481 const char *failure_reason
;
1482 gimple stmt
= last_stmt (bb
);
1483 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1487 expanded_location loc
= expand_location (gimple_location (stmt
));
1489 fprintf (dump_file
, "beginning to process the following "
1490 "SWITCH statement (%s:%d) : ------- \n",
1491 loc
.file
, loc
.line
);
1492 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
1493 putc ('\n', dump_file
);
1496 failure_reason
= process_switch (as_a
<gswitch
*> (stmt
));
1497 if (! failure_reason
)
1501 fputs ("Switch converted\n", dump_file
);
1502 fputs ("--------------------------------\n", dump_file
);
1505 /* Make no effort to update the post-dominator tree. It is actually not
1506 that hard for the transformations we have performed, but it is not
1507 supported by iterate_fix_dominators. */
1508 free_dominance_info (CDI_POST_DOMINATORS
);
1514 fputs ("Bailing out - ", dump_file
);
1515 fputs (failure_reason
, dump_file
);
1516 fputs ("\n--------------------------------\n", dump_file
);
1528 make_pass_convert_switch (gcc::context
*ctxt
)
1530 return new pass_convert_switch (ctxt
);