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