X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fc-gimplify.c;h=e50050c2324cff5e7a71792e95a49b4c2b804add;hb=fc7a207afb278ff786674fe38579828f382765bf;hp=9721b67008bd832e5267108309f7d781917c138a;hpb=8c4c00c181e6df4f0a9afc76e4c9edbbc1c2fd41;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/c-gimplify.c b/gcc/c-gimplify.c index 9721b67008b..e50050c2324 100644 --- a/gcc/c-gimplify.c +++ b/gcc/c-gimplify.c @@ -2,7 +2,8 @@ by the C-based front ends. The structure of gimplified, or language-independent, trees is dictated by the grammar described in this file. - Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc. + Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008 + Free Software Foundation, Inc. Lowering of expressions contributed by Sebastian Pop Re-written to support lowering of whole function trees, documentation and miscellaneous cleanups by Diego Novillo @@ -31,7 +32,7 @@ along with GCC; see the file COPYING3. If not see #include "varray.h" #include "c-tree.h" #include "c-common.h" -#include "tree-gimple.h" +#include "gimple.h" #include "hard-reg-set.h" #include "basic-block.h" #include "tree-flow.h" @@ -87,7 +88,8 @@ c_genericize (tree fndecl) fprintf (dump_orig, "\n;; Function %s", lang_hooks.decl_printable_name (fndecl, 2)); fprintf (dump_orig, " (%s)\n", - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))); + (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null" + : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)))); fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original)); fprintf (dump_orig, "\n"); @@ -101,15 +103,7 @@ c_genericize (tree fndecl) dump_end (TDI_original, dump_orig); } - /* Go ahead and gimplify for now. */ - gimplify_function_tree (fndecl); - - /* Dump the genericized tree IR. */ - dump_function (TDI_generic, fndecl); - - /* Genericize all nested functions now. We do things in this order so - that items like VLA sizes are expanded properly in the context of - the correct function. */ + /* Dump all nested functions now. */ cgn = cgraph_node (fndecl); for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested) c_genericize (cgn->decl); @@ -118,14 +112,16 @@ c_genericize (tree fndecl) static void add_block_to_enclosing (tree block) { + unsigned i; tree enclosing; + gimple bind; + VEC(gimple, heap) *stack = gimple_bind_expr_stack (); - for (enclosing = gimple_current_bind_expr (); - enclosing; enclosing = TREE_CHAIN (enclosing)) - if (BIND_EXPR_BLOCK (enclosing)) + for (i = 0; VEC_iterate (gimple, stack, i, bind); i++) + if (gimple_bind_block (bind)) break; - enclosing = BIND_EXPR_BLOCK (enclosing); + enclosing = gimple_bind_block (bind); BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block); } @@ -137,7 +133,7 @@ add_block_to_enclosing (tree block) genericized. */ tree -c_build_bind_expr (tree block, tree body) +c_build_bind_expr (location_t loc, tree block, tree body) { tree decls, bind; @@ -159,11 +155,12 @@ c_build_bind_expr (tree block, tree body) } if (!body) - body = build_empty_stmt (); + body = build_empty_stmt (loc); if (decls || block) { bind = build3 (BIND_EXPR, void_type_node, decls, body, block); TREE_SIDE_EFFECTS (bind) = 1; + SET_EXPR_LOCATION (bind, loc); } else bind = body; @@ -173,67 +170,25 @@ c_build_bind_expr (tree block, tree body) /* Gimplification of expression trees. */ -/* Gimplify a C99 compound literal expression. This just means adding - the DECL_EXPR before the current statement and using its anonymous - decl instead. */ - -static enum gimplify_status -gimplify_compound_literal_expr (tree *expr_p, tree *pre_p) -{ - tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (*expr_p); - tree decl = DECL_EXPR_DECL (decl_s); - /* Mark the decl as addressable if the compound literal - expression is addressable now, otherwise it is marked too late - after we gimplify the initialization expression. */ - if (TREE_ADDRESSABLE (*expr_p)) - TREE_ADDRESSABLE (decl) = 1; - - /* Preliminarily mark non-addressed complex variables as eligible - for promotion to gimple registers. We'll transform their uses - as we find them. */ - if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE) - && !TREE_THIS_VOLATILE (decl) - && !needs_to_live_in_memory (decl)) - DECL_GIMPLE_REG_P (decl) = 1; - - /* This decl isn't mentioned in the enclosing block, so add it to the - list of temps. FIXME it seems a bit of a kludge to say that - anonymous artificial vars aren't pushed, but everything else is. */ - if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl)) - gimple_add_tmp_var (decl); - - gimplify_and_add (decl_s, pre_p); - *expr_p = decl; - return GS_OK; -} - -/* Do C-specific gimplification. Args are as for gimplify_expr. */ +/* Do C-specific gimplification on *EXPR_P. PRE_P and POST_P are as in + gimplify_expr. */ int -c_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p ATTRIBUTE_UNUSED) +c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED, + gimple_seq *post_p ATTRIBUTE_UNUSED) { enum tree_code code = TREE_CODE (*expr_p); - switch (code) - { - case DECL_EXPR: - /* This is handled mostly by gimplify.c, but we have to deal with - not warning about int x = x; as it is a GCC extension to turn off - this warning but only if warn_init_self is zero. */ - if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL - && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) - && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) - && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) - == DECL_EXPR_DECL (*expr_p)) - && !warn_init_self) - TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; - return GS_UNHANDLED; - - case COMPOUND_LITERAL_EXPR: - return gimplify_compound_literal_expr (expr_p, pre_p); - - default: - return GS_UNHANDLED; - } + /* This is handled mostly by gimplify.c, but we have to deal with + not warning about int x = x; as it is a GCC extension to turn off + this warning but only if warn_init_self is zero. */ + if (code == DECL_EXPR + && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL + && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) + && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) + && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p)) + && !warn_init_self) + TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; + + return GS_UNHANDLED; }