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
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>
11 This file is part of GCC.
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
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
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/>. */
29 #include "coretypes.h"
35 #include "hard-reg-set.h"
36 #include "basic-block.h"
37 #include "tree-flow.h"
38 #include "tree-inline.h"
39 #include "diagnostic.h"
40 #include "langhooks.h"
41 #include "langhooks-def.h"
45 #include "tree-dump.h"
46 #include "c-pretty-print.h"
50 /* The gimplification pass converts the language-dependent trees
51 (ld-trees) emitted by the parser into language-independent trees
52 (li-trees) that are the target of SSA analysis and transformations.
54 Language-independent trees are based on the SIMPLE intermediate
55 representation used in the McCAT compiler framework:
57 "Designing the McCAT Compiler Based on a Family of Structured
58 Intermediate Representations,"
59 L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
60 Proceedings of the 5th International Workshop on Languages and
61 Compilers for Parallel Computing, no. 757 in Lecture Notes in
62 Computer Science, New Haven, Connecticut, pp. 406-420,
63 Springer-Verlag, August 3-5, 1992.
65 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
67 Basically, we walk down gimplifying the nodes that we encounter. As we
68 walk back up, we check that they fit our constraints, and copy them
69 into temporaries if not. */
71 /* Gimplification of statement trees. */
73 /* Convert the tree representation of FNDECL from C frontend trees to
77 c_genericize (tree fndecl)
81 struct cgraph_node *cgn;
83 /* Dump the C-specific tree IR. */
84 dump_orig = dump_begin (TDI_original, &local_dump_flags);
87 fprintf (dump_orig, "\n;; Function %s",
88 lang_hooks.decl_printable_name (fndecl, 2));
89 fprintf (dump_orig, " (%s)\n",
90 (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
91 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
92 fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
93 fprintf (dump_orig, "\n");
95 if (local_dump_flags & TDF_RAW)
96 dump_node (DECL_SAVED_TREE (fndecl),
97 TDF_SLIM | local_dump_flags, dump_orig);
99 print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
100 fprintf (dump_orig, "\n");
102 dump_end (TDI_original, dump_orig);
105 /* Dump all nested functions now. */
106 cgn = cgraph_node (fndecl);
107 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
108 c_genericize (cgn->decl);
112 add_block_to_enclosing (tree block)
117 VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
119 for (i = 0; VEC_iterate (gimple, stack, i, bind); i++)
120 if (gimple_bind_block (bind))
123 enclosing = gimple_bind_block (bind);
124 BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
127 /* Genericize a scope by creating a new BIND_EXPR.
128 BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
129 In the latter case, we need to create a new BLOCK and add it to the
130 BLOCK_SUBBLOCKS of the enclosing block.
131 BODY is a chain of C _STMT nodes for the contents of the scope, to be
135 c_build_bind_expr (location_t loc, tree block, tree body)
139 if (block == NULL_TREE)
141 else if (TREE_CODE (block) == BLOCK)
142 decls = BLOCK_VARS (block);
146 if (DECL_ARTIFICIAL (decls))
150 block = make_node (BLOCK);
151 BLOCK_VARS (block) = decls;
152 add_block_to_enclosing (block);
157 body = build_empty_stmt (loc);
160 bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
161 TREE_SIDE_EFFECTS (bind) = 1;
162 SET_EXPR_LOCATION (bind, loc);
170 /* Gimplification of expression trees. */
172 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in
176 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
177 gimple_seq *post_p ATTRIBUTE_UNUSED)
179 enum tree_code code = TREE_CODE (*expr_p);
181 /* This is handled mostly by gimplify.c, but we have to deal with
182 not warning about int x = x; as it is a GCC extension to turn off
183 this warning but only if warn_init_self is zero. */
184 if (code == DECL_EXPR
185 && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
186 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
187 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
188 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
190 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;