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