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 "expr.h"
  43 #include "output.h"
  44 #include "timevar.h"
  45 #include "predict.h"
  46 #include "tree-inline.h"
  47 #include "langhooks.h"
  48
  49 /* Create an empty statement tree rooted at T.  */
  50
  51 void
  52 begin_stmt_tree (tree *t)
  53 {
  54   /* We create a trivial EXPR_STMT so that last_tree is never NULL in
  55      what follows.  We remove the extraneous statement in
  56      finish_stmt_tree.  */
  57   *t = build_nt (EXPR_STMT, void_zero_node);
  58   last_tree = *t;
  59   last_expr_type = NULL_TREE;
  60   last_expr_filename = input_filename;
  61 }
  62
  63 /* T is a statement.  Add it to the statement-tree.  */
  64
  65 tree
  66 add_stmt (tree t)
  67 {
  68   if (!EXPR_LOCUS (t))
  69     annotate_with_locus (t, input_location);
  70
  71   /* Add T to the statement-tree.  */
  72   TREE_CHAIN (last_tree) = t;
  73   last_tree = t;
  74
  75   /* When we expand a statement-tree, we must know whether or not the
  76      statements are full-expressions.  We record that fact here.  */
  77   STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
  78
  79   return t;
  80 }
  81
  82 /* Create a declaration statement for the declaration given by the
  83    DECL.  */
  84
  85 void
  86 add_decl_stmt (tree decl)
  87 {
  88   tree decl_stmt;
  89
  90   /* We need the type to last until instantiation time.  */
  91   decl_stmt = build_stmt (DECL_STMT, decl);
  92   add_stmt (decl_stmt);
  93 }
  94
  95 /* Add a scope-statement to the statement-tree.  BEGIN_P indicates
  96    whether this statements opens or closes a scope.  PARTIAL_P is true
  97    for a partial scope, i.e, the scope that begins after a label when
  98    an object that needs a cleanup is created.  If BEGIN_P is nonzero,
  99    returns a new TREE_LIST representing the top of the SCOPE_STMT
 100    stack.  The TREE_PURPOSE is the new SCOPE_STMT.  If BEGIN_P is
 101    zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT,
 102    and whose TREE_PURPOSE is the matching SCOPE_STMT with
 103    SCOPE_BEGIN_P set.  */
 104
 105 tree
 106 add_scope_stmt (int begin_p, int partial_p)
 107 {
 108   tree *stack_ptr = current_scope_stmt_stack ();
 109   tree ss;
 110   tree top = *stack_ptr;
 111
 112   /* Build the statement.  */
 113   ss = build_stmt (SCOPE_STMT, NULL_TREE);
 114   SCOPE_BEGIN_P (ss) = begin_p;
 115   SCOPE_PARTIAL_P (ss) = partial_p;
 116
 117   /* Keep the scope stack up to date.  */
 118   if (begin_p)
 119     {
 120       top = tree_cons (ss, NULL_TREE, top);
 121       *stack_ptr = top;
 122     }
 123   else
 124     {
 125       if (partial_p != SCOPE_PARTIAL_P (TREE_PURPOSE (top)))
 126         abort ();
 127       TREE_VALUE (top) = ss;
 128       *stack_ptr = TREE_CHAIN (top);
 129     }
 130
 131   /* Add the new statement to the statement-tree.  */
 132   add_stmt (ss);
 133
 134   return top;
 135 }
 136
 137 /* Finish the statement tree rooted at T.  */
 138
 139 void
 140 finish_stmt_tree (tree *t)
 141 {
 142   tree stmt;
 143
 144   /* Remove the fake extra statement added in begin_stmt_tree.  */
 145   stmt = TREE_CHAIN (*t);
 146   *t = stmt;
 147   last_tree = NULL_TREE;
 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_LOCUS 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   length = TREE_CODE_LENGTH (code);
 168   annotate_with_locus (ret, input_location);
 169
 170   /* Most statements have implicit side effects all on their own,
 171      such as control transfer.  For those that do, we'll compute
 172      the real value of TREE_SIDE_EFFECTS from its arguments.  */
 173   switch (code)
 174     {
 175     case EXPR_STMT:
 176       side_effects = false;
 177       break;
 178     default:
 179       side_effects = true;
 180       break;
 181     }
 182
 183   for (i = 0; i < length; i++)
 184     {
 185       tree t = va_arg (p, tree);
 186       if (t && IS_NON_TYPE_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t))))
 187         side_effects |= TREE_SIDE_EFFECTS (t);
 188       TREE_OPERAND (ret, i) = t;
 189     }
 190
 191   TREE_SIDE_EFFECTS (ret) = side_effects;
 192
 193   va_end (p);
 194   return ret;
 195 }
 196
 197 /* Create RTL for the local static variable DECL.  */
 198
 199 void
 200 make_rtl_for_local_static (tree decl)
 201 {
 202   const char *asmspec = NULL;
 203
 204   /* If we inlined this variable, we could see it's declaration
 205      again.  */
 206   if (TREE_ASM_WRITTEN (decl))
 207     return;
 208
 209   /* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then
 210      either we already created RTL for this DECL (and since it was a
 211      local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent
 212      clashes with other local statics with the same name by a previous
 213      call to make_decl_rtl), or the user explicitly requested a
 214      particular assembly name for this variable, using the GNU
 215      extension for this purpose:
 216
 217        int i asm ("j");
 218
 219      There's no way to know which case we're in, here.  But, it turns
 220      out we're safe.  If there's already RTL, then
 221      rest_of_decl_compilation ignores the ASMSPEC parameter, so we
 222      may as well not pass it in.  If there isn't RTL, then we didn't
 223      already create RTL, which means that the modification to
 224      DECL_ASSEMBLER_NAME came only via the explicit extension.  */
 225   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
 226       && !DECL_RTL_SET_P (decl))
 227     asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 228
 229   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
 230 }
 231
 232 /* Let the back-end know about DECL.  */
 233
 234 void
 235 emit_local_var (tree decl)
 236 {
 237   /* Create RTL for this variable.  */
 238   if (!DECL_RTL_SET_P (decl))
 239     {
 240       if (DECL_HARD_REGISTER (decl))
 241         /* The user specified an assembler name for this variable.
 242            Set that up now.  */
 243         rest_of_decl_compilation
 244           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
 245            /*top_level=*/0, /*at_end=*/0);
 246       else
 247         expand_decl (decl);
 248     }
 249
 250   if (DECL_INITIAL (decl))
 251     {
 252       /* Actually do the initialization.  */
 253       if (stmts_are_full_exprs_p ())
 254         expand_start_target_temps ();
 255
 256       expand_decl_init (decl);
 257
 258       if (stmts_are_full_exprs_p ())
 259         expand_end_target_temps ();
 260     }
 261 }
 262
 263 /* Build the node for a return statement and return it.  */
 264
 265 tree
 266 build_return_stmt (tree expr)
 267 {
 268   return (build_stmt (RETURN_STMT, expr));
 269 }
 270
 271 /* Build a break statement node and return it.  */
 272
 273 tree
 274 build_break_stmt (void)
 275 {
 276   return (build_stmt (BREAK_STMT));
 277 }
 278
 279 /* Build a continue statement node and return it.  */
 280
 281 tree
 282 build_continue_stmt (void)
 283 {
 284   return (build_stmt (CONTINUE_STMT));
 285 }
 286
 287 /* Create a CASE_LABEL tree node and return it.  */
 288
 289 tree
 290 build_case_label (tree low_value, tree high_value, tree label_decl)
 291 {
 292   return build_stmt (CASE_LABEL, low_value, high_value, label_decl);
 293 }
 294
 295 /* We're about to expand T, a statement.  Set up appropriate context
 296    for the substitution.  */
 297
 298 void
 299 prep_stmt (tree t)
 300 {
 301   if (EXPR_LOCUS (t))
 302     input_location = *EXPR_LOCUS (t);
 303   current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
 304 }