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-2013 Free Software Foundation, Inc.
   6    Lowering of expressions contributed by Sebastian Pop <s.pop@laposte.net>
   7    Re-written to support lowering of whole function trees, documentation
   8    and miscellaneous cleanups by Diego Novillo <dnovillo@redhat.com>
   9
  10 This file is part of GCC.
  11
  12 GCC is free software; you can redistribute it and/or modify it under
  13 the terms of the GNU General Public License as published by the Free
  14 Software Foundation; either version 3, or (at your option) any later
  15 version.
  16
  17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with GCC; see the file COPYING3.  If not see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "c-common.h"
  32 #include "basic-block.h"
  33 #include "tree-ssa-alias.h"
  34 #include "internal-fn.h"
  35 #include "gimple-expr.h"
  36 #include "is-a.h"
  37 #include "gimple.h"
  38 #include "gimplify.h"
  39 #include "tree-inline.h"
  40 #include "diagnostic-core.h"
  41 #include "langhooks.h"
  42 #include "langhooks-def.h"
  43 #include "flags.h"
  44 #include "dumpfile.h"
  45 #include "c-pretty-print.h"
  46 #include "cgraph.h"
  47 #include "cilk.h"
  48
  49 /*  The gimplification pass converts the language-dependent trees
  50     (ld-trees) emitted by the parser into language-independent trees
  51     (li-trees) that are the target of SSA analysis and transformations.
  52
  53     Language-independent trees are based on the SIMPLE intermediate
  54     representation used in the McCAT compiler framework:
  55
  56     "Designing the McCAT Compiler Based on a Family of Structured
  57     Intermediate Representations,"
  58     L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
  59     Proceedings of the 5th International Workshop on Languages and
  60     Compilers for Parallel Computing, no. 757 in Lecture Notes in
  61     Computer Science, New Haven, Connecticut, pp. 406-420,
  62     Springer-Verlag, August 3-5, 1992.
  63
  64     http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
  65
  66     Basically, we walk down gimplifying the nodes that we encounter.  As we
  67     walk back up, we check that they fit our constraints, and copy them
  68     into temporaries if not.  */
  69
  70 /* Gimplification of statement trees.  */
  71
  72 /* Convert the tree representation of FNDECL from C frontend trees to
  73    GENERIC.  */
  74
  75 void
  76 c_genericize (tree fndecl)
  77 {
  78   FILE *dump_orig;
  79   int local_dump_flags;
  80   struct cgraph_node *cgn;
  81
  82   /* Dump the C-specific tree IR.  */
  83   dump_orig = dump_begin (TDI_original, &local_dump_flags);
  84   if (dump_orig)
  85     {
  86       fprintf (dump_orig, "\n;; Function %s",
  87                lang_hooks.decl_printable_name (fndecl, 2));
  88       fprintf (dump_orig, " (%s)\n",
  89                (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
  90                 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
  91       fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
  92       fprintf (dump_orig, "\n");
  93
  94       if (local_dump_flags & TDF_RAW)
  95         dump_node (DECL_SAVED_TREE (fndecl),
  96                    TDF_SLIM | local_dump_flags, dump_orig);
  97       else
  98         print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
  99       fprintf (dump_orig, "\n");
 100
 101       dump_end (TDI_original, dump_orig);
 102     }
 103
 104   /* Dump all nested functions now.  */
 105   cgn = cgraph_get_create_node (fndecl);
 106   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 107     c_genericize (cgn->decl);
 108 }
 109
 110 static void
 111 add_block_to_enclosing (tree block)
 112 {
 113   unsigned i;
 114   tree enclosing;
 115   gimple bind;
 116   vec<gimple> stack = gimple_bind_expr_stack ();
 117
 118   FOR_EACH_VEC_ELT (stack, i, bind)
 119     if (gimple_bind_block (bind))
 120       break;
 121
 122   enclosing = gimple_bind_block (bind);
 123   BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
 124 }
 125
 126 /* Genericize a scope by creating a new BIND_EXPR.
 127    BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
 128      In the latter case, we need to create a new BLOCK and add it to the
 129      BLOCK_SUBBLOCKS of the enclosing block.
 130    BODY is a chain of C _STMT nodes for the contents of the scope, to be
 131      genericized.  */
 132
 133 tree
 134 c_build_bind_expr (location_t loc, tree block, tree body)
 135 {
 136   tree decls, bind;
 137
 138   if (block == NULL_TREE)
 139     decls = NULL_TREE;
 140   else if (TREE_CODE (block) == BLOCK)
 141     decls = BLOCK_VARS (block);
 142   else
 143     {
 144       decls = block;
 145       if (DECL_ARTIFICIAL (decls))
 146         block = NULL_TREE;
 147       else
 148         {
 149           block = make_node (BLOCK);
 150           BLOCK_VARS (block) = decls;
 151           add_block_to_enclosing (block);
 152         }
 153     }
 154
 155   if (!body)
 156     body = build_empty_stmt (loc);
 157   if (decls || block)
 158     {
 159       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
 160       TREE_SIDE_EFFECTS (bind) = 1;
 161       SET_EXPR_LOCATION (bind, loc);
 162     }
 163   else
 164     bind = body;
 165
 166   return bind;
 167 }
 168
 169 /* Gimplification of expression trees.  */
 170
 171 /* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
 172    gimplify_expr.  */
 173
 174 int
 175 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 176                  gimple_seq *post_p ATTRIBUTE_UNUSED)
 177 {
 178   enum tree_code code = TREE_CODE (*expr_p);
 179
 180   switch (code)
 181     {
 182     case DECL_EXPR:
 183       /* This is handled mostly by gimplify.c, but we have to deal with
 184          not warning about int x = x; as it is a GCC extension to turn off
 185          this warning but only if warn_init_self is zero.  */
 186       if (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       break;
 193
 194     case PREINCREMENT_EXPR:
 195     case PREDECREMENT_EXPR:
 196     case POSTINCREMENT_EXPR:
 197     case POSTDECREMENT_EXPR:
 198       {
 199         tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
 200         if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type))
 201           {
 202             if (TYPE_OVERFLOW_UNDEFINED (type)
 203                 || ((flag_sanitize & SANITIZE_SI_OVERFLOW)
 204                     && !TYPE_OVERFLOW_WRAPS (type)))
 205               type = unsigned_type_for (type);
 206             return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type);
 207           }
 208         break;
 209       }
 210
 211     case CILK_SPAWN_STMT:
 212       gcc_assert
 213         (fn_contains_cilk_spawn_p (cfun)
 214          && cilk_detect_spawn_and_unwrap (expr_p));
 215
 216       /* If errors are seen, then just process it as a CALL_EXPR.  */
 217       if (!seen_error ())
 218         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 219
 220     case MODIFY_EXPR:
 221     case INIT_EXPR:
 222     case CALL_EXPR:
 223       if (fn_contains_cilk_spawn_p (cfun)
 224           && cilk_detect_spawn_and_unwrap (expr_p)
 225           /* If an error is found, the spawn wrapper is removed and the
 226              original expression (MODIFY/INIT/CALL_EXPR) is processes as
 227              it is supposed to be.  */
 228           && !seen_error ())
 229         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 230
 231     default:;
 232     }
 233
 234   return GS_UNHANDLED;
 235 }