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