gcc/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, 2003, 2004, 2005, 2007 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 "varray.h"
  32 #include "c-tree.h"
  33 #include "c-common.h"
  34 #include "tree-gimple.h"
  35 #include "hard-reg-set.h"
  36 #include "basic-block.h"
  37 #include "tree-flow.h"
  38 #include "tree-inline.h"
  39 #include "diagnostic.h"
  40 #include "langhooks.h"
  41 #include "langhooks-def.h"
  42 #include "flags.h"
  43 #include "rtl.h"
  44 #include "toplev.h"
  45 #include "tree-dump.h"
  46 #include "c-pretty-print.h"
  47 #include "cgraph.h"
  48
  49
  50 /*  The gimplification pass converts the language-dependent trees
  51     (ld-trees) emitted by the parser into language-independent trees
  52     (li-trees) that are the target of SSA analysis and transformations.
  53
  54     Language-independent trees are based on the SIMPLE intermediate
  55     representation used in the McCAT compiler framework:
  56
  57     "Designing the McCAT Compiler Based on a Family of Structured
  58     Intermediate Representations,"
  59     L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
  60     Proceedings of the 5th International Workshop on Languages and
  61     Compilers for Parallel Computing, no. 757 in Lecture Notes in
  62     Computer Science, New Haven, Connecticut, pp. 406-420,
  63     Springer-Verlag, August 3-5, 1992.
  64
  65     http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
  66
  67     Basically, we walk down gimplifying the nodes that we encounter.  As we
  68     walk back up, we check that they fit our constraints, and copy them
  69     into temporaries if not.  */
  70
  71 /* Gimplification of statement trees.  */
  72
  73 /* Convert the tree representation of FNDECL from C frontend trees to
  74    GENERIC.  */
  75
  76 void
  77 c_genericize (tree fndecl)
  78 {
  79   FILE *dump_orig;
  80   int local_dump_flags;
  81   struct cgraph_node *cgn;
  82
  83   /* Dump the C-specific tree IR.  */
  84   dump_orig = dump_begin (TDI_original, &local_dump_flags);
  85   if (dump_orig)
  86     {
  87       fprintf (dump_orig, "\n;; Function %s",
  88                lang_hooks.decl_printable_name (fndecl, 2));
  89       fprintf (dump_orig, " (%s)\n",
  90                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
  91       fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
  92       fprintf (dump_orig, "\n");
  93
  94       if (local_dump_flags & TDF_RAW)
  95         dump_node (DECL_SAVED_TREE (fndecl),
  96                    TDF_SLIM | local_dump_flags, dump_orig);
  97       else
  98         print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
  99       fprintf (dump_orig, "\n");
 100
 101       dump_end (TDI_original, dump_orig);
 102     }
 103
 104   /* Go ahead and gimplify for now.  */
 105   gimplify_function_tree (fndecl);
 106
 107   /* Dump the genericized tree IR.  */
 108   dump_function (TDI_generic, fndecl);
 109
 110   /* Genericize all nested functions now.  We do things in this order so
 111      that items like VLA sizes are expanded properly in the context of
 112      the correct function.  */
 113   cgn = cgraph_node (fndecl);
 114   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 115     c_genericize (cgn->decl);
 116 }
 117
 118 static void
 119 add_block_to_enclosing (tree block)
 120 {
 121   tree enclosing;
 122
 123   for (enclosing = gimple_current_bind_expr ();
 124        enclosing; enclosing = TREE_CHAIN (enclosing))
 125     if (BIND_EXPR_BLOCK (enclosing))
 126       break;
 127
 128   enclosing = BIND_EXPR_BLOCK (enclosing);
 129   BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
 130 }
 131
 132 /* Genericize a scope by creating a new BIND_EXPR.
 133    BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
 134      In the latter case, we need to create a new BLOCK and add it to the
 135      BLOCK_SUBBLOCKS of the enclosing block.
 136    BODY is a chain of C _STMT nodes for the contents of the scope, to be
 137      genericized.  */
 138
 139 tree
 140 c_build_bind_expr (tree block, tree body)
 141 {
 142   tree decls, bind;
 143
 144   if (block == NULL_TREE)
 145     decls = NULL_TREE;
 146   else if (TREE_CODE (block) == BLOCK)
 147     decls = BLOCK_VARS (block);
 148   else
 149     {
 150       decls = block;
 151       if (DECL_ARTIFICIAL (decls))
 152         block = NULL_TREE;
 153       else
 154         {
 155           block = make_node (BLOCK);
 156           BLOCK_VARS (block) = decls;
 157           add_block_to_enclosing (block);
 158         }
 159     }
 160
 161   if (!body)
 162     body = build_empty_stmt ();
 163   if (decls || block)
 164     {
 165       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
 166       TREE_SIDE_EFFECTS (bind) = 1;
 167     }
 168   else
 169     bind = body;
 170
 171   return bind;
 172 }
 173
 174 /* Gimplification of expression trees.  */
 175
 176 /* Gimplify a C99 compound literal expression.  This just means adding
 177    the DECL_EXPR before the current statement and using its anonymous
 178    decl instead.  */
 179
 180 static enum gimplify_status
 181 gimplify_compound_literal_expr (tree *expr_p, tree *pre_p)
 182 {
 183   tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (*expr_p);
 184   tree decl = DECL_EXPR_DECL (decl_s);
 185   /* Mark the decl as addressable if the compound literal
 186      expression is addressable now, otherwise it is marked too late
 187      after we gimplify the initialization expression.  */
 188   if (TREE_ADDRESSABLE (*expr_p))
 189     TREE_ADDRESSABLE (decl) = 1;
 190
 191   /* Preliminarily mark non-addressed complex variables as eligible
 192      for promotion to gimple registers.  We'll transform their uses
 193      as we find them.  */
 194   if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
 195        || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
 196       && !TREE_THIS_VOLATILE (decl)
 197       && !needs_to_live_in_memory (decl))
 198     DECL_GIMPLE_REG_P (decl) = 1;
 199
 200   /* This decl isn't mentioned in the enclosing block, so add it to the
 201      list of temps.  FIXME it seems a bit of a kludge to say that
 202      anonymous artificial vars aren't pushed, but everything else is.  */
 203   if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
 204     gimple_add_tmp_var (decl);
 205
 206   gimplify_and_add (decl_s, pre_p);
 207   *expr_p = decl;
 208   return GS_OK;
 209 }
 210
 211 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
 212    return a new CONSTRUCTOR if something changed.  */
 213
 214 static tree
 215 optimize_compound_literals_in_ctor (tree orig_ctor)
 216 {
 217   tree ctor = orig_ctor;
 218   VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
 219   unsigned int idx, num = VEC_length (constructor_elt, elts);
 220
 221   for (idx = 0; idx < num; idx++)
 222     {
 223       tree value = VEC_index (constructor_elt, elts, idx)->value;
 224       tree newval = value;
 225       if (TREE_CODE (value) == CONSTRUCTOR)
 226         newval = optimize_compound_literals_in_ctor (value);
 227       else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
 228         {
 229           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (value);
 230           tree decl = DECL_EXPR_DECL (decl_s);
 231           tree init = DECL_INITIAL (decl);
 232
 233           if (!TREE_ADDRESSABLE (value)
 234               && !TREE_ADDRESSABLE (decl)
 235               && init)
 236             newval = init;
 237         }
 238       if (newval == value)
 239         continue;
 240
 241       if (ctor == orig_ctor)
 242         {
 243           ctor = copy_node (orig_ctor);
 244           CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
 245           elts = CONSTRUCTOR_ELTS (ctor);
 246         }
 247       VEC_index (constructor_elt, elts, idx)->value = newval;
 248     }
 249   return ctor;
 250 }
 251
 252 /* Do C-specific gimplification.  Args are as for gimplify_expr.  */
 253
 254 int
 255 c_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p ATTRIBUTE_UNUSED)
 256 {
 257   enum tree_code code = TREE_CODE (*expr_p);
 258
 259   switch (code)
 260     {
 261     case DECL_EXPR:
 262       /* This is handled mostly by gimplify.c, but we have to deal with
 263          not warning about int x = x; as it is a GCC extension to turn off
 264          this warning but only if warn_init_self is zero.  */
 265       if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
 266           && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
 267           && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
 268           && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p))
 269               == DECL_EXPR_DECL (*expr_p))
 270           && !warn_init_self)
 271         TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
 272       return GS_UNHANDLED;
 273
 274     case COMPOUND_LITERAL_EXPR:
 275       return gimplify_compound_literal_expr (expr_p, pre_p);
 276
 277     case INIT_EXPR:
 278     case MODIFY_EXPR:
 279       if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == COMPOUND_LITERAL_EXPR)
 280         {
 281           tree complit = TREE_OPERAND (*expr_p, 1);
 282           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (complit);
 283           tree decl = DECL_EXPR_DECL (decl_s);
 284           tree init = DECL_INITIAL (decl);
 285
 286           /* struct T x = (struct T) { 0, 1, 2 } can be optimized
 287              into struct T x = { 0, 1, 2 } if the address of the
 288              compound literal has never been taken.  */
 289           if (!TREE_ADDRESSABLE (complit)
 290               && !TREE_ADDRESSABLE (decl)
 291               && init)
 292             {
 293               *expr_p = copy_node (*expr_p);
 294               TREE_OPERAND (*expr_p, 1) = init;
 295               return GS_OK;
 296             }
 297         }
 298       else if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR)
 299         {
 300           tree ctor
 301             = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
 302
 303           if (ctor != TREE_OPERAND (*expr_p, 1))
 304             {
 305               *expr_p = copy_node (*expr_p);
 306               TREE_OPERAND (*expr_p, 1) = ctor;
 307               return GS_OK;
 308             }
 309         }
 310       return GS_UNHANDLED;
 311
 312     default:
 313       return GS_UNHANDLED;
 314     }
 315 }