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-2014 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 "c-upc-low.h"
  44 #include "flags.h"
  45 #include "dumpfile.h"
  46 #include "c-pretty-print.h"
  47 #include "cgraph.h"
  48 #include "cilk.h"
  49 #include "c-ubsan.h"
  50 #include "pointer-set.h"
  51
  52 /*  The gimplification pass converts the language-dependent trees
  53     (ld-trees) emitted by the parser into language-independent trees
  54     (li-trees) that are the target of SSA analysis and transformations.
  55
  56     Language-independent trees are based on the SIMPLE intermediate
  57     representation used in the McCAT compiler framework:
  58
  59     "Designing the McCAT Compiler Based on a Family of Structured
  60     Intermediate Representations,"
  61     L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
  62     Proceedings of the 5th International Workshop on Languages and
  63     Compilers for Parallel Computing, no. 757 in Lecture Notes in
  64     Computer Science, New Haven, Connecticut, pp. 406-420,
  65     Springer-Verlag, August 3-5, 1992.
  66
  67     http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
  68
  69     Basically, we walk down gimplifying the nodes that we encounter.  As we
  70     walk back up, we check that they fit our constraints, and copy them
  71     into temporaries if not.  */
  72
  73 /* Callback for c_genericize.  */
  74
  75 static tree
  76 ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data)
  77 {
  78   struct pointer_set_t *pset = (struct pointer_set_t *) data;
  79
  80   /* Since walk_tree doesn't call the callback function on the decls
  81      in BIND_EXPR_VARS, we have to walk them manually.  */
  82   if (TREE_CODE (*tp) == BIND_EXPR)
  83     {
  84       for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
  85         {
  86           if (TREE_STATIC (decl))
  87             {
  88               *walk_subtrees = 0;
  89               continue;
  90             }
  91           walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset,
  92                      pset);
  93           walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset);
  94           walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset,
  95                      pset);
  96         }
  97     }
  98   else if (TREE_CODE (*tp) == ADDR_EXPR
  99            && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF)
 100     ubsan_maybe_instrument_array_ref (&TREE_OPERAND (*tp, 0), true);
 101   else if (TREE_CODE (*tp) == ARRAY_REF)
 102     ubsan_maybe_instrument_array_ref (tp, false);
 103   return NULL_TREE;
 104 }
 105
 106 /* Gimplification of statement trees.  */
 107
 108 /* Convert the tree representation of FNDECL from C frontend trees to
 109    GENERIC.  */
 110
 111 static void
 112 c_common_genericize (tree fndecl)
 113 {
 114   FILE *dump_orig;
 115   int local_dump_flags;
 116   struct cgraph_node *cgn;
 117
 118   if (flag_sanitize & SANITIZE_BOUNDS)
 119     {
 120       struct pointer_set_t *pset = pointer_set_create ();
 121       walk_tree (&DECL_SAVED_TREE (fndecl), ubsan_walk_array_refs_r, pset,
 122                  pset);
 123       pointer_set_destroy (pset);
 124     }
 125
 126   /* Dump the C-specific tree IR.  */
 127   dump_orig = get_dump_info (TDI_original, &local_dump_flags);
 128   if (dump_orig)
 129     {
 130       fprintf (dump_orig, "\n;; Function %s",
 131                lang_hooks.decl_printable_name (fndecl, 2));
 132       fprintf (dump_orig, " (%s)\n",
 133                (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
 134                 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
 135       fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
 136       fprintf (dump_orig, "\n");
 137
 138       if (local_dump_flags & TDF_RAW)
 139         dump_node (DECL_SAVED_TREE (fndecl),
 140                    TDF_SLIM | local_dump_flags, dump_orig);
 141       else
 142         print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
 143       fprintf (dump_orig, "\n");
 144     }
 145
 146   /* Dump all nested functions now.  */
 147   cgn = cgraph_get_create_node (fndecl);
 148   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 149     c_genericize (cgn->decl);
 150 }
 151
 152 void
 153 c_genericize (tree fndecl)
 154 {
 155   if (flag_upc)
 156     upc_genericize (fndecl);
 157   c_common_genericize (fndecl);
 158 }
 159
 160 static void
 161 add_block_to_enclosing (tree block)
 162 {
 163   unsigned i;
 164   tree enclosing;
 165   gimple bind;
 166   vec<gimple> stack = gimple_bind_expr_stack ();
 167
 168   FOR_EACH_VEC_ELT (stack, i, bind)
 169     if (gimple_bind_block (bind))
 170       break;
 171
 172   enclosing = gimple_bind_block (bind);
 173   BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
 174 }
 175
 176 /* Genericize a scope by creating a new BIND_EXPR.
 177    BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
 178      In the latter case, we need to create a new BLOCK and add it to the
 179      BLOCK_SUBBLOCKS of the enclosing block.
 180    BODY is a chain of C _STMT nodes for the contents of the scope, to be
 181      genericized.  */
 182
 183 tree
 184 c_build_bind_expr (location_t loc, tree block, tree body)
 185 {
 186   tree decls, bind;
 187
 188   if (block == NULL_TREE)
 189     decls = NULL_TREE;
 190   else if (TREE_CODE (block) == BLOCK)
 191     decls = BLOCK_VARS (block);
 192   else
 193     {
 194       decls = block;
 195       if (DECL_ARTIFICIAL (decls))
 196         block = NULL_TREE;
 197       else
 198         {
 199           block = make_node (BLOCK);
 200           BLOCK_VARS (block) = decls;
 201           add_block_to_enclosing (block);
 202         }
 203     }
 204
 205   if (!body)
 206     body = build_empty_stmt (loc);
 207   if (decls || block)
 208     {
 209       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
 210       TREE_SIDE_EFFECTS (bind) = 1;
 211       SET_EXPR_LOCATION (bind, loc);
 212     }
 213   else
 214     bind = body;
 215
 216   return bind;
 217 }
 218
 219 /* Gimplification of expression trees.  */
 220
 221 /* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
 222    gimplify_expr.  */
 223
 224 int
 225 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 226                  gimple_seq *post_p ATTRIBUTE_UNUSED)
 227 {
 228   enum tree_code code = TREE_CODE (*expr_p);
 229
 230   switch (code)
 231     {
 232     case DECL_EXPR:
 233       /* This is handled mostly by gimplify.c, but we have to deal with
 234          not warning about int x = x; as it is a GCC extension to turn off
 235          this warning but only if warn_init_self is zero.  */
 236       if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
 237           && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
 238           && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
 239           && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
 240           && !warn_init_self)
 241         TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
 242       break;
 243
 244     case PREINCREMENT_EXPR:
 245     case PREDECREMENT_EXPR:
 246     case POSTINCREMENT_EXPR:
 247     case POSTDECREMENT_EXPR:
 248       {
 249         tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
 250         if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type))
 251           {
 252             if (!TYPE_OVERFLOW_WRAPS (type))
 253               type = unsigned_type_for (type);
 254             return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type);
 255           }
 256         break;
 257       }
 258
 259     case CILK_SPAWN_STMT:
 260       gcc_assert
 261         (fn_contains_cilk_spawn_p (cfun)
 262          && cilk_detect_spawn_and_unwrap (expr_p));
 263
 264       /* If errors are seen, then just process it as a CALL_EXPR.  */
 265       if (!seen_error ())
 266         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 267
 268     case MODIFY_EXPR:
 269     case INIT_EXPR:
 270     case CALL_EXPR:
 271       if (fn_contains_cilk_spawn_p (cfun)
 272           && cilk_detect_spawn_and_unwrap (expr_p)
 273           /* If an error is found, the spawn wrapper is removed and the
 274              original expression (MODIFY/INIT/CALL_EXPR) is processes as
 275              it is supposed to be.  */
 276           && !seen_error ())
 277         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 278
 279     default:;
 280     }
 281
 282   return GS_UNHANDLED;
 283 }