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     case LROTATE_EXPR:
 233     case RROTATE_EXPR:
 234       {
 235         /* We used to convert the right operand of a shift-expression
 236            to an integer_type_node in the FEs.  But it is unnecessary
 237            and not desirable for diagnostics and sanitizers.  We keep
 238            this here to not pessimize the code, but we convert to an
 239            unsigned type, because negative shift counts are undefined
 240            anyway.
 241            We should get rid of this conversion when we have a proper
 242            type demotion/promotion pass.  */
 243         tree *op1_p = &TREE_OPERAND (*expr_p, 1);
 244         if (!VECTOR_TYPE_P (TREE_TYPE (*op1_p))
 245             && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)),
 246                                     unsigned_type_node)
 247             && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)),
 248                                     integer_type_node))
 249           *op1_p = convert (unsigned_type_node, *op1_p);
 250         break;
 251       }
 252
 253     case DECL_EXPR:
 254       /* This is handled mostly by gimplify.c, but we have to deal with
 255          not warning about int x = x; as it is a GCC extension to turn off
 256          this warning but only if warn_init_self is zero.  */
 257       if (VAR_P (DECL_EXPR_DECL (*expr_p))
 258           && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
 259           && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
 260           && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
 261           && !warn_init_self)
 262         TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
 263       break;
 264
 265     case PREINCREMENT_EXPR:
 266     case PREDECREMENT_EXPR:
 267     case POSTINCREMENT_EXPR:
 268     case POSTDECREMENT_EXPR:
 269       {
 270         tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
 271         if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type))
 272           {
 273             if (!TYPE_OVERFLOW_WRAPS (type))
 274               type = unsigned_type_for (type);
 275             return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type);
 276           }
 277         break;
 278       }
 279
 280     case CILK_SPAWN_STMT:
 281       gcc_assert(fn_contains_cilk_spawn_p (cfun)
 282                  && cilk_detect_spawn_and_unwrap (expr_p));
 283
 284       if (!seen_error ())
 285         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 286       return GS_ERROR;
 287
 288     case MODIFY_EXPR:
 289     case INIT_EXPR:
 290     case CALL_EXPR:
 291       if (fn_contains_cilk_spawn_p (cfun)
 292           && cilk_detect_spawn_and_unwrap (expr_p)
 293           /* If an error is found, the spawn wrapper is removed and the
 294              original expression (MODIFY/INIT/CALL_EXPR) is processes as
 295              it is supposed to be.  */
 296           && !seen_error ())
 297         return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 298
 299     default:;
 300     }
 301
 302   return GS_UNHANDLED;
 303 }