1 /* Switch Conversion converts variable initializations based on switch
2 statements to initializations from a static array.
3 Copyright (C) 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Martin Jambor <jamborm@suse.cz>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any
13 GCC is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 Switch initialization conversion
26 The following pass changes simple initializations of scalars in a switch
27 statement into initializations from a static array. Obviously, the values must
28 be constant and known at compile time and a default branch must be
29 provided. For example, the following code:
52 a_5 = PHI <a_1, a_2, a_3, a_4>
53 b_5 = PHI <b_1, b_2, b_3, b_4>
58 static const int = CSWTCH01[] = {6, 6, 5, 1, 1, 1, 1, 1, 1, 1, 1, 4};
59 static const int = CSWTCH02[] = {8, 8, 9, 16, 16, 16, 16, 16, 16, 16,
62 if (((unsigned) argc) - 1 < 11)
64 a_6 = CSWTCH02[argc - 1];
65 b_6 = CSWTCH01[argc - 1];
75 There are further constraints. Specifically, the range of values across all
76 case labels must not be bigger than SWITCH_CONVERSION_BRANCH_RATIO (default
77 eight) times the number of the actual switch branches. */
81 #include "coretypes.h"
89 #include "basic-block.h"
90 #include "tree-flow.h"
91 #include "tree-flow-inline.h"
92 #include "tree-ssa-operands.h"
95 #include "tree-pass.h"
96 #include "gimple-pretty-print.h"
97 #include "tree-dump.h"
100 /* The main structure of the pass. */
101 struct switch_conv_info
103 /* The expression used to decide the switch branch. (It is subsequently used
104 as the index to the created array.) */
107 /* The following integer constants store the minimum value covered by the
111 /* The difference between the above two numbers, i.e. The size of the array
112 that would have to be created by the transformation. */
115 /* Basic block that contains the actual SWITCH_EXPR. */
116 basic_block switch_bb
;
118 /* All branches of the switch statement must have a single successor stored in
119 the following variable. */
120 basic_block final_bb
;
122 /* Number of phi nodes in the final bb (that we'll be replacing). */
125 /* Array of default values, in the same order as phi nodes. */
126 tree
*default_values
;
128 /* Constructors of new static arrays. */
129 VEC (constructor_elt
, gc
) **constructors
;
131 /* Array of ssa names that are initialized with a value from a new static
133 tree
*target_inbound_names
;
135 /* Array of ssa names that are initialized with the default value if the
136 switch expression is out of range. */
137 tree
*target_outbound_names
;
139 /* The probability of the default edge in the replaced switch. */
142 /* The count of the default edge in the replaced switch. */
143 gcov_type default_count
;
145 /* Combined count of all other (non-default) edges in the replaced switch. */
146 gcov_type other_count
;
148 /* The first load statement that loads a temporary from a new static array.
150 gimple arr_ref_first
;
152 /* The last load statement that loads a temporary from a new static array. */
155 /* String reason why the case wasn't a good candidate that is written to the
156 dump file, if there is one. */
160 /* Global pass info. */
161 static struct switch_conv_info info
;
164 /* Checks whether the range given by individual case statements of the SWTCH
165 switch statement isn't too big and whether the number of branches actually
166 satisfies the size of the new array. */
169 check_range (gimple swtch
)
171 tree min_case
, max_case
;
172 unsigned int branch_num
= gimple_switch_num_labels (swtch
);
175 /* The gimplifier has already sorted the cases by CASE_LOW and ensured there
176 is a default label which is the last in the vector. */
178 min_case
= gimple_switch_label (swtch
, 1);
179 info
.range_min
= CASE_LOW (min_case
);
181 gcc_assert (branch_num
> 1);
182 gcc_assert (CASE_LOW (gimple_switch_label (swtch
, 0)) == NULL_TREE
);
183 max_case
= gimple_switch_label (swtch
, branch_num
- 1);
184 if (CASE_HIGH (max_case
) != NULL_TREE
)
185 range_max
= CASE_HIGH (max_case
);
187 range_max
= CASE_LOW (max_case
);
189 gcc_assert (info
.range_min
);
190 gcc_assert (range_max
);
192 info
.range_size
= int_const_binop (MINUS_EXPR
, range_max
, info
.range_min
, 0);
194 gcc_assert (info
.range_size
);
195 if (!host_integerp (info
.range_size
, 1))
197 info
.reason
= "index range way too large or otherwise unusable.\n";
201 if ((unsigned HOST_WIDE_INT
) tree_low_cst (info
.range_size
, 1)
202 > ((unsigned) branch_num
* SWITCH_CONVERSION_BRANCH_RATIO
))
204 info
.reason
= "the maximum range-branch ratio exceeded.\n";
211 /* Checks the given CS switch case whether it is suitable for conversion
212 (whether all but the default basic blocks are empty and so on). If it is,
213 adds the case to the branch list along with values for the defined variables
214 and returns true. Otherwise returns false. */
217 check_process_case (tree cs
)
220 basic_block label_bb
, following_bb
;
223 ldecl
= CASE_LABEL (cs
);
224 label_bb
= label_to_block (ldecl
);
226 e
= find_edge (info
.switch_bb
, label_bb
);
229 if (CASE_LOW (cs
) == NULL_TREE
)
231 /* Default branch. */
232 info
.default_prob
= e
->probability
;
233 info
.default_count
= e
->count
;
236 info
.other_count
+= e
->count
;
240 info
.reason
= " Bad case - cs BB label is NULL\n";
244 if (!single_pred_p (label_bb
))
246 if (info
.final_bb
&& info
.final_bb
!= label_bb
)
248 info
.reason
= " Bad case - a non-final BB has two predecessors\n";
249 return false; /* sth complex going on in this branch */
252 following_bb
= label_bb
;
256 if (!empty_block_p (label_bb
))
258 info
.reason
= " Bad case - a non-final BB not empty\n";
262 e
= single_succ_edge (label_bb
);
263 following_bb
= single_succ (label_bb
);
267 info
.final_bb
= following_bb
;
268 else if (info
.final_bb
!= following_bb
)
270 info
.reason
= " Bad case - different final BB\n";
271 return false; /* the only successor is not common for all the branches */
277 /* This function checks whether all required values in phi nodes in final_bb
278 are constants. Required values are those that correspond to a basic block
279 which is a part of the examined switch statement. It returns true if the
280 phi nodes are OK, otherwise false. */
283 check_final_bb (void)
285 gimple_stmt_iterator gsi
;
288 for (gsi
= gsi_start_phis (info
.final_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
290 gimple phi
= gsi_stmt (gsi
);
295 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
297 basic_block bb
= gimple_phi_arg_edge (phi
, i
)->src
;
299 if (bb
== info
.switch_bb
300 || (single_pred_p (bb
) && single_pred (bb
) == info
.switch_bb
))
304 val
= gimple_phi_arg_def (phi
, i
);
305 if (!is_gimple_ip_invariant (val
))
307 info
.reason
= " Non-invariant value from a case\n";
308 return false; /* Non-invariant argument. */
310 reloc
= initializer_constant_valid_p (val
, TREE_TYPE (val
));
311 if ((flag_pic
&& reloc
!= null_pointer_node
)
312 || (!flag_pic
&& reloc
== NULL_TREE
))
316 = " Value from a case would need runtime relocations\n";
319 = " Value from a case is not a valid initializer\n";
329 /* The following function allocates default_values, target_{in,out}_names and
330 constructors arrays. The last one is also populated with pointers to
331 vectors that will become constructors of new arrays. */
334 create_temp_arrays (void)
338 info
.default_values
= (tree
*) xcalloc (info
.phi_count
, sizeof (tree
));
339 info
.constructors
= (VEC (constructor_elt
, gc
) **) xcalloc (info
.phi_count
,
341 info
.target_inbound_names
= (tree
*) xcalloc (info
.phi_count
, sizeof (tree
));
342 info
.target_outbound_names
= (tree
*) xcalloc (info
.phi_count
,
345 for (i
= 0; i
< info
.phi_count
; i
++)
347 = VEC_alloc (constructor_elt
, gc
, tree_low_cst (info
.range_size
, 1) + 1);
350 /* Free the arrays created by create_temp_arrays(). The vectors that are
351 created by that function are not freed here, however, because they have
352 already become constructors and must be preserved. */
355 free_temp_arrays (void)
357 free (info
.constructors
);
358 free (info
.default_values
);
359 free (info
.target_inbound_names
);
360 free (info
.target_outbound_names
);
363 /* Populate the array of default values in the order of phi nodes.
364 DEFAULT_CASE is the CASE_LABEL_EXPR for the default switch branch. */
367 gather_default_values (tree default_case
)
369 gimple_stmt_iterator gsi
;
370 basic_block bb
= label_to_block (CASE_LABEL (default_case
));
374 gcc_assert (CASE_LOW (default_case
) == NULL_TREE
);
376 if (bb
== info
.final_bb
)
377 e
= find_edge (info
.switch_bb
, bb
);
379 e
= single_succ_edge (bb
);
381 for (gsi
= gsi_start_phis (info
.final_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
383 gimple phi
= gsi_stmt (gsi
);
384 tree val
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
386 info
.default_values
[i
++] = val
;
390 /* The following function populates the vectors in the constructors array with
391 future contents of the static arrays. The vectors are populated in the
392 order of phi nodes. SWTCH is the switch statement being converted. */
395 build_constructors (gimple swtch
)
397 unsigned i
, branch_num
= gimple_switch_num_labels (swtch
);
398 tree pos
= info
.range_min
;
400 for (i
= 1; i
< branch_num
; i
++)
402 tree cs
= gimple_switch_label (swtch
, i
);
403 basic_block bb
= label_to_block (CASE_LABEL (cs
));
406 gimple_stmt_iterator gsi
;
409 if (bb
== info
.final_bb
)
410 e
= find_edge (info
.switch_bb
, bb
);
412 e
= single_succ_edge (bb
);
415 while (tree_int_cst_lt (pos
, CASE_LOW (cs
)))
418 for (k
= 0; k
< info
.phi_count
; k
++)
420 constructor_elt
*elt
;
422 elt
= VEC_quick_push (constructor_elt
,
423 info
.constructors
[k
], NULL
);
424 elt
->index
= int_const_binop (MINUS_EXPR
, pos
,
426 elt
->value
= info
.default_values
[k
];
429 pos
= int_const_binop (PLUS_EXPR
, pos
, integer_one_node
, 0);
431 gcc_assert (tree_int_cst_equal (pos
, CASE_LOW (cs
)));
435 high
= CASE_HIGH (cs
);
437 high
= CASE_LOW (cs
);
438 for (gsi
= gsi_start_phis (info
.final_bb
);
439 !gsi_end_p (gsi
); gsi_next (&gsi
))
441 gimple phi
= gsi_stmt (gsi
);
442 tree val
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
443 tree low
= CASE_LOW (cs
);
448 constructor_elt
*elt
;
450 elt
= VEC_quick_push (constructor_elt
,
451 info
.constructors
[j
], NULL
);
452 elt
->index
= int_const_binop (MINUS_EXPR
, pos
, info
.range_min
, 0);
455 pos
= int_const_binop (PLUS_EXPR
, pos
, integer_one_node
, 0);
456 } while (!tree_int_cst_lt (high
, pos
)
457 && tree_int_cst_lt (low
, pos
));
463 /* If all values in the constructor vector are the same, return the value.
464 Otherwise return NULL_TREE. Not supposed to be called for empty
468 constructor_contains_same_values_p (VEC (constructor_elt
, gc
) *vec
)
470 int i
, len
= VEC_length (constructor_elt
, vec
);
471 tree prev
= NULL_TREE
;
473 for (i
= 0; i
< len
; i
++)
475 constructor_elt
*elt
= VEC_index (constructor_elt
, vec
, i
);
479 else if (!operand_equal_p (elt
->value
, prev
, OEP_ONLY_CONST
))
485 /* Create an appropriate array type and declaration and assemble a static array
486 variable. Also create a load statement that initializes the variable in
487 question with a value from the static array. SWTCH is the switch statement
488 being converted, NUM is the index to arrays of constructors, default values
489 and target SSA names for this particular array. ARR_INDEX_TYPE is the type
490 of the index of the new array, PHI is the phi node of the final BB that
491 corresponds to the value that will be loaded from the created array. TIDX
492 is an ssa name of a temporary variable holding the index for loads from the
496 build_one_array (gimple swtch
, int num
, tree arr_index_type
, gimple phi
,
501 gimple_stmt_iterator gsi
= gsi_for_stmt (swtch
);
502 location_t loc
= gimple_location (swtch
);
504 gcc_assert (info
.default_values
[num
]);
506 name
= make_ssa_name (SSA_NAME_VAR (PHI_RESULT (phi
)), NULL
);
507 info
.target_inbound_names
[num
] = name
;
509 cst
= constructor_contains_same_values_p (info
.constructors
[num
]);
511 load
= gimple_build_assign (name
, cst
);
514 tree array_type
, ctor
, decl
, value_type
, fetch
;
516 value_type
= TREE_TYPE (info
.default_values
[num
]);
517 array_type
= build_array_type (value_type
, arr_index_type
);
518 ctor
= build_constructor (array_type
, info
.constructors
[num
]);
519 TREE_CONSTANT (ctor
) = true;
521 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, array_type
);
522 TREE_STATIC (decl
) = 1;
523 DECL_INITIAL (decl
) = ctor
;
525 DECL_NAME (decl
) = create_tmp_var_name ("CSWTCH");
526 DECL_ARTIFICIAL (decl
) = 1;
527 TREE_CONSTANT (decl
) = 1;
528 TREE_READONLY (decl
) = 1;
529 add_referenced_var (decl
);
530 varpool_mark_needed_node (varpool_node (decl
));
531 varpool_finalize_decl (decl
);
533 fetch
= build4 (ARRAY_REF
, value_type
, decl
, tidx
, NULL_TREE
,
535 load
= gimple_build_assign (name
, fetch
);
538 SSA_NAME_DEF_STMT (name
) = load
;
539 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
541 info
.arr_ref_last
= load
;
544 /* Builds and initializes static arrays initialized with values gathered from
545 the SWTCH switch statement. Also creates statements that load values from
549 build_arrays (gimple swtch
)
554 gimple_stmt_iterator gsi
;
556 location_t loc
= gimple_location (swtch
);
558 gsi
= gsi_for_stmt (swtch
);
560 arr_index_type
= build_index_type (info
.range_size
);
561 tmp
= create_tmp_var (TREE_TYPE (info
.index_expr
), "csti");
562 add_referenced_var (tmp
);
563 tidx
= make_ssa_name (tmp
, NULL
);
564 sub
= fold_build2_loc (loc
, MINUS_EXPR
,
565 TREE_TYPE (info
.index_expr
), info
.index_expr
,
566 fold_convert_loc (loc
, TREE_TYPE (info
.index_expr
),
568 sub
= force_gimple_operand_gsi (&gsi
, sub
,
569 false, NULL
, true, GSI_SAME_STMT
);
570 stmt
= gimple_build_assign (tidx
, sub
);
571 SSA_NAME_DEF_STMT (tidx
) = stmt
;
573 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
575 info
.arr_ref_first
= stmt
;
577 for (gsi
= gsi_start_phis (info
.final_bb
), i
= 0;
578 !gsi_end_p (gsi
); gsi_next (&gsi
), i
++)
579 build_one_array (swtch
, i
, arr_index_type
, gsi_stmt (gsi
), tidx
);
582 /* Generates and appropriately inserts loads of default values at the position
583 given by BSI. Returns the last inserted statement. */
586 gen_def_assigns (gimple_stmt_iterator
*gsi
)
589 gimple assign
= NULL
;
591 for (i
= 0; i
< info
.phi_count
; i
++)
594 = make_ssa_name (SSA_NAME_VAR (info
.target_inbound_names
[i
]), NULL
);
596 info
.target_outbound_names
[i
] = name
;
597 assign
= gimple_build_assign (name
, info
.default_values
[i
]);
598 SSA_NAME_DEF_STMT (name
) = assign
;
599 gsi_insert_before (gsi
, assign
, GSI_SAME_STMT
);
600 update_stmt (assign
);
605 /* Deletes the unused bbs and edges that now contain the switch statement and
606 its empty branch bbs. BBD is the now dead BB containing the original switch
607 statement, FINAL is the last BB of the converted switch statement (in terms
611 prune_bbs (basic_block bbd
, basic_block final
)
616 for (ei
= ei_start (bbd
->succs
); (e
= ei_safe_edge (ei
)); )
622 delete_basic_block (bb
);
624 delete_basic_block (bbd
);
627 /* Add values to phi nodes in final_bb for the two new edges. E1F is the edge
628 from the basic block loading values from an array and E2F from the basic
629 block loading default values. BBF is the last switch basic block (see the
630 bbf description in the comment below). */
633 fix_phi_nodes (edge e1f
, edge e2f
, basic_block bbf
)
635 gimple_stmt_iterator gsi
;
638 for (gsi
= gsi_start_phis (bbf
), i
= 0;
639 !gsi_end_p (gsi
); gsi_next (&gsi
), i
++)
641 gimple phi
= gsi_stmt (gsi
);
642 add_phi_arg (phi
, info
.target_inbound_names
[i
], e1f
, UNKNOWN_LOCATION
);
643 add_phi_arg (phi
, info
.target_outbound_names
[i
], e2f
, UNKNOWN_LOCATION
);
648 /* Creates a check whether the switch expression value actually falls into the
649 range given by all the cases. If it does not, the temporaries are loaded
650 with default values instead. SWTCH is the switch statement being converted.
652 bb0 is the bb with the switch statement, however, we'll end it with a
655 bb1 is the bb to be used when the range check went ok. It is derived from
658 bb2 is the bb taken when the expression evaluated outside of the range
659 covered by the created arrays. It is populated by loads of default
662 bbF is a fall through for both bb1 and bb2 and contains exactly what
663 originally followed the switch statement.
665 bbD contains the switch statement (in the end). It is unreachable but we
666 still need to strip off its edges.
670 gen_inbound_check (gimple swtch
)
672 tree label_decl1
= create_artificial_label (UNKNOWN_LOCATION
);
673 tree label_decl2
= create_artificial_label (UNKNOWN_LOCATION
);
674 tree label_decl3
= create_artificial_label (UNKNOWN_LOCATION
);
675 gimple label1
, label2
, label3
;
678 tree tmp_u_1
, tmp_u_2
, tmp_u_var
;
680 gimple cast_assign
, minus_assign
;
687 gimple_stmt_iterator gsi
;
688 basic_block bb0
, bb1
, bb2
, bbf
, bbd
;
689 edge e01
, e02
, e21
, e1d
, e1f
, e2f
;
690 location_t loc
= gimple_location (swtch
);
692 gcc_assert (info
.default_values
);
693 bb0
= gimple_bb (swtch
);
695 /* Make sure we do not generate arithmetics in a subrange. */
696 if (TREE_TYPE (TREE_TYPE (info
.index_expr
)))
697 utype
= unsigned_type_for (TREE_TYPE (TREE_TYPE (info
.index_expr
)));
699 utype
= unsigned_type_for (TREE_TYPE (info
.index_expr
));
701 /* (end of) block 0 */
702 gsi
= gsi_for_stmt (info
.arr_ref_first
);
703 tmp_u_var
= create_tmp_var (utype
, "csui");
704 add_referenced_var (tmp_u_var
);
705 tmp_u_1
= make_ssa_name (tmp_u_var
, NULL
);
707 cast
= fold_convert_loc (loc
, utype
, info
.index_expr
);
708 cast_assign
= gimple_build_assign (tmp_u_1
, cast
);
709 SSA_NAME_DEF_STMT (tmp_u_1
) = cast_assign
;
710 gsi_insert_before (&gsi
, cast_assign
, GSI_SAME_STMT
);
711 update_stmt (cast_assign
);
713 ulb
= fold_convert_loc (loc
, utype
, info
.range_min
);
714 minus
= fold_build2_loc (loc
, MINUS_EXPR
, utype
, tmp_u_1
, ulb
);
715 minus
= force_gimple_operand_gsi (&gsi
, minus
, false, NULL
, true,
717 tmp_u_2
= make_ssa_name (tmp_u_var
, NULL
);
718 minus_assign
= gimple_build_assign (tmp_u_2
, minus
);
719 SSA_NAME_DEF_STMT (tmp_u_2
) = minus_assign
;
720 gsi_insert_before (&gsi
, minus_assign
, GSI_SAME_STMT
);
721 update_stmt (minus_assign
);
723 bound
= fold_convert_loc (loc
, utype
, info
.range_size
);
724 cond_stmt
= gimple_build_cond (LE_EXPR
, tmp_u_2
, bound
, NULL_TREE
, NULL_TREE
);
725 gsi_insert_before (&gsi
, cond_stmt
, GSI_SAME_STMT
);
726 update_stmt (cond_stmt
);
729 gsi
= gsi_for_stmt (info
.arr_ref_first
);
730 label2
= gimple_build_label (label_decl2
);
731 gsi_insert_before (&gsi
, label2
, GSI_SAME_STMT
);
732 last_assign
= gen_def_assigns (&gsi
);
735 gsi
= gsi_for_stmt (info
.arr_ref_first
);
736 label1
= gimple_build_label (label_decl1
);
737 gsi_insert_before (&gsi
, label1
, GSI_SAME_STMT
);
740 gsi
= gsi_start_bb (info
.final_bb
);
741 label3
= gimple_build_label (label_decl3
);
742 gsi_insert_before (&gsi
, label3
, GSI_SAME_STMT
);
745 e02
= split_block (bb0
, cond_stmt
);
748 e21
= split_block (bb2
, last_assign
);
752 e1d
= split_block (bb1
, info
.arr_ref_last
);
756 /* flags and profiles of the edge for in-range values */
757 e01
= make_edge (bb0
, bb1
, EDGE_TRUE_VALUE
);
758 e01
->probability
= REG_BR_PROB_BASE
- info
.default_prob
;
759 e01
->count
= info
.other_count
;
761 /* flags and profiles of the edge taking care of out-of-range values */
762 e02
->flags
&= ~EDGE_FALLTHRU
;
763 e02
->flags
|= EDGE_FALSE_VALUE
;
764 e02
->probability
= info
.default_prob
;
765 e02
->count
= info
.default_count
;
769 e1f
= make_edge (bb1
, bbf
, EDGE_FALLTHRU
);
770 e1f
->probability
= REG_BR_PROB_BASE
;
771 e1f
->count
= info
.other_count
;
773 e2f
= make_edge (bb2
, bbf
, EDGE_FALLTHRU
);
774 e2f
->probability
= REG_BR_PROB_BASE
;
775 e2f
->count
= info
.default_count
;
777 /* frequencies of the new BBs */
778 bb1
->frequency
= EDGE_FREQUENCY (e01
);
779 bb2
->frequency
= EDGE_FREQUENCY (e02
);
780 bbf
->frequency
= EDGE_FREQUENCY (e1f
) + EDGE_FREQUENCY (e2f
);
782 prune_bbs (bbd
, info
.final_bb
); /* To keep calc_dfs_tree() in dominance.c
785 fix_phi_nodes (e1f
, e2f
, bbf
);
787 free_dominance_info (CDI_DOMINATORS
);
788 free_dominance_info (CDI_POST_DOMINATORS
);
791 /* The following function is invoked on every switch statement (the current one
792 is given in SWTCH) and runs the individual phases of switch conversion on it
793 one after another until one fails or the conversion is completed. */
796 process_switch (gimple swtch
)
798 unsigned int i
, branch_num
= gimple_switch_num_labels (swtch
);
801 /* Operand 2 is either NULL_TREE or a vector of cases (stmt.c). */
804 info
.reason
= "switch has no labels\n";
808 info
.final_bb
= NULL
;
809 info
.switch_bb
= gimple_bb (swtch
);
810 info
.index_expr
= gimple_switch_index (swtch
);
811 index_type
= TREE_TYPE (info
.index_expr
);
812 info
.arr_ref_first
= NULL
;
813 info
.arr_ref_last
= NULL
;
814 info
.default_prob
= 0;
815 info
.default_count
= 0;
816 info
.other_count
= 0;
818 /* An ERROR_MARK occurs for various reasons including invalid data type.
819 (comment from stmt.c) */
820 if (index_type
== error_mark_node
)
822 info
.reason
= "index error.\n";
826 /* Check the case label values are within reasonable range: */
827 if (!check_range (swtch
))
830 /* For all the cases, see whether they are empty, the assignments they
831 represent constant and so on... */
832 for (i
= 0; i
< branch_num
; i
++)
833 if (!check_process_case (gimple_switch_label (swtch
, i
)))
836 fprintf (dump_file
, "Processing of case %i failed\n", i
);
840 if (!check_final_bb ())
843 /* At this point all checks have passed and we can proceed with the
846 create_temp_arrays ();
847 gather_default_values (gimple_switch_label (swtch
, 0));
848 build_constructors (swtch
);
850 build_arrays (swtch
); /* Build the static arrays and assignments. */
851 gen_inbound_check (swtch
); /* Build the bounds check. */
858 /* The main function of the pass scans statements for switches and invokes
859 process_switch on them. */
868 gimple stmt
= last_stmt (bb
);
869 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
873 expanded_location loc
= expand_location (gimple_location (stmt
));
875 fprintf (dump_file
, "beginning to process the following "
876 "SWITCH statement (%s:%d) : ------- \n",
878 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
879 putc ('\n', dump_file
);
883 if (process_switch (stmt
))
887 fputs ("Switch converted\n", dump_file
);
888 fputs ("--------------------------------\n", dump_file
);
895 gcc_assert (info
.reason
);
896 fputs ("Bailing out - ", dump_file
);
897 fputs (info
.reason
, dump_file
);
898 fputs ("--------------------------------\n", dump_file
);
910 switchconv_gate (void)
912 return flag_tree_switch_conversion
!= 0;
915 struct gimple_opt_pass pass_convert_switch
=
919 "switchconv", /* name */
920 switchconv_gate
, /* gate */
921 do_switchconv
, /* execute */
924 0, /* static_pass_number */
925 TV_TREE_SWITCH_CONVERSION
, /* tv_id */
926 PROP_cfg
| PROP_ssa
, /* properties_required */
927 0, /* properties_provided */
928 0, /* properties_destroyed */
929 0, /* todo_flags_start */
930 TODO_update_ssa
| TODO_dump_func
931 | TODO_ggc_collect
| TODO_verify_ssa
/* todo_flags_finish */