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   if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
 144     STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
 145
 146   /* Add T to the statement-tree.  Non-side-effect statements need to be
 147      recorded during statement expressions.  */
 148   append_to_statement_list_force (t, &cur_stmt_list);
 149
 150   return t;
 151 }
 152
 153 /* Build a generic statement based on the given type of node and
 154    arguments. Similar to `build_nt', except that we set
 155    EXPR_LOCATION to be the current source location.  */
 156 /* ??? This should be obsolete with the lineno_stmt productions
 157    in the grammar.  */
 158
 159 tree
 160 build_stmt (enum tree_code code, ...)
 161 {
 162   tree ret;
 163   int length, i;
 164   va_list p;
 165   bool side_effects;
 166
 167   va_start (p, code);
 168
 169   ret = make_node (code);
 170   TREE_TYPE (ret) = void_type_node;
 171   length = TREE_CODE_LENGTH (code);
 172   SET_EXPR_LOCATION (ret, input_location);
 173
 174   /* Most statements have implicit side effects all on their own,
 175      such as control transfer.  For those that do, we'll compute
 176      the real value of TREE_SIDE_EFFECTS from its arguments.  */
 177   switch (code)
 178     {
 179     case EXPR_STMT:
 180       side_effects = false;
 181       break;
 182     default:
 183       side_effects = true;
 184       break;
 185     }
 186
 187   for (i = 0; i < length; i++)
 188     {
 189       tree t = va_arg (p, tree);
 190       if (t && IS_NON_TYPE_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t))))
 191         side_effects |= TREE_SIDE_EFFECTS (t);
 192       TREE_OPERAND (ret, i) = t;
 193     }
 194
 195   TREE_SIDE_EFFECTS (ret) = side_effects;
 196
 197   va_end (p);
 198   return ret;
 199 }
 200
 201 /* Let the back-end know about DECL.  */
 202
 203 void
 204 emit_local_var (tree decl)
 205 {
 206   /* Create RTL for this variable.  */
 207   if (!DECL_RTL_SET_P (decl))
 208     {
 209       if (DECL_HARD_REGISTER (decl))
 210         /* The user specified an assembler name for this variable.
 211            Set that up now.  */
 212         rest_of_decl_compilation (decl, 0, 0);
 213       else
 214         expand_decl (decl);
 215     }
 216 }
 217
 218 /* Build a break statement node and return it.  */
 219
 220 tree
 221 build_break_stmt (void)
 222 {
 223   return (build_stmt (BREAK_STMT));
 224 }
 225
 226 /* Build a continue statement node and return it.  */
 227
 228 tree
 229 build_continue_stmt (void)
 230 {
 231   return (build_stmt (CONTINUE_STMT));
 232 }
 233
 234 /* Create a CASE_LABEL_EXPR tree node and return it.  */
 235
 236 tree
 237 build_case_label (tree low_value, tree high_value, tree label_decl)
 238 {
 239   return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
 240 }