+2000-07-01 Benjamin Chelf <chelf@codesourcery.com>
+
+ * Makefile.in (C_AND_OBJC_OBJS): Added c-semantics.o.
+ (c-semantics.o): New target.
+
+ * c-common.h (TREE_LANG_FLAG_?): Added documentation.
+ (genrtl_do_pushlevel): Moved from cp/cp-tree.h.
+ (genrtl_clear_out_block): Likewise.
+ (genrtl_goto_stmt): Likewise.
+ (genrtl_expr_stmt): Likewise.
+ (genrtl_decl_stmt): Likewise.
+ (genrtl_if_stmt): Likewise.
+ (genrtl_while_stmt): Likewise.
+ (genrtl_do_stmt): Likewise.
+ (genrtl_return_stmt): Likewise.
+ (genrtl_for_stmt): Likewise.
+ (genrtl_break_stmt): Likewise.
+ (genrtl_continue_stmt): Likewise.
+ (genrtl_scope_stmt): Likewise.
+ (genrtl_switch_stmt): Likewise.
+ (genrtl_case_label): Likewise.
+ (genrtl_begin_compound_stmt): Likewise.
+ (gerntl_finish_compound_stmt): Likewise.
+ (genrtl_compound_stmt): Likewise.
+ (genrtl_asm_stmt): Likewise.
+ (genrtl_decl_cleanup): Likewise.
+ (DECL_ANON_UNION_ELEMS): Likewise.
+ (emit_local_var): Likewise.
+ (make_rtl_for_local_static): Likewise.
+ (expand_cond): Likewise.
+ (expand_stmt): Likewise.
+ (c_expand_return): Likewise.
+ (c_expand_start_case): Likewise.
+ (do_case): Likewise.
+ (COMPOUND_STMT_NO_SCOPE): Likewise.
+ (c_expand_asm_operands): Likewise.
+ (NEW_FOR_SCOPE_P): New macro.
+ (expand_expr_stmt_fn): New type.
+
+ (set_current_function_name_declared): Likewise.
+ (current_function_name_declared): Likewise.
+ (lang_expand_stmt): Likewise.
+ (stmts_are_full_exprs_p): Likewise.
+ (anon_aggr_type_p): Likewise.
+ (lang_expand_expr_stmt): Likewise.
+ (build_case_label): Likewise.
+
+ * c-decl.c (lang_expand_expr_stmt): Initialize.
+ (stmts_are_full_exprs_p): Define.
+ (current_function_name_declared): Likewise.
+ (do_case): Likewise.
+ (lang_expand_stmt): Likewise.
+ (set_current_function_name_declared): Likewise.
+ (anon_aggr_type_p): Likewise.
+ (build_case_label): Likewise.
+
+ * c-semantics.c: New file.
+ (expand_cond): Moved from cp/semantics.c.
+ (genrtl_do_pushlevel): Likewise.
+ (genrtl_clear_out_block): Likewise.
+ (genrtl_goto_stmt): Likewise.
+ (genrtl_expr_stmt): Likewise.
+ (genrtl_decl_stmt): Likewise.
+ (genrtl_if_stmt): Likewise.
+ (genrtl_while_stmt): Likewise.
+ (genrtl_do_stmt): Likewise.
+ (genrtl_return_stmt): Likewise.
+ (genrtl_for_stmt): Likewise.
+ (genrtl_break_stmt): Likewise.
+ (genrtl_continue_stmt): Likewise.
+ (genrtl_scope_stmt): Likewise.
+ (genrtl_switch_stmt): Likewise.
+ (genrtl_case_label): Likewise.
+ (genrtl_begin_compound_stmt): Likewise.
+ (genrtl_finish_compound_stmt): Likewise.
+ (genrtl_compound_stmt): Likewise.
+ (genrtl_asm_stmt): Likewise.
+ (genrtl_decl_cleanup): Likewise.
+ (make_rtl_for_local_static): Moved from cp/decl.c.
+ (emit_local_var): Likewise.
+ (expand_stmt): Define.
+
+ * c-tree.h: (c_expand_asm_operands): Moved to c-common.h.
+ (c_expand_return): Likewise.
+ (c_expand_start_case): Likewise.
+
2000-07-01 Richard Henderson <rth@cygnus.com>
* config/ia64/ia64.c (symbolic_operand): Reject CONST expressions
# Language-specific object files for C and Objective C.
C_AND_OBJC_OBJS = c-lex.o c-pragma.o c-decl.o c-typeck.o c-convert.o \
- c-aux-info.o c-common.o c-iterate.o @extra_c_objs@
+ c-aux-info.o c-common.o c-iterate.o c-semantics.o @extra_c_objs@
# Language-specific object files for C.
C_OBJS = c-parse.o c-lang.o $(C_AND_OBJC_OBJS)
c-common.h flags.h toplev.h output.h c-pragma.h $(RTL_H) $(GGC_H) \
$(EXPR_H)
+c-semantics.o : c-semantics.c $(CONFIG_H) system.h $(TREE_H) c-tree.h c-lex.h \
+ c-common.h flags.h toplev.h output.h c-pragma.h $(RTL_H) $(GGC_H) \
+ $(EXPR_H)
+
# Language-independent files.
DRIVER_DEFINES = \
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+/* Usage of TREE_LANG_FLAG_?:
+ 0: COMPOUND_STMT_NO_SCOPE (in COMPOUND_STMT).
+ TREE_NEGATED_INT (in INTEGER_CST).
+ IDENTIFIER_MARKED (used by search routines).
+ SCOPE_BEGIN_P (in SCOPE_STMT)
+ DECL_PRETTY_FUNCTION_P (in VAR_DECL)
+ NEW_FOR_SCOPE_P (in FOR_STMT)
+ 1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
+ STMT_IS_FULL_EXPR_P (in _STMT)
+ 2: STMT_LINENO_FOR_FN_P (in _STMT)
+ 3: SCOPE_NO_CLEANUPS_P (in SCOPE_STMT)
+ 4: SCOPE_PARTIAL_P (in SCOPE_STMT)
+*/
+
/* Reserved identifiers. */
enum rid
extern int self_promoting_args_p PARAMS ((tree));
extern tree simple_type_promotes_to PARAMS ((tree));
-\f
/* These macros provide convenient access to the various _STMT nodes
created when parsing template declarations. */
#define STMT_LINENO_FOR_FN_P(NODE) \
(TREE_LANG_FLAG_2 ((NODE)))
+/* Nonzero if we want the new ISO rules for pushing a new scope for `for'
+ initialization variables. */
+#define NEW_FOR_SCOPE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
#undef DEFTREECODE
extern void add_c_tree_codes PARAMS ((void));
-\f
+extern void genrtl_do_pushlevel PARAMS ((void));
+extern void genrtl_clear_out_block PARAMS ((void));
+extern void genrtl_goto_stmt PARAMS ((tree));
+extern void genrtl_expr_stmt PARAMS ((tree));
+extern void genrtl_decl_stmt PARAMS ((tree));
+extern void genrtl_if_stmt PARAMS ((tree));
+extern void genrtl_while_stmt PARAMS ((tree));
+extern void genrtl_do_stmt PARAMS ((tree));
+extern void genrtl_return_stmt PARAMS ((tree));
+extern void genrtl_for_stmt PARAMS ((tree));
+extern void genrtl_break_stmt PARAMS ((void));
+extern void genrtl_continue_stmt PARAMS ((void));
+extern void genrtl_scope_stmt PARAMS ((tree));
+extern void genrtl_switch_stmt PARAMS ((tree));
+extern void genrtl_case_label PARAMS ((tree, tree));
+extern tree genrtl_begin_compound_stmt PARAMS ((int));
+extern tree genrtl_finish_compound_stmt PARAMS ((int));
+extern tree genrtl_compound_stmt PARAMS ((tree));
+extern void genrtl_asm_stmt PARAMS ((tree, tree,
+ tree, tree,
+ tree));
+extern void genrtl_decl_cleanup PARAMS ((tree, tree));
+extern int stmts_are_full_exprs_p PARAMS ((void));
+typedef void (*expand_expr_stmt_fn) PARAMS ((tree));
+extern expand_expr_stmt_fn lang_expand_expr_stmt;
+extern int anon_aggr_type_p PARAMS ((tree));
+
+/* For a VAR_DECL that is an anonymous union, these are the various
+ sub-variables that make up the anonymous union. */
+#define DECL_ANON_UNION_ELEMS(NODE) DECL_ARGUMENTS ((NODE))
+
+extern void emit_local_var PARAMS ((tree));
+extern void make_rtl_for_local_static PARAMS ((tree));
+extern tree expand_cond PARAMS ((tree));
+extern tree expand_stmt PARAMS ((tree));
+extern tree lang_expand_stmt PARAMS ((tree));
+extern void c_expand_return PARAMS ((tree));
+extern tree c_expand_start_case PARAMS ((tree));
+extern void do_case PARAMS ((tree, tree));
+extern tree build_case_label PARAMS ((tree, tree));
+
+#define COMPOUND_STMT_NO_SCOPE(NODE) TREE_LANG_FLAG_0 (NODE)
+
+extern void c_expand_asm_operands PARAMS ((tree, tree, tree, tree, int, const char *, int));
+extern int current_function_name_declared PARAMS ((void));
+extern void set_current_function_name_declared PARAMS ((int));
/* These functions must be defined by each front-end which implements
a variant of the C language. They are used in c-common.c. */
Given two compatible ANSI C types, returns the merged type. */
extern tree common_type PARAMS ((tree, tree));
-
int warn_multichar = 1;
+/* Wrapper since C and C++ expand_expr_stmt are different. */
+
+expand_expr_stmt_fn lang_expand_expr_stmt = c_expand_expr_stmt;
+
/* The variant of the C language being processed. */
c_language_kind c_language = clk_c;
else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
ggc_mark (TYPE_LANG_SPECIFIC (t));
}
+
+/* The functions below are required for functionality of doing
+ function at once processing in the C front end. Currently these
+ functions are not called from anywhere in the C front end, but as
+ these changes continue, that will change. */
+
+/* Returns non-zero if the current statement is a full expression,
+ i.e. temporaries created during that statement should be destroyed
+ at the end of the statement. */
+
+int
+stmts_are_full_exprs_p ()
+{
+ return 0;
+}
+
+/* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
+ C. */
+
+int
+anon_aggr_type_p (node)
+ tree node;
+{
+ return 0;
+}
+
+/* One if we have already declared __FUNCTION__ (and related
+ variables) in the current function. Two if we are in the process
+ of doing so. */
+
+int
+current_function_name_declared ()
+{
+ abort ();
+ return 0;
+}
+
+/* Code to generate the RTL for a case label in C. */
+
+void
+do_case (low_value, high_value)
+ tree low_value;
+ tree high_value;
+{
+ abort ();
+}
+
+/* Language specific handler of tree nodes used when generating RTL
+ from a tree. */
+
+tree
+lang_expand_stmt (t)
+ tree t;
+{
+ abort ();
+ return NULL_TREE;
+}
+
+/* Accessor to set the 'current_function_name_declared' flag. */
+
+void
+set_current_function_name_declared (i)
+ int i;
+{
+ abort ();
+}
--- /dev/null
+/* 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 Free Software Foundation, Inc. Written by
+ Benjamin Chelf (chelf@codesourcery.com).
+
+This file is part of GNU CC.
+
+GNU CC 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.
+
+GNU CC 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 GNU CC; 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 "tree.h"
+#include "function.h"
+#include "splay-tree.h"
+#include "varray.h"
+#include "c-common.h"
+#include "except.h"
+#include "toplev.h"
+#include "flags.h"
+#include "ggc.h"
+#include "rtl.h"
+#include "output.h"
+#include "timevar.h"
+
+/* Some statements, like for-statements or if-statements, require a
+ condition. This condition can be a declaration. If T is such a
+ declaration it is processed, and an expression appropriate to use
+ as the condition is returned. Otherwise, T itself is returned. */
+
+tree
+expand_cond (t)
+ tree t;
+{
+ if (t && TREE_CODE (t) == TREE_LIST)
+ {
+ expand_stmt (TREE_PURPOSE (t));
+ return TREE_VALUE (t);
+ }
+ else
+ return t;
+}
+
+/* Create RTL for the local static variable DECL. */
+
+void
+make_rtl_for_local_static (decl)
+ tree decl;
+{
+ const char *asmspec = NULL;
+
+ /* If we inlined this variable, we could see it's declaration
+ again. */
+ if (DECL_RTL (decl))
+ return;
+
+ if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
+ {
+ /* The only way this situaton can occur is if the
+ user specified a name for this DECL using the
+ `attribute' syntax. */
+ asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+ DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
+ }
+
+ rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
+}
+
+/* Let the back-end know about DECL. */
+
+void
+emit_local_var (decl)
+ tree decl;
+{
+ /* Create RTL for this variable. */
+ if (!DECL_RTL (decl))
+ {
+ if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
+ /* The user must have specified an assembler name for this
+ variable. Set that up now. */
+ rest_of_decl_compilation
+ (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
+ /*top_level=*/0, /*at_end=*/0);
+ else
+ expand_decl (decl);
+ }
+
+ /* Actually do the initialization. */
+ if (stmts_are_full_exprs_p ())
+ expand_start_target_temps ();
+
+ expand_decl_init (decl);
+
+ if (stmts_are_full_exprs_p ())
+ expand_end_target_temps ();
+}
+
+/* Helper for generating the RTL at the beginning of a scope. */
+
+void
+genrtl_do_pushlevel ()
+{
+ emit_line_note (input_filename, lineno);
+ clear_last_expr ();
+}
+
+/* Helper for generating the RTL. */
+
+void
+genrtl_clear_out_block ()
+{
+ /* If COND wasn't a declaration, clear out the
+ block we made for it and start a new one here so the
+ optimization in expand_end_loop will work. */
+ if (getdecls () == NULL_TREE)
+ genrtl_do_pushlevel ();
+}
+
+/* Generate the RTL for DESTINATION, which is a GOTO_STMT. */
+
+void
+genrtl_goto_stmt (destination)
+ tree destination;
+{
+ if (TREE_CODE (destination) == IDENTIFIER_NODE)
+ abort ();
+
+ /* We warn about unused labels with -Wunused. That means we have to
+ mark the used labels as used. */
+ if (TREE_CODE (destination) == LABEL_DECL)
+ TREE_USED (destination) = 1;
+
+ emit_line_note (input_filename, lineno);
+
+ if (TREE_CODE (destination) == LABEL_DECL)
+ {
+ label_rtx (destination);
+ expand_goto (destination);
+ }
+ else
+ expand_computed_goto (destination);
+}
+
+/* Generate the RTL for EXPR, which is an EXPR_STMT. */
+
+void
+genrtl_expr_stmt (expr)
+ tree expr;
+{
+ if (expr != NULL_TREE)
+ {
+ emit_line_note (input_filename, lineno);
+
+ if (stmts_are_full_exprs_p ())
+ expand_start_target_temps ();
+
+ lang_expand_expr_stmt (expr);
+
+ if (stmts_are_full_exprs_p ())
+ expand_end_target_temps ();
+ }
+}
+
+/* Generate the RTL for T, which is a DECL_STMT. */
+
+void
+genrtl_decl_stmt (t)
+ tree t;
+{
+ tree decl;
+ emit_line_note (input_filename, lineno);
+ decl = DECL_STMT_DECL (t);
+ /* If this is a declaration for an automatic local
+ variable, initialize it. Note that we might also see a
+ declaration for a namespace-scope object (declared with
+ `extern'). We don't have to handle the initialization
+ of those objects here; they can only be declarations,
+ rather than definitions. */
+ if (TREE_CODE (decl) == VAR_DECL
+ && !TREE_STATIC (decl)
+ && !DECL_EXTERNAL (decl))
+ {
+ /* Let the back-end know about this variable. */
+ if (!anon_aggr_type_p (TREE_TYPE (decl)))
+ emit_local_var (decl);
+ else
+ expand_anon_union_decl (decl, NULL_TREE,
+ DECL_ANON_UNION_ELEMS (decl));
+ }
+ else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
+ {
+ if (DECL_ARTIFICIAL (decl) && ! TREE_USED (decl))
+ /* Do not emit unused decls. This is not just an
+ optimization. We really do not want to emit
+ __PRETTY_FUNCTION__ etc, if they're never used. */
+ DECL_IGNORED_P (decl) = 1;
+ else
+ make_rtl_for_local_static (decl);
+ }
+}
+
+/* Generate the RTL for T, which is an IF_STMT. */
+
+void
+genrtl_if_stmt (t)
+ tree t;
+{
+ tree cond;
+ genrtl_do_pushlevel ();
+ cond = expand_cond (IF_COND (t));
+ emit_line_note (input_filename, lineno);
+ expand_start_cond (cond, 0);
+ if (THEN_CLAUSE (t))
+ expand_stmt (THEN_CLAUSE (t));
+ if (ELSE_CLAUSE (t))
+ {
+ expand_start_else ();
+ expand_stmt (ELSE_CLAUSE (t));
+ }
+ expand_end_cond ();
+}
+
+/* Generate the RTL for T, which is a WHILE_STMT. */
+
+void
+genrtl_while_stmt (t)
+ tree t;
+{
+ tree cond;
+ emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop (1);
+ genrtl_do_pushlevel ();
+
+ cond = expand_cond (WHILE_COND (t));
+ emit_line_note (input_filename, lineno);
+ expand_exit_loop_if_false (0, cond);
+ genrtl_clear_out_block ();
+
+ expand_stmt (WHILE_BODY (t));
+
+ expand_end_loop ();
+}
+
+/* Generate the RTL for T, which is a DO_STMT. */
+
+void
+genrtl_do_stmt (t)
+ tree t;
+{
+ tree cond;
+ emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop_continue_elsewhere (1);
+
+ expand_stmt (DO_BODY (t));
+
+ expand_loop_continue_here ();
+
+ cond = expand_cond (DO_COND (t));
+ emit_line_note (input_filename, lineno);
+ expand_exit_loop_if_false (0, cond);
+ expand_end_loop ();
+}
+
+/* Generate the RTL for EXPR, which is a RETURN_STMT. */
+
+void
+genrtl_return_stmt (expr)
+ tree expr;
+{
+ emit_line_note (input_filename, lineno);
+ c_expand_return (expr);
+}
+
+/* Generate the RTL for T, which is a FOR_STMT. */
+
+void
+genrtl_for_stmt (t)
+ tree t;
+{
+ tree tmp;
+ tree cond;
+ if (NEW_FOR_SCOPE_P (t))
+ genrtl_do_pushlevel ();
+
+ expand_stmt (FOR_INIT_STMT (t));
+
+ emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop_continue_elsewhere (1);
+ genrtl_do_pushlevel ();
+ cond = expand_cond (FOR_COND (t));
+ emit_line_note (input_filename, lineno);
+ if (cond)
+ expand_exit_loop_if_false (0, cond);
+ genrtl_clear_out_block ();
+ tmp = FOR_EXPR (t);
+
+ expand_stmt (FOR_BODY (t));
+
+ emit_line_note (input_filename, lineno);
+ expand_loop_continue_here ();
+ if (tmp)
+ genrtl_expr_stmt (tmp);
+ expand_end_loop ();
+}
+
+/* Generate the RTL for a BREAK_STMT. */
+
+void
+genrtl_break_stmt ()
+{
+ emit_line_note (input_filename, lineno);
+ if ( ! expand_exit_something ())
+ error ("break statement not within loop or switch");
+}
+
+/* Generate the RTL for a CONTINUE_STMT. */
+
+void
+genrtl_continue_stmt ()
+{
+ emit_line_note (input_filename, lineno);
+ if (! expand_continue_loop (0))
+ error ("continue statement not within a loop");
+}
+
+/* Generate the RTL for T, which is a SCOPE_STMT. */
+
+void
+genrtl_scope_stmt (t)
+ tree t;
+{
+ if (!SCOPE_NO_CLEANUPS_P (t))
+ {
+ if (SCOPE_BEGIN_P (t))
+ expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t),
+ SCOPE_STMT_BLOCK (t));
+ else if (SCOPE_END_P (t))
+ expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0);
+ }
+ else if (!SCOPE_NULLIFIED_P (t))
+ {
+ rtx note = emit_note (NULL,
+ (SCOPE_BEGIN_P (t)
+ ? NOTE_INSN_BLOCK_BEG
+ : NOTE_INSN_BLOCK_END));
+ NOTE_BLOCK (note) = SCOPE_STMT_BLOCK (t);
+ }
+}
+
+/* Generate the RTL for T, which is a SWITCH_STMT. */
+
+void
+genrtl_switch_stmt (t)
+ tree t;
+{
+ tree cond;
+ genrtl_do_pushlevel ();
+
+ cond = expand_cond (SWITCH_COND (t));
+ if (cond != error_mark_node)
+ {
+ emit_line_note (input_filename, lineno);
+ c_expand_start_case (cond);
+ }
+ else
+ /* The code is in error, but we don't want expand_end_case to
+ crash. */
+ c_expand_start_case (boolean_false_node);
+
+ expand_stmt (SWITCH_BODY (t));
+
+ expand_end_case (cond);
+}
+
+/* Generate the RTL for a CASE_LABEL. */
+
+void
+genrtl_case_label (low_value, high_value)
+ tree low_value;
+ tree high_value;
+{
+ do_case (low_value, high_value);
+}
+
+/* Generate the RTL for the start of a COMPOUND_STMT. */
+
+tree
+genrtl_begin_compound_stmt (has_no_scope)
+ int has_no_scope;
+{
+ /* If this is the outermost block of the function, declare the
+ variables __FUNCTION__, __PRETTY_FUNCTION__, and so forth. */
+ if (cfun
+ && !current_function_name_declared ()
+ && !has_no_scope)
+ {
+ set_current_function_name_declared (1);
+ declare_function_name ();
+ }
+
+ return NULL_TREE;
+}
+
+/* Generate the RTL for the end of a COMPOUND_STMT. */
+
+tree genrtl_finish_compound_stmt (has_no_scope)
+ int has_no_scope;
+{
+ return NULL_TREE;
+}
+
+/* Generate the RTL for T, which is a COMPOUND_STMT. */
+
+tree
+genrtl_compound_stmt (t)
+ tree t;
+{
+ genrtl_begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
+ expand_stmt (COMPOUND_BODY (t));
+ return (genrtl_finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t)));
+}
+
+/* Generate the RTL for an ASM_STMT. */
+
+void
+genrtl_asm_stmt (cv_qualifier, string, output_operands,
+ input_operands, clobbers)
+ tree cv_qualifier;
+ tree string;
+ tree output_operands;
+ tree input_operands;
+ tree clobbers;
+{
+ if (TREE_CHAIN (string))
+ string = combine_strings (string);
+
+ if (cv_qualifier != NULL_TREE
+ && cv_qualifier != ridpointers[(int) RID_VOLATILE])
+ {
+ warning ("%s qualifier ignored on asm",
+ IDENTIFIER_POINTER (cv_qualifier));
+ cv_qualifier = NULL_TREE;
+ }
+
+ emit_line_note (input_filename, lineno);
+ if (output_operands != NULL_TREE || input_operands != NULL_TREE
+ || clobbers != NULL_TREE)
+ c_expand_asm_operands (string, output_operands,
+ input_operands,
+ clobbers,
+ cv_qualifier != NULL_TREE,
+ input_filename, lineno);
+ else
+ expand_asm (string);
+}
+
+/* Generate the RTL for a DECL_CLEANUP. */
+
+void
+genrtl_decl_cleanup (decl, cleanup)
+ tree decl;
+ tree cleanup;
+{
+ if (!decl || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
+ expand_decl_cleanup (decl, cleanup);
+}
+
+tree
+expand_stmt (t)
+ tree t;
+{
+ tree rval;
+ rval = lang_expand_stmt (t);
+ return rval;
+}
extern void set_init_index PARAMS ((tree, tree));
extern void set_init_label PARAMS ((tree));
extern void process_init_element PARAMS ((tree));
-extern void c_expand_asm_operands PARAMS ((tree, tree, tree,
- tree, int,
- const char *, int));
-extern void c_expand_return PARAMS ((tree));
-extern tree c_expand_start_case PARAMS ((tree));
extern void pedwarn_c99 PARAMS ((const char *, ...))
ATTRIBUTE_PRINTF_1;
+2000-07-01 Benjamin Chelf <chelf@codesourcery.com>
+
+ * Make-lang.in (cc1plus$(exeext)): Added c-semantics.o.
+
+ * Makefile.in (OBJS): Added ../c-semantics.o.
+ (OBJDEPS): Likewise.
+
+ * cp-tree.h (TREE_LANG_FLAG_?): Moved common documentation to
+ ../c-common.h.
+ (struct stmt_tree): Added comment.
+ (current_function_name_declared): Removed.
+ (stmts_are_full_exprs_p): Likewise.
+ (genrtl_do_pushlevel): Likewise.
+ (genrtl_clear_out_block): Likewise.
+ (COMPOUND_STMT_NO_SCOPE): Moved to ../c-common.h.
+ (DECL_ANON_UNION_ELEMS): Likewise.
+ (emit_local_var): Likewise.
+ (make_rtl_for_local_static): Likewise.
+ (do_case): Likewise.
+ (expand_stmt): Likewise.
+ (genrtl_decl_cleanup): Likewise.
+ (c_expand_asm_operands): Likewise.
+ (c_expand_return): Likewise.
+ (c_expand_start_case): Likewise.
+
+ * decl.c (make_rtl_for_local_static): Moved to c-semantics.c.
+ (emit_local_var): Likewise.
+ (initialize_local_var): Change reference to
+ stmts_are_full_exprs_p to call to stmts_are_full_exprs_p().
+ Change reference to stmts_are_full_exprs_p to
+ current_stmt_tree->stmts_are_full_exprs_p.
+ (push_cp_function_context): Likewise.
+
+ * expect.c (expand_throw): Change reference to
+ stmts_are_full_exprs_p.
+
+ * init.c (build_aggr_init): Change reference to
+ stmts_are_full_exprs_p.
+ (build_vec_init): Likewise.
+
+ * optimize.c (maybe_clone_body): Change reference to
+ current_function_name_declared to
+ cp_function_chain->name_declared.
+
+ * pt.c (instantiate_decl): Change reference to
+ current_function_name_declared to
+ cp_function_chain->name_declared.
+
+ * semantics.c (expand_cond): Moved declaration to c-common.h.
+ (genrtl_do_pushlevel): Moved to c-semantics.c.
+ (genrtl_clear_out_block): Likewise.
+ (genrtl_goto_stmt): Likewise.
+ (genrtl_expr_stmt): Likewise.
+ (genrtl_decl_stmt): Likewise.
+ (gerntl_if_stmt): Likewise.
+ (genrtl_while_stmt): Likewise.
+ (genrtl_do_stmt): Likewise.
+ (genrtl_return_stmt): Likewise.
+ (genrtl_for_stmt): Likewise.
+ (genrtl_break_stmt): Likewise.
+ (genrtl_continue_stmt): Likewise.
+ (genrtl_scope_stmt): Likewise.
+ (genrtl_switch_stmt): Likewise.
+ (genrtl_case_label): Likewise.
+ (genrtl_begin_compound_stmt): Likewise.
+ (genrtl_finish_compound_stmt): Likewise.
+ (genrtl_compound_stmt): Likewise.
+ (genrtl_asm_stmt): Likewise.
+ (genrtl_decl_cleanup): Likewise.
+ (expand_cond): Likewise.
+ (expand_stmt): Renamed to ...
+ (lang_expand_stmt): ... this.
+ (lang_expand_expr_stmt): Initialize.
+ (set_current_function_name_declared): Likewise.
+ (stmts_are_full_exprs_p): Likewise.
+ (current_function_name_declared): Likewise.
+ (anon_aggr_type_p): Likewise.
+ (do_poplevel): Change reference to
+ stmts_are_full_exprs_p to call to stmts_are_full_exprs_p().
+ Change reference to stmts_are_full_exprs_p to
+ current_stmt_tree->stmts_are_full_exprs_p.
+ (add_tree): Likewise.
+ (finish_expr_stmt): Likewise.
+ (prep_stmt): Likewise.
+ (lang_expand_stmt): Likewise.
+ (begin_compound_stmt): Change reference to
+ current_function_name_declared to
+ cp_function_chain->name_declared and call to
+ current_function_name_declared().
+ (setup_vtbl_ptr): Likewise.
+ (genrtl_do_poplevel): Removed.
+
2000-06-30 Jason Merrill <jason@redhat.com>
* init.c (init_init_processing): Go back to aligning like
* cp-tree.h: Declare flag_check_new here.
* init.c: Not here.
+2000-06-28 Alex Samuel <samuel@codesourcery.com>
+
+ * mangle.c (find_substitution): Use same_type_p.
+ (write_encoding): Don't check for substitutions.
+
+2000-06-30 Nathan Sidwell <nathan@codesourcery.com>
+
+ * parse.y (expr_no_comma_rangle): New non-terminal.
+ (template_parm): Use it for default parameter case.
+ (template_arg): Use it.
+ (expr_no_commas): Remove commented out undefined extensions.
+ * Makefile.in (CONFLICTS): Adjust to 33 s/r & 48 r/r.
+ * parse.h, parse.c: Rebuilt.
+
2000-06-30 Mark Mitchell <mark@codesourcery.com>
* semantics.c (genrtl_asm_stmt): Don't decay input operands here.
(overloaded_template_name): Adjust.
* semantics.c (finish_template_template_parm): Adjust.
->>>>>>> 1.1867
2000-06-28 Mark Mitchell <mark@codesourcery.com>
* cp-tree.h (CLEAR_BINFO_NEW_VTABLE_MARKED): Remove.
* mangle.c (write_method_parms): Use direct comparison for end
of parmlist.
-2000-06-19 Benjamin Chelf <chelf@cabriolet.stanford.edu>
+2000-06-19 Benjamin Chelf <chelf@codesourcery.com>
* cp-tree.h (genrtl_try_block): Declare function.
(genrtl_handler): Likewise.
$(srcdir)/cp/typeck.c $(srcdir)/cp/typeck2.c $(srcdir)/cp/xref.c
cc1plus$(exeext): $(P) $(CXX_SRCS) $(LIBDEPS) stamp-objlist c-common.o \
- c-pragma.o $(srcdir)/cp/cp-tree.h $(srcdir)/cp/cp-tree.def \
+ c-pragma.o c-semantics.o $(srcdir)/cp/cp-tree.h $(srcdir)/cp/cp-tree.def \
$(srcdir)/c-common.def $(srcdir)/cp/gxx.gperf $(srcdir)/cp/cfns.gperf hash.o \
$(srcdir)/cp/operators.def
cd cp; $(MAKE) $(LANG_FLAGS_TO_PASS) $(CXX_FLAGS_TO_PASS) ../cc1plus$(exeext)
repo.o dump.o optimize.o mangle.o @extra_cxx_objs@
# Language-independent object files.
-OBJS = `cat ../stamp-objlist` ../c-common.o ../c-pragma.o
-OBJDEPS = ../stamp-objlist ../c-common.o ../c-pragma.o
+OBJS = `cat ../stamp-objlist` ../c-common.o ../c-pragma.o ../c-semantics.o
+OBJDEPS = ../stamp-objlist ../c-common.o ../c-pragma.o ../c-semantics.o
compiler: ../cc1plus$(exeext)
../cc1plus$(exeext): $(P) $(OBJDEPS) $(CXX_OBJS) $(LIBDEPS)
/* Usage of TREE_LANG_FLAG_?:
0: BINFO_MARKED (BINFO nodes).
- COMPOUND_STMT_NO_SCOPE (in COMPOUND_STMT).
NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
LOOKUP_EXPR_GLOBAL (in LOOKUP_EXPR).
- TREE_NEGATED_INT (in INTEGER_CST).
TREE_INDIRECT_USING (in NAMESPACE_DECL).
- IDENTIFIER_MARKED (used by search routines).
LOCAL_BINDING_P (in CPLUS_BINDING)
ICS_USER_FLAG (in _CONV)
CLEANUP_P (in TRY_BLOCK)
AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
- SCOPE_BEGIN_P (in SCOPE_STMT)
CTOR_BEGIN_P (in CTOR_STMT)
- DECL_PRETTY_FUNCTION_P (in VAR_DECL)
BV_USE_VCALL_INDEX_P (in the BINFO_VIRTUALS TREE_LIST)
1: IDENTIFIER_VIRTUAL_P.
TI_PENDING_TEMPLATE_FLAG.
DELETE_EXPR_USE_VEC (in DELETE_EXPR).
(TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out).
TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (in _TYPE).
- C_DECLARED_LABEL_FLAG (in LABEL_DECL)
INHERITED_VALUE_BINDING_P (in CPLUS_BINDING)
BASELINK_P (in TREE_LIST)
ICS_ELLIPSIS_FLAG (in _CONV)
- STMT_IS_FULL_EXPR_P (in _STMT)
BINFO_ACCESS (in BINFO)
BV_GENERATE_THUNK_WITH_VTABLE_P (in TREE_LIST)
2: IDENTIFIER_OPNAME_P.
TYPE_POLYMORHPIC_P (in _TYPE)
ICS_THIS_FLAG (in _CONV)
- STMT_LINENO_FOR_FN_P (in _STMT)
BINDING_HAS_LEVEL_P (in CPLUS_BINDING)
BINFO_OVERRIDE_ALONG_VIRTUAL_PATH_P (in BINFO)
3: TYPE_USES_VIRTUAL_BASECLASSES (in a class TYPE).
(TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
ICS_BAD_FLAG (in _CONV)
FN_TRY_BLOCK_P (in TRY_BLOCK)
- SCOPE_NO_CLEANUPS_P (in SCOPE_STMT)
IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE)
4: BINFO_NEW_VTABLE_MARKED.
TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
or FIELD_DECL).
NEED_TEMPORARY_P (in REF_BIND, BASE_CONV)
- SCOPE_PARTIAL_P (in SCOPE_STMT)
IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE)
5: BINFO_PRIMARY_MARKED_P (in BINFO)
6: BINFO_VBASE_PRIMARY_P (in BINFO)
struct stmt_tree {
tree x_last_stmt;
tree x_last_expr_type;
+/* Non-zero if we should treat statements as full expressions. In
+ particular, this variable is no-zero if at the end of a statement
+ we should destroy any temporaries created during that statement.
+ Similarly, if, at the end of a block, we should destroy any local
+ variables in this block. Normally, this variable is non-zero,
+ since those are the normal semantics of C++.
+
+ However, in order to represent aggregate initialization code as
+ tree structure, we use statement-expressions. The statements
+ within the statement expression should not result in cleanups being
+ run until the entire enclosing statement is complete. */
int stmts_are_full_exprs_p;
};
#define current_function_parms_stored \
cp_function_chain->parms_stored
-/* One if we have already declared __FUNCTION__ (and related
- variables) in the current function. Two if we are in the process
- of doing so. */
-
-#define current_function_name_declared \
- cp_function_chain->name_declared
-
/* Nonzero if we have already generated code to initialize virtual
function tables in this function. */
#define doing_semantic_analysis_p() (!expanding_p)
-/* Non-zero if we should treat statements as full expressions. In
- particular, this variable is no-zero if at the end of a statement
- we should destroy any temporaries created during that statement.
- Similarly, if, at the end of a block, we should destroy any local
- variables in this block. Normally, this variable is non-zero,
- since those are the normal semantics of C++.
-
- However, in order to represent aggregate initialization code as
- tree structure, we use statement-expressions. The statements
- within the statement expression should not result in cleanups being
- run until the entire enclosing statement is complete. */
-
-#define stmts_are_full_exprs_p \
- current_stmt_tree->stmts_are_full_exprs_p
-
#define in_function_try_handler cp_function_chain->in_function_try_handler
extern tree current_function_return_value;
#define DECL_SAVED_FUNCTION_DATA(NODE) \
(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE))->u.saved_language_function)
-#define COMPOUND_STMT_NO_SCOPE(NODE) TREE_LANG_FLAG_0 (NODE)
#define NEW_EXPR_USE_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE)
#define DELETE_EXPR_USE_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE)
#define DELETE_EXPR_USE_VEC(NODE) TREE_LANG_FLAG_1 (NODE)
#define ANON_UNION_TYPE_P(NODE) \
(TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
-/* For a VAR_DECL that is an anonymous union, these are the various
- sub-variables that make up the anonymous union. */
-#define DECL_ANON_UNION_ELEMS(NODE) DECL_ARGUMENTS ((NODE))
-
#define UNKNOWN_TYPE LANG_TYPE
/* Define fields and accessors for nodes representing declared names. */
extern void maybe_push_to_top_level PARAMS ((int));
extern void push_to_top_level PARAMS ((void));
extern void pop_from_top_level PARAMS ((void));
+extern void push_switch PARAMS ((void));
+extern void pop_switch PARAMS ((void));
extern tree identifier_type_value PARAMS ((tree));
extern void set_identifier_type_value PARAMS ((tree, tree));
extern void pop_everything PARAMS ((void));
extern tree declare_local_label PARAMS ((tree));
extern tree define_label PARAMS ((const char *, int, tree));
extern void check_goto PARAMS ((tree));
-extern void push_switch PARAMS ((void));
-extern void pop_switch PARAMS ((void));
extern void define_case_label PARAMS ((void));
extern tree getdecls PARAMS ((void));
extern tree gettags PARAMS ((void));
extern tree cp_namespace_decls PARAMS ((tree));
extern tree create_implicit_typedef PARAMS ((tree, tree));
extern tree maybe_push_decl PARAMS ((tree));
-extern void emit_local_var PARAMS ((tree));
extern tree build_target_expr_with_type PARAMS ((tree, tree));
-extern void make_rtl_for_local_static PARAMS ((tree));
extern int local_variable_p PARAMS ((tree));
extern int nonstatic_local_decl_p PARAMS ((tree));
extern tree declare_global_var PARAMS ((tree, tree));
extern void init_cplus_expand PARAMS ((void));
extern void fixup_result_decl PARAMS ((tree, struct rtx_def *));
extern int extract_init PARAMS ((tree, tree));
-extern void do_case PARAMS ((tree, tree));
extern tree cplus_expand_constant PARAMS ((tree));
/* friend.c */
extern void add_decl_stmt PARAMS ((tree));
extern void finish_decl_cleanup PARAMS ((tree, tree));
extern void finish_named_return_value PARAMS ((tree, tree));
-extern tree expand_stmt PARAMS ((tree));
extern void expand_body PARAMS ((tree));
extern void begin_stmt_tree PARAMS ((tree *));
extern void finish_stmt_tree PARAMS ((tree *));
extern void genrtl_catch_block PARAMS ((tree));
extern void genrtl_ctor_stmt PARAMS ((tree));
extern void genrtl_subobject PARAMS ((tree));
-extern void genrtl_decl_cleanup PARAMS ((tree, tree));
extern tree genrtl_do_poplevel PARAMS ((void));
-extern void genrtl_do_pushlevel PARAMS ((void));
-extern void genrtl_clear_out_block PARAMS ((void));
+extern void clear_out_block PARAMS ((void));
extern void genrtl_goto_stmt PARAMS ((tree));
extern void genrtl_expr_stmt PARAMS ((tree));
extern void genrtl_decl_stmt PARAMS ((tree));
extern tree build_modify_expr PARAMS ((tree, enum tree_code, tree));
extern tree dubious_conversion_warnings PARAMS ((tree, tree, const char *, tree, int));
extern tree convert_for_initialization PARAMS ((tree, tree, tree, int, const char *, tree, int));
-extern void c_expand_asm_operands PARAMS ((tree, tree, tree, tree, int, const char *, int));
-extern void c_expand_return PARAMS ((tree));
-extern tree c_expand_start_case PARAMS ((tree));
extern int comp_ptr_ttypes PARAMS ((tree, tree));
extern int ptr_reasonably_similar PARAMS ((tree, tree));
extern tree build_ptrmemfunc PARAMS ((tree, tree, int));
rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
}
-/* Create RTL for the local static variable DECL. */
-
-void
-make_rtl_for_local_static (decl)
- tree decl;
-{
- const char *asmspec = NULL;
-
- /* If we inlined this variable, we could see it's declaration
- again. */
- if (DECL_RTL (decl))
- return;
-
- if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
- {
- /* The only way this situaton can occur is if the
- user specified a name for this DECL using the
- `attribute' syntax. */
- asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
- DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
- }
-
- rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
-}
/* The old ARM scoping rules injected variables declared in the
initialization statement of a for-statement into the surrounding
emit_line_note (DECL_SOURCE_FILE (decl),
DECL_SOURCE_LINE (decl));
- saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
- stmts_are_full_exprs_p = 1;
+ saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
+ current_stmt_tree->stmts_are_full_exprs_p = 1;
if (building_stmt_tree ())
finish_expr_stmt (build_aggr_init (decl, init, flags));
else
genrtl_expr_stmt (build_aggr_init (decl, init, flags));
- stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
+ current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
}
/* Set this to 0 so we can tell whether an aggregate which was
finish_decl_cleanup (decl, cleanup);
}
-/* Let the back-end know about DECL. */
-void
-emit_local_var (decl)
- tree decl;
-{
- /* Create RTL for this variable. */
- if (DECL_RTL (decl))
- /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
- All other local variables are assigned RTL in this function. */
- my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
- 19990828);
- else
- {
- if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
- /* The user must have specified an assembler name for this
- variable. Set that up now. */
- rest_of_decl_compilation
- (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
- /*top_level=*/0, /*at_end=*/0);
- else
- expand_decl (decl);
- }
-
- /* Actually do the initialization. */
- if (stmts_are_full_exprs_p)
- expand_start_target_temps ();
-
- expand_decl_init (decl);
-
- if (stmts_are_full_exprs_p)
- expand_end_target_temps ();
-}
/* Finish processing of a declaration;
install its line number and initial value.
/* Whenever we start a new function, we destroy temporaries in the
usual way. */
- stmts_are_full_exprs_p = 1;
+ current_stmt_tree->stmts_are_full_exprs_p = 1;
}
/* Free the language-specific parts of F, now that we've finished
first. Since there could be temps in the expression, we need
to handle that, too. */
- my_friendly_assert (stmts_are_full_exprs_p == 1, 19990926);
+ my_friendly_assert (stmts_are_full_exprs_p () == 1, 19990926);
/* Store the throw expression into a temp. This can be less
efficient than storing it into the allocated space directly, but
TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
begin_init_stmts (&stmt_expr, &compound_stmt);
- destroy_temps = stmts_are_full_exprs_p;
- stmts_are_full_exprs_p = 0;
+ destroy_temps = stmts_are_full_exprs_p ();
+ current_stmt_tree->stmts_are_full_exprs_p = 0;
expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
init, LOOKUP_NORMAL|flags);
stmt_expr = finish_init_stmts (stmt_expr, compound_stmt);
- stmts_are_full_exprs_p = destroy_temps;
+ current_stmt_tree->stmts_are_full_exprs_p = destroy_temps;
TREE_TYPE (exp) = type;
TREE_READONLY (exp) = was_const;
TREE_THIS_VOLATILE (exp) = was_volatile;
of blocks of memory. */
begin_init_stmts (&stmt_expr, &compound_stmt);
- destroy_temps = stmts_are_full_exprs_p;
- stmts_are_full_exprs_p = 0;
+ destroy_temps = stmts_are_full_exprs_p ();
+ current_stmt_tree->stmts_are_full_exprs_p = 0;
rval = get_temp_regvar (ptype,
cp_convert (ptype, default_conversion (base)));
base = get_temp_regvar (ptype, rval);
}
else
{
- stmts_are_full_exprs_p = 1;
+ current_stmt_tree->stmts_are_full_exprs_p = 1;
finish_expr_stmt (elt_init);
- stmts_are_full_exprs_p = 0;
+ current_stmt_tree->stmts_are_full_exprs_p = 0;
}
finish_expr_stmt (build_modify_expr
finish_expr_stmt (rval);
stmt_expr = finish_init_stmts (stmt_expr, compound_stmt);
- stmts_are_full_exprs_p = destroy_temps;
+ current_stmt_tree->stmts_are_full_exprs_p = destroy_temps;
return stmt_expr;
}
VARRAY_FREE (id.fns);
/* Now, expand this function into RTL, if appropriate. */
- current_function_name_declared = 1;
+ cp_function_chain->name_declared = 1;
expand_body (finish_function (0));
pop_from_top_level ();
}
/* We already set up __FUNCTION__, etc., so we don't want to do
it again now. */
- current_function_name_declared = 1;
+ cp_function_chain->name_declared = 1;
/* Substitute into the body of the function. */
tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
parsing into this file; that will make implementing the new parser
much easier since it will be able to make use of these routines. */
-static tree expand_cond PARAMS ((tree));
static tree maybe_convert_cond PARAMS ((tree));
static tree simplify_aggr_init_exprs_r PARAMS ((tree *, int *, void *));
static void deferred_type_access_control PARAMS ((void));
substmt = cond; \
} while (0)
-/* Finish a scope. */
+/* Wrapper since C and C++ expand_expr_stmt are different. */
-tree
-do_poplevel ()
+expand_expr_stmt_fn lang_expand_expr_stmt = cplus_expand_expr_stmt;
+
+/* Wrapper function instead of #define for use with c-common code. */
+
+void
+set_current_function_name_declared (i)
+ int i;
{
- tree block = NULL_TREE;
+ cp_function_chain->name_declared = i;
+}
- if (stmts_are_full_exprs_p)
- {
- tree scope_stmts;
+/* Returns non-zero if the current statement is a full expression,
+ i.e. temporaries created during that statement should be destroyed
+ at the end of the statement. */
- if (!processing_template_decl)
- scope_stmts = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
+int
+stmts_are_full_exprs_p ()
+{
+ return current_stmt_tree->stmts_are_full_exprs_p;
+}
- block = poplevel (kept_level_p (), 1, 0);
- if (block && !processing_template_decl)
- {
- SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
- SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
- }
- }
+/* One if we have already declared __FUNCTION__ (and related
+ variables) in the current function. Two if we are in the process
+ of doing so. */
- return block;
+int
+current_function_name_declared ()
+{
+ return cp_function_chain->name_declared;
}
-/* Begin a new scope. */
+/* Nonzero if TYPE is an anonymous union or struct type. We have to use a
+ flag for this because "A union for which objects or pointers are
+ declared is not an anonymous union" [class.union]. */
-void
-do_pushlevel ()
+int
+anon_aggr_type_p (node)
+ tree node;
{
- if (stmts_are_full_exprs_p)
- {
- pushlevel (0);
- if (!processing_template_decl)
- add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
- }
+ return (CLASS_TYPE_P (node) && TYPE_LANG_SPECIFIC(node)->anon_aggr);
}
-/* Helper for generating the RTL at the end of a scope. */
+/* Finish a scope. */
tree
-genrtl_do_poplevel ()
+do_poplevel ()
{
tree block = NULL_TREE;
- if (stmts_are_full_exprs_p)
+ if (stmts_are_full_exprs_p ())
{
tree scope_stmts;
- scope_stmts = NULL_TREE;
+
+ if (!processing_template_decl)
+ scope_stmts = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
block = poplevel (kept_level_p (), 1, 0);
if (block && !processing_template_decl)
return block;
}
-/* Helper for generating the RTL at the beginning of a scope. */
-
-void
-genrtl_do_pushlevel ()
-{
- emit_line_note (input_filename, lineno);
- clear_last_expr ();
-
- if (stmts_are_full_exprs_p)
- {
- pushlevel (0); // Try to get rid of me.
- if (!cfun->x_whole_function_mode_p)
- my_friendly_abort (19991129);
- }
-}
-
-/* Helper for generating the RTL. */
+/* Begin a new scope. */
void
-genrtl_clear_out_block ()
+do_pushlevel ()
{
- /* If COND wasn't a declaration, clear out the
- block we made for it and start a new one here so the
- optimization in expand_end_loop will work. */
- if (getdecls () == NULL_TREE)
+ if (stmts_are_full_exprs_p ())
{
- genrtl_do_poplevel ();
- genrtl_do_pushlevel ();
+ pushlevel (0);
+ if (!processing_template_decl)
+ add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
}
}
SET_LAST_STMT (t);
/* When we expand a statement-tree, we must know whether or not the
statements are full-expresions. We record that fact here. */
- STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p;
+ STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
}
/* Finish a goto-statement. */
add_tree (build_min_nt (GOTO_STMT, destination));
}
-/* Generate the RTL for DESTINATION, which is a GOTO_STMT. */
-
-void
-genrtl_goto_stmt (destination)
- tree destination;
-{
- if (TREE_CODE (destination) == IDENTIFIER_NODE)
- destination = lookup_label (destination);
-
- /* We warn about unused labels with -Wunused. That means we have to
- mark the used labels as used. */
- if (TREE_CODE (destination) == LABEL_DECL)
- TREE_USED (destination) = 1;
-
- emit_line_note (input_filename, lineno);
-
- if (TREE_CODE (destination) == LABEL_DECL)
- {
- label_rtx (destination);
- expand_goto (destination);
- }
- else
- expand_computed_goto (destination);
-}
-
/* COND is the condition-expression for an if, while, etc.,
statement. Convert it to a boolean value, if appropriate. */
-static tree
+tree
maybe_convert_cond (cond)
tree cond;
{
if (expr != NULL_TREE)
{
if (!processing_template_decl
- && !stmts_are_full_exprs_p
+ && !(stmts_are_full_exprs_p ())
&& ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
&& lvalue_p (expr))
|| TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE))
expr = default_conversion (expr);
- if (stmts_are_full_exprs_p)
+ if (stmts_are_full_exprs_p ())
expr = convert_to_void (expr, "statement");
if (!processing_template_decl)
last_expr_type = expr ? TREE_TYPE (expr) : NULL_TREE;
}
-/* Generate the RTL for EXPR, which is an EXPR_STMT. */
-
-void
-genrtl_expr_stmt (expr)
- tree expr;
-{
- if (expr != NULL_TREE)
- {
- emit_line_note (input_filename, lineno);
-
- if (stmts_are_full_exprs_p)
- expand_start_target_temps ();
-
- cplus_expand_expr_stmt (expr);
-
- if (stmts_are_full_exprs_p)
- expand_end_target_temps ();
- }
-
- finish_stmt ();
-
- /* This was an expression-statement, so we save the type of the
- expression. */
- last_expr_type = expr ? TREE_TYPE (expr) : NULL_TREE;
-}
-
-/* Generate the RTL for T, which is a DECL_STMT. */
-
-void
-genrtl_decl_stmt (t)
- tree t;
-{
- tree decl;
- emit_line_note (input_filename, lineno);
- decl = DECL_STMT_DECL (t);
- /* If this is a declaration for an automatic local
- variable, initialize it. Note that we might also see a
- declaration for a namespace-scope object (declared with
- `extern'). We don't have to handle the initialization
- of those objects here; they can only be declarations,
- rather than definitions. */
- if (TREE_CODE (decl) == VAR_DECL
- && !TREE_STATIC (decl)
- && !DECL_EXTERNAL (decl))
- {
- /* Let the back-end know about this variable. */
- if (!ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
- emit_local_var (decl);
- else
- expand_anon_union_decl (decl, NULL_TREE,
- DECL_ANON_UNION_ELEMS (decl));
- }
- else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
- {
- if (DECL_ARTIFICIAL (decl) && ! TREE_USED (decl))
- /* Do not emit unused decls. This is not just an
- optimization. We really do not want to emit
- __PRETTY_FUNCTION__ etc, if they're never used. */
- DECL_IGNORED_P (decl) = 1;
- else
- make_rtl_for_local_static (decl);
- }
-}
-
-/* Generate the RTL for T, which is an IF_STMT. */
-
-void
-genrtl_if_stmt (t)
- tree t;
-{
- tree cond;
- genrtl_do_pushlevel ();
- cond = maybe_convert_cond (expand_cond (IF_COND (t)));
- emit_line_note (input_filename, lineno);
- expand_start_cond (cond, 0);
- if (THEN_CLAUSE (t))
- expand_stmt (THEN_CLAUSE (t));
- if (ELSE_CLAUSE (t))
- {
- expand_start_else ();
- expand_stmt (ELSE_CLAUSE (t));
- }
- expand_end_cond ();
- genrtl_do_poplevel ();
- finish_stmt ();
-}
/* Begin an if-statement. Returns a newly created IF_STMT if
appropriate. */
}
}
-/* Generate the RTL for T, which is a WHILE_STMT. */
-
-void
-genrtl_while_stmt (t)
- tree t;
-{
- tree cond;
- emit_nop ();
- emit_line_note (input_filename, lineno);
- expand_start_loop (1);
- genrtl_do_pushlevel ();
-
- cond = maybe_convert_cond (expand_cond (WHILE_COND (t)));
- emit_line_note (input_filename, lineno);
- expand_exit_loop_if_false (0, cond);
- genrtl_clear_out_block ();
-
- expand_stmt (WHILE_BODY (t));
-
- genrtl_do_poplevel ();
- expand_end_loop ();
- finish_stmt ();
-}
-
/* Begin a while-statement. Returns a newly created WHILE_STMT if
appropriate. */
finish_stmt ();
}
-/* Generate the RTL for T, which is a DO_STMT. */
-
-void
-genrtl_do_stmt (t)
- tree t;
-{
- tree cond;
- emit_nop ();
- emit_line_note (input_filename, lineno);
- expand_start_loop_continue_elsewhere (1);
-
- expand_stmt (DO_BODY (t));
-
- expand_loop_continue_here ();
-
- cond = maybe_convert_cond (DO_COND (t));
- emit_line_note (input_filename, lineno);
- expand_exit_loop_if_false (0, cond);
- expand_end_loop ();
- finish_stmt ();
-}
-
/* Begin a do-statement. Returns a newly created DO_STMT if
appropriate. */
finish_stmt ();
}
-/* Generate the RTL for EXPR, which is a RETURN_STMT. */
-
-void
-genrtl_return_stmt (expr)
- tree expr;
-{
- emit_line_note (input_filename, lineno);
- c_expand_return (expr);
- finish_stmt ();
-}
-
/* Finish a return-statement. The EXPRESSION returned, if any, is as
indicated. */
finish_stmt ();
}
-/* Generate the RTL for T, which is a FOR_STMT. */
-
-void
-genrtl_for_stmt (t)
- tree t;
-{
- tree tmp;
- tree cond;
- if (flag_new_for_scope > 0)
- {
- genrtl_do_pushlevel ();
- note_level_for_for ();
- }
-
- expand_stmt (FOR_INIT_STMT (t));
-
- emit_nop ();
- emit_line_note (input_filename, lineno);
- expand_start_loop_continue_elsewhere (1);
- genrtl_do_pushlevel ();
- cond = maybe_convert_cond (expand_cond (FOR_COND (t)));
- emit_line_note (input_filename, lineno);
- if (cond)
- expand_exit_loop_if_false (0, cond);
- genrtl_clear_out_block ();
- tmp = FOR_EXPR (t);
-
- expand_stmt (FOR_BODY (t));
-
- /* Pop the scope for the body of the loop. */
- genrtl_do_poplevel ();
- emit_line_note (input_filename, lineno);
- expand_loop_continue_here ();
- if (tmp)
- genrtl_expr_stmt (tmp);
- expand_end_loop ();
- if (flag_new_for_scope > 0)
- genrtl_do_poplevel ();
- finish_stmt ();
-}
-
/* Begin a for-statement. Returns a new FOR_STMT if appropriate. */
tree
r = build_min_nt (FOR_STMT, NULL_TREE, NULL_TREE,
NULL_TREE, NULL_TREE);
+ NEW_FOR_SCOPE_P (r) = flag_new_for_scope > 0;
add_tree (r);
-
- if (flag_new_for_scope > 0)
+ if (NEW_FOR_SCOPE_P (r))
{
do_pushlevel ();
note_level_for_for ();
/* Pop the scope for the body of the loop. */
do_poplevel ();
RECHAIN_STMTS (for_stmt, FOR_BODY (for_stmt));
- if (flag_new_for_scope > 0)
+ if (NEW_FOR_SCOPE_P (for_stmt))
do_poplevel ();
finish_stmt ();
}
-/* Generate the RTL for a BREAK_STMT. */
-
-void
-genrtl_break_stmt ()
-{
- emit_line_note (input_filename, lineno);
- if ( ! expand_exit_something ())
- cp_error ("break statement not within loop or switch");
-}
-
/* Finish a break-statement. */
void
add_tree (build_min_nt (BREAK_STMT));
}
-/* Generate the RTL for a CONTINUE_STMT. */
-
-void
-genrtl_continue_stmt ()
-{
- emit_line_note (input_filename, lineno);
- if (! expand_continue_loop (0))
- cp_error ("continue statement not within a loop");
-}
-
/* Finish a continue-statement. */
void
add_tree (build_min_nt (CONTINUE_STMT));
}
-/* Generate the RTL for T, which is a SCOPE_STMT. */
-
-void
-genrtl_scope_stmt (t)
- tree t;
-{
- if (!SCOPE_NO_CLEANUPS_P (t))
- {
- if (SCOPE_BEGIN_P (t))
- expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t),
- SCOPE_STMT_BLOCK (t));
- else if (SCOPE_END_P (t))
- expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0);
- }
- else if (!SCOPE_NULLIFIED_P (t))
- {
- rtx note = emit_note (NULL,
- (SCOPE_BEGIN_P (t)
- ? NOTE_INSN_BLOCK_BEG
- : NOTE_INSN_BLOCK_END));
- NOTE_BLOCK (note) = SCOPE_STMT_BLOCK (t);
- }
-}
-
-/* Generate the RTL for T, which is a SWITCH_STMT. */
-
-void
-genrtl_switch_stmt (t)
- tree t;
-{
- tree cond;
- genrtl_do_pushlevel ();
-
- cond = expand_cond (SWITCH_COND (t));
- if (cond != error_mark_node)
- {
- emit_line_note (input_filename, lineno);
- c_expand_start_case (cond);
- }
- else
- /* The code is in error, but we don't want expand_end_case to
- crash. */
- c_expand_start_case (boolean_false_node);
-
- push_switch ();
-
- expand_stmt (SWITCH_BODY (t));
-
- expand_end_case (cond);
- pop_switch ();
- genrtl_do_poplevel ();
- finish_stmt ();
-}
-
/* Begin a switch-statement. Returns a new SWITCH_STMT if
appropriate. */
finish_stmt ();
}
-/* Generate the RTL for a CASE_LABEL. */
-
-void
-genrtl_case_label (low_value, high_value)
- tree low_value;
- tree high_value;
-{
- do_case (low_value, high_value);
-}
-
/* Finish a case-label. */
void
expand_goto (top_label_entry (&caught_return_label_stack));
end_catch_handler ();
}
-
- genrtl_do_poplevel ();
}
/* Begin a handler. Returns a HANDLER if appropriate. */
end_protect_partials ();
}
-/* Generate the RTL for the start of a COMPOUND_STMT. */
-
-tree genrtl_begin_compound_stmt (has_no_scope)
- int has_no_scope;
-{
- tree r;
- int is_try = 0;
-
- r = NULL_TREE;
-
- last_expr_type = NULL_TREE;
-
- if (!has_no_scope)
- {
- genrtl_do_pushlevel ();
- if (is_try)
- note_level_for_eh ();
- }
- else
- /* Normally, we try hard to keep the BLOCK for a
- statement-expression. But, if it's a statement-expression with
- a scopeless block, there's nothing to keep, and we don't want
- to accidentally keep a block *inside* the scopeless block. */
- keep_next_level (0);
-
- /* If this is the outermost block of the function, declare the
- variables __FUNCTION__, __PRETTY_FUNCTION__, and so forth. */
- if (cfun
- && !current_function_name_declared
- && !has_no_scope)
- {
- current_function_name_declared = 1;
- declare_function_name ();
- }
-
- return r;
-}
-
-/* Generate the RTL for the end of a COMPOUND_STMT. */
-
-tree genrtl_finish_compound_stmt (has_no_scope)
- int has_no_scope;
-{
- tree r;
- tree t;
-
- if (!has_no_scope)
- r = genrtl_do_poplevel ();
- else
- r = NULL_TREE;
-
- /* When we call finish_stmt we will lose LAST_EXPR_TYPE. But, since
- the precise purpose of that variable is store the type of the
- last expression statement within the last compound statement, we
- preserve the value. */
- t = last_expr_type;
- finish_stmt ();
- last_expr_type = t;
-
- return r;
-}
-
-/* Generate the RTL for T, which is a COMPOUND_STMT. */
-
-tree
-genrtl_compound_stmt (t)
- tree t;
-{
- genrtl_begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
- expand_stmt (COMPOUND_BODY (t));
- return (genrtl_finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t)));
-}
-
/* Begin a compound-statement. If HAS_NO_SCOPE is non-zero, the
compound-statement does not define a scope. Returns a new
COMPOUND_STMT if appropriate. */
/* If this is the outermost block of the function, declare the
variables __FUNCTION__, __PRETTY_FUNCTION__, and so forth. */
if (cfun
- && !current_function_name_declared
+ && !(current_function_name_declared () )
&& !has_no_scope)
{
- current_function_name_declared = 1;
+ cp_function_chain->name_declared = 1;
declare_function_name ();
}
return r;
}
-/* Generate the RTL for an ASM_STMT. */
-
-void
-genrtl_asm_stmt (cv_qualifier, string, output_operands,
- input_operands, clobbers)
- tree cv_qualifier;
- tree string;
- tree output_operands;
- tree input_operands;
- tree clobbers;
-{
- if (TREE_CHAIN (string))
- string = combine_strings (string);
-
- if (cv_qualifier != NULL_TREE
- && cv_qualifier != ridpointers[(int) RID_VOLATILE])
- {
- cp_warning ("%s qualifier ignored on asm",
- IDENTIFIER_POINTER (cv_qualifier));
- cv_qualifier = NULL_TREE;
- }
-
- emit_line_note (input_filename, lineno);
- if (output_operands != NULL_TREE || input_operands != NULL_TREE
- || clobbers != NULL_TREE)
- c_expand_asm_operands (string, output_operands,
- input_operands,
- clobbers,
- cv_qualifier != NULL_TREE,
- input_filename, lineno);
- else
- expand_asm (string);
-
- finish_stmt ();
-}
-
/* Finish an asm-statement, whose components are a CV_QUALIFIER, a
STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
CLOBBERS. */
add_tree (r);
}
-/* Generate the RTL for a DECL_CLEANUP. */
-
-void
-genrtl_decl_cleanup (decl, cleanup)
- tree decl;
- tree cleanup;
-{
- if (!decl || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
- expand_decl_cleanup (decl, cleanup);
-}
-
/* When DECL goes out of scope, make sure that CLEANUP is executed. */
void
/* Don't declare __PRETTY_FUNCTION__ and friends here when we
open the block for the if-body. */
- saved_cfnd = current_function_name_declared;
- current_function_name_declared = 1;
+ saved_cfnd = current_function_name_declared ();
+ cp_function_chain->name_declared = 1;
compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
- current_function_name_declared = saved_cfnd;
+ cp_function_chain->name_declared = saved_cfnd;
/* Make all virtual function table pointers in non-virtual base
classes point to CURRENT_CLASS_TYPE's virtual function
{
if (!STMT_LINENO_FOR_FN_P (t))
lineno = STMT_LINENO (t);
- stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
-}
-
-/* Some statements, like for-statements or if-statements, require a
- condition. This condition can be a declaration. If T is such a
- declaration it is processed, and an expression appropriate to use
- as the condition is returned. Otherwise, T itself is returned. */
-
-static tree
-expand_cond (t)
- tree t;
-{
- if (t && TREE_CODE (t) == TREE_LIST)
- {
- expand_stmt (TREE_PURPOSE (t));
- return TREE_VALUE (t);
- }
- else
- return t;
+ current_stmt_tree->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
}
/* Generate RTL for the statement T, and its substatements, and any
other statements at its nesting level. */
tree
-expand_stmt (t)
+lang_expand_stmt (t)
tree t;
{
tree rval = NULL_TREE;
rval = NULL_TREE;
/* Set up context appropriately for handling this statement. */
- saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
+ saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
prep_stmt (t);
switch (TREE_CODE (t))
}
/* Restore saved state. */
- stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
+ current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
/* Go on to the next statement in this scope. */
t = TREE_CHAIN (t);
/* We don't need to redeclare __FUNCTION__, __PRETTY_FUNCTION__, or
any of the other magic variables we set up when starting a
function body. */
- current_function_name_declared = 1;
+ cp_function_chain->name_declared = 1;
/* Expand the body. */
expand_stmt (DECL_SAVED_TREE (fn));
/* Statements should always be full-expressions at the outermost set
of curly braces for a function. */
- my_friendly_assert (stmts_are_full_exprs_p, 19990831);
+ my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
/* The outermost statement for a function contains the line number
recorded when we finished processing the function. */
projects / platform / upstream / gcc.git / commitdiff