./ * c-common.def: Move FOR_STMT, WHILE_STMT, DO_STMT, BREAK_STMT, CONTINUE_STMT, and SWITCH_STMT to cp/cp-tree.def. * c-common.h (WHILE_COND, WHILE_BODY): Move to cp/cp-tree.h. (DO_COND, DO_BODY): Likewise. (FOR_INIT_STMT, FOR_COND, FOR_EXPR, FOR_BODY): Likewise. (SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE): Likewise. (c_common_stmt_codes): Remove FOR_STMT, WHILE_STMT, DO_STMT, BREAK_STMT, CONTINUE_STMT, and SWITCH_STMT. (build_continue_stmt, build_break_stmt): Don't declare. (c_do_switch_warnings): Update declaration. * c-gimplify.c (enum bc_t): Remove. (struct c_gimplify_ctx, ctxp): Remove. (push_context, pop_context): Remove static functions. (c_genericize): Don't call push_context or pop_context. (begin_bc_block, finish_bc_block): Remove static functions. (build_bc_goto): Likewise. (gimplify_c_loop): Likewise. (gimplify_for_stmt, gimplify_while_stmt): Likewise. (gimplify_do_stmt, gimplify_switch_stmt): Likewise. (c_gimplify_expr): Remove handling of FOR_STMT, WHILE_STMT, DO_STMT, SWITCH_STMT, CONTINUE_STMT, BREAK_STMT. * c-common.c (c_do_switch_warnings): Rename from c_do_switch_warnings_1. (c_do_switch_warnings) [old version]: Remove. (c_do_switch_expr_warnings): Remove. * c-typeck.c (c_finish_case): Call new c_do_switch_warnings function instead of c_do_switch_expr_warnings. * c-dump.c (c_dump_tree): Remove handling of BREAK_STMT, CONTINUE_STMT, DO_STMT, FOR_STMT, SWITCH_STMT, and WHILE_STMT. * c-pretty-print.c (pp_c_statement): Likewise. * c-semantics.c (build_break_stmt, build_continue_stmt): Remove. cp/ * cp-tree.def: Define FOR_STMT, WHILE_STMT, DO_STMT, BREAK_STMT, CONTINUE_STMT, SWITCH_STMT. * cp-tree.h (cp_stmt_codes): Add FOR_STMT, WHILE_STMT, DO_STMT, BREAK_STMT, CONTINUE_STMT, SWITCH_STMT. (WHILE_COND, WHILE_BODY): Define. (DO_COND, DO_BODY): Define. (FOR_INIT_STMT, FOR_COND, FOR_EXPR, FOR_BODY): Define. (SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE): Define. * cp-gimplify.c (enum bc_t): Define. (struct cp_gimplify_ctx, ctxp): Define. (push_context, pop_context): New static functions. (begin_bc_block, finish_bc_block): New static functions. (build_bc_goto): New static function. (gimplify_cp_loop, gimplify_for_stmt): New static functions. (gimplify_while_stmt, gimplify_do_stmt): Likewise. (gimplify_switch_stmt): Likewise. (cp_gimplify_expr): Handle FOR_STMT, WHILE_STMT, DO_STMT, SWITCH_STMT, CONTINUE_STMT, BREAK_STMT. (cp_genericize): Call push_context and pop_context. * semantics.c (finish_break_stmt): Just call build_stmt (BREAK_STMT) rather than build_break_stmt. (finish_continue_stmt): Corresponding change. * decl.c (pop_switch): Update call to c_do_switch_warnings for new parameters. * cxx-pretty-print.c (pp_cxx_statement): Handle SWITCH_STMT, WHILE_STMT, DO_STMT, FOR_STMT, BREAK_STMT, CONTINUE_STMT. * dump.c (cp_dump_tree): Likewise. From-SVN: r97885
203 lines
5.2 KiB
C
203 lines
5.2 KiB
C
/* This file contains the definitions and documentation for the common
|
|
tree codes used in the GNU C and C++ compilers (see c-common.def
|
|
for the standard codes).
|
|
Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
|
|
Free Software Foundation, Inc.
|
|
Written by Benjamin Chelf (chelf@codesourcery.com).
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "tm.h"
|
|
#include "tree.h"
|
|
#include "function.h"
|
|
#include "splay-tree.h"
|
|
#include "varray.h"
|
|
#include "c-common.h"
|
|
#include "except.h"
|
|
/* In order for the format checking to accept the C frontend
|
|
diagnostic framework extensions, you must define this token before
|
|
including toplev.h. */
|
|
#define GCC_DIAG_STYLE __gcc_cdiag__
|
|
#include "toplev.h"
|
|
#include "flags.h"
|
|
#include "ggc.h"
|
|
#include "rtl.h"
|
|
#include "output.h"
|
|
#include "timevar.h"
|
|
#include "predict.h"
|
|
#include "tree-inline.h"
|
|
#include "tree-gimple.h"
|
|
#include "langhooks.h"
|
|
|
|
/* Create an empty statement tree rooted at T. */
|
|
|
|
tree
|
|
push_stmt_list (void)
|
|
{
|
|
tree t;
|
|
t = alloc_stmt_list ();
|
|
TREE_CHAIN (t) = cur_stmt_list;
|
|
cur_stmt_list = t;
|
|
return t;
|
|
}
|
|
|
|
/* Finish the statement tree rooted at T. */
|
|
|
|
tree
|
|
pop_stmt_list (tree t)
|
|
{
|
|
tree u = cur_stmt_list, chain;
|
|
|
|
/* Pop statement lists until we reach the target level. The extra
|
|
nestings will be due to outstanding cleanups. */
|
|
while (1)
|
|
{
|
|
chain = TREE_CHAIN (u);
|
|
TREE_CHAIN (u) = NULL_TREE;
|
|
if (t == u)
|
|
break;
|
|
u = chain;
|
|
}
|
|
cur_stmt_list = chain;
|
|
|
|
/* If the statement list is completely empty, just return it. This is
|
|
just as good small as build_empty_stmt, with the advantage that
|
|
statement lists are merged when they appended to one another. So
|
|
using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
|
|
statements. */
|
|
if (TREE_SIDE_EFFECTS (t))
|
|
{
|
|
tree_stmt_iterator i = tsi_start (t);
|
|
|
|
/* If the statement list contained exactly one statement, then
|
|
extract it immediately. */
|
|
if (tsi_one_before_end_p (i))
|
|
{
|
|
u = tsi_stmt (i);
|
|
tsi_delink (&i);
|
|
free_stmt_list (t);
|
|
t = u;
|
|
}
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
/* T is a statement. Add it to the statement-tree. */
|
|
|
|
tree
|
|
add_stmt (tree t)
|
|
{
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
if ((EXPR_P (t) || STATEMENT_CODE_P (code)) && code != LABEL_EXPR)
|
|
{
|
|
if (!EXPR_HAS_LOCATION (t))
|
|
SET_EXPR_LOCATION (t, input_location);
|
|
|
|
/* When we expand a statement-tree, we must know whether or not the
|
|
statements are full-expressions. We record that fact here. */
|
|
STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
|
|
}
|
|
|
|
if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
|
|
STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
|
|
|
|
/* Add T to the statement-tree. Non-side-effect statements need to be
|
|
recorded during statement expressions. */
|
|
append_to_statement_list_force (t, &cur_stmt_list);
|
|
|
|
return t;
|
|
}
|
|
|
|
/* Build a generic statement based on the given type of node and
|
|
arguments. Similar to `build_nt', except that we set
|
|
EXPR_LOCATION to be the current source location. */
|
|
/* ??? This should be obsolete with the lineno_stmt productions
|
|
in the grammar. */
|
|
|
|
tree
|
|
build_stmt (enum tree_code code, ...)
|
|
{
|
|
tree ret;
|
|
int length, i;
|
|
va_list p;
|
|
bool side_effects;
|
|
|
|
va_start (p, code);
|
|
|
|
ret = make_node (code);
|
|
TREE_TYPE (ret) = void_type_node;
|
|
length = TREE_CODE_LENGTH (code);
|
|
SET_EXPR_LOCATION (ret, input_location);
|
|
|
|
/* Most statements have implicit side effects all on their own,
|
|
such as control transfer. For those that do, we'll compute
|
|
the real value of TREE_SIDE_EFFECTS from its arguments. */
|
|
switch (code)
|
|
{
|
|
case EXPR_STMT:
|
|
side_effects = false;
|
|
break;
|
|
default:
|
|
side_effects = true;
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
tree t = va_arg (p, tree);
|
|
if (t && !TYPE_P (t))
|
|
side_effects |= TREE_SIDE_EFFECTS (t);
|
|
TREE_OPERAND (ret, i) = t;
|
|
}
|
|
|
|
TREE_SIDE_EFFECTS (ret) = side_effects;
|
|
|
|
va_end (p);
|
|
return ret;
|
|
}
|
|
|
|
/* Let the back-end know about DECL. */
|
|
|
|
void
|
|
emit_local_var (tree decl)
|
|
{
|
|
/* Create RTL for this variable. */
|
|
if (!DECL_RTL_SET_P (decl))
|
|
{
|
|
if (DECL_HARD_REGISTER (decl))
|
|
/* The user specified an assembler name for this variable.
|
|
Set that up now. */
|
|
rest_of_decl_compilation (decl, 0, 0);
|
|
else
|
|
expand_decl (decl);
|
|
}
|
|
}
|
|
|
|
/* Create a CASE_LABEL_EXPR tree node and return it. */
|
|
|
|
tree
|
|
build_case_label (tree low_value, tree high_value, tree label_decl)
|
|
{
|
|
return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
|
|
}
|