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