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