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"
99 #include "langhooks.h"
101 /* The main structure of the pass. */
102 struct switch_conv_info
104 /* The expression used to decide the switch branch. (It is subsequently used
105 as the index to the created array.) */
108 /* The following integer constants store the minimum value covered by the
112 /* The difference between the above two numbers, i.e. The size of the array
113 that would have to be created by the transformation. */
116 /* Basic block that contains the actual SWITCH_EXPR. */
117 basic_block switch_bb
;
119 /* All branches of the switch statement must have a single successor stored in
120 the following variable. */
121 basic_block final_bb
;
123 /* Number of phi nodes in the final bb (that we'll be replacing). */
126 /* Array of default values, in the same order as phi nodes. */
127 tree
*default_values
;
129 /* Constructors of new static arrays. */
130 VEC (constructor_elt
, gc
) **constructors
;
132 /* Array of ssa names that are initialized with a value from a new static
134 tree
*target_inbound_names
;
136 /* Array of ssa names that are initialized with the default value if the
137 switch expression is out of range. */
138 tree
*target_outbound_names
;
140 /* The probability of the default edge in the replaced switch. */
143 /* The count of the default edge in the replaced switch. */
144 gcov_type default_count
;
146 /* Combined count of all other (non-default) edges in the replaced switch. */
147 gcov_type other_count
;
149 /* The first load statement that loads a temporary from a new static array.
151 gimple arr_ref_first
;
153 /* The last load statement that loads a temporary from a new static array. */
156 /* String reason why the case wasn't a good candidate that is written to the
157 dump file, if there is one. */
161 /* Global pass info. */
162 static struct switch_conv_info info
;
165 /* Checks whether the range given by individual case statements of the SWTCH
166 switch statement isn't too big and whether the number of branches actually
167 satisfies the size of the new array. */
170 check_range (gimple swtch
)
172 tree min_case
, max_case
;
173 unsigned int branch_num
= gimple_switch_num_labels (swtch
);
176 /* The gimplifier has already sorted the cases by CASE_LOW and ensured there
177 is a default label which is the last in the vector. */
179 min_case
= gimple_switch_label (swtch
, 1);
180 info
.range_min
= CASE_LOW (min_case
);
182 gcc_assert (branch_num
> 1);
183 gcc_assert (CASE_LOW (gimple_switch_label (swtch
, 0)) == NULL_TREE
);
184 max_case
= gimple_switch_label (swtch
, branch_num
- 1);
185 if (CASE_HIGH (max_case
) != NULL_TREE
)
186 range_max
= CASE_HIGH (max_case
);
188 range_max
= CASE_LOW (max_case
);
190 gcc_assert (info
.range_min
);
191 gcc_assert (range_max
);
193 info
.range_size
= int_const_binop (MINUS_EXPR
, range_max
, info
.range_min
, 0);
195 gcc_assert (info
.range_size
);
196 if (!host_integerp (info
.range_size
, 1))
198 info
.reason
= "index range way too large or otherwise unusable.\n";
202 if ((unsigned HOST_WIDE_INT
) tree_low_cst (info
.range_size
, 1)
203 > ((unsigned) branch_num
* SWITCH_CONVERSION_BRANCH_RATIO
))
205 info
.reason
= "the maximum range-branch ratio exceeded.\n";
212 /* Checks the given CS switch case whether it is suitable for conversion
213 (whether all but the default basic blocks are empty and so on). If it is,
214 adds the case to the branch list along with values for the defined variables
215 and returns true. Otherwise returns false. */
218 check_process_case (tree cs
)
221 basic_block label_bb
, following_bb
;
224 ldecl
= CASE_LABEL (cs
);
225 label_bb
= label_to_block (ldecl
);
227 e
= find_edge (info
.switch_bb
, label_bb
);
230 if (CASE_LOW (cs
) == NULL_TREE
)
232 /* Default branch. */
233 info
.default_prob
= e
->probability
;
234 info
.default_count
= e
->count
;
237 info
.other_count
+= e
->count
;
241 info
.reason
= " Bad case - cs BB label is NULL\n";
245 if (!single_pred_p (label_bb
))
247 if (info
.final_bb
&& info
.final_bb
!= label_bb
)
249 info
.reason
= " Bad case - a non-final BB has two predecessors\n";
250 return false; /* sth complex going on in this branch */
253 following_bb
= label_bb
;
257 if (!empty_block_p (label_bb
))
259 info
.reason
= " Bad case - a non-final BB not empty\n";
263 e
= single_succ_edge (label_bb
);
264 following_bb
= single_succ (label_bb
);
268 info
.final_bb
= following_bb
;
269 else if (info
.final_bb
!= following_bb
)
271 info
.reason
= " Bad case - different final BB\n";
272 return false; /* the only successor is not common for all the branches */
278 /* This function checks whether all required values in phi nodes in final_bb
279 are constants. Required values are those that correspond to a basic block
280 which is a part of the examined switch statement. It returns true if the
281 phi nodes are OK, otherwise false. */
284 check_final_bb (void)
286 gimple_stmt_iterator gsi
;
289 for (gsi
= gsi_start_phis (info
.final_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
291 gimple phi
= gsi_stmt (gsi
);
296 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
298 basic_block bb
= gimple_phi_arg_edge (phi
, i
)->src
;
300 if (bb
== info
.switch_bb
301 || (single_pred_p (bb
) && single_pred (bb
) == info
.switch_bb
))
305 val
= gimple_phi_arg_def (phi
, i
);
306 if (!is_gimple_ip_invariant (val
))
308 info
.reason
= " Non-invariant value from a case\n";
309 return false; /* Non-invariant argument. */
311 reloc
= initializer_constant_valid_p (val
, TREE_TYPE (val
));
312 if ((flag_pic
&& reloc
!= null_pointer_node
)
313 || (!flag_pic
&& reloc
== NULL_TREE
))
317 = " Value from a case would need runtime relocations\n";
320 = " Value from a case is not a valid initializer\n";
330 /* The following function allocates default_values, target_{in,out}_names and
331 constructors arrays. The last one is also populated with pointers to
332 vectors that will become constructors of new arrays. */
335 create_temp_arrays (void)
339 info
.default_values
= (tree
*) xcalloc (info
.phi_count
, sizeof (tree
));
340 info
.constructors
= (VEC (constructor_elt
, gc
) **) xcalloc (info
.phi_count
,
342 info
.target_inbound_names
= (tree
*) xcalloc (info
.phi_count
, sizeof (tree
));
343 info
.target_outbound_names
= (tree
*) xcalloc (info
.phi_count
,
346 for (i
= 0; i
< info
.phi_count
; i
++)
348 = VEC_alloc (constructor_elt
, gc
, tree_low_cst (info
.range_size
, 1) + 1);
351 /* Free the arrays created by create_temp_arrays(). The vectors that are
352 created by that function are not freed here, however, because they have
353 already become constructors and must be preserved. */
356 free_temp_arrays (void)
358 free (info
.constructors
);
359 free (info
.default_values
);
360 free (info
.target_inbound_names
);
361 free (info
.target_outbound_names
);
364 /* Populate the array of default values in the order of phi nodes.
365 DEFAULT_CASE is the CASE_LABEL_EXPR for the default switch branch. */
368 gather_default_values (tree default_case
)
370 gimple_stmt_iterator gsi
;
371 basic_block bb
= label_to_block (CASE_LABEL (default_case
));
375 gcc_assert (CASE_LOW (default_case
) == NULL_TREE
);
377 if (bb
== info
.final_bb
)
378 e
= find_edge (info
.switch_bb
, bb
);
380 e
= single_succ_edge (bb
);
382 for (gsi
= gsi_start_phis (info
.final_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
384 gimple phi
= gsi_stmt (gsi
);
385 tree val
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
387 info
.default_values
[i
++] = val
;
391 /* The following function populates the vectors in the constructors array with
392 future contents of the static arrays. The vectors are populated in the
393 order of phi nodes. SWTCH is the switch statement being converted. */
396 build_constructors (gimple swtch
)
398 unsigned i
, branch_num
= gimple_switch_num_labels (swtch
);
399 tree pos
= info
.range_min
;
401 for (i
= 1; i
< branch_num
; i
++)
403 tree cs
= gimple_switch_label (swtch
, i
);
404 basic_block bb
= label_to_block (CASE_LABEL (cs
));
407 gimple_stmt_iterator gsi
;
410 if (bb
== info
.final_bb
)
411 e
= find_edge (info
.switch_bb
, bb
);
413 e
= single_succ_edge (bb
);
416 while (tree_int_cst_lt (pos
, CASE_LOW (cs
)))
419 for (k
= 0; k
< info
.phi_count
; k
++)
421 constructor_elt
*elt
;
423 elt
= VEC_quick_push (constructor_elt
,
424 info
.constructors
[k
], NULL
);
425 elt
->index
= int_const_binop (MINUS_EXPR
, pos
,
427 elt
->value
= info
.default_values
[k
];
430 pos
= int_const_binop (PLUS_EXPR
, pos
, integer_one_node
, 0);
432 gcc_assert (tree_int_cst_equal (pos
, CASE_LOW (cs
)));
436 high
= CASE_HIGH (cs
);
438 high
= CASE_LOW (cs
);
439 for (gsi
= gsi_start_phis (info
.final_bb
);
440 !gsi_end_p (gsi
); gsi_next (&gsi
))
442 gimple phi
= gsi_stmt (gsi
);
443 tree val
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
444 tree low
= CASE_LOW (cs
);
449 constructor_elt
*elt
;
451 elt
= VEC_quick_push (constructor_elt
,
452 info
.constructors
[j
], NULL
);
453 elt
->index
= int_const_binop (MINUS_EXPR
, pos
, info
.range_min
, 0);
456 pos
= int_const_binop (PLUS_EXPR
, pos
, integer_one_node
, 0);
457 } while (!tree_int_cst_lt (high
, pos
)
458 && tree_int_cst_lt (low
, pos
));
464 /* If all values in the constructor vector are the same, return the value.
465 Otherwise return NULL_TREE. Not supposed to be called for empty
469 constructor_contains_same_values_p (VEC (constructor_elt
, gc
) *vec
)
471 int i
, len
= VEC_length (constructor_elt
, vec
);
472 tree prev
= NULL_TREE
;
474 for (i
= 0; i
< len
; i
++)
476 constructor_elt
*elt
= VEC_index (constructor_elt
, vec
, i
);
480 else if (!operand_equal_p (elt
->value
, prev
, OEP_ONLY_CONST
))
486 /* Create an appropriate array type and declaration and assemble a static array
487 variable. Also create a load statement that initializes the variable in
488 question with a value from the static array. SWTCH is the switch statement
489 being converted, NUM is the index to arrays of constructors, default values
490 and target SSA names for this particular array. ARR_INDEX_TYPE is the type
491 of the index of the new array, PHI is the phi node of the final BB that
492 corresponds to the value that will be loaded from the created array. TIDX
493 is an ssa name of a temporary variable holding the index for loads from the
497 build_one_array (gimple swtch
, int num
, tree arr_index_type
, gimple phi
,
502 gimple_stmt_iterator gsi
= gsi_for_stmt (swtch
);
503 location_t loc
= gimple_location (swtch
);
505 gcc_assert (info
.default_values
[num
]);
507 name
= make_ssa_name (SSA_NAME_VAR (PHI_RESULT (phi
)), NULL
);
508 info
.target_inbound_names
[num
] = name
;
510 cst
= constructor_contains_same_values_p (info
.constructors
[num
]);
512 load
= gimple_build_assign (name
, cst
);
515 tree array_type
, ctor
, decl
, value_type
, fetch
;
517 value_type
= TREE_TYPE (info
.default_values
[num
]);
518 array_type
= build_array_type (value_type
, arr_index_type
);
519 ctor
= build_constructor (array_type
, info
.constructors
[num
]);
520 TREE_CONSTANT (ctor
) = true;
522 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, array_type
);
523 TREE_STATIC (decl
) = 1;
524 DECL_INITIAL (decl
) = ctor
;
526 DECL_NAME (decl
) = create_tmp_var_name ("CSWTCH");
527 DECL_ARTIFICIAL (decl
) = 1;
528 TREE_CONSTANT (decl
) = 1;
529 TREE_READONLY (decl
) = 1;
530 add_referenced_var (decl
);
531 varpool_mark_needed_node (varpool_node (decl
));
532 varpool_finalize_decl (decl
);
534 fetch
= build4 (ARRAY_REF
, value_type
, decl
, tidx
, NULL_TREE
,
536 load
= gimple_build_assign (name
, fetch
);
539 SSA_NAME_DEF_STMT (name
) = load
;
540 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
542 info
.arr_ref_last
= load
;
545 /* Builds and initializes static arrays initialized with values gathered from
546 the SWTCH switch statement. Also creates statements that load values from
550 build_arrays (gimple swtch
)
555 gimple_stmt_iterator gsi
;
557 location_t loc
= gimple_location (swtch
);
559 gsi
= gsi_for_stmt (swtch
);
561 arr_index_type
= build_index_type (info
.range_size
);
562 tmp
= create_tmp_var (TREE_TYPE (info
.index_expr
), "csti");
563 add_referenced_var (tmp
);
564 tidx
= make_ssa_name (tmp
, NULL
);
565 sub
= fold_build2_loc (loc
, MINUS_EXPR
,
566 TREE_TYPE (info
.index_expr
), info
.index_expr
,
567 fold_convert_loc (loc
, TREE_TYPE (info
.index_expr
),
569 sub
= force_gimple_operand_gsi (&gsi
, sub
,
570 false, NULL
, true, GSI_SAME_STMT
);
571 stmt
= gimple_build_assign (tidx
, sub
);
572 SSA_NAME_DEF_STMT (tidx
) = stmt
;
574 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
576 info
.arr_ref_first
= stmt
;
578 for (gsi
= gsi_start_phis (info
.final_bb
), i
= 0;
579 !gsi_end_p (gsi
); gsi_next (&gsi
), i
++)
580 build_one_array (swtch
, i
, arr_index_type
, gsi_stmt (gsi
), tidx
);
583 /* Generates and appropriately inserts loads of default values at the position
584 given by BSI. Returns the last inserted statement. */
587 gen_def_assigns (gimple_stmt_iterator
*gsi
)
590 gimple assign
= NULL
;
592 for (i
= 0; i
< info
.phi_count
; i
++)
595 = make_ssa_name (SSA_NAME_VAR (info
.target_inbound_names
[i
]), NULL
);
597 info
.target_outbound_names
[i
] = name
;
598 assign
= gimple_build_assign (name
, info
.default_values
[i
]);
599 SSA_NAME_DEF_STMT (name
) = assign
;
600 gsi_insert_before (gsi
, assign
, GSI_SAME_STMT
);
601 update_stmt (assign
);
606 /* Deletes the unused bbs and edges that now contain the switch statement and
607 its empty branch bbs. BBD is the now dead BB containing the original switch
608 statement, FINAL is the last BB of the converted switch statement (in terms
612 prune_bbs (basic_block bbd
, basic_block final
)
617 for (ei
= ei_start (bbd
->succs
); (e
= ei_safe_edge (ei
)); )
623 delete_basic_block (bb
);
625 delete_basic_block (bbd
);
628 /* Add values to phi nodes in final_bb for the two new edges. E1F is the edge
629 from the basic block loading values from an array and E2F from the basic
630 block loading default values. BBF is the last switch basic block (see the
631 bbf description in the comment below). */
634 fix_phi_nodes (edge e1f
, edge e2f
, basic_block bbf
)
636 gimple_stmt_iterator gsi
;
639 for (gsi
= gsi_start_phis (bbf
), i
= 0;
640 !gsi_end_p (gsi
); gsi_next (&gsi
), i
++)
642 gimple phi
= gsi_stmt (gsi
);
643 add_phi_arg (phi
, info
.target_inbound_names
[i
], e1f
, UNKNOWN_LOCATION
);
644 add_phi_arg (phi
, info
.target_outbound_names
[i
], e2f
, UNKNOWN_LOCATION
);
649 /* Creates a check whether the switch expression value actually falls into the
650 range given by all the cases. If it does not, the temporaries are loaded
651 with default values instead. SWTCH is the switch statement being converted.
653 bb0 is the bb with the switch statement, however, we'll end it with a
656 bb1 is the bb to be used when the range check went ok. It is derived from
659 bb2 is the bb taken when the expression evaluated outside of the range
660 covered by the created arrays. It is populated by loads of default
663 bbF is a fall through for both bb1 and bb2 and contains exactly what
664 originally followed the switch statement.
666 bbD contains the switch statement (in the end). It is unreachable but we
667 still need to strip off its edges.
671 gen_inbound_check (gimple swtch
)
673 tree label_decl1
= create_artificial_label (UNKNOWN_LOCATION
);
674 tree label_decl2
= create_artificial_label (UNKNOWN_LOCATION
);
675 tree label_decl3
= create_artificial_label (UNKNOWN_LOCATION
);
676 gimple label1
, label2
, label3
;
679 tree tmp_u_1
, tmp_u_2
, tmp_u_var
;
681 gimple cast_assign
, minus_assign
;
688 gimple_stmt_iterator gsi
;
689 basic_block bb0
, bb1
, bb2
, bbf
, bbd
;
690 edge e01
, e02
, e21
, e1d
, e1f
, e2f
;
691 location_t loc
= gimple_location (swtch
);
693 gcc_assert (info
.default_values
);
694 bb0
= gimple_bb (swtch
);
696 /* Make sure we do not generate arithmetics in a subrange. */
697 if (TREE_TYPE (TREE_TYPE (info
.index_expr
)))
698 utype
= lang_hooks
.types
.type_for_mode
699 (TYPE_MODE (TREE_TYPE (TREE_TYPE (info
.index_expr
))), 1);
701 utype
= lang_hooks
.types
.type_for_mode
702 (TYPE_MODE (TREE_TYPE (info
.index_expr
)), 1);
704 /* (end of) block 0 */
705 gsi
= gsi_for_stmt (info
.arr_ref_first
);
706 tmp_u_var
= create_tmp_var (utype
, "csui");
707 add_referenced_var (tmp_u_var
);
708 tmp_u_1
= make_ssa_name (tmp_u_var
, NULL
);
710 cast
= fold_convert_loc (loc
, utype
, info
.index_expr
);
711 cast_assign
= gimple_build_assign (tmp_u_1
, cast
);
712 SSA_NAME_DEF_STMT (tmp_u_1
) = cast_assign
;
713 gsi_insert_before (&gsi
, cast_assign
, GSI_SAME_STMT
);
714 update_stmt (cast_assign
);
716 ulb
= fold_convert_loc (loc
, utype
, info
.range_min
);
717 minus
= fold_build2_loc (loc
, MINUS_EXPR
, utype
, tmp_u_1
, ulb
);
718 minus
= force_gimple_operand_gsi (&gsi
, minus
, false, NULL
, true,
720 tmp_u_2
= make_ssa_name (tmp_u_var
, NULL
);
721 minus_assign
= gimple_build_assign (tmp_u_2
, minus
);
722 SSA_NAME_DEF_STMT (tmp_u_2
) = minus_assign
;
723 gsi_insert_before (&gsi
, minus_assign
, GSI_SAME_STMT
);
724 update_stmt (minus_assign
);
726 bound
= fold_convert_loc (loc
, utype
, info
.range_size
);
727 cond_stmt
= gimple_build_cond (LE_EXPR
, tmp_u_2
, bound
, NULL_TREE
, NULL_TREE
);
728 gsi_insert_before (&gsi
, cond_stmt
, GSI_SAME_STMT
);
729 update_stmt (cond_stmt
);
732 gsi
= gsi_for_stmt (info
.arr_ref_first
);
733 label2
= gimple_build_label (label_decl2
);
734 gsi_insert_before (&gsi
, label2
, GSI_SAME_STMT
);
735 last_assign
= gen_def_assigns (&gsi
);
738 gsi
= gsi_for_stmt (info
.arr_ref_first
);
739 label1
= gimple_build_label (label_decl1
);
740 gsi_insert_before (&gsi
, label1
, GSI_SAME_STMT
);
743 gsi
= gsi_start_bb (info
.final_bb
);
744 label3
= gimple_build_label (label_decl3
);
745 gsi_insert_before (&gsi
, label3
, GSI_SAME_STMT
);
748 e02
= split_block (bb0
, cond_stmt
);
751 e21
= split_block (bb2
, last_assign
);
755 e1d
= split_block (bb1
, info
.arr_ref_last
);
759 /* flags and profiles of the edge for in-range values */
760 e01
= make_edge (bb0
, bb1
, EDGE_TRUE_VALUE
);
761 e01
->probability
= REG_BR_PROB_BASE
- info
.default_prob
;
762 e01
->count
= info
.other_count
;
764 /* flags and profiles of the edge taking care of out-of-range values */
765 e02
->flags
&= ~EDGE_FALLTHRU
;
766 e02
->flags
|= EDGE_FALSE_VALUE
;
767 e02
->probability
= info
.default_prob
;
768 e02
->count
= info
.default_count
;
772 e1f
= make_edge (bb1
, bbf
, EDGE_FALLTHRU
);
773 e1f
->probability
= REG_BR_PROB_BASE
;
774 e1f
->count
= info
.other_count
;
776 e2f
= make_edge (bb2
, bbf
, EDGE_FALLTHRU
);
777 e2f
->probability
= REG_BR_PROB_BASE
;
778 e2f
->count
= info
.default_count
;
780 /* frequencies of the new BBs */
781 bb1
->frequency
= EDGE_FREQUENCY (e01
);
782 bb2
->frequency
= EDGE_FREQUENCY (e02
);
783 bbf
->frequency
= EDGE_FREQUENCY (e1f
) + EDGE_FREQUENCY (e2f
);
785 prune_bbs (bbd
, info
.final_bb
); /* To keep calc_dfs_tree() in dominance.c
788 fix_phi_nodes (e1f
, e2f
, bbf
);
790 free_dominance_info (CDI_DOMINATORS
);
791 free_dominance_info (CDI_POST_DOMINATORS
);
794 /* The following function is invoked on every switch statement (the current one
795 is given in SWTCH) and runs the individual phases of switch conversion on it
796 one after another until one fails or the conversion is completed. */
799 process_switch (gimple swtch
)
801 unsigned int i
, branch_num
= gimple_switch_num_labels (swtch
);
804 /* Operand 2 is either NULL_TREE or a vector of cases (stmt.c). */
807 info
.reason
= "switch has no labels\n";
811 info
.final_bb
= NULL
;
812 info
.switch_bb
= gimple_bb (swtch
);
813 info
.index_expr
= gimple_switch_index (swtch
);
814 index_type
= TREE_TYPE (info
.index_expr
);
815 info
.arr_ref_first
= NULL
;
816 info
.arr_ref_last
= NULL
;
817 info
.default_prob
= 0;
818 info
.default_count
= 0;
819 info
.other_count
= 0;
821 /* An ERROR_MARK occurs for various reasons including invalid data type.
822 (comment from stmt.c) */
823 if (index_type
== error_mark_node
)
825 info
.reason
= "index error.\n";
829 /* Check the case label values are within reasonable range: */
830 if (!check_range (swtch
))
833 /* For all the cases, see whether they are empty, the assignments they
834 represent constant and so on... */
835 for (i
= 0; i
< branch_num
; i
++)
836 if (!check_process_case (gimple_switch_label (swtch
, i
)))
839 fprintf (dump_file
, "Processing of case %i failed\n", i
);
843 if (!check_final_bb ())
846 /* At this point all checks have passed and we can proceed with the
849 create_temp_arrays ();
850 gather_default_values (gimple_switch_label (swtch
, 0));
851 build_constructors (swtch
);
853 build_arrays (swtch
); /* Build the static arrays and assignments. */
854 gen_inbound_check (swtch
); /* Build the bounds check. */
861 /* The main function of the pass scans statements for switches and invokes
862 process_switch on them. */
871 gimple stmt
= last_stmt (bb
);
872 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
876 expanded_location loc
= expand_location (gimple_location (stmt
));
878 fprintf (dump_file
, "beginning to process the following "
879 "SWITCH statement (%s:%d) : ------- \n",
881 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
882 putc ('\n', dump_file
);
886 if (process_switch (stmt
))
890 fputs ("Switch converted\n", dump_file
);
891 fputs ("--------------------------------\n", dump_file
);
898 gcc_assert (info
.reason
);
899 fputs ("Bailing out - ", dump_file
);
900 fputs (info
.reason
, dump_file
);
901 fputs ("--------------------------------\n", dump_file
);
913 switchconv_gate (void)
915 return flag_tree_switch_conversion
!= 0;
918 struct gimple_opt_pass pass_convert_switch
=
922 "switchconv", /* name */
923 switchconv_gate
, /* gate */
924 do_switchconv
, /* execute */
927 0, /* static_pass_number */
928 TV_TREE_SWITCH_CONVERSION
, /* tv_id */
929 PROP_cfg
| PROP_ssa
, /* properties_required */
930 0, /* properties_provided */
931 0, /* properties_destroyed */
932 0, /* todo_flags_start */
933 TODO_update_ssa
| TODO_dump_func
934 | TODO_ggc_collect
| TODO_verify_ssa
/* todo_flags_finish */