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   if (EXPR_P (t) || STATEMENT_CODE_P (TREE_CODE (t)))
 132     {
 133       if (!EXPR_LOCUS (t))
 134         annotate_with_locus (t, input_location);
 135
 136       /* When we expand a statement-tree, we must know whether or not the
 137          statements are full-expressions.  We record that fact here.  */
 138       STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
 139     }
 140
 141   /* Add T to the statement-tree.  Non-side-effect statements need to be
 142      recorded during statement expressions.  */
 143   append_to_statement_list_force (t, &cur_stmt_list);
 144
 145   return t;
 146 }
 147
 148 /* Build a generic statement based on the given type of node and
 149    arguments. Similar to `build_nt', except that we set
 150    EXPR_LOCUS to be the current source location.  */
 151 /* ??? This should be obsolete with the lineno_stmt productions
 152    in the grammar.  */
 153
 154 tree
 155 build_stmt (enum tree_code code, ...)
 156 {
 157   tree ret;
 158   int length, i;
 159   va_list p;
 160   bool side_effects;
 161
 162   va_start (p, code);
 163
 164   ret = make_node (code);
 165   TREE_TYPE (ret) = void_type_node;
 166   length = TREE_CODE_LENGTH (code);
 167   annotate_with_locus (ret, input_location);
 168
 169   /* Most statements have implicit side effects all on their own,
 170      such as control transfer.  For those that do, we'll compute
 171      the real value of TREE_SIDE_EFFECTS from its arguments.  */
 172   switch (code)
 173     {
 174     case EXPR_STMT:
 175       side_effects = false;
 176       break;
 177     default:
 178       side_effects = true;
 179       break;
 180     }
 181
 182   for (i = 0; i < length; i++)
 183     {
 184       tree t = va_arg (p, tree);
 185       if (t && IS_NON_TYPE_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t))))
 186         side_effects |= TREE_SIDE_EFFECTS (t);
 187       TREE_OPERAND (ret, i) = t;
 188     }
 189
 190   TREE_SIDE_EFFECTS (ret) = side_effects;
 191
 192   va_end (p);
 193   return ret;
 194 }
 195
 196 /* Create RTL for the local static variable DECL.  */
 197
 198 void
 199 make_rtl_for_local_static (tree decl)
 200 {
 201   const char *asmspec = NULL;
 202
 203   /* If we inlined this variable, we could see it's declaration
 204      again.  */
 205   if (TREE_ASM_WRITTEN (decl))
 206     return;
 207
 208   /* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then
 209      either we already created RTL for this DECL (and since it was a
 210      local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent
 211      clashes with other local statics with the same name by a previous
 212      call to make_decl_rtl), or the user explicitly requested a
 213      particular assembly name for this variable, using the GNU
 214      extension for this purpose:
 215
 216        int i asm ("j");
 217
 218      There's no way to know which case we're in, here.  But, it turns
 219      out we're safe.  If there's already RTL, then
 220      rest_of_decl_compilation ignores the ASMSPEC parameter, so we
 221      may as well not pass it in.  If there isn't RTL, then we didn't
 222      already create RTL, which means that the modification to
 223      DECL_ASSEMBLER_NAME came only via the explicit extension.  */
 224   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
 225       && !DECL_RTL_SET_P (decl))
 226     asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 227
 228   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
 229 }
 230
 231 /* Let the back-end know about DECL.  */
 232
 233 void
 234 emit_local_var (tree decl)
 235 {
 236   /* Create RTL for this variable.  */
 237   if (!DECL_RTL_SET_P (decl))
 238     {
 239       if (DECL_HARD_REGISTER (decl))
 240         /* The user specified an assembler name for this variable.
 241            Set that up now.  */
 242         rest_of_decl_compilation
 243           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
 244            /*top_level=*/0, /*at_end=*/0);
 245       else
 246         expand_decl (decl);
 247     }
 248 }
 249
 250 /* Build a break statement node and return it.  */
 251
 252 tree
 253 build_break_stmt (void)
 254 {
 255   return (build_stmt (BREAK_STMT));
 256 }
 257
 258 /* Build a continue statement node and return it.  */
 259
 260 tree
 261 build_continue_stmt (void)
 262 {
 263   return (build_stmt (CONTINUE_STMT));
 264 }
 265
 266 /* Create a CASE_LABEL_EXPR tree node and return it.  */
 267
 268 tree
 269 build_case_label (tree low_value, tree high_value, tree label_decl)
 270 {
 271   return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
 272 }