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 "flags.h"
  44 #include "dumpfile.h"
  45 #include "c-pretty-print.h"
  46 #include "cgraph.h"
  47 #include "cilk.h"
  48 #include "c-ubsan.h"
  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 /* Callback for c_genericize.  */
  72
  73 static tree
  74 ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data)
  75 {
  76   hash_set<tree> *pset = (hash_set<tree> *) data;
  77
  78   /* Since walk_tree doesn't call the callback function on the decls
  79      in BIND_EXPR_VARS, we have to walk them manually.  */
  80   if (TREE_CODE (*tp) == BIND_EXPR)
  81     {
  82       for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
  83         {
  84           if (TREE_STATIC (decl))
  85             {
  86               *walk_subtrees = 0;
  87               continue;
  88             }
  89           walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset,
  90                      pset);
  91           walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset);
  92           walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset,
  93                      pset);
  94         }
  95     }
  96   else if (TREE_CODE (*tp) == ADDR_EXPR
  97            && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF)
  98     {
  99       ubsan_maybe_instrument_array_ref (&TREE_OPERAND (*tp, 0), true);
 100       /* Make sure ubsan_maybe_instrument_array_ref is not called again
 101          on the ARRAY_REF, the above call might not instrument anything
 102          as the index might be constant or masked, so ensure it is not
 103          walked again and walk its subtrees manually.  */
 104       tree aref = TREE_OPERAND (*tp, 0);
 105       pset->add (aref);
 106       *walk_subtrees = 0;
 107       walk_tree (&TREE_OPERAND (aref, 0), ubsan_walk_array_refs_r, pset, pset);
 108       walk_tree (&TREE_OPERAND (aref, 1), ubsan_walk_array_refs_r, pset, pset);
 109       walk_tree (&TREE_OPERAND (aref, 2), ubsan_walk_array_refs_r, pset, pset);
 110       walk_tree (&TREE_OPERAND (aref, 3), ubsan_walk_array_refs_r, pset, pset);
 111     }
 112   else if (TREE_CODE (*tp) == ARRAY_REF)
 113     ubsan_maybe_instrument_array_ref (tp, false);
 114   return NULL_TREE;
 115 }
 116
 117 /* Gimplification of statement trees.  */
 118
 119 /* Convert the tree representation of FNDECL from C frontend trees to
 120    GENERIC.  */
 121
 122 void
 123 c_genericize (tree fndecl)
 124 {
 125   FILE *dump_orig;
 126   int local_dump_flags;
 127   struct cgraph_node *cgn;
 128
 129   if (flag_sanitize & SANITIZE_BOUNDS)
 130     {
 131       hash_set<tree> pset;
 132       walk_tree (&DECL_SAVED_TREE (fndecl), ubsan_walk_array_refs_r, &pset,
 133                  &pset);
 134     }
 135
 136   /* Dump the C-specific tree IR.  */
 137   dump_orig = get_dump_info (TDI_original, &local_dump_flags);
 138   if (dump_orig)
 139     {
 140       fprintf (dump_orig, "\n;; Function %s",
 141                lang_hooks.decl_printable_name (fndecl, 2));
 142       fprintf (dump_orig, " (%s)\n",
 143                (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
 144                 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
 145       fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
 146       fprintf (dump_orig, "\n");
 147
 148       if (local_dump_flags & TDF_RAW)
 149         dump_node (DECL_SAVED_TREE (fndecl),
 150                    TDF_SLIM | local_dump_flags, dump_orig);
 151       else
 152         print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
 153       fprintf (dump_orig, "\n");
 154     }
 155
 156   /* Dump all nested functions now.  */
 157   cgn = cgraph_node::get_create (fndecl);
 158   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 159     c_genericize (cgn->decl);
 160 }
 161
 162 static void
 163 add_block_to_enclosing (tree block)
 164 {
 165   unsigned i;
 166   tree enclosing;
 167   gimple bind;
 168   vec<gimple> stack = gimple_bind_expr_stack ();
 169
 170   FOR_EACH_VEC_ELT (stack, i, bind)
 171     if (gimple_bind_block (bind))
 172       break;
 173
 174   enclosing = gimple_bind_block (bind);
 175   BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
 176 }
 177
 178 /* Genericize a scope by creating a new BIND_EXPR.
 179    BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
 180      In the latter case, we need to create a new BLOCK and add it to the
 181      BLOCK_SUBBLOCKS of the enclosing block.
 182    BODY is a chain of C _STMT nodes for the contents of the scope, to be
 183      genericized.  */
 184
 185 tree
 186 c_build_bind_expr (location_t loc, tree block, tree body)
 187 {
 188   tree decls, bind;
 189
 190   if (block == NULL_TREE)
 191     decls = NULL_TREE;
 192   else if (TREE_CODE (block) == BLOCK)
 193     decls = BLOCK_VARS (block);
 194   else
 195     {
 196       decls = block;
 197       if (DECL_ARTIFICIAL (decls))
 198         block = NULL_TREE;
 199       else
 200         {
 201           block = make_node (BLOCK);
 202           BLOCK_VARS (block) = decls;
 203           add_block_to_enclosing (block);
 204         }
 205     }
 206
 207   if (!body)
 208     body = build_empty_stmt (loc);
 209   if (decls || block)
 210     {
 211       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
 212       TREE_SIDE_EFFECTS (bind) = 1;
 213       SET_EXPR_LOCATION (bind, loc);
 214     }
 215   else
 216     bind = body;
 217
 218   return bind;
 219 }
 220
 221 /* Gimplification of expression trees.  */
 222
 223 /* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
 224    gimplify_expr.  */
 225
 226 int
 227 c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 228                  gimple_seq *post_p ATTRIBUTE_UNUSED)
 229 {
 230   enum tree_code code = TREE_CODE (*expr_p);
 231
 232   switch (code)
 233     {
 234     case DECL_EXPR:
 235       /* This is handled mostly by gimplify.c, but we have to deal with
 236          not warning about int x = x; as it is a GCC extension to turn off
 237          this warning but only if warn_init_self is zero.  */
 238       if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
 239           && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
 240           && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
 241           && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
 242           && !warn_init_self)
 243         TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
 244       break;
 245
 246     case PREINCREMENT_EXPR:
 247     case PREDECREMENT_EXPR:
 248     case POSTINCREMENT_EXPR:
 249     case POSTDECREMENT_EXPR:
 250       {
 251         tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
 252         if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type))
 253           {
 254             if (!TYPE_OVERFLOW_WRAPS (type))
 255               type = unsigned_type_for (type);
 256             return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type);
 257           }
 258         break;
 259       }
 260
 261     case CILK_SPAWN_STMT:
 262       gcc_assert
 263         (fn_contains_cilk_spawn_p (cfun)
 264          && cilk_detect_spawn_and_unwrap (expr_p));
 265
 266       /* If errors are seen, then just process it as a CALL_EXPR.  */
 267       if (!seen_error ())
 268         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 269
 270     case MODIFY_EXPR:
 271     case INIT_EXPR:
 272     case CALL_EXPR:
 273       if (fn_contains_cilk_spawn_p (cfun)
 274           && cilk_detect_spawn_and_unwrap (expr_p)
 275           /* If an error is found, the spawn wrapper is removed and the
 276              original expression (MODIFY/INIT/CALL_EXPR) is processes as
 277              it is supposed to be.  */
 278           && !seen_error ())
 279         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 280
 281     default:;
 282     }
 283
 284   return GS_UNHANDLED;
 285 }