Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-gimplify.c @ 55:77e2b8dfacca gcc-4.4.5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update it from 4.4.3 to 4.5.0
author ryoma <e075725@ie.u-ryukyu.ac.jp>
date Fri, 12 Feb 2010 23:39:51 +0900
parents a06113de4d67
children b7f97abdc517
comparison
equal deleted inserted replaced
52:c156f1bd5cd9 55:77e2b8dfacca
101 fprintf (dump_orig, "\n"); 101 fprintf (dump_orig, "\n");
102 102
103 dump_end (TDI_original, dump_orig); 103 dump_end (TDI_original, dump_orig);
104 } 104 }
105 105
106 /* Go ahead and gimplify for now. */ 106 /* Dump all nested functions now. */
107 gimplify_function_tree (fndecl);
108
109 dump_function (TDI_generic, fndecl);
110
111 /* Genericize all nested functions now. We do things in this order so
112 that items like VLA sizes are expanded properly in the context of
113 the correct function. */
114 cgn = cgraph_node (fndecl); 107 cgn = cgraph_node (fndecl);
115 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested) 108 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
116 c_genericize (cgn->decl); 109 c_genericize (cgn->decl);
117 } 110 }
118 111
138 BLOCK_SUBBLOCKS of the enclosing block. 131 BLOCK_SUBBLOCKS of the enclosing block.
139 BODY is a chain of C _STMT nodes for the contents of the scope, to be 132 BODY is a chain of C _STMT nodes for the contents of the scope, to be
140 genericized. */ 133 genericized. */
141 134
142 tree 135 tree
143 c_build_bind_expr (tree block, tree body) 136 c_build_bind_expr (location_t loc, tree block, tree body)
144 { 137 {
145 tree decls, bind; 138 tree decls, bind;
146 139
147 if (block == NULL_TREE) 140 if (block == NULL_TREE)
148 decls = NULL_TREE; 141 decls = NULL_TREE;
160 add_block_to_enclosing (block); 153 add_block_to_enclosing (block);
161 } 154 }
162 } 155 }
163 156
164 if (!body) 157 if (!body)
165 body = build_empty_stmt (); 158 body = build_empty_stmt (loc);
166 if (decls || block) 159 if (decls || block)
167 { 160 {
168 bind = build3 (BIND_EXPR, void_type_node, decls, body, block); 161 bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
169 TREE_SIDE_EFFECTS (bind) = 1; 162 TREE_SIDE_EFFECTS (bind) = 1;
163 SET_EXPR_LOCATION (bind, loc);
170 } 164 }
171 else 165 else
172 bind = body; 166 bind = body;
173 167
174 return bind; 168 return bind;
175 } 169 }
176 170
177 /* Gimplification of expression trees. */ 171 /* Gimplification of expression trees. */
178 172
179 /* Gimplify a C99 compound literal expression. This just means adding
180 the DECL_EXPR before the current statement and using its anonymous
181 decl instead. */
182
183 static enum gimplify_status
184 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
185 {
186 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (*expr_p);
187 tree decl = DECL_EXPR_DECL (decl_s);
188 /* Mark the decl as addressable if the compound literal
189 expression is addressable now, otherwise it is marked too late
190 after we gimplify the initialization expression. */
191 if (TREE_ADDRESSABLE (*expr_p))
192 TREE_ADDRESSABLE (decl) = 1;
193
194 /* Preliminarily mark non-addressed complex variables as eligible
195 for promotion to gimple registers. We'll transform their uses
196 as we find them. */
197 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
198 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
199 && !TREE_THIS_VOLATILE (decl)
200 && !needs_to_live_in_memory (decl))
201 DECL_GIMPLE_REG_P (decl) = 1;
202
203 /* This decl isn't mentioned in the enclosing block, so add it to the
204 list of temps. FIXME it seems a bit of a kludge to say that
205 anonymous artificial vars aren't pushed, but everything else is. */
206 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
207 gimple_add_tmp_var (decl);
208
209 gimplify_and_add (decl_s, pre_p);
210 *expr_p = decl;
211 return GS_OK;
212 }
213
214 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
215 return a new CONSTRUCTOR if something changed. */
216
217 static tree
218 optimize_compound_literals_in_ctor (tree orig_ctor)
219 {
220 tree ctor = orig_ctor;
221 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
222 unsigned int idx, num = VEC_length (constructor_elt, elts);
223
224 for (idx = 0; idx < num; idx++)
225 {
226 tree value = VEC_index (constructor_elt, elts, idx)->value;
227 tree newval = value;
228 if (TREE_CODE (value) == CONSTRUCTOR)
229 newval = optimize_compound_literals_in_ctor (value);
230 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
231 {
232 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (value);
233 tree decl = DECL_EXPR_DECL (decl_s);
234 tree init = DECL_INITIAL (decl);
235
236 if (!TREE_ADDRESSABLE (value)
237 && !TREE_ADDRESSABLE (decl)
238 && init)
239 newval = init;
240 }
241 if (newval == value)
242 continue;
243
244 if (ctor == orig_ctor)
245 {
246 ctor = copy_node (orig_ctor);
247 CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
248 elts = CONSTRUCTOR_ELTS (ctor);
249 }
250 VEC_index (constructor_elt, elts, idx)->value = newval;
251 }
252 return ctor;
253 }
254
255 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in 173 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in
256 gimplify_expr. */ 174 gimplify_expr. */
257 175
258 int 176 int
259 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p, 177 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
260 gimple_seq *post_p ATTRIBUTE_UNUSED) 178 gimple_seq *post_p ATTRIBUTE_UNUSED)
261 { 179 {
262 enum tree_code code = TREE_CODE (*expr_p); 180 enum tree_code code = TREE_CODE (*expr_p);
263 181
264 switch (code) 182 /* This is handled mostly by gimplify.c, but we have to deal with
265 { 183 not warning about int x = x; as it is a GCC extension to turn off
266 case DECL_EXPR: 184 this warning but only if warn_init_self is zero. */
267 /* This is handled mostly by gimplify.c, but we have to deal with 185 if (code == DECL_EXPR
268 not warning about int x = x; as it is a GCC extension to turn off 186 && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
269 this warning but only if warn_init_self is zero. */ 187 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
270 if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL 188 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
271 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) 189 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
272 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) 190 && !warn_init_self)
273 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) 191 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
274 == DECL_EXPR_DECL (*expr_p))
275 && !warn_init_self)
276 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
277 return GS_UNHANDLED;
278 192
279 case COMPOUND_LITERAL_EXPR: 193 return GS_UNHANDLED;
280 return gimplify_compound_literal_expr (expr_p, pre_p);
281
282 case INIT_EXPR:
283 case MODIFY_EXPR:
284 if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == COMPOUND_LITERAL_EXPR)
285 {
286 tree complit = TREE_OPERAND (*expr_p, 1);
287 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (complit);
288 tree decl = DECL_EXPR_DECL (decl_s);
289 tree init = DECL_INITIAL (decl);
290
291 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
292 into struct T x = { 0, 1, 2 } if the address of the
293 compound literal has never been taken. */
294 if (!TREE_ADDRESSABLE (complit)
295 && !TREE_ADDRESSABLE (decl)
296 && init)
297 {
298 *expr_p = copy_node (*expr_p);
299 TREE_OPERAND (*expr_p, 1) = init;
300 return GS_OK;
301 }
302 }
303 else if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR)
304 {
305 tree ctor
306 = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
307
308 if (ctor != TREE_OPERAND (*expr_p, 1))
309 {
310 *expr_p = copy_node (*expr_p);
311 TREE_OPERAND (*expr_p, 1) = ctor;
312 return GS_OK;
313 }
314 }
315 return GS_UNHANDLED;
316
317 default:
318 return GS_UNHANDLED;
319 }
320 } 194 }