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