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"
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"
46 #include "tree-dump.h"
47 #include "c-pretty-print.h"
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.
55 Language-independent trees are based on the SIMPLE intermediate
56 representation used in the McCAT compiler framework:
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.
66 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
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. */
72 /* Gimplification of statement trees. */
74 /* Convert the tree representation of FNDECL from C frontend trees to
78 c_genericize (tree fndecl
)
82 struct cgraph_node
*cgn
;
84 /* Dump the C-specific tree IR. */
85 dump_orig
= dump_begin (TDI_original
, &local_dump_flags
);
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");
96 if (local_dump_flags
& TDF_RAW
)
97 dump_node (DECL_SAVED_TREE (fndecl
),
98 TDF_SLIM
| local_dump_flags
, dump_orig
);
100 print_c_tree (dump_orig
, DECL_SAVED_TREE (fndecl
));
101 fprintf (dump_orig
, "\n");
103 dump_end (TDI_original
, dump_orig
);
106 /* Dump all nested functions now. */
107 cgn
= cgraph_node (fndecl
);
108 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
109 c_genericize (cgn
->decl
);
113 add_block_to_enclosing (tree block
)
118 VEC(gimple
, heap
) *stack
= gimple_bind_expr_stack ();
120 for (i
= 0; VEC_iterate (gimple
, stack
, i
, bind
); i
++)
121 if (gimple_bind_block (bind
))
124 enclosing
= gimple_bind_block (bind
);
125 BLOCK_SUBBLOCKS (enclosing
) = chainon (BLOCK_SUBBLOCKS (enclosing
), block
);
128 /* Genericize a scope by creating a new BIND_EXPR.
129 BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
130 In the latter case, we need to create a new BLOCK and add it to the
131 BLOCK_SUBBLOCKS of the enclosing block.
132 BODY is a chain of C _STMT nodes for the contents of the scope, to be
136 c_build_bind_expr (location_t loc
, tree block
, tree body
)
140 if (block
== NULL_TREE
)
142 else if (TREE_CODE (block
) == BLOCK
)
143 decls
= BLOCK_VARS (block
);
147 if (DECL_ARTIFICIAL (decls
))
151 block
= make_node (BLOCK
);
152 BLOCK_VARS (block
) = decls
;
153 add_block_to_enclosing (block
);
158 body
= build_empty_stmt (loc
);
161 bind
= build3 (BIND_EXPR
, void_type_node
, decls
, body
, block
);
162 TREE_SIDE_EFFECTS (bind
) = 1;
163 SET_EXPR_LOCATION (bind
, loc
);
171 /* Gimplification of expression trees. */
173 /* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in
177 c_gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p ATTRIBUTE_UNUSED
,
178 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
180 enum tree_code code
= TREE_CODE (*expr_p
);
182 /* This is handled mostly by gimplify.c, but we have to deal with
183 not warning about int x = x; as it is a GCC extension to turn off
184 this warning but only if warn_init_self is zero. */
185 if (code
== DECL_EXPR
186 && TREE_CODE (DECL_EXPR_DECL (*expr_p
)) == VAR_DECL
187 && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p
))
188 && !TREE_STATIC (DECL_EXPR_DECL (*expr_p
))
189 && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p
)) == DECL_EXPR_DECL (*expr_p
))
191 TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p
)) = 1;