From 46e8c075d018b365ce2a7ebba396ebcf3235c6d5 Mon Sep 17 00:00:00 2001 From: Mark Mitchell Date: Thu, 25 Nov 1999 20:32:04 +0000 Subject: [PATCH] Make-lang.in (CXX_SRCS): Add optimize.c. 1999-11-25 Mark Mitchell * 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. From-SVN: r30669 --- gcc/cp/ChangeLog | 70 +++++++ gcc/cp/Make-lang.in | 2 +- gcc/cp/Makefile.in | 104 ++++----- gcc/cp/class.c | 1 - gcc/cp/cp-tree.def | 8 +- gcc/cp/cp-tree.h | 27 ++- gcc/cp/decl.c | 94 +++++---- gcc/cp/decl2.c | 6 +- gcc/cp/dump.c | 1 - gcc/cp/except.c | 13 +- gcc/cp/init.c | 2 +- gcc/cp/ir.texi | 12 +- gcc/cp/lex.c | 6 +- gcc/cp/optimize.c | 497 ++++++++++++++++++++++++++++++++++++++++++++ gcc/cp/semantics.c | 58 +++++- gcc/cp/tree.c | 222 +++++++++++++++++--- 16 files changed, 966 insertions(+), 157 deletions(-) create mode 100644 gcc/cp/optimize.c diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index f089e4fffe8..c020d438e6f 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,73 @@ +1999-11-25 Mark Mitchell + + * 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 * search.c (note_debug_info_needed): Do perform this optimization diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in index 3051d910413..ffb1b0c6ab6 100644 --- a/gcc/cp/Make-lang.in +++ b/gcc/cp/Make-lang.in @@ -118,7 +118,7 @@ CXX_SRCS = $(srcdir)/cp/call.c $(srcdir)/cp/decl2.c \ $(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 \ diff --git a/gcc/cp/Makefile.in b/gcc/cp/Makefile.in index 897697d0b65..900823c8e7f 100644 --- a/gcc/cp/Makefile.in +++ b/gcc/cp/Makefile.in @@ -175,7 +175,7 @@ INCLUDES = -I. -I.. -I$(srcdir) -I$(srcdir)/.. -I$(srcdir)/../config -I$(srcdir) 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 @@ -202,12 +202,14 @@ RTL_H = $(srcdir)/../rtl.h $(srcdir)/../rtl.def \ 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) \ @@ -239,64 +241,66 @@ $(srcdir)/hash.h: $(srcdir)/gxx.gperf 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 -errfn.o : errfn.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.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 -repo.o : repo.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../system.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 $(CXX_TREE_H) \ + $(srcdir)/../toplev.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 # # These exist for maintenance purposes. diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 19bd69cf089..a916123ed9b 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -30,7 +30,6 @@ Boston, MA 02111-1307, USA. */ #include "rtl.h" #include "output.h" #include "toplev.h" -#include "splay-tree.h" #include "ggc.h" #include "lex.h" diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def index 59b14fd298a..6ccc8745ed9 100644 --- a/gcc/cp/cp-tree.def +++ b/gcc/cp/cp-tree.def @@ -237,9 +237,11 @@ DEFTREECODE (ASM_STMT, "asm_stmt", 'e', 5) 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. */ diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index a83744e2876..3b1f402d525 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -21,6 +21,7 @@ Boston, MA 02111-1307, USA. */ #include "c-common.h" #include "function.h" +#include "splay-tree.h" #include "varray.h" #ifndef _CP_TREE_H @@ -40,6 +41,7 @@ Boston, MA 02111-1307, USA. */ 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. @@ -2121,6 +2123,10 @@ extern int flag_new_for_scope; #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) @@ -2691,6 +2697,14 @@ extern int flag_new_for_scope; #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))) @@ -3107,6 +3121,11 @@ extern int flag_new_abi; 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; @@ -3532,6 +3551,8 @@ extern tree maybe_push_decl PROTO((tree)); 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)); @@ -3744,6 +3765,9 @@ extern void emit_thunk PROTO((tree)); 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)); @@ -3960,7 +3984,6 @@ extern tree arbitrate_lookup PROTO((tree, tree, 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)); @@ -4028,9 +4051,11 @@ extern tree maybe_dummy_object PROTO((tree, 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) diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index f24bb3f011f..0edcc258c6b 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -141,7 +141,7 @@ static boolean typename_compare PROTO((hash_table_key, hash_table_key)); 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)); @@ -7362,26 +7362,10 @@ make_rtl_for_local_static (decl) 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)) { @@ -7543,9 +7527,8 @@ emit_local_var (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 @@ -11141,27 +11124,48 @@ require_complete_types_for_parms (parms) } } -/* 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 @@ -11230,7 +11234,7 @@ check_default_argument (decl, arg) 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'", @@ -13067,9 +13071,15 @@ start_function (declspecs, declarator, attrs, flags) 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; } @@ -13295,10 +13305,8 @@ finish_constructor_body () /* 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 diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 617d85426f5..7759b0a0e3f 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -42,7 +42,6 @@ Boston, MA 02111-1307, USA. */ #include "toplev.h" #include "dwarf2out.h" #include "dwarfout.h" -#include "splay-tree.h" #include "ggc.h" #if USE_CPPLIB @@ -444,6 +443,11 @@ int flag_new_abi; 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. */ diff --git a/gcc/cp/dump.c b/gcc/cp/dump.c index ef92f182964..6e3fbcceab7 100644 --- a/gcc/cp/dump.c +++ b/gcc/cp/dump.c @@ -23,7 +23,6 @@ Boston, MA 02111-1307, USA. */ #include "system.h" #include "tree.h" #include "cp-tree.h" -#include "splay-tree.h" /* Flags used with queue functions. */ #define DUMP_NONE 0 diff --git a/gcc/cp/except.c b/gcc/cp/except.c index eb8cf0e7c63..62cae27bf59 100644 --- a/gcc/cp/except.c +++ b/gcc/cp/except.c @@ -564,7 +564,7 @@ expand_end_catch_block (blocks) /* 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); } @@ -615,6 +615,7 @@ expand_end_eh_spec (raises, try_block) 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); @@ -804,12 +805,10 @@ expand_throw (exp) 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 diff --git a/gcc/cp/init.c b/gcc/cp/init.c index da586e9bc60..1361b9686ee 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -2470,7 +2470,7 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, use_global_delete) /* 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, diff --git a/gcc/cp/ir.texi b/gcc/cp/ir.texi index 09ae98d53fa..b2e6a497270 100644 --- a/gcc/cp/ir.texi +++ b/gcc/cp/ir.texi @@ -1274,9 +1274,11 @@ following the @code{TREE_CHAIN} link from one substatement to the next. 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 @@ -1387,9 +1389,9 @@ equalit) to @code{CATCH_ALL_TYPE} if this handler is for all types. 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 diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index b7fc18fb819..ae2783f4c1b 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -405,7 +405,7 @@ my_get_run_time () #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE, -char cplus_tree_code_type[] = { +static char cplus_tree_code_type[] = { 'x', #include "cp-tree.def" }; @@ -417,7 +417,7 @@ char cplus_tree_code_type[] = { #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH, -int cplus_tree_code_length[] = { +static int cplus_tree_code_length[] = { 0, #include "cp-tree.def" }; @@ -427,7 +427,7 @@ int cplus_tree_code_length[] = { 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" }; diff --git a/gcc/cp/optimize.c b/gcc/cp/optimize.c new file mode 100644 index 00000000000..d81f5448f1f --- /dev/null +++ b/gcc/cp/optimize.c @@ -0,0 +1,497 @@ +/* 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); + } +} diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 7a030e696a2..2d70cb9044e 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -658,7 +658,16 @@ finish_goto_stmt (destination) 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); @@ -1183,7 +1192,17 @@ setup_vtbl_ptr () (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) @@ -1592,6 +1611,9 @@ finish_label_address_expr (label) 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; @@ -2268,11 +2290,6 @@ expand_stmt (t) 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; @@ -2309,6 +2326,16 @@ expand_stmt (t) 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; @@ -2508,6 +2535,9 @@ expand_body (fn) 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. */ @@ -2538,9 +2568,17 @@ expand_body (fn) /* 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. */ diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 15f66daf527..93893b3a048 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -28,7 +28,8 @@ Boston, MA 02111-1307, USA. */ #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 *)); @@ -42,7 +43,10 @@ static cp_lvalue_kind lvalue_p_1 PROTO((tree, int)); 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)) @@ -259,6 +263,7 @@ build_cplus_new (type, init) 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. @@ -1456,6 +1461,45 @@ is_aggr_type_2 (t1, t2) 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; + } +} #define PRINT_RING_SIZE 4 @@ -1594,7 +1638,8 @@ walk_tree (tp, func, data) /* 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; @@ -1602,6 +1647,11 @@ walk_tree (tp, func, data) 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; } @@ -1706,7 +1756,7 @@ walk_tree (tp, func, data) if (TYPE_PTRMEMFUNC_P (*tp)) WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp)); break; - + default: my_friendly_abort (19990803); } @@ -1755,10 +1805,10 @@ no_linkage_check (t) /* 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); @@ -1767,6 +1817,7 @@ copy_tree_r (tp, walk_subtrees, data) 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 @@ -1781,12 +1832,21 @@ copy_tree_r (tp, walk_subtrees, data) /* 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; } @@ -2605,41 +2665,143 @@ void 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); } - else - return; + /* 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 + { + 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); +}