OSDN Git Service

* c-gimplify.c (c_genericize): Don't refer to DECL_ASSEMBLER_NAME
[pf3gnuchains/gcc-fork.git] / gcc / c-gimplify.c
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 }