Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-gimplify.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
1 /* Tree lowering pass. This pass gimplifies the tree representation built
2 by the C-based front ends. The structure of gimplified, or
3 language-independent, trees is dictated by the grammar described in this
4 file.
5 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
6 Free Software Foundation, Inc.
7 Lowering of expressions contributed by Sebastian Pop <s.pop@laposte.net>
8 Re-written to support lowering of whole function trees, documentation
9 and miscellaneous cleanups by Diego Novillo <dnovillo@redhat.com>
10
11 This file is part of GCC.
12
13 GCC is free software; you can redistribute it and/or modify it under
14 the terms of the GNU General Public License as published by the Free
15 Software Foundation; either version 3, or (at your option) any later
16 version.
17
18 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
19 WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with GCC; see the file COPYING3. If not see
25 <http://www.gnu.org/licenses/>. */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "tree.h"
32 #include "varray.h"
33 #include "c-tree.h"
34 #include "c-common.h"
35 #include "gimple.h"
36 #include "hard-reg-set.h"
37 #include "basic-block.h"
38 #include "tree-flow.h"
39 #include "tree-inline.h"
40 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "langhooks-def.h"
43 #include "flags.h"
44 #include "rtl.h"
45 #include "toplev.h"
46 #include "tree-dump.h"
47 #include "c-pretty-print.h"
48 #include "cgraph.h"
49
50
51 /* The gimplification pass converts the language-dependent trees
52 (ld-trees) emitted by the parser into language-independent trees
53 (li-trees) that are the target of SSA analysis and transformations.
54
55 Language-independent trees are based on the SIMPLE intermediate
56 representation used in the McCAT compiler framework:
57
58 "Designing the McCAT Compiler Based on a Family of Structured
59 Intermediate Representations,"
60 L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
61 Proceedings of the 5th International Workshop on Languages and
62 Compilers for Parallel Computing, no. 757 in Lecture Notes in
63 Computer Science, New Haven, Connecticut, pp. 406-420,
64 Springer-Verlag, August 3-5, 1992.
65
66 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
67
68 Basically, we walk down gimplifying the nodes that we encounter. As we
69 walk back up, we check that they fit our constraints, and copy them
70 into temporaries if not. */
71
72 /* Gimplification of statement trees. */
73
74 /* Convert the tree representation of FNDECL from C frontend trees to
75 GENERIC. */
76
77 void
78 c_genericize (tree fndecl)
79 {
80 FILE *dump_orig;
81 int local_dump_flags;
82 struct cgraph_node *cgn;
83
84 /* Dump the C-specific tree IR. */
85 dump_orig = dump_begin (TDI_original, &local_dump_flags);
86 if (dump_orig)
87 {
88 fprintf (dump_orig, "\n;; Function %s",
89 lang_hooks.decl_printable_name (fndecl, 2));
90 fprintf (dump_orig, " (%s)\n",
91 (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
92 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
93 fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
94 fprintf (dump_orig, "\n");
95
96 if (local_dump_flags & TDF_RAW)
97 dump_node (DECL_SAVED_TREE (fndecl),
98 TDF_SLIM | local_dump_flags, dump_orig);
99 else
100 print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
101 fprintf (dump_orig, "\n");
102
103 dump_end (TDI_original, dump_orig);
104 }
105
106 /* Go ahead and gimplify for 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);
115 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
116 c_genericize (cgn->decl);
117 }
118
119 static void
120 add_block_to_enclosing (tree block)
121 {
122 unsigned i;
123 tree enclosing;
124 gimple bind;
125 VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
126
127 for (i = 0; VEC_iterate (gimple, stack, i, bind); i++)
128 if (gimple_bind_block (bind))
129 break;
130
131 enclosing = gimple_bind_block (bind);
132 BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
133 }
134
135 /* Genericize a scope by creating a new BIND_EXPR.
136 BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
137 In the latter case, we need to create a new BLOCK and add it to the
138 BLOCK_SUBBLOCKS of the enclosing block.
139 BODY is a chain of C _STMT nodes for the contents of the scope, to be
140 genericized. */
141
142 tree
143 c_build_bind_expr (tree block, tree body)
144 {
145 tree decls, bind;
146
147 if (block == NULL_TREE)
148 decls = NULL_TREE;
149 else if (TREE_CODE (block) == BLOCK)
150 decls = BLOCK_VARS (block);
151 else
152 {
153 decls = block;
154 if (DECL_ARTIFICIAL (decls))
155 block = NULL_TREE;
156 else
157 {
158 block = make_node (BLOCK);
159 BLOCK_VARS (block) = decls;
160 add_block_to_enclosing (block);
161 }
162 }
163
164 if (!body)
165 body = build_empty_stmt ();
166 if (decls || block)
167 {
168 bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
169 TREE_SIDE_EFFECTS (bind) = 1;
170 }
171 else
172 bind = body;
173
174 return bind;
175 }
176
177 /* Gimplification of expression trees. */
178
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
256 gimplify_expr. */
257
258 int
259 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p,
260 gimple_seq *post_p ATTRIBUTE_UNUSED)
261 {
262 enum tree_code code = TREE_CODE (*expr_p);
263
264 switch (code)
265 {
266 case DECL_EXPR:
267 /* This is handled mostly by gimplify.c, but we have to deal with
268 not warning about int x = x; as it is a GCC extension to turn off
269 this warning but only if warn_init_self is zero. */
270 if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
271 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
272 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
273 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p))
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
279 case COMPOUND_LITERAL_EXPR:
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 }