gcc/c-semantics.c

   1 /* This file contains the definitions and documentation for the common
   2    tree codes used in the GNU C and C++ compilers (see c-common.def
   3    for the standard codes).
   4    Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   5    Written by Benjamin Chelf (chelf@codesourcery.com).
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to the Free
  21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 02111-1307, USA.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "tree.h"
  29 #include "function.h"
  30 #include "splay-tree.h"
  31 #include "varray.h"
  32 #include "c-common.h"
  33 #include "except.h"
  34 /* In order for the format checking to accept the C frontend
  35    diagnostic framework extensions, you must define this token before
  36    including toplev.h.  */
  37 #define GCC_DIAG_STYLE __gcc_cdiag__
  38 #include "toplev.h"
  39 #include "flags.h"
  40 #include "ggc.h"
  41 #include "rtl.h"
  42 #include "output.h"
  43 #include "timevar.h"
  44 #include "predict.h"
  45 #include "tree-inline.h"
  46 #include "tree-gimple.h"
  47 #include "langhooks.h"
  48
  49 /* Create an empty statement tree rooted at T.  */
  50
  51 tree
  52 push_stmt_list (void)
  53 {
  54   tree t;
  55   t = alloc_stmt_list ();
  56   TREE_CHAIN (t) = cur_stmt_list;
  57   cur_stmt_list = t;
  58   return t;
  59 }
  60
  61 /* Similarly, except that T may have already been pushed/popped, and
  62    thus may already contain statement(s).  Arrage for new statements
  63    to be appended.  */
  64
  65 tree
  66 re_push_stmt_list (tree t)
  67 {
  68   if (t)
  69     {
  70       if (TREE_CODE (t) != STATEMENT_LIST)
  71         {
  72           tree u = alloc_stmt_list ();
  73           append_to_statement_list_force (t, &u);
  74           t = u;
  75         }
  76     }
  77   else
  78     t = alloc_stmt_list ();
  79   TREE_CHAIN (t) = cur_stmt_list;
  80   cur_stmt_list = t;
  81   return t;
  82 }
  83
  84 /* Finish the statement tree rooted at T.  */
  85
  86 tree
  87 pop_stmt_list (tree t)
  88 {
  89   tree u = cur_stmt_list, chain;
  90
  91   /* Pop statement lists until we reach the target level.  The extra
  92      nestings will be due to outstanding cleanups.  */
  93   while (1)
  94     {
  95       chain = TREE_CHAIN (u);
  96       TREE_CHAIN (u) = NULL_TREE;
  97       if (t == u)
  98         break;
  99       u = chain;
 100     }
 101   cur_stmt_list = chain;
 102
 103   /* If the statement list is completely empty, just return it.  This is
 104      just as good small as build_empty_stmt, with the advantage that
 105      statement lists are merged when they appended to one another.  So
 106      using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
 107      statements.  */
 108   if (TREE_SIDE_EFFECTS (t))
 109     {
 110       tree_stmt_iterator i = tsi_start (t);
 111
 112       /* If the statement list contained exactly one statement, then
 113          extract it immediately.  */
 114       if (tsi_one_before_end_p (i))
 115         {
 116           u = tsi_stmt (i);
 117           tsi_delink (&i);
 118           free_stmt_list (t);
 119           t = u;
 120         }
 121     }
 122
 123   return t;
 124 }
 125
 126 /* T is a statement.  Add it to the statement-tree.  */
 127
 128 tree
 129 add_stmt (tree t)
 130 {
 131   enum tree_code code = TREE_CODE (t);
 132
 133   if ((EXPR_P (t) || STATEMENT_CODE_P (code)) && code != LABEL_EXPR)
 134     {
 135       if (!EXPR_HAS_LOCATION (t))
 136         SET_EXPR_LOCATION (t, input_location);
 137
 138       /* When we expand a statement-tree, we must know whether or not the
 139          statements are full-expressions.  We record that fact here.  */
 140       STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
 141     }
 142
 143   /* Add T to the statement-tree.  Non-side-effect statements need to be
 144      recorded during statement expressions.  */
 145   append_to_statement_list_force (t, &cur_stmt_list);
 146
 147   return t;
 148 }
 149
 150 /* Build a generic statement based on the given type of node and
 151    arguments. Similar to `build_nt', except that we set
 152    EXPR_LOCATION to be the current source location.  */
 153 /* ??? This should be obsolete with the lineno_stmt productions
 154    in the grammar.  */
 155
 156 tree
 157 build_stmt (enum tree_code code, ...)
 158 {
 159   tree ret;
 160   int length, i;
 161   va_list p;
 162   bool side_effects;
 163
 164   va_start (p, code);
 165
 166   ret = make_node (code);
 167   TREE_TYPE (ret) = void_type_node;
 168   length = TREE_CODE_LENGTH (code);
 169   SET_EXPR_LOCATION (ret, input_location);
 170
 171   /* Most statements have implicit side effects all on their own,
 172      such as control transfer.  For those that do, we'll compute
 173      the real value of TREE_SIDE_EFFECTS from its arguments.  */
 174   switch (code)
 175     {
 176     case EXPR_STMT:
 177       side_effects = false;
 178       break;
 179     default:
 180       side_effects = true;
 181       break;
 182     }
 183
 184   for (i = 0; i < length; i++)
 185     {
 186       tree t = va_arg (p, tree);
 187       if (t && IS_NON_TYPE_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t))))
 188         side_effects |= TREE_SIDE_EFFECTS (t);
 189       TREE_OPERAND (ret, i) = t;
 190     }
 191
 192   TREE_SIDE_EFFECTS (ret) = side_effects;
 193
 194   va_end (p);
 195   return ret;
 196 }
 197
 198 /* Let the back-end know about DECL.  */
 199
 200 void
 201 emit_local_var (tree decl)
 202 {
 203   /* Create RTL for this variable.  */
 204   if (!DECL_RTL_SET_P (decl))
 205     {
 206       if (DECL_HARD_REGISTER (decl))
 207         /* The user specified an assembler name for this variable.
 208            Set that up now.  */
 209         rest_of_decl_compilation (decl, 0, 0);
 210       else
 211         expand_decl (decl);
 212     }
 213 }
 214
 215 /* Build a break statement node and return it.  */
 216
 217 tree
 218 build_break_stmt (void)
 219 {
 220   return (build_stmt (BREAK_STMT));
 221 }
 222
 223 /* Build a continue statement node and return it.  */
 224
 225 tree
 226 build_continue_stmt (void)
 227 {
 228   return (build_stmt (CONTINUE_STMT));
 229 }
 230
 231 /* Create a CASE_LABEL_EXPR tree node and return it.  */
 232
 233 tree
 234 build_case_label (tree low_value, tree high_value, tree label_decl)
 235 {
 236   return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
 237 }