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