+Mon Dec 18 15:51:33 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * cp-tree.h, decl2.c (flag_weak): New flag to control the use of
+ weak symbols.
+ * lang-options.h: Add -f{no-,}weak.
+ * decl.c (init_decl_processing): If the target does not support weak
+ symbols, don't use them.
+ * decl2.c, pt.c: s/SUPPORTS_WEAK/flag_weak/.
+
+Sun Dec 17 21:13:23 1995 Rusty Russell <rusty@adelaide.maptek.com.au>
+
+ * init.c (expand_member_init): warning for base init after members.
+
+Sun Dec 17 22:06:56 1995 Jeffrey A Law (law@cygnus.com)
+
+ * tree.c (tree_copy_lang_decl_for_deferred_output): Handle
+ CONST_DECLs correctly.
+
+Fri Dec 15 15:32:18 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * cvt.c (build_expr_type_conversion): Don't convert to a reference
+ type.
+
+Thu Dec 14 16:05:58 1995 Mike Stump <mrs@cygnus.com>
+
+ * method.c (report_type_mismatch): Improve wording for volatile
+ mismatches.
+
+Thu Dec 14 14:16:26 1995 Mike Stump <mrs@cygnus.com>
+
+ * init.c (expand_aggr_init_1): Use expand_aggr_init_1 instead of
+ expand_assignment, as the later doesn't handle things that have
+ copy constructors well. The compiler would do bitwise copying,
+ instead of ctor calling in some cases.
+
+Wed Dec 13 17:05:54 PST 1995 Paul Eggert <eggert@twinsun.com>
+
+ * g++.c (my_strerror): Return "cannot access" if errno is 0.
+ (pfatal_with_name, perror_exec): Don't assume that
+ the returned value from my_strerror contains no '%'s.
+ (concat): Remove.
+ (sys_nerror): Declare only if HAVE_STRERROR is not defined.
+
+Wed Dec 13 16:22:38 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ Lose CLASSTYPE_METHODS/DECL_NEXT_METHOD chain; make
+ TYPE_METHODS/TREE_CHAIN mean what they used to.
+ * decl2.c (constructor_name_full): Refer to CLASSTYPE_METHOD_VEC
+ instead of TYPE_METHODS.
+ * decl.c (duplicate_decls): Lose references to DECL_NEXT_METHOD.
+ * tree.c (tree_copy_lang_decl_for_deferred_output): Ditto.
+ * cp-tree.h (CLASSTYPE_METHODS): Lose.
+ (CLASSTYPE_METHOD_VEC): Point to lang_spec->methods instead of
+ TYPE_METHODS.
+ (struct lang_decl): Lose next_method field.
+ (DECL_NEXT_METHOD): Lose.
+ * class.c (finish_struct_methods): Don't mess with TYPE_METHODS.
+ (finish_struct): Just use TYPE_METHODS; we don't need fn_fields
+ anymore.
+ (finish_struct_methods): Don't mess with the TREE_CHAINs in
+ fn_fields.
+
+ * search.c (add_conversions): Don't use TREE_CHAIN to traverse method
+ vector.
+
+ * call.c (build_method_call): Synthesize here even when not inlining.
+ * typeck.c (build_function_call_real): Ditto.
+
+Wed Dec 13 15:02:39 1995 Ian Lance Taylor <ian@cygnus.com>
+
+ * cp/lex.c (check_newline): If DBX_DEBUGGING_INFO and write_symbols
+ == DBX_DEBUG, call dbxout_start_new_source_file and
+ dbxout_resume_previous_source_file when appropriate.
+
+Tue Dec 12 20:38:55 1995 Mike Stump <mrs@cygnus.com>
+
+ * except.c (start_anon_func): Push to the top level.
+ (end_anon_func): Pop from the top level.
+
+Mon Dec 11 18:56:14 1995 Mike Stump <mrs@cygnus.com>
+
+ * cp-tree.h (build_cleanup): New routine to build cleanups.
+ * decl.c (expand_static_init): Use build_cleanup to build a cleanup
+ call at ctor time and use atexit to run it later.
+ * decl2.c (build_cleanup): New routine, taken from finish_file.
+ (finish_file): Use build_cleanup instead, and don't put function
+ local statics in global dtor list.
+
+Wed Dec 6 14:34:29 1995 Mike Stump <mrs@cygnus.com>
+
+ * except.c (expand_throw): Ensure that we have cleanups, if we try
+ and expand cleanups.
+
+Wed Dec 6 11:48:21 1995 Mike Stump <mrs@cygnus.com>
+
+ * except.c (expand_throw): Add logic to manage dynamic cleanups for
+ the EH object.
+ (expand_end_catch_block): Use the magic of expand_goto, instead of
+ emit_jump so that we get the cleanup for any catch clause parameter
+ and the cleanup for the exception object. Update to reflect label
+ changes.
+ (push_eh_cleanup): New routine to register a cleanup for an
+ exception object.
+ (empty_fndecl): Used to default cleanup actions to
+ nothing.
+ (init_exception_processing): Setup empty_fndecl. Setup
+ saved_cleanup.
+ (expand_start_catch_block): Update to reflect label changes. Call
+ push_eh_object to register the cleanup for the EH object.
+ (start_anon_func): New routine to start building lambda expressions
+ from trees.
+ (end_anon_func): New routine to end them.
+ (struct labelNode): Change so that we can use tree labels, or rtx
+ labels.
+ (saved_cleanup): Object to check for dynamic cleanups for the
+ exception handling object.
+ (push_label_entry): Change so that we can use tree labels, or rtx
+ labels.
+ (pop_label_entry): Ditto.
+ (top_label_entry): Ditto.
+ (expand_start_all_catch): Use tree label instead of rtx label, so
+ that we can get the magic of expand_goto.
+ (expand_end_all_catch): Update to reflect label changes.
+
+ * class.c (build_vfn_ref): Remove building_cleanup logic, as we now
+ use UNSAVE_EXPRs.
+ typeck.c (get_member_function_from_ptrfunc): Remove remnants of
+ building_cleanup logic, as we now use UNSAVE_EXPRs.
+ * cp-tree.h (unsave_expr): Declare it.
+ * decl.c (building_cleanup): Remove.
+ (maybe_build_cleanup): Remove building_cleanup logic, and use
+ UNSAVE_EXPR instead.
+
+Sun Dec 3 01:34:58 1995 Mike Stump <mrs@cygnus.com>
+
+ * gc.c (build_t_desc): Update error message to say <typeinfo>.
+
+Thu Nov 30 12:30:05 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * decl.c (pushdecl): Only warn about shadowing a local variable if
+ warn_shadow is true.
+
+Sun Nov 26 16:06:55 1995 Rusty Russell <rusty@adelaide.maptek.com.au>
+
+ * typeck.c (build_binary_op_nodefault): Added warning about
+ comparisons between different enum types with -Wall, unless
+ -fenum-int-equiv set.
+
+Wed Nov 22 15:44:02 1995 Mike Stump <mrs@cygnus.com>
+
+ * class.c (finish_struct_1): Skip down to the inner type in
+ multidimensional arrays. Ensures ctors will be made for types that
+ need constructing.
+
+Wed Nov 22 14:19:22 1995 Mike Stump <mrs@cygnus.com>
+
+ * decl.c (last_dtor_insn): New to track the last compiler generated
+ insn in a dtor.
+ (store_parm_decls): Set it.
+ (finish_function): Use it to see if the dtor is empty. Avoid doing
+ vtable setup all the time, if we can.
+ (struct cp_function): Add last_dtor_insn.
+ (push_cp_function_context): Save it.
+ (pop_cp_function_context): Restore it.
+
+Wed Nov 22 11:52:19 1995 Paul Russell <Rusty.Russell@adelaide.maptek.com.au>
+
+ * typeck.c (build_unary_op): Set TREE_NO_UNUSED_WARNING to avoid
+ warnings.
+
+Tue Nov 21 17:15:23 1995 Mike Stump <mrs@cygnus.com>
+
+ * typeck.c (expand_target_expr): Make sure targets get put into the
+ current temp_slot_level, so that the free_temp_slots call will reuse
+ them.
+
+Tue Nov 21 13:32:03 1995 Mike Stump <mrs@cygnus.com>
+
+ * class.c (finish_struct_1): Delay delta fixups for virtual bases
+ until after we have done the hard virtuals, to avoid a bogus `every
+ virtual function must have a unique final overrider' for virtual
+ functions that are only overridden by hard virtuals.
+
+Thu Nov 9 13:35:30 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * pt.c (do_function_instantiation): Don't try to find a file-scope
+ template for a member function.
+
+Tue Nov 14 06:20:35 1995 Mike Stump <mrs@cygnus.com>
+
+ * g++.c (main): Add handling of -nodefaultlibs.
+
+Mon Nov 13 15:45:34 1995 Mike Stump <mrs@cygnus.com>
+
+ * cp-tree.h (INDIRECT_BIND): Add a way for the frontend to
+ distinguish between direct bindings of reference variables, and
+ indirect bindings of reference variables.
+ * cvt.c (build_up_reference): Use it.
+ * typeck.c (convert_arguments): Use it to indicate this is an
+ indirect binding.
+ * decl.c (cp_finish_decl): Ensure that we reuse stack slots as fast
+ as they are unused.
+ (expand_static_init): Diotto.
+ (cplus_expand_expr_stmt): Ditto.
+ * decl2.c (finish_file): Ditto.
+ * init.c (perform_member_init): Ditto.
+ (emit_base_init): Ditto.
+ (expand_aggr_vbase_init_1): Ditto.
+
+Fri Nov 10 09:19:31 1995 Jeffrey A Law (law@cygnus.com)
+
+ * tree.c (tree_copy_lang_decl_for_deferred_output): Handle
+ copying of DECL_ARGUMENTS field.
+ (tree_copy_lang_type_for_deferred_output): Handle disgusting
+ re-use of TYPE_LANG_SPECIFIC for pointer to member function
+ type nodes.
+
+Fri Nov 10 09:18:09 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * decl.c (push_namespace): Rewrite to use build_lang_decl, so we
+ get a DECL_LANG_SPECIFIC node.
+ * cp-tree.h (lang_decl_flags): Add new member `level'.
+ (NAMESPACE_LEVEL): Don't use decl.arguments, instead use the
+ decl_flags level member.
+
+Mon Nov 6 18:36:13 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * call.c (build_method_call): Make sure instance has a
+ TYPE_LANG_SPECIFIC node before we dive into it.
+
+Sat Nov 4 20:01:52 1995 Jason Molenda (crash@phydeaux.cygnus.com)
+
+ * method.c (make_thunk): use TREE_SET_CODE to set thunk's tree code.
+
+Thu Nov 2 17:56:57 1995 Mike Stump <mrs@cygnus.com>
+
+ * decl.c (duplicate_decls): When smashing decls, smash staticness in
+ the usual way.
+
+Thu Nov 2 16:44:02 1995 Mike Stump <mrs@cygnus.com>
+
+ * decl.c (poplevel): Handle the merging of subblocks of cleanups
+ when finishing blocks that have already been created (usually due to
+ the fixup goto code). Fixes bad debugging information.
+
+Wed Nov 1 12:33:53 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * method.c (hack_identifier): Don't abort when we get a TREE_LIST
+ that's not a list of overloaded functions.
+
+Wed Nov 1 11:38:58 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * decl2.c (mark_vtable_entries): Check DECL_LANG_SPECIFIC on fn
+ before trying to use DECL_ABSTRACT_VIRTUAL_P.
+
+Tue Oct 31 11:56:55 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl2.c (mark_used): New function for hooking into setting of
+ TREE_USED on decls.
+ * call.c (build_method_call): Use it.
+ * class.c (instantiate_type): Ditto.
+ * init.c (build_offset_ref): Ditto. Don't call assemble_external
+ for all like-named functions.
+ * method.c (hack_identifier): Ditto.
+ (emit_thunk): Don't call assemble_external.
+ (make_thunk): Create thunk as a FUNCTION_DECL so that it
+ gets the right mode and ENCODE_SECTION_INFO works.
+
+ * parse.y: Use mark_used. Pass operator names to do_identifier.
+ * lex.c (do_identifier): Handle operator names.
+
+ * decl2.c (grokclassfn): Tweak __in_chrg attributes.
+
+Thu Oct 26 20:58:59 1995 Jeffrey A Law (law@cygnus.com)
+
+ * cp/tree.c (tree_copy_lang_decl_for_deferred_output): Handle
+ FIELD_DECLs and VAR_DECLs correctly.
+
+Thu Oct 26 16:45:58 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * errfn.c: Include stdio.h.
+ (cp_sprintf): Take out decl of sprintf, and cast sprintf to errorfn*.
+
+Wed Oct 25 18:58:41 1995 Mike Stump <mrs@cygnus.com>
+
+ * typeck2.c (digest_init): Always convert initializers to the
+ right type.
+
+Wed Oct 25 13:25:24 1995 Mike Stump <mrs@cygnus.com>
+
+ * init.c (member_init_ok_or_else): Don't allow member initializers
+ for indirect members, as it is invalid.
+
+Wed Oct 25 11:35:28 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * decl.c (grokdeclarator): Don't allow `friend signed ()'.
+
+Fri Oct 20 10:30:59 1995 Mike Stump <mrs@cygnus.com>
+
+ * parse.y (for.init.statement): Catch compound statements inside for
+ initializations, if we're being pedantic.
+
+Fri Oct 20 10:03:42 1995 Mike Stump <mrs@cygnus.com>
+
+ * decl.c (lookup_tag): Return NULL_TREE if we don't find what we are
+ looking for.
+
+Thu Oct 19 14:26:10 1995 Mike Stump <mrs@cygnus.com>
+
+ * error.c (dump_expr): Don't core dump when a boolean expression is
+ used as a default argument.
+
+Thu Oct 19 10:36:30 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * class.c (finish_struct_bits): Check aggregate_value_p instead of
+ RETURN_IN_MEMORY.
+
+Wed Oct 18 18:12:32 1995 Jason Merrill <jason@yorick.cygnus.com>
+
+ * class.c (finish_struct_bits): Also set TREE_ADDRESSABLE on a
+ BLKmode type that would otherwise be returned in registers.
+
+Mon Oct 16 12:32:19 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * g++.c (WITHLIBC): New macro.
+ (main): Declare saw_libc. Use WITHLIBC if `-lc' was used; set
+ saw_libc and pass it at the end if it was set.
+
+Wed Oct 11 16:30:34 1995 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * parse.y (fn.def1): Call split_specs_attrs in
+ declmods notype_declarator case.
+
Mon Nov 20 14:06:28 1995 Mike Stump <mrs@cygnus.com>
* Version 2.7.2 released.
* typeck.c (comptypes, case OFFSET_REF): If either offset basetype
is a TEMPLATE_TYPE_PARM, give a match.
-Mon Jul 3 15:17:20 1995 Steve Chamberlain <sac@slash.cygnus.com>
-
- * g++.c (sys/file.h): Remove change of Jun 28.
-
Fri Jun 30 15:42:57 1995 Mike Stump <mrs@cygnus.com>
* method.c (build_overload_value): Handle encoding of null pointer
* decl.c (revert_static_member_fn): But only if DECL_ARGUMENTS is
set.
-Wed Jun 28 23:34:58 1995 Steve Chamberlain <sac@slash.cygnus.com>
-
- * g++.c (pfatal_with_name): Use my_strerror to get error
- string.
- (sys/file.h): Include if HAVE_FILE_H defined.
-
Wed Jun 28 18:39:03 1995 Jason Merrill <jason@phydeaux.cygnus.com>
* decl.c (revert_static_member_fn): Also remove 'this' from
* decl.c (get_unique_name): New routine to name unnamed namespaces.
(push_namespace): Use get_unique_name for naming unnamed namespaces.
-Fri Jun 16 15:07:29 1995 Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
-
- * Make-lang.in (DEMANGLER_PROG): Add LIBS.
-
Thu Jun 15 15:00:41 1995 Jason Merrill <jason@phydeaux.cygnus.com>
- * decl.c (define_function): Don't set DECL_INTERFACE_KNOWN.
-
* parse.y: Call cplus_decl_attributes with prefix_attributes where
appropriate.
* gc.c (build_dynamic_cast): Build up a reference to a parameter of
aggregate type.
-Wed Jun 7 20:00:31 1995 Mike Stump <mrs@cygnus.com>
-
- * *.[chy]: Change all callers of finish_decl to cp_finish_decl.
- * decl.c (finish_decl): New routine to handle call backs from the
- mid end (declare_hidden_char_array).
-
-Wed Jun 7 19:02:50 1995 Jason Merrill <jason@phydeaux.cygnus.com>
-
- * decl.c (start_function): Handle setting C_C_D here.
- (set_C_C_D): Removed.
- (struct saved_scope): Remove class_decl.
- (push_to_top_level): Don't save current_class_decl.
- (pop_from_top_level): Don't restore current_class_decl or C_C_D.
- (struct cp_function): Add C_C_D.
- (push_cp_function_context): Save C_C_D.
- (pop_cp_function_context): Restore C_C_D.
-
Wed Jun 7 15:31:57 1995 Brendan Kehoe (brendan@lisa.cygnus.com)
* init.c (build_vec_delete): Resolve an offset ref before we try to
to tag and delta, respectively.
(build_signature_method_call): Ditto. Use above variables.
-Fri Jun 2 11:05:58 1995 Jason Merrill <jason@phydeaux.cygnus.com>
-
- * decl.c (set_C_C_D): New function. suspend_momentary before
- building C_C_D.
- (pop_from_top_level): Call it.
- (start_function): Ditto.
- (pop_cp_function_context): Ditto.
-
- * class.c, cp-tree.h, decl.c, decl2.c, parse.y: Lose all references
- to current_vtable_decl, CLASSTYPE_INST_VAR and CLASSTYPE_VTBL_PTR.
-
- * decl.c (push_cp_function_context): Save current_class_decl.
- (pop_cp_function_context): Restore current_class_decl and set C_C_D.
- (pop_from_top_level): Don't use CLASSTYPE_INST_VAR to set C_C_D.
- (start_function): Ditto.
-
- * class.c (popclass): Don't mess with current_class_decl,
- current_vtable_decl, or C_C_D.
-
-Mon May 29 12:45:10 1995 Paul Eggert <eggert@twinsun.com>
-
- * Make-lang.in (c++.mostlyclean): Remove $(DEMANGLER_PROG).
-
Thu Jun 1 17:03:51 1995 Jason Merrill <jason@phydeaux.cygnus.com>
* decl.c (lookup_name_real): Don't try to look anything up in an
reference type.
(build_indirect_ref): Fix check for *&.
+Fri Jun 16 06:54:03 1995 Mike Stump <mrs@cygnus.com>
+
+ * Version 2.7.0 released.
+
+Fri Jun 16 15:07:29 1995 Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
+
+ * Make-lang.in (DEMANGLER_PROG): Add LIBS.
+
+Thu Jun 15 15:00:41 1995 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * decl.c (define_function): Don't set DECL_INTERFACE_KNOWN.
+
+Wed Jun 7 20:00:31 1995 Mike Stump <mrs@cygnus.com>
+
+ * *.[chy]: Change all callers of finish_decl to cp_finish_decl.
+ * decl.c (finish_decl): New routine to handle call backs from the
+ mid end (declare_hidden_char_array).
+
+Wed Jun 7 19:02:50 1995 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * decl.c (start_function): Handle setting C_C_D here.
+ (set_C_C_D): Removed.
+ (struct saved_scope): Remove class_decl.
+ (push_to_top_level): Don't save current_class_decl.
+ (pop_from_top_level): Don't restore current_class_decl or C_C_D.
+ (struct cp_function): Add C_C_D.
+ (push_cp_function_context): Save C_C_D.
+ (pop_cp_function_context): Restore C_C_D.
+
+Fri Jun 2 11:05:58 1995 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * decl.c (set_C_C_D): New function. suspend_momentary before
+ building C_C_D.
+ (pop_from_top_level): Call it.
+ (start_function): Ditto.
+ (pop_cp_function_context): Ditto.
+
+ * class.c, cp-tree.h, decl.c, decl2.c, parse.y: Lose all references
+ to current_vtable_decl, CLASSTYPE_INST_VAR and CLASSTYPE_VTBL_PTR.
+
+ * decl.c (push_cp_function_context): Save current_class_decl.
+ (pop_cp_function_context): Restore current_class_decl and set C_C_D.
+ (pop_from_top_level): Don't use CLASSTYPE_INST_VAR to set C_C_D.
+ (start_function): Ditto.
+
+ * class.c (popclass): Don't mess with current_class_decl,
+ current_vtable_decl, or C_C_D.
+
+Mon May 29 12:45:10 1995 Paul Eggert <eggert@twinsun.com>
+
+ * Make-lang.in (c++.mostlyclean): Remove $(DEMANGLER_PROG).
+
Wed May 24 15:55:18 1995 Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
* decl.c (duplicate_decls): Check simple_cst_equal result against 0.
(pushdecl): Set the nested typename if the decl doesn't have one,
rather than if the type's canonical decl doesn't have one.
-Mon Jan 9 16:48:16 1995 Steve Chamberlain (sac@jonny.cygnus.com)
-
- * typeck.c (pointer_int_sum): Use offset size when calculating
- index expression.
-
Mon Jan 9 03:44:33 1995 Jason Merrill <jason@phydeaux.cygnus.com>
* typeck.c (convert_for_assignment): Complain about contravariance
(c++.install-man): Use program_transform_name on g++.1.
(c++.uninstall): Likewise.
-Thu Nov 3 18:48:19 1994 Paul Eggert <eggert@twinsun.com>
-
- * Makefile.in (spew.o, lex.o, pt.o):
- Depend on $(srcdir)/parse.h, not parse.h.
-
Mon Nov 28 13:53:03 1994 Mike Stump <mrs@cygnus.com>
* parse.y (THROW): Fix precedence of throw expressions.
to add support for explicit, namespace, typename, and using, support
for the rest is already in.
-Thu Nov 17 10:56:50 1994 Jason Merrill <jason@phydeaux.cygnus.com>
-
- * typeck2.c (build_m_component_ref): Check the basetype of the
- member pointer against the main variant of the object type.
-
-Mon Nov 14 14:21:52 1994 Jason Merrill <jason@phydeaux.cygnus.com>
-
- * cvt.c (convert_to_reference): Make sure that the original expr
- gets its type back when converting a reference.
-
- * method.c (build_overload_name): Clear numeric_outputed_need_bar here.
- (build_decl_overload): Instead of here.
-
-Tue Nov 8 17:11:24 1994 Jason Merrill <jason@phydeaux.cygnus.com>
-
- * cvt.c (cp_convert): Don't build a TARGET_EXPR if we're not in a
- function.
-
- * typeck.c (convert_for_initialization): Handle initialization from
- a TARGET_EXPR.
-
-Sun Nov 6 01:34:24 1994 Jason Merrill (jason@phydeaux.cygnus.com)
-
- * pt.c (lookup_nested_type_by_name): Fix list-walking logic.
- (tsubst): When replacing a TEMPLATE_TYPE_PARM, propagate
- TYPE_READONLY and TYPE_VOLATILE from the argument.
- (unify): When unifying with a TEMPLATE_TYPE_PARM, remove cv-quals
- present in parm from arg.
- (type_unification): Strip REFERENCE_TYPE from the argument type.
- (unify): Don't strip REFERENCE_TYPE from the argument type.
-
-Sat Nov 5 22:42:15 1994 Greg McGary (gkm@magilla.cichlid.com)
-
- * pt.c (do_type_instantiation): Check to see if there's a
- IDENTIFIER_TEMPLATE on a class before calling
- instantiate_member_templates().
-
Fri Nov 4 19:04:18 1994 Mike Stump <mrs@cygnus.com>
* gc.c (get_bad_cast_node): New routine to support compile time
* call.c (convert_harshness): Check for TREE_UNSIGNED differences
after checking for integral conversions.
+Wed Nov 30 19:13:50 1994 Mike Stump <mrs@cygnus.com>
+
+ * Version 2.6.3 released.
+
+Thu Nov 17 10:56:50 1994 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * typeck2.c (build_m_component_ref): Check the basetype of the
+ member pointer against the main variant of the object type.
+
+Mon Nov 14 14:21:52 1994 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * cvt.c (convert_to_reference): Make sure that the original expr
+ gets its type back when converting a reference.
+
+ * method.c (build_overload_name): Clear numeric_outputed_need_bar here.
+ (build_decl_overload): Instead of here.
+
+Tue Nov 8 17:11:24 1994 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * cvt.c (cp_convert): Don't build a TARGET_EXPR if we're not in a
+ function.
+
+ * typeck.c (convert_for_initialization): Handle initialization from
+ a TARGET_EXPR.
+
+Sun Nov 6 01:34:24 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * pt.c (lookup_nested_type_by_name): Fix list-walking logic.
+ (tsubst): When replacing a TEMPLATE_TYPE_PARM, propagate
+ TYPE_READONLY and TYPE_VOLATILE from the argument.
+ (unify): When unifying with a TEMPLATE_TYPE_PARM, remove cv-quals
+ present in parm from arg.
+ (type_unification): Strip REFERENCE_TYPE from the argument type.
+ (unify): Don't strip REFERENCE_TYPE from the argument type.
+
+Sat Nov 5 22:42:15 1994 Greg McGary (gkm@magilla.cichlid.com)
+
+ * pt.c (do_type_instantiation): Check to see if there's a
+ IDENTIFIER_TEMPLATE on a class before calling
+ instantiate_member_templates().
+
+Sat Nov 12 06:35:42 1994 Mike Stump <mrs@cygnus.com>
+
+ * Version 2.6.2 released.
+
+Thu Nov 3 18:48:19 1994 Paul Eggert <eggert@twinsun.com>
+
+ * Makefile.in (spew.o, lex.o, pt.o):
+ Depend on $(srcdir)/parse.h, not parse.h.
+
+Tue Nov 1 19:19:41 1994 Mike Stump <mrs@cygnus.com>
+
+ * Version 2.6.1 released.
+
Sun Oct 23 13:19:55 1994 Jason Merrill (jason@phydeaux.cygnus.com)
* decl2.c: Declare flag_access_control.
* call.c (build_method_call): Accept using a typedef name (or
template type parameter) for explicit destructor calls.
+Thu Jul 14 09:42:23 1994 Mike Stump <mrs@cygnus.com>
+
+ * Version 2.6.0 released.
+
Wed Jul 13 03:57:54 1994 Jason Merrill (jason@deneb.cygnus.com)
* method.c (hack_identifier): Put back old code so lists of
}
/* We already know whether it's needed or not for vec delete. */
else if (name == ansi_opname[(int) VEC_DELETE_EXPR]
+ && TYPE_LANG_SPECIFIC (TREE_TYPE (instance))
&& ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance)))
TREE_CHAIN (parms) = NULL_TREE;
return build_signature_method_call (basetype, instance, function, parms);
function = DECL_MAIN_VARIANT (function);
- /* Declare external function if necessary. */
- assemble_external (function);
+ mark_used (function);
-#if 1
/* Is it a synthesized method that needs to be synthesized? */
- if (DECL_ARTIFICIAL (function) && ! flag_no_inline
- && ! DECL_INITIAL (function)
+ if (DECL_ARTIFICIAL (function) && ! DECL_INITIAL (function)
/* Kludge: don't synthesize for default args. */
&& current_function_decl)
synthesize_method (function);
-#endif
if (pedantic && DECL_THIS_INLINE (function) && ! DECL_ARTIFICIAL (function)
&& ! DECL_INITIAL (function) && ! DECL_PENDING_INLINE_INFO (function))
if (TREE_CODE (function) == FUNCTION_DECL)
{
is_constructor = DECL_CONSTRUCTOR_P (function);
- TREE_USED (function) = 1;
function = default_conversion (function);
}
else
tree *ptr_to_instptr, instance;
tree idx;
{
- extern int building_cleanup;
tree vtbl, aref;
tree basetype = TREE_TYPE (instance);
/* Save the intermediate result in a SAVE_EXPR so we don't have to
compute each component of the virtual function pointer twice. */
- if (!building_cleanup && TREE_CODE (aref) == INDIRECT_REF)
+ if (TREE_CODE (aref) == INDIRECT_REF)
TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
if (flag_vtable_thunks)
/* If this type has a copy constructor, force its mode to be BLKmode, and
force its TREE_ADDRESSABLE bit to be nonzero. This will cause it to
be passed by invisible reference and prevent it from being returned in
- a register. */
- if (! TYPE_HAS_TRIVIAL_INIT_REF (t))
+ a register.
+
+ Also do this if the class has BLKmode but can still be returned in
+ registers, since function_cannot_inline_p won't let us inline
+ functions returning such a type. This affects the HP-PA. */
+ if (! TYPE_HAS_TRIVIAL_INIT_REF (t)
+ || (TYPE_MODE (t) == BLKmode && ! aggregate_value_p (t)
+ && CLASSTYPE_NON_AGGREGATE (t)))
{
tree variants;
if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
us to reduce search time in places like `build_method_call' to
consider only reasonably likely functions. */
-static tree
+tree
finish_struct_methods (t, fn_fields, nonprivate_method)
tree t;
tree fn_fields;
int nonprivate_method;
{
tree method_vec;
- tree save_fn_fields = tree_cons (NULL_TREE, NULL_TREE, fn_fields);
- tree lastp;
+ tree save_fn_fields = fn_fields;
tree name = constructor_name (t);
int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
/* First fill in entry 0 with the constructors, and the next few with
type conversion operators (if any). */
- for (lastp = save_fn_fields; fn_fields; fn_fields = TREE_CHAIN (lastp))
+ for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
{
tree fn_name = DECL_NAME (fn_fields);
if (fn_name == NULL_TREE)
grow_method (fn_fields, &method_vec);
}
- else
- {
- lastp = fn_fields;
- continue;
- }
-
- TREE_CHAIN (lastp) = TREE_CHAIN (fn_fields);
- TREE_CHAIN (fn_fields) = NULL_TREE;
}
- fn_fields = TREE_CHAIN (save_fn_fields);
- while (fn_fields)
+ fn_fields = save_fn_fields;
+ for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
{
- tree nextp;
tree fn_name = DECL_NAME (fn_fields);
if (fn_name == NULL_TREE)
fn_name = name;
- nextp = TREE_CHAIN (fn_fields);
- TREE_CHAIN (fn_fields) = NULL_TREE;
+ if (fn_name == name || IDENTIFIER_TYPENAME_P (fn_name))
+ continue;
if (fn_name == ansi_opname[(int) MODIFY_EXPR])
{
}
grow_method (fn_fields, &method_vec);
- fn_fields = nextp;
}
TREE_VEC_LENGTH (method_vec) = (tree *)obstack_next_free (&class_obstack)
obstack_free (current_obstack, baselink_vec);
}
+#if 0
/* Now add the methods to the TYPE_METHODS of T, arranged in a chain. */
{
tree x, last_x = NULL_TREE;
}
TYPE_METHODS (t) = method_vec;
+#endif
return method_vec;
}
tree name = TYPE_IDENTIFIER (t);
enum tree_code code = TREE_CODE (t);
tree fields = TYPE_FIELDS (t);
- tree fn_fields = CLASSTYPE_METHODS (t);
+ tree fn_fields = TYPE_METHODS (t);
tree x, last_x, method_vec;
int needs_virtual_dtor;
int all_virtual;
else
all_virtual = 0;
- for (x = CLASSTYPE_METHODS (t); x; x = TREE_CHAIN (x))
+ for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
{
GNU_xref_member (current_class_name, x);
{
tree type = TREE_TYPE (x);
- if (TREE_CODE (type) == ARRAY_TYPE)
+ while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
if (TYPE_LANG_SPECIFIC (type) && ! ANON_UNION_P (x)
}
}
}
-
- /* Now fixup any virtual function entries from virtual bases
- that have different deltas. */
- vbases = CLASSTYPE_VBASECLASSES (t);
- while (vbases)
- {
- /* We might be able to shorten the amount of work we do by
- only doing this for vtables that come from virtual bases
- that have differing offsets, but don't want to miss any
- entries. */
- fixup_vtable_deltas (vbases, 1, t);
- vbases = TREE_CHAIN (vbases);
- }
}
/* Set up the DECL_FIELD_BITPOS of the vfield if we need to, as we
TREE_VALUE (pending_hard_virtuals));
pending_hard_virtuals = TREE_CHAIN (pending_hard_virtuals);
}
+
+ if (TYPE_USES_VIRTUAL_BASECLASSES (t))
+ {
+ tree vbases;
+ /* Now fixup any virtual function entries from virtual bases
+ that have different deltas. This has to come after we do the
+ pending hard virtuals, as we might have a function that comes
+ from multiple virtual base instances that is only overridden
+ by a hard virtual above. */
+ vbases = CLASSTYPE_VBASECLASSES (t);
+ while (vbases)
+ {
+ /* We might be able to shorten the amount of work we do by
+ only doing this for vtables that come from virtual bases
+ that have differing offsets, but don't want to miss any
+ entries. */
+ fixup_vtable_deltas (vbases, 1, t);
+ vbases = TREE_CHAIN (vbases);
+ }
+ }
+
doing_hard_virtuals = 0;
/* Under our model of GC, every C++ class gets its own virtual
tree list_of_fieldlists;
int warn_anon;
{
- tree fields = NULL_TREE, fn_fields, *tail;
- tree *tail_user_methods = &CLASSTYPE_METHODS (t);
+ tree fields = NULL_TREE;
+ tree *tail = &TYPE_METHODS (t);
tree name = TYPE_NAME (t);
tree x, last_x = NULL_TREE;
enum access_type access;
if (IS_SIGNATURE (t))
append_signature_fields (list_of_fieldlists);
- tail = &fn_fields;
if (last_x && list_of_fieldlists)
TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
{
if (last_x)
TREE_CHAIN (last_x) = TREE_CHAIN (x);
- /* Link x onto end of fn_fields and CLASSTYPE_METHODS. */
+ /* Link x onto end of TYPE_METHODS. */
*tail = x;
tail = &TREE_CHAIN (x);
- *tail_user_methods = x;
- tail_user_methods = &DECL_NEXT_METHOD (x);
continue;
}
}
*tail = NULL_TREE;
- *tail_user_methods = NULL_TREE;
TYPE_FIELDS (t) = fields;
if (0 && processing_template_defn)
{
- CLASSTYPE_METHOD_VEC (t) = finish_struct_methods (t, fn_fields, 1);
+ CLASSTYPE_METHOD_VEC (t)
+ = finish_struct_methods (t, TYPE_METHODS (t), 1);
return t;
}
else
return error_mark_node;
return build_vfn_ref (&base_ptr, base, DECL_VINDEX (function));
}
+ mark_used (function);
return function;
}
if (field)
{
TREE_OPERAND (rhs, 1) = field;
+ mark_used (field);
return rhs;
}
if (! comptypes (lhstype, TREE_TYPE (elem), 1))
elem = DECL_CHAIN (elem);
else
- return elem;
+ {
+ mark_used (elem);
+ return elem;
+ }
/* No exact match found, look for a compatible template. */
{
}
return error_mark_node;
}
+ mark_used (save_elem);
return save_elem;
}
if (complain)
elem = TREE_VALUE (baselink);
while (elem)
if (comptypes (lhstype, TREE_TYPE (elem), 1))
- return elem;
+ {
+ mark_used (elem);
+ return elem;
+ }
else
elem = DECL_CHAIN (elem);
}
error ("ambiguous overload for overloaded method requested");
return error_mark_node;
}
+ mark_used (save_elem);
return save_elem;
}
name = DECL_NAME (TREE_VALUE (rhs));
/* The is the VAR_DECL that contains NODE's rtti. */
#define CLASSTYPE_RTTI(NODE) (TYPE_LANG_SPECIFIC(NODE)->rtti)
-/* List of all explicit methods (chained using DECL_NEXT_METHOD),
- in order they were parsed. */
-#define CLASSTYPE_METHODS(NODE) (TYPE_LANG_SPECIFIC(NODE)->methods)
-
/* Nonzero means that this _CLASSTYPE node overloads operator(). */
#define TYPE_OVERLOADS_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_call_overloaded)
#define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TREE_LANG_FLAG_3(NODE))
/* List of lists of member functions defined in this class. */
-#define CLASSTYPE_METHOD_VEC(NODE) TYPE_METHODS(NODE)
+#define CLASSTYPE_METHOD_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->methods)
/* The first type conversion operator in the class (the others can be
searched with TREE_CHAIN), or the first non-constructor function if
#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_NONCOPIED_PARTS (NODE)
/* The binding level associated with the namespace. */
-#define NAMESPACE_LEVEL(NODE) ((NODE)->decl.arguments)
+#define NAMESPACE_LEVEL(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.level)
\f
struct lang_decl_flags
{
tree access;
tree context;
tree memfunc_pointer_to;
+ struct binding_level *level;
};
struct lang_decl
struct template_info *template_info;
tree main_decl_variant;
struct pending_inline *pending_inline_info;
- tree next_method;
tree chain;
};
#define DECL_CHAIN(NODE) (TREE_CHAIN (NODE))
#endif
-/* Next method in CLASSTYPE_METHODS list. */
-#define DECL_NEXT_METHOD(NODE) (DECL_LANG_SPECIFIC(NODE)->next_method)
-
/* In a VAR_DECL for a variable declared in a for statement,
this is the shadowed variable. */
#define DECL_SHADOWED_FOR_VAR(NODE) DECL_RESULT(NODE)
#define UPT_TEMPLATE(NODE) TREE_PURPOSE(TYPE_VALUES(NODE))
#define UPT_PARMS(NODE) TREE_VALUE(TYPE_VALUES(NODE))
+#define builtin_function(NAME, TYPE, CODE, LIBNAME) \
+ define_function (NAME, TYPE, CODE, (void (*)())pushdecl, LIBNAME)
+
/* An enumeration of the kind of tags that C++ accepts. */
enum tag_types { record_type, class_type, union_type, enum_type,
signature_type };
extern int flag_implicit_templates;
+/* Nonzero if we want to emit defined symbols with common-like linkage as
+ weak symbols where possible, in order to conform to C++ semantics.
+ Otherwise, emit them as local symbols. */
+
+extern int flag_weak;
+
/* Current end of entries in the gc obstack for stack pointer variables. */
extern int current_function_obstack_index;
LOOKUP_HAS_IN_CHARGE means that the "in charge" variable is already
in the parameter list.
LOOKUP_ONLYCONVERTING means that non-conversion constructors are not tried.
+ INDIRECT_BIND means that if a temporary is created, it should be created so
+ that it lives only as long as WITH_CLEANUP_EXPRs live, else if a temporary
+ is created then it should live as long as the current variable bindings.
LOOKUP_SPECULATIVELY means return NULL_TREE if we cannot find what we are
after. Note, LOOKUP_COMPLAIN is checked and error messages printed
before LOOKUP_SPECULATIVELY is checked.
#define LOOKUP_HAS_IN_CHARGE (32)
#define LOOKUP_SPECULATIVELY (64)
#define LOOKUP_ONLYCONVERTING (128)
-/* 256 is free */
+#define INDIRECT_BIND (256)
#define LOOKUP_NO_CONVERSION (512)
#define LOOKUP_DESTRUCTOR (512)
extern void expand_builtin_throw PROTO((void));
extern void expand_start_eh_spec PROTO((void));
extern void expand_end_eh_spec PROTO((tree));
+extern tree build_cleanup PROTO((tree));
+extern tree start_anon_func PROTO((void));
/* in expr.c */
/* skip cplus_expand_expr */
extern tree array_type_nelts_top PROTO((tree));
extern tree break_out_target_exprs PROTO((tree));
extern tree build_unsave_expr PROTO((tree));
+extern tree unsave_expr PROTO((tree));
extern int cp_expand_decl_cleanup PROTO((tree, tree));
/* in typeck.c */
value we have to begin with is in ARG.
FLAGS controls how we manage access checking.
+ INDIRECT_BIND in FLAGS controls how any temporarys are generated.
CHECKCONST controls if we report error messages on const subversion. */
static tree
build_up_reference (type, arg, flags, checkconst)
{
tree temp;
- if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (argtype))
+ if (flags&INDIRECT_BIND)
+ {
+ tree slot = build (VAR_DECL, argtype);
+ layout_decl (slot, 0);
+ rval = build (TARGET_EXPR, argtype, slot, arg, 0);
+ rval = build1 (ADDR_EXPR, type, rval);
+ goto done;
+ }
+ else if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (argtype))
{
temp = build_cplus_new (argtype, targ, 1);
if (TREE_CODE (temp) == WITH_CLEANUP_EXPR)
}
if (winner)
- return build_type_conversion_1 (TREE_VALUE (winner), basetype, expr,
- TREE_PURPOSE (winner), 1);
+ {
+ tree type = TREE_VALUE (winner);
+ if (TREE_CODE (type) == REFERENCE_TYPE)
+ type = TREE_TYPE (type);
+ return build_type_conversion_1 (type, basetype, expr,
+ TREE_PURPOSE (winner), 1);
+ }
return NULL_TREE;
}
#include <sys/types.h>
#include <signal.h>
#include "obstack.h"
+#include "defaults.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
tree dtor_label;
+/* In a destructor, the last insn emitted after the start of the
+ function and the parms. */
+
+rtx last_dtor_insn;
+
/* In a constructor, the point at which we are ready to return
the pointer to the initialized object. */
block = make_node (BLOCK);
if (block != NULL_TREE)
{
- BLOCK_VARS (block) = decls;
- BLOCK_TYPE_TAGS (block) = tags;
- BLOCK_SUBBLOCKS (block) = subblocks;
- /* If we created the block earlier on, and we are just diddling it now,
- then it already should have a proper BLOCK_END_NOTE value associated
- with it, so avoid trashing that. Otherwise, for a new block, install
- a new BLOCK_END_NOTE value. */
- if (! block_previously_created)
- remember_end_note (block);
+ if (block_previously_created)
+ {
+ if (decls || tags || subblocks)
+ {
+ if (BLOCK_VARS (block) || BLOCK_TYPE_TAGS (block) || BLOCK_SUBBLOCKS (block))
+ {
+ warning ("internal compiler error: debugging info corrupted");
+ }
+ BLOCK_VARS (block) = decls;
+ BLOCK_TYPE_TAGS (block) = tags;
+ /* Recover from too many blocks by chaining them together. */
+ BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block), subblocks);
+ }
+ /* If we created the block earlier on, and we are just diddling it now, then
+ it already should have a proper BLOCK_END_NOTE value associated with it. */
+ }
+ else
+ {
+ BLOCK_VARS (block) = decls;
+ BLOCK_TYPE_TAGS (block) = tags;
+ BLOCK_SUBBLOCKS (block) = subblocks;
+ /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
+ remember_end_note (block);
+ }
}
/* In each subblock, record that this is its superior. */
extern tree current_namespace;
tree old_id = get_namespace_id ();
char *buf;
- tree d = make_node (NAMESPACE_DECL);
+ tree d;
if (! name)
{
name = get_unique_name ();
}
- DECL_NAME (d) = name;
- DECL_ASSEMBLER_NAME (d) = name;
- /* pushdecl wants to check the size of it to see if it is incomplete... */
- TREE_TYPE (d) = void_type_node;
+ d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
+
/* Mark them as external, so redeclaration_error_message doesn't think
they are duplicates. */
+
DECL_EXTERNAL (d) = 1;
d = pushdecl (d);
/* This is new for this compilation unit. */
pushlevel (0);
declare_namespace_level ();
- NAMESPACE_LEVEL (d) = (tree)current_binding_level;
+ NAMESPACE_LEVEL (d) = current_binding_level;
}
else
- {
- resume_level ((struct binding_level*)NAMESPACE_LEVEL (d));
- }
+ resume_level (NAMESPACE_LEVEL (d));
/* This code is just is bit old now... */
current_namespace = tree_cons (NULL_TREE, name, current_namespace);
types_match = TREE_TYPE (newdecl) == NULL_TREE;
else if (TREE_TYPE (newdecl) == NULL_TREE)
types_match = 0;
+ /* Qualifiers must match, and they may be present on either, the type
+ or the decl. */
+ else if ((TREE_READONLY (newdecl)
+ || TYPE_READONLY (TREE_TYPE (newdecl)))
+ == (TREE_READONLY (olddecl)
+ || TYPE_READONLY (TREE_TYPE (olddecl)))
+ && (TREE_THIS_VOLATILE (newdecl)
+ || TYPE_VOLATILE (TREE_TYPE (newdecl)))
+ == (TREE_THIS_VOLATILE (olddecl)
+ || TYPE_VOLATILE (TREE_TYPE (olddecl))))
+ types_match = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (newdecl)),
+ TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)), 1);
else
- types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 1);
+ types_match = 0;
}
return types_match;
DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
if (DECL_CHAIN (newdecl) == NULL_TREE)
DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl);
- if (DECL_NEXT_METHOD (newdecl) == NULL_TREE)
- DECL_NEXT_METHOD (newdecl) = DECL_NEXT_METHOD (olddecl);
if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
if (TREE_CODE (newdecl) == FUNCTION_DECL)
{
- DECL_C_STATIC (newdecl) = DECL_C_STATIC (olddecl);
+ DECL_C_STATIC (newdecl) |= DECL_C_STATIC (olddecl);
DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
}
if (b->parm_flag == 1)
cp_error ("declaration of `%#D' shadows a parameter", name);
}
- else if (oldlocal != NULL_TREE && b->is_for_scope
+ else if (warn_shadow && oldlocal != NULL_TREE && b->is_for_scope
&& !DECL_DEAD_FOR_LOCAL (oldlocal))
{
warning ("variable `%s' shadows local",
/* Definition isn't the kind we were looking for. */
cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
form);
+ return NULL_TREE;
}
return TREE_VALUE (tail);
}
{
cp_error ("`%#D' redeclared as %C in class scope",
TREE_VALUE (tail), form);
+ return NULL_TREE;
}
return TREE_VALUE (tail);
}
push_overloaded_decl (x, 0);
}
-#define builtin_function(NAME, TYPE, CODE, LIBNAME) \
- define_function (NAME, TYPE, CODE, (void (*)())pushdecl, LIBNAME)
-
#ifdef __GNUC__
__inline
#endif
#if 0
/* Support for these has not been written in either expand_builtin
or build_function_call. */
- builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, 0);
- builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, 0);
+ builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
+ builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
- 0);
- builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, 0);
+ NULL_PTR);
+ builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, NULL_PTR);
builtin_function ("__builtin_fmod", double_ftype_double_double,
- BUILT_IN_FMOD, 0);
+ BUILT_IN_FMOD, NULL_PTR);
builtin_function ("__builtin_frem", double_ftype_double_double,
- BUILT_IN_FREM, 0);
+ BUILT_IN_FREM, NULL_PTR);
builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int, BUILT_IN_MEMSET,
- 0);
+ NULL_PTR);
builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
- 0);
+ NULL_PTR);
builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
- 0);
+ NULL_PTR);
#endif
/* C++ extensions */
real gc code. */
if (flag_gc)
{
- builtin_function ("__gc_main", default_function_type, NOT_BUILT_IN, 0);
+ builtin_function ("__gc_main", default_function_type, NOT_BUILT_IN, NULL_PTR);
pushdecl (lookup_name (get_identifier ("__gc_main"), 0));
}
}
if (flag_cadillac)
init_cadillac ();
+ if (! SUPPORTS_WEAK)
+ flag_weak = 0;
/* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
declare_function_name ();
}
else if (! toplev)
{
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
tree old_cleanups = cleanups_this_call;
+ int old_temp_level = target_temp_slot_level;
+
/* This is a declared decl which must live until the
end of the binding contour. It may need a cleanup. */
}
}
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
+
if (DECL_SIZE (decl) && type != error_mark_node)
{
/* Compute and store the initial value. */
}
/* Cleanup any temporaries needed for the initial value. */
expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
}
finish_end0:
tree init;
{
tree oldstatic = value_member (decl, static_aggregates);
- tree old_cleanups;
if (oldstatic)
{
/* Emit code to perform this initialization but once. */
tree temp;
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
+ tree old_cleanups;
+ int old_temp_level;
+
/* Remember this information until end of file. */
push_obstacks (&permanent_obstack, &permanent_obstack);
expand_start_cond (build_binary_op (EQ_EXPR, temp,
integer_zero_node, 1), 0);
old_cleanups = cleanups_this_call;
+ old_temp_level = target_temp_slot_level;
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
+
expand_assignment (temp, integer_one_node, 0, 0);
if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
|| (init && TREE_CODE (init) == TREE_LIST))
/* Cleanup any temporaries needed for the initial value. */
expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+
+ if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
+ {
+ tree cleanup, fcall;
+ static tree Atexit = 0;
+ if (Atexit == 0)
+ {
+ tree atexit_fndecl, PFV, pfvlist;
+ /* Remember this information until end of file. */
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ PFV = build_pointer_type (build_function_type
+ (void_type_node, void_list_node));
+
+ pfvlist = tree_cons (NULL_TREE, PFV, void_list_node);
+
+ push_lang_context (lang_name_c);
+ atexit_fndecl =
+ builtin_function ("atexit",
+ build_function_type (void_type_node,
+ pfvlist),
+ NOT_BUILT_IN, NULL_PTR);
+ Atexit = default_conversion (atexit_fndecl);
+ pop_lang_context ();
+ pop_obstacks ();
+ }
+
+ cleanup = start_anon_func ();
+ expand_expr_stmt (build_cleanup (decl));
+ end_anon_func ();
+ mark_addressable (cleanup);
+ cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
+ fcall = build_function_call (Atexit, tree_cons (NULL_TREE, cleanup, NULL_TREE));
+ expand_expr_stmt (fcall);
+ }
+
expand_end_cond ();
if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
{
{
int publicp = 0;
+ /* We catch the others as conflicts with the builtin
+ typedefs. */
+ if (friendp && declarator == ridpointers[(int) RID_SIGNED])
+ {
+ cp_error ("function `%D' cannot be declared friend",
+ declarator);
+ friendp = 0;
+ }
+
if (friendp == 0)
{
if (ctype == NULL_TREE)
if (insns)
store_in_parms (insns);
}
+ last_dtor_insn = get_last_insn ();
}
/* Bind a name and initialization to the return value of
tree in_charge_node = lookup_name (in_charge_identifier, 0);
tree virtual_size;
int ok_to_optimize_dtor = 0;
+ int empty_dtor = get_last_insn () == last_dtor_insn;
if (current_function_assigns_this)
cond = build (NE_EXPR, boolean_type_node,
whether `this' is NULL in some cases. */
if ((flag_this_is_variable & 1) == 0)
ok_to_optimize_dtor = 1;
- else if (get_last_insn () == get_first_nonparm_insn ())
+ else if (empty_dtor)
ok_to_optimize_dtor
= (n_baseclasses == 0
|| (n_baseclasses == 1
start_sequence ();
- /* Make all virtual function table pointers in non-virtual base
- classes point to CURRENT_CLASS_TYPE's virtual function
- tables. */
- expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_decl);
- if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
- expand_indirect_vtbls_init (binfo, C_C_D, current_class_decl, 0);
+ /* If the dtor is empty, and we know there is not possible way we could
+ use any vtable entries, before they are possibly set by a base class
+ dtor, we don't have to setup the vtables, as we know that any base
+ class dtoring will set up any vtables it needs. We avoid MI,
+ because one base class dtor can do a virtual dispatch to an
+ overridden function that would need to have a non-related vtable set
+ up, we cannot avoid setting up vtables in that case. We could
+ change this to see if there is just one vtable. */
+ if (! empty_dtor || TYPE_USES_COMPLEX_INHERITANCE (current_class_type))
+ {
+ /* Make all virtual function table pointers in non-virtual base
+ classes point to CURRENT_CLASS_TYPE's virtual function
+ tables. */
+ expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_decl);
+
+ if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
+ expand_indirect_vtbls_init (binfo, C_C_D, current_class_decl, 0);
+ }
+
if (! ok_to_optimize_dtor)
{
cond = build_binary_op (NE_EXPR,
}
}
-/* Nonzero if presently building a cleanup. Needed because
- SAVE_EXPRs are not the right things to use inside of cleanups.
- They are only ever evaluated once, where the cleanup
- might be evaluated several times. In this case, a later evaluation
- of the cleanup might fill in the SAVE_EXPR_RTL, and it will
- not be valid for an earlier cleanup. */
-
-int building_cleanup;
-
/* If DECL is of a type which needs a cleanup, build that cleanup here.
We don't build cleanups if just going for syntax checking, since
fixup_cleanups does not know how to not handle them.
{
int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
tree rval;
- int old_building_cleanup = building_cleanup;
- building_cleanup = 1;
if (TREE_CODE (decl) != PARM_DECL)
temp = suspend_momentary ();
rval = build_compound_expr (tree_cons (NULL_TREE, rval,
build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
+ /* Since this is a cleanup, UNSAVE it now. */
+ rval = unsave_expr (rval);
+
if (TREE_CODE (decl) != PARM_DECL)
resume_momentary (temp);
- building_cleanup = old_building_cleanup;
-
return rval;
}
return 0;
cplus_expand_expr_stmt (exp)
tree exp;
{
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
+ tree old_cleanups = cleanups_this_call;
+ int old_temp_level = target_temp_slot_level;
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
+
if (TREE_TYPE (exp) == unknown_type_node)
{
if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
/* Clean up any pending cleanups. This happens when a function call
returns a cleanup-needing value that nobody uses. */
- expand_cleanups_to (NULL_TREE);
+ expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+ /* There might something left from building the trees. */
+ if (cleanups_this_call)
+ {
+ expand_cleanups_to (NULL_TREE);
+ }
+ free_temp_slots ();
}
/* When a stmt has been parsed, this function is called.
tree shadowed_labels;
tree ctor_label;
tree dtor_label;
+ rtx last_dtor_insn;
tree protect_list;
tree base_init_list;
tree member_init_list;
p->binding_level = current_binding_level;
p->ctor_label = ctor_label;
p->dtor_label = dtor_label;
+ p->last_dtor_insn = last_dtor_insn;
p->assigns_this = current_function_assigns_this;
p->just_assigned_this = current_function_just_assigned_this;
p->parms_stored = current_function_parms_stored;
current_binding_level = p->binding_level;
ctor_label = p->ctor_label;
dtor_label = p->dtor_label;
+ last_dtor_insn = p->last_dtor_insn;
protect_list = p->protect_list;
current_function_assigns_this = p->assigns_this;
current_function_just_assigned_this = p->just_assigned_this;
#include "decl.h"
#include "lex.h"
#include "output.h"
-#include "defaults.h"
extern tree get_file_function_name ();
extern tree cleanups_this_call;
int flag_new_for_scope = 1;
+/* Nonzero if we want to emit defined symbols with common-like linkage as
+ weak symbols where possible, in order to conform to C++ semantics.
+ Otherwise, emit them as local symbols. */
+
+int flag_weak = 1;
+
/* Table of language-dependent -f options.
STRING is the option name. VARIABLE is the address of the variable.
ON_VALUE is the value to store in VARIABLE
{"operator-names", &flag_operator_names, 1},
{"check-new", &flag_check_new, 1},
{"repo", &flag_use_repository, 1},
- {"for-scope", &flag_new_for_scope, 2}
+ {"for-scope", &flag_new_for_scope, 2},
+ {"weak", &flag_weak, 1}
};
/* Decode the string P as a language-specific option.
/* Mark the artificial `__in_chrg' parameter as "artificial". */
SET_DECL_ARTIFICIAL (parm);
DECL_ARG_TYPE (parm) = integer_type_node;
- DECL_REGISTER (parm) = 1;
+ TREE_READONLY (parm) = 1;
TREE_CHAIN (parm) = last_function_parms;
last_function_parms = parm;
}
buf[len] = '\0';
strcat (buf, dbuf);
DECL_ASSEMBLER_NAME (function) = get_identifier (buf);
- parm = build_decl (PARM_DECL, in_charge_identifier, const_integer_type);
+ parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
/* Mark the artificial `__in_chrg' parameter as "artificial". */
SET_DECL_ARTIFICIAL (parm);
- TREE_USED (parm) = 1;
-#if 0
- /* We don't need to mark the __in_chrg parameter itself as `const'
- since its type is already `const int'. In fact we MUST NOT mark
- it as `const' cuz that will screw up the debug info (causing it
- to say that the type of __in_chrg is `const const int'). */
TREE_READONLY (parm) = 1;
-#endif
- DECL_ARG_TYPE (parm) = const_integer_type;
+ DECL_ARG_TYPE (parm) = integer_type_node;
/* This is the same chain as DECL_ARGUMENTS (...). */
TREE_CHAIN (last_function_parms) = parm;
if (IS_AGGR_TYPE_CODE (TREE_CODE (thing)))
{
if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing))
- thing = DECL_NAME (TREE_VEC_ELT (TYPE_METHODS (thing), 0));
+ thing = DECL_NAME (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (thing), 0));
else
thing = TYPE_NAME (thing);
}
return type;
}
\f
+extern tree abort_fndecl;
+
static void
mark_vtable_entries (decl)
tree decl;
for (; entries; entries = TREE_CHAIN (entries))
{
- tree fnaddr = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries));
+ tree fnaddr = (flag_vtable_thunks ? TREE_VALUE (entries)
+ : FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries)));
tree fn = TREE_OPERAND (fnaddr, 0);
TREE_ADDRESSABLE (fn) = 1;
- if (DECL_ABSTRACT_VIRTUAL_P (fn))
- {
- extern tree abort_fndecl;
- if (flag_vtable_thunks)
- fnaddr = TREE_VALUE (entries);
- TREE_OPERAND (fnaddr, 0) = fn = abort_fndecl;
- }
+ if (DECL_LANG_SPECIFIC (fn) && DECL_ABSTRACT_VIRTUAL_P (fn))
+ TREE_OPERAND (fnaddr, 0) = fn = abort_fndecl;
assemble_external (fn);
}
}
if (! found && ! final)
{
tree method;
- for (method = CLASSTYPE_METHODS (type); method != NULL_TREE;
- method = DECL_NEXT_METHOD (method))
+ for (method = TYPE_METHODS (type); method != NULL_TREE;
+ method = TREE_CHAIN (method))
if (DECL_VINDEX (method) != NULL_TREE
&& ! DECL_THIS_INLINE (method)
&& ! DECL_ABSTRACT_VIRTUAL_P (method))
if (TREE_PUBLIC (decl))
cp_error ("all virtual functions redeclared inline");
#endif
- if (SUPPORTS_WEAK)
+ if (flag_weak)
DECL_WEAK (decl) = 1;
else
TREE_PUBLIC (decl) = 0;
&& ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
{
tree method;
- for (method = CLASSTYPE_METHODS (ctype); method != NULL_TREE;
- method = DECL_NEXT_METHOD (method))
+ for (method = TYPE_METHODS (ctype); method != NULL_TREE;
+ method = TREE_CHAIN (method))
{
if (DECL_VINDEX (method) != NULL_TREE
&& !DECL_THIS_INLINE (method)
{
if (DECL_IMPLICIT_INSTANTIATION (decl) && flag_implicit_templates)
{
- if (SUPPORTS_WEAK)
+ if (flag_weak)
DECL_WEAK (decl) = 1;
else
TREE_PUBLIC (decl) = 0;
= ! (CLASSTYPE_INTERFACE_ONLY (ctype)
|| (DECL_THIS_INLINE (decl) && ! flag_implement_inlines));
}
- else if (SUPPORTS_WEAK)
+ else if (flag_weak)
DECL_WEAK (decl) = 1;
else
TREE_PUBLIC (decl) = 0;
}
else if (DECL_C_STATIC (decl))
TREE_PUBLIC (decl) = 0;
- else if (SUPPORTS_WEAK)
+ else if (flag_weak)
DECL_WEAK (decl) = 1;
else
TREE_PUBLIC (decl) = 0;
DECL_INTERFACE_KNOWN (decl) = 1;
}
+tree
+build_cleanup (decl)
+ tree decl;
+{
+ tree temp;
+ tree type = TREE_TYPE (decl);
+
+ if (TREE_CODE (type) == ARRAY_TYPE)
+ temp = decl;
+ else
+ {
+ mark_addressable (decl);
+ temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
+ }
+ temp = build_delete (TREE_TYPE (temp), temp,
+ integer_two_node,
+ LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
+ return temp;
+}
+
extern int parse_time, varconst_time;
#define TIMEVAR(VAR, BODY) \
{
tree decl = TREE_VALUE (vars);
tree type = TREE_TYPE (decl);
- if (TYPE_NEEDS_DESTRUCTOR (type))
+ if (TYPE_NEEDS_DESTRUCTOR (type) && ! TREE_STATIC (vars))
{
needs_cleaning = 1;
- needs_messing_up = 1;
break;
}
- else
- needs_messing_up |= TYPE_NEEDS_CONSTRUCTING (type);
+
vars = TREE_CHAIN (vars);
}
tree type = TREE_TYPE (decl);
tree temp = TREE_PURPOSE (vars);
- if (TYPE_NEEDS_DESTRUCTOR (type))
+ if (TYPE_NEEDS_DESTRUCTOR (type) && ! TREE_STATIC (vars))
{
- if (TREE_STATIC (vars))
- expand_start_cond (build_binary_op (NE_EXPR, temp, integer_zero_node, 1), 0);
- if (TREE_CODE (type) == ARRAY_TYPE)
- temp = decl;
- else
- {
- mark_addressable (decl);
- temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
- }
- temp = build_delete (TREE_TYPE (temp), temp,
- integer_two_node, LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
+ temp = build_cleanup (decl);
expand_expr_stmt (temp);
-
- if (TREE_STATIC (vars))
- expand_end_cond ();
}
}
while (vars)
{
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
tree decl = TREE_VALUE (vars);
tree init = TREE_PURPOSE (vars);
tree old_cleanups = cleanups_this_call;
+ int old_temp_level = target_temp_slot_level;
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
/* If this was a static attribute within some function's scope,
then don't initialize it here. Also, don't bother
TREE_VEC_ELT (init, 1),
TREE_VEC_ELT (init, 2), 0),
const0_rtx, VOIDmode, 0);
- free_temp_slots ();
}
else
expand_assignment (decl, init, 0, 0);
{
/* a `new' expression at top level. */
expand_expr (decl, const0_rtx, VOIDmode, 0);
- free_temp_slots ();
if (TREE_CODE (init) == TREE_VEC)
{
expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0),
TREE_VEC_ELT (init, 1),
TREE_VEC_ELT (init, 2), 0),
const0_rtx, VOIDmode, 0);
- free_temp_slots ();
}
else
expand_aggr_init (build_indirect_ref (decl, NULL_PTR), init, 0, 0);
else if (decl == error_mark_node)
;
else my_friendly_abort (22);
- vars = TREE_CHAIN (vars);
+
/* Cleanup any temporaries needed for the initial value. */
expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+
+ vars = TREE_CHAIN (vars);
}
for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
}
}
}
+
+void
+mark_used (decl)
+ tree decl;
+{
+ TREE_USED (decl) = 1;
+ assemble_external (decl);
+}
#include "config.h"
#include "tree.h"
+#include <stdio.h>
#include <ctype.h>
/* cp_printer is the type of a function which converts an argument into
char *format;
arglist_dcl
{
- extern errorfn sprintf;
- cp_thing (sprintf, 0, format, arglist);
+ cp_thing ((errorfn *) sprintf, 0, format, arglist);
}
void
}
else if (type == boolean_type_node)
{
- if (t == boolean_false_node)
+ if (t == boolean_false_node
+ || (TREE_INT_CST_LOW (t) == 0
+ && TREE_INT_CST_HIGH (t) == 0))
OB_PUTS ("false");
else if (t == boolean_true_node)
OB_PUTS ("true");
- else
- my_friendly_abort (366);
}
else if (type == char_type_node)
{
/* holds a ready to emit call to "terminate ()". */
static tree TerminateFunctionCall;
+static tree empty_fndecl;
+
/* ====================================================================== */
/* =================================================================== */
struct labelNode {
- rtx label;
+ union {
+ rtx rlabel;
+ tree tlabel;
+ } u;
struct labelNode *chain;
};
tree saved_throw_type;
/* Holds the value being thrown. */
tree saved_throw_value;
+/* Holds the cleanup for the value being thrown. */
+tree saved_cleanup;
int throw_used;
static struct ehEntry *dequeue_eh_entry PROTO((struct ehQueue *queue));
static void new_eh_queue PROTO((struct ehQueue *queue));
static void new_eh_stack PROTO((struct ehStack *stack));
-static void push_label_entry PROTO((struct labelNode **labelstack, rtx label));
+static void push_label_entry PROTO((struct labelNode **labelstack, rtx rlabel, tree tlabel));
static rtx pop_label_entry PROTO((struct labelNode **labelstack));
-static rtx top_label_entry PROTO((struct labelNode **labelstack));
+static tree top_label_entry PROTO((struct labelNode **labelstack));
static struct ehEntry *copy_eh_entry PROTO((struct ehEntry *entry));
========================================================================= */
static void
-push_label_entry (labelstack, label)
+push_label_entry (labelstack, rlabel, tlabel)
struct labelNode **labelstack;
- rtx label;
+ rtx rlabel;
+ tree tlabel;
{
struct labelNode *newnode=(struct labelNode*)xmalloc (sizeof (struct labelNode));
- newnode->label = label;
+ if (rlabel)
+ newnode->u.rlabel = rlabel;
+ else
+ newnode->u.tlabel = tlabel;
newnode->chain = *labelstack;
*labelstack = newnode;
}
if (! *labelstack) return NULL_RTX;
tempnode = *labelstack;
- label = tempnode->label;
+ label = tempnode->u.rlabel;
*labelstack = (*labelstack)->chain;
free (tempnode);
return label;
}
-static rtx
+static tree
top_label_entry (labelstack)
struct labelNode **labelstack;
{
- if (! *labelstack) return NULL_RTX;
+ if (! *labelstack) return NULL_TREE;
- return (*labelstack)->label;
+ return (*labelstack)->u.tlabel;
}
/* Push to permanent obstack for rtl generation.
push_lang_context (lang_name_c);
catch_match_fndecl =
- define_function (flag_rtti
- ? "__throw_type_match_rtti"
- : "__throw_type_match",
- build_function_type (ptr_type_node,
- tree_cons (NULL_TREE, ptr_type_node,
- tree_cons (NULL_TREE, ptr_type_node,
- tree_cons (NULL_TREE, ptr_type_node,
- void_list_node)))),
- NOT_BUILT_IN,
- pushdecl,
- 0);
+ builtin_function (flag_rtti
+ ? "__throw_type_match_rtti"
+ : "__throw_type_match",
+ build_function_type (ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ void_list_node)))),
+ NOT_BUILT_IN, NULL_PTR);
find_first_exception_match_fndecl =
- define_function ("__find_first_exception_table_match",
- build_function_type (ptr_type_node,
- tree_cons (NULL_TREE, ptr_type_node,
- void_list_node)),
- NOT_BUILT_IN,
- pushdecl,
- 0);
+ builtin_function ("__find_first_exception_table_match",
+ build_function_type (ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ void_list_node)),
+ NOT_BUILT_IN, NULL_PTR);
unwind_fndecl =
- define_function ("__unwind_function",
- build_function_type (void_type_node,
- tree_cons (NULL_TREE, ptr_type_node,
- void_list_node)),
- NOT_BUILT_IN,
- pushdecl,
- 0);
+ builtin_function ("__unwind_function",
+ build_function_type (void_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ void_list_node)),
+ NOT_BUILT_IN, NULL_PTR);
throw_fndecl =
- define_function ("__throw",
- build_function_type (void_type_node, void_list_node),
- NOT_BUILT_IN,
- pushdecl,
- 0);
+ builtin_function ("__throw",
+ build_function_type (void_type_node, void_list_node),
+ NOT_BUILT_IN, NULL_PTR);
DECL_EXTERNAL (throw_fndecl) = 0;
TREE_PUBLIC (throw_fndecl) = 0;
+ empty_fndecl =
+ builtin_function ("__empty",
+ build_function_type (void_type_node, void_list_node),
+ NOT_BUILT_IN, NULL_PTR);
+ DECL_EXTERNAL (empty_fndecl) = 1;
+ TREE_PUBLIC (empty_fndecl) = 1;
Unexpected = default_conversion (unexpected_fndecl);
Terminate = default_conversion (terminate_fndecl);
DECL_COMMON (d) = 1;
cp_finish_decl (d, NULL_TREE, NULL_TREE, 0, 0);
saved_throw_value = lookup_name (get_identifier ("__eh_value"), 0);
+
+ declspecs = tree_cons (NULL_TREE, get_identifier ("void"), NULL_TREE);
+ d = build_parse_node (INDIRECT_REF, get_identifier ("__eh_cleanup"));
+ d = build_parse_node (CALL_EXPR, d, void_list_node, NULL_TREE);
+ d = start_decl (d, declspecs, 0, NULL_TREE);
+ DECL_COMMON (d) = 1;
+ cp_finish_decl (d, NULL_TREE, NULL_TREE, 0, 0);
+ saved_cleanup = lookup_name (get_identifier ("__eh_cleanup"), 0);
}
/* call this to begin a block of unwind protection (ie: when an object is
expand_start_all_catch ()
{
struct ehEntry *entry;
- rtx label;
+ tree label;
if (! doing_eh (1))
return;
emit_line_note (input_filename, lineno);
- label = gen_label_rtx ();
+ label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
/* The label for the exception handling block we will save. This is
Lresume, in the documention. */
- emit_label (label);
+ expand_label (label);
/* Put in something that takes up space, as otherwise the end
address for the EH region could have the exact same address as
region. */
emit_insn (gen_nop ());
- push_label_entry (&caught_return_label_stack, label);
+ push_label_entry (&caught_return_label_stack, NULL_RTX, label);
/* Start a new sequence for all the catch blocks. We will add this
to the gloabl sequence catch_clauses, when we have completed all
documentation. */
expand_internal_throw (gen_rtx (LABEL_REF,
Pmode,
- top_label_entry (&caught_return_label_stack)));
+ DECL_RTL (top_label_entry (&caught_return_label_stack))));
/* Now we have the complete catch sequence. */
new_catch_clause = get_insns ();
return build_eh_type_type (TREE_TYPE (exp));
}
+/* This routine creates the cleanup for the exception handling object. */
+void
+push_eh_cleanup ()
+{
+ /* All cleanups must last longer than normal. */
+ int yes = suspend_momentary ();
+
+ /* Arrange to do a dynamically scoped cleanup upon exit from this region. */
+ tree cleanup = build_function_call (saved_cleanup, NULL_TREE);
+ cp_expand_decl_cleanup (NULL_TREE, cleanup);
+
+ resume_momentary (yes);
+}
+
+
/* call this to start a catch block. Typename is the typename, and identifier
is the variable to place the object in or NULL if the variable doesn't
matter. If typename is NULL, that means its a "catch (...)" or catch
rtx protect_label_rtx;
tree decl = NULL_TREE;
tree init;
+ tree cleanup;
if (! doing_eh (1))
return;
push_rtl_perm ();
protect_label_rtx = gen_label_rtx ();
pop_rtl_from_perm ();
- push_label_entry (&false_label_stack, false_label_rtx);
- push_label_entry (&false_label_stack, protect_label_rtx);
+ push_label_entry (&false_label_stack, false_label_rtx, NULL_TREE);
+ push_label_entry (&false_label_stack, protect_label_rtx, NULL_TREE);
if (declspecs)
{
/* if it returned FALSE, jump over the catch block, else fall into it */
emit_jump_insn (gen_beq (false_label_rtx));
+ push_eh_cleanup ();
+
init = convert_from_reference (save_expr (make_tree (init_type, call_rtx)));
/* Do we need the below two lines? */
}
else
{
+ push_eh_cleanup ();
+
/* Fall into the catch all section. */
}
/* fall to outside the try statement when done executing handler and
we fall off end of handler. This is jump Lresume in the
documentation. */
- emit_jump (top_label_entry (&caught_return_label_stack));
+ expand_goto (top_label_entry (&caught_return_label_stack));
/* We end the rethrow protection region as soon as we hit a label. */
end_protect_label_rtx = expand_leftover_cleanups ();
emit_label (entry.exception_handler_label);
expand_internal_throw (gen_rtx (LABEL_REF,
Pmode,
- top_label_entry (&caught_return_label_stack)));
+ DECL_RTL (top_label_entry (&caught_return_label_stack))));
/* No associated finalization. */
entry.finalization = NULL_TREE;
emit_insns (insns);
}
+tree
+start_anon_func ()
+{
+ static int counter = 0;
+ char name[32];
+ tree params;
+ tree t;
+
+ push_cp_function_context (NULL_TREE);
+ push_to_top_level ();
+
+ /* No need to mangle this. */
+ push_lang_context (lang_name_c);
+
+ params = void_list_node;
+ /* tcf stands for throw clean funciton. */
+ sprintf (name, "__tcf_%d", counter++);
+ t = build_parse_node (CALL_EXPR, get_identifier (name), params, NULL_TREE);
+ start_function (decl_tree_cons (NULL_TREE, get_identifier ("static"),
+ void_list_node),
+ t, NULL_TREE, NULL_TREE, 0);
+ store_parm_decls ();
+ pushlevel (0);
+ clear_last_expr ();
+ push_momentary ();
+ expand_start_bindings (0);
+ emit_line_note (input_filename, lineno);
+
+ pop_lang_context ();
+
+ return current_function_decl;
+}
+
+void
+end_anon_func ()
+{
+ expand_end_bindings (getdecls(), 1, 0);
+ poplevel (1, 0, 0);
+ pop_momentary ();
+
+ finish_function (lineno, 0, 0);
+
+ pop_from_top_level ();
+ pop_cp_function_context (NULL_TREE);
+}
/* call this to expand a throw statement. This follows the following
algorithm:
if (exp)
{
tree throw_type;
- tree e;
+ tree cleanup = empty_fndecl, e;
/* throw expression */
/* First, decay it. */
}
else
{
+ rtx cleanup_insns;
+ tree object;
/* Make a copy of the thrown object. WP 15.1.5 */
exp = build_new (NULL_TREE, TREE_TYPE (exp),
build_tree_list (NULL_TREE, exp),
if (exp == error_mark_node)
error (" in thrown expression");
- throw_type = build_eh_type (build_indirect_ref (exp, NULL_PTR));
+ object = build_indirect_ref (exp, NULL_PTR);
+ throw_type = build_eh_type (object);
+
+ start_sequence ();
+ object = build_reinterpret_cast (TREE_TYPE (exp), saved_throw_value);
+ object = build_indirect_ref (object, NULL_PTR);
+ cleanup = maybe_build_cleanup (object);
+ if (cleanup)
+ expand_expr (cleanup, const0_rtx, VOIDmode, 0);
+ cleanup_insns = get_insns ();
+ end_sequence ();
+
+ if (cleanup && cleanup_insns)
+ {
+ cleanup = start_anon_func ();
+
+ expand_expr (maybe_build_cleanup (object), const0_rtx, VOIDmode, 0);
+
+ end_anon_func ();
+
+ mark_addressable (cleanup);
+ }
+ else
+ {
+ cleanup = empty_fndecl;
+ }
}
e = build_modify_expr (saved_throw_type, NOP_EXPR, throw_type);
expand_expr (e, const0_rtx, VOIDmode, 0);
+
e = build_modify_expr (saved_throw_value, NOP_EXPR, exp);
e = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (e), e);
expand_expr (e, const0_rtx, VOIDmode, 0);
+
+ cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
+ cleanup = build_modify_expr (saved_cleanup, NOP_EXPR, cleanup);
+ expand_expr (cleanup, const0_rtx, VOIDmode, 0);
}
else
{
line. Perhaps this was not intended. */
tree current_base_init_list, current_member_init_list;
+extern tree cleanups_this_call;
+
void emit_base_init ();
void check_base_init ();
static void expand_aggr_vbase_init ();
{
tree decl;
tree type = TREE_TYPE (member);
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
+ tree old_cleanups = cleanups_this_call;
+ int old_temp_level = target_temp_slot_level;
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
if (TYPE_NEEDS_CONSTRUCTING (type)
|| (init && TYPE_HAS_CONSTRUCTOR (type)))
expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
}
}
- expand_cleanups_to (NULL_TREE);
+ expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+ /* There might something left from building the trees. */
+ if (cleanups_this_call)
+ {
+ expand_cleanups_to (NULL_TREE);
+ }
+ free_temp_slots ();
if (TYPE_NEEDS_DESTRUCTOR (type))
{
if (init != void_list_node)
{
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
+ tree old_cleanups = cleanups_this_call;
+ int old_temp_level = target_temp_slot_level;
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
+
member = convert_pointer_to_real (base_binfo, current_class_decl);
expand_aggr_init_1 (base_binfo, 0,
build_indirect_ref (member, NULL_PTR), init,
BINFO_OFFSET_ZEROP (base_binfo), LOOKUP_NORMAL);
- expand_cleanups_to (NULL_TREE);
+ expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+ /* There might something left from building the trees. */
+ if (cleanups_this_call)
+ {
+ expand_cleanups_to (NULL_TREE);
+ }
+ free_temp_slots ();
}
if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
{
tree init = purpose_member (binfo, init_list);
tree ref = build_indirect_ref (addr, NULL_PTR);
+
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
+ tree old_cleanups = cleanups_this_call;
+ int old_temp_level = target_temp_slot_level;
+ push_temp_slots ();
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
+
if (init)
init = TREE_VALUE (init);
/* Call constructors, but don't set up vtables. */
expand_aggr_init_1 (binfo, exp, ref, init, 0, LOOKUP_COMPLAIN);
- expand_cleanups_to (NULL_TREE);
+
+ expand_cleanups_to (old_cleanups);
+ pop_temp_slots ();
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+ /* There might something left from building the trees. */
+ if (cleanups_this_call)
+ {
+ expand_cleanups_to (NULL_TREE);
+ }
+ free_temp_slots ();
}
/* Initialize this object's virtual base class pointers. This must be
/* Function to give error message if member initialization specification
is erroneous. FIELD is the member we decided to initialize.
TYPE is the type for which the initialization is being performed.
- FIELD must be a member of TYPE, or the base type from which FIELD
- comes must not need a constructor.
+ FIELD must be a member of TYPE.
MEMBER_NAME is the name of the member. */
{
if (field == error_mark_node)
return 0;
- if (field == NULL_TREE)
+ if (field == NULL_TREE || DECL_CONTEXT (field) != type)
{
cp_error ("class `%T' does not have any field named `%s'", type,
member_name);
return 0;
}
- if (DECL_CONTEXT (field) != type
- && TYPE_NEEDS_CONSTRUCTING (DECL_CONTEXT (field)))
- {
- if (current_function_decl && DECL_CONSTRUCTOR_P (current_function_decl))
- cp_error ("initialization of `%D' inside constructor for `%T'",
- field, type);
- else
- cp_error ("member `%D' comes from base class needing constructor",
- field);
- return 0;
- }
if (TREE_STATIC (field))
{
cp_error ("field `%#D' is static; only point of initialization is its declaration",
return;
}
+ if (warn_reorder && current_member_init_list)
+ {
+ warning ("base initializer for `%s'", IDENTIFIER_POINTER (name));
+ warning (" will be re-ordered to precede member initializations");
+ }
+
base_init = build_tree_list (name, init);
TREE_TYPE (base_init) = basetype;
current_base_init_list = chainon (current_base_init_list, base_init);
}
else
{
+#if 0
+ /* This causes testcase return2.C to fail. */
init = TREE_OPERAND (init, 1);
init = build (CALL_EXPR, init_type,
TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0);
TREE_SIDE_EFFECTS (init) = 1;
if (init_list)
TREE_VALUE (init_list) = init;
+#endif
}
}
cp_error ("ambiguity between conversion to `%T' and constructor",
type);
else
- expand_assignment (exp, rval, 0, 0);
+ expand_aggr_init_1 (binfo, true_exp, exp, rval, alias_this, flags);
return;
}
}
if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == VAR_DECL
|| TREE_CODE (t) == CONST_DECL)
{
- TREE_USED (t) = 1;
+ mark_used (t);
return t;
}
if (TREE_CODE (t) == FIELD_DECL)
error ("in this context");
return error_mark_node;
}
- assemble_external (t);
+ mark_used (t);
return build (OFFSET_REF, TREE_TYPE (t), decl, t);
}
|| ! allocation_temporary_p ()))
fnfields = copy_list (fnfields);
+#if 0
for (t = TREE_VALUE (fnfields); t; t = DECL_CHAIN (t))
assemble_external (t);
+#endif
t = build_tree_list (error_mark_node, fnfields);
TREE_TYPE (t) = build_offset_type (type, unknown_type_node);
values can be returned without further ado. */
if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
{
- assemble_external (t);
- TREE_USED (t) = 1;
+ mark_used (t);
return t;
}
"-fno-this-is-variable",
"-fvtable-thunks",
"-fno-vtable-thunks",
+ "-fweak",
+ "-fno-weak",
"-fxref",
"-fno-xref",
static int *reduce_count;
int *token_count;
+#if 0
#define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
#define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
+#endif
int *
init_parse ()
{
#ifdef GATHER_STATISTICS
+#ifdef REDUCE_LENGTH
reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
reduce_count += 1;
token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
token_count += 1;
+#endif
#endif
return token_count;
}
#ifdef GATHER_STATISTICS
+#ifdef REDUCE_LENGTH
void
yyhook (yyn)
int yyn;
return token_count[*q] - token_count[*p];
}
#endif
+#endif
void
print_parse_statistics ()
{
#ifdef GATHER_STATISTICS
+#ifdef REDUCE_LENGTH
#if YYDEBUG != 0
int i;
int maxlen = REDUCE_LENGTH;
fprintf (stderr, "\n");
#endif
#endif
+#endif
}
/* Sets the value of the 'yydebug' variable to VALUE.
p->name = input_filename;
input_file_stack = p;
input_file_stack_tick++;
+#ifdef DBX_DEBUGGING_INFO
+ if (write_symbols == DBX_DEBUG)
+ dbxout_start_new_source_file (input_filename);
+#endif
#ifdef DWARF_DEBUGGING_INFO
if (debug_info_level == DINFO_LEVEL_VERBOSE
&& write_symbols == DWARF_DEBUG)
input_file_stack = p->next;
free (p);
input_file_stack_tick++;
+#ifdef DBX_DEBUGGING_INFO
+ if (write_symbols == DBX_DEBUG)
+ dbxout_resume_previous_source_file ();
+#endif
#ifdef DWARF_DEBUGGING_INFO
if (debug_info_level == DINFO_LEVEL_VERBOSE
&& write_symbols == DWARF_DEBUG)
{
register tree id = lastiddecl;
+ if (IDENTIFIER_OPNAME_P (token))
+ id = lookup_name (token, 0);
+
if (yychar == YYEMPTY)
yychar = yylex ();
/* Scope class declarations before global
if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
return id;
}
- if (yychar == '(' || yychar == LEFT_RIGHT)
+
+ if (IDENTIFIER_OPNAME_P (token))
+ {
+ if (token != ansi_opname[ERROR_MARK])
+ cp_error ("operator %O not defined", token);
+ id = error_mark_node;
+ }
+ else if (yychar == '(' || yychar == LEFT_RIGHT)
{
id = implicitly_declare (token);
}
done:
/* yylloc.last_line = lineno; */
#ifdef GATHER_STATISTICS
+#ifdef REDUCE_LENGTH
token_count[value] += 1;
+#endif
#endif
return value;
/* Happens when the implicit object parameter is rejected. */
my_friendly_assert (! TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))),
241);
- cp_error ("call to non-const %s `%#D' with const object",
- name_kind, cp->function);
+ if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))))
+ && ! TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (cp->function))))))
+ cp_error ("call to non-volatile %s `%#D' with volatile object",
+ name_kind, cp->function);
+ else
+ cp_error ("call to non-const %s `%#D' with const object",
+ name_kind, cp->function);
return;
}
if (really_overloaded_fn (value))
{
+#if 0
tree t = get_first_fn (value);
for (; t; t = DECL_CHAIN (t))
{
assemble_external (t);
TREE_USED (t) = 1;
}
+#endif
}
else if (TREE_CODE (value) == TREE_LIST)
{
+ /* Ambiguous reference to base members, possibly other cases?. */
tree t = value;
while (t && TREE_CODE (t) == TREE_LIST)
{
- assemble_external (TREE_VALUE (t));
- TREE_USED (t) = 1;
+ mark_used (TREE_VALUE (t));
t = TREE_CHAIN (t);
}
}
else
- {
- assemble_external (value);
- TREE_USED (value) = 1;
- }
+ mark_used (value);
if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
{
}
if (thunk == NULL_TREE)
{
- thunk = build_decl (THUNK_DECL, thunk_id, TREE_TYPE (func_decl));
+ thunk = build_decl (FUNCTION_DECL, thunk_id, TREE_TYPE (func_decl));
DECL_RESULT (thunk)
= build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (TREE_TYPE (vtable_entry_type)));
TREE_READONLY (thunk) = TYPE_READONLY (TREE_TYPE (vtable_entry_type));
TREE_THIS_VOLATILE (thunk) = TYPE_VOLATILE (TREE_TYPE (vtable_entry_type));
make_function_rtl (thunk);
+ TREE_SET_CODE (thunk, THUNK_DECL);
DECL_INITIAL (thunk) = function;
THUNK_DELTA (thunk) = delta;
+ DECL_EXTERNAL (thunk) = 1;
+ TREE_PUBLIC (thunk) = 1;
/* So that finish_file can write out any thunks that need to be: */
pushdecl_top_level (thunk);
}
TREE_ASM_WRITTEN (thunk_fndecl) = 1;
- if (TREE_PUBLIC (function))
- {
- TREE_PUBLIC (thunk_fndecl) = 1;
- if (DECL_EXTERNAL (function))
- {
- DECL_EXTERNAL (thunk_fndecl) = 1;
- assemble_external (thunk_fndecl);
- return;
- }
- }
+ if (! TREE_PUBLIC (function))
+ TREE_PUBLIC (thunk_fndecl) = 0;
+ if (DECL_EXTERNAL (function))
+ return;
+ DECL_EXTERNAL (thunk_fndecl) = 0;
decl_printable_name = thunk_printable_name;
if (current_function_decl)
reinit_parse_for_function ();
$$ = NULL_TREE; }
| declmods notype_declarator exception_specification_opt
- { tree specs = strip_attrs ($1);
- if (! start_function (specs, $2, $3, NULL_TREE, 0))
+ { tree specs, attrs;
+ split_specs_attrs ($1, &specs, &attrs);
+ if (! start_function (specs, $2, $3, attrs, 0))
YYERROR1;
reinit_parse_for_function ();
$$ = NULL_TREE; }
{
if (TREE_CODE ($$) == BIT_NOT_EXPR)
$$ = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND ($$, 0));
- else if (IDENTIFIER_OPNAME_P ($$))
- {
- tree op = $$;
- $$ = lookup_name (op, 0);
- if ($$ == NULL_TREE)
- {
- if (op != ansi_opname[ERROR_MARK])
- error ("operator %s not defined",
- operator_name_string (op));
- $$ = error_mark_node;
- }
- }
else
$$ = do_identifier ($$);
}
else
{
if (TREE_CODE ($$) == ADDR_EXPR)
- assemble_external (TREE_OPERAND ($$, 0));
+ mark_used (TREE_OPERAND ($$, 0));
else
- assemble_external ($$);
- TREE_USED ($$) = 1;
+ mark_used ($$);
}
if (TREE_CODE ($$) == CONST_DECL)
{
{ if ($1) cplus_expand_expr_stmt ($1); }
| decl
| '{' compstmtend
+ { if (pedantic)
+ pedwarn ("ANSI C++ forbids compound statements inside for initializations");
+ }
;
/* Either a type-qualifier or nothing. First thing in an `asm' statement. */
if (i->interface == 1)
/* OK, it was an implicit instantiation. */
{
- if (SUPPORTS_WEAK)
+ if (flag_weak)
DECL_WEAK (t) = 1;
else
TREE_PUBLIC (t) = 0;
fn = IDENTIFIER_GLOBAL_VALUE (name),
fn && DECL_TEMPLATE_INSTANTIATION (fn))
result = fn;
+ else if (fn && DECL_CONTEXT (fn))
+ ;
else if (name = DECL_NAME (decl), fn = IDENTIFIER_GLOBAL_VALUE (name), fn)
{
for (fn = get_first_fn (fn); fn; fn = DECL_CHAIN (fn))
add_conversions (binfo)
tree binfo;
{
- tree tmp = CLASSTYPE_FIRST_CONVERSION (BINFO_TYPE (binfo));
- for (; tmp && IDENTIFIER_TYPENAME_P (DECL_NAME (tmp));
- tmp = TREE_CHAIN (tmp))
- conversions = tree_cons (DECL_NAME (tmp), TREE_TYPE (TREE_TYPE (tmp)),
- conversions);
+ int i;
+ tree vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));
+
+ for (i = 1; i < TREE_VEC_LENGTH (vec); ++i)
+ {
+ tree tmp = TREE_VEC_ELT (vec, i);
+ if (! IDENTIFIER_TYPENAME_P (DECL_NAME (tmp)))
+ break;
+ conversions = tree_cons (DECL_NAME (tmp), TREE_TYPE (TREE_TYPE (tmp)),
+ conversions);
+ }
}
tree
my_friendly_assert (datum != error_mark_node, 310);
fndecl = build_vfn_ref (&addr, datum, DECL_VINDEX (fndecl));
}
- assemble_external (fndecl);
+ mark_used (fndecl);
return fndecl;
}
if (access == access_protected)
not matter unless we're actually calling the function. */
tree t;
+#if 0
for (t = TREE_VALUE (fndecls); t; t = DECL_CHAIN (t))
assemble_external (t);
+#endif
t = build_tree_list (error_mark_node, fndecls);
TREE_TYPE (t) = build_offset_type (basetype,
cp_error ("invalid use of type decl `%#D' as expression", field);
return error_mark_node;
}
- if (DECL_RTL (field) != 0)
- assemble_external (field);
- TREE_USED (field) = 1;
+ else if (DECL_RTL (field) != 0)
+ mark_used (field);
+ else
+ TREE_USED (field) = 1;
return field;
}
}
/* Save the intermediate result in a SAVE_EXPR so we don't have to
compute each component of the virtual function pointer twice. */
- if (/* !building_cleanup && */ TREE_CODE (aref) == INDIRECT_REF)
+ if (TREE_CODE (aref) == INDIRECT_REF)
TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
delta = build_binary_op (PLUS_EXPR,
GNU_xref_call (current_function_decl,
IDENTIFIER_POINTER (name ? name
: TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function))));
- assemble_external (function);
+ mark_used (function);
fndecl = function;
/* Convert anything with function type to a pointer-to-function. */
if (DECL_INLINE (function))
{
/* Is it a synthesized method that needs to be synthesized? */
- if (DECL_ARTIFICIAL (function) && ! flag_no_inline
- && ! DECL_INITIAL (function)
+ if (DECL_ARTIFICIAL (function) && ! DECL_INITIAL (function)
/* Kludge: don't synthesize for default args. */
&& current_function_decl)
synthesize_method (function);
function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
}
else
- {
- assemble_external (function);
- TREE_USED (function) = 1;
- function = default_conversion (function);
- }
+ function = default_conversion (function);
}
else
{
&& (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
type = integer_type_node;
#endif
- parmval = convert_for_initialization (return_loc, type, val, flags,
+ parmval = convert_for_initialization (return_loc, type, val,
+ flags|INDIRECT_BIND,
"argument passing", fndecl, i);
#ifdef PROMOTE_PROTOTYPES
if ((TREE_CODE (type) == INTEGER_TYPE
tree primop0 = get_narrower (op0, &unsignedp0);
tree primop1 = get_narrower (op1, &unsignedp1);
+ /* Check for comparison of different enum types. */
+ if (flag_int_enum_equivalence == 0
+ && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
+ && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
+ && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
+ != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
+ {
+ cp_warning ("comparison between `%#T' and `%#T'",
+ TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
+ }
+
/* Give warnings for comparisons between signed and unsigned
quantities that may fail. */
/* Do the checking based on the original operand trees, so that
case FIX_ROUND_EXPR:
case FIX_CEIL_EXPR:
{
- tree incremented, modify, value;
+ tree incremented, modify, value, compound;
if (! lvalue_p (arg) && pedantic)
pedwarn ("cast to non-reference type used as lvalue");
arg = stabilize_reference (arg);
? PLUS_EXPR : MINUS_EXPR),
argtype, value, inc);
TREE_SIDE_EFFECTS (incremented) = 1;
+
modify = build_modify_expr (arg, NOP_EXPR, incremented);
- return build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
+ compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
+
+ /* Eliminate warning about unused result of + or -. */
+ TREE_NO_UNUSED_WARNING (compound) = 1;
+ return compound;
}
}
TREE_ADDRESSABLE (x) = 1;
TREE_USED (x) = 1;
TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
- if (asm_out_file)
- assemble_external (x);
return 1;
default:
expand_target_expr (t)
tree t;
{
+ extern int temp_slot_level;
+ extern int target_temp_slot_level;
+ int old_temp_level = target_temp_slot_level;
+
tree xval = make_node (RTL_EXPR);
rtx rtxval;
+ /* Any TARGET_EXPR temps live only as long as the outer temp level.
+ Since they are preserved in this new inner level, we know they
+ will make it into the outer level. */
+ push_temp_slots ();
+ target_temp_slot_level = temp_slot_level;
+
do_pending_stack_adjust ();
start_sequence_for_rtl_expr (xval);
emit_note (0, -1);
end_sequence ();
RTL_EXPR_RTL (xval) = rtxval;
TREE_TYPE (xval) = TREE_TYPE (t);
+
+ pop_temp_slots ();
+ target_temp_slot_level = old_temp_level;
+
return xval;
}
if (TREE_CODE (init) == CONSTRUCTOR)
{
tree field;
- tree funcs;
- int func;
/* Check that we're really an aggregate as ARM 8.4.1 defines it. */
if (CLASSTYPE_N_BASECLASSES (type))
cp_error_at ("initializer list construction invalid for `%D'", decl);
cp_error_at ("due to non-public access of member `%D'", field);
}
- funcs = TYPE_METHODS (type);
- if (funcs)
- for (func = 0; func < TREE_VEC_LENGTH (funcs); func++)
+ for (field = TYPE_METHODS (type); field; field = TREE_CHAIN (field))
+ if (TREE_PRIVATE (field) || TREE_PROTECTED (field))
{
- field = TREE_VEC_ELT (funcs, func);
- if (field && (TREE_PRIVATE (field) || TREE_PROTECTED (field)))
- {
- cp_error_at ("initializer list construction invalid for `%D'", decl);
- cp_error_at ("due to non-public access of member `%D'", field);
- }
+ cp_error_at ("initializer list construction invalid for `%D'", decl);
+ cp_error_at ("due to non-public access of member `%D'", field);
}
}
#endif
return process_init_constructor (type, init, (tree *)0);
else if (TYPE_NON_AGGREGATE_CLASS (type))
{
+#if 0
+ /* This isn't true. */
/* This can only be reached when caller is initializing
ARRAY_TYPE. In that case, we don't want to convert
INIT to TYPE. We will let `expand_vec_init' do it. */
return init;
+#else
+ return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
+ "initialization", NULL_TREE, 0);
+#endif
}
else if (tail != 0)
{
projects / gcc.git / commitdiff