1 /* { dg-do compile } */
2
3 /* { dg-options "-O2 -fdump-rtl-expand-details" } */
4
5 typedef long unsigned int size_t;
6 union tree_node;
7 typedef union tree_node *tree;
8 union gimple_statement_d;
9 typedef union gimple_statement_d *gimple;
10 typedef const union tree_node *const_tree;
11 typedef const union gimple_statement_d *const_gimple;
12 struct gimple_seq_d;
13 typedef struct gimple_seq_d *gimple_seq;
14 struct edge_def;
15 typedef struct edge_def *edge;
16 struct basic_block_def;
17 typedef struct basic_block_def *basic_block;
18 typedef const struct basic_block_def *const_basic_block;
19 struct tree_exp
20 {
21 tree operands[1];
22 };
23 typedef struct ssa_use_operand_d
24 {
25 tree *use;
26 } ssa_use_operand_t;
27 struct phi_arg_d
28 {
29 struct ssa_use_operand_d imm_use;
30 };
31 union tree_node
32 {
33 struct tree_exp exp;
34 };
35 struct function
36 {
37 };
38 extern struct function *cfun;
39 struct edge_def
40 {
41 unsigned int dest_idx;
42 };
43 static __inline__ void
44 VEC_edge_must_be_pointer_type (void)
45 {
46 (void) ((edge) 1 == (void *) 1);
47 } typedef struct VEC_edge_base
48
49 {
50 unsigned num;
51 unsigned alloc;
52 edge vec[1];
53 } VEC_edge_base;
54 typedef struct VEC_edge_none
55 {
56 VEC_edge_base base;
57 } VEC_edge_none;
58
59 static __inline__ edge
60 VEC_edge_base_index (const VEC_edge_base * vec_, unsigned ix_,
61 const char *file_, unsigned line_, const char *function_)
62 {
63 return vec_->vec[ix_];
64 }
65
66 typedef struct VEC_edge_gc
67 {
68 VEC_edge_base base;
69 } VEC_edge_gc;
70 struct basic_block_def
71 {
72 VEC_edge_gc *succs;
73 };
74 static __inline__ edge
75 single_succ_edge (const_basic_block bb)
76 {
77 return (VEC_edge_base_index
78 ((((bb)->succs) ? &((bb)->succs)->base : 0), (0),
79 "/home/gcc/virgin-gcc/gcc/basic-block.h", 563, __FUNCTION__));
80 }
81
82 edge find_edge (basic_block, basic_block);
83 typedef tree *def_operand_p;
84 typedef ssa_use_operand_t *use_operand_p;
85 struct gimple_seq_node_d;
86 typedef struct gimple_seq_node_d *gimple_seq_node;
87 struct gimple_seq_node_d
88 {
89 gimple stmt;
90 };
91 typedef struct
92 {
93 gimple_seq_node ptr;
94 gimple_seq seq;
95 basic_block bb;
96 } gimple_stmt_iterator;
97 struct gimple_statement_phi
98 {
99 struct phi_arg_d args[1];
100 };
101 union gimple_statement_d
102 {
103 struct gimple_statement_phi gimple_phi;
104 };
105 extern size_t const gimple_ops_offset_[];
106 int gimple_statement_structure (gimple);
107 static __inline__ tree *
108 gimple_ops (gimple gs)
109 {
110 size_t off;
111 off = gimple_ops_offset_[gimple_statement_structure (gs)];
112 return (tree *) ((char *) gs + off);
113 }
114
115 static __inline__ tree
116 gimple_op (const_gimple gs, unsigned i)
117 {
118 return gimple_ops ((((union
119 {
120 const union gimple_statement_d * _q;
121 union gimple_statement_d * _nq;}) (((gs))))._nq))[i];
122 }
123
124 static __inline__ struct phi_arg_d *
125 gimple_phi_arg (gimple gs, unsigned index)
126 {
127 return &(gs->gimple_phi.args[index]);
128 }
129
130 static __inline__ tree
131 gimple_switch_label (const_gimple gs, unsigned index)
132 {
133 return gimple_op (gs, index + 1);
134 }
135
136 gimple_stmt_iterator gsi_start_phis (basic_block);
137 extern basic_block label_to_block_fn (struct function *, tree);
138
139 static __inline__ tree
140 get_use_from_ptr (use_operand_p use)
141 {
142 return *(use->use);
143 }
144
145 static __inline__ use_operand_p
146 gimple_phi_arg_imm_use_ptr (gimple gs, int i)
147 {
148 return &gimple_phi_arg (gs, i)->imm_use;
149 }
150
151 struct switch_conv_info
152 {
153 basic_block final_bb;
154 basic_block switch_bb;
155 const char *reason;
156 tree *default_values;
157 };
158 static struct switch_conv_info info;
159 void gsi_next (gimple_stmt_iterator *);
160 int gsi_gsi_start_phis (basic_block);
161
162 static void
163 gather_default_values (tree default_case)
164 {
165 gimple_stmt_iterator gsi;
166 basic_block bb =
167 (label_to_block_fn ((cfun + 0), default_case->exp.operands[2]));
168 edge e;
169 int i = 0;
170 if (bb == info.final_bb)
171 e = find_edge (info.switch_bb, bb);
172 else
173 e = single_succ_edge (bb);
174 for (gsi = gsi_start_phis (info.final_bb);
175 gsi_gsi_start_phis (info.final_bb); gsi_next (&gsi))
176 {
177 gimple phi = gsi.ptr->stmt;
178 tree val = get_use_from_ptr (gimple_phi_arg_imm_use_ptr
179 ((((phi))), (((e)->dest_idx))));
180 info.default_values[i++] = val;
181 }
182 }
183
184 unsigned int gimple_switch_num_labels (gimple);
185
186 unsigned char
187 process_switch (gimple swtch)
188 {
189 unsigned int i, branch_num = gimple_switch_num_labels (swtch);
190 tree index_type;
191 info.reason = "switch has no labels\n";
192 gather_default_values (gimple_switch_label (swtch, 0));
193 }
194
195 /* Verify that out-of-ssa coalescing did its job by verifying there are not
196 any partition copies inserted. */
197
198 /* { dg-final { scan-rtl-dump-not "partition copy" "expand"} } */
199