gcc/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
   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 "varray.h"
  33 #include "c-tree.h"
  34 #include "c-common.h"
  35 #include "gimple.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"
  43 #include "flags.h"
  44 #include "rtl.h"
  45 #include "toplev.h"
  46 #include "tree-dump.h"
  47 #include "c-pretty-print.h"
  48 #include "cgraph.h"
  49
  50
  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.
  54
  55     Language-independent trees are based on the SIMPLE intermediate
  56     representation used in the McCAT compiler framework:
  57
  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.
  65
  66     http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
  67
  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.  */
  71
  72 /* Gimplification of statement trees.  */
  73
  74 /* Convert the tree representation of FNDECL from C frontend trees to
  75    GENERIC.  */
  76
  77 void
  78 c_genericize (tree fndecl)
  79 {
  80   FILE *dump_orig;
  81   int local_dump_flags;
  82   struct cgraph_node *cgn;
  83
  84   /* Dump the C-specific tree IR.  */
  85   dump_orig = dump_begin (TDI_original, &local_dump_flags);
  86   if (dump_orig)
  87     {
  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");
  95
  96       if (local_dump_flags & TDF_RAW)
  97         dump_node (DECL_SAVED_TREE (fndecl),
  98                    TDF_SLIM | local_dump_flags, dump_orig);
  99       else
 100         print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
 101       fprintf (dump_orig, "\n");
 102
 103       dump_end (TDI_original, dump_orig);
 104     }
 105
 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);
 110 }
 111
 112 static void
 113 add_block_to_enclosing (tree block)
 114 {
 115   unsigned i;
 116   tree enclosing;
 117   gimple bind;
 118   VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
 119
 120   for (i = 0; VEC_iterate (gimple, stack, i, bind); i++)
 121     if (gimple_bind_block (bind))
 122       break;
 123
 124   enclosing = gimple_bind_block (bind);
 125   BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
 126 }
 127
 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
 133      genericized.  */
 134
 135 tree
 136 c_build_bind_expr (location_t loc, tree block, tree body)
 137 {
 138   tree decls, bind;
 139
 140   if (block == NULL_TREE)
 141     decls = NULL_TREE;
 142   else if (TREE_CODE (block) == BLOCK)
 143     decls = BLOCK_VARS (block);
 144   else
 145     {
 146       decls = block;
 147       if (DECL_ARTIFICIAL (decls))
 148         block = NULL_TREE;
 149       else
 150         {
 151           block = make_node (BLOCK);
 152           BLOCK_VARS (block) = decls;
 153           add_block_to_enclosing (block);
 154         }
 155     }
 156
 157   if (!body)
 158     body = build_empty_stmt (loc);
 159   if (decls || block)
 160     {
 161       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
 162       TREE_SIDE_EFFECTS (bind) = 1;
 163       SET_EXPR_LOCATION (bind, loc);
 164     }
 165   else
 166     bind = body;
 167
 168   return bind;
 169 }
 170
 171 /* Gimplification of expression trees.  */
 172
 173 /* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
 174    gimplify_expr.  */
 175
 176 int
 177 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 178                  gimple_seq *post_p ATTRIBUTE_UNUSED)
 179 {
 180   enum tree_code code = TREE_CODE (*expr_p);
 181
 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))
 190       && !warn_init_self)
 191     TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
 192
 193   return GS_UNHANDLED;
 194 }