+1999-11-25 Mark Mitchell <mark@codesourcery.com>
+
+ * Make-lang.in (CXX_SRCS): Add optimize.c.
+ * Makefile.in (CXX_OBJS): Add optimize.o.
+ (CXX_TREE_H): Add splay-tree.h, system.h, and $(CONFIG_H).
+ (spew.o, lex.o, decl.o, decl2.o, typeck2.o, typeck.o): Adjust.
+ (class.o, call.o, friend.o, init.o, method.o, cvt.o): Likewise.
+ (search.o, tree.o, ptree.o, rtti.o, except.o, expr.o): Likewise.
+ (xref.o, pt.o, error.o, errfn.o, repo.o, semantics.o): Likewise.
+ (dump.o): Likewise.
+ (optimize.o): New target.
+ * class.c: Don't include splay-tree.h.
+ * cp-tree.def (CTOR_COMPLETE): Rename to CTOR_STMT.
+ * cp-tree.h: Include splay-tree.h.
+ (DECL_UNINLINABLE): New macro.
+ (CTOR_BEGIN_P, CTOR_END_P): New macros.
+ (flag_inline_trees): New variable.
+ (local_variable_p): New function.
+ (nonstatic_local_decl_p): Likewise.
+ (optimize_function): Likewise.
+ (cplus_unsave_expr_now): Remove.
+ (copy_tree_r): Declare.
+ (remap_save_expr): Likewise.
+ * decl.c (local_variable_p): Don't
+ make it static.
+ (local_variable_p_walkfn): New function.
+ (make_rtl_for_local_static): Remove code to try to avoid writing
+ out static constants.
+ (emit_local_var): Fix indentation.
+ (nonstatic_local_decl_p): New function.
+ (check_default_argument): Use local_variable_p_walkfn, not
+ local_variable_p, when walking the tree.
+ (start_function): Set the DECL_CONTEXT for automatically generated
+ labels.
+ (finish_constructor_body): Use CTOR_STMT to mark the end of a
+ constructor.
+ * decl2.c: Don't include splay-tree.h.
+ (flag_inline_trees): Define.
+ * dump.c: Don't include
+ splay-tree.h.
+ * except.c (expand_end_catch_block): Fix comment formatting.
+ (expand_end_eh_spec): Set DECL_CONTEXT on temporary variables.
+ (expand_throw): Tidy comment.
+ * init.c (build_vec_delete_1): Use create_temporary_var.
+ * lex.c (cplus_tree_code_type): Make it static.
+ (cplus_tree_code_length): Likewise.
+ (cplus_tree_code_name): Likewise.
+ * optimize.c: New file.
+ * semantics.c (finish_goto_stmt): Set DECL_UNLINABLE for functions
+ with computed gotos.
+ (setup_vtbl_ptr): Mark the beginnings of constructors with
+ CTOR_STMT.
+ (expand_stmt): Handle CTOR_STMT, not CTOR_COMPLETE.
+ (expand_body): Call optimize_function. Save bodies if we're doing
+ inlining on trees.
+ * tree.c: Don't include splay-tree.h. Include insn-config.h and
+ integrate.h.
+ (copy_tree_r): Make it public.
+ (statement_code_p): New function.
+ (mark_local_for_remap_r): Likewise.
+ (cp_usave_r): Likewise.
+ (cp_unsave): Likewise.
+ (build_cplus_new): Set DECL_CONTEXT for temporary variables.
+ (walk_tree): Walk into `s' class nodes. Walk statement chains.
+ (copy_tree_r): Handle 's' class nodes. Restore chains for
+ statements. Nullify scopes. Don't copy types.
+ (init_tree): Set lang_unsave to cp_unsave.
+ (remap_save_expr): Define.
+ * ir.texi: Document CTOR_STMT.
+
1999-11-24 Jason Merrill <jason@casey.cygnus.com>
* search.c (note_debug_info_needed): Do perform this optimization
$(srcdir)/cp/error.c $(srcdir)/cp/friend.c $(srcdir)/cp/init.c \
$(srcdir)/cp/parse.y $(srcdir)/cp/typeck2.c \
$(srcdir)/cp/repo.c $(srcdir)/cp/semantics.c \
- $(srcdir)/cp/dump.c
+ $(srcdir)/cp/dump.c $(srcdir)/cp/optimize.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 \
CXX_OBJS = call.o decl.o errfn.o expr.o pt.o typeck2.o \
class.o decl2.o error.o lex.o parse.o ptree.o rtti.o spew.o typeck.o cvt.o \
except.o friend.o init.o method.o search.o semantics.o tree.o xref.o \
- repo.o dump.o @extra_cxx_objs@
+ repo.o dump.o optimize.o @extra_cxx_objs@
# Language-independent object files.
OBJS = `cat ../stamp-objlist` ../c-common.o ../c-pragma.o
TREE_H = $(srcdir)/../tree.h $(srcdir)/../real.h $(srcdir)/../tree.def \
$(srcdir)/../machmode.h $(srcdir)/../machmode.def
CXX_TREE_H = $(TREE_H) cp-tree.h $(srcdir)/../c-common.h cp-tree.def \
- $(srcdir)/../function.h $(srcdir)/../varray.h
+ $(srcdir)/../function.h $(srcdir)/../varray.h \
+ $(srcdir)/../../include/splay-tree.h \
+ $(srcdir)/../system.h $(CONFIG_H)
PARSE_H = $(srcdir)/parse.h
PARSE_C = $(srcdir)/parse.c
EXPR_H = $(srcdir)/../expr.h ../insn-codes.h
-parse.o : $(PARSE_C) $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h lex.h \
+parse.o : $(PARSE_C) $(CXX_TREE_H) $(srcdir)/../flags.h lex.h \
$(srcdir)/../except.h $(srcdir)/../output.h $(srcdir)/../system.h \
$(srcdir)/../toplev.h $(srcdir)/../ggc.h
$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(BIG_SWITCHFLAG) \
echo " ftp://sourceware.cygnus.com/pub/egcs/infrastructure/gperf*" >&2 ; \
exit 1 )
-spew.o : spew.c $(CONFIG_H) $(CXX_TREE_H) $(PARSE_H) $(srcdir)/../flags.h \
- lex.h $(srcdir)/../system.h $(srcdir)/../toplev.h
-lex.o : lex.c $(CONFIG_H) $(CXX_TREE_H) \
+spew.o : spew.c $(CXX_TREE_H) $(PARSE_H) $(srcdir)/../flags.h \
+ lex.h $(srcdir)/../toplev.h
+lex.o : lex.c $(CXX_TREE_H) \
$(PARSE_H) input.c $(srcdir)/../flags.h hash.h lex.h \
- $(srcdir)/../c-pragma.h $(srcdir)/../system.h $(srcdir)/../toplev.h \
+ $(srcdir)/../c-pragma.h $(srcdir)/../toplev.h \
$(srcdir)/../output.h $(srcdir)/../mbchar.h $(srcdir)/../ggc.h
-decl.o : decl.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
+decl.o : decl.c $(CXX_TREE_H) $(srcdir)/../flags.h \
lex.h decl.h $(srcdir)/../stack.h $(srcdir)/../output.h \
- $(srcdir)/../except.h $(srcdir)/../system.h $(srcdir)/../toplev.h \
+ $(srcdir)/../except.h $(srcdir)/../toplev.h \
$(srcdir)/../hash.h $(srcdir)/../ggc.h $(RTL_H)
-decl2.o : decl2.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
- lex.h decl.h $(EXPR_H) $(srcdir)/../except.h \
- $(srcdir)/../output.h $(srcdir)/../except.h $(srcdir)/../system.h \
+decl2.o : decl2.c $(CXX_TREE_H) $(srcdir)/../flags.h \
+ lex.h decl.h $(EXPR_H) $(srcdir)/../output.h $(srcdir)/../except.h \
$(srcdir)/../toplev.h $(srcdir)/../dwarf2out.h $(srcdir)/../dwarfout.h \
- $(srcdir)/../../include/splay-tree.h $(srcdir)/../ggc.h $(RTL_H)
-typeck2.o : typeck2.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h $(srcdir)/../output.h
-typeck.o : typeck.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
- $(EXPR_H) $(srcdir)/../system.h $(srcdir)/../toplev.h
-class.o : class.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h \
- $(srcdir)/../../include/splay-tree.h $(RTL_H)
-call.o : call.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h $(RTL_H)
-friend.o : friend.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
- $(srcdir)/../system.h $(srcdir)/../toplev.h
-init.o : init.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
- $(EXPR_H) $(srcdir)/../system.h $(srcdir)/../toplev.h $(srcdir)/../ggc.h
-method.o : method.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h \
+ $(srcdir)/../ggc.h $(RTL_H)
+typeck2.o : typeck2.c $(CXX_TREE_H) $(srcdir)/../flags.h \
+ $(srcdir)/../toplev.h $(srcdir)/../output.h
+typeck.o : typeck.c $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
+ $(EXPR_H) $(srcdir)/../toplev.h
+class.o : class.c $(CXX_TREE_H) $(srcdir)/../flags.h \
+ $(srcdir)/../toplev.h $(RTL_H)
+call.o : call.c $(CXX_TREE_H) $(srcdir)/../flags.h \
+ $(srcdir)/../toplev.h $(RTL_H)
+friend.o : friend.c $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
+ $(srcdir)/../toplev.h
+init.o : init.c $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
+ $(EXPR_H) $(srcdir)/../toplev.h $(srcdir)/../ggc.h \
+ $(srcdir)/../except.h
+method.o : method.c $(CXX_TREE_H) \
$(srcdir)/../toplev.h $(srcdir)/../ggc.h $(RTL_H)
-cvt.o : cvt.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h decl.h \
+cvt.o : cvt.c $(CXX_TREE_H) decl.h \
$(srcdir)/../flags.h $(srcdir)/../toplev.h $(srcdir)/../convert.h
-search.o : search.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../stack.h \
- $(srcdir)/../flags.h $(srcdir)/../system.h $(srcdir)/../toplev.h $(RTL_H)
-tree.o : tree.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h $(srcdir)/../ggc.h $(RTL_H) \
- $(srcdir)/../../include/splay-tree.h
-ptree.o : ptree.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h
-rtti.o : rtti.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h
-except.o : except.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
- $(srcdir)/../except.h $(srcdir)/../system.h $(srcdir)/../toplev.h
-expr.o : expr.c $(CONFIG_H) $(CXX_TREE_H) $(RTL_H) $(srcdir)/../flags.h \
- $(EXPR_H) $(srcdir)/../system.h $(srcdir)/../toplev.h $(srcdir)/../except.h
-xref.o : xref.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../input.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h
-pt.o : pt.c $(CONFIG_H) $(CXX_TREE_H) decl.h $(PARSE_H) lex.h \
- $(srcdir)/../system.h $(srcdir)/../toplev.h $(srcdir)/../ggc.h $(RTL_H)
-error.o : error.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h \
+search.o : search.c $(CXX_TREE_H) $(srcdir)/../stack.h \
+ $(srcdir)/../flags.h $(srcdir)/../toplev.h $(RTL_H)
+tree.o : tree.c $(CXX_TREE_H) $(srcdir)/../flags.h \
+ $(srcdir)/../toplev.h $(srcdir)/../ggc.h $(RTL_H) \
+ ../insn-config.h $(srcdir)/../integrate.h
+ptree.o : ptree.c $(CXX_TREE_H) $(srcdir)/../system.h
+rtti.o : rtti.c $(CXX_TREE_H) $(srcdir)/../flags.h \
+ $(srcdir)/../toplev.h
+except.o : except.c $(CXX_TREE_H) $(srcdir)/../flags.h $(RTL_H) \
+ $(srcdir)/../except.h $(srcdir)/../toplev.h
+expr.o : expr.c $(CXX_TREE_H) $(RTL_H) $(srcdir)/../flags.h \
+ $(EXPR_H) $(srcdir)/../toplev.h $(srcdir)/../except.h
+xref.o : xref.c $(CXX_TREE_H) $(srcdir)/../input.h \
+ $(srcdir)/../toplev.h
+pt.o : pt.c $(CXX_TREE_H) decl.h $(PARSE_H) lex.h \
+ $(srcdir)/../toplev.h $(srcdir)/../ggc.h $(RTL_H) \
+ $(srcdir)/../except.h
+error.o : error.c $(CXX_TREE_H) \
$(srcdir)/../toplev.h
-errfn.o : errfn.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h \
+errfn.o : errfn.c $(CXX_TREE_H) \
$(srcdir)/../toplev.h
-repo.o : repo.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h \
+repo.o : repo.c $(CXX_TREE_H) \
$(srcdir)/../toplev.h $(srcdir)/../ggc.h
-semantics.o: semantics.c $(CONFIG_H) $(CXX_TREE_H) lex.h \
- $(srcdir)/../except.h $(srcdir)/../system.h $(srcdir)/../toplev.h \
+semantics.o: semantics.c $(CXX_TREE_H) lex.h \
+ $(srcdir)/../except.h $(srcdir)/../toplev.h \
$(srcdir)/../flags.h $(srcdir)/../ggc.h
-dump.o: dump.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.h
+dump.o: dump.c $(CXX_TREE_H)
+optimize.o: optimize.c $(CXX_TREE_H) \
+ $(srcdir)/../rtl.h $(srcdir)/../integrate.h ../insn-config.h
#\f
# These exist for maintenance purposes.
#include "rtl.h"
#include "output.h"
#include "toplev.h"
-#include "splay-tree.h"
#include "ggc.h"
#include "lex.h"
run if an exception is thrown before the end of the enclosing
function. */
DEFTREECODE (SUBOBJECT, "subobject", 'e', 1)
-/* A CTOR_COMPLETE statements marks the end of the main body of the
- constructor, not including any function try blocks. */
-DEFTREECODE (CTOR_COMPLETE, "ctor_complete", 'e', 0)
+/* An CTOR_STMT marks the beginning (if CTOR_BEGIN_P holds) or end of
+ a contstructor (if CTOR_END_P) holds. At the end of a constructor,
+ the cleanups associated with any SUBOBJECT_CLEANUPS need no longer
+ be run. */
+DEFTREECODE (CTOR_STMT, "ctor_stmt", 'e', 0)
/* A CLEANUP_STMT marks the point at which a declaration is fully
constructed. If, after this point, the CLEANUP_DECL goes out of
scope, the CLEANUP_EXPR must be run. */
#include "c-common.h"
#include "function.h"
+#include "splay-tree.h"
#include "varray.h"
#ifndef _CP_TREE_H
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)
1: IDENTIFIER_VIRTUAL_P.
TI_PENDING_TEMPLATE_FLAG.
TEMPLATE_PARMS_FOR_INLINE.
#define SET_DECL_C_BIT_FIELD(NODE) \
(DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE))->decl_flags.bitfield = 1)
+/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
+#define DECL_UNINLINABLE(NODE) \
+ (DECL_LANG_SPECIFIC (NODE)->decl_flags.bitfield)
+
#define INTEGRAL_CODE_P(CODE) \
(CODE == INTEGER_TYPE || CODE == ENUMERAL_TYPE || CODE == BOOLEAN_TYPE)
#define SCOPE_END_P(NODE) \
(!SCOPE_BEGIN_P (SCOPE_STMT_CHECK (NODE)))
+/* Nonzero if this CTOR_STMT is for the beginning of a constructor. */
+#define CTOR_BEGIN_P(NODE) \
+ (TREE_LANG_FLAG_0 (CTOR_STMT_CHECK (NODE)))
+
+/* Nonzero if this CTOR_STMT is for the end of a constructor. */
+#define CTOR_END_P(NODE) \
+ (!CTOR_BEGIN_P (NODE))
+
/* Nonzero for a SCOPE_STMT if there were no variables in this scope. */
#define SCOPE_NULLIFIED_P(NODE) \
(TREE_LANG_FLAG_3 (SCOPE_STMT_CHECK (NODE)))
extern int flag_honor_std;
+/* Nonzero if we should expand functions calls inline at the tree
+ level, rather than at the RTL level. */
+
+extern int flag_inline_trees;
+
/* Nonzero if we're done parsing and into end-of-file activities. */
extern int at_eof;
extern void emit_local_var PROTO((tree));
extern tree build_target_expr_with_type PROTO((tree, tree));
extern void make_rtl_for_local_static PROTO((tree));
+extern int local_variable_p PROTO((tree));
+extern int nonstatic_local_decl_p PROTO((tree));
/* in decl2.c */
extern void init_decl2 PROTO((void));
extern void synthesize_method PROTO((tree));
extern tree get_id_2 PROTO((const char *, tree));
+/* In optimize.c */
+extern void optimize_function PROTO((tree));
+
/* in pt.c */
extern void init_pt PROTO ((void));
extern void check_template_shadow PROTO ((tree));
/* in tree.c */
extern void init_tree PROTO((void));
-extern void cplus_unsave_expr_now PROTO((tree));
extern int pod_type_p PROTO((tree));
extern void unshare_base_binfos PROTO((tree));
extern int member_p PROTO((tree));
extern int is_dummy_object PROTO((tree));
typedef tree (*walk_tree_fn) PROTO((tree *, int *, void *));
extern tree walk_tree PROTO((tree *, walk_tree_fn, void *));
+extern tree copy_tree_r PROTO((tree *, int *, void *));
extern int cp_valid_lang_attribute PROTO((tree, tree, tree, tree));
extern tree make_ptrmem_cst PROTO((tree, tree));
extern tree cp_build_qualified_type_real PROTO((tree, int, int));
+extern void remap_save_expr PROTO((tree *, splay_tree, tree));
#define cp_build_qualified_type(TYPE, QUALS) \
cp_build_qualified_type_real ((TYPE), (QUALS), /*complain=*/1)
static void push_binding PROTO((tree, tree, struct binding_level*));
static int add_binding PROTO((tree, tree));
static void pop_binding PROTO((tree, tree));
-static tree local_variable_p PROTO((tree *, int *, void *));
+static tree local_variable_p_walkfn PROTO((tree *, int *, void *));
static tree find_binding PROTO((tree, tree));
static tree select_decl PROTO((tree, int));
static int lookup_flags PROTO((int, int));
tree type = TREE_TYPE (decl);
const char *asmspec = NULL;
- if (TREE_READONLY (decl)
- && DECL_INITIAL (decl) != NULL_TREE
- && DECL_INITIAL (decl) != error_mark_node
- && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
- && ! TREE_SIDE_EFFECTS (decl)
- && ! TREE_PUBLIC (decl)
- && ! DECL_EXTERNAL (decl)
- && ! TYPE_NEEDS_DESTRUCTOR (type)
- && ! TREE_ADDRESSABLE (decl)
- && DECL_MODE (decl) != BLKmode)
- {
- /* As an optimization, we try to put register-sized static
- constants in a register, rather than writing them out. If we
- take the address of the constant later, we'll make RTL for it
- at that point. */
- DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
- store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
- TREE_ASM_WRITTEN (decl) = 1;
- return;
- }
+ /* 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))
{
{
/* 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. */
+ /* 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
}
}
-/* Returns *TP if *TP is a local variable (or parameter). Returns
- NULL_TREE otherwise. */
+/* Returns non-zero if T is a local variable. */
-static tree
-local_variable_p (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+int
+local_variable_p (t)
+ tree t;
{
- tree t = *tp;
-
if ((TREE_CODE (t) == VAR_DECL
/* A VAR_DECL with a context that is a _TYPE is a static data
member. */
&& !TYPE_P (CP_DECL_CONTEXT (t))
/* Any other non-local variable must be at namespace scope. */
- && TREE_CODE (CP_DECL_CONTEXT (t)) != NAMESPACE_DECL)
+ && !DECL_NAMESPACE_SCOPE_P (t))
|| (TREE_CODE (t) == PARM_DECL))
- return t;
+ return 1;
- return NULL_TREE;
+ return 0;
+}
+
+/* Returns non-zero if T is an automatic local variable or a label.
+ (These are the declarations that need to be remapped when the code
+ containing them is duplicated.) */
+
+int
+nonstatic_local_decl_p (t)
+ tree t;
+{
+ return ((local_variable_p (t) && !TREE_STATIC (t))
+ || TREE_CODE (t) == LABEL_DECL
+ || TREE_CODE (t) == RESULT_DECL);
+}
+
+/* Like local_variable_p, but suitable for use as a tree-walking
+ function. */
+
+static tree
+local_variable_p_walkfn (tp, walk_subtrees, data)
+ tree *tp;
+ int *walk_subtrees ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
+{
+ return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
+ ? *tp : NULL_TREE);
}
/* Check that ARG, which is a default-argument expression for a
The keyword `this' shall not be used in a default argument of a
member function. */
- var = walk_tree (&arg, local_variable_p, NULL);
+ var = walk_tree (&arg, local_variable_p_walkfn, NULL);
if (var)
{
cp_error ("default argument `%E' uses local variable `%D'",
if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
&& DECL_LANGUAGE (decl1) == lang_cplusplus)
- dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ {
+ dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ DECL_CONTEXT (dtor_label) = current_function_decl;
+ }
else if (DECL_CONSTRUCTOR_P (decl1))
- ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ {
+ ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ DECL_CONTEXT (ctor_label) = current_function_decl;
+ }
return 1;
}
/* In check_return_expr we translate an empty return from a
constructor to a return of `this'. */
finish_return_stmt (NULL_TREE);
-
- /* Mark the end of the main constructor body. */
- if (DECL_CONSTRUCTOR_P (current_function_decl))
- add_tree (build_min_nt (CTOR_COMPLETE));
+ /* Mark the end of the constructor. */
+ add_tree (build_min_nt (CTOR_STMT));
}
/* At the end of every destructor we generate code to restore virtual
#include "toplev.h"
#include "dwarf2out.h"
#include "dwarfout.h"
-#include "splay-tree.h"
#include "ggc.h"
#if USE_CPPLIB
int flag_honor_std;
+/* Nonzero if we should expand functions calls inline at the tree
+ level, rather than at the RTL level. */
+
+int flag_inline_trees = 0;
+
/* Maximum template instantiation depth. Must be at least 17 for ANSI
compliance. */
#include "system.h"
#include "tree.h"
#include "cp-tree.h"
-#include "splay-tree.h"
/* Flags used with queue functions. */
#define DUMP_NONE 0
/* Cleanup the EH parameter. */
finish_compound_stmt (/*has_no_scope=*/0, compound_stmt_2);
- /* Cleanup the EH object. */
+ /* Cleanup the EH object. */
finish_compound_stmt (/*has_no_scope=*/0, compound_stmt_1);
}
decl = build_decl (VAR_DECL, NULL_TREE, tmp);
DECL_ARTIFICIAL (decl) = 1;
DECL_INITIAL (decl) = types;
+ DECL_CONTEXT (decl) = current_function_decl;
cp_finish_decl (decl, types, NULL_TREE, 0);
decl = decay_conversion (decl);
tree object, ptr;
/* OK, this is kind of wacky. The WP says that we call
- terminate
-
- when the exception handling mechanism, after completing
- evaluation of the expression to be thrown but before the
- exception is caught (_except.throw_), calls a user function
- that exits via an uncaught exception.
+ terminate when the exception handling mechanism, after
+ completing evaluation of the expression to be thrown but
+ before the exception is caught (_except.throw_), calls a
+ user function that exits via an uncaught exception.
So we have to protect the actual initialization of the
exception object with terminate(), but evaluate the expression
/* The below is short by BI_header_size */
virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
- tbase = build_decl (VAR_DECL, NULL_TREE, ptype);
+ tbase = create_temporary_var (ptype);
tbase_init = build_modify_expr (tbase, NOP_EXPR,
fold (build (PLUS_EXPR, ptype,
base,
Used to represent a @code{continue} statement. There are no additional
fields.
-@item CTOR_COMPLETE
+@item CTOR_STMT
-Used to mark the end of the main body of a constructor.
+Used to mark the beginning (if @code{CTOR_BEGIN_P} holds) or end (if
+@code{CTOR_END_P} holds of the main body of a constructor. See also
+@code{SUBOBJECT} for more information on how to use these nodes.
@item DECL_STMT
In a constructor, these nodes are used to mark the point at which a
subobject of @code{this} is fully constructed. If, after this point, an
-exception is thrown before a CTOR_COMPLETE statement is encountered, the
-@code{SUBOBJECT_CLEANUP} must be executed. The cleanups must be
-executed in the reverse order in which they appear.
+exception is thrown before a @code{CTOR_STMT} with @code{CTOR_END_P} set
+is encountered, the @code{SUBOBJECT_CLEANUP} must be executed. The
+cleanups must be executed in the reverse order in which they appear.
@item SWITCH_STMT
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
-char cplus_tree_code_type[] = {
+static char cplus_tree_code_type[] = {
'x',
#include "cp-tree.def"
};
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
-int cplus_tree_code_length[] = {
+static int cplus_tree_code_length[] = {
0,
#include "cp-tree.def"
};
Used for printing out the tree and error messages. */
#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
-const char *cplus_tree_code_name[] = {
+static const char *cplus_tree_code_name[] = {
"@@dummy",
#include "cp-tree.def"
};
--- /dev/null
+/* Perform optimizations on tree structure.
+
+ Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ Written by Mark Michell (mark@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 "cp-tree.h"
+#include "rtl.h"
+#include "insn-config.h"
+#include "integrate.h"
+#include "varray.h"
+
+/* To Do:
+
+ o Provide debugging information for inlined function bodies.
+
+ o In order to make inlining-on-trees work, we pessimized
+ function-local static constants. In particular, they are now
+ always output, even when not addressed. Fix this by treating
+ function-local static constants just like global static
+ constants; the back-end already knows not to output them if they
+ are not needed.
+
+ o Provide heuristics to clamp inlining of recursive template
+ calls? */
+
+/* Data required for function inlining. */
+
+typedef struct inline_data
+{
+ /* A stack of the functions we are inlining. For example, if we are
+ compiling `f', which calls `g', which calls `h', and we are
+ inlining the body of `h', the stack will contain, `h', followed
+ by `g', followed by `f'. */
+ varray_type fns;
+ /* The top of the FNS stack. */
+ size_t fns_top;
+ /* The label to jump to when a return statement is encountered. */
+ tree ret_label;
+ /* The map from local declarations in the inlined function to
+ equivalents in the function into which it is being inlined. */
+ splay_tree decl_map;
+} inline_data;
+
+/* Prototypes. */
+
+static tree initialize_inlined_parameters PROTO((inline_data *, tree));
+static tree declare_return_variable PROTO((inline_data *, tree *));
+static tree copy_body_r PROTO((tree *, int *, void *));
+static tree copy_body PROTO((inline_data *));
+static tree expand_call_inline PROTO((tree *, int *, void *));
+static void expand_calls_inline PROTO((tree *, inline_data *));
+static int inlinable_function_p PROTO((tree, inline_data *));
+
+/* Called from copy_body via walk_tree. DATA is really an
+ `inline_data *'. */
+
+static tree
+copy_body_r (tp, walk_subtrees, data)
+ tree *tp;
+ int *walk_subtrees;
+ void *data;
+{
+ inline_data* id;
+ tree fn;
+
+ /* Set up. */
+ id = (inline_data *) data;
+ fn = VARRAY_TREE (id->fns, id->fns_top - 1);
+
+ /* All automatic variables should have a DECL_CONTEXT indicating
+ what function they come from. */
+ if ((TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == LABEL_DECL)
+ && DECL_NAMESPACE_SCOPE_P (*tp))
+ my_friendly_assert (DECL_EXTERNAL (*tp) || TREE_STATIC (*tp),
+ 19991113);
+
+ /* If this is a RETURN_STMT, change it into an EXPR_STMT and a
+ GOTO_STMT with the RET_LABEL as its target. */
+ if (TREE_CODE (*tp) == RETURN_STMT)
+ {
+ tree return_stmt = *tp;
+ tree goto_stmt;
+
+ /* Build the GOTO_STMT. */
+ goto_stmt = build_min_nt (GOTO_STMT, id->ret_label);
+ TREE_CHAIN (goto_stmt) = TREE_CHAIN (return_stmt);
+
+ /* If we're returning something, just turn that into an
+ assignment into the equivalent of the original
+ RESULT_DECL. */
+ if (RETURN_EXPR (return_stmt))
+ {
+ *tp = build_min_nt (EXPR_STMT,
+ RETURN_EXPR (return_stmt));
+ /* And then jump to the end of the function. */
+ TREE_CHAIN (*tp) = goto_stmt;
+ }
+ /* If we're not returning anything just do the jump. */
+ else
+ *tp = goto_stmt;
+ }
+ /* Local variables and labels need to be replaced by equivalent
+ variables. We don't want to copy static variables; there's only
+ one of those, no matter how many times we inline the containing
+ function. */
+ else if (nonstatic_local_decl_p (*tp) && DECL_CONTEXT (*tp) == fn)
+ {
+ splay_tree_node n;
+
+ /* Look up the declaration. */
+ n = splay_tree_lookup (id->decl_map, (splay_tree_key) *tp);
+
+ /* If we didn't already have an equivalent for this declaration,
+ create one now. */
+ if (!n)
+ {
+ tree t;
+
+ /* Make a copy of the variable or label. */
+ t = copy_decl_for_inlining (*tp, fn,
+ VARRAY_TREE (id->fns, 0));
+ /* Remember it, so that if we encounter this local entity
+ again we can reuse this copy. */
+ n = splay_tree_insert (id->decl_map,
+ (splay_tree_key) *tp,
+ (splay_tree_value) t);
+ }
+
+ /* Replace this variable with the copy. */
+ *tp = (tree) n->value;
+ }
+ else if (TREE_CODE (*tp) == SAVE_EXPR)
+ remap_save_expr (tp, id->decl_map, VARRAY_TREE (id->fns, 0));
+ else if (TREE_CODE (*tp) == UNSAVE_EXPR)
+ my_friendly_abort (19991113);
+ /* Otherwise, just copy the node. Note that copy_tree_r already
+ knows not to copy VAR_DECLs, etc., so this is safe. */
+ else
+ {
+ copy_tree_r (tp, walk_subtrees, NULL);
+
+ /* The copied TARGET_EXPR has never been expanded, even if the
+ original node was expanded already. */
+ if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
+ TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
+ /* Similarly, if we're copying a CALL_EXPR, the RTL for the
+ result is no longer valid. */
+ else if (TREE_CODE (*tp) == CALL_EXPR)
+ CALL_EXPR_RTL (*tp) = NULL_RTX;
+ }
+
+ /* Keep iterating. */
+ return NULL_TREE;
+}
+
+/* Make a copy of the body of FN so that it can be inserted inline in
+ another function. */
+
+static tree
+copy_body (id)
+ inline_data *id;
+{
+ tree body;
+
+ body = DECL_SAVED_TREE (VARRAY_TREE (id->fns, id->fns_top - 1));
+ walk_tree (&body, copy_body_r, id);
+
+ return body;
+}
+
+/* Generate code to initialize the parameters of the function at the
+ top of the stack in ID from the ARGS (presented as a TREE_LIST). */
+
+static tree
+initialize_inlined_parameters (id, args)
+ inline_data *id;
+ tree args;
+{
+ tree fn;
+ tree init_stmts;
+ tree parms;
+ tree a;
+ tree p;
+
+ /* Figure out what the parameters are. */
+ fn = VARRAY_TREE (id->fns, id->fns_top - 1);
+ parms = DECL_ARGUMENTS (fn);
+
+ /* Start with no initializations whatsoever. */
+ init_stmts = NULL_TREE;
+
+ /* Loop through the parameter declarations, replacing each with an
+ equivalent VAR_DECL, appropriately initialized. */
+ for (p = parms, a = args; p; a = TREE_CHAIN (a), p = TREE_CHAIN (p))
+ {
+ tree init_stmt;
+ tree var;
+
+ /* Make an equivalent VAR_DECL. */
+ var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0));
+ /* Register the VAR_DECL as the equivalent for the PARM_DECL;
+ that way, when the PARM_DECL is encountered, it will be
+ automatically replaced by the VAR_DECL. */
+ splay_tree_insert (id->decl_map,
+ (splay_tree_key) p,
+ (splay_tree_value) var);
+ /* Initialize this VAR_DECL from the equivalent argument. If
+ the argument is an object, created via a constructor or copy,
+ this will not result in an extra copy: the TARGET_EXPR
+ representing the argument will be bound to VAR, and the
+ object will be constructed in VAR. */
+ init_stmt = build_min_nt (EXPR_STMT,
+ build (INIT_EXPR, TREE_TYPE (p),
+ var, TREE_VALUE (a)));
+ /* Declare this new variable. Note that we do this *after* the
+ initialization because we are going to reverse all the
+ initialization statements below. */
+ TREE_CHAIN (init_stmt) = build_min_nt (DECL_STMT, var);
+ /* Add this initialization to the list. */
+ TREE_CHAIN (TREE_CHAIN (init_stmt)) = init_stmts;
+ init_stmts = init_stmt;
+ }
+
+ /* The initialization statements have been built up in reverse
+ order. Straighten them out now. */
+ return nreverse (init_stmts);
+}
+
+/* Declare a return variable to replace the RESULT_DECL for the
+ function we are calling. An appropriate DECL_STMT is returned.
+ The USE_STMT is filled in to contain a use of the declaration to
+ indicate the return value of the function. */
+
+static tree
+declare_return_variable (id, use_stmt)
+ struct inline_data *id;
+ tree *use_stmt;
+{
+ tree fn = VARRAY_TREE (id->fns, id->fns_top - 1);
+ tree result = DECL_RESULT (fn);
+ tree var;
+
+ /* We don't need to do anything for functions that don't return
+ anything. */
+ if (!result || same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (result)),
+ void_type_node))
+ {
+ *use_stmt = NULL_TREE;
+ return NULL_TREE;
+ }
+
+ /* Make an appropriate copy. */
+ var = copy_decl_for_inlining (result, fn, VARRAY_TREE (id->fns, 0));
+ /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
+ way, when the RESULT_DECL is encountered, it will be
+ automatically replaced by the VAR_DECL. */
+ splay_tree_insert (id->decl_map,
+ (splay_tree_key) result,
+ (splay_tree_value) var);
+
+ /* Build the USE_STMT. */
+ *use_stmt = build_min_nt (EXPR_STMT, var);
+
+ /* Build the declaration statement. */
+ return build_min_nt (DECL_STMT, var);
+}
+
+/* Returns non-zero if FN is a function that can be inlined. */
+
+static int
+inlinable_function_p (fn, id)
+ tree fn;
+ inline_data *id;
+{
+ int inlinable;
+
+ /* If we've already decided this function shouldn't be inlined,
+ there's no need to check again. */
+ if (DECL_UNINLINABLE (fn))
+ return 0;
+
+ /* Assume it is not inlinable. */
+ inlinable = 0;
+
+ /* If the function was not declared `inline', then we don't inline
+ it. */
+ if (!DECL_INLINE (fn))
+ ;
+ /* If we don't have the function body available, we can't inline
+ it. */
+ else if (!DECL_SAVED_TREE (fn))
+ ;
+ /* We can't inline varargs functions. */
+ else if (varargs_function_p (fn))
+ ;
+ /* All is well. We can inline this function. Traditionally, GCC
+ has refused to inline functions using setjmp or alloca, or
+ functions whose values are returned in a PARALLEL, and a few
+ other such obscure conditions. We are not equally constrained at
+ the tree level. */
+ else
+ inlinable = 1;
+
+ /* Squirrel away the result so that we don't have to check again. */
+ DECL_UNINLINABLE (fn) = !inlinable;
+
+ /* Don't do recursive inlining, either. We don't record this in
+ DECL_UNLINABLE; we may be able to inline this function later. */
+ if (inlinable)
+ {
+ size_t i;
+
+ for (i = 0; i < id->fns_top; ++i)
+ if (VARRAY_TREE (id->fns, i) == fn)
+ inlinable = 0;
+ }
+
+ /* We can inline a template instantiation only if its fully
+ instantiated. */
+ if (inlinable
+ && DECL_TEMPLATE_INFO (fn)
+ && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
+ {
+ fn = instantiate_decl (fn);
+ inlinable = !TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn));
+ }
+
+ /* Return the result. */
+ return inlinable;
+}
+
+/* If *TP is CALL_EXPR, replace it with its inline expansion. */
+
+static tree
+expand_call_inline (tp, walk_subtrees, data)
+ tree *tp;
+ int *walk_subtrees;
+ void *data;
+{
+ inline_data *id;
+ tree t;
+ tree expr;
+ tree chain;
+ tree fn;
+ tree use_stmt;
+ splay_tree st;
+
+ /* We're only interested in CALL_EXPRs. */
+ t = *tp;
+ if (TREE_CODE (t) != CALL_EXPR)
+ return NULL_TREE;
+
+ /* First, see if we can figure out what function is being called.
+ If we cannot, then there is no hope of inlining the function. */
+ fn = get_callee_fndecl (t);
+ if (!fn)
+ return NULL_TREE;
+
+ /* Don't try to inline functions that are not well-suited to
+ inlining. */
+ id = (inline_data *) data;
+ if (!inlinable_function_p (fn, id))
+ return NULL_TREE;
+
+ /* Return statements in the function body will be replaced by jumps
+ to the RET_LABEL. */
+ id->ret_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
+
+ /* Build a statement-expression containing code to initialize the
+ arguments, the actual inline expansion of the body, and a label
+ for the return statements within the function to jump to. The
+ type of the statement expression is the return type of the
+ function call. */
+ expr = build_min (STMT_EXPR, TREE_TYPE (TREE_TYPE (fn)), NULL_TREE);
+
+ /* Record the function we are about to inline so that we can avoid
+ recursing into it. */
+ if (id->fns_top > id->fns->num_elements)
+ VARRAY_GROW (id->fns, 2 * id->fns->num_elements);
+ VARRAY_TREE (id->fns, id->fns_top++) = fn;
+
+ /* Local declarations will be replaced by their equivalents in this
+ map. */
+ st = id->decl_map;
+ id->decl_map = splay_tree_new (splay_tree_compare_pointers,
+ NULL, NULL);
+
+ /* Initialize the parameters. */
+ STMT_EXPR_STMT (expr)
+ = initialize_inlined_parameters (id, TREE_OPERAND (t, 1));
+
+ /* Declare the return variable for the function. */
+ STMT_EXPR_STMT (expr)
+ = chainon (STMT_EXPR_STMT (expr),
+ declare_return_variable (id, &use_stmt));
+
+ /* After we've initialized the parameters, we insert the body of the
+ function itself. */
+ STMT_EXPR_STMT (expr)
+ = chainon (STMT_EXPR_STMT (expr), copy_body (id));
+
+ /* Finally, mention the returned value so that the value of the
+ statement-expression is the returned value of the function. */
+ STMT_EXPR_STMT (expr) = chainon (STMT_EXPR_STMT (expr), use_stmt);
+
+ /* Clean up. */
+ splay_tree_delete (id->decl_map);
+ id->decl_map = st;
+
+ /* After the body of the function comes the RET_LABEL. */
+ STMT_EXPR_STMT (expr)
+ = chainon (STMT_EXPR_STMT (expr),
+ build_min_nt (LABEL_STMT, id->ret_label));
+
+ /* The new expression has side-effects if the old one did. */
+ TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (t);
+ /* If the value of the new expression is ignored, that's OK. We
+ don't warn about this for CALL_EXPRs, so we shouldn't warn about
+ the equivalent inlined version either. */
+ TREE_USED (expr) = 1;
+
+ /* Replace the call by the inlined body. */
+ chain = TREE_CHAIN (*tp);
+ *tp = expr;
+ TREE_CHAIN (expr) = chain;
+
+ /* Recurse into the body of the just inlined function. */
+ expand_calls_inline (tp, id);
+ --id->fns_top;
+
+ /* Don't walk into subtrees. We've already handled them above. */
+ *walk_subtrees = 0;
+
+ /* Keep iterating. */
+ return NULL_TREE;
+}
+
+/* Walk over the entire tree *TP, replacing CALL_EXPRs with inline
+ expansions as appropriate. */
+
+static void
+expand_calls_inline (tp, id)
+ tree *tp;
+ inline_data *id;
+{
+ /* Search through *TP, replacing all calls to inline functions by
+ appropriate equivalents. */
+ walk_tree (tp, expand_call_inline, id);
+}
+
+/* Optimize the body of FN. */
+
+void
+optimize_function (fn)
+ tree fn;
+{
+ /* Expand calls to inline functions. */
+ if (flag_inline_trees)
+ {
+ inline_data id;
+
+ /* Clear out ID. */
+ bzero (&id, sizeof (id));
+
+ /* Don't allow recursion into FN. */
+ VARRAY_TREE_INIT (id.fns, 32, "fns");
+ VARRAY_TREE (id.fns, id.fns_top++) = fn;
+
+ /* Replace all calls to inline functions with the bodies of those
+ functions. */
+ expand_calls_inline (&DECL_SAVED_TREE (fn), &id);
+
+ /* Clean up. */
+ VARRAY_FREE (id.fns);
+ }
+}
TREE_USED (destination) = 1;
if (building_stmt_tree ())
- add_tree (build_min_nt (GOTO_STMT, destination));
+ {
+ if (TREE_CODE (destination) != LABEL_DECL)
+ /* We don't inline calls to functions with computed gotos.
+ Those functions are typically up to some funny business,
+ and may be depending on the labels being at particular
+ addresses, or some such. */
+ DECL_UNINLINABLE (current_function_decl) = 1;
+
+ add_tree (build_min_nt (GOTO_STMT, destination));
+ }
else
{
emit_line_note (input_filename, lineno);
(CTOR_INITIALIZER,
current_member_init_list, current_base_init_list));
else
- finish_expr_stmt (emit_base_init (current_class_type));
+ {
+ tree ctor_stmt;
+
+ /* Mark the beginning of the constructor. */
+ ctor_stmt = build_min_nt (CTOR_STMT);
+ CTOR_BEGIN_P (ctor_stmt) = 1;
+ add_tree (ctor_stmt);
+
+ /* And actually initialize the base-classes and members. */
+ finish_expr_stmt (emit_base_init (current_class_type));
+ }
}
else if (DECL_DESTRUCTOR_P (current_function_decl)
&& !processing_template_decl)
TREE_USED (label) = 1;
result = build1 (ADDR_EXPR, ptr_type_node, label);
TREE_CONSTANT (result) = 1;
+ /* This function cannot be inlined. All jumps to the addressed
+ label should wind up at the same point. */
+ DECL_UNINLINABLE (current_function_decl) = 1;
}
return result;
finish_expr_stmt (EXPR_STMT_EXPR (t));
break;
- case CTOR_COMPLETE:
- /* All subobjects have been fully constructed at this point. */
- end_protect_partials ();
- break;
-
case DECL_STMT:
{
tree decl;
begin_catch_block (TREE_TYPE (t));
break;
+ case CTOR_STMT:
+ if (CTOR_BEGIN_P (t))
+ begin_protect_partials ();
+ else
+ /* After this point, any exceptions will cause the
+ destructor to be executed, so we no longer need to worry
+ about destroying the various subobjects ourselves. */
+ end_protect_partials ();
+ break;
+
case FOR_STMT:
{
tree tmp;
if (flag_syntax_only)
return;
+ /* Optimize the body of the function before expanding it. */
+ optimize_function (fn);
+
/* Save the current file name and line number. When we expand the
body of the function, we'll set LINENO and INPUT_FILENAME so that
error-mesages come out in the right places. */
/* Generate code for the function. */
finish_function (lineno, 0);
- /* We don't need the body any more. Allow it to be garbage
- collected. We can't do this if we're going to dump everything. */
- if (!flag_dump_translation_unit)
+ /* If possible, obliterate the body of the function so that it can
+ be garbage collected. */
+ if (flag_dump_translation_unit)
+ /* Keep the body; we're going to dump it. */
+ ;
+ else if (DECL_INLINE (fn) && flag_inline_trees)
+ /* We might need the body of this function so that we can expand
+ it inline somewhere else. */
+ ;
+ else
+ /* We don't need the body; blow it away. */
DECL_SAVED_TREE (fn) = NULL_TREE;
/* And restore the current source position. */
#include "rtl.h"
#include "toplev.h"
#include "ggc.h"
-#include "splay-tree.h"
+#include "insn-config.h"
+#include "integrate.h"
static tree bot_manip PROTO((tree *, int *, void *));
static tree bot_replace PROTO((tree *, int *, void *));
static tree no_linkage_helper PROTO((tree *, int *, void *));
static tree build_srcloc PROTO((char *, int));
static void mark_list_hash PROTO ((void *));
-static tree copy_tree_r PROTO ((tree *, int *, void *));
+static int statement_code_p PROTO((enum tree_code));
+static tree mark_local_for_remap_r PROTO((tree *, int *, void *));
+static tree cp_unsave_r PROTO ((tree *, int *, void *));
+static void cp_unsave PROTO((tree *));
static tree build_target_expr PROTO((tree, tree));
#define CEIL(x,y) (((x) + (y) - 1) / (y))
slot = build (VAR_DECL, type);
DECL_ARTIFICIAL (slot) = 1;
+ DECL_CONTEXT (slot) = current_function_decl;
layout_decl (slot, 0);
/* We split the CALL_EXPR into its function and its arguments here.
return 0;
return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
}
+
+/* Returns non-zero if CODE is the code for a statement. */
+
+static int
+statement_code_p (code)
+ enum tree_code code;
+{
+ switch (code)
+ {
+ case EXPR_STMT:
+ case COMPOUND_STMT:
+ case DECL_STMT:
+ case IF_STMT:
+ case FOR_STMT:
+ case WHILE_STMT:
+ case DO_STMT:
+ case RETURN_STMT:
+ case BREAK_STMT:
+ case CONTINUE_STMT:
+ case SWITCH_STMT:
+ case GOTO_STMT:
+ case LABEL_STMT:
+ case ASM_STMT:
+ case SUBOBJECT:
+ case CLEANUP_STMT:
+ case START_CATCH_STMT:
+ case CTOR_STMT:
+ case SCOPE_STMT:
+ case CTOR_INITIALIZER:
+ case CASE_LABEL:
+ case RETURN_INIT:
+ case TRY_BLOCK:
+ case HANDLER:
+ return 1;
+
+ default:
+ return 0;
+ }
+}
\f
#define PRINT_RING_SIZE 4
/* Handle commmon cases up front. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
- || TREE_CODE_CLASS (code) == 'r')
+ || TREE_CODE_CLASS (code) == 'r'
+ || TREE_CODE_CLASS (code) == 's')
{
int i;
for (i = first_rtl_op (code) - 1; i >= 0; --i)
WALK_SUBTREE (TREE_OPERAND (*tp, i));
+ /* For statements, we also walk the chain so that we cover the
+ entire statement tree. */
+ if (statement_code_p (code))
+ WALK_SUBTREE (TREE_CHAIN (*tp));
+
/* We didn't find what we were looking for. */
return NULL_TREE;
}
if (TYPE_PTRMEMFUNC_P (*tp))
WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
break;
-
+
default:
my_friendly_abort (19990803);
}
/* Passed to walk_tree. Copies the node pointed to, if appropriate. */
-static tree
+tree
copy_tree_r (tp, walk_subtrees, data)
tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
+ int *walk_subtrees;
void *data ATTRIBUTE_UNUSED;
{
enum tree_code code = TREE_CODE (*tp);
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
|| TREE_CODE_CLASS (code) == 'r'
|| TREE_CODE_CLASS (code) == 'c'
+ || TREE_CODE_CLASS (code) == 's'
|| code == PARM_DECL
|| code == TREE_LIST
|| code == TREE_VEC
/* Now, restore the chain, if appropriate. That will cause
walk_tree to walk into the chain as well. */
- if (code == PARM_DECL || code == TREE_LIST || code == OVERLOAD)
+ if (code == PARM_DECL || code == TREE_LIST || code == OVERLOAD
+ || statement_code_p (code))
TREE_CHAIN (*tp) = chain;
+
+ /* For now, we don't update BLOCKs when we make copies. So, we
+ have to nullify all scope-statements. */
+ if (TREE_CODE (*tp) == SCOPE_STMT)
+ SCOPE_NULLIFIED_P (*tp) = 1;
}
else if (code == TEMPLATE_TEMPLATE_PARM)
/* These must be copied specially. */
*tp = copy_template_template_parm (*tp);
+ else if (TREE_CODE_CLASS (code) == 't')
+ /* There's no need to copy types, or anything beneath them. */
+ *walk_subtrees = 0;
return NULL_TREE;
}
init_tree ()
{
make_lang_type_fn = cp_make_lang_type;
- lang_unsave_expr_now = cplus_unsave_expr_now;
+ lang_unsave = cp_unsave;
ggc_add_root (list_hash_table,
sizeof (list_hash_table) / sizeof (struct list_hash *),
sizeof (struct list_hash *),
mark_list_hash);
}
-/* The C++ version of unsave_expr_now.
- See gcc/tree.c:unsave_expr_now for comments. */
+/* The SAVE_EXPR pointed to by TP is being copied. If ST contains
+ information indicating to what new SAVE_EXPR this one should be
+ mapped, use that one. Otherwise, create a new node and enter it in
+ ST. FN is the function into which the copy will be placed. */
void
-cplus_unsave_expr_now (expr)
- tree expr;
+remap_save_expr (tp, st, fn)
+ tree *tp;
+ splay_tree st;
+ tree fn;
{
- if (expr == NULL)
- return;
+ splay_tree_node n;
- else if (TREE_CODE (expr) == AGGR_INIT_EXPR)
+ /* See if we already encountered this SAVE_EXPR. */
+ n = splay_tree_lookup (st, (splay_tree_key) *tp);
+
+ /* If we didn't already remap this SAVE_EXPR, do so now. */
+ if (!n)
{
- unsave_expr_now (TREE_OPERAND (expr,0));
- if (TREE_OPERAND (expr, 1)
- && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST)
- {
- tree exp = TREE_OPERAND (expr, 1);
- while (exp)
- {
- unsave_expr_now (TREE_VALUE (exp));
- exp = TREE_CHAIN (exp);
- }
- }
- unsave_expr_now (TREE_OPERAND (expr,2));
- return;
+ tree t = copy_node (*tp);
+
+ /* The SAVE_EXPR is now part of the function into which we
+ are inlining this body. */
+ SAVE_EXPR_CONTEXT (t) = fn;
+ /* And we haven't evaluated it yet. */
+ SAVE_EXPR_RTL (t) = NULL_RTX;
+ /* Remember this SAVE_EXPR. */
+ n = splay_tree_insert (st,
+ (splay_tree_key) *tp,
+ (splay_tree_value) t);
+ }
+
+ /* Replace this SAVE_EXPR with the copy. */
+ *tp = (tree) n->value;
+}
+
+/* Called via walk_tree. If *TP points to a DECL_STMT for a local
+ declaration, copies the declaration and enters it in the splay_tree
+ pointed to by DATA (which is really a `splay_tree *'). */
+
+static tree
+mark_local_for_remap_r (tp, walk_subtrees, data)
+ tree *tp;
+ int *walk_subtrees ATTRIBUTE_UNUSED;
+ void *data;
+{
+ tree t = *tp;
+ splay_tree st = (splay_tree) data;
+
+ if ((TREE_CODE (t) == DECL_STMT
+ && nonstatic_local_decl_p (DECL_STMT_DECL (t)))
+ || TREE_CODE (t) == LABEL_STMT)
+ {
+ tree decl;
+ tree copy;
+
+ /* Figure out what's being declared. */
+ decl = (TREE_CODE (t) == DECL_STMT
+ ? DECL_STMT_DECL (t) : LABEL_STMT_LABEL (t));
+
+ /* Make a copy. */
+ copy = copy_decl_for_inlining (decl,
+ DECL_CONTEXT (decl),
+ DECL_CONTEXT (decl));
+
+ /* Remember the copy. */
+ splay_tree_insert (st,
+ (splay_tree_key) decl,
+ (splay_tree_value) copy);
}
+ return NULL_TREE;
+}
+
+/* Called via walk_tree when an expression is unsaved. Using the
+ splay_tree pointed to by ST (which is really a `splay_tree *'),
+ remaps all local declarations to appropriate replacements. */
+
+static tree
+cp_unsave_r (tp, walk_subtrees, data)
+ tree *tp;
+ int *walk_subtrees;
+ void *data;
+{
+ splay_tree st = (splay_tree) data;
+ splay_tree_node n;
+
+ /* Only a local declaration (variable or label). */
+ if (nonstatic_local_decl_p (*tp))
+ {
+ /* Lookup the declaration. */
+ n = splay_tree_lookup (st, (splay_tree_key) *tp);
+
+ /* If it's there, remap it. */
+ if (n)
+ *tp = (tree) n->value;
+ }
+ else if (TREE_CODE (*tp) == SAVE_EXPR)
+ remap_save_expr (tp, st, current_function_decl);
else
- return;
+ {
+ copy_tree_r (tp, walk_subtrees, NULL);
+
+ /* Do whatever unsaving is required. */
+ unsave_expr_1 (*tp);
+ }
+
+ /* Keep iterating. */
+ return NULL_TREE;
}
+/* Called by unsave_expr_now whenever an expression (*TP) needs to be
+ unsaved. */
+
+static void
+cp_unsave (tp)
+ tree *tp;
+{
+ splay_tree st;
+
+ /* Create a splay-tree to map old local variable declarations to new
+ ones. */
+ st = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
+
+ /* Walk the tree once figuring out what needs to be remapped. */
+ walk_tree (tp, mark_local_for_remap_r, st);
+
+ /* Walk the tree again, copying, remapping, and unsaving. */
+ walk_tree (tp, cp_unsave_r, st);
+
+ /* Clean up. */
+ splay_tree_delete (st);
+}
projects / platform / upstream / linaro-gcc.git / commitdiff