gcc/c-family/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, 2009, 2010
   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 "c-common.h"
  33 #include "gimple.h"
  34 #include "tree-inline.h"
  35 #include "diagnostic-core.h"
  36 #include "langhooks.h"
  37 #include "langhooks-def.h"
  38 #include "flags.h"
  39 #include "dumpfile.h"
  40 #include "c-pretty-print.h"
  41 #include "cgraph.h"
  42
  43
  44 /*  The gimplification pass converts the language-dependent trees
  45     (ld-trees) emitted by the parser into language-independent trees
  46     (li-trees) that are the target of SSA analysis and transformations.
  47
  48     Language-independent trees are based on the SIMPLE intermediate
  49     representation used in the McCAT compiler framework:
  50
  51     "Designing the McCAT Compiler Based on a Family of Structured
  52     Intermediate Representations,"
  53     L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
  54     Proceedings of the 5th International Workshop on Languages and
  55     Compilers for Parallel Computing, no. 757 in Lecture Notes in
  56     Computer Science, New Haven, Connecticut, pp. 406-420,
  57     Springer-Verlag, August 3-5, 1992.
  58
  59     http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
  60
  61     Basically, we walk down gimplifying the nodes that we encounter.  As we
  62     walk back up, we check that they fit our constraints, and copy them
  63     into temporaries if not.  */
  64
  65 /* Gimplification of statement trees.  */
  66
  67 /* Convert the tree representation of FNDECL from C frontend trees to
  68    GENERIC.  */
  69
  70 void
  71 c_genericize (tree fndecl)
  72 {
  73   FILE *dump_orig;
  74   int local_dump_flags;
  75   struct cgraph_node *cgn;
  76
  77   /* Dump the C-specific tree IR.  */
  78   dump_orig = dump_begin (TDI_original, &local_dump_flags);
  79   if (dump_orig)
  80     {
  81       fprintf (dump_orig, "\n;; Function %s",
  82                lang_hooks.decl_printable_name (fndecl, 2));
  83       fprintf (dump_orig, " (%s)\n",
  84                (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
  85                 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
  86       fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
  87       fprintf (dump_orig, "\n");
  88
  89       if (local_dump_flags & TDF_RAW)
  90         dump_node (DECL_SAVED_TREE (fndecl),
  91                    TDF_SLIM | local_dump_flags, dump_orig);
  92       else
  93         print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
  94       fprintf (dump_orig, "\n");
  95
  96       dump_end (TDI_original, dump_orig);
  97     }
  98
  99   /* Dump all nested functions now.  */
 100   cgn = cgraph_get_create_node (fndecl);
 101   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 102     c_genericize (cgn->symbol.decl);
 103 }
 104
 105 static void
 106 add_block_to_enclosing (tree block)
 107 {
 108   unsigned i;
 109   tree enclosing;
 110   gimple bind;
 111   VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
 112
 113   FOR_EACH_VEC_ELT (gimple, stack, i, bind)
 114     if (gimple_bind_block (bind))
 115       break;
 116
 117   enclosing = gimple_bind_block (bind);
 118   BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
 119 }
 120
 121 /* Genericize a scope by creating a new BIND_EXPR.
 122    BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
 123      In the latter case, we need to create a new BLOCK and add it to the
 124      BLOCK_SUBBLOCKS of the enclosing block.
 125    BODY is a chain of C _STMT nodes for the contents of the scope, to be
 126      genericized.  */
 127
 128 tree
 129 c_build_bind_expr (location_t loc, tree block, tree body)
 130 {
 131   tree decls, bind;
 132
 133   if (block == NULL_TREE)
 134     decls = NULL_TREE;
 135   else if (TREE_CODE (block) == BLOCK)
 136     decls = BLOCK_VARS (block);
 137   else
 138     {
 139       decls = block;
 140       if (DECL_ARTIFICIAL (decls))
 141         block = NULL_TREE;
 142       else
 143         {
 144           block = make_node (BLOCK);
 145           BLOCK_VARS (block) = decls;
 146           add_block_to_enclosing (block);
 147         }
 148     }
 149
 150   if (!body)
 151     body = build_empty_stmt (loc);
 152   if (decls || block)
 153     {
 154       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
 155       TREE_SIDE_EFFECTS (bind) = 1;
 156       SET_EXPR_LOCATION (bind, loc);
 157     }
 158   else
 159     bind = body;
 160
 161   return bind;
 162 }
 163
 164 /* Gimplification of expression trees.  */
 165
 166 /* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
 167    gimplify_expr.  */
 168
 169 int
 170 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 171                  gimple_seq *post_p ATTRIBUTE_UNUSED)
 172 {
 173   enum tree_code code = TREE_CODE (*expr_p);
 174
 175   /* This is handled mostly by gimplify.c, but we have to deal with
 176      not warning about int x = x; as it is a GCC extension to turn off
 177      this warning but only if warn_init_self is zero.  */
 178   if (code == DECL_EXPR
 179       && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
 180       && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
 181       && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
 182       && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
 183       && !warn_init_self)
 184     TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
 185
 186   return GS_UNHANDLED;
 187 }