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