+Mon Nov 28 16:44:41 1994 Mike Stump <mrs@cygnus.com>
+
+ * Makefile.in: Make is easier to decide where parse.[ch] will be
+ built.
+
Thu Nov 17 20:11:24 1994 Doug Evans <dje@cygnus.com>
* cp/Make-lang.in (CXX_INSTALL_NAME) Use program_transform_name.
* Makefile.in (spew.o, lex.o, pt.o):
Depend on $(srcdir)/parse.h, not parse.h.
-Sat Oct 29 07:18:52 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
+Mon Nov 28 13:53:03 1994 Mike Stump <mrs@cygnus.com>
+
+ * parse.y (THROW): Fix precedence of throw expressions.
+
+Mon Nov 28 13:15:16 1994 Mike Stump <mrs@cygnus.com>
+
+ * typeck.c (build_unary_op): Allow promotions from bool to int on
+ unary ~.
+
+Sun Nov 27 00:16:21 1994 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * method.c (build_overload_name): Use DECL_ASSEMBLER_NAME for
+ classes when appropriate.
+ (build_overload_nested_name): When dealing with a function context,
+ use ASM_FORMAT_PRIVATE_NAME to tweak the name of the function to
+ avoid conflicts between local classes of the same name.
+
+Wed Nov 23 17:59:42 1994 Mike Stump <mrs@cygnus.com>
+
+ * gxx.gperf, parse.y, lex.h, hash.h, lex.c (init_lex), delc.c
+ (duplicate_decls, grokdeclarator), cp-tree.h: Add support for
+ `explicit'.
+ * cvt.c (convert_to_reference, cp_convert, build_type_conversion_1,
+ build_type_conversion): Use LOOKUP_ONLYCONVERTING in
+ build_method_calls so that non-converting constructors are not used.
+ * call.c (build_method_call): If we shouldn't use a non-converting
+ constructor, then don't.
+
+Wed Nov 23 14:46:56 1994 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * call.c (build_method_call): Don't try to synthesize methods yet.
+
+Tue Nov 22 12:45:21 1994 Jason Merrill <jason@phydeaux.cygnus.com>
+
+ * pt.c (push_template_decls): Create CONST_DECLs for template
+ constant parameters, not VAR_DECLs.
+
+Sat Nov 19 15:28:31 1994 Jim Wilson (wilson@chestnut.cygnus.com)
+
+ * typeck.c (build_binary_op_nodefault): Can shorten shift only if
+ shift count is less than size in bits of arg0.
+
+Thu Nov 17 15:30:50 1994 Mike Stump <mrs@cygnus.com>
+
+ * gxx.gperf, hash.h, lex.c (init_lex, real_yylex), parse.y: Add new
+ ANSI keywords and, and_eq, bitand, bitor, explicit, namespace, not,
+ not_eq, or, or_eq, typename, using, xor, xor_eq to g++. Still need
+ 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
+ throws of bad_cast.
+ * gc.c (build_dynamic_cast): Support throwing of bad_cast at compile
+ time.
+
+Fri Nov 4 11:12:00 1994 Mike Stump <mrs@cygnus.com>
+
+ * except.c: Add hppa support.
+
+Fri Nov 4 10:50:50 1994 Mike Stump <mrs@cygnus.com>
+
+ * except.c: Add rs6000 support.
+
+Thu Nov 3 14:24:23 1994 Mike Stump <mrs@cygnus.com>
- * g++.c (main): Cast arg to bzero to avoid warning.
+ * except.c (do_unwind): Add i[34]86 support.
+
+Thu Nov 3 00:10:46 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * pt.c (do_pending_expansions): Unset TREE_PUBLIC on implicit
+ instantiations.
+
+Wed Nov 2 15:08:24 1994 Kung Hsu (kung@mexican.cygnus.com)
+
+ * decl.c (finish_function): emit types used in method parameters
+ into symbol table.
+
+Wed Nov 2 15:05:47 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * pt.c (process_template_parm): Allow pointer to member function
+ template parameter types.
+ (uses_template_parms): Handle pointer to member function
+ CONSTRUCTORs.
+
+ * g++.c (main): Cast first argument of bzero to (char *).
+ Pass -lstdc++ instead of -lg++ unless we are invoked as 'g++'.
+
+Mon Oct 31 14:50:48 1994 Kung Hsu (kung@mexican.cygnus.com)
+
+ * gc.c (build_dynamic_cast): rewrite to make it work.
+ * class.c (finish_vtbls): build more vtables if flag_rtti is on.
+ * class.c (modify_all_direct_vtables): ditto.
+ * init.c (expand_direct_vtbls_init): expand more vtables if
+ flag_rtti is on.
+ * decl.c (init_type_desc): add default return.
+
+Tue Oct 25 17:13:09 1994 Kung Hsu (kung@mexican.cygnus.com)
+
+ * tree.c (debug_binfo): get rid of the initial size entry of
+ vtable.
+ * cp-tree.h: change flag_dossier to flag rtti, define type
+ descriptor type nodes.
+ * decl.c (init_type_desc): new function to initialize type
+ descriptor type nodes.
+ * decl.c (record_builtin_type): change flag_dossier to flag_rtti.
+ * lex.c (init_lex): ditto.
+ * decl.c : change variable flag_dossier to flag_rtti.
+ * decl.c (duplicate_decls): get rid initial size entry of vtable.
+ * decl.c (hack_incomplete_structures): take out assert 164.
+ * search.c (get_abstract_virtuals_1): ditto.
+ * search.c (dfs_init_vbase_pointers): change CLASSTYPE_DOSSIER to
+ CLASSTYPE_RTTI.
+ * parse.y: ditto.
+ * class.c (prepare_fresh_vtable): for virtual bases, get right
+ offset.
+ * class.c (add_virtual_function): change flag_dossier to
+ flag_rtti.
+ * class.c (modify_one_vtable): modify the right rtti entry.
+ * class.c (override_one_vtable): get rid of size entry.
+ * class.c (finish_struct): change flag_dossier to flag_rtti, and
+ build extra vtables, build type descriptors for polymorphic
+ classes.
+ * gc.c (build_headof): make headof() works correctly with new
+ rtti.
+ * gc.c (build_typeid): make this function work with new rtti.
+ * gc.c (get_typeid): make this function work with new rtti.
+ * gc.c (build_bltn_desc): new function for new rtti.
+ * gc.c (build_user_desc): ditto.
+ * gc.c (build_class_desc): ditto.
+ * gc.c (build_ptr_desc): ditto.
+ * gc.c (build_attr_desc): ditto.
+ * gc.c (build_func_desc): ditto.
+ * gc.c (build_ptmf_desc): ditto.
+ * gc.c (build_ptmd_desc): ditto.
+ * gc.c (build_t_desc): ditto.
+ * gc.c : comment out old build_t_desc, build_i_desc, build_m_desc.
+
+Tue Oct 25 13:37:41 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * call.c (convert_harshness): Check for TREE_UNSIGNED differences
+ after checking for integral conversions.
Sun Oct 23 13:19:55 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * decl2.c: Declare flag_access_control.
- (struct lang_f_options): Add access-control.
- * expr.c (cplus_expand_expr, NEW_EXPR): Unset flag_access_control
- for the call to expand_aggr_init to copy the object out of the
- pcc_struct_return slot.
- * search.c (compute_access): if (!flag_access_control) return
- access_public.
+ * decl2.c: Declare flag_access_control.
+ (struct lang_f_options): Add access-control.
+ * expr.c (cplus_expand_expr, NEW_EXPR): Unset flag_access_control
+ for the call to expand_aggr_init to copy the object out of the
+ pcc_struct_return slot.
+ * search.c (compute_access): if (!flag_access_control) return
+ access_public.
Fri Oct 21 00:32:54 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * decl.c (init_decl_processing): Use __pure_virtual for abort_fndecl
- instead of abort, since the OSF/1 dynamic linker doesn't like to see
- relocation entries for abort.
+ * lex.c (cons_up_default_function): Don't try to defer method
+ synthesis now.
+
+ * decl.c (init_decl_processing): Use __pure_virtual for abort_fndecl
+ instead of abort, since the OSF/1 dynamic linker doesn't like to see
+ relocation entries for abort.
+
+ * tree.c (array_type_nelts_total): Use sizetype, not
+ integer_type_node.
+ (array_type_nelts_top): Ditto.
- * tree.c (array_type_nelts_total): Use sizetype, not
- integer_type_node.
- (array_type_nelts_top): Ditto.
+Thu Oct 20 15:48:27 1994 Mike Stump <mrs@cygnus.com>
+
+ * decl.c (grokdeclarator): Added handling for catch parameters
+ (CATCHPARM).
+ * except.c (expand_start_catch_block): Use the new CATCHPARM context
+ instead of NORMAL.
+ * except.c (expand_throw): Don't let convert_to_reference complain
+ about what we are doing.
+
+Thu Oct 20 12:55:24 1994 Jim Wilson (wilson@cygnus.com)
+
+ * method.c (emit_thunk): Call instantiate_virtual_regs.
+
+Wed Oct 19 14:15:33 1994 Mike Stump <mrs@cygnus.com>
+
+ * except.c (expand_exception_blocks): Make sure throw code doesn't
+ get put in function that won't be output.
Mon Oct 17 18:03:15 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * decl.c (init_decl_processing): Make alloca a builtin.
+ * decl.c (init_decl_processing): Make alloca a builtin.
+
+Thu Oct 27 21:10:25 1994 Craig Burley (craig@burley)
+
+ * g++.c (main): Only decrement "added" and set "library" to
+ NULL when "library" != NULL (just like 940829 fix).
Mon Oct 17 15:56:11 1994 Mike Stump <mrs@cygnus.com>
* class.c (modify_one_vtable): Since the DECL_CONTEXT of fndecl can
be set just below, use current_fndecl instead.
+Fri Oct 14 15:12:22 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * init.c (expand_aggr_vbase_init_1): Don't call expand_aggr_init_1
+ with LOOKUP_SPECULATIVELY.
+ (expand_default_init): Abort if build_method_call returns NULL_TREE.
+
+ * typeck.c (build_modify_expr): Don't just build a MODIFY_EXPR if
+ the rhs is a TARGET_EXPR.
+
+ * parse.y (left_curly): Anonymous types are not affected by #pragma
+ interface/implementation.
+
+ * method.c (synthesize_method): Don't call setup_vtbl_ptr for the
+ default constructor if it isn't needed.
+
+ * lex.c (cons_up_default_function): Do synthesize methods for
+ anonymous types if necessary.
+
Thu Oct 13 17:44:55 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * method.c (build_decl_overload): Set numeric_outputed_need_bar to 0.
+ * method.c (build_decl_overload): Set numeric_outputed_need_bar to 0.
Wed Oct 12 13:27:57 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * lex.c (real_yylex): Use HOST_BITS_PER_WIDE_INT to determine the
- bitmask for lexing character constants.
+ * typeck.c (build_modify_expr): Understand how to copy an aggregate.
+
+ * init.c (expand_default_init): Ditto. Also remove some of the
+ crufty code that assumes methods will not be synthesized properly.
+
+ * lex.c (cons_up_default_function): If the containing type has no
+ name, these functions should never need to be called, so just
+ declare them.
- * call.c (build_method_call): Disable code that tries to do tricky
- stuff with a default parameter that is a constructor call, but
- actually does other tricky stuff that breaks things.
+ * lex.c (real_yylex): Use HOST_BITS_PER_WIDE_INT to determine the
+ bitmask for lexing character constants.
+
+ * call.c (build_method_call): Disable code that tries to do tricky
+ stuff with a default parameter that is a constructor call, but
+ actually does other tricky stuff that breaks things.
Wed Oct 12 16:14:01 1994 Benoit Belley <belley@cae.ca>
- * decl.c (finish_enum): Disable code which forces enums to be signed,
- since this conflicts with their use as bitfields. type_promotes_to
- handles promotion of enums of underlying unsigned types to signed
- integer types.
+ * decl.c (finish_enum): Disable code which forces enums to be signed,
+ since this conflicts with their use as bitfields. type_promotes_to
+ handles promotion of enums of underlying unsigned types to signed
+ integer types.
Wed Oct 12 13:24:03 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * cvt.c (type_promotes_to): Also promote enums to long if
- appropriate.
+ * cvt.c (type_promotes_to): Also promote enums to long if
+ appropriate.
- * typeck.c (default_conversion): Don't expect type_promotes_to to
- return a main variant.
+ * typeck.c (default_conversion): Don't expect type_promotes_to to
+ return a main variant.
Wed Oct 12 12:19:45 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * call.c (build_scoped_method_call): Don't lose side effects in the
- object expression when calling a non-existent destructor.
+ * call.c (build_scoped_method_call): Don't lose side effects in the
+ object expression when calling a non-existent destructor.
Fri Sep 2 19:05:21 1994 Rohan Lenard (rjl@iassf.easams.com.au)
- * call.c (build_scoped_method_call): Remove erroneous error message
- when destructor call is written as a scoped call.
+ * call.c (build_scoped_method_call): Remove erroneous error message
+ when destructor call is written as a scoped call.
Tue Oct 11 23:48:31 1994 Jason Merrill (jason@phydeaux.cygnus.com)
-
- * various: Cast pointer arguments to bzero and bcopy to char *.
+
+ * various: Cast pointer arguments to bzero and bcopy to char *.
Tue Oct 11 19:34:32 1994 Mike Stump <mrs@cygnus.com>
offset to put into the vtable for the this parameter, make sure we
don't offset from a parent of the DECL_CONTEXT of the function.
+Tue Oct 11 16:10:52 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * pt.c (do_function_instantiation): Set DECL_EXTERNAL and
+ TREE_STATIC when setting DECL_INTERFACE_KNOWN.
+ (do_type_instantiation): Ditto.
+
+ * lex.c (cons_up_default_function): Set DECL_INTERFACE_KNOWN,
+ DECL_EXTERNAL and TREE_STATIC as appropriate.
+
+ * decl2.c (finish_file): Also synthesize methods that don't have
+ DECL_EXTERNAL set. Set interface_unknown before doing so.
+
+ * decl.c (start_function): If DECL_INTERFACE_KNOWN is set on the
+ function decl, don't muck with TREE_PUBLIC and DECL_EXTERNAL.
+
Mon Oct 10 00:56:53 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * lex.c (cons_up_default_function): Mark methods in a template class
- as template instances. Store the values of interface_unknown and
- interface_only for do_pending_inlines.
- (do_pending_inlines): Use them.
+ * lex.c (cons_up_default_function): Mark methods in a template class
+ as template instances. Store the values of interface_unknown and
+ interface_only for do_pending_inlines.
+ (do_pending_inlines): Use them.
+
+ * decl2.c (finish_file): If we haven't seen a definition of a
+ function declared static, make the decl non-PUBLIC so compile_file
+ can give an error.
Sun Oct 9 02:42:29 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * method.c (do_build_copy_constructor): Handle anonymous unions.
- (do_build_assign_ref): Ditto.
- (largest_union_member): Move from lex.c.
+ * method.c (do_build_copy_constructor): Handle anonymous unions.
+ (do_build_assign_ref): Ditto.
+ (largest_union_member): Move from lex.c.
+
+Sat Oct 8 14:59:43 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ Re-implement g++'s vague linkage independent of TREE_PUBLIC.
+ * pt.c (instantiate_member_templates): Lose redundant
+ -fexternal-templates handling.
+ (tsubst): Set TREE_PUBLIC and DECL_EXTERNAL on new decls. Don't set
+ TREE_STATIC or DECL_INTERFACE_KNOWN.
+ (do_pending_expansions): Predicate on DECL_INTERFACE_KNOWN instead
+ of DECL_EXTERNAL for explicit instantiations.
+ (do_function_instantiation): Do the new thing.
+ (do_type_instantiation): Ditto.
+ (instantiate_template): Deal with member templates defined in a .cc
+ file with -fexternal-templates.
+ * except.c (expand_exception_blocks): Use DECL_LINKAGE_KNOWN to
+ decide whether to stick builtin_throw here.
+ * decl2.c (import_export_inline): Predicate on DECL_INTERFACE_KNOWN
+ rather than TREE_PUBLIC. Generally fix rules.
+ (finish_file): Use DECL_INITIAL to determine whether or not a method
+ has been synthesized, rather than TREE_ASM_WRITTEN.
+ * decl.c (warn_extern_redeclared_static): Use DECL_PUBLIC instead of
+ TREE_PUBLIC.
+ (pushdecl): Ditto.
+ (duplicate_decls): Ditto. Deal with DECL_DECLARED_STATIC and
+ DECL_INTERFACE_KNOWN.
+ (redeclaration_error_message): Fix checking for conflicting linkage.
+ (define_function): Set DECL_INTERFACE_KNOWN.
+ (grokfndecl): Function decls are PUBLIC until we are sure about
+ their linkage. Set DECL_DECLARED_STATIC as needed.
+ (start_function): Deal with linkage. Move pushdecl after linkage
+ magic.
+ (finish_function): Don't set TREE_ASM_WRITTEN on discarded inlines.
+ * cp-tree.h (lang_decl_flags): Add interface_known and
+ declared_static.
+ (DECL_INTERFACE_KNOWN): New macro.
+ (DECL_DECLARED_STATIC): New macro.
+ (DECL_PUBLIC): New macro.
+
+ Clean up bogus use of TREE_PUBLIC.
+ * class.c (alter_access): Fix mistaken use of TREE_PUBLIC (it
+ doesn't correspond to TREE_PROTECTED and TREE_PRIVATE).
+ * init.c (do_friend): Don't arbitrarily set TREE_PUBLIC.
Wed Oct 5 13:44:41 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * call.c (build_overload_call_real): Don't immediately do
- array->pointer conversion.
+ * call.c (build_overload_call_real): Don't immediately do
+ array->pointer conversion.
- * pt.c (type_unification): If not passing to a reference, strip
- cv-quals. Also handle array->pointer conversion.
+ * pt.c (type_unification): If not passing to a reference, strip
+ cv-quals. Also handle array->pointer conversion.
Tue Oct 4 17:45:37 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * decl.c (grokdeclarator): Don't warn about applying const to a
- const typedef or template type parameter.
+ * decl.c (grokdeclarator): Don't warn about applying const to a
+ const typedef or template type parameter.
+
+ * decl2.c (finish_file): Also synthesize methods after walking the
+ vtables. Ugly ugly ugly.
Mon Oct 3 15:02:41 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * decl.c (shadow_tag): Remove obsolete code for pushing tags and
- dealing with exceptions.
+ * various: Remove lingering remnants of old exception handling code.
+
+ * decl2.c (finish_file): Synthesize methods before walking the
+ vtables, so that the vtables get emitted as needed.
+
+ * decl.c (shadow_tag): Remove obsolete code for pushing tags and
+ dealing with exceptions.
+
+Mon Oct 3 13:05:27 1994 Ian Lance Taylor <ian@sanguine.cygnus.com>
+
+ * Make-lang.in (g++-cross): Depend upon version.o and $(LIBDEPS).
+
+Mon Oct 3 02:59:28 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ * decl2.c (finish_file): Fix inline handling.
Sun Oct 2 00:21:56 1994 Jason Merrill (jason@phydeaux.cygnus.com)
- * parse.y (expr_or_declarator): Add '(' expr_or_declarator ')' rule.
- (direct_notype_declarator): Ditto.
- (complex_direct_notype_declarator): Remove it here.
+ * decl.c (grokdeclarator): Handle redundant scope even better.
+ ({push,pop}_cp_function_context): Take toplev parameter.
-Sat Oct 1 21:42:18 1994 Jason Merrill (jason@deneb.cygnus.com)
+ * method.c (synthesize_method): Pass toplev parameter to
+ {push,pop}_cp_function_context depending on decl_function_context
+ (fndecl).
- * init.c (resolve_offset_ref): Fix types used in resolving .*
- expressions.
+ * typeck.c (build_x_unary_op): Unary & on OFFSET_REFs is always the
+ built-in version.
-Thu Sep 29 16:15:36 1994 Michael I Bushnell <mib@churchy.gnu.ai.mit.edu>
+ * method.c (synthesize_method): Don't be confused by __in_chrg
+ parameter.
- * g++.c: Rework last change so it's done like collect.c (and
- gcc.c).
+ * class.c (popclass): Set C_C_D like start_function does.
-Wed Sep 28 19:19:01 1994 Brendan Kehoe (brendan@mole.gnu.ai.mit.edu)
+ * decl.c (grokdeclarator): Handle redundant scope better.
- * except.c (register_exception_table): Use Pmode, not PTRmode.
+ * parse.y (expr_or_declarator): Add '(' expr_or_declarator ')' rule.
+ (direct_notype_declarator): Ditto.
+ (complex_direct_notype_declarator): Remove it here.
-Wed Sep 14 10:17:27 1994 Michael I Bushnell <mib@churchy.gnu.ai.mit.edu>
+Sat Oct 1 21:42:18 1994 Jason Merrill (jason@deneb.cygnus.com)
- * g++.c: Include <sys/errno.h> in case `errno' is a macro
- as permitted by ANSI C.
+ * init.c (resolve_offset_ref): Fix types used in resolving .*
+ expressions.
+
+Sat Oct 1 15:18:49 1994 Jason Merrill (jason@phydeaux.cygnus.com)
+
+ Beginnings of work to synthesize methods only when needed.
+ * call.c (build_method_call): Synthesize methods as necessary
+ (currently never necessary).
+ * class.c (popclass): Don't try to set C_C_D here, as it'll end up
+ on the wrong obstack.
+ * decl.c (push_cp_function_context): Mostly copied from
+ push_c_function_context.
+ (pop_cp_function_context): Similarly.
+ (finish_function): Reverse order of poplevel and pop_nested_class so
+ that current_class_decl is restored properly.
+ (start_function): Ditto.
+ (finish_function): Add parameter 'nested'. Don't call
+ permanent_allocation if (nested).
+ * various: Pass extra parameter to finish_function.
+ * decl2.c (finish_file): Reorganize end-of-file inline handling,
+ synthesizing methods as necessary.
+ * lex.c (cons_up_default_function): Call mark_inline_for_output.
+ Only synthesize methods immediately if #pragma implementation
+ (currently disabled).
+ (do_pending_inlines): Call synthesize_method.
+ * method.c (synthesize_method): New function; all method synthesis
+ goes through here. Calls do_build_assign_ref and
+ do_build_copy_constructor.
+ (build_default_constructor): Remove.
+ (build_dtor): Ditto.
+ (build_assign_ref): Rename to do_build_assign_ref and remove stuff
+ done by synthesize_method.
+ (build_copy_constructor): Similarly.
Thu Sep 29 16:58:52 1994 Mike Stump <mrs@cygnus.com>
* *.c: Use cp_build_type_variant instead of c_build_type_variant.
* pt.c (do_type_instantiation): Don't try to instantiate nested
- enums.
+ enums.
Tue Sep 13 10:56:58 1994 Jason Merrill (jason@deneb.cygnus.com)
* cvt.c (build_up_reference): Handle preincrement and predecrement
- properly.
+ properly.
Tue Sep 13 09:51:59 1994 Brendan Kehoe (brendan@lisa.cygnus.com)
* class.c (finish_struct): Move setting of CLASSTYPE_INTERFACE and
CLASSTYPE_VTABLE_NEEDS_WRITING for signatures up to left_curly time.
* decl.c (xref_tag): Move setting of CLASSTYPE_INTERFACE and
- CLASSTYPE_VTABLE_NEEDS_WRITING for signatures down to left_curly time.
+ CLASSTYPE_VTABLE_NEEDS_WRITING for signatures down to left_curly time.
* parse.y (left_curly): New final resting place for setting
CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING for signatures.
* error.c (dump_decl): Handle NULL args.
+Thu Sep 29 16:15:36 1994 Michael I Bushnell <mib@churchy.gnu.ai.mit.edu>
+
+ * g++.c: Rework last change so it's done like collect.c (and
+ gcc.c).
+
+Wed Sep 14 10:17:27 1994 Michael I Bushnell <mib@churchy.gnu.ai.mit.edu>
+
+ * g++.c: Include <sys/errno.h> in case `errno' is a macro
+ as permitted by ANSI C.
+
Thu Aug 18 12:48:09 1994 Mike Stump (mrs@cygnus.com)
* class.c (finish_struct): Move setting of CLASSTYPE_INTERFACE and
CLASSTYPE_VTABLE_NEEDS_WRITING up to left_curly time.
* decl.c (xref_tag): Move setting of CLASSTYPE_INTERFACE and
- CLASSTYPE_VTABLE_NEEDS_WRITING down to left_curly time.
+ CLASSTYPE_VTABLE_NEEDS_WRITING down to left_curly time.
* parse.y (left_curly): New final resting place for setting
CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING.
* method.c (hack_identifier): Fix for new overloading.
* typeck.c (build_binary_op_nodefault): Don't mess with division by
- zero.
+ zero.
Fri Jul 8 13:20:28 1994 Gerald Baumgartner (gb@cs.purdue.edu)
$(CC) $(ALL_CFLAGS) $(INCLUDES) $(LDFLAGS) -o g++ $(srcdir)/cp/g++.c $(LIBS)
# Create a version of the g++ driver which calls the cross-compiler.
-g++-cross: $(srcdir)/cp/g++.c
+g++-cross: $(srcdir)/cp/g++.c version.o $(LIBDEPS)
$(CC) $(ALL_CFLAGS) $(INCLUDES) $(LDFLAGS) -o g++-cross \
-DGCC_NAME=\"$(GCC_CROSS_NAME)\" $(srcdir)/cp/g++.c version.o $(LIBS)
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 tree.def
+PARSE_H = $(srcdir)/parse.h
+PARSE_C = $(srcdir)/parse.c
-parse.o : $(srcdir)/parse.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h lex.h
+parse.o : $(PARSE_C) $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h lex.h
$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(BIG_SWITCHFLAG) \
- `echo $(srcdir)/parse.c | sed 's,^\./,,'`
-
-$(srcdir)/parse.c $(srcdir)/parse.h : $(srcdir)/parse.y
+ `echo $(PARSE_C) | sed 's,^\./,,'`
+
+#$(PARSE_C) $(PARSE_H) : $(srcdir)/parse.y
+# @echo expect 1 shift/reduce confict and 34 reduce/reduce conflicts.
+# cd $(srcdir); $(BISON) $(BISONFLAGS) -d -o parse.c parse.y
+# cd $(srcdir); grep '^#define[ ]*YYEMPTY' parse.c >>parse.h
+$(PARSE_C) $(PARSE_H) : stamp-parse ; @true
+stamp-parse: $(srcdir)/parse.y
@echo expect 1 shift/reduce confict and 34 reduce/reduce conflicts.
- cd $(srcdir); $(BISON) $(BISONFLAGS) -d -o parse.c parse.y
- cd $(srcdir); grep '^#define[ ]*YYEMPTY' parse.c >>parse.h
+ $(BISON) $(BISONFLAGS) -d $(srcdir)/parse.y
+ grep '^#define[ ]*YYEMPTY' y.tab.c >>y.tab.h
+ $(srcdir)/../move-if-change y.tab.c $(PARSE_C)
+ $(srcdir)/../move-if-change y.tab.h $(PARSE_H)
+ cp $(PARSE_C) y.tab.c
+ touch stamp-parse
# hash.h really depends on $(srcdir)/gxx.gperf.
# But this would screw things for people that don't have gperf,
$(srcdir)/gxx.gperf >$(srcdir)/hash.h
spew.o : spew.c $(CONFIG_H) $(CXX_TREE_H) \
- $(srcdir)/parse.h $(srcdir)/../flags.h lex.h
+ $(PARSE_H) $(srcdir)/../flags.h lex.h
lex.o : lex.c $(CONFIG_H) $(CXX_TREE_H) \
- $(srcdir)/parse.h input.c $(srcdir)/../flags.h hash.h lex.h
+ $(PARSE_H) input.c $(srcdir)/../flags.h hash.h lex.h
decl.o : decl.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
lex.h decl.h $(srcdir)/../stack.h
decl2.o : decl2.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h \
$(srcdir)/../expr.h ../insn-codes.h
edsel.o : edsel.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../stack.h $(srcdir)/../flags.h
xref.o : xref.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../input.h
-pt.o : pt.c $(CONFIG_H) $(CXX_TREE_H) decl.h $(srcdir)/parse.h
+pt.o : pt.c $(CONFIG_H) $(CXX_TREE_H) decl.h $(PARSE_H)
error.o : error.c $(CONFIG_H) $(CXX_TREE_H)
errfn.o : errfn.c $(CONFIG_H) $(CXX_TREE_H)
sig.o : sig.c $(CONFIG_H) $(CXX_TREE_H) $(srcdir)/../flags.h
else
penalty = 2;
- if (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (intype))
- {
- ttl = unsigned_type (ttl);
- intype = unsigned_type (intype);
- penalty += 2;
- }
-
ttr = intype;
/* If the initializer is not an lvalue, then it does not
return h;
}
+ if (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (intype))
+ {
+ ttl = unsigned_type (ttl);
+ ttr = intype = unsigned_type (intype);
+ penalty += 2;
+ }
+
if (ttl == ttr)
{
if (penalty > 2)
cp->function = function;
cp->basetypes = basetype_path;
+ /* Don't allow non-converting constructors to convert. */
+ if (flags & LOOKUP_ONLYCONVERTING
+ && DECL_LANG_SPECIFIC (function)
+ && DECL_NONCONVERTING_P (function))
+ continue;
+
/* No "two-level" conversions. */
if (flags & LOOKUP_NO_CONVERSION
&& (cp->h.code & USER_CODE))
/* Declare external function if necessary. */
assemble_external (function);
+#if 0
+ if (DECL_ARTIFICIAL (function) && ! flag_no_inline
+ && DECL_SAVED_INSNS (function) == 0
+ && ! TREE_ASM_WRITTEN (function))
+ synthesize_method (function);
+#endif
+
fntype = TREE_TYPE (function);
if (TREE_CODE (fntype) == POINTER_TYPE)
fntype = TREE_TYPE (fntype);
for_type, and we really want different names. (mrs) */
tree name = build_type_pathname (VTABLE_NAME_FORMAT, basetype, for_type);
tree new_decl = build_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
- tree path;
+ tree path, offset;
int result;
/* Remember which class this vtable is really for. */
/* Make fresh virtual list, so we can smash it later. */
BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
+
+ if (TREE_VIA_VIRTUAL (binfo))
+ offset = BINFO_OFFSET (binfo_member (BINFO_TYPE (binfo),
+ CLASSTYPE_VBASECLASSES (for_type)));
+ else
+ offset = BINFO_OFFSET (binfo);
+
/* Install the value for `headof' if that's what we're doing. */
- if (flag_dossier)
- TREE_VALUE (TREE_CHAIN (BINFO_VIRTUALS (binfo)))
- = build_vtable_entry (size_binop (MINUS_EXPR, integer_zero_node, BINFO_OFFSET (binfo)),
- FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (TREE_CHAIN (BINFO_VIRTUALS (binfo)))));
+ if (flag_rtti)
+ TREE_VALUE (BINFO_VIRTUALS (binfo))
+ = build_vtable_entry (size_binop (MINUS_EXPR, integer_zero_node, offset),
+ FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (BINFO_VIRTUALS (binfo))));
#ifdef GATHER_STATISTICS
n_vtables += 1;
{
tree entry;
- if (flag_dossier && *has_virtual == 0)
+ if (flag_rtti && *has_virtual == 0)
{
- /* CLASSTYPE_DOSSIER is only used as a Boolean (NULL or not). */
- CLASSTYPE_DOSSIER (t) = integer_one_node;
+ /* CLASSTYPE_RTTI is only used as a Boolean (NULL or not). */
+ CLASSTYPE_RTTI (t) = integer_one_node;
+#if 0
*has_virtual = 1;
+#endif
}
/* Build a new INT_CST for this DECL_VINDEX. */
error ("conflicting access specifications for field `%s', ignored",
IDENTIFIER_POINTER (DECL_NAME (fdecl)));
}
- else if (TREE_PRIVATE (fdecl) && access != access_private)
- cp_error_at ("cannot make private `%D' non-private", fdecl);
+ else if (TREE_PRIVATE (fdecl))
+ {
+ if (access != access_private)
+ cp_error_at ("cannot make private `%D' non-private", fdecl);
+ goto alter;
+ }
else if (TREE_PROTECTED (fdecl))
{
- if (access == access_public)
- cp_error_at ("cannot make protected `%D' public", fdecl);
+ if (access != access_protected)
+ cp_error_at ("cannot make protected `%D' non-protected", fdecl);
goto alter;
}
/* ARM 11.3: an access declaration may not be used to restrict access
to a member that is accessible in the base class. */
- else if (TREE_PUBLIC (fdecl)
- && (access == access_private
- || access == access_protected))
+ else if (access != access_public)
cp_error_at ("cannot reduce access of public member `%D'", fdecl);
else if (elem == NULL_TREE)
{
{
base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
}
- finish_vtbls (base_binfo, is_not_base_vtable, t);
+ finish_vtbls (base_binfo, (is_not_base_vtable || flag_rtti), t);
}
}
tree binfo, t, fndecl, pfn;
{
tree virtuals = BINFO_VIRTUALS (binfo);
+ tree old_rtti;
unsigned HOST_WIDE_INT n;
- n = 0;
- /* Skip initial vtable length field and RTTI fake object. */
- for (; virtuals && n < 1 + flag_dossier; n++)
- virtuals = TREE_CHAIN (virtuals);
+ /* update rtti entry */
+ if (flag_rtti)
+ {
+ if (binfo == TYPE_BINFO (t))
+ {
+ if (! BINFO_NEW_VTABLE_MARKED (binfo))
+ build_vtable (TYPE_BINFO (DECL_CONTEXT (CLASSTYPE_VFIELD (t))), t);
+ }
+ else
+ {
+ if (! BINFO_NEW_VTABLE_MARKED (binfo))
+ prepare_fresh_vtable (binfo, t);
+ }
+ old_rtti = get_vtable_entry_n (BINFO_VIRTUALS (binfo), 0);
+ if (old_rtti)
+ TREE_VALUE (old_rtti) = build_vtable_entry (
+ DELTA_FROM_VTABLE_ENTRY (TREE_VALUE (old_rtti)),
+ build_t_desc (t, 0));
+ }
+ if (fndecl == NULL_TREE) return;
+
+ /* Skip RTTI fake object. */
+ n = 1;
+ if (virtuals)
+ virtuals = TREE_CHAIN (virtuals);
while (virtuals)
{
tree current_fndecl = TREE_VALUE (virtuals);
int is_not_base_vtable =
i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
if (! TREE_VIA_VIRTUAL (base_binfo))
- modify_all_direct_vtables (base_binfo, is_not_base_vtable, t, fndecl, pfn);
+ modify_all_direct_vtables (base_binfo, (is_not_base_vtable || flag_rtti), t, fndecl, pfn);
}
}
tree virtuals = BINFO_VIRTUALS (binfo);
unsigned HOST_WIDE_INT n;
- n = 0;
- /* Skip initial vtable length field and RTTI fake object. */
- for (; virtuals && n < 1 + flag_dossier; n++)
- virtuals = TREE_CHAIN (virtuals);
+ /* Skip RTTI fake object. */
+ n = 1;
+ if (virtuals)
+ virtuals = TREE_CHAIN (virtuals);
while (virtuals)
{
tree fndecl = TREE_VALUE (virtuals);
if (BINFO_NEW_VTABLE_MARKED (binfo))
choose = NEITHER;
- /* Skip size entry. */
- virtuals = TREE_CHAIN (virtuals);
/* Skip RTTI fake object. */
- if (flag_dossier)
- {
- virtuals = TREE_CHAIN (virtuals);
- }
-
- /* Skip size entry. */
+ virtuals = TREE_CHAIN (virtuals);
old_virtuals = TREE_CHAIN (old_virtuals);
- /* Skip RTTI fake object. */
- if (flag_dossier)
- {
- old_virtuals = TREE_CHAIN (old_virtuals);
- }
while (virtuals)
{
}
#endif
- if (flag_dossier)
+#if 0
+ if (flag_rtti)
build_t_desc (t, 0);
+#endif
TYPE_BINFO (t) = NULL_TREE;
tail = &TREE_CHAIN (dtor);
if (DECL_VINDEX (dtor) == NULL_TREE
- && ! CLASSTYPE_DECLARED_EXCEPTION (t)
&& (needs_virtual_dtor
|| pending_virtuals != NULL_TREE
|| pending_hard_virtuals != NULL_TREE))
*tail_user_methods = NULL_TREE;
TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
+ if (flag_rtti && (max_has_virtual > 0 || needs_virtual_dtor) &&
+ has_virtual == 0)
+ has_virtual = 1;
if (! fn_fields)
nonprivate_method = 1;
method_vec = finish_struct_methods (t, fn_fields, nonprivate_method);
if (TYPE_HAS_CONSTRUCTOR (t)
- && ! CLASSTYPE_DECLARED_EXCEPTION (t)
&& CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
&& DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
{
DECL_FCONTEXT (vfield) = t;
DECL_FIELD_SIZE (vfield) = 0;
DECL_ALIGN (vfield) = TYPE_ALIGN (ptr_type_node);
- if (CLASSTYPE_DOSSIER (t))
+ if (CLASSTYPE_RTTI (t))
{
/* vfield is always first entry in structure. */
TREE_CHAIN (vfield) = fields;
vbases = CLASSTYPE_VBASECLASSES (t);
CLASSTYPE_N_VBASECLASSES (t) = list_length (vbases);
+ /* The rtti code should do this. (mrs) */
+#if 0
while (vbases)
{
- /* The rtti code should do this. (mrs) */
- /* Update dossier info with offsets for virtual baseclasses. */
- if (flag_dossier && ! BINFO_NEW_VTABLE_MARKED (vbases))
+ /* Update rtti info with offsets for virtual baseclasses. */
+ if (flag_rtti && ! BINFO_NEW_VTABLE_MARKED (vbases))
prepare_fresh_vtable (vbases, t);
vbases = TREE_CHAIN (vbases);
}
+#endif
{
/* Now fixup overrides of all functions in vtables from all
#ifdef NOTQUITE
cp_warning ("Doing hard virtuals for %T...", t);
#endif
+
+ if (has_virtual > max_has_virtual)
+ max_has_virtual = has_virtual;
+ if (max_has_virtual > 0)
+ TYPE_VIRTUAL_P (t) = 1;
+
+ if (flag_rtti && TYPE_VIRTUAL_P (t) && !pending_hard_virtuals)
+ modify_all_vtables (t, NULL_TREE, NULL_TREE);
+
while (pending_hard_virtuals)
{
modify_all_vtables (t,
/* Under our model of GC, every C++ class gets its own virtual
function table, at least virtually. */
- if (pending_virtuals || CLASSTYPE_DOSSIER (t))
+ if (pending_virtuals || (flag_rtti && TYPE_VIRTUAL_P (t)))
{
pending_virtuals = nreverse (pending_virtuals);
/* We must enter these virtuals into the table. */
if (first_vfn_base_index < 0)
{
- if (flag_dossier)
+ if (flag_rtti)
pending_virtuals = tree_cons (NULL_TREE,
- build_vtable_entry (integer_zero_node,
- build_t_desc (t, 0)),
- pending_virtuals);
+ build_vtable_entry (integer_zero_node, build_t_desc (t, 0)),
+ pending_virtuals);
+ else
+ pending_virtuals = tree_cons (NULL_TREE,
+ build_vtable_entry (integer_zero_node, integer_zero_node),
+ pending_virtuals);
+
+#if 0
+ /* The size is no longer used. */
+ /* now we put the size of the vtable as first entry */
pending_virtuals = tree_cons (NULL_TREE, the_null_vtable_entry,
pending_virtuals);
+#endif
build_vtable (NULL_TREE, t);
}
else
if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
build_vtable (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index), t);
- /* Update the dossier pointer for this class. */
- if (flag_dossier)
- TREE_VALUE (TREE_CHAIN (TYPE_BINFO_VIRTUALS (t)))
+ /* Update the rtti pointer for this class. */
+ if (flag_rtti)
+ TREE_VALUE (TYPE_BINFO_VIRTUALS (t))
= build_vtable_entry (integer_zero_node, build_t_desc (t, 0));
}
CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
}
- if (has_virtual > max_has_virtual)
- max_has_virtual = has_virtual;
if (max_has_virtual || first_vfn_base_index >= 0)
{
- TYPE_VIRTUAL_P (t) = 1;
CLASSTYPE_VSIZE (t) = has_virtual;
if (first_vfn_base_index >= 0)
{
else if (TYPE_NEEDS_CONSTRUCTING (t))
build_class_init_list (t);
- if (! CLASSTYPE_DECLARED_EXCEPTION (t) && ! IS_SIGNATURE (t))
+ if (! IS_SIGNATURE (t))
embrace_waiting_friends (t);
/* Write out inline function definitions. */
finish_vtbls (TYPE_BINFO (t), 1, t);
TYPE_BEING_DEFINED (t) = 0;
- if (flag_dossier && CLASSTYPE_VTABLE_NEEDS_WRITING (t))
+ if (flag_rtti && TYPE_VIRTUAL_P (t) && CLASSTYPE_VTABLE_NEEDS_WRITING (t))
{
tree variants;
- tree tdecl;
+ tree tdecl, td;
/* Now instantiate its type descriptors. */
- tdecl = TREE_OPERAND (build_t_desc (t, 1), 0);
+ td = build_t_desc (t, 1);
+ if (td == NULL_TREE)
+ {
+ cp_error ("failed to build type descriptor node of '%T', maybe typeinfo.h not included", t);
+ tdecl = NULL_TREE;
+ }
+ else
+ tdecl = TREE_OPERAND (td, 0);
+
+#if 0
+ /* I see no need for building the following TD */
variants = TYPE_POINTER_TO (t);
build_type_variant (variants, 1, 0);
while (variants)
build_t_desc (variants, 1);
variants = TYPE_NEXT_VARIANT (variants);
}
+#endif
variants = build_reference_type (t);
build_type_variant (variants, 1, 0);
while (variants)
build_t_desc (variants, 1);
variants = TYPE_NEXT_VARIANT (variants);
}
- DECL_CONTEXT (tdecl) = t;
+ if (tdecl != NULL_TREE)
+ DECL_CONTEXT (tdecl) = t;
}
+#if 0
/* Still need to instantiate this C struct's type descriptor. */
- else if (flag_dossier && ! CLASSTYPE_DOSSIER (t))
+ else if (flag_rtti && ! CLASSTYPE_RTTI (t))
build_t_desc (t, 1);
+#endif
#if 0
if (TYPE_NAME (t) && TYPE_IDENTIFIER (t))
if (TREE_CODE (TREE_TYPE (current_class_decl)) == POINTER_TYPE)
{
tree temp;
- /* Can't call build_indirect_ref here, because it has special
- logic to return C_C_D given this argument. */
- C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
+ if (CLASSTYPE_INST_VAR (current_class_type) == NULL_TREE)
+ {
+ /* Can't call build_indirect_ref here, because it has special
+ logic to return C_C_D given this argument. */
+ C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
+ CLASSTYPE_INST_VAR (current_class_type) = C_C_D;
+ }
+ else
+ {
+ C_C_D = CLASSTYPE_INST_VAR (current_class_type);
+ /* `current_class_decl' is different for every
+ function we compile. */
+ TREE_OPERAND (C_C_D, 0) = current_class_decl;
+ }
temp = TREE_TYPE (TREE_TYPE (current_class_decl));
TREE_READONLY (C_C_D) = TYPE_READONLY (temp);
TREE_SIDE_EFFECTS (C_C_D) = TYPE_VOLATILE (temp);
unsigned interface_only : 1;
unsigned interface_unknown : 1;
unsigned needs_virtual_reinit : 1;
- unsigned declared_exception : 1;
+ unsigned vec_delete_takes_size : 1;
unsigned declared_class : 1;
unsigned being_defined : 1;
unsigned redefined : 1;
unsigned has_const_init_ref : 1;
unsigned has_complex_init_ref : 1;
unsigned has_complex_assign_ref : 1;
- unsigned vec_delete_takes_size : 1;
unsigned has_abstract_assign_ref : 1;
/* The MIPS compiler gets it wrong if this struct also
does not fill out to a multiple of 4 bytes. Add a
member `dummy' with new bits if you go over the edge. */
- unsigned dummy : 19;
+ unsigned dummy : 20;
unsigned n_vancestors : 16;
} type_flags;
char *mi_matrix;
union tree_node *conversions[last_conversion_type];
- union tree_node *dossier;
+ union tree_node *rtti;
union tree_node *methods;
signature reference type. */
#define SIGNATURE_REFERENCE_TO(NODE) (TYPE_LANG_SPECIFIC(NODE)->signature_reference_to)
-/* The is the VAR_DECL that contains NODE's dossier. */
-#define CLASSTYPE_DOSSIER(NODE) (TYPE_LANG_SPECIFIC(NODE)->dossier)
+/* 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. */
/* Say whether this node was declared as a "class" or a "struct". */
#define CLASSTYPE_DECLARED_CLASS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_class)
-/* Say whether this node was declared as a "class" or a "struct". */
-#define CLASSTYPE_DECLARED_EXCEPTION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_exception)
/* whether this can be globalized. */
#define CLASSTYPE_NO_GLOBALIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.no_globalize)
unsigned saved_inline : 1;
unsigned use_template : 2;
- unsigned dummy : 8;
+ unsigned interface_known : 1;
+ unsigned declared_static : 1;
+ unsigned nonconverting : 1;
+ unsigned dummy : 5;
tree access;
tree context;
is mutable. */
#define DECL_MUTABLE_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.mutable_flag)
+/* Nonzero for _DECL means that this constructor is a non-converting
+ constructor. */
+#define DECL_NONCONVERTING_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.nonconverting)
+
/* Nonzero for FUNCTION_DECL means that this member function
exists as part of an abstract class's interface. */
#define DECL_ABSTRACT_VIRTUAL_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.abstract_virtual)
#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
(CLASSTYPE_USE_TEMPLATE(NODE) = 3)
+/* We know what we're doing with this decl now. */
+#define DECL_INTERFACE_KNOWN(NODE) \
+ (DECL_LANG_SPECIFIC (NODE)->decl_flags.interface_known)
+
+/* This decl was declared to have internal linkage. */
+#define DECL_DECLARED_STATIC(NODE) \
+ (DECL_LANG_SPECIFIC (NODE)->decl_flags.declared_static)
+
+#define DECL_PUBLIC(NODE) \
+ (TREE_CODE (NODE) == FUNCTION_DECL ? ! DECL_DECLARED_STATIC (NODE) \
+ : TREE_PUBLIC (NODE))
+
#define THUNK_DELTA(DECL) ((DECL)->decl.frame_size.i)
/* ...and for unexpanded-parameterized-type nodes. */
/* An enumeration of the kind of tags that C++ accepts. */
enum tag_types { record_type, class_type, union_type, enum_type,
- exception_type, signature_type };
+ signature_type };
/* Zero means prototype weakly, as in ANSI C (no args means nothing).
Each language context defines how this variable should be set. */
extern tree default_function_type;
extern tree vtable_entry_type;
extern tree sigtable_entry_type;
-extern tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
-extern tree Type_info_type_node;
+extern tree __t_desc_type_node;
+extern tree __tp_desc_type_node;
+extern tree __access_mode_type_node;
+extern tree __bltn_desc_type_node, __user_desc_type_node;
+extern tree __class_desc_type_node, __attr_desc_type_node;
+extern tree __ptr_desc_type_node, __func_desc_type_node;
+extern tree __ptmf_desc_type_node, __ptmd_desc_type_node;
+extern tree type_info_type_node;
extern tree class_star_type_node;
extern tree this_identifier;
extern tree pfn_identifier;
extern tree ptr_type_node, const_ptr_type_node;
extern tree class_type_node, record_type_node, union_type_node, enum_type_node;
-extern tree exception_type_node, unknown_type_node;
+extern tree unknown_type_node;
extern tree opaque_type_node, signature_type_node;
/* Node for "pointer to (virtual) function".
extern tree integer_two_node, integer_three_node;
extern tree bool_type_node, true_node, false_node;
-/* in except.c */
-extern tree current_exception_type;
-extern tree current_exception_decl;
-extern tree current_exception_object;
-
/* in pt.c */
/* PARM_VEC is a vector of template parameters, either IDENTIFIER_NODEs or
PARM_DECLs. BINDINGS, if non-null, is a vector of bindings for those
extern int flag_gc;
-/* Nonzero means generate 'dossiers' that give run-time type information. */
+/* Nonzero means generate 'rtti' that give run-time type information. */
-extern int flag_dossier;
+extern int flag_rtti;
/* Nonzero means do emit exported implementations of functions even if
they can be inlined. */
#define LOOKUP_GLOBAL (16)
#define LOOKUP_HAS_IN_CHARGE (32)
#define LOOKUP_SPECULATIVELY (64)
-/* 128 & 256 are free */
+#define LOOKUP_ONLYCONVERTING (128)
+/* 256 is free */
#define LOOKUP_NO_CONVERSION (512)
#define LOOKUP_DESTRUCTOR (512)
extern int start_function PROTO((tree, tree, tree, int));
extern void store_parm_decls PROTO((void));
extern void store_return_init PROTO((tree, tree));
-extern void finish_function PROTO((int, int));
+extern void finish_function PROTO((int, int, int));
extern tree start_method PROTO((tree, tree, tree));
extern tree finish_method PROTO((tree));
extern void hack_incomplete_structures PROTO((tree));
if (form == REFERENCE_TYPE)
{
- rval = copy_node (expr);
- TREE_TYPE (rval) = build_pointer_type (TREE_TYPE (TREE_TYPE (expr)));
- rval = cp_convert (build_pointer_type (TREE_TYPE (reftype)), rval,
+ tree type = TREE_TYPE (expr);
+ tree tmp = copy_node (expr);
+ TREE_TYPE (tmp) = build_pointer_type (TREE_TYPE (TREE_TYPE (expr)));
+ rval = cp_convert (build_pointer_type (TREE_TYPE (reftype)), tmp,
convtype, flags);
+ TREE_TYPE (tmp) = type;
TREE_TYPE (rval) = reftype;
return rval;
}
&& (rval = build_method_call
(NULL_TREE, constructor_name_full (type),
build_tree_list (NULL_TREE, expr), TYPE_BINFO (type),
- LOOKUP_NO_CONVERSION|LOOKUP_SPECULATIVELY)))
+ LOOKUP_NO_CONVERSION|LOOKUP_SPECULATIVELY
+ | LOOKUP_ONLYCONVERTING)))
{
tree init;
init = build_method_call (t, constructor_name_full (type),
build_tree_list (NULL_TREE, expr),
TYPE_BINFO (type),
- LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
+ LOOKUP_NORMAL|LOOKUP_NO_CONVERSION
+ | LOOKUP_ONLYCONVERTING);
if (init == error_mark_node)
return error_mark_node;
init = build_method_call (NULL_TREE, constructor_name_full (type),
build_tree_list (NULL_TREE, expr),
TYPE_BINFO (type),
- LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
+ LOOKUP_NORMAL|LOOKUP_NO_CONVERSION
+ |LOOKUP_ONLYCONVERTING);
if (init == error_mark_node)
return error_mark_node;
if (IS_AGGR_TYPE_CODE (code))
{
tree dtype = TREE_TYPE (e);
+ tree ctor = NULL_TREE;
+ tree conversion = NULL_TREE;
- if (TREE_CODE (dtype) == REFERENCE_TYPE)
- {
- e = convert_from_reference (e);
- dtype = TREE_TYPE (e);
- }
dtype = TYPE_MAIN_VARIANT (dtype);
/* Conversion of object pointers or signature pointers/references
There may be some ambiguity between using a constructor
vs. using a type conversion operator when both apply. */
- else if (IS_AGGR_TYPE (dtype))
- {
- tree binfo;
-
- tree conversion;
-
- if (! DERIVED_FROM_P (type, dtype) && TYPE_HAS_CONVERSION (dtype))
- conversion = build_type_conversion (CONVERT_EXPR, type, e, 1);
- else
- conversion = NULL_TREE;
-
- if (TYPE_HAS_CONSTRUCTOR (type))
- {
- tree rval = build_method_call (NULL_TREE, constructor_name_full (type),
- build_tree_list (NULL_TREE, e),
- TYPE_BINFO (type),
- conversion ? LOOKUP_NO_CONVERSION : 0);
+ if (IS_AGGR_TYPE (dtype) && ! DERIVED_FROM_P (type, dtype)
+ && TYPE_HAS_CONVERSION (dtype))
+ conversion = build_type_conversion (CONVERT_EXPR, type, e, 1);
- if (rval != error_mark_node)
- {
- if (conversion)
- {
- error ("both constructor and type conversion operator apply");
- return error_mark_node;
- }
- /* call to constructor successful. */
- rval = build_cplus_new (type, rval, 1);
- return rval;
- }
- }
- /* Type conversion successful/applies. */
- if (conversion)
- {
- if (conversion == error_mark_node)
- error ("ambiguous pointer conversion");
- return conversion;
- }
-
- /* now try normal C++ assignment semantics. */
- binfo = TYPE_BINFO (dtype);
- if (BINFO_TYPE (binfo) == type
- || (binfo = get_binfo (type, dtype, 1)))
- {
- if (binfo == error_mark_node)
- return error_mark_node;
- }
- if (binfo != NULL_TREE)
- {
- if (lvalue_p (e))
- {
- e = build_unary_op (ADDR_EXPR, e, 0);
+ if (conversion == error_mark_node)
+ {
+ error ("ambiguous pointer conversion");
+ return conversion;
+ }
- if (! BINFO_OFFSET_ZEROP (binfo))
- e = build (PLUS_EXPR, TYPE_POINTER_TO (type),
- e, BINFO_OFFSET (binfo));
- return build1 (INDIRECT_REF, type, e);
- }
+ if (TYPE_HAS_CONSTRUCTOR (type))
+ ctor = build_method_call (NULL_TREE, constructor_name_full (type),
+ build_tree_list (NULL_TREE, e),
+ TYPE_BINFO (type),
+ LOOKUP_NORMAL | LOOKUP_SPECULATIVELY
+ | LOOKUP_ONLYCONVERTING
+ | (conversion ? LOOKUP_NO_CONVERSION : 0));
- sorry ("addressable aggregates");
- return error_mark_node;
- }
- error ("conversion between incompatible aggregate types requested");
+ if (ctor == error_mark_node)
+ {
+ cp_error ("in conversion to type `%T'", type);
return error_mark_node;
}
- /* conversion from non-aggregate to aggregate type requires
- constructor. */
- else if (TYPE_HAS_CONSTRUCTOR (type))
+
+ if (conversion && ctor)
{
- tree rval;
- tree init = build_method_call (NULL_TREE, constructor_name_full (type),
- build_tree_list (NULL_TREE, e),
- TYPE_BINFO (type), LOOKUP_NORMAL);
- if (init == error_mark_node)
+ error ("both constructor and type conversion operator apply");
+ return error_mark_node;
+ }
+ else if (conversion)
+ return conversion;
+ else if (ctor)
+ {
+ if (current_function_decl)
+ /* We can't pass 1 to the with_cleanup_p arg here, because that
+ screws up passing classes by value. */
+ ctor = build_cplus_new (type, ctor, 0);
+ else
{
- cp_error ("in conversion to type `%T'", type);
- return error_mark_node;
+ register tree parm = TREE_OPERAND (ctor, 1);
+
+ /* Initializers for static variables and parameters
+ have to handle doing the initialization and
+ cleanup themselves. */
+ my_friendly_assert (TREE_CODE (ctor) == CALL_EXPR, 322);
+#if 0
+ /* The following assertion fails in cases where we
+ are initializing a static member variable of a
+ particular instance of a template class with a
+ call to a constructor of the given instance, as
+ in:
+
+ TMPL<int> object = TMPL<int>();
+
+ Curiously, the assertion does not fail if we do
+ the same thing for a static member of a
+ non-template class, as in:
+
+ T object = T();
+
+ I can't see why we should care here whether or not
+ the initializer expression involves a call to
+ `new', so for the time being, it seems best to
+ just avoid doing this assertion. */
+ my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm)),
+ 323);
+#endif
+ TREE_VALUE (parm) = NULL_TREE;
+ ctor = build_indirect_ref (ctor, NULL_PTR);
+ TREE_HAS_CONSTRUCTOR (ctor) = 1;
}
- /* We can't pass 1 to the with_cleanup_p arg here, because that
- screws up passing classes by value. */
- rval = build_cplus_new (type, init, 0);
- return rval;
+ return ctor;
}
}
int flags;
if (for_sure == 0)
- flags = LOOKUP_PROTECT;
+ flags = LOOKUP_PROTECT|LOOKUP_ONLYCONVERTING;
else
- flags = LOOKUP_NORMAL;
+ flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
rval = build_method_call (expr, typename, NULL_TREE, NULL_TREE, flags);
if (rval == error_mark_node)
int flags;
if (for_sure == 0)
- flags = LOOKUP_PROTECT;
+ flags = LOOKUP_PROTECT|LOOKUP_ONLYCONVERTING;
else
- flags = LOOKUP_NORMAL;
+ flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
rval = build_method_call (expr,
constructor_name_full (typename),
NULL_TREE, NULL_TREE, flags);
/* C++ extensions */
tree vtable_entry_type;
tree delta_type_node;
-tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
+#if 0
+/* Old rtti stuff. */
+tree __baselist_desc_type_node;
+tree __i_desc_type_node, __m_desc_type_node;
tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
+#endif
+tree __t_desc_type_node, __tp_desc_type_node;
+tree __access_mode_type_node;
+tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
+tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
+tree __ptmf_desc_type_node, __ptmd_desc_type_node;
+#if 0
+/* Not needed yet? May be needed one day? */
+tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
+tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
+tree __ptmf_desc_array_type, __ptmd_desc_array_type;
+#endif
+
tree class_star_type_node;
tree class_type_node, record_type_node, union_type_node, enum_type_node;
-tree exception_type_node, unknown_type_node;
+tree unknown_type_node;
tree opaque_type_node, signature_type_node;
tree sigtable_entry_type;
tree maybe_gc_cleanup;
TYPE_NAME (type) = name;
/* Do C++ gratuitous typedefing. */
- if (IDENTIFIER_TYPE_VALUE (name) != type
- && (TREE_CODE (type) != RECORD_TYPE
- || b->parm_flag != 2
- || !CLASSTYPE_DECLARED_EXCEPTION (type)))
+ if (IDENTIFIER_TYPE_VALUE (name) != type)
{
register tree d;
int newdecl = 0;
return;
name = DECL_ASSEMBLER_NAME (newdecl);
- if (TREE_PUBLIC (name) && ! TREE_PUBLIC (newdecl))
+ if (TREE_PUBLIC (name) && ! DECL_PUBLIC (newdecl))
{
/* It's okay to redeclare an ANSI built-in function as static,
or to declare a non-ANSI built-in function as anything. */
/* If you declare a built-in or predefined function name as static,
the old definition is overridden, but optionally warn this was a
bad choice of name. Ditto for overloads. */
- if (! TREE_PUBLIC (newdecl)
+ if (! DECL_PUBLIC (newdecl)
|| (TREE_CODE (newdecl) == FUNCTION_DECL
&& DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
{
{
TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
+ TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
- if (TREE_CODE (newdecl) != FUNCTION_DECL)
- TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
+ if (TREE_CODE (newdecl) == FUNCTION_DECL)
+ {
+ DECL_DECLARED_STATIC (newdecl) = DECL_DECLARED_STATIC (olddecl);
+ DECL_INTERFACE_KNOWN (newdecl) = DECL_INTERFACE_KNOWN (olddecl);
+ }
}
else
{
TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
- /* A `const' which was not declared `extern' and is
- in static storage is invisible. */
+ /* A `const' which was not declared `extern' gets internal linkage. */
if (TREE_CODE (newdecl) == VAR_DECL
- && TREE_READONLY (newdecl) && TREE_STATIC (newdecl)
- && ! DECL_THIS_EXTERN (newdecl))
+ && TREE_READONLY (newdecl) && ! DECL_THIS_EXTERN (newdecl))
TREE_PUBLIC (newdecl) = 0;
- else if (TREE_CODE (newdecl) != FUNCTION_DECL)
- TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
- }
+ else
+ {
+ TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
- /* For functions, static overrides non-static. */
- if (TREE_CODE (newdecl) == FUNCTION_DECL)
- {
- TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
- /* This is since we don't automatically
- copy the attributes of NEWDECL into OLDDECL. */
- TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
- /* If this clears `static', clear it in the identifier too. */
- if (! TREE_PUBLIC (olddecl))
- TREE_PUBLIC (DECL_ASSEMBLER_NAME (olddecl)) = 0;
+ /* If this clears PUBLIC, clear it in the identifier too. */
+ if (TREE_CODE (newdecl) == FUNCTION_DECL && ! TREE_PUBLIC (olddecl))
+ TREE_PUBLIC (DECL_ASSEMBLER_NAME (olddecl)) = 0;
+ }
}
/* If either decl says `inline', this fn is inline,
{
DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
+ DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
}
if (TREE_CODE (newdecl) == FUNCTION_DECL)
/* If the first global decl has external linkage,
warn if we later see static one. */
- if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
+ if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && DECL_PUBLIC (x))
TREE_PUBLIC (name) = 1;
/* Don't install a TYPE_DECL if we already have another
if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
return 0;
- /* Declarations of functions can insist on internal linkage
- but they can't be inconsistent with internal linkage,
- so there can be no error on that account.
- However defining the same name twice is no good. */
+ /* We'll complain about linkage mismatches in
+ warn_extern_redeclared_static. */
+
+ /* defining the same name twice is no good. */
if (DECL_INITIAL (olddecl) != NULL_TREE
&& DECL_INITIAL (newdecl) != NULL_TREE
/* However, defining once as extern inline and a second
else if (current_binding_level == global_binding_level)
{
/* Objects declared at top level: */
+ /* Insist that the linkage match. */
+ if (! TREE_PUBLIC (newdecl) && TREE_PUBLIC (olddecl))
+ return "conflicting declarations of `%#D'";
/* If at least one is a reference, it's ok. */
if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
return 0;
- /* Now we have two tentative defs, or one tentative and one real def. */
- /* Insist that the linkage match. */
- if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
- return "conflicting declarations of `%#D'";
/* Reject two definitions. */
return "redefinition of `%#D'";
}
}
}
- if (flag_dossier)
+ if (flag_rtti)
{
if (builtin_type_tdescs_len+5 >= builtin_type_tdescs_max)
{
#endif
gcc_obstack_init (&decl_obstack);
- if (flag_dossier)
+ if (flag_rtti)
{
builtin_type_tdescs_max = 100;
builtin_type_tdescs_arr = (tree *)xmalloc (100 * sizeof (tree));
record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
}
- if (flag_dossier)
+#if 0
+ if (flag_rtti)
{
/* Must build __t_desc type. Currently, type descriptors look like this:
integer_type_node);
}
- /* Now, C++. */
- current_lang_name = lang_name_cplusplus;
- if (flag_dossier)
+ if (flag_rtti)
{
int i = builtin_type_tdescs_len;
while (i > 0)
TREE_PUBLIC (TREE_OPERAND (tdesc, 0)) = 1;
}
}
+#endif /*flag_rtti*/
+
+ /* Now, C++. */
+ current_lang_name = lang_name_cplusplus;
auto_function (ansi_opname[(int) NEW_EXPR],
build_function_type (ptr_type_node,
init_function_format_info ();
}
+/* initialize type descriptor type node of various rtti type. */
+
+int
+init_type_desc()
+{
+ tree tdecl;
+
+ tdecl = lookup_name (get_identifier ("type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __t_desc_type_node = TREE_TYPE(tdecl);
+ __tp_desc_type_node = build_pointer_type (__t_desc_type_node);
+
+#if 0
+ tdecl = lookup_name (get_identifier ("__baselist_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __baselist_desc_type_node = TREE_TYPE (tdecl);
+#endif
+
+ tdecl = lookup_name (get_identifier ("__builtin_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __bltn_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__user_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __user_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__class_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __class_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_field (__class_desc_type_node,
+ get_identifier ("access_mode"), 0, 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __access_mode_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__attr_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __attr_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__pointer_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __ptr_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__func_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __func_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__ptmf_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __ptmf_desc_type_node = TREE_TYPE (tdecl);
+
+ tdecl = lookup_name (get_identifier ("__ptmd_type_info"), 0);
+ if (tdecl == NULL_TREE)
+ return 0;
+ __ptmd_desc_type_node = TREE_TYPE (tdecl);
+
+ return 1;
+}
/* Make a definition for a builtin function named NAME and whose data type
is TYPE. TYPE should be a function type with argument types.
FUNCTION_CODE tells later passes how to compile calls to this function.
tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
+ DECL_INTERFACE_KNOWN (decl) = 1;
/* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
we cannot change DECL_ASSEMBLER_NAME until we have installed this
pop_obstacks ();
}
- /* Interesting work for this is done in `finish_exception_decl'. */
- if (TREE_CODE (type) == RECORD_TYPE
- && CLASSTYPE_DECLARED_EXCEPTION (type))
- return decl;
-
/* Corresponding pop_obstacks is done in `finish_decl'. */
push_obstacks_nochange ();
DECL_ARGUMENTS (decl) = args;
}
d = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), TREE_TYPE (decl));
- if (interface_unknown && flag_external_templates
- && ! DECL_IN_SYSTEM_HEADER (decl))
- warn_if_unknown_interface ();
TREE_PUBLIC (d) = TREE_PUBLIC (decl);
TREE_STATIC (d) = TREE_STATIC (decl);
DECL_EXTERNAL (d) = (DECL_EXTERNAL (decl)
DECL_CONTEXT (decl) == NULL_TREE, 0);
goto finish_end;
}
- if (type != error_mark_node && IS_AGGR_TYPE (type)
- && CLASSTYPE_DECLARED_EXCEPTION (type))
- {
- CLASSTYPE_GOT_SEMICOLON (type) = 1;
- goto finish_end;
- }
if (TREE_CODE (decl) != FUNCTION_DECL)
{
ttype = target_type (type);
else if (toplev && ! TREE_PUBLIC (decl))
{
/* If this is a static const, change its apparent linkage
- if it belongs to a #pragma interface. */
+ if it belongs to a #pragma interface. */
if (!interface_unknown)
{
TREE_PUBLIC (decl) = 1;
DECL_CLASS_CONTEXT (decl) = ctype;
}
+ /* All function decls start out public; we'll fix their linkage later (at
+ definition or EOF) if appropriate. */
+ TREE_PUBLIC (decl) = 1;
+
if (publicp)
- TREE_PUBLIC (decl) = 1;
+ ;
+ else
+ DECL_DECLARED_STATIC (decl) = 1;
DECL_EXTERNAL (decl) = 1;
if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
t = make_lang_type (RECORD_TYPE);
/* Let the front-end know this is a pointer to member function. */
- TYPE_PTRMEMFUNC_FLAG(t) = 1;
+ TYPE_PTRMEMFUNC_FLAG (t) = 1;
/* and not really an aggregate. */
IS_AGGR_TYPE (t) = 0;
try to parse.
PARM for a parameter declaration (either within a function prototype
or before a function body). Make a PARM_DECL, or return void_type_node.
+ CATCHPARM for a parameter declaration before a catch clause.
TYPENAME if for a typename (in a cast or sizeof).
Don't make a DECL node; just return the ..._TYPE node.
FIELD for a struct or union field; make a FIELD_DECL.
int longlong = 0;
int constp;
int volatilep;
- int virtualp, friendp, inlinep, staticp;
+ int virtualp, explicitp, friendp, inlinep, staticp;
int explicit_int = 0;
int explicit_char = 0;
int opaque_typedef = 0;
warning ("duplicate `volatile'");
#endif
virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
+ RIDBIT_RESET (RID_VIRTUAL, specbits);
+ explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
+ RIDBIT_RESET (RID_EXPLICIT, specbits);
if (RIDBIT_SETP (RID_STATIC, specbits))
staticp = 1 + (decl_context == FIELD);
staticp = 0;
}
friendp = RIDBIT_SETP (RID_FRIEND, specbits);
- RIDBIT_RESET (RID_VIRTUAL, specbits);
RIDBIT_RESET (RID_FRIEND, specbits);
if (RIDBIT_SETP (RID_MUTABLE, specbits))
{
if (decl_context == PARM)
{
- error ("non-member `%s' cannot be declared mutable", name);
+ error ("non-member `%s' cannot be declared `mutable'", name);
RIDBIT_RESET (RID_MUTABLE, specbits);
}
else if (friendp || decl_context == TYPENAME)
{
- error ("non-object member `%s' cannot be declared mutable", name);
+ error ("non-object member `%s' cannot be declared `mutable'", name);
RIDBIT_RESET (RID_MUTABLE, specbits);
}
else if (staticp)
{
- error ("static `%s' cannot be declared mutable", name);
+ error ("static `%s' cannot be declared `mutable'", name);
RIDBIT_RESET (RID_MUTABLE, specbits);
}
#if 0
if (RIDBIT_SETP (RID_TYPEDEF, specbits))
{
- error ("non-object member `%s' cannot be declared mutable", name);
+ error ("non-object member `%s' cannot be declared `mutable'", name);
RIDBIT_RESET (RID_MUTABLE, specbits);
}
/* Because local typedefs are parsed twice, we don't want this
message here. */
else if (decl_context != FIELD)
{
- error ("non-member `%s' cannot be declared mutable", name);
+ error ("non-member `%s' cannot be declared `mutable'", name);
RIDBIT_RESET (RID_MUTABLE, specbits);
}
#endif
error ("multiple storage classes in declaration of `%s'", name);
else if (decl_context != NORMAL && nclasses > 0)
{
- if (decl_context == PARM
+ if ((decl_context == PARM || decl_context == CATCHPARM)
&& (RIDBIT_SETP (RID_REGISTER, specbits)
|| RIDBIT_SETP (RID_AUTO, specbits)))
;
op ? operator_name_string (tmp) : name);
}
else
- error ((decl_context == PARM
+ error (((decl_context == PARM || decl_context == CATCHPARM)
? "storage class specified for parameter `%s'"
: "storage class specified for typename"), name);
RIDBIT_RESET (RID_REGISTER, specbits);
}
else /* it's a constructor. */
{
+ if (explicitp == 1)
+ explicitp = 2;
/* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
not be declared const or volatile. A constructor may
not be virtual. A constructor may not be static. */
/* This is the `standard' use of the scoping operator:
basetype :: member . */
- if (TREE_CODE (type) == FUNCTION_TYPE)
+ if (ctype == current_class_type)
+ cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
+ ctype, name);
+ else if (TREE_CODE (type) == FUNCTION_TYPE)
{
if (current_class_type == NULL_TREE
- || TYPE_MAIN_VARIANT (ctype) == current_class_type
|| friendp)
type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
TREE_TYPE (type), TYPE_ARG_TYPES (type));
return void_type_node;
}
}
- else if (TYPE_MAIN_VARIANT (ctype) == current_class_type)
- {
- if (extra_warnings)
- cp_warning ("redundant qualification `%T' on member `%s' ignored",
- ctype, name);
- type = build_offset_type (ctype, type);
- }
else if (TYPE_SIZE (ctype) != NULL_TREE
|| (RIDBIT_SETP (RID_TYPEDEF, specbits)))
{
tree t;
/* have to move this code elsewhere in this function.
- this code is used for i.e., typedef int A::M; M *pm; */
+ this code is used for i.e., typedef int A::M; M *pm;
+
+ It is? How? jason 10/2/94 */
if (explicit_int == -1 && decl_context == FIELD
&& funcdef_flag == 0)
/* Don't include destructor with constructors. */
t = DECL_CHAIN (TREE_VALUE (t));
if (t == NULL_TREE)
- error ("class `%s' does not have any constructors", IDENTIFIER_POINTER (sname));
+ cp_error ("`%T' does not have any constructors",
+ ctype);
t = build_tree_list (NULL_TREE, t);
}
t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
if (current_class_type)
{
- if (TYPE_MAIN_VARIANT (ctype) != current_class_type)
- {
- cp_error ("cannot declare member `%T::%s' within `%T'",
- ctype, name, current_class_type);
- return void_type_node;
- }
- else if (extra_warnings)
- cp_warning ("extra qualification `%T' on member `%s' ignored",
- ctype, name);
+ cp_error ("cannot declare member `%T::%s' within `%T'",
+ ctype, name, current_class_type);
+ return void_type_node;
}
type = build_offset_type (ctype, type);
}
}
}
+ if (explicitp == 1)
+ {
+ error ("only constructors can be declared `explicit'");
+ explicitp = 0;
+ }
+
/* Now TYPE has the actual type. */
/* If this is declaring a typedef name, return a TYPE_DECL. */
return type;
}
else if (declarator == NULL_TREE && decl_context != PARM
+ && decl_context != CATCHPARM
&& TREE_CODE (type) != UNION_TYPE
&& ! bitfield)
{
if (decl == NULL_TREE)
return NULL_TREE;
+ if (explicitp == 2)
+ DECL_NONCONVERTING_P (decl) = 1;
+
DECL_INLINE (decl) = inlinep;
}
else if (TREE_CODE (type) == METHOD_TYPE)
DECL_INLINE (decl) = inlinep;
}
- else if (TREE_CODE (type) == RECORD_TYPE
- && CLASSTYPE_DECLARED_EXCEPTION (type))
- {
- /* Handle a class-local exception declaration. */
- decl = build_lang_field_decl (VAR_DECL, declarator, type);
- if (ctype == NULL_TREE)
- ctype = current_class_type;
- return void_type_node;
- }
else if (TYPE_SIZE (type) == NULL_TREE && !staticp
&& (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
{
- error ("field `%s' has incomplete type",
- IDENTIFIER_POINTER (declarator));
+ cp_error ("field `%D' has incomplete type", declarator);
/* If we're instantiating a template, tell them which
instantiation made the field's type be incomplete. */
&& IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (current_class_type)))
&& declspecs && TREE_VALUE (declspecs)
&& TREE_TYPE (TREE_VALUE (declspecs)) == type)
- error (" in instantiation of template `%s'",
- TYPE_NAME_STRING (current_class_type));
-
+ cp_error (" in instantiation of template `%T'",
+ current_class_type);
+
type = error_mark_node;
decl = NULL_TREE;
}
{
/* It's a variable. */
+ if (decl_context == CATCHPARM)
+ {
+ if (ctype)
+ {
+ ctype = NULL_TREE;
+ error ("cannot use `::' in parameter declaration");
+ }
+
+ /* A parameter declared as an array of T is really a pointer to T.
+ One declared as a function is really a pointer to a function.
+ One declared as a member is really a pointer to member. */
+
+ if (TREE_CODE (type) == ARRAY_TYPE)
+ {
+ /* Transfer const-ness of array into that of type pointed to. */
+ type = build_pointer_type
+ (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
+ volatilep = constp = 0;
+ }
+ else if (TREE_CODE (type) == FUNCTION_TYPE)
+ type = build_pointer_type (type);
+ else if (TREE_CODE (type) == OFFSET_TYPE)
+ type = build_pointer_type (type);
+ }
+
/* An uninitialized decl with `extern' is a reference. */
decl = grokvardecl (type, declarator, specbits, initialized);
bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
{
case record_type:
case class_type:
- case exception_type:
case signature_type:
code = RECORD_TYPE;
len = list_length (binfo);
if (flag_cadillac)
cadillac_start_enum (ref);
}
- else if (tag_code == exception_type)
- {
- ref = make_lang_type (code);
- /* Enable us to recognize when an exception type is created in
- class context. To do nested classes correctly, this should
- probably be cleared out when we leave this class's scope. */
- CLASSTYPE_DECLARED_EXCEPTION (ref) = 1;
- pushtag (name, ref, globalize);
- if (flag_cadillac)
- cadillac_start_struct (ref);
- }
else
{
struct binding_level *old_b = class_binding_level;
}
else
{
- if (IS_AGGR_TYPE_CODE (code))
- {
- if (IS_AGGR_TYPE (ref)
- && ((tag_code == exception_type)
- != (CLASSTYPE_DECLARED_EXCEPTION (ref) == 1)))
- {
- cp_error ("type `%T' is both exception and aggregate type", ref);
- CLASSTYPE_DECLARED_EXCEPTION (ref) = (tag_code == exception_type);
- }
- }
-
/* If it no longer looks like a nested type, make sure it's
in global scope. */
if (b == global_binding_level && !class_binding_level
(This does not mean `static' in the C sense!) */
TREE_STATIC (decl1) = 1;
- /* Record the decl so that the function name is defined.
- If we already have a decl for this name, and it is a FUNCTION_DECL,
- use the old decl. */
-
- if (pre_parsed_p == 0)
- {
- current_function_decl = decl1 = pushdecl (decl1);
- DECL_MAIN_VARIANT (decl1) = decl1;
- fntype = TREE_TYPE (decl1);
- }
- else
- current_function_decl = decl1;
-
+ if (DECL_INTERFACE_KNOWN (decl1))
+ /* We know. */;
/* If this function belongs to an interface, it is public.
If it belongs to someone else's interface, it is also external.
It doesn't matter whether it's inline or not. */
- if (interface_unknown == 0
- && ! TREE_PUBLIC (decl1))
+ else if (interface_unknown == 0)
{
- TREE_PUBLIC (decl1) = 1;
- DECL_EXTERNAL (decl1)
- = (interface_only
- || (DECL_INLINE (decl1) && ! flag_implement_inlines));
+ if (DECL_DECLARED_STATIC (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
+ DECL_EXTERNAL (decl1)
+ = (interface_only
+ || (DECL_INLINE (decl1) && ! flag_implement_inlines));
+ else
+ DECL_EXTERNAL (decl1) = current_extern_inline;
+ DECL_INTERFACE_KNOWN (decl1) = 1;
}
else
{
defining how to inline. So set DECL_EXTERNAL in that case. */
DECL_EXTERNAL (decl1) = current_extern_inline;
- DECL_DEFER_OUTPUT (decl1)
- = DECL_INLINE (decl1) && ! TREE_PUBLIC (decl1)
- && (DECL_FUNCTION_MEMBER_P (decl1)
- || DECL_TEMPLATE_INSTANTIATION (decl1));
+ if (DECL_INLINE (decl1) && (DECL_FUNCTION_MEMBER_P (decl1)
+ || DECL_TEMPLATE_INSTANTIATION (decl1)))
+ /* We know nothing yet */;
+ else
+ {
+ DECL_INTERFACE_KNOWN (decl1) = 1;
+ if (DECL_DECLARED_STATIC (decl1))
+ TREE_PUBLIC (decl1) = 0;
+ }
+
+ DECL_DEFER_OUTPUT (decl1) = ! DECL_INTERFACE_KNOWN (decl1);
}
+ /* Record the decl so that the function name is defined.
+ If we already have a decl for this name, and it is a FUNCTION_DECL,
+ use the old decl. */
+
+ if (pre_parsed_p == 0)
+ {
+ current_function_decl = decl1 = pushdecl (decl1);
+ DECL_MAIN_VARIANT (decl1) = decl1;
+ fntype = TREE_TYPE (decl1);
+ }
+ else
+ current_function_decl = decl1;
+
if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
{
if (TREE_CODE (fntype) == METHOD_TYPE)
}
restype = TREE_TYPE (fntype);
- pushlevel (0);
- current_binding_level->parm_flag = 1;
-
- /* Save the parm names or decls from this function's declarator
- where store_parm_decls will find them. */
- current_function_parms = last_function_parms;
- current_function_parm_tags = last_function_parm_tags;
-
- GNU_xref_function (decl1, current_function_parms);
-
- make_function_rtl (decl1);
-
if (ctype)
{
push_nested_class (ctype, 1);
push_memoized_context (0, 1);
}
+ pushlevel (0);
+ current_binding_level->parm_flag = 1;
+
+ /* Save the parm names or decls from this function's declarator
+ where store_parm_decls will find them. */
+ current_function_parms = last_function_parms;
+ current_function_parm_tags = last_function_parm_tags;
+
+ GNU_xref_function (decl1, current_function_parms);
+
+ make_function_rtl (decl1);
+
/* Allocate further tree nodes temporarily during compilation
of this function only. Tiemann moved up here from bottom of fn. */
temporary_allocation ();
if (flag_gc)
expand_expr (build_function_call (lookup_name (get_identifier ("__gc_main"), 0), NULL_TREE),
0, VOIDmode, 0);
-
- if (flag_dossier)
+#if 0
+ /* done at a differnet time */
+ if (flag_rtti)
output_builtin_tdesc_entries ();
+#endif
}
}
constructors. */
void
-finish_function (lineno, call_poplevel)
+finish_function (lineno, call_poplevel, nested)
int lineno;
int call_poplevel;
+ int nested;
{
register tree fndecl = current_function_decl;
tree fntype, ctype = NULL_TREE;
store_parm_decls ();
}
- if (write_symbols != NO_DEBUG && TREE_CODE (fntype) != METHOD_TYPE)
+ if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
{
tree ttype = target_type (fntype);
tree parmdecl;
expand_label (no_return_label);
}
- /* reset scope for C++: if we were in the scope of a class,
- then when we finish this function, we are not longer so.
- This cannot be done until we know for sure that no more
- class members will ever be referenced in this function
- (i.e., calls to destructors). */
- if (current_class_name)
- {
- ctype = current_class_type;
- pop_nested_class (1);
- }
- else
- pop_memoized_context (1);
-
/* Generate rtl for function exit. */
expand_function_end (input_filename, lineno, 1);
my_friendly_abort (122);
poplevel (1, 0, 1);
+ /* reset scope for C++: if we were in the scope of a class,
+ then when we finish this function, we are not longer so.
+ This cannot be done until we know for sure that no more
+ class members will ever be referenced in this function
+ (i.e., calls to destructors). */
+ if (current_class_name)
+ {
+ ctype = current_class_type;
+ pop_nested_class (1);
+ }
+ else
+ pop_memoized_context (1);
+
/* Must mark the RESULT_DECL as being in this function. */
DECL_CONTEXT (DECL_RESULT (fndecl)) = DECL_INITIAL (fndecl);
/* Free all the tree nodes making up this function. */
/* Switch back to allocating nodes permanently
until we start another function. */
- permanent_allocation (1);
+ if (! nested)
+ permanent_allocation (1);
if (flag_cadillac)
cadillac_finish_function (fndecl);
decl);
}
}
+ /*
my_friendly_assert (current_binding_level->n_incomplete > 0, 164);
+ */
--current_binding_level->n_incomplete;
}
}
{
return !!purpose_member (id, class_binding_level->class_shadowed);
}
+
+struct cp_function
+{
+ int returns_value;
+ int returns_null;
+ int warn_about_return_type;
+ int extern_inline;
+ int assigns_this;
+ int just_assigned_this;
+ int parms_stored;
+ tree named_labels;
+ tree shadowed_labels;
+ tree ctor_label;
+ tree dtor_label;
+ rtx result_rtx;
+ struct cp_function *next;
+ struct binding_level *binding_level;
+};
+
+struct cp_function *cp_function_chain;
+
+/* Save and reinitialize the variables
+ used during compilation of a C++ function. */
+
+void
+push_cp_function_context (toplev)
+ int toplev;
+{
+ struct cp_function *p
+ = (struct cp_function *) xmalloc (sizeof (struct cp_function));
+
+ push_function_context_to (toplev);
+
+ p->next = cp_function_chain;
+ cp_function_chain = p;
+
+ p->named_labels = named_labels;
+ p->shadowed_labels = shadowed_labels;
+ p->returns_value = current_function_returns_value;
+ p->returns_null = current_function_returns_null;
+ p->warn_about_return_type = warn_about_return_type;
+ p->extern_inline = current_extern_inline;
+ p->binding_level = current_binding_level;
+ p->ctor_label = ctor_label;
+ p->dtor_label = dtor_label;
+ p->assigns_this = current_function_assigns_this;
+ p->just_assigned_this = current_function_just_assigned_this;
+ p->parms_stored = current_function_parms_stored;
+ p->result_rtx = original_result_rtx;
+}
+
+/* Restore the variables used during compilation of a C++ function. */
+
+void
+pop_cp_function_context (toplev)
+ int toplev;
+{
+ struct cp_function *p = cp_function_chain;
+ tree link;
+
+ /* Bring back all the labels that were shadowed. */
+ for (link = shadowed_labels; link; link = TREE_CHAIN (link))
+ if (DECL_NAME (TREE_VALUE (link)) != 0)
+ SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)),
+ TREE_VALUE (link));
+
+#if 0
+ if (DECL_SAVED_INSNS (current_function_decl) == 0)
+ {
+ /* Stop pointing to the local nodes about to be freed. */
+ /* But DECL_INITIAL must remain nonzero so we know this
+ was an actual function definition. */
+ DECL_INITIAL (current_function_decl) = error_mark_node;
+ DECL_ARGUMENTS (current_function_decl) = 0;
+ }
+#endif
+
+ pop_function_context_from (toplev);
+
+ cp_function_chain = p->next;
+
+ named_labels = p->named_labels;
+ shadowed_labels = p->shadowed_labels;
+ current_function_returns_value = p->returns_value;
+ current_function_returns_null = p->returns_null;
+ warn_about_return_type = p->warn_about_return_type;
+ current_extern_inline = p->extern_inline;
+ current_binding_level = p->binding_level;
+ ctor_label = p->ctor_label;
+ dtor_label = p->dtor_label;
+ current_function_assigns_this = p->assigns_this;
+ current_function_just_assigned_this = p->just_assigned_this;
+ current_function_parms_stored = p->parms_stored;
+ original_result_rtx = p->result_rtx;
+
+ free (p);
+}
{ NORMAL, /* Ordinary declaration */
FUNCDEF, /* Function definition */
PARM, /* Declaration of parm before function body */
+ CATCHPARM, /* Declaration of catch parm */
FIELD, /* Declaration inside struct or union */
BITFIELD, /* Likewise but with specified width */
TYPENAME, /* Typename (inside cast or sizeof) */
that can be collected when they become garbage. */
int flag_gc;
-/* Controls whether compiler generates 'dossiers' that give
+/* Controls whether compiler generates 'type descriptor' that give
run-time type information. */
-int flag_dossier;
+int flag_rtti = 0;
/* Nonzero if we wish to output cross-referencing information
for the GNU class browser. */
{"dollars-in-identifiers", &dollars_in_ident, 1},
{"enum-int-equiv", &flag_int_enum_equivalence, 1},
{"gc", &flag_gc, 1},
- {"dossier", &flag_dossier, 1},
+ {"rtti", &flag_rtti, 1},
{"xref", &flag_gnu_xref, 1},
{"nonnull-objects", &flag_assume_nonnull_objects, 1},
{"implement-inlines", &flag_implement_inlines, 1},
{
flag_gc = 1;
/* This must come along for the ride. */
- flag_dossier = 1;
+ flag_rtti = 1;
found = 1;
}
else if (! strcmp (p, "no-gc"))
{
flag_gc = 0;
/* This must come along for the ride. */
- flag_dossier = 0;
+ flag_rtti = 0;
found = 1;
}
else if (! strcmp (p, "alt-external-templates"))
tcode = class_type_node;
else if (IS_SIGNATURE(t))
tcode = signature_type_node;
- else if (CLASSTYPE_DECLARED_EXCEPTION(t))
- tcode = exception_type_node;
t = xref_defn_tag(tcode, TYPE_IDENTIFIER(t), NULL_TREE);
if (TYPE_CONTEXT(t))
CLASSTYPE_NO_GLOBALIZE(t) = 1;
- if (TYPE_LANG_SPECIFIC (t)
- && CLASSTYPE_DECLARED_EXCEPTION (t))
- shadow_tag (specs);
return NULL_TREE;
break;
if (TREE_VALUE (init) == integer_zero_node
&& TREE_CHAIN (init) == NULL_TREE)
{
+#if 0
if (empty_table == NULL_TREE)
+#endif
{
empty_table = get_temp_name (atype, 1);
init = build (CONSTRUCTOR, atype, NULL_TREE, init);
{
tree entries = TREE_CHAIN (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)));
- if (flag_dossier)
- entries = TREE_CHAIN (entries);
-
for (; entries; entries = TREE_CHAIN (entries))
{
tree fnaddr = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries));
/* Stuff this virtual function table's size into
`pfn' slot of `the_null_vtable_entry'. */
+#if 0
+ /* we do not put size as first entry any more */
tree nelts = array_type_nelts (TREE_TYPE (vars));
if (flag_vtable_thunks)
TREE_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (vars))) = nelts;
else
SET_FNADDR_FROM_VTABLE_ENTRY (the_null_vtable_entry, nelts);
- /* Kick out the dossier before writing out the vtable. */
- if (flag_dossier)
- rest_of_decl_compilation (TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (DECL_INITIAL (vars))))), 0), 0, 1, 1);
+#endif
+
+ /* Kick out the type descriptor before writing out the vtable. */
+ if (flag_rtti)
+ rest_of_decl_compilation (TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (vars)))), 0), 0, 1, 1);
/* Write it out. */
mark_vtable_entries (vars);
import_export_inline (decl)
tree decl;
{
- if (TREE_PUBLIC (decl))
+ if (DECL_INTERFACE_KNOWN (decl))
return;
- /* If an explicit instantiation doesn't have TREE_PUBLIC set, it was with
- 'extern'. */
- if (DECL_EXPLICIT_INSTANTIATION (decl)
- || (DECL_IMPLICIT_INSTANTIATION (decl) && ! flag_implicit_templates))
+ if (DECL_TEMPLATE_INSTANTIATION (decl))
{
- TREE_PUBLIC (decl) = 1;
- DECL_EXTERNAL (decl) = 1;
+ if (DECL_IMPLICIT_INSTANTIATION (decl) && flag_implicit_templates)
+ TREE_PUBLIC (decl) = 0;
+ else
+ DECL_EXTERNAL (decl) = 1;
}
else if (DECL_FUNCTION_MEMBER_P (decl))
{
tree ctype = DECL_CLASS_CONTEXT (decl);
if (CLASSTYPE_INTERFACE_KNOWN (ctype))
{
- TREE_PUBLIC (decl) = 1;
DECL_EXTERNAL (decl)
= (CLASSTYPE_INTERFACE_ONLY (ctype)
|| (DECL_INLINE (decl) && ! flag_implement_inlines));
}
+ else
+ TREE_PUBLIC (decl) = 0;
}
+ else
+ TREE_PUBLIC (decl) = 0;
}
-
+
extern int parse_time, varconst_time;
#define TIMEVAR(VAR, BODY) \
poplevel (1, 0, 0);
pop_momentary ();
- finish_function (lineno, 0);
+ finish_function (lineno, 0, 0);
assemble_destructor (IDENTIFIER_POINTER (fnname));
poplevel (1, 0, 0);
pop_momentary ();
- finish_function (lineno, 0);
+ finish_function (lineno, 0, 0);
assemble_constructor (IDENTIFIER_POINTER (fnname));
}
pushdecl (vars);
#endif
+ interface_unknown = 1;
+ interface_only = 0;
+
+ for (vars = saved_inlines; vars; vars = TREE_CHAIN (vars))
+ {
+ tree decl = TREE_VALUE (vars);
+
+ if (DECL_ARTIFICIAL (decl)
+ && ! DECL_INITIAL (decl)
+ && (TREE_USED (decl) || ! DECL_EXTERNAL (decl)))
+ synthesize_method (decl);
+ }
+
walk_vtables ((void (*)())0, finish_vtable_vardecl);
if (flag_handle_signatures)
walk_sigtables ((void (*)())0, finish_sigtable_vardecl);
+ for (vars = saved_inlines; vars; vars = TREE_CHAIN (vars))
+ {
+ tree decl = TREE_VALUE (vars);
+
+ if (DECL_ARTIFICIAL (decl)
+ && ! DECL_INITIAL (decl)
+ && TREE_USED (decl))
+ synthesize_method (decl);
+ }
+
for (vars = getdecls (); vars; vars = TREE_CHAIN (vars))
{
if (TREE_CODE (vars) == THUNK_DECL)
emit_thunk (vars);
+ else if (TREE_CODE (vars) == FUNCTION_DECL
+ && ! DECL_INTERFACE_KNOWN (vars)
+ && DECL_DECLARED_STATIC (vars))
+ TREE_PUBLIC (vars) = 0;
}
+ /* Now write out inline functions which had their addresses taken and
+ which were not declared virtual and which were not declared `extern
+ inline'. */
{
- int reconsider = 0; /* More may be referenced; check again */
- tree delayed = NULL_TREE; /* These might be referenced later */
+ int reconsider = 1; /* More may be referenced; check again */
+ saved_inlines = tree_cons (NULL_TREE, NULL_TREE, saved_inlines);
- /* Now write out inline functions which had their addresses taken and
- which were not declared virtual and which were not declared `extern
- inline'. */
- while (saved_inlines)
+ while (reconsider)
{
- tree decl = TREE_VALUE (saved_inlines);
- saved_inlines = TREE_CHAIN (saved_inlines);
- /* Redefinition of a member function can cause DECL_SAVED_INSNS to be
- 0; don't crash. */
- if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0)
- continue;
- import_export_inline (decl);
- if (TREE_PUBLIC (decl)
- || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
- || flag_keep_inline_functions)
+ tree last = saved_inlines;
+ tree place = TREE_CHAIN (saved_inlines);
+ reconsider = 0;
+
+ for (; place; place = TREE_CHAIN (place))
{
- if (DECL_EXTERNAL (decl))
- assemble_external (decl);
- else
+ tree decl = TREE_VALUE (place);
+
+ if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0)
{
- reconsider = 1;
- temporary_allocation ();
- output_inline_function (decl);
- permanent_allocation (1);
+ TREE_CHAIN (last) = TREE_CHAIN (place);
+ continue;
}
- }
- else if (TREE_USED (decl)
- || TREE_USED (DECL_ASSEMBLER_NAME (decl)))
- delayed = tree_cons (NULL_TREE, decl, delayed);
- }
-
- if (reconsider && delayed)
- {
- while (reconsider)
- {
- tree place;
- reconsider = 0;
- for (place = delayed; place; place = TREE_CHAIN (place))
+ import_export_inline (decl);
+ if (TREE_PUBLIC (decl)
+ || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
+ || flag_keep_inline_functions)
{
- tree decl = TREE_VALUE (place);
- if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
- && ! TREE_ASM_WRITTEN (decl))
+ TREE_CHAIN (last) = TREE_CHAIN (place);
+
+ if (DECL_EXTERNAL (decl))
+ assemble_external (decl);
+ else
{
- if (DECL_EXTERNAL (decl))
- assemble_external (decl);
- else
- {
- reconsider = 1;
- temporary_allocation ();
- output_inline_function (decl);
- permanent_allocation (1);
- }
+ reconsider = 1;
+ temporary_allocation ();
+ output_inline_function (decl);
+ permanent_allocation (1);
}
+
+ continue;
}
+
+ last = place;
}
}
}
#define TRY_NEW_EH
#endif
#endif
+#if defined(__i386) || defined(__rs6000) || defined(__hppa)
+#define TRY_NEW_EH
+#endif
#endif
#ifndef TRY_NEW_EH
expand_asm (build_string (strlen (str)+1, str));
}
-/* unwind the stack. */
-static void
-do_unwind (throw_label)
- rtx throw_label;
-{
-#ifdef sparc
- extern FILE *asm_out_file;
- tree fcall;
- tree params;
- rtx return_val_rtx;
-
- /* call to __builtin_return_address () */
- params=tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
- fcall = build_function_call (BuiltinReturnAddress, params);
- return_val_rtx = expand_expr (fcall, NULL_RTX, SImode, 0);
- /* In the return, the new pc is pc+8, as the value comming in is
- really the address of the call insn, not the next insn. */
- emit_move_insn (return_val_rtx, plus_constant(gen_rtx (LABEL_REF,
- Pmode,
- throw_label), -8));
- /* We use three values, PC, type, and value */
- easy_expand_asm ("st %l0,[%fp]");
- easy_expand_asm ("st %l1,[%fp+4]");
- easy_expand_asm ("st %l2,[%fp+8]");
- easy_expand_asm ("ret");
- easy_expand_asm ("restore");
- emit_barrier ();
-#endif
-#if m88k
- rtx temp_frame = frame_pointer_rtx;
-
- temp_frame = memory_address (Pmode, temp_frame);
- temp_frame = copy_to_reg (gen_rtx (MEM, Pmode, temp_frame));
-
- /* hopefully this will successfully pop the frame! */
- emit_move_insn (frame_pointer_rtx, temp_frame);
- emit_move_insn (stack_pointer_rtx, frame_pointer_rtx);
- emit_move_insn (arg_pointer_rtx, frame_pointer_rtx);
- emit_insn (gen_add2_insn (stack_pointer_rtx, gen_rtx (CONST_INT, VOIDmode,
- (HOST_WIDE_INT)m88k_debugger_offset (stack_pointer_rtx, 0))));
-
-#if 0
- emit_insn (gen_add2_insn (arg_pointer_rtx, gen_rtx (CONST_INT, VOIDmode,
- -(HOST_WIDE_INT)m88k_debugger_offset (arg_pointer_rtx, 0))));
-
- emit_move_insn (stack_pointer_rtx, arg_pointer_rtx);
-
- emit_insn (gen_add2_insn (stack_pointer_rtx, gen_rtx (CONST_INT, VOIDmode,
- (HOST_WIDE_INT)m88k_debugger_offset (arg_pointer_rtx, 0))));
-#endif
-#endif
-}
-
-
#if 0
/* This is the startup, and finish stuff per exception table. */
pop_lang_context ();
throw_label = gen_label_rtx ();
+#ifdef sparc
saved_pc = gen_rtx (REG, Pmode, 16);
saved_throw_type = gen_rtx (REG, Pmode, 17);
saved_throw_value = gen_rtx (REG, Pmode, 18);
-
+#endif
+#ifdef __i386
+ saved_pc = gen_rtx (REG, Pmode, 3);
+ saved_throw_type = gen_rtx (REG, Pmode, 4);
+ saved_throw_value = gen_rtx (REG, Pmode, 5);
+#endif
+#ifdef __rs6000
+ saved_pc = gen_rtx (REG, Pmode, 12);
+ saved_throw_type = gen_rtx (REG, Pmode, 13);
+ saved_throw_value = gen_rtx (REG, Pmode, 14);
+#endif
+#ifdef __hppa
+ saved_pc = gen_rtx (REG, Pmode, 5);
+ saved_throw_type = gen_rtx (REG, Pmode, 6);
+ saved_throw_value = gen_rtx (REG, Pmode, 7);
+#endif
new_eh_queue (&ehqueue);
new_eh_queue (&eh_table_output_queue);
new_eh_stack (&ehstack);
if (declspecs)
{
tree init_type;
- decl = grokdeclarator (declarator, declspecs, NORMAL, 1, NULL_TREE);
+ decl = grokdeclarator (declarator, declspecs, CATCHPARM, 1, NULL_TREE);
/* Figure out the type that the initializer is. */
init_type = TREE_TYPE (decl);
return NULL_RTX;
}
+/* unwind the stack. */
+static void
+do_unwind (throw_label)
+ rtx throw_label;
+{
+#ifdef sparc
+ extern FILE *asm_out_file;
+ tree fcall;
+ tree params;
+ rtx return_val_rtx;
+
+ /* call to __builtin_return_address () */
+ params=tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
+ fcall = build_function_call (BuiltinReturnAddress, params);
+ return_val_rtx = expand_expr (fcall, NULL_RTX, SImode, 0);
+ /* In the return, the new pc is pc+8, as the value comming in is
+ really the address of the call insn, not the next insn. */
+ emit_move_insn (return_val_rtx, plus_constant(gen_rtx (LABEL_REF,
+ Pmode,
+ throw_label), -8));
+ /* We use three values, PC, type, and value */
+ easy_expand_asm ("st %l0,[%fp]");
+ easy_expand_asm ("st %l1,[%fp+4]");
+ easy_expand_asm ("st %l2,[%fp+8]");
+ easy_expand_asm ("ret");
+ easy_expand_asm ("restore");
+ emit_barrier ();
+#endif
+#if defined(__i386) || defined(__rs6000) || defined(__hppa)
+ extern FILE *asm_out_file;
+ tree fcall;
+ tree params;
+ rtx return_val_rtx;
+
+ /* call to __builtin_return_address () */
+ params=tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
+ fcall = build_function_call (BuiltinReturnAddress, params);
+ return_val_rtx = expand_expr (fcall, NULL_RTX, SImode, 0);
+#if 0
+ /* I would like to do this here, but doesn't seem to work. */
+ emit_move_insn (return_val_rtx, gen_rtx (LABEL_REF,
+ Pmode,
+ throw_label));
+ /* So, for now, just pass throw label to stack unwinder. */
+#endif
+ /* We use three values, PC, type, and value */
+ params = tree_cons (NULL_TREE, make_tree (ptr_type_node,
+ gen_rtx (LABEL_REF, Pmode, throw_label)), NULL_TREE);
+
+ do_function_call (Unwind, params, NULL_TREE);
+ emit_barrier ();
+#endif
+#if m88k
+ rtx temp_frame = frame_pointer_rtx;
+
+ temp_frame = memory_address (Pmode, temp_frame);
+ temp_frame = copy_to_reg (gen_rtx (MEM, Pmode, temp_frame));
+
+ /* hopefully this will successfully pop the frame! */
+ emit_move_insn (frame_pointer_rtx, temp_frame);
+ emit_move_insn (stack_pointer_rtx, frame_pointer_rtx);
+ emit_move_insn (arg_pointer_rtx, frame_pointer_rtx);
+ emit_insn (gen_add2_insn (stack_pointer_rtx, gen_rtx (CONST_INT, VOIDmode,
+ (HOST_WIDE_INT)m88k_debugger_offset (stack_pointer_rtx, 0))));
+
+#if 0
+ emit_insn (gen_add2_insn (arg_pointer_rtx, gen_rtx (CONST_INT, VOIDmode,
+ -(HOST_WIDE_INT)m88k_debugger_offset (arg_pointer_rtx, 0))));
+
+ emit_move_insn (stack_pointer_rtx, arg_pointer_rtx);
+
+ emit_insn (gen_add2_insn (stack_pointer_rtx, gen_rtx (CONST_INT, VOIDmode,
+ (HOST_WIDE_INT)m88k_debugger_offset (arg_pointer_rtx, 0))));
+#endif
+#endif
+}
/* is called from expand_excpetion_blocks () to generate the code in a function
to "throw" if anything in the function needs to preform a throw.
emit_jump_insn (gen_beq (gotta_call_terminate));
+#ifndef sparc
+ /* On the SPARC, __builtin_return_address is already -8, no need to
+ subtract any more from it. */
+ emit_insn (gen_add2_insn (return_val_rtx, GEN_INT (-1)));
+#endif
+
/* yes it did */
emit_move_insn (saved_pc, return_val_rtx);
do_unwind (throw_label);
{
static int have_done = 0;
if (! have_done && TREE_PUBLIC (current_function_decl)
- && ! DECL_INLINE (current_function_decl))
+ && DECL_INTERFACE_KNOWN (current_function_decl)
+ && ! DECL_EXTERNAL (current_function_decl))
{
have_done = 1;
expand_builtin_throw ();
rtx throw_value_rtx;
emit_move_insn (saved_throw_type, throw_type_rtx);
- exp = convert_to_reference (build_reference_type (build_type_variant (TREE_TYPE (exp), 1, 0)), exp, CONV_STATIC, LOOKUP_COMPLAIN, NULL_TREE);
+ exp = convert_to_reference (build_reference_type (build_type_variant (TREE_TYPE (exp), 1, 0)), exp, CONV_STATIC, LOOKUP_COMPLAIN, error_mark_node);
if (exp == error_mark_node)
error (" in thrown expression");
throw_value_rtx = expand_expr (build_unary_op (ADDR_EXPR, exp, 0), NULL_RTX, VOIDmode, 0);
/* Beginning marker for table. */
ASM_OUTPUT_ALIGN (asm_out_file, 2);
ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_TABLE__");
- fprintf (asm_out_file, " .word 0, 0, 0\n");
+ output_exception_table_entry (asm_out_file,
+ const0_rtx, const0_rtx, const0_rtx);
}
count++;
output_exception_table_entry (asm_out_file,
{
/* Ending marker for table. */
ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_END__");
- fprintf (asm_out_file, " .word -1, -1, -1\n");
+ output_exception_table_entry (asm_out_file,
+ constm1_rtx, constm1_rtx, constm1_rtx);
}
#endif /* TRY_NEW_EH */
build_throw (e)
tree e;
{
- e = build1 (THROW_EXPR, void_type_node, e);
- TREE_SIDE_EFFECTS (e) = 1;
+ if (e != error_mark_node)
+ {
+ e = build1 (THROW_EXPR, void_type_node, e);
+ TREE_SIDE_EFFECTS (e) = 1;
+ }
return e;
}
__volatile__, TYPE_QUAL, RID_VOLATILE
__wchar_t, TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,
asm, ASM_KEYWORD, NORID,
+and, ANDAND, NORID,
+and_eq, ASSIGN, NORID,
auto, SCSPEC, RID_AUTO,
+bitand, '&', NORID,
+bitor, '|', NORID,
bool, TYPESPEC, RID_BOOL,
break, BREAK, NORID,
case, CASE, NORID,
char, TYPESPEC, RID_CHAR,
class, AGGR, RID_CLASS,
classof, CLASSOF, NORID,
+compl, '~', NORID,
const, TYPE_QUAL, RID_CONST,
const_cast, CONST_CAST, NORID,
continue, CONTINUE, NORID,
dynamic_cast, DYNAMIC_CAST, NORID,
else, ELSE, NORID,
enum, ENUM, NORID,
+explicit, SCSPEC, RID_EXPLICIT,
extern, SCSPEC, RID_EXTERN,
false, CXX_FALSE, NORID,
float, TYPESPEC, RID_FLOAT,
int, TYPESPEC, RID_INT,
long, TYPESPEC, RID_LONG,
mutable, SCSPEC, RID_MUTABLE,
+namespace, NAMESPACE, NORID,
new, NEW, NORID,
+not, '!', NORID,
+not_eq, EQCOMPARE, NORID,
operator, OPERATOR, NORID,
+or, OROR, NORID,
+or_eq, ASSIGN, NORID,
overload, OVERLOAD, NORID,
private, VISSPEC, RID_PRIVATE,
protected, VISSPEC, RID_PROTECTED,
static_cast, STATIC_CAST, NORID,
struct, AGGR, RID_RECORD,
switch, SWITCH, NORID,
+template, TEMPLATE, RID_TEMPLATE,
this, THIS, NORID,
throw, THROW, NORID,
-template, TEMPLATE, RID_TEMPLATE,
true, CXX_TRUE, NORID,
try, TRY, NORID,
typedef, SCSPEC, RID_TYPEDEF,
-typeof, TYPEOF, NORID,
+typename, TYPENAME_KEYWORD, NORID,
typeid, TYPEID, NORID,
+typeof, TYPEOF, NORID,
union, AGGR, RID_UNION,
unsigned, TYPESPEC, RID_UNSIGNED,
+using, USING, NORID,
virtual, SCSPEC, RID_VIRTUAL,
void, TYPESPEC, RID_VOID,
volatile, TYPE_QUAL, RID_VOLATILE,
while, WHILE, NORID,
+xor, '^', NORID,
+xor_eq, ASSIGN, NORID,
block. When is unwinds down into a handler, the frame pointer is
adjusted back to the normal value for the frame in which the handler
resides, and the stack pointer is left unchanged from the time at which
-the object was throwed. This is so that there is always someplace for
+the object was thrown. This is so that there is always someplace for
the exception object, and nothing can overwrite it, once we start
throwing. The only bad part, is that the stack remains large.
/* C code produced by gperf version 2.5 (GNU C++ version) */
-/* Command-line: gperf -p -j1 -g -o -t -N is_reserved_word -k1,4,7,$ /deneb/blob/jason/g++/small/devo/gcc/cp/gxx.gperf */
+/* Command-line: gperf -p -j1 -g -o -t -N is_reserved_word -k1,4,7,$ ../../../devo/gcc/cp/gxx.gperf */
/* Command-line: gperf -p -j1 -g -o -t -N is_reserved_word -k1,4,$,7 gplus.gperf */
struct resword { char *name; short token; enum rid rid;};
-#define TOTAL_KEYWORDS 86
+#define TOTAL_KEYWORDS 101
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 16
#define MIN_HASH_VALUE 4
-#define MAX_HASH_VALUE 171
-/* maximum key range = 168, duplicates = 0 */
+#define MAX_HASH_VALUE 210
+/* maximum key range = 207, duplicates = 0 */
#ifdef __GNUC__
inline
{
static unsigned char asso_values[] =
{
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
- 172, 172, 172, 172, 172, 0, 172, 36, 1, 61,
- 0, 0, 30, 44, 44, 35, 172, 7, 12, 53,
- 40, 17, 6, 172, 28, 2, 4, 35, 31, 51,
- 5, 7, 172, 172, 172, 172, 172, 172,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
+ 211, 211, 211, 211, 211, 0, 211, 35, 1, 69,
+ 61, 0, 19, 65, 20, 100, 211, 5, 11, 52,
+ 3, 25, 6, 2, 31, 26, 4, 41, 24, 64,
+ 10, 24, 211, 211, 211, 211, 211, 211,
};
register int hval = len;
{
{"",}, {"",}, {"",}, {"",},
{"else", ELSE, NORID,},
- {"",},
- {"delete", DELETE, NORID,},
- {"double", TYPESPEC, RID_DOUBLE,},
+ {"",}, {"",}, {"",},
{"true", CXX_TRUE, NORID,},
- {"__asm__", GCC_ASM_KEYWORD, NORID},
- {"typeid", TYPEID, NORID,},
- {"",},
- {"this", THIS, NORID,},
+ {"extern", SCSPEC, RID_EXTERN,},
+ {"not", '!', NORID,},
+ {"not_eq", EQCOMPARE, NORID,},
+ {"",}, {"",},
+ {"__inline", SCSPEC, RID_INLINE},
{"",},
- {"try", TRY, NORID,},
- {"",}, {"",}, {"",}, {"",},
- {"do", DO, NORID,},
+ {"__inline__", SCSPEC, RID_INLINE},
{"",},
- {"static_cast", STATIC_CAST, NORID,},
+ {"xor_eq", ASSIGN, NORID,},
+ {"",}, {"",}, {"",},
{"template", TEMPLATE, RID_TEMPLATE,},
- {"protected", VISSPEC, RID_PROTECTED,},
+ {"",}, {"",},
+ {"__alignof__", ALIGNOF, NORID},
+ {"__extension__", EXTENSION, NORID},
+ {"bool", TYPESPEC, RID_BOOL,},
{"",},
- {"__classof__", CLASSOF, NORID},
+ {"typeof", TYPEOF, NORID,},
+ {"",},
+ {"try", TRY, NORID,},
+ {"or_eq", ASSIGN, NORID,},
+ {"__asm__", GCC_ASM_KEYWORD, NORID},
{"",},
{"__headof__", HEADOF, NORID},
{"",},
- {"bool", TYPESPEC, RID_BOOL,},
+ {"private", VISSPEC, RID_PRIVATE,},
{"__const__", TYPE_QUAL, RID_CONST},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"__const", TYPE_QUAL, RID_CONST},
{"__volatile__", TYPE_QUAL, RID_VOLATILE},
- {"__typeof__", TYPEOF, NORID},
- {"void", TYPESPEC, RID_VOID,},
- {"friend", SCSPEC, RID_FRIEND,},
+ {"__alignof", ALIGNOF, NORID},
+ {"and_eq", ASSIGN, NORID,},
+ {"xor", '^', NORID,},
+ {"static_cast", STATIC_CAST, NORID,},
+ {"break", BREAK, NORID,},
+ {"namespace", NAMESPACE, NORID,},
+ {"__classof__", CLASSOF, NORID},
+ {"typedef", SCSPEC, RID_TYPEDEF,},
{"false", CXX_FALSE, NORID,},
{"sizeof", SIZEOF, NORID,},
- {"short", TYPESPEC, RID_SHORT,},
- {"typeof", TYPEOF, NORID,},
- {"",},
- {"int", TYPESPEC, RID_INT,},
- {"__signed", TYPESPEC, RID_SIGNED},
- {"private", VISSPEC, RID_PRIVATE,},
- {"__signed__", TYPESPEC, RID_SIGNED},
- {"extern", SCSPEC, RID_EXTERN,},
- {"struct", AGGR, RID_RECORD,},
- {"signed", TYPESPEC, RID_SIGNED,},
- {"break", BREAK, NORID,},
- {"__attribute", ATTRIBUTE, NORID},
- {"default", DEFAULT, NORID,},
- {"__attribute__", ATTRIBUTE, NORID},
- {"__classof", CLASSOF, NORID},
- {"sigof", SIGOF, NORID /* Extension */,},
{"__headof", HEADOF, NORID},
- {"switch", SWITCH, NORID,},
- {"__label__", LABEL, NORID},
- {"__extension__", EXTENSION, NORID},
- {"",},
- {"__asm", GCC_ASM_KEYWORD, NORID},
{"for", FOR, NORID,},
- {"__typeof", TYPEOF, NORID},
- {"__alignof__", ALIGNOF, NORID},
{"",},
- {"case", CASE, NORID,},
+ {"__label__", LABEL, NORID},
+ {"switch", SWITCH, NORID,},
{"virtual", SCSPEC, RID_VIRTUAL,},
- {"if", IF, NORID,},
- {"while", WHILE, NORID,},
+ {"or", OROR, NORID,},
+ {"__typeof__", TYPEOF, NORID},
+ {"this", THIS, NORID,},
{"",},
- {"class", AGGR, RID_CLASS,},
- {"typedef", SCSPEC, RID_TYPEDEF,},
- {"const", TYPE_QUAL, RID_CONST,},
- {"static", SCSPEC, RID_STATIC,},
- {"auto", SCSPEC, RID_AUTO,},
+ {"bitor", '|', NORID,},
{"float", TYPESPEC, RID_FLOAT,},
- {"inline", SCSPEC, RID_INLINE,},
- {"throw", THROW, NORID,},
- {"unsigned", TYPESPEC, RID_UNSIGNED,},
+ {"typename", TYPENAME_KEYWORD, NORID,},
+ {"__classof", CLASSOF, NORID},
+ {"short", TYPESPEC, RID_SHORT,},
+ {"delete", DELETE, NORID,},
+ {"double", TYPESPEC, RID_DOUBLE,},
{"",},
- {"headof", HEADOF, NORID,},
+ {"new", NEW, NORID,},
+ {"typeid", TYPEID, NORID,},
{"",},
- {"goto", GOTO, NORID,},
- {"",}, {"",},
- {"public", VISSPEC, RID_PUBLIC,},
- {"signature", AGGR, RID_SIGNATURE /* Extension */,},
+ {"case", CASE, NORID,},
+ {"union", AGGR, RID_UNION,},
+ {"sigof", SIGOF, NORID /* Extension */,},
+ {"__typeof", TYPEOF, NORID},
+ {"struct", AGGR, RID_RECORD,},
{"volatile", TYPE_QUAL, RID_VOLATILE,},
- {"__inline", SCSPEC, RID_INLINE},
- {"overload", OVERLOAD, NORID,},
- {"__inline__", SCSPEC, RID_INLINE},
- {"__alignof", ALIGNOF, NORID},
- {"asm", ASM_KEYWORD, NORID,},
+ {"signature", AGGR, RID_SIGNATURE /* Extension */,},
+ {"while", WHILE, NORID,},
+ {"return", RETURN, NORID,},
{"",},
- {"new", NEW, NORID,},
+ {"__asm", GCC_ASM_KEYWORD, NORID},
+ {"protected", VISSPEC, RID_PROTECTED,},
+ {"reinterpret_cast", REINTERPRET_CAST, NORID,},
+ {"friend", SCSPEC, RID_FRIEND,},
+ {"",},
+ {"do", DO, NORID,},
+ {"auto", SCSPEC, RID_AUTO,},
+ {"asm", ASM_KEYWORD, NORID,},
+ {"compl", '~', NORID,},
+ {"public", VISSPEC, RID_PUBLIC,},
{"",},
{"mutable", SCSPEC, RID_MUTABLE,},
- {"union", AGGR, RID_UNION,},
- {"operator", OPERATOR, NORID,},
- {"register", SCSPEC, RID_REGISTER,},
- {"",}, {"",},
- {"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
{"",},
- {"long", TYPESPEC, RID_LONG,},
+ {"signed", TYPESPEC, RID_SIGNED,},
+ {"",},
+ {"throw", THROW, NORID,},
+ {"and", ANDAND, NORID,},
{"",}, {"",}, {"",},
- {"continue", CONTINUE, NORID,},
- {"return", RETURN, NORID,},
+ {"bitand", '&', NORID,},
+ {"const", TYPE_QUAL, RID_CONST,},
+ {"static", SCSPEC, RID_STATIC,},
+ {"headof", HEADOF, NORID,},
+ {"int", TYPESPEC, RID_INT,},
{"enum", ENUM, NORID,},
+ {"",},
+ {"__signed__", TYPESPEC, RID_SIGNED},
+ {"default", DEFAULT, NORID,},
+ {"",},
+ {"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
+ {"using", USING, NORID,},
+ {"__attribute", ATTRIBUTE, NORID},
+ {"",},
+ {"__attribute__", ATTRIBUTE, NORID},
+ {"",},
+ {"goto", GOTO, NORID,},
+ {"operator", OPERATOR, NORID,},
+ {"if", IF, NORID,},
+ {"continue", CONTINUE, NORID,},
+ {"explicit", SCSPEC, RID_EXPLICIT,},
{"",}, {"",},
- {"dynamic_cast", DYNAMIC_CAST, NORID,},
- {"",}, {"",},
- {"reinterpret_cast", REINTERPRET_CAST, NORID,},
- {"",}, {"",}, {"",}, {"",},
- {"char", TYPESPEC, RID_CHAR,},
+ {"class", AGGR, RID_CLASS,},
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"char", TYPESPEC, RID_CHAR,},
+ {"",}, {"",}, {"",}, {"",},
{"classof", CLASSOF, NORID,},
+ {"",}, {"",}, {"",}, {"",},
+ {"long", TYPESPEC, RID_LONG,},
+ {"",}, {"",}, {"",}, {"",},
+ {"void", TYPESPEC, RID_VOID,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"overload", OVERLOAD, NORID,},
+ {"",}, {"",},
+ {"catch", CATCH, NORID,},
+ {"",}, {"",}, {"",}, {"",}, {"",},
+ {"__signed", TYPESPEC, RID_SIGNED},
+ {"register", SCSPEC, RID_REGISTER,},
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
{"const_cast", CONST_CAST, NORID,},
+ {"",}, {"",},
+ {"dynamic_cast", DYNAMIC_CAST, NORID,},
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
- {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
- {"",}, {"",}, {"",}, {"",}, {"",},
- {"catch", CATCH, NORID,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"inline", SCSPEC, RID_INLINE,},
+ {"",}, {"",}, {"",},
+ {"unsigned", TYPESPEC, RID_UNSIGNED,},
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
tree real_binfos = BINFO_BASETYPES (real_binfo);
tree binfos = BINFO_BASETYPES (binfo);
int i, n_baselinks = real_binfos ? TREE_VEC_LENGTH (real_binfos) : 0;
+ int has_expanded = 0;
for (i = 0; i < n_baselinks; i++)
{
int is_not_base_vtable =
i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo));
if (! TREE_VIA_VIRTUAL (real_base_binfo))
- expand_direct_vtbls_init (real_base_binfo, base_binfo,
- is_not_base_vtable, can_elide, addr);
+ {
+ expand_direct_vtbls_init (real_base_binfo, base_binfo,
+ (is_not_base_vtable || flag_rtti), can_elide, addr);
+ if (is_not_base_vtable && flag_rtti)
+ has_expanded = 1;
+ }
}
#if 0
/* Before turning this on, make sure it is correct. */
return;
#endif
/* Should we use something besides CLASSTYPE_VFIELDS? */
- if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo)))
+ if (init_self && !has_expanded && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo)))
{
tree base_ptr = convert_pointer_to_real (binfo, addr);
expand_virtual_init (real_binfo, base_ptr);
switch (n_baseclasses)
{
case 0:
- error ("type `%s' does not have a base class to initialize",
- IDENTIFIER_POINTER (current_class_name));
+ cp_error ("`%T' does not have a base class to initialize",
+ current_class_type);
return;
case 1:
break;
default:
- error ("unnamed initializer ambiguous for type `%s' which uses multiple inheritance", IDENTIFIER_POINTER (current_class_name));
+ cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
+ current_class_type);
return;
}
binfo = TREE_VEC_ELT (binfos, 0);
break;
if (i < 0)
{
- error ("type `%s' is not an immediate base class of type `%s'",
- IDENTIFIER_POINTER (basename),
- IDENTIFIER_POINTER (current_class_name));
+ cp_error ("`%T' is not an immediate base class of `%T'",
+ IDENTIFIER_TYPE_VALUE (basename),
+ current_class_type);
continue;
}
}
if (TREE_STATIC (member))
{
- error_with_aggr_type (DECL_FIELD_CONTEXT (member),
- "field `%s::%s' is static; only point of initialization is its declaration",
- IDENTIFIER_POINTER (TREE_PURPOSE (init_list)));
+ cp_error ("field `%#D' is static; only point of initialization is its declaration",
+ member);
continue;
}
if (init)
init = TREE_PURPOSE (init);
/* Call constructors, but don't set up vtables. */
- expand_aggr_init_1 (binfo, exp, ref, init, 0,
- LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY);
+ expand_aggr_init_1 (binfo, exp, ref, init, 0, LOOKUP_COMPLAIN);
expand_cleanups_to (NULL_TREE);
CLEAR_BINFO_VBASE_INIT_MARKED (binfo);
}
out, then look hard. */
tree rval;
tree parms;
- int xxref_init_possible;
if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
{
parms = init;
- if (parms) init = TREE_VALUE (parms);
+ if (parms)
+ init = TREE_VALUE (parms);
}
else if (TREE_CODE (init) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (init))
{
else
parms = build_tree_list (NULL_TREE, init);
- if (TYPE_HAS_INIT_REF (type)
- || init == NULL_TREE
- || TREE_CHAIN (parms) != NULL_TREE)
- xxref_init_possible = 0;
- else
- {
- xxref_init_possible = LOOKUP_SPECULATIVELY;
- flags &= ~LOOKUP_COMPLAIN;
- }
-
if (TYPE_USES_VIRTUAL_BASECLASSES (type))
{
if (true_exp == exp)
flags |= LOOKUP_HAS_IN_CHARGE;
}
- rval = build_method_call (exp, constructor_name_full (type),
- parms, binfo, flags|xxref_init_possible);
- if (rval == NULL_TREE && xxref_init_possible)
- {
- /* It is an error to implement a default copy constructor if
- (see ARM 12.8 for details) ... one case being if another
- copy constructor already exists. */
- tree init_type = TREE_TYPE (init);
- if (TREE_CODE (init_type) == REFERENCE_TYPE)
- init_type = TREE_TYPE (init_type);
- if (TYPE_MAIN_VARIANT (init_type) == TYPE_MAIN_VARIANT (type)
- || (IS_AGGR_TYPE (init_type)
- && UNIQUELY_DERIVED_FROM_P (type, init_type)))
- {
- if (type == BINFO_TYPE (binfo)
- && TYPE_USES_VIRTUAL_BASECLASSES (type))
- {
- tree addr = build_unary_op (ADDR_EXPR, exp, 0);
- expand_aggr_vbase_init (binfo, exp, addr, NULL_TREE);
-
- expand_indirect_vtbls_init (binfo, exp, addr, 1);
- }
- expand_expr_stmt (build_modify_expr (exp, INIT_EXPR, init));
- return;
- }
- else
- rval = build_method_call (exp, constructor_name_full (type), parms,
- binfo, flags);
- }
-
- /* Private, protected, or otherwise unavailable. */
- if (rval == error_mark_node && (flags&LOOKUP_COMPLAIN))
- cp_error ("in base initialization for class `%T'", binfo);
- /* A valid initialization using constructor. */
- else if (rval != error_mark_node && rval != NULL_TREE)
+ if (init && TREE_CHAIN (parms) == NULL_TREE
+ && TYPE_HAS_CONSTRUCTOR (type)
+ && ! TYPE_NEEDS_CONSTRUCTING (type)
+ && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (init)))
{
- /* p. 222: if the base class assigns to `this', then that
- value is used in the derived class. */
- if ((flag_this_is_variable & 1) && alias_this)
- {
- TREE_TYPE (rval) = TREE_TYPE (current_class_decl);
- expand_assignment (current_class_decl, rval, 0, 0);
- }
- else
- expand_expr_stmt (rval);
+ rval = build (INIT_EXPR, type, exp, init);
+ TREE_SIDE_EFFECTS (rval) = 1;
+ expand_expr_stmt (rval);
}
- else if (parms && TREE_CHAIN (parms) == NULL_TREE)
+ else
{
- /* If we are initializing one aggregate value
- from another, and though there are constructors,
- and none accept the initializer, just do a bitwise
- copy.
-
- The above sounds wrong, ``If a class has any copy
- constructor defined, the default copy constructor will
- not be generated.'' 12.8 Copying Class Objects (mrs)
-
- @@ This should reject initializer which a constructor
- @@ rejected on access gounds, but there is
- @@ no way right now to recognize that case with
- @@ just `error_mark_node'. */
- tree itype;
- init = TREE_VALUE (parms);
- itype = TREE_TYPE (init);
- if (TREE_CODE (itype) == REFERENCE_TYPE)
- {
- init = convert_from_reference (init);
- itype = TREE_TYPE (init);
- }
- itype = TYPE_MAIN_VARIANT (itype);
+ rval = build_method_call (exp, constructor_name_full (type),
+ parms, binfo, flags);
- /* This is currently how the default X(X&) constructor
- is implemented. */
- if (comptypes (TYPE_MAIN_VARIANT (type), itype, 0))
- {
-#if 0
- warning ("bitwise copy in initialization of type `%s'",
- TYPE_NAME_STRING (type));
-#endif
- rval = build (INIT_EXPR, type, exp, init);
- expand_expr_stmt (rval);
- }
- else
+ /* Private, protected, or otherwise unavailable. */
+ if (rval == error_mark_node)
{
- cp_error ("in base initialization for class `%T',", binfo);
- cp_error ("invalid initializer to constructor for type `%T'", type);
- return;
+ if (flags & LOOKUP_COMPLAIN)
+ cp_error ("in base initialization for %sclass `%T'",
+ TREE_VIA_VIRTUAL (binfo) ? "virtual base " : "",
+ binfo);
}
- }
- else
- {
- if (init == NULL_TREE)
- my_friendly_assert (parms == NULL_TREE, 210);
- if (parms == NULL_TREE && TREE_VIA_VIRTUAL (binfo))
- cp_error ("virtual baseclass `%T' does not have default initializer", binfo);
+ else if (rval == NULL_TREE)
+ my_friendly_abort (361);
else
{
- cp_error ("in base initialization for class `%T',", binfo);
- /* This will make an error message for us. */
- build_method_call (exp, constructor_name_full (type), parms, binfo,
- (TYPE_USES_VIRTUAL_BASECLASSES (type)
- ? LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE
- : LOOKUP_NORMAL));
+ /* p. 222: if the base class assigns to `this', then that
+ value is used in the derived class. */
+ if ((flag_this_is_variable & 1) && alias_this)
+ {
+ TREE_TYPE (rval) = TREE_TYPE (current_class_decl);
+ expand_assignment (current_class_decl, rval, 0, 0);
+ }
+ else
+ expand_expr_stmt (rval);
}
- return;
}
- /* Constructor has been called, but vtables may be for TYPE
- rather than for FOR_TYPE. */
}
/* This function is responsible for initializing EXP with INIT
{
/* raw "main", and builtin functions never gets overloaded,
but they can become friends. */
- TREE_PUBLIC (decl) = 1;
add_friend (current_class_type, decl);
DECL_FRIEND_P (decl) = 1;
decl = void_type_node;
ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
+ ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
+ SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPLICIT],
+ build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPLICIT]));
ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
- /* Exception handling extensions. */
- exception_type_node = build_int_2 (exception_type, 0);
- TREE_TYPE (exception_type_node) = exception_type_node;
- ridpointers[(int) RID_EXCEPTION] = exception_type_node;
-
/* Signature handling extensions. */
signature_type_node = build_int_2 (signature_type, 0);
TREE_TYPE (signature_type_node) = signature_type_node;
}
#endif
- if (! (flag_gc || flag_dossier))
+ if (! (flag_gc || flag_rtti))
{
UNSET_RESERVED_WORD ("classof");
UNSET_RESERVED_WORD ("headof");
UNSET_RESERVED_WORD ("asm");
if (flag_no_asm || flag_traditional)
UNSET_RESERVED_WORD ("typeof");
+ if (!flag_ansi)
+ {
+ /* These are new ANSI keywords that may break code. */
+ UNSET_RESERVED_WORD ("and");
+ UNSET_RESERVED_WORD ("bitand");
+ UNSET_RESERVED_WORD ("bitor");
+ UNSET_RESERVED_WORD ("compl");
+ UNSET_RESERVED_WORD ("not");
+ UNSET_RESERVED_WORD ("or");
+ UNSET_RESERVED_WORD ("xor");
+ }
token_count = init_parse ();
interface_unknown = 1;
DECL_PENDING_INLINE_INFO (f) = 0;
interface_unknown = t->interface == 1;
interface_only = t->interface == 0;
- switch (- t->lineno)
- {
- case 0: case 1:
- build_dtor (f); break;
- case 2:
- build_default_constructor (f); break;
- case 3: case 4:
- build_copy_constructor (f); break;
- case 5: case 6:
- build_assign_ref (f); break;
- default:
- ;
- }
+ synthesize_method (f);
if (tail)
tail->next = t->next;
else
tree fn, args;
tree argtype;
int retref = 0;
+ int complex = 0;
name = constructor_name (name);
switch (kind)
/* Fall through... */
case 0:
name = build_parse_node (BIT_NOT_EXPR, name);
- /* Fall through... */
+ args = void_list_node;
+ break;
+
case 2:
/* Default constructor. */
args = void_list_node;
+ complex = TYPE_NEEDS_CONSTRUCTING (type);
break;
case 3:
build_tree_list (hash_tree_chain (argtype, NULL_TREE),
get_identifier ("_ctor_arg")),
void_list_node);
+ complex = TYPE_HAS_COMPLEX_INIT_REF (type);
break;
case 5:
build_tree_list (hash_tree_chain (argtype, NULL_TREE),
get_identifier ("_ctor_arg")),
void_list_node);
+ complex = TYPE_HAS_COMPLEX_ASSIGN_REF (type);
break;
default:
if (fn == void_type_node)
return fn;
- if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
+ if (processing_template_defn)
SET_DECL_IMPLICIT_INSTANTIATION (fn);
- /* This kludge should go away when synthesized methods are handled
- properly, i.e. only when needed. */
- {
- struct pending_inline *t;
- t = (struct pending_inline *)
- obstack_alloc (&synth_obstack, sizeof (struct pending_inline));
- t->lineno = -kind;
- t->can_free = 0;
- t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
- store_pending_inline (fn, t);
- }
+ if (CLASSTYPE_INTERFACE_KNOWN (type))
+ {
+ DECL_INTERFACE_KNOWN (fn) = 1;
+ DECL_EXTERNAL (fn) = (CLASSTYPE_INTERFACE_ONLY (type)
+ || ! flag_implement_inlines);
+ TREE_STATIC (fn) = ! DECL_EXTERNAL (fn);
+ }
+
+ /* When on-the-fly synthesis works properly, remove the second and third
+ conditions here. */
+ if (flag_keep_inline_functions
+ || ! flag_no_inline
+ || complex
+ || ! DECL_EXTERNAL (fn))
+ {
+ struct pending_inline *t;
+ t = (struct pending_inline *)
+ obstack_alloc (&synth_obstack, sizeof (struct pending_inline));
+ t->lineno = -kind;
+ t->can_free = 0;
+ t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
+ store_pending_inline (fn, t);
+ }
+ else
+ mark_inline_for_output (fn);
#ifdef DEBUG_DEFAULT_FUNCTIONS
{ char *fn_type = NULL;
else
yylval.ttype = old_ttype;
}
+ else if (ptr->token == EQCOMPARE)
+ {
+ yylval.code = NE_EXPR;
+ token_buffer[0] = '!';
+ token_buffer[1] = '=';
+ token_buffer[2] = 0;
+ }
+ else if (ptr->token == ASSIGN)
+ {
+ if (strcmp ("and_eq", token_buffer) == 0)
+ {
+ yylval.code = BIT_AND_EXPR;
+ token_buffer[0] = '&';
+ }
+ else if (strcmp ("or_eq", token_buffer) == 0)
+ {
+ yylval.code = BIT_IOR_EXPR;
+ token_buffer[0] = '|';
+ }
+ else if (strcmp ("xor_eq", token_buffer) == 0)
+ {
+ yylval.code = BIT_XOR_EXPR;
+ token_buffer[0] = '^';
+ }
+ token_buffer[1] = '=';
+ token_buffer[2] = 0;
+ }
+ else if (ptr->token == '&')
+ {
+ yylval.code = BIT_AND_EXPR;
+ token_buffer[0] = '&';
+ token_buffer[1] = 0;
+ }
+ else if (ptr->token == '|')
+ {
+ yylval.code = BIT_IOR_EXPR;
+ token_buffer[0] = '|';
+ token_buffer[1] = 0;
+ }
+ else if (ptr->token == '^')
+ {
+ yylval.code = BIT_XOR_EXPR;
+ token_buffer[0] = '^';
+ token_buffer[1] = 0;
+ }
+
value = (int) ptr->token;
}
}
RID_VOLATILE,
RID_FRIEND,
RID_VIRTUAL,
+ RID_EXPLICIT,
RID_SIGNED,
RID_AUTO,
RID_MUTABLE,
IDENTIFIER_LENGTH (ID)))
# define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
# define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
+# define OB_LAST() (obstack_next_free (&scratch_obstack)[-1])
#ifdef NO_AUTO_OVERLOAD
int is_overloaded ();
static void build_overload_identifier ();
static void
-build_overload_nested_name (context)
- tree context;
+build_overload_nested_name (decl)
+ tree decl;
{
- /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME. */
- tree name = DECL_NAME (context);
- if (DECL_CONTEXT (context))
+ if (DECL_CONTEXT (decl))
{
- context = DECL_CONTEXT (context);
+ tree context = DECL_CONTEXT (decl);
if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
- context = TYPE_NAME (context);
+ context = TYPE_MAIN_DECL (context);
build_overload_nested_name (context);
}
- build_overload_identifier (name);
+
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ {
+ tree name = DECL_ASSEMBLER_NAME (decl);
+ char *label;
+ extern int var_labelno;
+
+ ASM_FORMAT_PRIVATE_NAME (label, IDENTIFIER_POINTER (name), var_labelno);
+ var_labelno++;
+
+ if (numeric_outputed_need_bar)
+ {
+ OB_PUTC ('_');
+ numeric_outputed_need_bar = 0;
+ }
+ icat (strlen (label));
+ OB_PUTCP (label);
+ }
+ else /* TYPE_DECL */
+ {
+ tree name = DECL_NAME (decl);
+ build_overload_identifier (name);
+ }
}
static void
tree parmtype;
if (begin) OB_INIT ();
+ numeric_outputed_need_bar = 0;
if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
{
if (TREE_CODE (name) == TYPE_DECL)
{
tree context = name;
+
+ /* If DECL_ASSEMBLER_NAME has been set properly, use it. */
+ if (DECL_ASSEMBLER_NAME (context) != DECL_NAME (context))
+ {
+ OB_PUTID (DECL_ASSEMBLER_NAME (context));
+ break;
+ }
while (DECL_CONTEXT (context))
{
i += 1;
icat (i);
if (i > 9)
OB_PUTC ('_');
- numeric_outputed_need_bar = 0;
- build_overload_nested_name (TYPE_NAME (parmtype));
+ numeric_outputed_need_bar = 0;
+ build_overload_nested_name (TYPE_MAIN_DECL (parmtype));
}
else
build_overload_identifier (name);
{
ALLOCATE_TYPEVEC (parms);
nofold = 0;
- numeric_outputed_need_bar = 0;
if (for_method)
{
build_overload_name (TREE_VALUE (parms), 0, 0);
unshare_all_rtl (insns);
+ /* Instantiate all virtual registers. */
+
+ instantiate_virtual_regs (current_function_decl, get_insns ());
+
/* We are no longer anticipating cse in this function, at least. */
cse_not_expected = 1;
\f
/* Code for synthesizing methods which have default semantics defined. */
-void
-build_default_constructor (fndecl)
- tree fndecl;
-{
- start_function (NULL_TREE, fndecl, NULL_TREE, 1);
- store_parm_decls ();
- setup_vtbl_ptr ();
- finish_function (lineno, 0);
-}
-
/* For the anonymous union in TYPE, return the member that is at least as
large as the rest of the members, so we can copy it. */
static tree
/* Generate code for default X(X&) constructor. */
void
-build_copy_constructor (fndecl)
+do_build_copy_constructor (fndecl)
tree fndecl;
{
tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
tree t;
- start_function (NULL_TREE, fndecl, NULL_TREE, 1);
- store_parm_decls ();
clear_last_expr ();
push_momentary ();
}
pop_momentary ();
- finish_function (lineno, 0);
}
void
-build_assign_ref (fndecl)
+do_build_assign_ref (fndecl)
tree fndecl;
{
tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
- start_function (NULL_TREE, fndecl, NULL_TREE, 1);
- store_parm_decls ();
+ clear_last_expr ();
push_momentary ();
parm = convert_from_reference (parm);
}
c_expand_return (C_C_D);
pop_momentary ();
- finish_function (lineno, 0);
}
+void push_cp_function_context ();
+void pop_cp_function_context ();
+
void
-build_dtor (fndecl)
+synthesize_method (fndecl)
tree fndecl;
{
+ int nested = (current_function_decl != NULL_TREE);
+ int toplev = (decl_function_context (fndecl) == NULL_TREE);
+ char *f = input_filename;
+
+ if (nested)
+ push_cp_function_context (toplev);
+
+ input_filename = DECL_SOURCE_FILE (fndecl);
+ extract_interface_info ();
start_function (NULL_TREE, fndecl, NULL_TREE, 1);
store_parm_decls ();
- finish_function (lineno, 0);
+
+ if (DECL_NAME (fndecl) == ansi_opname[MODIFY_EXPR])
+ do_build_assign_ref (fndecl);
+ else if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
+ ;
+ else
+ {
+ tree arg_chain = FUNCTION_ARG_CHAIN (fndecl);
+ if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl))
+ arg_chain = TREE_CHAIN (arg_chain);
+ if (arg_chain != void_list_node)
+ do_build_copy_constructor (fndecl);
+ else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
+ setup_vtbl_ptr ();
+ }
+
+ finish_function (lineno, 0, nested);
+ input_filename = f;
+ extract_interface_info ();
+ if (nested)
+ pop_cp_function_context (toplev);
}
%token <ttype> AGGR
%token <itype> VISSPEC
%token DELETE NEW OVERLOAD THIS OPERATOR CXX_TRUE CXX_FALSE
+%token NAMESPACE TYPENAME_KEYWORD USING
%token LEFT_RIGHT TEMPLATE
%token TYPEID DYNAMIC_CAST STATIC_CAST REINTERPRET_CAST CONST_CAST
%token <itype> SCOPE
%left '{' ',' ';'
+%nonassoc THROW
%right <code> ASSIGN '='
%right <code> '?' ':'
%left <code> OROR
%left <code> POINTSAT '.' '(' '['
%right SCOPE /* C++ extension */
-%nonassoc NEW DELETE TRY CATCH THROW
+%nonassoc NEW DELETE TRY CATCH
%type <code> unop
{
yychar = ':';
template1:
- if (current_aggr == exception_type_node)
- error ("template type must define an aggregate or union");
- else if (current_aggr == signature_type_node)
+ if (current_aggr == signature_type_node)
sorry ("template type defining a signature");
/* Maybe pedantic warning for union?
How about an enum? :-) */
fndef:
fn.def1 base_init compstmt_or_error
{
- finish_function (lineno, 1);
+ finish_function (lineno, 1, 0);
/* finish_function performs these three statements:
expand_end_bindings (getdecls (), 1, 0);
}
| fn.def1 return_init base_init compstmt_or_error
{
- finish_function (lineno, 1);
+ finish_function (lineno, 1, 0);
/* finish_function performs these three statements:
expand_end_bindings (getdecls (), 1, 0);
if ($<ttype>$) process_next_inline ($<ttype>$);
}
| fn.def1 nodecls compstmt_or_error
- { finish_function (lineno, 0);
+ { finish_function (lineno, 0, 0);
if ($<ttype>$) process_next_inline ($<ttype>$); }
| fn.def1 return_init ';' nodecls compstmt_or_error
- { finish_function (lineno, 0);
+ { finish_function (lineno, 0, 0);
if ($<ttype>$) process_next_inline ($<ttype>$); }
| fn.def1 return_init nodecls compstmt_or_error
- { finish_function (lineno, 0);
+ { finish_function (lineno, 0, 0);
if ($<ttype>$) process_next_inline ($<ttype>$); }
| typed_declspecs declarator error
{}
{
tree type = IDENTIFIER_TYPE_VALUE ($3);
if (! IS_SIGNATURE(type))
- $$ = CLASSTYPE_DOSSIER (type);
+ $$ = CLASSTYPE_RTTI (type);
else
{
sorry ("signature name as argument of `classof'");
if (TREE_CODE ($$) == ENUMERAL_TYPE)
/* $$ = $1 from default rule. */;
- else if (CLASSTYPE_DECLARED_EXCEPTION ($$))
- {
- }
else
{
$$ = finish_struct ($$, $3, semi);
int needs_writing;
tree name = TYPE_IDENTIFIER (t);
- CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
- SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
+ if (! ANON_AGGRNAME_P (name))
+ {
+ CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
+ SET_CLASSTYPE_INTERFACE_UNKNOWN_X
+ (t, interface_unknown);
+ }
/* Record how to set the access of this class's
virtual functions. If write_virtuals == 2 or 3, then
{ expand_start_catch_block ($2, $3); }
| '(' typed_typespecs after_type_declarator ')'
{ expand_start_catch_block ($2, $3); }
- */
+ This allows reference parameters... */
| '(' parm ')'
{ expand_start_catch_block (TREE_PURPOSE ($2),
TREE_VALUE ($2)); }
PARM, 0, NULL_TREE);
/* A template parameter is not modifiable. */
TREE_READONLY (parm) = 1;
- if (TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE
- || TREE_CODE (TREE_TYPE (parm)) == UNION_TYPE)
+ if (IS_AGGR_TYPE (TREE_TYPE (parm)))
{
sorry ("aggregate template parameter types");
TREE_TYPE (parm) = void_type_node;
tree a = TREE_OPERAND (val, 0);
if ((TREE_CODE (a) == VAR_DECL
|| TREE_CODE (a) == FUNCTION_DECL)
- && !TREE_PUBLIC (a))
+ && ! DECL_PUBLIC (a))
{
cp_error ("address of non-extern `%E' cannot be used as template argument", a);
val = error_mark_node;
val = digest_init (TREE_TYPE (parm), arg, (tree *) 0);
if (val != error_mark_node)
{
- decl = build_decl (VAR_DECL, DECL_NAME (parm), TREE_TYPE (parm));
+ decl = build_decl (CONST_DECL, DECL_NAME (parm),
+ TREE_TYPE (parm));
DECL_INITIAL (decl) = val;
TREE_READONLY (decl) = 1;
}
case UNINSTANTIATED_P_TYPE:
return 1;
+ case CONSTRUCTOR:
+ if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
+ return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
+ /* else fall through */
+
default:
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
&TREE_VEC_ELT (parmvec, 0));
type = IDENTIFIER_TYPE_VALUE (id);
my_friendly_assert (type != 0, 277);
- if (flag_external_templates)
- {
- if (CLASSTYPE_INTERFACE_UNKNOWN (type))
- {
- DECL_EXTERNAL (t2) = 0;
- TREE_PUBLIC (t2) = 0;
- }
- else
- {
- DECL_EXTERNAL (t2) = CLASSTYPE_INTERFACE_ONLY (type);
- TREE_PUBLIC (t2) = 1;
- }
- }
break;
case 1:
/* Failure. */
{
tree t;
- t = TREE_VALUE(CLASSTYPE_TAGS(ctype));
- while (t)
- {
- if (strcmp(IDENTIFIER_POINTER(name), IDENTIFIER_POINTER(TYPE_IDENTIFIER(t)))
- == 0)
- return t;
- else
- t = TREE_CHAIN(t);
- }
+ for (t = CLASSTYPE_TAGS (ctype); t; t = TREE_CHAIN (t))
+ {
+ if (name == TREE_PURPOSE (t))
+ return TREE_VALUE (t);
+ }
return NULL_TREE;
}
tsubst (TYPE_MAX_VALUE (t), args, nargs, in_decl));
case TEMPLATE_TYPE_PARM:
- return cp_build_type_variant (args[TEMPLATE_TYPE_IDX (t)],
- TYPE_READONLY (t),
- TYPE_VOLATILE (t));
+ {
+ tree arg = args[TEMPLATE_TYPE_IDX (t)];
+ return cp_build_type_variant
+ (arg, TYPE_READONLY (arg) || TYPE_READONLY (t),
+ TYPE_VOLATILE (arg) || TYPE_VOLATILE (t));
+ }
case TEMPLATE_CONST_PARM:
return args[TEMPLATE_CONST_IDX (t)];
}
}
}
- TREE_PUBLIC (r) = TREE_PUBLIC (t);
- DECL_EXTERNAL (r) = DECL_EXTERNAL (t);
- TREE_STATIC (r) = TREE_STATIC (t);
+ TREE_PUBLIC (r) = 1;
+ DECL_EXTERNAL (r) = 1;
+ TREE_STATIC (r) = 0;
+ DECL_INTERFACE_KNOWN (r) = 0;
DECL_INLINE (r) = DECL_INLINE (t);
{
#if 0 /* Maybe later. -jason */
input_filename = p->filename = t->filename;
extract_interface_info ();
-
- if (interface_unknown && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (tmpl))
- warn_if_unknown_interface ();
- if (interface_unknown || !flag_external_templates)
+
+ if (interface_unknown && flag_external_templates)
+ {
+ if (DECL_CLASS_CONTEXT (fndecl)
+ && CLASSTYPE_INTERFACE_KNOWN (DECL_CLASS_CONTEXT (fndecl)))
+ {
+ interface_unknown = 0;
+ interface_only
+ = CLASSTYPE_INTERFACE_ONLY (DECL_CLASS_CONTEXT (fndecl));
+ }
+ else if (! DECL_IN_SYSTEM_HEADER (tmpl))
+ warn_if_unknown_interface ();
+ }
+
+ if (interface_unknown || ! flag_external_templates)
p->interface = 1; /* unknown */
else
p->interface = interface_only ? 0 : 2;
arg = TREE_TYPE (arg);
}
#endif
+ if (TREE_CODE (arg) == REFERENCE_TYPE)
+ arg = TREE_TYPE (arg);
+
if (TREE_CODE (parm) != REFERENCE_TYPE)
{
if (TREE_CODE (arg) == FUNCTION_TYPE
if (arg == parm)
return 0;
- if (TREE_CODE (arg) == REFERENCE_TYPE)
- arg = TREE_TYPE (arg);
-
switch (TREE_CODE (parm))
{
case TEMPLATE_TYPE_PARM:
return 1;
}
idx = TEMPLATE_TYPE_IDX (parm);
+#if 0
/* Template type parameters cannot contain cv-quals; i.e.
template <class T> void f (T& a, T& b) will not generate
void f (const int& a, const int& b). */
|| TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm))
return 1;
arg = TYPE_MAIN_VARIANT (arg);
+#else
+ {
+ int constp = TYPE_READONLY (arg) > TYPE_READONLY (parm);
+ int volatilep = TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm);
+ arg = cp_build_type_variant (arg, constp, volatilep);
+ }
+#endif
/* Simple cases: Value already set, does match or doesn't. */
if (targs[idx] == arg)
return 0;
case UNINSTANTIATED_P_TYPE:
{
tree a;
- /* Unification of something that is not a template fails. (mrs) */
- if (TYPE_NAME (arg) == 0)
+ /* Unification of something that is not a class fails. */
+ if (! IS_AGGR_TYPE (arg))
return 1;
a = IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (arg));
- /* Unification of something that is not a template fails. (mrs) */
- if (a == 0)
- return 1;
- if (UPT_TEMPLATE (parm) != TREE_PURPOSE (a))
- /* different templates */
- return 1;
- return unify (tparms, targs, ntparms, UPT_PARMS (parm), TREE_VALUE (a),
- nsubsts);
+ if (a && UPT_TEMPLATE (parm) == TREE_PURPOSE (a))
+ return unify (tparms, targs, ntparms, UPT_PARMS (parm),
+ TREE_VALUE (a), nsubsts);
+ /* FIXME: Should check base conversions here. */
+ return 1;
}
case RECORD_TYPE:
- if (TYPE_PTRMEMFUNC_P (parm))
+ if (TYPE_PTRMEMFUNC_FLAG (parm))
return unify (tparms, targs, ntparms, TYPE_PTRMEMFUNC_FN_TYPE (parm),
arg, nsubsts);
else if (! flag_implicit_templates)
DECIDE (0);
+ /* OK, it was an implicit instantiation. */
+ TREE_PUBLIC (t) = 0;
+
/* If it's a method, let the class type decide it.
@@ What if the method template is in a separate file?
Maybe both file contexts should be taken into account?
if (flag_external_templates)
return;
- if (DECL_EXPLICIT_INSTANTIATION (result) && TREE_PUBLIC (result))
- return;
-
SET_DECL_EXPLICIT_INSTANTIATION (result);
+ TREE_PUBLIC (result) = 1;
if (storage == NULL_TREE)
{
- TREE_PUBLIC (result) = 1;
- DECL_EXTERNAL (result) = (DECL_INLINE (result)
- && ! flag_implement_inlines);
- TREE_STATIC (result) = ! DECL_EXTERNAL (result);
+ DECL_INTERFACE_KNOWN (result) = 1;
+ DECL_EXTERNAL (result) = 0;
+ TREE_STATIC (result) = 1;
}
else if (storage == ridpointers[(int) RID_EXTERN])
;
}
/* We've already instantiated this. */
- if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && CLASSTYPE_INTERFACE_KNOWN (t))
+ if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && ! CLASSTYPE_INTERFACE_ONLY (t))
{
if (! extern_p)
cp_pedwarn ("multiple explicit instantiation of `%#T'", t);
if (! CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
{
SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
+ SET_CLASSTYPE_INTERFACE_KNOWN (t);
+ CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
+ CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p;
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
if (! extern_p)
{
- SET_CLASSTYPE_INTERFACE_KNOWN (t);
- CLASSTYPE_INTERFACE_ONLY (t) = 0;
- CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 1;
CLASSTYPE_DEBUG_REQUESTED (t) = 1;
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0;
rest_of_type_compilation (t, 1);
}
}
-
- instantiate_member_templates (TYPE_IDENTIFIER (t));
-
- /* this should really be done by instantiate_member_templates */
+
{
- tree tmp = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0);
+ tree tmp;
+ /* Classes nested in template classes currently don't have an
+ IDENTIFIER_TEMPLATE--their out-of-line members are handled
+ by the enclosing template class. Note that there are name
+ conflict bugs with this approach. */
+ tmp = TYPE_IDENTIFIER (t);
+ if (IDENTIFIER_TEMPLATE (tmp))
+ instantiate_member_templates (tmp);
+
+ /* this should really be done by instantiate_member_templates */
+ tmp = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0);
for (; tmp; tmp = TREE_CHAIN (tmp))
{
if (DECL_TEMPLATE_SPECIALIZATION (tmp)
continue;
SET_DECL_EXPLICIT_INSTANTIATION (tmp);
+ TREE_PUBLIC (tmp) = 1;
if (! extern_p)
{
- TREE_PUBLIC (tmp) = 1;
- DECL_EXTERNAL (tmp) = (DECL_INLINE (tmp)
- && ! flag_implement_inlines);
- TREE_STATIC (tmp) = ! DECL_EXTERNAL (tmp);
+ DECL_INTERFACE_KNOWN (tmp) = 1;
+ DECL_EXTERNAL (tmp) = 0;
+ TREE_STATIC (tmp) = 1;
}
}
type_stack = (struct type_level *)type_stack->base.prev;
}
\f
-#if 0 /* unused */
/* This is the newer recursive depth first search routine. */
+#if 0 /* unused */
/* Return non-zero if PARENT is directly derived from TYPE. By directly
we mean it's only one step up the inheritance lattice. We check this
by walking horizontally across the types that TYPE directly inherits
/* Should we use something besides CLASSTYPE_VFIELDS? */
if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
{
+ /* Get around first entry reserved for RTTI. */
tree tmp = TREE_CHAIN (BINFO_VIRTUALS (binfo));
- /* Get around dossier entry if there is one. */
- if (flag_dossier)
- tmp = TREE_CHAIN (tmp);
-
while (tmp)
{
tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp));
CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
- /* If there is a dossier, it is the first field, though perhaps from
+ /* If there is a rtti, it is the first field, though perhaps from
the base class. Otherwise, the first fields are virtual base class
pointer fields. */
- if (CLASSTYPE_DOSSIER (type) && VFIELD_NAME_P (DECL_NAME (fields)))
+ if (CLASSTYPE_RTTI (type) && VFIELD_NAME_P (DECL_NAME (fields)))
/* Get past vtable for the object. */
fields = TREE_CHAIN (fields);
virtuals = BINFO_VIRTUALS (elem);
if (virtuals != 0)
{
+ /* skip the rtti type descriptor entry */
virtuals = TREE_CHAIN (virtuals);
- if (flag_dossier)
- virtuals = TREE_CHAIN (virtuals);
}
i = 1;
while (virtuals)
unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
+ /* We can shorten only if the shift count is less than the
+ number of bits in the smaller type size. */
+ && TREE_INT_CST_HIGH (op1) == 0
+ && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
/* If arg is sign-extended and then unsigned-shifted,
we can simulate this with a signed shift in arg's type
only if the extended result is at least twice as wide
{
/* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
error message. */
- if (code != ADDR_EXPR || TREE_CODE (TREE_TYPE (xarg)) != RECORD_TYPE
- || TYPE_SIZE (TREE_TYPE (xarg)))
+ if (code == ADDR_EXPR
+ && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg)))
+ && TYPE_SIZE (TREE_TYPE (xarg)) == NULL_TREE)
+ || (TREE_CODE (xarg) == OFFSET_REF)))
+ /* don't look for a function */;
+ else
{
tree rval = build_opfncall (code, LOOKUP_SPECULATIVELY, xarg,
NULL_TREE, NULL_TREE);
if (typecode == ENUMERAL_TYPE)
typecode = INTEGER_TYPE;
+ if (typecode == BOOLEAN_TYPE && ! noconvert)
+ typecode = INTEGER_TYPE;
+
isaggrtype = IS_AGGR_TYPE_CODE (typecode);
switch (code)
if (modifycode == INIT_EXPR)
{
- if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_CONSTRUCTOR (lhstype))
+ if (! IS_AGGR_TYPE (lhstype))
+ /* Do the default thing */;
+ else if (! TYPE_HAS_CONSTRUCTOR (lhstype))
+ cp_error ("`%T' has no constructors", lhstype);
+ else if (! TYPE_NEEDS_CONSTRUCTING (lhstype)
+ && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
+ /* Do the default thing */;
+ else
{
result = build_method_call (lhs, constructor_name_full (lhstype),
build_tree_list (NULL_TREE, rhs),
{
#if 1
/* `operator=' is not an inheritable operator. */
- if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_ASSIGNMENT (lhstype))
+ if (! IS_AGGR_TYPE (lhstype))
+ /* Do the default thing */;
+ else if (! TYPE_HAS_ASSIGNMENT (lhstype))
+ cp_error ("`%T' does not define operator=", lhstype);
+ else if (! TYPE_HAS_REAL_ASSIGNMENT (lhstype)
+ && ! TYPE_HAS_COMPLEX_ASSIGN_REF (lhstype)
+ /* FIXME find some way to deal with TARGET_EXPRs here. */
+ && TREE_CODE (newrhs) != TARGET_EXPR
+ && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
+ /* Do the default thing */;
+ else
{
result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
lhs, rhs, make_node (NOP_EXPR));
if (TREE_SIDE_EFFECTS (newrhs))
newrhs = stabilize_reference (newrhs);
+#if 0
+ /* This is now done by generating X(X&) and operator=(X&). */
/* C++: The semantics of C++ differ from those of C when an
assignment of an aggregate is desired. Assignment in C++ is
now defined as memberwise assignment of non-static members
|| (TREE_CODE (TREE_TYPE (newrhs)) == RECORD_TYPE
&& UNIQUELY_DERIVED_FROM_P (lhstype, TREE_TYPE (newrhs)))))
{
- /* This was decided in finish_struct. */
- if (modifycode == INIT_EXPR)
- cp_error ("can't generate default copy constructor for `%T'", lhstype);
- else
- cp_error ("can't generate default assignment operator for `%T'",
- lhstype);
-#if 0
- /* This is now done by generating X(X&) and operator=(X&). */
tree vbases = CLASSTYPE_VBASECLASSES (lhstype);
tree lhs_addr = build_unary_op (ADDR_EXPR, lhs, 0);
tree rhs_addr;
TYPE_BINFO (lhstype)),
result);
return build_compound_expr (result);
-#endif
}
+#endif
/* Convert new value to destination type. */
}
else
{
+#if 0
if (IS_AGGR_TYPE (lhstype))
{
if (result = build_opfncall (MODIFY_EXPR,
make_node (NOP_EXPR)))
return result;
}
+#endif
/* Avoid warnings on enum bit fields. */
if (TREE_CODE (olhstype) == ENUMERAL_TYPE
&& TREE_CODE (lhstype) == INTEGER_TYPE)
`convert_for_initialization'. They should otherwise be
bashed before coming here. */
else if (codel == REFERENCE_TYPE)
- /* Force an abort. */
- my_friendly_assert (codel != REFERENCE_TYPE, 317);
+ my_friendly_abort (317);
else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))
{
tree nrhs = build1 (NOP_EXPR, type, rhs);
}
/* Handle the case of default parameter initialization and
initialization of static variables. */
+ else if (TREE_CODE (rhs) == TARGET_EXPR)
+ return rhs;
else if (TREE_CODE (rhs) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (rhs))
{
my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs, 0)) == CALL_EXPR, 318);
silly. So instead, we just do the equivalent of a call to fatal in the
same situation (call exit). */
-/* First used: 0 (reserved), Last used: 360. Free: 261. */
+/* First used: 0 (reserved), Last used: 361. Free: */
static int abortcount = 0;
if (TREE_CODE (objtype) == REFERENCE_TYPE)
objtype = TREE_TYPE (objtype);
+ objtype = TYPE_MAIN_VARIANT (objtype);
if (! IS_AGGR_TYPE (objtype))
{
git://gcc.gnu.org / gcc.git / commitdiff